diff --git a/apps/client/src/app.tsx b/apps/client/src/app.tsx
index da5687c..63f5e75 100644
--- a/apps/client/src/app.tsx
+++ b/apps/client/src/app.tsx
@@ -45,8 +45,8 @@
       <LobbyScene
         room={room}
         myId={myId}
-        onStart={(targetPlayerCount) =>
-          socketManager.lobby.startGame(targetPlayerCount)
+        onStart={(payload) =>
+          socketManager.lobby.startGame(payload)
         }
         onBackToTitle={() => returnToTitle({ leaveRoom: true })}
       />
diff --git a/apps/client/src/config/index.ts b/apps/client/src/config/index.ts
index 3a98026..d131dba 100644
--- a/apps/client/src/config/index.ts
+++ b/apps/client/src/config/index.ts
@@ -1,4 +1,40 @@
 import { config as sharedConfig } from "@repo/shared";
+import type { FieldSizePreset, GameStartPayload } from "@repo/shared";
+
+const runtimeMapSize = {
+  gridCols: sharedConfig.GAME_CONFIG.GRID_COLS,
+  gridRows: sharedConfig.GAME_CONFIG.GRID_ROWS,
+};
+
+/** フィールドサイズ種別からクライアント実行中のマップサイズを更新する */
+export const setRuntimeMapSizeByPreset = (preset: FieldSizePreset): void => {
+  const resolved = sharedConfig.resolveFieldGridSize(preset);
+  runtimeMapSize.gridCols = resolved.cols;
+  runtimeMapSize.gridRows = resolved.rows;
+};
+
+/** GAME_STARTペイロードを優先してクライアント実行中のマップサイズを更新する */
+export const applyRuntimeMapSizeFromGameStart = (
+  payload: Pick<GameStartPayload, "fieldSizePreset" | "gridCols" | "gridRows">,
+): void => {
+  if (
+    Number.isFinite(payload.gridCols)
+    && Number.isFinite(payload.gridRows)
+    && payload.gridCols > 0
+    && payload.gridRows > 0
+  ) {
+    runtimeMapSize.gridCols = payload.gridCols;
+    runtimeMapSize.gridRows = payload.gridRows;
+    return;
+  }
+
+  setRuntimeMapSizeByPreset(payload.fieldSizePreset);
+};
+
+/** クライアント実行中マップサイズを既定値へ戻す */
+export const resetRuntimeMapSizeToDefault = (): void => {
+  setRuntimeMapSizeByPreset(sharedConfig.GAME_CONFIG.DEFAULT_FIELD_PRESET);
+};
 
 const sharedBombRenderScale =
   (sharedConfig.GAME_CONFIG as { BOMB_RENDER_SCALE?: number })
@@ -66,6 +102,12 @@
 const GAME_CONFIG = {
   ...sharedConfig.GAME_CONFIG,
   ...CLIENT_GAME_CONFIG,
+  get GRID_COLS(): number {
+    return runtimeMapSize.gridCols;
+  },
+  get GRID_ROWS(): number {
+    return runtimeMapSize.gridRows;
+  },
   get MAP_WIDTH_PX(): number {
     return this.GRID_COLS * this.GRID_CELL_SIZE;
   },
diff --git a/apps/client/src/hooks/useSocketSubscriptions.ts b/apps/client/src/hooks/useSocketSubscriptions.ts
index 3af4fa3..25b53a7 100644
--- a/apps/client/src/hooks/useSocketSubscriptions.ts
+++ b/apps/client/src/hooks/useSocketSubscriptions.ts
@@ -5,8 +5,12 @@
  */
 import { useEffect } from "react";
 import { socketManager } from "@client/network/SocketManager";
+import {
+  applyRuntimeMapSizeFromGameStart,
+  setRuntimeMapSizeByPreset,
+} from "@client/config";
 import { domain } from "@repo/shared";
-import type { GameResultPayload } from "@repo/shared";
+import type { GameResultPayload, GameStartPayload } from "@repo/shared";
 import type { AppFlowAction } from "./types/appFlowState";
 
 type UseSocketSubscriptionsParams = {
@@ -18,7 +22,7 @@
 type AppSocketHandlers = {
   handleConnect: (id: string) => void;
   handleRoomUpdate: (updatedRoom: domain.room.Room) => void;
-  handleGameStart: () => void;
+  handleGameStart: (payload: GameStartPayload) => void;
   handleGameResult: (payload: GameResultPayload) => void;
 };
 
@@ -76,6 +80,7 @@
 
       handleRoomUpdate: (updatedRoom: domain.room.Room) => {
         completeJoinRequest();
+        setRuntimeMapSizeByPreset(updatedRoom.fieldSizePreset);
         if (
           scenePhase === domain.app.ScenePhase.PLAYING ||
           scenePhase === domain.app.ScenePhase.RESULT
@@ -86,7 +91,8 @@
         }
       },
 
-      handleGameStart: () => {
+      handleGameStart: (payload) => {
+        applyRuntimeMapSizeFromGameStart(payload);
         dispatchAppFlow({ type: "setPlaying" });
       },
 
diff --git a/apps/client/src/network/handlers/LobbyHandler.ts b/apps/client/src/network/handlers/LobbyHandler.ts
index 1b1d70e..00c037b 100644
--- a/apps/client/src/network/handlers/LobbyHandler.ts
+++ b/apps/client/src/network/handlers/LobbyHandler.ts
@@ -5,7 +5,7 @@
  */
 import type { Socket } from "socket.io-client";
 import { contracts as protocol } from "@repo/shared";
-import type { ServerToClientPayloadOf } from "@repo/shared";
+import type { ServerToClientPayloadOf, StartGameRequestPayload } from "@repo/shared";
 import { createClientSocketEventBridge } from "./socketEventBridge";
 
 /** ロビー画面で利用する通信操作の契約 */
@@ -25,7 +25,7 @@
       room: ServerToClientPayloadOf<typeof protocol.SocketEvents.ROOM_UPDATE>,
     ) => void,
   ) => void;
-  startGame: (targetPlayerCount?: number) => void;
+  startGame: (payload?: StartGameRequestPayload) => void;
 };
 
 /** ロビー画面向けのソケットハンドラを生成する */
@@ -43,10 +43,8 @@
     offRoomUpdate: (callback) => {
       offEvent(protocol.SocketEvents.ROOM_UPDATE, callback);
     },
-    startGame: (targetPlayerCount) => {
-      emitEvent(protocol.SocketEvents.START_GAME, {
-        targetPlayerCount,
-      });
+    startGame: (payload) => {
+      emitEvent(protocol.SocketEvents.START_GAME, payload ?? {});
     },
   };
 };
diff --git a/apps/client/src/scenes/game/application/loopSteps/SimulationStep.ts b/apps/client/src/scenes/game/application/loopSteps/SimulationStep.ts
index 0f4759e..2aef873 100644
--- a/apps/client/src/scenes/game/application/loopSteps/SimulationStep.ts
+++ b/apps/client/src/scenes/game/application/loopSteps/SimulationStep.ts
@@ -63,7 +63,10 @@
       me.tick();
 
       const now = this.nowMsProvider();
-      if (now - this.lastPositionSentTime >= config.GAME_CONFIG.PLAYER_POSITION_UPDATE_MS) {
+      if (
+        now - this.lastPositionSentTime
+        >= config.GAME_CONFIG.NETWORK_SYNC.PLAYER_POSITION_UPDATE_MS
+      ) {
         const position = me.getPosition();
         this.moveSender.sendMove(position.x, position.y);
         this.lastPositionSentTime = now;
@@ -71,7 +74,7 @@
     } else if (this.wasMoving) {
       me.tick();
       const position = me.getPosition();
-      this.moveSender.sendMove(position.x, position.y);
+      this.moveSender.sendMove(position.x, position.y, { force: true });
     } else {
       me.tick();
     }
diff --git a/apps/client/src/scenes/game/application/network/PlayerMoveSender.ts b/apps/client/src/scenes/game/application/network/PlayerMoveSender.ts
index 9efa0c6..64fee02 100644
--- a/apps/client/src/scenes/game/application/network/PlayerMoveSender.ts
+++ b/apps/client/src/scenes/game/application/network/PlayerMoveSender.ts
@@ -3,17 +3,38 @@
  * ローカルプレイヤー移動の送信責務を提供する
  * シミュレーション層から通信実装を分離する
  */
+import { domain } from "@repo/shared";
 import { socketManager } from "@client/network/SocketManager";
 
+/** 移動送信時の動作オプション */
+export type SendMoveOptions = {
+  force?: boolean;
+};
+
 /** 移動送信のインターフェース型 */
 export type MoveSender = {
-  sendMove: (x: number, y: number) => void;
+  sendMove: (x: number, y: number, options?: SendMoveOptions) => void;
 };
 
 /** ソケット経由で移動送信を行う実装 */
 export class SocketPlayerMoveSender implements MoveSender {
+  private lastSentPosition: domain.game.player.MovePayload | null = null;
+
   /** 指定座標をサーバーへ送信する */
-  public sendMove(x: number, y: number): void {
-    socketManager.game.sendMove(x, y);
+  public sendMove(x: number, y: number, options?: SendMoveOptions): void {
+    const quantizedPosition = domain.game.player.quantizeMovePayload({ x, y });
+    const lastPosition = this.lastSentPosition;
+
+    if (
+      !options?.force
+      &&
+      lastPosition
+      && domain.game.player.isSameMovePayload(lastPosition, quantizedPosition)
+    ) {
+      return;
+    }
+
+    this.lastSentPosition = quantizedPosition;
+    socketManager.game.sendMove(quantizedPosition.x, quantizedPosition.y);
   }
 }
\ No newline at end of file
diff --git a/apps/client/src/scenes/game/entities/hurricane/HurricaneOverlayController.ts b/apps/client/src/scenes/game/entities/hurricane/HurricaneOverlayController.ts
index cc68f75..887ea68 100644
--- a/apps/client/src/scenes/game/entities/hurricane/HurricaneOverlayController.ts
+++ b/apps/client/src/scenes/game/entities/hurricane/HurricaneOverlayController.ts
@@ -28,11 +28,7 @@
 
   /** ハリケーン状態を描画へ同期する */
   public applyUpdates(states: UpdateHurricanesPayload): void {
-    const activeIds = new Set<string>();
-
     states.forEach((state) => {
-      activeIds.add(state.id);
-
       let target = this.displayById.get(state.id);
       if (!target) {
         const created = this.createDisplay();
@@ -50,16 +46,6 @@
       target.container.y = state.y * config.GAME_CONFIG.GRID_CELL_SIZE;
       target.container.rotation = state.rotationRad;
     });
-
-    this.displayById.forEach((display, id) => {
-      if (activeIds.has(id)) {
-        return;
-      }
-
-      this.layer.removeChild(display.container);
-      display.container.destroy({ children: true });
-      this.displayById.delete(id);
-    });
   }
 
   /** 描画リソースを破棄する */
diff --git a/apps/client/src/scenes/game/hooks/useGameSceneController.ts b/apps/client/src/scenes/game/hooks/useGameSceneController.ts
index aabba96..9d57079 100644
--- a/apps/client/src/scenes/game/hooks/useGameSceneController.ts
+++ b/apps/client/src/scenes/game/hooks/useGameSceneController.ts
@@ -19,9 +19,12 @@
 const DEFAULT_TEAM_PAINT_RATES = new Array<number>(
   config.GAME_CONFIG.TEAM_COUNT,
 ).fill(0);
-const DEFAULT_MINIMAP_TEAM_IDS = new Array<number>(
-  config.GAME_CONFIG.GRID_COLS * config.GAME_CONFIG.GRID_ROWS,
-).fill(-1);
+
+const createDefaultMiniMapTeamIds = (): number[] => {
+  return new Array<number>(
+    config.GAME_CONFIG.GRID_COLS * config.GAME_CONFIG.GRID_ROWS,
+  ).fill(-1);
+};
 
 type SceneControllerState = {
   timeLeft: string;
@@ -38,14 +41,16 @@
   | { type: "syncMiniMap"; payload: MiniMapState }
   | { type: "reset" };
 
-const INITIAL_SCENE_CONTROLLER_STATE: SceneControllerState = {
-  timeLeft: getInitialTimeDisplay(),
-  startCountdownText: null,
-  isInputEnabled: false,
-  teamPaintRates: DEFAULT_TEAM_PAINT_RATES,
-  miniMapTeamIds: DEFAULT_MINIMAP_TEAM_IDS,
-  localBombHitCount: 0,
-  localPlayerPosition: null,
+const createInitialSceneControllerState = (): SceneControllerState => {
+  return {
+    timeLeft: getInitialTimeDisplay(),
+    startCountdownText: null,
+    isInputEnabled: false,
+    teamPaintRates: DEFAULT_TEAM_PAINT_RATES,
+    miniMapTeamIds: createDefaultMiniMapTeamIds(),
+    localBombHitCount: 0,
+    localPlayerPosition: null,
+  };
 };
 
 const sceneControllerReducer = (
@@ -73,7 +78,7 @@
       };
     }
     case "reset": {
-      return INITIAL_SCENE_CONTROLLER_STATE;
+      return createInitialSceneControllerState();
     }
     default: {
       return state;
@@ -87,7 +92,7 @@
   const gameManagerRef = useRef<GameManager | null>(null);
   const [state, dispatch] = useReducer(
     sceneControllerReducer,
-    INITIAL_SCENE_CONTROLLER_STATE,
+    createInitialSceneControllerState(),
   );
 
   useEffect(() => {
diff --git a/apps/client/src/scenes/lobby/LobbyScene.tsx b/apps/client/src/scenes/lobby/LobbyScene.tsx
index af8cc78..ae26629 100644
--- a/apps/client/src/scenes/lobby/LobbyScene.tsx
+++ b/apps/client/src/scenes/lobby/LobbyScene.tsx
@@ -1,12 +1,14 @@
 import { useEffect, useMemo, useState } from "react";
 import { domain } from "@repo/shared";
+import type { FieldSizePreset, StartGameRequestPayload } from "@repo/shared";
+import { config } from "@client/config";
 import { OVERLAY_BUTTON_STYLE } from "@client/scenes/shared/styles/overlayStyles";
 import { LobbyRuleModal } from "./components/LobbyRuleModal";
 
 type Props = {
   room: domain.room.Room | null;
   myId: string | null;
-  onStart: (targetPlayerCount: number) => void;
+  onStart: (payload: StartGameRequestPayload) => void;
   onBackToTitle: () => void;
 };
 
@@ -46,6 +48,13 @@
   const [selectedStartPlayerCount, setSelectedStartPlayerCount] = useState(
     minimumStartPlayerCount,
   );
+  const fieldPresetOptions = useMemo(() => {
+    return Object.keys(
+      config.GAME_CONFIG.FIELD_PRESETS,
+    ) as FieldSizePreset[];
+  }, []);
+  const [selectedFieldSizePreset, setSelectedFieldSizePreset] =
+    useState<FieldSizePreset>(config.GAME_CONFIG.DEFAULT_FIELD_PRESET);
   const [isRuleModalOpen, setIsRuleModalOpen] = useState(false);
 
   useEffect(() => {
@@ -63,7 +72,24 @@
   }, [minimumStartPlayerCount, maxStartPlayerCount]);
 
   const handleStart = () => {
-    onStart(selectedStartPlayerCount);
+    onStart({
+      targetPlayerCount: selectedStartPlayerCount,
+      fieldSizePreset: selectedFieldSizePreset,
+    });
+  };
+
+  const toFieldPresetLabel = (preset: FieldSizePreset): string => {
+    const range = config.GAME_CONFIG.FIELD_PRESETS[preset].recommendedPlayers;
+    const baseLabel =
+      preset === "SMALL"
+        ? "小"
+        : preset === "MEDIUM"
+          ? "中"
+          : preset === "LARGE"
+            ? "大"
+            : "極大";
+
+    return `${baseLabel} (${range.min}-${range.max}人目安)`;
   };
 
   return (
@@ -226,6 +252,40 @@
                     ))}
                   </select>
 
+                  <label
+                    htmlFor="field-size-preset"
+                    style={{
+                      fontSize: "0.95rem",
+                      fontWeight: 700,
+                      textShadow: "1px 1px 2px rgba(0,0,0,0.7)",
+                    }}
+                  >
+                    フィールドサイズ
+                  </label>
+                  <select
+                    id="field-size-preset"
+                    value={selectedFieldSizePreset}
+                    onChange={(event) => {
+                      setSelectedFieldSizePreset(event.target.value as FieldSizePreset);
+                    }}
+                    style={{
+                      width: "100%",
+                      padding: "10px 12px",
+                      borderRadius: "8px",
+                      border: "1px solid rgba(255,255,255,0.4)",
+                      background: "rgba(0,0,0,0.55)",
+                      color: "white",
+                      fontSize: "1rem",
+                      fontWeight: 700,
+                    }}
+                  >
+                    {fieldPresetOptions.map((preset) => (
+                      <option key={preset} value={preset}>
+                        {toFieldPresetLabel(preset)}
+                      </option>
+                    ))}
+                  </select>
+
                   <button
                     onClick={handleStart}
                     style={{
diff --git a/apps/server/src/application/coordinators/startGameCoordinator.ts b/apps/server/src/application/coordinators/startGameCoordinator.ts
index 1d09b4a..f974987 100644
--- a/apps/server/src/application/coordinators/startGameCoordinator.ts
+++ b/apps/server/src/application/coordinators/startGameCoordinator.ts
@@ -3,6 +3,9 @@
  * START_GAMEイベントの調停を行い，ルーム状態更新とゲーム開始処理を橋渡しする
  */
 import { type StartGameOutputPort } from "@server/domains/game/application/ports/gameUseCasePorts";
+import type { FieldSizePreset } from "@repo/shared";
+import { config } from "@server/config";
+import { config as sharedConfig } from "@repo/shared";
 import type { StartGameCoordinatorDeps } from "./coordinatorDeps";
 import { startGameUseCase } from "@server/domains/game/application/useCases/startGameUseCase";
 import {
@@ -19,6 +22,7 @@
 type StartGameCoordinatorParams = {
   ownerId: string;
   requestedPlayerCount?: number;
+  requestedFieldSizePreset?: FieldSizePreset;
 } & StartGameCoordinatorDeps & {
     output: StartGameOutputPort;
   };
@@ -27,6 +31,7 @@
 export const startGameCoordinator = ({
   ownerId,
   requestedPlayerCount,
+  requestedFieldSizePreset,
   roomManager,
   runtimeRegistry,
   output,
@@ -67,12 +72,22 @@
     return;
   }
 
+  const resolvedFieldSizePreset: FieldSizePreset =
+    requestedFieldSizePreset
+    ?? updatedRoom.fieldSizePreset
+    ?? config.GAME_CONFIG.DEFAULT_FIELD_PRESET;
+  const resolvedGridSize = sharedConfig.resolveFieldGridSize(
+    resolvedFieldSizePreset,
+  );
+  updatedRoom.fieldSizePreset = resolvedFieldSizePreset;
+
   logEvent(logScopes.GAME_USE_CASE, {
     event: gameUseCaseLogEvents.START_GAME,
     result: logResults.ACCEPTED,
     roomId: updatedRoom.roomId,
     socketId: ownerId,
     totalPlayers: updatedRoom.players.length,
+    fieldSizePreset: resolvedFieldSizePreset,
   });
 
   const humanPlayerIds = updatedRoom.players.map((player) => player.id);
@@ -100,6 +115,11 @@
 
   startGameUseCase({
     roomId: updatedRoom.roomId,
+    fieldConfig: {
+      fieldSizePreset: resolvedFieldSizePreset,
+      gridCols: resolvedGridSize.cols,
+      gridRows: resolvedGridSize.rows,
+    },
     playerIds: sessionPlayerIds,
     playerNamesById,
     gameSession: gameManager,
diff --git a/apps/server/src/common/syncDelta.ts b/apps/server/src/common/syncDelta.ts
new file mode 100644
index 0000000..545bd64
--- /dev/null
+++ b/apps/server/src/common/syncDelta.ts
@@ -0,0 +1,44 @@
+/**
+ * syncDelta
+ * ID単位の前回同期スナップショットと比較して差分抽出する共通関数を提供する
+ */
+
+/** ID単位で抽出した差分1件の構造 */
+export type SyncDeltaEntry<TItem, TSnapshot> = {
+  item: TItem;
+  snapshot: TSnapshot;
+};
+
+/** 差分抽出時に必要な比較ルール */
+export type SyncDeltaOptions<TItem, TSnapshot> = {
+  selectId: (item: TItem) => string;
+  toSnapshot: (item: TItem) => TSnapshot;
+  isSameSnapshot: (left: TSnapshot, right: TSnapshot) => boolean;
+};
+
+/** ID別の前回同期状態を参照して差分のみ抽出する */
+export const collectSyncDeltaEntries = <TItem, TSnapshot>(
+  items: TItem[],
+  lastSnapshotById: Map<string, TSnapshot>,
+  options: SyncDeltaOptions<TItem, TSnapshot>,
+): SyncDeltaEntry<TItem, TSnapshot>[] => {
+  const changedEntries: SyncDeltaEntry<TItem, TSnapshot>[] = [];
+
+  items.forEach((item) => {
+    const id = options.selectId(item);
+    const nextSnapshot = options.toSnapshot(item);
+    const lastSnapshot = lastSnapshotById.get(id);
+
+    if (lastSnapshot && options.isSameSnapshot(lastSnapshot, nextSnapshot)) {
+      return;
+    }
+
+    lastSnapshotById.set(id, nextSnapshot);
+    changedEntries.push({
+      item,
+      snapshot: nextSnapshot,
+    });
+  });
+
+  return changedEntries;
+};
diff --git a/apps/server/src/domains/game/GameManager.ts b/apps/server/src/domains/game/GameManager.ts
index c6aa198..1061248 100644
--- a/apps/server/src/domains/game/GameManager.ts
+++ b/apps/server/src/domains/game/GameManager.ts
@@ -10,6 +10,7 @@
 import { GameRoomSession } from "./application/services/GameRoomSession";
 import type { GameSessionCallbacks } from "./application/services/GameRoomSession";
 import type { ActiveBombRegistration } from "./application/ports/gameUseCasePorts";
+import type { GameFieldConfig } from "./application/ports/gameUseCasePorts";
 import { GameSessionLifecycleService } from "./application/services/GameSessionLifecycleService";
 import { GamePlayerOperationService } from "./application/services/GamePlayerOperationService";
 
@@ -44,6 +45,10 @@
     return this.lifecycleService.getRoomStartTime();
   }
 
+  getRoomFieldConfig(): GameFieldConfig | undefined {
+    return this.lifecycleService.getRoomFieldConfig();
+  }
+
   // プレイヤー登録解除処理
   removePlayer(id: string) {
     this.playerOperationService.removePlayer(id);
@@ -67,11 +72,13 @@
   startRoomSession(
     playerIds: string[],
     playerNamesById: Record<string, string>,
+    fieldConfig: GameFieldConfig,
     callbacks: GameSessionCallbacks,
   ) {
     this.lifecycleService.startRoomSession(
       playerIds,
       playerNamesById,
+      fieldConfig,
       callbacks,
     );
   }
diff --git a/apps/server/src/domains/game/application/ports/gameUseCasePorts.ts b/apps/server/src/domains/game/application/ports/gameUseCasePorts.ts
index e23c295..0ff7535 100644
--- a/apps/server/src/domains/game/application/ports/gameUseCasePorts.ts
+++ b/apps/server/src/domains/game/application/ports/gameUseCasePorts.ts
@@ -17,23 +17,34 @@
   PongPayload,
   RemovePlayerPayload,
   UpdatePlayersPayload,
+  FieldSizePreset,
 } from "@repo/shared";
 import type { GameSessionCallbacks } from "../services/GameRoomSession";
 
+/** ゲーム開始時に固定するフィールド設定情報 */
+export type GameFieldConfig = {
+  fieldSizePreset: FieldSizePreset;
+  gridCols: number;
+  gridRows: number;
+};
+
 /** ゲーム開始ユースケースが利用するゲーム管理入力ポート */
 export interface StartGamePort {
   startRoomSession(
     playerIds: string[],
     playerNamesById: Record<string, string>,
+    fieldConfig: GameFieldConfig,
     callbacks: GameSessionCallbacks,
   ): void;
   getRoomStartTime(): number | undefined;
+  getRoomFieldConfig(): GameFieldConfig | undefined;
 }
 
 /** 準備完了ユースケースが利用するゲーム状態参照入力ポート */
 export interface ReadyForGamePort {
   getRoomPlayers(): domain.game.player.PlayerData[];
   getRoomStartTime(): number | undefined;
+  getRoomFieldConfig(): GameFieldConfig | undefined;
 }
 
 /** 移動入力ユースケースが利用するプレイヤー操作入力ポート */
diff --git a/apps/server/src/domains/game/application/services/GameRoomSession.ts b/apps/server/src/domains/game/application/services/GameRoomSession.ts
index dd009b1..1958875 100644
--- a/apps/server/src/domains/game/application/services/GameRoomSession.ts
+++ b/apps/server/src/domains/game/application/services/GameRoomSession.ts
@@ -22,6 +22,7 @@
 } from "../../entities/player/playerMovement.js";
 import { buildGameResultPayload } from "./gameResultCalculator.js";
 import { TeamAssignmentService } from "../services/TeamAssignmentService.js";
+import type { GameFieldConfig } from "../ports/gameUseCasePorts";
 
 /** GameRoomSession のコールバック集合 */
 export type GameSessionCallbacks = {
@@ -40,15 +41,21 @@
   private gameLoop: GameLoop | null = null;
   private startTime: number | undefined;
   private startDelayTimer: NodeJS.Timeout | null = null;
+  private fieldConfig: GameFieldConfig;
 
   constructor(
     private roomId: string,
     playerIds: string[],
     playerNamesById: Record<string, string>,
+    fieldConfig: GameFieldConfig,
   ) {
     this.players = new Map();
-    this.mapStore = new MapStore();
+    this.mapStore = new MapStore({
+      gridCols: fieldConfig.gridCols,
+      gridRows: fieldConfig.gridRows,
+    });
     this.bombStateStore = new BombStateStore();
+    this.fieldConfig = fieldConfig;
 
     playerIds.forEach((playerId) => {
       // 現在のプレイヤー構成から人数が最も少ないチームを算出する
@@ -58,7 +65,15 @@
 
       // 算出したチームIDを指定してプレイヤーを生成する
       const playerName = playerNamesById[playerId] ?? playerId;
-      const player = createSpawnedPlayer(playerId, playerName, assignedTeamId);
+      const player = createSpawnedPlayer(
+        playerId,
+        playerName,
+        assignedTeamId,
+        {
+          gridCols: fieldConfig.gridCols,
+          gridRows: fieldConfig.gridRows,
+        },
+      );
 
       this.players.set(playerId, player);
     });
@@ -95,6 +110,8 @@
     this.gameLoop = new GameLoop({
       roomId: this.roomId,
       tickRate,
+      gridCols: this.fieldConfig.gridCols,
+      gridRows: this.fieldConfig.gridRows,
       players: this.players,
       mapStore: this.mapStore,
       activeBombRegistry: this.bombStateStore.activeBombRegistry,
@@ -166,6 +183,11 @@
     return this.startTime;
   }
 
+  /** 現在セッションで確定したフィールド設定を返す */
+  public getFieldConfig(): GameFieldConfig {
+    return this.fieldConfig;
+  }
+
   public getPlayers(): Player[] {
     return Array.from(this.players.values());
   }
diff --git a/apps/server/src/domains/game/application/services/GameSessionLifecycleService.ts b/apps/server/src/domains/game/application/services/GameSessionLifecycleService.ts
index f6e826c..dbbc2f2 100644
--- a/apps/server/src/domains/game/application/services/GameSessionLifecycleService.ts
+++ b/apps/server/src/domains/game/application/services/GameSessionLifecycleService.ts
@@ -3,7 +3,10 @@
  * ゲームセッションの開始，参照，終了時クリーンアップを管理する
  */
 import { config } from "@server/config";
-import type { ActiveBombRegistration } from "../ports/gameUseCasePorts";
+import type {
+  ActiveBombRegistration,
+  GameFieldConfig,
+} from "../ports/gameUseCasePorts";
 import type {
   domain,
   GameResultPayload,
@@ -35,6 +38,10 @@
     return this.sessionRef.current?.getPlayers() ?? [];
   }
 
+  public getRoomFieldConfig(): GameFieldConfig | undefined {
+    return this.sessionRef.current?.getFieldConfig();
+  }
+
   public shouldBroadcastBombPlaced(dedupeKey: string, nowMs: number): boolean {
     return (
       this.sessionRef.current?.shouldBroadcastBombPlaced(dedupeKey, nowMs) ??
@@ -74,6 +81,7 @@
   public startRoomSession(
     playerIds: string[],
     playerNamesById: Record<string, string>,
+    fieldConfig: GameFieldConfig,
     callbacks: GameSessionCallbacks,
   ) {
     if (this.sessionRef.current) {
@@ -85,11 +93,12 @@
       return;
     }
 
-    const tickRate = config.GAME_CONFIG.PLAYER_POSITION_UPDATE_MS;
+    const tickRate = config.GAME_CONFIG.NETWORK_SYNC.PLAYER_POSITION_UPDATE_MS;
     const session = new GameRoomSession(
       this.roomId,
       playerIds,
       playerNamesById,
+      fieldConfig,
     );
 
     this.activePlayerIds.clear();
diff --git a/apps/server/src/domains/game/application/services/bot/movement/MovePlanner.ts b/apps/server/src/domains/game/application/services/bot/movement/MovePlanner.ts
index 49d8cdb..915be6e 100644
--- a/apps/server/src/domains/game/application/services/bot/movement/MovePlanner.ts
+++ b/apps/server/src/domains/game/application/services/bot/movement/MovePlanner.ts
@@ -4,6 +4,11 @@
  */
 import { config } from "@server/config";
 
+type MapGridSize = {
+  gridCols: number;
+  gridRows: number;
+};
+
 const clamp = (value: number, min: number, max: number): number => {
   return Math.max(min, Math.min(max, value));
 };
@@ -14,6 +19,7 @@
   y: number,
   targetCol: number,
   targetRow: number,
+  size: MapGridSize,
 ): { nextX: number; nextY: number } => {
   const targetX = targetCol + 0.5;
   const targetY = targetRow + 0.5;
@@ -35,7 +41,7 @@
   const nextY = y + diffY * ratio;
 
   return {
-    nextX: clamp(nextX, 0, config.GAME_CONFIG.GRID_COLS - 0.001),
-    nextY: clamp(nextY, 0, config.GAME_CONFIG.GRID_ROWS - 0.001),
+    nextX: clamp(nextX, 0, size.gridCols - 0.001),
+    nextY: clamp(nextY, 0, size.gridRows - 0.001),
   };
 };
diff --git a/apps/server/src/domains/game/application/services/bot/orchestrators/BotTurnOrchestrator.ts b/apps/server/src/domains/game/application/services/bot/orchestrators/BotTurnOrchestrator.ts
index 470c413..9550ec8 100644
--- a/apps/server/src/domains/game/application/services/bot/orchestrators/BotTurnOrchestrator.ts
+++ b/apps/server/src/domains/game/application/services/bot/orchestrators/BotTurnOrchestrator.ts
@@ -12,18 +12,28 @@
 import { BotStateStore } from "../state/BotStateStore.js";
 import type { BotDecision } from "../types/BotTypes.js";
 
+type MapGridSize = {
+  gridCols: number;
+  gridRows: number;
+};
+
 const clamp = (value: number, min: number, max: number): number => {
   return Math.max(min, Math.min(max, value));
 };
 
 /** Botの1tick分の意思決定を提供するオーケストレータ */
 export class BotTurnOrchestrator {
+  private readonly mapSize: MapGridSize;
   private stateStore = new BotStateStore();
   private readonly hitStunPolicy = new BotHitStunPolicy({
     hitStunMs: config.GAME_CONFIG.PLAYER_HIT_STUN_MS,
   });
   private readonly respawnAtMsByBotId = new Map<BotPlayerId, number>();
 
+  constructor(mapSize: MapGridSize) {
+    this.mapSize = mapSize;
+  }
+
   public decide(
     botPlayerId: BotPlayerId,
     player: Player,
@@ -31,9 +41,8 @@
     nowMs: number,
     elapsedMs: number,
   ): BotDecision {
-    const { GRID_COLS, GRID_ROWS } = config.GAME_CONFIG;
-    const currentCol = clamp(Math.floor(player.x), 0, GRID_COLS - 1);
-    const currentRow = clamp(Math.floor(player.y), 0, GRID_ROWS - 1);
+    const currentCol = clamp(Math.floor(player.x), 0, this.mapSize.gridCols - 1);
+    const currentRow = clamp(Math.floor(player.y), 0, this.mapSize.gridRows - 1);
 
     const currentState = this.stateStore.getOrCreate(botPlayerId, {
       targetCol: currentCol,
@@ -49,8 +58,8 @@
       this.respawnAtMsByBotId.delete(botPlayerId);
       this.stateStore.update(botPlayerId, (state) => ({
         ...state,
-        targetCol: clamp(Math.floor(player.initialX), 0, GRID_COLS - 1),
-        targetRow: clamp(Math.floor(player.initialY), 0, GRID_ROWS - 1),
+        targetCol: clamp(Math.floor(player.initialX), 0, this.mapSize.gridCols - 1),
+        targetRow: clamp(Math.floor(player.initialY), 0, this.mapSize.gridRows - 1),
       }));
       return {
         nextX: player.initialX,
@@ -78,7 +87,7 @@
       config.BOT_AI_CONFIG.TARGET_REACHED_EPSILON;
 
     const nextTarget = reachedTarget
-      ? chooseNextTarget(currentCol, currentRow, gridColors)
+      ? chooseNextTarget(currentCol, currentRow, gridColors, this.mapSize)
       : { col: currentState.targetCol, row: currentState.targetRow };
 
     const moved = moveTowardsTarget(
@@ -86,6 +95,7 @@
       player.y,
       nextTarget.col,
       nextTarget.row,
+      this.mapSize,
     );
 
     const bombDecision = decideBombPlacement(
diff --git a/apps/server/src/domains/game/application/services/bot/policies/TargetSelectionPolicy.ts b/apps/server/src/domains/game/application/services/bot/policies/TargetSelectionPolicy.ts
index 1024753..06788e5 100644
--- a/apps/server/src/domains/game/application/services/bot/policies/TargetSelectionPolicy.ts
+++ b/apps/server/src/domains/game/application/services/bot/policies/TargetSelectionPolicy.ts
@@ -5,6 +5,11 @@
 import { config } from "@server/config";
 import type { BotTarget } from "../types/BotTypes.js";
 
+type MapGridSize = {
+  gridCols: number;
+  gridRows: number;
+};
+
 const UNPAINTED_TEAM_ID = -1;
 
 const clamp = (value: number, min: number, max: number): number => {
@@ -29,9 +34,10 @@
   col: number,
   row: number,
   gridColors: number[],
+  size: MapGridSize,
 ): BotTarget => {
   const { UNPAINTED_PRIORITY_STRENGTH } = config.BOT_AI_CONFIG;
-  const { GRID_COLS, GRID_ROWS } = config.GAME_CONFIG;
+  const { gridCols, gridRows } = size;
   const candidates = [
     { col: col + 1, row },
     { col: col - 1, row },
@@ -40,9 +46,9 @@
   ].filter((candidate) => {
     return (
       candidate.col >= 0 &&
-      candidate.col < GRID_COLS &&
+      candidate.col < gridCols &&
       candidate.row >= 0 &&
-      candidate.row < GRID_ROWS
+      candidate.row < gridRows
     );
   });
 
@@ -52,7 +58,7 @@
 
   const unpaintedCandidates = candidates.filter((candidate) => {
     return (
-      getCellTeamId(gridColors, candidate.col, candidate.row, GRID_COLS) ===
+      getCellTeamId(gridColors, candidate.col, candidate.row, gridCols) ===
       UNPAINTED_TEAM_ID
     );
   });
diff --git a/apps/server/src/domains/game/application/useCases/readyForGameUseCase.ts b/apps/server/src/domains/game/application/useCases/readyForGameUseCase.ts
index f61ceda..1cb24f0 100644
--- a/apps/server/src/domains/game/application/useCases/readyForGameUseCase.ts
+++ b/apps/server/src/domains/game/application/useCases/readyForGameUseCase.ts
@@ -4,7 +4,9 @@
  */
 import type { ReadyForGamePort } from "../ports/gameUseCasePorts";
 import type { GameOutputPort } from "../ports/gameUseCasePorts";
+import { config } from "@server/config";
 import { logEvent } from "@server/logging/logger";
+import { config as sharedConfig } from "@repo/shared";
 import { gameUseCaseLogEvents, logResults, logScopes } from "@server/logging/index";
 
 type ReadyForGameUseCaseParams = {
@@ -47,7 +49,24 @@
     return;
   }
 
-  output.publishGameStartToSocket({ startTime, serverNow: Date.now() });
+  const fieldConfig = gameManager.getRoomFieldConfig();
+
+  output.publishGameStartToSocket({
+    startTime,
+    serverNow: Date.now(),
+    fieldSizePreset:
+      fieldConfig?.fieldSizePreset ?? config.GAME_CONFIG.DEFAULT_FIELD_PRESET,
+    gridCols:
+      fieldConfig?.gridCols
+      ?? sharedConfig.resolveFieldGridSize(
+        config.GAME_CONFIG.DEFAULT_FIELD_PRESET,
+      ).cols,
+    gridRows:
+      fieldConfig?.gridRows
+      ?? sharedConfig.resolveFieldGridSize(
+        config.GAME_CONFIG.DEFAULT_FIELD_PRESET,
+      ).rows,
+  });
   logEvent(logScopes.GAME_USE_CASE, {
     event: gameUseCaseLogEvents.GAME_START,
     result: logResults.EMITTED,
diff --git a/apps/server/src/domains/game/application/useCases/startGameUseCase.ts b/apps/server/src/domains/game/application/useCases/startGameUseCase.ts
index 0163655..5301633 100644
--- a/apps/server/src/domains/game/application/useCases/startGameUseCase.ts
+++ b/apps/server/src/domains/game/application/useCases/startGameUseCase.ts
@@ -4,6 +4,7 @@
  */
 import type {
   BombPlacementPort,
+  GameFieldConfig,
   StartGameOutputPort,
   StartGamePort,
 } from "../ports/gameUseCasePorts";
@@ -17,6 +18,7 @@
 
 type StartGameUseCaseParams = {
   roomId: string;
+  fieldConfig: GameFieldConfig;
   playerIds: string[];
   playerNamesById: Record<string, string>;
   gameSession: StartGamePort;
@@ -25,9 +27,38 @@
   output: StartGameOutputPort;
 };
 
+type TickUpdatePublishParams = {
+  roomId: string;
+  output: StartGameOutputPort;
+  tickData: Parameters<StartGamePort["startRoomSession"]>[3] extends {
+    onTick: (data: infer TTickData) => void;
+  }
+    ? TTickData
+    : never;
+};
+
+const publishTickUpdates = ({
+  roomId,
+  output,
+  tickData,
+}: TickUpdatePublishParams): void => {
+  if (tickData.playerUpdates.length > 0) {
+    output.publishUpdatePlayersToRoom(roomId, tickData.playerUpdates);
+  }
+
+  if (tickData.cellUpdates.length > 0) {
+    output.publishMapCellUpdatesToRoom(roomId, tickData.cellUpdates);
+  }
+
+  if (tickData.hurricaneUpdates.length > 0) {
+    output.publishUpdateHurricanesToRoom(roomId, tickData.hurricaneUpdates);
+  }
+};
+
 /** ゲームセッション開始とティック通知，終了通知を実行する */
 export const startGameUseCase = ({
   roomId,
+  fieldConfig,
   playerIds,
   playerNamesById,
   gameSession,
@@ -48,38 +79,44 @@
     });
   };
 
-  gameSession.startRoomSession(playerIds, playerNamesById, {
-    onTick: (tickData) => {
-      if (tickData.playerUpdates.length > 0) {
-        output.publishUpdatePlayersToRoom(roomId, tickData.playerUpdates);
-      }
-
-      if (tickData.cellUpdates.length > 0) {
-        output.publishMapCellUpdatesToRoom(roomId, tickData.cellUpdates);
-      }
-
-      output.publishUpdateHurricanesToRoom(roomId, tickData.hurricaneUpdates);
+  gameSession.startRoomSession(
+    playerIds,
+    playerNamesById,
+    {
+      ...fieldConfig,
     },
-    onGameEnd: (resultPayload) => {
-      logEvent(logScopes.GAME_USE_CASE, {
-        event: gameUseCaseLogEvents.GAME_END,
-        result: logResults.EMITTED,
-        roomId,
-        reason: "duration_elapsed",
-      });
-      output.publishGameEndToRoom(roomId);
-      output.publishGameResultToRoom(roomId, resultPayload);
-      onGameEnd();
+    {
+      onTick: (tickData) => {
+        publishTickUpdates({ roomId, output, tickData });
+      },
+      onGameEnd: (resultPayload) => {
+        logEvent(logScopes.GAME_USE_CASE, {
+          event: gameUseCaseLogEvents.GAME_END,
+          result: logResults.EMITTED,
+          roomId,
+          reason: "duration_elapsed",
+        });
+        output.publishGameEndToRoom(roomId);
+        output.publishGameResultToRoom(roomId, resultPayload);
+        onGameEnd();
+      },
+      onBotPlaceBomb: handleBotBombAction,
+      onBotBombHit: handleBotBombHit,
+      onHurricanePlayerHit: (targetPlayerId) => {
+        output.publishHurricaneHitToRoom(roomId, {
+          playerId: targetPlayerId,
+        });
+      },
     },
-    onBotPlaceBomb: handleBotBombAction,
-    onBotBombHit: handleBotBombHit,
-    onHurricanePlayerHit: (targetPlayerId) => {
-      output.publishHurricaneHitToRoom(roomId, {
-        playerId: targetPlayerId,
-      });
-    },
-  });
+  );
 
   const startTime = gameSession.getRoomStartTime() || Date.now();
-  output.publishGameStartToRoom(roomId, { startTime, serverNow: Date.now() });
+  const sessionFieldConfig = gameSession.getRoomFieldConfig() ?? fieldConfig;
+  output.publishGameStartToRoom(roomId, {
+    startTime,
+    serverNow: Date.now(),
+    fieldSizePreset: sessionFieldConfig.fieldSizePreset,
+    gridCols: sessionFieldConfig.gridCols,
+    gridRows: sessionFieldConfig.gridRows,
+  });
 };
diff --git a/apps/server/src/domains/game/entities/map/MapStore.ts b/apps/server/src/domains/game/entities/map/MapStore.ts
index ec06150..6742b1c 100644
--- a/apps/server/src/domains/game/entities/map/MapStore.ts
+++ b/apps/server/src/domains/game/entities/map/MapStore.ts
@@ -6,6 +6,11 @@
 import { createInitialGridColors } from "./mapGrid.js";
 import { paintCellIfChanged } from "./mapPainting.js";
 
+type MapGridSize = {
+  gridCols: number;
+  gridRows: number;
+};
+
 /** ルーム内マップの塗り状態と更新差分を管理するストア */
 export class MapStore {
   // 全マスの現在の色（teamId）を保持
@@ -13,9 +18,9 @@
   // 次回の送信ループで送る差分リスト
   private pendingUpdates: domain.game.gridMap.CellUpdate[];
 
-  constructor() {
+  constructor(size?: MapGridSize) {
     // 初期状態は -1 (無色) などで初期化
-    this.gridColors = createInitialGridColors();
+    this.gridColors = createInitialGridColors(size);
     this.pendingUpdates = [];
   }
 
diff --git a/apps/server/src/domains/game/entities/map/mapGrid.ts b/apps/server/src/domains/game/entities/map/mapGrid.ts
index 9cae240..1de2039 100644
--- a/apps/server/src/domains/game/entities/map/mapGrid.ts
+++ b/apps/server/src/domains/game/entities/map/mapGrid.ts
@@ -4,8 +4,15 @@
  */
 import { config } from "@server/config";
 
+type MapGridSize = {
+  gridCols: number;
+  gridRows: number;
+};
+
 /** マップ全セルを未塗り状態で初期化した配列を返す */
-export const createInitialGridColors = (): number[] => {
-  const totalCells = config.GAME_CONFIG.GRID_COLS * config.GAME_CONFIG.GRID_ROWS;
+export const createInitialGridColors = (size?: MapGridSize): number[] => {
+  const gridCols = size?.gridCols ?? config.GAME_CONFIG.GRID_COLS;
+  const gridRows = size?.gridRows ?? config.GAME_CONFIG.GRID_ROWS;
+  const totalCells = gridCols * gridRows;
   return new Array(totalCells).fill(-1);
 };
diff --git a/apps/server/src/domains/game/entities/player/playerPosition.ts b/apps/server/src/domains/game/entities/player/playerPosition.ts
index 316e400..8ae376f 100644
--- a/apps/server/src/domains/game/entities/player/playerPosition.ts
+++ b/apps/server/src/domains/game/entities/player/playerPosition.ts
@@ -5,7 +5,24 @@
 import { domain } from "@repo/shared";
 import { Player } from "./Player.js";
 
+type MapGridSize = {
+  gridCols: number;
+  gridRows: number;
+};
+
 /** プレイヤー座標に対応するグリッドインデックスを返す */
-export const getPlayerGridIndex = (player: Player): number | null => {
+export const getPlayerGridIndex = (
+  player: Player,
+  size?: MapGridSize,
+): number | null => {
+  if (size) {
+    return domain.game.gridMap.getGridIndexFromPositionWithSize(
+      player.x,
+      player.y,
+      size.gridCols,
+      size.gridRows,
+    );
+  }
+
   return domain.game.gridMap.getGridIndexFromPosition(player.x, player.y);
 };
diff --git a/apps/server/src/domains/game/entities/player/playerSpawn.ts b/apps/server/src/domains/game/entities/player/playerSpawn.ts
index 62340bd..b613979 100644
--- a/apps/server/src/domains/game/entities/player/playerSpawn.ts
+++ b/apps/server/src/domains/game/entities/player/playerSpawn.ts
@@ -5,19 +5,27 @@
 import { config } from "@server/config";
 import { Player } from "./Player.js";
 
+type SpawnMapSize = {
+  gridCols: number;
+  gridRows: number;
+};
+
 /** プレイヤーを生成し，初期スポーン座標を設定して返す */
 // 💡 引数に teamId を追加
 export const createSpawnedPlayer = (
   id: string,
   name: string,
   teamId: number,
+  mapSize?: SpawnMapSize,
 ): Player => {
   const player = new Player(id, name, teamId); // ここにteamIdを渡す！
 
-  const { GRID_COLS, GRID_ROWS, TEAM_COUNT } = config.GAME_CONFIG;
+  const { TEAM_COUNT } = config.GAME_CONFIG;
+  const gridCols = mapSize?.gridCols ?? config.GAME_CONFIG.GRID_COLS;
+  const gridRows = mapSize?.gridRows ?? config.GAME_CONFIG.GRID_ROWS;
 
-  let baseX = GRID_COLS / 2;
-  let baseY = GRID_ROWS / 2;
+  let baseX = gridCols / 2;
+  let baseY = gridRows / 2;
 
   switch (player.teamId % TEAM_COUNT) {
     case 0: // 左上
@@ -25,24 +33,24 @@
       baseY = 2;
       break;
     case 1: // 右下
-      baseX = GRID_COLS - 2;
-      baseY = GRID_ROWS - 2;
+      baseX = gridCols - 2;
+      baseY = gridRows - 2;
       break;
     case 2: // 右上
-      baseX = GRID_COLS - 2;
+      baseX = gridCols - 2;
       baseY = 2;
       break;
     case 3: // 左下
       baseX = 2;
-      baseY = GRID_ROWS - 2;
+      baseY = gridRows - 2;
       break;
   }
 
   const scatterX = (Math.random() - 0.5) * 2;
   const scatterY = (Math.random() - 0.5) * 2;
 
-  player.x = Math.max(1, Math.min(GRID_COLS - 1, baseX + scatterX));
-  player.y = Math.max(1, Math.min(GRID_ROWS - 1, baseY + scatterY));
+  player.x = Math.max(1, Math.min(gridCols - 1, baseX + scatterX));
+  player.y = Math.max(1, Math.min(gridRows - 1, baseY + scatterY));
 
   // リスポーン時に戻る座標として初期位置を保持する
   player.initialX = player.x;
diff --git a/apps/server/src/domains/game/loop/GameLoop.ts b/apps/server/src/domains/game/loop/GameLoop.ts
index 0cbfaad..3a8ae13 100644
--- a/apps/server/src/domains/game/loop/GameLoop.ts
+++ b/apps/server/src/domains/game/loop/GameLoop.ts
@@ -34,6 +34,8 @@
 export type GameLoopOptions = {
   roomId: string;
   tickRate: number;
+  gridCols: number;
+  gridRows: number;
   players: Map<string, Player>;
   mapStore: MapStore;
   activeBombRegistry: ActiveBombRegistry;
@@ -65,9 +67,10 @@
   private lastSentPlayers: Map<string, domain.game.tick.PlayerPositionUpdate> =
     new Map();
   private disconnectedBotControlledPlayerIds: Set<string> = new Set();
-  private botTurnOrchestrator: BotTurnOrchestrator = new BotTurnOrchestrator();
+  private readonly mapSize: { gridCols: number; gridRows: number };
+  private botTurnOrchestrator: BotTurnOrchestrator;
   private readonly botReceivedHitCountById = new Map<string, number>();
-  private readonly hurricaneSystem = new HurricaneSystem();
+  private readonly hurricaneSystem: HurricaneSystem;
 
   private readonly roomId: string;
   private readonly tickRate: number;
@@ -79,6 +82,12 @@
   constructor(options: GameLoopOptions) {
     this.roomId = options.roomId;
     this.tickRate = options.tickRate;
+    this.mapSize = {
+      gridCols: options.gridCols,
+      gridRows: options.gridRows,
+    };
+    this.botTurnOrchestrator = new BotTurnOrchestrator(this.mapSize);
+    this.hurricaneSystem = new HurricaneSystem(this.mapSize);
     this.players = options.players;
     this.mapStore = options.mapStore;
     this.activeBombRegistry = options.activeBombRegistry;
@@ -311,7 +320,7 @@
     this.players.forEach((player) => {
       gridEntries.push({
         playerId: player.id,
-        gridIndex: getPlayerGridIndex(player),
+        gridIndex: getPlayerGridIndex(player, this.mapSize),
         teamId: player.teamId,
         player,
       });
diff --git a/apps/server/src/domains/game/loop/HurricaneSystem.ts b/apps/server/src/domains/game/loop/HurricaneSystem.ts
index d959001..7c49b1a 100644
--- a/apps/server/src/domains/game/loop/HurricaneSystem.ts
+++ b/apps/server/src/domains/game/loop/HurricaneSystem.ts
@@ -4,6 +4,7 @@
  * GameLoop からハリケーン専用責務を分離する
  */
 import { config } from "@server/config";
+import { collectSyncDeltaEntries } from "@server/common/syncDelta";
 import { domain, type HurricaneStatePayload } from "@repo/shared";
 import { Player } from "../entities/player/Player.js";
 
@@ -19,11 +20,71 @@
   rotationRad: number;
 };
 
+type MapGridSize = {
+  gridCols: number;
+  gridRows: number;
+};
+
+type HurricaneSyncSnapshot = {
+  x: number;
+  y: number;
+  radius: number;
+  rotationRad: number;
+};
+
+const quantizeValue = (value: number, scale: number): number => {
+  return Math.round(value * scale) / scale;
+};
+
+const toHurricaneSyncSnapshot = (
+  state: HurricaneState,
+): HurricaneSyncSnapshot => {
+  return {
+    x: quantizeValue(
+      state.x,
+      config.GAME_CONFIG.NETWORK_SYNC.HURRICANE_POSITION_QUANTIZE_SCALE,
+    ),
+    y: quantizeValue(
+      state.y,
+      config.GAME_CONFIG.NETWORK_SYNC.HURRICANE_POSITION_QUANTIZE_SCALE,
+    ),
+    radius: quantizeValue(
+      state.radius,
+      config.GAME_CONFIG.NETWORK_SYNC.HURRICANE_POSITION_QUANTIZE_SCALE,
+    ),
+    rotationRad: quantizeValue(
+      state.rotationRad,
+      config.GAME_CONFIG.NETWORK_SYNC.HURRICANE_ROTATION_QUANTIZE_SCALE,
+    ),
+  };
+};
+
+const isSameHurricaneSyncSnapshot = (
+  left: HurricaneSyncSnapshot,
+  right: HurricaneSyncSnapshot,
+): boolean => {
+  return (
+    left.x === right.x
+    && left.y === right.y
+    && left.radius === right.radius
+    && left.rotationRad === right.rotationRad
+  );
+};
+
 /** ハリケーン状態の生成更新と被弾判定を管理する */
 export class HurricaneSystem {
+  private readonly mapSize: MapGridSize;
   private hasSpawned = false;
   private hurricanes: HurricaneState[] = [];
   private readonly lastHitAtMsByPlayerId = new Map<string, number>();
+  private readonly lastSentSnapshotByHurricaneId = new Map<
+    string,
+    HurricaneSyncSnapshot
+  >();
+
+  constructor(mapSize: MapGridSize) {
+    this.mapSize = mapSize;
+  }
 
   /** 残り時間しきい値到達時にハリケーンを一度だけ生成する */
   public ensureSpawned(elapsedMs: number): void {
@@ -50,8 +111,8 @@
       return;
     }
 
-    const maxX = config.GAME_CONFIG.GRID_COLS;
-    const maxY = config.GAME_CONFIG.GRID_ROWS;
+    const maxX = this.mapSize.gridCols;
+    const maxY = this.mapSize.gridRows;
 
     this.hurricanes.forEach((hurricane) => {
       hurricane.x += hurricane.vx * deltaSec;
@@ -79,13 +140,25 @@
 
   /** 同期配信用のハリケーン状態配列を返す */
   public getUpdatePayload(): HurricaneStatePayload[] {
-    return this.hurricanes.map((hurricane) => ({
-      id: hurricane.id,
-      x: hurricane.x,
-      y: hurricane.y,
-      radius: hurricane.radius,
-      rotationRad: hurricane.rotationRad,
-    }));
+    return collectSyncDeltaEntries(
+      this.hurricanes,
+      this.lastSentSnapshotByHurricaneId,
+      {
+        selectId: (hurricane) => hurricane.id,
+        toSnapshot: (hurricane) => toHurricaneSyncSnapshot(hurricane),
+        isSameSnapshot: (left, right) =>
+          isSameHurricaneSyncSnapshot(left, right),
+      },
+    ).map((entry) => {
+      const { item, snapshot } = entry;
+      return {
+        id: item.id,
+        x: snapshot.x,
+        y: snapshot.y,
+        radius: snapshot.radius,
+        rotationRad: snapshot.rotationRad,
+      };
+    });
   }
 
   /** クールダウン付きで被弾プレイヤーID配列を返す */
@@ -141,13 +214,14 @@
     this.hasSpawned = false;
     this.hurricanes = [];
     this.lastHitAtMsByPlayerId.clear();
+    this.lastSentSnapshotByHurricaneId.clear();
   }
 
   /** ハリケーン初期状態を生成する */
   private createHurricane(index: number): HurricaneState {
     const radius = config.GAME_CONFIG.HURRICANE_DIAMETER_GRID / 2;
-    const x = this.randomInRange(radius, config.GAME_CONFIG.GRID_COLS - radius);
-    const y = this.randomInRange(radius, config.GAME_CONFIG.GRID_ROWS - radius);
+    const x = this.randomInRange(radius, this.mapSize.gridCols - radius);
+    const y = this.randomInRange(radius, this.mapSize.gridRows - radius);
     const directionRad = this.randomInRange(0, Math.PI * 2);
     const speed = config.GAME_CONFIG.HURRICANE_MOVE_SPEED;
 
diff --git a/apps/server/src/domains/room/application/services/RoomJoinService.ts b/apps/server/src/domains/room/application/services/RoomJoinService.ts
index 979b5b2..2dc89ab 100644
--- a/apps/server/src/domains/room/application/services/RoomJoinService.ts
+++ b/apps/server/src/domains/room/application/services/RoomJoinService.ts
@@ -21,6 +21,7 @@
         players: [],
         status: domain.room.RoomPhase.WAITING,
         maxPlayers: config.GAME_CONFIG.MAX_PLAYERS_PER_ROOM,
+        fieldSizePreset: config.GAME_CONFIG.DEFAULT_FIELD_PRESET,
       };
       this.rooms.set(roomId, room);
       logEvent(logScopes.ROOM_JOIN_SERVICE, {
diff --git a/apps/server/src/network/adapters/gamePayloadSanitizers.ts b/apps/server/src/network/adapters/gamePayloadSanitizers.ts
index 35fffec..dd188fb 100644
--- a/apps/server/src/network/adapters/gamePayloadSanitizers.ts
+++ b/apps/server/src/network/adapters/gamePayloadSanitizers.ts
@@ -1,12 +1,46 @@
 /**
  * gamePayloadSanitizers
- * ゲーム関連の送信ペイロードを境界で正規化する
+ * ゲーム関連の送信ペイロードを正規化し，同期差分へ変換する
  */
+import { domain } from "@repo/shared";
 import type { UpdatePlayersPayload } from "@repo/shared";
+import { collectSyncDeltaEntries } from "@server/common/syncDelta";
 
-/** UPDATE_PLAYERS の送信値を座標差分のみへ正規化する */
-export const sanitizeUpdatePlayersPayload = (
+type QuantizedPosition = {
+  x: number;
+  y: number;
+};
+
+/** UPDATE_PLAYERS の送信値を座標量子化した配列へ正規化する */
+export const quantizeUpdatePlayersPayload = (
   players: UpdatePlayersPayload
 ): UpdatePlayersPayload => {
-  return players.map(({ id, x, y }) => ({ id, x, y }));
+  return players.map(({ id, x, y }) => {
+    const quantized = domain.game.player.quantizeMovePayload({ x, y });
+    return {
+      id,
+      x: quantized.x,
+      y: quantized.y,
+    };
+  });
 };
+
+/** UPDATE_PLAYERS の量子化済み配列から同値座標を除外して差分のみ返す */
+export const collectChangedUpdatePlayersPayload = (
+  players: UpdatePlayersPayload,
+  lastSentPositionByPlayerId: Map<string, QuantizedPosition>
+): UpdatePlayersPayload => {
+  return collectSyncDeltaEntries(players, lastSentPositionByPlayerId, {
+    selectId: (player) => player.id,
+    toSnapshot: (player) => ({ x: player.x, y: player.y }),
+    isSameSnapshot: (left, right) =>
+      domain.game.player.isSameMovePayload(left, right),
+  }).map((entry) => entry.item);
+};
+
+/** 既存呼び出し互換のため残す UPDATE_PLAYERS 量子化関数 */
+export const sanitizeUpdatePlayersPayload = quantizeUpdatePlayersPayload;
+
+/** 既存呼び出し互換のため残す UPDATE_PLAYERS 同値除外関数 */
+export const filterUnchangedUpdatePlayersPayload =
+  collectChangedUpdatePlayersPayload;
diff --git a/apps/server/src/network/adapters/realtimeRoomSyncState.ts b/apps/server/src/network/adapters/realtimeRoomSyncState.ts
new file mode 100644
index 0000000..d712228
--- /dev/null
+++ b/apps/server/src/network/adapters/realtimeRoomSyncState.ts
@@ -0,0 +1,37 @@
+/**
+ * realtimeRoomSyncState
+ * ルーム単位で高頻度同期の前回送信状態を保持するストアを提供する
+ */
+import type { domain } from "@repo/shared";
+
+type RoomId = domain.room.Room["roomId"];
+
+/** ルーム単位のプレイヤー送信座標キャッシュの構造 */
+export type RoomPlayerPositionCache = Map<string, { x: number; y: number }>;
+
+/** 高頻度同期向けのルーム状態ストア操作契約 */
+export type RealtimeRoomSyncStateStore = {
+  getPlayerPositionCache: (roomId: RoomId) => RoomPlayerPositionCache;
+  resetRoom: (roomId: RoomId) => void;
+};
+
+/** 高頻度同期向けのルーム状態ストアを生成する */
+export const createRealtimeRoomSyncStateStore = (): RealtimeRoomSyncStateStore => {
+  const playerPositionCacheByRoomId = new Map<RoomId, RoomPlayerPositionCache>();
+
+  return {
+    getPlayerPositionCache: (roomId) => {
+      const existing = playerPositionCacheByRoomId.get(roomId);
+      if (existing) {
+        return existing;
+      }
+
+      const created: RoomPlayerPositionCache = new Map();
+      playerPositionCacheByRoomId.set(roomId, created);
+      return created;
+    },
+    resetRoom: (roomId) => {
+      playerPositionCacheByRoomId.delete(roomId);
+    },
+  };
+};
diff --git a/apps/server/src/network/adapters/socketEmitters.ts b/apps/server/src/network/adapters/socketEmitters.ts
index dfe1fc3..4fb57bb 100644
--- a/apps/server/src/network/adapters/socketEmitters.ts
+++ b/apps/server/src/network/adapters/socketEmitters.ts
@@ -15,6 +15,11 @@
   <TEvent extends SocketEventName>(roomId: string, event: TEvent, payload: ServerToClientPayloadOf<TEvent>): void;
 };
 
+type EmitToRoomVolatile = {
+  <TEvent extends SocketEventName>(roomId: string, event: TEvent): void;
+  <TEvent extends SocketEventName>(roomId: string, event: TEvent, payload: ServerToClientPayloadOf<TEvent>): void;
+};
+
 type EmitToRoomExceptSocket = {
   <TEvent extends SocketEventName>(roomId: string, excludedSocketId: string, event: TEvent): void;
   <TEvent extends SocketEventName>(roomId: string, excludedSocketId: string, event: TEvent, payload: ServerToClientPayloadOf<TEvent>): void;
@@ -56,6 +61,17 @@
   };
 };
 
+/** ルーム単位の volatile 送信関数を生成する */
+export const createEmitToRoomVolatile = (io: Server): EmitToRoomVolatile => {
+  return (roomId: string, event: SocketEventName, payload?: unknown) => {
+    emitWithOptionalPayload(
+      (eventName, body) => io.to(roomId).volatile.emit(eventName, body),
+      event,
+      payload,
+    );
+  };
+};
+
 /** ルーム送信時に特定ソケットを除外する送信関数を生成する */
 export const createEmitToRoomExceptSocket = (io: Server): EmitToRoomExceptSocket => {
   return (roomId: string, excludedSocketId: string, event: SocketEventName, payload?: unknown) => {
diff --git a/apps/server/src/network/handlers/CommonHandler.ts b/apps/server/src/network/handlers/CommonHandler.ts
index 6348c9d..2636c34 100644
--- a/apps/server/src/network/handlers/CommonHandler.ts
+++ b/apps/server/src/network/handlers/CommonHandler.ts
@@ -6,13 +6,14 @@
 import {
   createEmitToAll,
   createEmitToRoom,
+  createEmitToRoomVolatile,
   createEmitToRoomExceptSocket,
   createEmitToSocket,
   createEmitToSocketById,
 } from "@server/network/adapters/socketEmitters";
 
-/** ハンドラで共通利用する送信コンテキスト */
-export type CommonHandlerContext = {
+/** 到達保証を重視する送信関数群 */
+export type ReliableEmitters = {
   emitToAll: ReturnType<typeof createEmitToAll>;
   emitToRoom: ReturnType<typeof createEmitToRoom>;
   emitToRoomExceptSocket: ReturnType<typeof createEmitToRoomExceptSocket>;
@@ -20,16 +21,36 @@
   emitToSocketById: ReturnType<typeof createEmitToSocketById>;
 };
 
+/** 鮮度を重視する高頻度送信関数群 */
+export type RealtimeEmitters = {
+  emitToRoom: ReturnType<typeof createEmitToRoomVolatile>;
+};
+
+/** ハンドラで共通利用する送信コンテキスト */
+export type CommonHandlerContext = {
+  reliable: ReliableEmitters;
+  realtime: RealtimeEmitters;
+};
+
 /** 送信先別のエミッタをまとめた共通コンテキストを生成する */
 export const createCommonHandlerContext = (
   io: Server,
   socket: Socket
 ): CommonHandlerContext => {
-  return {
+  const reliable: ReliableEmitters = {
     emitToAll: createEmitToAll(io),
     emitToRoom: createEmitToRoom(io),
     emitToRoomExceptSocket: createEmitToRoomExceptSocket(io),
     emitToSocket: createEmitToSocket(socket),
     emitToSocketById: createEmitToSocketById(io),
   };
+
+  const realtime: RealtimeEmitters = {
+    emitToRoom: createEmitToRoomVolatile(io),
+  };
+
+  return {
+    reliable,
+    realtime,
+  };
 };
diff --git a/apps/server/src/network/handlers/game/createGameOutputAdapter.ts b/apps/server/src/network/handlers/game/createGameOutputAdapter.ts
index e0ee30f..c1a3d03 100644
--- a/apps/server/src/network/handlers/game/createGameOutputAdapter.ts
+++ b/apps/server/src/network/handlers/game/createGameOutputAdapter.ts
@@ -24,7 +24,11 @@
   GameOutputPort,
 } from "@server/domains/game/application/ports/gameUseCasePorts";
 import { isBotPlayerId } from "@server/domains/game/application/services/bot/index.js";
-import { sanitizeUpdatePlayersPayload } from "@server/network/adapters/gamePayloadSanitizers";
+import {
+  collectChangedUpdatePlayersPayload,
+  quantizeUpdatePlayersPayload,
+} from "@server/network/adapters/gamePayloadSanitizers";
+import { createRealtimeRoomSyncStateStore } from "@server/network/adapters/realtimeRoomSyncState";
 import { createEmitToRoom } from "@server/network/adapters/socketEmitters";
 import type { CommonHandlerContext } from "../CommonHandler";
 
@@ -48,19 +52,31 @@
 export const createGameOutputAdapter = (
   common: CommonHandlerContext,
 ): GameOutputAdapter => {
+  const { reliable, realtime } = common;
+  const realtimeRoomSyncState = createRealtimeRoomSyncStateStore();
+
   return {
     publishPongToSocket: (payload: PongPayload) => {
-      common.emitToSocket(protocol.SocketEvents.PONG, payload);
+      reliable.emitToSocket(protocol.SocketEvents.PONG, payload);
     },
     publishUpdatePlayersToRoom: (
       roomId: RoomId,
       players: UpdatePlayersPayload,
     ) => {
-      const sanitizedPlayers = sanitizeUpdatePlayersPayload(players);
-      common.emitToRoom(
+      const quantizedPlayers = quantizeUpdatePlayersPayload(players);
+      const changedPlayers = collectChangedUpdatePlayersPayload(
+        quantizedPlayers,
+        realtimeRoomSyncState.getPlayerPositionCache(roomId),
+      );
+
+      if (changedPlayers.length === 0) {
+        return;
+      }
+
+      realtime.emitToRoom(
         roomId,
         protocol.SocketEvents.UPDATE_PLAYERS,
-        sanitizedPlayers,
+        changedPlayers,
       );
     },
     publishMapCellUpdatesToRoom: (
@@ -68,7 +84,7 @@
       cellUpdates: domainNs.game.gridMap.CellUpdate[],
     ) => {
       const grouped = domainNs.game.gridMap.groupCellUpdates(cellUpdates);
-      common.emitToRoom(
+      reliable.emitToRoom(
         roomId,
         protocol.SocketEvents.UPDATE_MAP_CELLS,
         grouped,
@@ -78,26 +94,28 @@
       roomId: RoomId,
       hurricanes: UpdateHurricanesPayload,
     ) => {
-      common.emitToRoom(
+      realtime.emitToRoom(
         roomId,
         protocol.SocketEvents.UPDATE_HURRICANES,
         hurricanes,
       );
     },
     publishGameEndToRoom: (roomId: RoomId) => {
-      common.emitToRoom(roomId, protocol.SocketEvents.GAME_END);
+      realtimeRoomSyncState.resetRoom(roomId);
+      reliable.emitToRoom(roomId, protocol.SocketEvents.GAME_END);
     },
     publishGameResultToRoom: (roomId: RoomId, payload: GameResultPayload) => {
-      common.emitToRoom(roomId, protocol.SocketEvents.GAME_RESULT, payload);
+      reliable.emitToRoom(roomId, protocol.SocketEvents.GAME_RESULT, payload);
     },
     publishGameStartToRoom: (roomId: RoomId, payload: GameStartPayload) => {
-      common.emitToRoom(roomId, protocol.SocketEvents.GAME_START, payload);
+      realtimeRoomSyncState.resetRoom(roomId);
+      reliable.emitToRoom(roomId, protocol.SocketEvents.GAME_START, payload);
     },
     publishCurrentPlayersToSocket: (players: CurrentPlayersPayload) => {
-      common.emitToSocket(protocol.SocketEvents.CURRENT_PLAYERS, players);
+      reliable.emitToSocket(protocol.SocketEvents.CURRENT_PLAYERS, players);
     },
     publishGameStartToSocket: (payload: GameStartPayload) => {
-      common.emitToSocket(protocol.SocketEvents.GAME_START, payload);
+      reliable.emitToSocket(protocol.SocketEvents.GAME_START, payload);
     },
     publishBombPlacedToOthersInRoom: (
       roomId: RoomId,
@@ -105,11 +123,11 @@
       payload: BombPlacedPayload,
     ) => {
       if (isBotPlayerId(ownerSocketId)) {
-        common.emitToRoom(roomId, protocol.SocketEvents.BOMB_PLACED, payload);
+        reliable.emitToRoom(roomId, protocol.SocketEvents.BOMB_PLACED, payload);
         return;
       }
 
-      common.emitToRoomExceptSocket(
+      reliable.emitToRoomExceptSocket(
         roomId,
         ownerSocketId,
         protocol.SocketEvents.BOMB_PLACED,
@@ -120,7 +138,7 @@
       socketId: string,
       payload: BombPlacedAckPayload,
     ) => {
-      common.emitToSocketById(
+      reliable.emitToSocketById(
         socketId,
         protocol.SocketEvents.BOMB_PLACED_ACK,
         payload,
@@ -131,7 +149,7 @@
       deadPlayerId: string,
       payload: PlayerHitPayload,
     ) => {
-      common.emitToRoomExceptSocket(
+      reliable.emitToRoomExceptSocket(
         roomId,
         deadPlayerId,
         protocol.SocketEvents.PLAYER_HIT,
@@ -139,13 +157,13 @@
       );
     },
     publishPlayerHitToRoom: (roomId: RoomId, payload: PlayerHitPayload) => {
-      common.emitToRoom(roomId, protocol.SocketEvents.PLAYER_HIT, payload);
+      reliable.emitToRoom(roomId, protocol.SocketEvents.PLAYER_HIT, payload);
     },
     publishHurricaneHitToRoom: (
       roomId: RoomId,
       payload: HurricaneHitPayload,
     ) => {
-      common.emitToRoom(roomId, protocol.SocketEvents.HURRICANE_HIT, payload);
+      reliable.emitToRoom(roomId, protocol.SocketEvents.HURRICANE_HIT, payload);
     },
   };
 };
diff --git a/apps/server/src/network/handlers/game/gameEventOrchestrators.ts b/apps/server/src/network/handlers/game/gameEventOrchestrators.ts
index bb6b4ae..88c3ba5 100644
--- a/apps/server/src/network/handlers/game/gameEventOrchestrators.ts
+++ b/apps/server/src/network/handlers/game/gameEventOrchestrators.ts
@@ -4,7 +4,7 @@
  * 受信ハンドラからユースケース実行責務を分離する
  * ランタイム未解決時はNetworkスコープでignored_missing_roomを記録する
  */
-import { contracts as protocol, domain, type BombHitReportPayload, type PingPayload, type PlaceBombPayload } from "@repo/shared";
+import { contracts as protocol, domain, type BombHitReportPayload, type PingPayload, type PlaceBombPayload, type StartGameRequestPayload } from "@repo/shared";
 import { readyForGameCoordinator } from "@server/application/coordinators/readyForGameCoordinator";
 import { startGameCoordinator } from "@server/application/coordinators/startGameCoordinator";
 import { movePlayerUseCase } from "@server/domains/game/application/useCases/movePlayerUseCase";
@@ -20,9 +20,7 @@
 } from "@server/network/types/connectionPorts";
 
 /** START_GAMEイベントの入力ペイロード型 */
-export type StartGamePayload = {
-  targetPlayerCount?: number;
-};
+export type StartGamePayload = StartGameRequestPayload;
 
 /** PINGイベントの入力ペイロード型 */
 export type PingEventPayload = Parameters<typeof handlePingEvent>[1];
@@ -63,6 +61,7 @@
   startGameCoordinator({
     ownerId: deps.socketId,
     requestedPlayerCount: payload.targetPlayerCount,
+    requestedFieldSizePreset: payload.fieldSizePreset,
     roomManager: deps.roomManager,
     runtimeRegistry: deps.runtimeRegistry,
     output: deps.output,
@@ -86,6 +85,7 @@
   deps: GameEventOrchestratorDeps,
   move: domain.game.player.MovePayload,
 ): void => {
+  const normalizedMove = domain.game.player.quantizeMovePayload(move);
   const resolved = runWithRuntimeByPlayerId(
     deps.roomManager,
     deps.runtimeRegistry,
@@ -94,7 +94,7 @@
       movePlayerUseCase({
         gameManager,
         playerId: deps.socketId,
-        move,
+        move: normalizedMove,
       });
     },
   );
diff --git a/apps/server/src/network/handlers/room/createRoomOutputAdapter.ts b/apps/server/src/network/handlers/room/createRoomOutputAdapter.ts
index 090a0b9..daf7957 100644
--- a/apps/server/src/network/handlers/room/createRoomOutputAdapter.ts
+++ b/apps/server/src/network/handlers/room/createRoomOutputAdapter.ts
@@ -19,12 +19,14 @@
 export const createRoomOutputAdapter = (
   common: CommonHandlerContext
 ): RoomOutputAdapter => {
+  const { reliable } = common;
+
   return {
     publishRoomUpdateToRoom: (roomId: RoomId, room: RoomUpdatePayload) => {
-      common.emitToRoom(roomId, protocol.SocketEvents.ROOM_UPDATE, room);
+      reliable.emitToRoom(roomId, protocol.SocketEvents.ROOM_UPDATE, room);
     },
     publishJoinRejectedToSocket: (payload: domain.room.JoinRoomRejectedPayload) => {
-      common.emitToSocket(protocol.SocketEvents.ROOM_JOIN_REJECTED, payload);
+      reliable.emitToSocket(protocol.SocketEvents.ROOM_JOIN_REJECTED, payload);
     },
   };
 };
diff --git a/apps/server/src/network/validation/socketPayloadValidators.ts b/apps/server/src/network/validation/socketPayloadValidators.ts
index b999b69..1c82b78 100644
--- a/apps/server/src/network/validation/socketPayloadValidators.ts
+++ b/apps/server/src/network/validation/socketPayloadValidators.ts
@@ -6,6 +6,7 @@
   domain,
   PlaceBombPayload,
   BombHitReportPayload,
+  StartGameRequestPayload,
 } from "@repo/shared";
 import type { PingPayload } from "@repo/shared";
 import { isPlaceBombPayload as isValidPlaceBombPayload } from "@server/domains/game/entities/bomb/bombPayloadValidation";
@@ -57,21 +58,47 @@
 /** START_GAMEイベントのペイロードが開始要求情報であるか判定する */
 export const isStartGamePayload = (
   value: unknown,
-): value is { targetPlayerCount?: number } => {
+): value is StartGameRequestPayload => {
   if (typeof value !== "object" || value === null) {
     return false;
   }
 
   const candidate = value as Record<string, unknown>;
   const targetPlayerCount = candidate.targetPlayerCount;
+  const fieldSizePreset = candidate.fieldSizePreset;
+
   if (targetPlayerCount === undefined) {
+    if (fieldSizePreset === undefined) {
+      return true;
+    }
+
+    return (
+      fieldSizePreset === "SMALL"
+      || fieldSizePreset === "MEDIUM"
+      || fieldSizePreset === "LARGE"
+      || fieldSizePreset === "XLARGE"
+    );
+  }
+
+  const isValidTargetPlayerCount = (
+    typeof targetPlayerCount === "number" &&
+    Number.isInteger(targetPlayerCount) &&
+    targetPlayerCount > 0
+  );
+
+  if (!isValidTargetPlayerCount) {
+    return false;
+  }
+
+  if (fieldSizePreset === undefined) {
     return true;
   }
 
   return (
-    typeof targetPlayerCount === "number" &&
-    Number.isInteger(targetPlayerCount) &&
-    targetPlayerCount > 0
+    fieldSizePreset === "SMALL"
+    || fieldSizePreset === "MEDIUM"
+    || fieldSizePreset === "LARGE"
+    || fieldSizePreset === "XLARGE"
   );
 };
 
diff --git a/packages/shared/src/config/gameConfig.ts b/packages/shared/src/config/gameConfig.ts
index 6226512..f3670ce 100644
--- a/packages/shared/src/config/gameConfig.ts
+++ b/packages/shared/src/config/gameConfig.ts
@@ -4,17 +4,78 @@
  * クライアントとサーバーで参照する定数群を提供する
  */
 /** ゲーム全体で利用する共有設定値 */
+const NETWORK_SYNC_CONFIG = {
+  PLAYER_POSITION_UPDATE_MS: 50,
+  POSITION_QUANTIZE_SCALE: 100,
+  HURRICANE_POSITION_QUANTIZE_SCALE: 10,
+  HURRICANE_ROTATION_QUANTIZE_SCALE: 4,
+} as const;
+
+/** AOI同期で利用する1セルのグリッド幅 */
+const AOI_CELL_SIZE = 3 as const;
+
+/** フィールドサイズ種別ごとのAOIセル数と推奨人数レンジ */
+const FIELD_PRESETS = {
+  SMALL: {
+    aoiCols: 8,
+    aoiRows: 8,
+    recommendedPlayers: { min: 4, max: 20 },
+  },
+  MEDIUM: {
+    aoiCols: 12,
+    aoiRows: 12,
+    recommendedPlayers: { min: 20, max: 40 },
+  },
+  LARGE: {
+    aoiCols: 15,
+    aoiRows: 15,
+    recommendedPlayers: { min: 40, max: 70 },
+  },
+  XLARGE: {
+    aoiCols: 18,
+    aoiRows: 18,
+    recommendedPlayers: { min: 70, max: 100 },
+  },
+} as const;
+
+/** フィールドサイズ種別のキー型 */
+export type FieldSizePreset = keyof typeof FIELD_PRESETS;
+
+/** フィールドサイズ種別から実グリッドサイズを解決する */
+export const resolveFieldGridSize = (preset: FieldSizePreset) => {
+  const selectedPreset = FIELD_PRESETS[preset];
+  return {
+    cols: selectedPreset.aoiCols * AOI_CELL_SIZE,
+    rows: selectedPreset.aoiRows * AOI_CELL_SIZE,
+  };
+};
+
+/** 既定で利用するフィールドサイズ種別 */
+const DEFAULT_FIELD_PRESET = "MEDIUM" as const;
+
+const defaultGridSize = resolveFieldGridSize(DEFAULT_FIELD_PRESET);
+
+/** ゲーム全体で利用する共有設定値 */
 export const GAME_CONFIG = {
   // ゲーム進行設定（クライアント/サーバー契約）
   GAME_DURATION_SEC: 180, // 1ゲームの制限時間（秒）
   GAME_START_DELAY_MS: 5000, // 開始通知から実際にゲーム進行を開始するまでの待機時間（ms）
 
   // ネットワーク同期設定（クライアント/サーバー契約）
-  PLAYER_POSITION_UPDATE_MS: 50, // 座標送信間隔（20Hz）
+  NETWORK_SYNC: NETWORK_SYNC_CONFIG,
+  PLAYER_POSITION_UPDATE_MS: NETWORK_SYNC_CONFIG.PLAYER_POSITION_UPDATE_MS, // 後方互換のため維持
+  POSITION_QUANTIZE_SCALE: NETWORK_SYNC_CONFIG.POSITION_QUANTIZE_SCALE, // 後方互換のため維持
+  HURRICANE_POSITION_QUANTIZE_SCALE: NETWORK_SYNC_CONFIG.HURRICANE_POSITION_QUANTIZE_SCALE, // 後方互換のため維持
+  HURRICANE_ROTATION_QUANTIZE_SCALE: NETWORK_SYNC_CONFIG.HURRICANE_ROTATION_QUANTIZE_SCALE, // 後方互換のため維持
+
+  // AOI設定（クライアント/サーバー契約）
+  AOI_CELL_SIZE,
+  FIELD_PRESETS,
+  DEFAULT_FIELD_PRESET,
 
   // グリッド（マス）設定（クライアント/サーバー契約）
-  GRID_COLS: 40, // 横のマス数（グリッド単位）
-  GRID_ROWS: 40, // 縦のマス数（グリッド単位）
+  GRID_COLS: defaultGridSize.cols, // 横のマス数（グリッド単位）
+  GRID_ROWS: defaultGridSize.rows, // 縦のマス数（グリッド単位）
 
   // プレイヤー挙動設定（内部座標はグリッド単位、契約値）
   PLAYER_RADIUS: 0.5, // プレイヤー半径（グリッド単位、目安: 0.05〜0.2）
diff --git a/packages/shared/src/config/index.ts b/packages/shared/src/config/index.ts
index 3d3230d..f21dee7 100644
--- a/packages/shared/src/config/index.ts
+++ b/packages/shared/src/config/index.ts
@@ -6,6 +6,10 @@
 
 /** ゲーム全体の共有設定値を再公開する */
 export { GAME_CONFIG } from "./gameConfig";
+/** フィールドサイズ種別から実グリッドサイズを解決する関数を再公開する */
+export { resolveFieldGridSize } from "./gameConfig";
+/** フィールドサイズ種別のキー型を再公開する */
+export type { FieldSizePreset } from "./gameConfig";
 /** チーム名配列を再公開する */
 export { TEAM_NAMES } from "./gameConfig";
 /** 未確定 teamId の既定値を再公開する */
diff --git a/packages/shared/src/domains/game/gridMap/gridMap.logic.ts b/packages/shared/src/domains/game/gridMap/gridMap.logic.ts
index bb9d466..226feed 100644
--- a/packages/shared/src/domains/game/gridMap/gridMap.logic.ts
+++ b/packages/shared/src/domains/game/gridMap/gridMap.logic.ts
@@ -1,20 +1,35 @@
 import { GAME_CONFIG } from "../../../config/gameConfig";
 
+const toGridIndexWithSize = (
+  x: number,
+  y: number,
+  gridCols: number,
+  gridRows: number,
+): number | null => {
+  const col = Math.floor(x);
+  const row = Math.floor(y);
+
+  if (col < 0 || col >= gridCols || row < 0 || row >= gridRows) {
+    return null;
+  }
+
+  return row * gridCols + col;
+};
+
+/** グリッド座標から1次元配列インデックスを取得する（サイズ指定版） */
+export function getGridIndexFromPositionWithSize(
+  x: number,
+  y: number,
+  gridCols: number,
+  gridRows: number,
+): number | null {
+  return toGridIndexWithSize(x, y, gridCols, gridRows);
+}
+
 /**
  * グリッド座標から1次元配列インデックスを取得する（中心点判定）
  */
 export function getGridIndexFromPosition(x: number, y: number): number | null {
   const { GRID_COLS, GRID_ROWS } = GAME_CONFIG;
-
-  // 座標がどのマス（列・行）に属するか計算
-  const col = Math.floor(x);
-  const row = Math.floor(y);
-
-  // マップ外の場合は null を返す
-  if (col < 0 || col >= GRID_COLS || row < 0 || row >= GRID_ROWS) {
-    return null;
-  }
-
-  // 1次元配列のインデックスに変換 (row * 幅 + col)
-  return row * GRID_COLS + col;
+  return toGridIndexWithSize(x, y, GRID_COLS, GRID_ROWS);
 }
diff --git a/packages/shared/src/domains/game/gridMap/index.ts b/packages/shared/src/domains/game/gridMap/index.ts
index af9db0a..4a6e22e 100644
--- a/packages/shared/src/domains/game/gridMap/index.ts
+++ b/packages/shared/src/domains/game/gridMap/index.ts
@@ -7,6 +7,9 @@
 /** グリッドマップ関連の型を再公開する */
 export type { MapState, CellUpdate, GroupedCellUpdates } from "./gridMap.type";
 /** グリッド座標変換ロジックを再公開する */
-export { getGridIndexFromPosition } from "./gridMap.logic";
+export {
+	getGridIndexFromPosition,
+	getGridIndexFromPositionWithSize,
+} from "./gridMap.logic";
 /** CellUpdate配列とGroupedCellUpdatesの相互変換を再公開する */
 export { groupCellUpdates, ungroupCellUpdates } from "./groupedCellUpdates";
diff --git a/packages/shared/src/domains/game/player/index.ts b/packages/shared/src/domains/game/player/index.ts
index d302a12..3dc0d4d 100644
--- a/packages/shared/src/domains/game/player/index.ts
+++ b/packages/shared/src/domains/game/player/index.ts
@@ -6,3 +6,9 @@
 
 /** プレイヤー契約関連の型を再公開する */
 export type { PlayerData, MovePayload } from "./player.type";
+/** MOVE ペイロード送信の正規化関数を再公開する */
+export {
+	DEFAULT_MOVE_QUANTIZE_SCALE,
+	quantizeMovePayload,
+	isSameMovePayload,
+} from "./moveSync";
diff --git a/packages/shared/src/domains/game/player/moveSync.ts b/packages/shared/src/domains/game/player/moveSync.ts
new file mode 100644
index 0000000..24f6c01
--- /dev/null
+++ b/packages/shared/src/domains/game/player/moveSync.ts
@@ -0,0 +1,41 @@
+/**
+ * moveSync
+ * MOVE ペイロードの送信正規化に関する関数を提供する
+ */
+import { GAME_CONFIG } from "../../../config/gameConfig";
+import type { MovePayload } from "./player.type";
+
+/** MOVE ペイロード量子化の既定スケール */
+export const DEFAULT_MOVE_QUANTIZE_SCALE =
+  GAME_CONFIG.NETWORK_SYNC.POSITION_QUANTIZE_SCALE;
+
+/** MOVE 座標を量子化して送信用の値へ正規化する */
+export const quantizeMovePayload = (
+  move: Readonly<MovePayload>,
+  scale = DEFAULT_MOVE_QUANTIZE_SCALE,
+): MovePayload => {
+  return {
+    x: quantizeMoveAxis(move.x, scale),
+    y: quantizeMoveAxis(move.y, scale),
+  };
+};
+
+/** MOVE ペイロードの値が一致するかを判定する */
+export const isSameMovePayload = (
+  left: Readonly<MovePayload>,
+  right: Readonly<MovePayload>,
+): boolean => {
+  return left.x === right.x && left.y === right.y;
+};
+
+const quantizeMoveAxis = (value: number, scale: number): number => {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+
+  if (!Number.isFinite(scale) || scale <= 0) {
+    return value;
+  }
+
+  return Math.round(value * scale) / scale;
+};
\ No newline at end of file
diff --git a/packages/shared/src/domains/room/room.type.ts b/packages/shared/src/domains/room/room.type.ts
index 6fad7d7..22d8039 100644
--- a/packages/shared/src/domains/room/room.type.ts
+++ b/packages/shared/src/domains/room/room.type.ts
@@ -4,6 +4,8 @@
  * 参加状態とイベントペイロード契約を集約する
  */
 
+import type { FieldSizePreset } from "../../config/gameConfig";
+
 /** ルーム進行フェーズ状態型 */
 export type RoomPhase = "waiting" | "playing" | "result";
 
@@ -22,6 +24,7 @@
   players: RoomMember[];
   status: RoomPhase;
   maxPlayers: number;
+  fieldSizePreset: FieldSizePreset;
 }
 
 /** ルーム参加時に送信するペイロード */
diff --git a/packages/shared/src/protocol/eventPayloads.ts b/packages/shared/src/protocol/eventPayloads.ts
index e5ab7db..dca324e 100644
--- a/packages/shared/src/protocol/eventPayloads.ts
+++ b/packages/shared/src/protocol/eventPayloads.ts
@@ -24,10 +24,13 @@
   CurrentPlayersPayload,
   UpdateMapCellsPayload,
   HurricaneStatePayload,
+  HurricaneSnapshotPayload,
+  HurricaneDeltaPayload,
   UpdateHurricanesPayload,
   NewPlayerPayload,
   RemovePlayerPayload,
   GameStartPayload,
+  FieldSizePreset,
   StartGameRequestPayload,
   MovePayload,
   PlaceBombPayload,
diff --git a/packages/shared/src/protocol/payloads/gamePayloads.ts b/packages/shared/src/protocol/payloads/gamePayloads.ts
index afb03bd..76a60ee 100644
--- a/packages/shared/src/protocol/payloads/gamePayloads.ts
+++ b/packages/shared/src/protocol/payloads/gamePayloads.ts
@@ -9,6 +9,10 @@
   MovePayload as PlayerMovePayload,
   PlayerData,
 } from "../../domains/game/player/player.type";
+import type { FieldSizePreset } from "../../config/gameConfig";
+
+/** start-game で利用するフィールドサイズ種別を再公開する型別名 */
+export type { FieldSizePreset } from "../../config/gameConfig";
 
 /** game-result イベントで送受信するランキング1行 */
 export type GameResultRanking = {
@@ -78,7 +82,13 @@
 };
 
 /** update-hurricanes イベントで送受信するハリケーン状態配列 */
-export type UpdateHurricanesPayload = HurricaneStatePayload[];
+export type HurricaneSnapshotPayload = HurricaneStatePayload[];
+
+/** update-hurricanes イベントで送受信するハリケーン差分配列 */
+export type HurricaneDeltaPayload = HurricaneStatePayload[];
+
+/** update-hurricanes イベントで送受信するハリケーン差分配列（互換名） */
+export type UpdateHurricanesPayload = HurricaneDeltaPayload;
 
 /**
  * new-player イベントで送受信するプレイヤー情報
@@ -95,11 +105,18 @@
   startTime: number;
   /** ペイロード送信時のサーバー時刻（クライアント側クロックオフセット補正用, ms） */
   serverNow: number;
+  /** 今回のゲームで採用するフィールドサイズ種別 */
+  fieldSizePreset: FieldSizePreset;
+  /** 今回のゲームで採用するマップ横幅（グリッド単位） */
+  gridCols: number;
+  /** 今回のゲームで採用するマップ縦幅（グリッド単位） */
+  gridRows: number;
 };
 
 /** start-game イベントで受信するゲーム開始要求 */
 export type StartGameRequestPayload = {
   targetPlayerCount?: number;
+  fieldSizePreset?: FieldSizePreset;
 };
 
 /** move イベントで送受信する移動入力情報 */