diff --git a/packages/client/src/components/map/HexGrid.tsx b/packages/client/src/components/map/HexGrid.tsx
index 9bef42c..3cb4eac 100644
--- a/packages/client/src/components/map/HexGrid.tsx
+++ b/packages/client/src/components/map/HexGrid.tsx
@@ -1,4 +1,4 @@
-import { useMemo, useCallback } from "react";
+import React, { useMemo, useCallback } from "react";
 import { defineHex, Grid, rectangle, Orientation } from "honeycomb-grid";
 import { TransformWrapper, TransformComponent } from "react-zoom-pan-pinch";
 import type { HexData, HexEntry } from "@triplanetary/shared";
@@ -20,6 +20,8 @@ interface Props {
   rRange: [number, number];
   onHexClick: (q: number, r: number) => void;
   selectedHex?: string | null;
+  /** SVG elements rendered inside <svg> after the hex layer */
+  overlays?: React.ReactNode;
 }
 
 export function HexGrid({
@@ -28,6 +30,7 @@ export function HexGrid({
   rRange,
   onHexClick,
   selectedHex,
+  overlays,
 }: Props) {
   const [qMin, qMax] = qRange;
   const [rMin, rMax] = rRange;
@@ -144,6 +147,7 @@ export function HexGrid({
               );
             })}
           </g>
+          {overlays}
         </svg>
       </TransformComponent>
     </TransformWrapper>
diff --git a/packages/client/src/pages/game/Board.tsx b/packages/client/src/pages/game/Board.tsx
new file mode 100644
index 0000000..82ef8ce
--- /dev/null
+++ b/packages/client/src/pages/game/Board.tsx
@@ -0,0 +1,225 @@
+import { useState, useMemo, useCallback } from 'react';
+import type { BoardProps as BgioBoardProps } from 'boardgame.io/react';
+import { defineHex, Grid, rectangle, Orientation } from 'honeycomb-grid';
+import {
+  getValidDestinations,
+  type TriplanetaryState,
+  type HexData,
+} from '@triplanetary/shared';
+import { HexGrid } from '../../components/map/HexGrid';
+import HUD from './HUD';
+
+const Q_RANGE: [number, number] = [-12, 14];
+const R_RANGE: [number, number] = [-10, 12];
+
+const FACTION_COLORS: Record<string, string> = {
+  mars: '#cc4444',
+  venus: '#44aacc',
+  terra: '#44cc44',
+  none: '#888888',
+};
+
+// Fallback empty map used when G.mapSnapshot is null
+const EMPTY_MAP: HexData = {
+  meta: { name: '', version: '1.0', hexSize: 30, orientation: 'pointy' },
+  bodies: {},
+  hexes: {},
+  bases: {},
+};
+
+type BoardProps = BgioBoardProps<TriplanetaryState>;
+
+export default function Board({ G, ctx, moves, playerID, isActive }: BoardProps) {
+  const typedMoves = moves as {
+    plotCourse: (dest: [number, number]) => void;
+    lockIn: () => void;
+  };
+  const [selectedShip, setSelectedShip] = useState<number | null>(null);
+  const [validDests, setValidDests] = useState<Set<string>>(new Set());
+
+  const mapData = G.mapSnapshot ?? EMPTY_MAP;
+  const hexSize = mapData.meta.hexSize;
+
+  // Build the same hex grid as HexGrid uses to look up pixel centers
+  const hexLookup = useMemo(() => {
+    const [qMin, qMax] = Q_RANGE;
+    const [rMin, rMax] = R_RANGE;
+    const ProtoHex = defineHex({
+      dimensions: hexSize,
+      orientation: Orientation.POINTY,
+      origin: 'topLeft',
+    });
+    const grid = new Grid(
+      ProtoHex,
+      rectangle({ width: qMax - qMin + 1, height: rMax - rMin + 1, start: { q: qMin, r: rMin } }),
+    );
+    const map = new Map<string, { x: number; y: number }>();
+    for (const hex of grid) {
+      map.set(`${hex.q},${hex.r}`, { x: hex.x, y: hex.y });
+    }
+    return map;
+  }, [hexSize]);
+
+  const center = useCallback(
+    (q: number, r: number) => hexLookup.get(`${q},${r}`) ?? { x: 0, y: 0 },
+    [hexLookup],
+  );
+
+  const handleHexClick = useCallback(
+    (q: number, r: number) => {
+      if (!isActive || !playerID || ctx.phase !== 'astrogation') return;
+      const key = `${q},${r}`;
+      const ownShipIdx = Number(playerID);
+
+      // If clicking own ship and haven't plotted yet, select it
+      if (
+        G.ships[ownShipIdx]?.position[0] === q &&
+        G.ships[ownShipIdx]?.position[1] === r &&
+        !G.plots[playerID ?? '']
+      ) {
+        setSelectedShip(ownShipIdx);
+        const ship = G.ships[ownShipIdx];
+        if (ship) {
+          setValidDests(getValidDestinations(ship, mapData.hexes));
+        }
+        return;
+      }
+
+      // If a ship is selected and this is a valid destination, plot
+      if (selectedShip !== null && validDests.has(key)) {
+        typedMoves.plotCourse([q, r]);
+        setSelectedShip(null);
+        setValidDests(new Set());
+      }
+    },
+    [isActive, ctx.phase, playerID, G.ships, G.plots, selectedShip, validDests, typedMoves, mapData.hexes],
+  );
+
+  const overlays = useMemo(() => {
+    const elements: React.ReactNode[] = [];
+    const r = 10; // ship counter radius
+
+    // Valid destination highlights
+    for (const key of validDests) {
+      const [qStr, rStr] = key.split(',');
+      const q = Number(qStr);
+      const rv = Number(rStr);
+      const c = center(q, rv);
+      // Hexagon highlight using 6 corners (same size as rendered hex)
+      const pts = [];
+      for (let i = 0; i < 6; i++) {
+        const angle = (Math.PI / 180) * (60 * i - 30);
+        pts.push(`${c.x + hexSize * Math.cos(angle)},${c.y + hexSize * Math.sin(angle)}`);
+      }
+      elements.push(
+        <polygon
+          key={`valid-${key}`}
+          points={pts.join(' ')}
+          fill="rgba(255,220,0,0.18)"
+          stroke="#ffcc00"
+          strokeWidth={1.5}
+          style={{ pointerEvents: 'none' }}
+        />,
+      );
+    }
+
+    for (let i = 0; i < G.ships.length; i++) {
+      const ship = G.ships[i];
+      if (!ship) continue;
+      const [sq, sr] = ship.position;
+      const c = center(sq, sr);
+      const color = FACTION_COLORS[ship.faction] ?? '#888';
+
+      // Vector arrow (from current pos toward predicted coast)
+      const [vq, vr] = ship.vector;
+      const grav = ship.pendingGravity ?? [0, 0];
+      const coastQ = sq + vq + grav[0];
+      const coastR = sr + vr + grav[1];
+      const tc = center(coastQ, coastR);
+      if (vq !== 0 || vr !== 0 || grav[0] !== 0 || grav[1] !== 0) {
+        elements.push(
+          <line
+            key={`vector-${ship.id}`}
+            x1={c.x}
+            y1={c.y}
+            x2={tc.x}
+            y2={tc.y}
+            stroke={color}
+            strokeWidth={2}
+            strokeDasharray="4 2"
+            style={{ pointerEvents: 'none' }}
+          />,
+        );
+      }
+
+      // Plot line (if a destination is plotted but not yet locked in)
+      const plot = G.plots[String(i)];
+      if (plot) {
+        const pc = center(plot.destination[0], plot.destination[1]);
+        elements.push(
+          <line
+            key={`plot-${ship.id}`}
+            x1={c.x}
+            y1={c.y}
+            x2={pc.x}
+            y2={pc.y}
+            stroke={color}
+            strokeWidth={1.5}
+            strokeDasharray="6 3"
+            opacity={0.7}
+            style={{ pointerEvents: 'none' }}
+          />,
+        );
+      }
+
+      // Ship counter
+      const isSelected = selectedShip === i;
+      elements.push(
+        <g key={`ship-${ship.id}`}>
+          <circle
+            cx={c.x}
+            cy={c.y}
+            r={r}
+            fill={color}
+            stroke={isSelected ? '#ffcc00' : '#fff'}
+            strokeWidth={isSelected ? 2.5 : 1}
+          />
+          <text
+            x={c.x}
+            y={c.y}
+            textAnchor="middle"
+            dominantBaseline="middle"
+            fontSize={8}
+            fill="#fff"
+            style={{ pointerEvents: 'none', userSelect: 'none' }}
+          >
+            {ship.faction.slice(0, 1).toUpperCase()}
+          </text>
+        </g>,
+      );
+    }
+
+    return <g>{elements}</g>;
+  }, [G.ships, G.plots, validDests, selectedShip, center, hexSize]);
+
+  return (
+    <div style={{ display: 'flex', height: '100vh' }}>
+      <div style={{ flex: 1, overflow: 'hidden' }}>
+        <HexGrid
+          data={mapData}
+          qRange={Q_RANGE}
+          rRange={R_RANGE}
+          onHexClick={handleHexClick}
+          overlays={overlays}
+        />
+      </div>
+      <HUD
+        G={G}
+        ctx={ctx}
+        playerID={playerID ?? ''}
+        isActive={isActive}
+        onLockIn={() => typedMoves.lockIn()}
+      />
+    </div>
+  );
+}
diff --git a/packages/client/src/pages/game/HUD.tsx b/packages/client/src/pages/game/HUD.tsx
new file mode 100644
index 0000000..b89c993
--- /dev/null
+++ b/packages/client/src/pages/game/HUD.tsx
@@ -0,0 +1,46 @@
+import type { Ctx } from 'boardgame.io';
+import type { TriplanetaryState } from '@triplanetary/shared';
+
+interface Props {
+  G: TriplanetaryState;
+  ctx: Ctx;
+  playerID: string;
+  isActive: boolean;
+  onLockIn: () => void;
+}
+
+export default function HUD({ G, ctx, playerID, isActive, onLockIn }: Props) {
+  const shipIdx = Number(playerID);
+  const ship = G.ships[shipIdx];
+  const plot = G.plots[playerID];
+
+  return (
+    <div style={{ padding: '12px', background: '#111', color: '#eee', minWidth: 200 }}>
+      <p>
+        <strong>Turn {G.turnNumber}</strong> — {ctx.phase ?? 'astrogation'}
+      </p>
+
+      {ship && (
+        <p>
+          Fuel: {ship.fuel} / {ship.maxFuel}
+        </p>
+      )}
+
+      {G.winner !== null ? (
+        <p style={{ color: '#ffcc00', fontWeight: 'bold' }}>
+          {G.winner === playerID
+            ? 'You win!'
+            : G.winner === 'draw'
+              ? "It's a draw!"
+              : 'You lose.'}
+        </p>
+      ) : isActive && !plot ? (
+        <p>Select your ship, then click a destination to plot your course.</p>
+      ) : isActive && plot && !plot.locked ? (
+        <button onClick={onLockIn}>Lock In</button>
+      ) : plot?.locked ? (
+        <p>Waiting for opponent…</p>
+      ) : null}
+    </div>
+  );
+}
diff --git a/packages/client/src/pages/lobby/GameRoom.tsx b/packages/client/src/pages/lobby/GameRoom.tsx
index 7877eba..673418e 100644
--- a/packages/client/src/pages/lobby/GameRoom.tsx
+++ b/packages/client/src/pages/lobby/GameRoom.tsx
@@ -1,21 +1,48 @@
-import { useParams } from 'react-router-dom';
+import { useMemo } from 'react';
+import { useParams, Link } from 'react-router-dom';
+import { Client } from 'boardgame.io/react';
+import { SocketIO } from 'boardgame.io/multiplayer';
+import { TriplanetaryGame } from '@triplanetary/shared';
+import Board from '../game/Board';
 
-// Placeholder board component - Phase 1 will wire up boardgame.io Client
-function Board() {
-  return (
-    <div>
-      <p>Game board placeholder — Phase 1 will render the hex map here.</p>
-    </div>
-  );
+// Module-level singleton — avoids re-creating the client class on every render.
+const GameClient = Client({
+  game: TriplanetaryGame,
+  board: Board,
+  multiplayer: SocketIO({ server: '' }), // same origin — Vite proxies /socket.io → :8000
+  debug: false,
+});
+
+interface StoredSeat {
+  playerID: string;
+  credentials: string;
 }
 
 export default function GameRoom() {
   const { matchID } = useParams<{ matchID: string }>();
 
+  const stored = useMemo<StoredSeat | null>(() => {
+    if (!matchID) return null;
+    const raw = sessionStorage.getItem(`bgio-${matchID}`);
+    if (!raw) return null;
+    return JSON.parse(raw) as StoredSeat;
+  }, [matchID]);
+
+  if (!matchID) return <p>Missing match ID.</p>;
+
+  if (!stored) {
+    return (
+      <p>
+        No seat found for this match — <Link to="/lobby">return to lobby</Link>
+      </p>
+    );
+  }
+
   return (
-    <main>
-      <h1>Game {matchID}</h1>
-      <Board />
-    </main>
+    <GameClient
+      matchID={matchID}
+      playerID={stored.playerID}
+      credentials={stored.credentials}
+    />
   );
 }
diff --git a/packages/client/src/pages/lobby/LobbyPage.tsx b/packages/client/src/pages/lobby/LobbyPage.tsx
index 1bf0a4b..b3eef38 100644
--- a/packages/client/src/pages/lobby/LobbyPage.tsx
+++ b/packages/client/src/pages/lobby/LobbyPage.tsx
@@ -2,6 +2,19 @@ import { useState } from 'react';
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
 import { useNavigate } from 'react-router-dom';
 import { SCENARIOS } from '@triplanetary/shared';
+import { apiClient } from '../../lib/apiClient';
+import type { HexData } from '@triplanetary/shared';
+
+interface MapMeta {
+  id: string;
+  name: string;
+  isCanonical: boolean;
+}
+
+interface MapRow {
+  id: string;
+  data: HexData;
+}
 
 interface Match {
   matchID: string;
@@ -17,15 +30,78 @@ async function fetchMatches(): Promise<Match[]> {
   return data.matches ?? [];
 }
 
-async function createMatch(numPlayers: number): Promise<{ matchID: string }> {
-  const res = await fetch('/games/triplanetary/create', {
+async function fetchCanonicalMap(): Promise<HexData | null> {
+  const maps = await apiClient.get<MapMeta[]>('/maps');
+  const canonical = maps.find((m) => m.isCanonical);
+  if (!canonical) return null;
+  const row = await apiClient.get<MapRow>(`/maps/${canonical.id}`);
+  return row.data;
+}
+
+async function createAndJoin(
+  numPlayers: number,
+  mapData: HexData | null,
+  playerName: string,
+): Promise<{ matchID: string }> {
+  // 1. Create match with canonical map as setupData
+  const createRes = await fetch('/games/triplanetary/create', {
+    method: 'POST',
+    credentials: 'include',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ numPlayers, setupData: { mapData } }),
+  });
+  if (!createRes.ok) throw new Error('Failed to create match');
+  const { matchID } = (await createRes.json()) as { matchID: string };
+
+  // 2. Join as player 0
+  const joinRes = await fetch(`/games/triplanetary/${matchID}/join`, {
     method: 'POST',
     credentials: 'include',
     headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ numPlayers }),
+    body: JSON.stringify({ playerID: '0', playerName }),
   });
-  if (!res.ok) throw new Error('Failed to create match');
-  return res.json() as Promise<{ matchID: string }>;
+  if (!joinRes.ok) throw new Error('Failed to join match');
+  const { playerCredentials } = (await joinRes.json()) as { playerCredentials: string };
+
+  // 3. Store credentials in sessionStorage
+  sessionStorage.setItem(
+    `bgio-${matchID}`,
+    JSON.stringify({ playerID: '0', credentials: playerCredentials }),
+  );
+
+  return { matchID };
+}
+
+async function joinExistingMatch(
+  matchID: string,
+  playerName: string,
+): Promise<void> {
+  // Determine free seat
+  const matchRes = await fetch(`/games/triplanetary/${matchID}`, {
+    credentials: 'include',
+  });
+  if (!matchRes.ok) throw new Error('Failed to fetch match');
+  const matchData = (await matchRes.json()) as {
+    players: Array<{ id: number; name?: string }>;
+  };
+
+  const freeSeat = matchData.players.find((p) => !p.name);
+  if (!freeSeat) throw new Error('Match is full');
+  const playerID = String(freeSeat.id);
+
+  const joinRes = await fetch(`/games/triplanetary/${matchID}/join`, {
+    method: 'POST',
+    credentials: 'include',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ playerID, playerName }),
+  });
+  if (!joinRes.ok) throw new Error('Failed to join match');
+  const { playerCredentials } = (await joinRes.json()) as { playerCredentials: string };
+
+  sessionStorage.setItem(
+    `bgio-${matchID}`,
+    JSON.stringify({ playerID, credentials: playerCredentials }),
+  );
 }
 
 export default function LobbyPage() {
@@ -42,13 +118,26 @@ export default function LobbyPage() {
   const scenario = SCENARIOS.find((s) => s.id === selectedScenario);
 
   const createMutation = useMutation({
-    mutationFn: () => createMatch(scenario?.minPlayers ?? 2),
+    mutationFn: async () => {
+      const mapData = await fetchCanonicalMap();
+      return createAndJoin(scenario?.minPlayers ?? 2, mapData, 'Player 1');
+    },
     onSuccess: (data) => {
       queryClient.invalidateQueries({ queryKey: ['matches'] }).catch(() => undefined);
       navigate(`/game/${data.matchID}`);
     },
   });
 
+  const joinMutation = useMutation({
+    mutationFn: async (matchID: string) => {
+      await joinExistingMatch(matchID, 'Player 2');
+      return matchID;
+    },
+    onSuccess: (matchID) => {
+      navigate(`/game/${matchID}`);
+    },
+  });
+
   return (
     <main>
       <h1>Lobby</h1>
@@ -70,7 +159,12 @@ export default function LobbyPage() {
             <li key={match.matchID}>
               Match {match.matchID.slice(0, 8)}
               {' · '}
-              <button onClick={() => navigate(`/game/${match.matchID}`)}>Join</button>
+              <button
+                onClick={() => joinMutation.mutate(match.matchID)}
+                disabled={joinMutation.isPending}
+              >
+                Join
+              </button>
             </li>
           ))}
         </ul>
diff --git a/packages/client/vite.config.ts b/packages/client/vite.config.ts
index ff3f841..9cab078 100644
--- a/packages/client/vite.config.ts
+++ b/packages/client/vite.config.ts
@@ -4,6 +4,9 @@ import { resolve } from "node:path";
 
 export default defineConfig({
   plugins: [react()],
+  optimizeDeps: {
+    include: ['boardgame.io/react', 'boardgame.io/multiplayer'],
+  },
   resolve: {
     alias: {
       "@triplanetary/shared": resolve("../shared/src/index.ts"),
diff --git a/packages/shared/src/game/TriplanetaryGame.ts b/packages/shared/src/game/TriplanetaryGame.ts
index 2b10bb6..4103346 100644
--- a/packages/shared/src/game/TriplanetaryGame.ts
+++ b/packages/shared/src/game/TriplanetaryGame.ts
@@ -1,19 +1,76 @@
+import { Stage, INVALID_MOVE } from 'boardgame.io/core';
 import type { Game } from 'boardgame.io';
 import type { TriplanetaryState } from '../types/game';
+import { getValidDestinations, resolveMovement } from '../lib/movement';
 
 export const TriplanetaryGame: Game<TriplanetaryState> = {
   name: 'triplanetary',
 
-  setup: (): TriplanetaryState => ({
-    ships: [],
-    phase: 'lobby',
+  setup: (_ctx, setupData): TriplanetaryState => ({
+    ships: [
+      {
+        id: 'ship-0',
+        faction: 'mars',
+        position: [5, -3],
+        vector: [0, 0],
+        fuel: 6,
+        maxFuel: 6,
+        cs: 2,
+        pendingGravity: null,
+      },
+      {
+        id: 'ship-1',
+        faction: 'venus',
+        position: [-4, 2],
+        vector: [0, 0],
+        fuel: 6,
+        maxFuel: 6,
+        cs: 2,
+        pendingGravity: null,
+      },
+    ],
+    plots: {},
+    phase: 'astrogation',
+    turnNumber: 1,
+    winner: null,
+    mapSnapshot: (setupData as { mapData?: TriplanetaryState['mapSnapshot'] } | undefined)?.mapData ?? null,
+    scenarioId: 'bi-planetary',
   }),
 
-  moves: {
-    // Phase 1 will add plotCourse, lockIn, etc.
+  phases: {
+    astrogation: {
+      start: true,
+      turn: {
+        activePlayers: { all: Stage.NULL },
+      },
+      moves: {
+        plotCourse: ({ G, ctx }, destination: [number, number]) => {
+          const ship = G.ships[Number(ctx.currentPlayer)];
+          if (!ship) return INVALID_MOVE;
+          const valid = getValidDestinations(ship, G.mapSnapshot?.hexes ?? {});
+          if (!valid.has(`${destination[0]},${destination[1]}`)) return INVALID_MOVE;
+          G.plots[ctx.currentPlayer] = { destination, locked: false };
+        },
+
+        lockIn: ({ G, ctx, events }) => {
+          const plot = G.plots[ctx.currentPlayer];
+          if (!plot) return INVALID_MOVE;
+          plot.locked = true;
+          const allLocked = Object.keys(ctx.activePlayers ?? {})
+            .every(pid => G.plots[pid]?.locked === true);
+          if (allLocked) events.endPhase();
+        },
+      },
+
+      onEnd: ({ G }) => {
+        resolveMovement(G);
+      },
+
+      next: 'astrogation',
+    },
   },
 
-  turn: {
-    minMoves: 0,
+  endIf: ({ G }) => {
+    if (G.winner !== null) return { winner: G.winner };
   },
 };
diff --git a/packages/shared/src/index.ts b/packages/shared/src/index.ts
index 64bc7f2..f4471bc 100644
--- a/packages/shared/src/index.ts
+++ b/packages/shared/src/index.ts
@@ -4,3 +4,4 @@ export * from "./types/map";
 export * from "./constants/scenarios";
 export * from "./game/TriplanetaryGame";
 export * from "./lib/gravity";
+export * from "./lib/movement";
diff --git a/packages/shared/src/lib/__tests__/movement.test.ts b/packages/shared/src/lib/__tests__/movement.test.ts
new file mode 100644
index 0000000..ec9c5f9
--- /dev/null
+++ b/packages/shared/src/lib/__tests__/movement.test.ts
@@ -0,0 +1,424 @@
+import { describe, it, expect } from "vitest";
+import {
+  getValidDestinations,
+  checkLanding,
+  resolveMovement,
+  type MovementState,
+} from "../movement";
+import type { Ship } from "../../types/game";
+import type { HexData } from "../../types/map";
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+function makeShip(overrides: Partial<Ship> = {}): Ship {
+  return {
+    id: "ship-0",
+    faction: "mars",
+    position: [0, 0],
+    vector: [0, 0],
+    fuel: 6,
+    maxFuel: 6,
+    cs: 2,
+    pendingGravity: null,
+    ...overrides,
+  };
+}
+
+const MARS_HEX: [number, number] = [5, -3];
+const VENUS_HEX: [number, number] = [-4, 2];
+
+/** Minimal map with just the two planet hexes for landing tests. */
+const MINIMAL_MAP: HexData = {
+  meta: { name: "test", version: "1.0", hexSize: 48, orientation: "pointy" },
+  bodies: {
+    mars: { center: "5,-3", gravityRings: 1 },
+    venus: { center: "-4,2", gravityRings: 1 },
+  },
+  hexes: {
+    "5,-3": { type: "planet", body: "mars" },
+    "-4,2": { type: "planet", body: "venus" },
+  },
+  bases: {},
+};
+
+/** Map with a single gravity hex for testing gravity accumulation. */
+function mapWithGravity(hexKey: string, offset: [number, number]): HexData {
+  return {
+    ...MINIMAL_MAP,
+    hexes: {
+      ...MINIMAL_MAP.hexes,
+      [hexKey]: { type: "gravity", offset, manual: false },
+    },
+  };
+}
+
+function makeState(overrides: Partial<MovementState> = {}): MovementState {
+  return {
+    ships: [
+      makeShip({ id: "ship-0", faction: "mars", position: [5, -3] }),
+      makeShip({ id: "ship-1", faction: "venus", position: [-4, 2] }),
+    ],
+    plots: {},
+    mapSnapshot: MINIMAL_MAP,
+    turnNumber: 1,
+    winner: null,
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// getValidDestinations
+// ---------------------------------------------------------------------------
+
+describe("getValidDestinations", () => {
+  it("stationary ship with full fuel: coast = (0,0) + 6 neighbors", () => {
+    const ship = makeShip({ position: [0, 0], vector: [0, 0] });
+    const valid = getValidDestinations(ship, {});
+    expect(valid.size).toBe(7); // coast + 6 neighbors
+    expect(valid.has("0,0")).toBe(true);
+    expect(valid.has("1,0")).toBe(true);
+    expect(valid.has("0,1")).toBe(true);
+    expect(valid.has("-1,1")).toBe(true);
+    expect(valid.has("-1,0")).toBe(true);
+    expect(valid.has("0,-1")).toBe(true);
+    expect(valid.has("1,-1")).toBe(true);
+  });
+
+  it("ship with vector [1,0]: coast is (1,0), valid includes coast + neighbors", () => {
+    const ship = makeShip({ position: [0, 0], vector: [1, 0] });
+    const valid = getValidDestinations(ship, {});
+    expect(valid.has("1,0")).toBe(true); // coast
+    expect(valid.has("2,0")).toBe(true); // neighbor of coast
+    expect(valid.has("1,1")).toBe(true);
+    expect(valid.size).toBe(7);
+  });
+
+  it("ship with 0 fuel: only coast destination is valid", () => {
+    const ship = makeShip({ position: [0, 0], vector: [2, -1], fuel: 0 });
+    const valid = getValidDestinations(ship, {});
+    expect(valid.size).toBe(1);
+    expect(valid.has("2,-1")).toBe(true);
+  });
+
+  it("pendingGravity shifts the effective vector before computing coast", () => {
+    const ship = makeShip({
+      position: [0, 0],
+      vector: [1, 0],
+      pendingGravity: [0, 1],
+    });
+    const valid = getValidDestinations(ship, {});
+    // effective vector = [1+0, 0+1] = [1,1], coast = [1,1]
+    expect(valid.has("1,1")).toBe(true);
+    // [1,-1] is a neighbor of old coast [1,0] but NOT of new coast [1,1]
+    expect(valid.has("1,-1")).toBe(false);
+  });
+
+  it("null pendingGravity treated as [0,0]", () => {
+    const ship = makeShip({ position: [0, 0], vector: [0, 0], pendingGravity: null });
+    const valid = getValidDestinations(ship, {});
+    expect(valid.has("0,0")).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// checkLanding
+// ---------------------------------------------------------------------------
+
+describe("checkLanding", () => {
+  it("player 0 at venus hex returns true", () => {
+    expect(checkLanding(VENUS_HEX, "0", MINIMAL_MAP)).toBe(true);
+  });
+
+  it("player 0 at mars hex returns false (wrong target)", () => {
+    expect(checkLanding(MARS_HEX, "0", MINIMAL_MAP)).toBe(false);
+  });
+
+  it("player 1 at mars hex returns true", () => {
+    expect(checkLanding(MARS_HEX, "1", MINIMAL_MAP)).toBe(true);
+  });
+
+  it("player 1 at venus hex returns false (wrong target)", () => {
+    expect(checkLanding(VENUS_HEX, "1", MINIMAL_MAP)).toBe(false);
+  });
+
+  it("neither player at a random hex returns false", () => {
+    expect(checkLanding([0, 0], "0", MINIMAL_MAP)).toBe(false);
+    expect(checkLanding([0, 0], "1", MINIMAL_MAP)).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resolveMovement
+// ---------------------------------------------------------------------------
+
+describe("resolveMovement — coasting", () => {
+  it("coasting ship moves by its vector, fuel unchanged", () => {
+    const state = makeState({
+      ships: [
+        makeShip({ id: "ship-0", faction: "mars", position: [0, 0], vector: [1, 0], fuel: 6 }),
+        makeShip({ id: "ship-1", faction: "venus", position: [5, 5], vector: [0, 0], fuel: 6 }),
+      ],
+      plots: {
+        "0": { destination: [1, 0], locked: true },  // coast
+        "1": { destination: [5, 5], locked: true },  // coast (stationary)
+      },
+    });
+    resolveMovement(state);
+    expect(state.ships[0]!.position).toEqual([1, 0]);
+    expect(state.ships[0]!.fuel).toBe(6);
+    expect(state.ships[1]!.position).toEqual([5, 5]);
+    expect(state.ships[1]!.fuel).toBe(6);
+  });
+
+  it("coasting ship: vector updated to new velocity", () => {
+    const state = makeState({
+      ships: [
+        makeShip({ id: "ship-0", faction: "mars", position: [0, 0], vector: [2, -1], fuel: 6 }),
+        makeShip({ id: "ship-1", faction: "venus", position: [9, 9], vector: [0, 0], fuel: 3 }),
+      ],
+      plots: {
+        "0": { destination: [2, -1], locked: true },
+        "1": { destination: [9, 9], locked: true },
+      },
+    });
+    resolveMovement(state);
+    // new velocity = dest − old position = [2,-1] − [0,0] = [2,-1]
+    expect(state.ships[0]!.vector).toEqual([2, -1]);
+  });
+});
+
+describe("resolveMovement — thrusting", () => {
+  it("thrusting to non-coast hex costs 1 fuel", () => {
+    const state = makeState({
+      ships: [
+        makeShip({ id: "ship-0", faction: "mars", position: [0, 0], vector: [0, 0], fuel: 4 }),
+        makeShip({ id: "ship-1", faction: "venus", position: [9, 9], vector: [0, 0], fuel: 4 }),
+      ],
+      plots: {
+        "0": { destination: [1, 0], locked: true },  // thrust (coast was [0,0])
+        "1": { destination: [9, 9], locked: true },
+      },
+    });
+    resolveMovement(state);
+    expect(state.ships[0]!.position).toEqual([1, 0]);
+    expect(state.ships[0]!.fuel).toBe(3);
+  });
+
+  it("new velocity = destination − previous position", () => {
+    const state = makeState({
+      ships: [
+        makeShip({ id: "ship-0", faction: "mars", position: [2, 3], vector: [1, 0], fuel: 6 }),
+        makeShip({ id: "ship-1", faction: "venus", position: [9, 9], vector: [0, 0], fuel: 6 }),
+      ],
+      plots: {
+        "0": { destination: [4, 3], locked: true },  // thrust to [4,3] (coast was [3,3])
+        "1": { destination: [9, 9], locked: true },
+      },
+    });
+    resolveMovement(state);
+    expect(state.ships[0]!.vector).toEqual([2, 0]); // [4,3] − [2,3]
+  });
+});
+
+describe("resolveMovement — gravity", () => {
+  it("pendingGravity is applied to vector before thrust, then cleared", () => {
+    const state = makeState({
+      ships: [
+        makeShip({
+          id: "ship-0",
+          faction: "mars",
+          position: [0, 0],
+          vector: [1, 0],
+          fuel: 6,
+          pendingGravity: [0, 1],
+        }),
+        makeShip({ id: "ship-1", faction: "venus", position: [9, 9], vector: [0, 0], fuel: 6 }),
+      ],
+      plots: {
+        // effective vector after gravity = [1,1]; coast = [1,1]; player coasts
+        "0": { destination: [1, 1], locked: true },
+        "1": { destination: [9, 9], locked: true },
+      },
+    });
+    resolveMovement(state);
+    expect(state.ships[0]!.pendingGravity).toBeNull();
+    expect(state.ships[0]!.position).toEqual([1, 1]);
+    expect(state.ships[0]!.fuel).toBe(6); // coasting
+  });
+
+  it("ship arriving in gravity hex has pendingGravity set for next turn", () => {
+    const gravMap = mapWithGravity("1,0", [0, 1]);
+    const state = makeState({
+      ships: [
+        makeShip({ id: "ship-0", faction: "mars", position: [0, 0], vector: [1, 0], fuel: 6 }),
+        makeShip({ id: "ship-1", faction: "venus", position: [9, 9], vector: [0, 0], fuel: 6 }),
+      ],
+      plots: {
+        "0": { destination: [1, 0], locked: true },  // coast into gravity hex
+        "1": { destination: [9, 9], locked: true },
+      },
+      mapSnapshot: gravMap,
+    });
+    resolveMovement(state);
+    expect(state.ships[0]!.pendingGravity).toEqual([0, 1]);
+  });
+
+  it("ship leaving gravity hex clears pendingGravity", () => {
+    const state = makeState({
+      ships: [
+        makeShip({
+          id: "ship-0",
+          faction: "mars",
+          position: [0, 0],
+          vector: [1, 0],
+          fuel: 6,
+          pendingGravity: [-1, 0],
+        }),
+        makeShip({ id: "ship-1", faction: "venus", position: [9, 9], vector: [0, 0], fuel: 6 }),
+      ],
+      plots: {
+        "0": { destination: [0, 0], locked: true },  // lands on non-gravity hex
+        "1": { destination: [9, 9], locked: true },
+      },
+    });
+    resolveMovement(state);
+    expect(state.ships[0]!.pendingGravity).toBeNull();
+  });
+});
+
+describe("resolveMovement — win condition", () => {
+  it("player 0 landing on Venus wins", () => {
+    const state = makeState({
+      ships: [
+        makeShip({ id: "ship-0", faction: "mars", position: [-5, 2], vector: [1, 0], fuel: 6 }),
+        makeShip({ id: "ship-1", faction: "venus", position: [9, 9], vector: [0, 0], fuel: 6 }),
+      ],
+      plots: {
+        "0": { destination: [-4, 2], locked: true },  // Venus hex
+        "1": { destination: [9, 9], locked: true },
+      },
+    });
+    resolveMovement(state);
+    expect(state.winner).toBe("0");
+  });
+
+  it("player 1 landing on Mars wins", () => {
+    const state = makeState({
+      ships: [
+        makeShip({ id: "ship-0", faction: "mars", position: [0, 0], vector: [0, 0], fuel: 6 }),
+        makeShip({ id: "ship-1", faction: "venus", position: [4, -3], vector: [1, 0], fuel: 6 }),
+      ],
+      plots: {
+        "0": { destination: [0, 0], locked: true },
+        "1": { destination: [5, -3], locked: true },  // Mars hex
+      },
+    });
+    resolveMovement(state);
+    expect(state.winner).toBe("1");
+  });
+
+  it("both players landing simultaneously results in draw", () => {
+    const state = makeState({
+      ships: [
+        makeShip({ id: "ship-0", faction: "mars", position: [-5, 2], vector: [1, 0], fuel: 6 }),
+        makeShip({ id: "ship-1", faction: "venus", position: [4, -3], vector: [1, 0], fuel: 6 }),
+      ],
+      plots: {
+        "0": { destination: [-4, 2], locked: true },  // Venus
+        "1": { destination: [5, -3], locked: true },  // Mars
+      },
+    });
+    resolveMovement(state);
+    expect(state.winner).toBe("draw");
+  });
+
+  it("no winner yet: winner remains null and turnNumber increments", () => {
+    const state = makeState({
+      ships: [
+        makeShip({ id: "ship-0", faction: "mars", position: [0, 0], vector: [1, 0], fuel: 6 }),
+        makeShip({ id: "ship-1", faction: "venus", position: [9, 9], vector: [0, 0], fuel: 6 }),
+      ],
+      plots: {
+        "0": { destination: [1, 0], locked: true },
+        "1": { destination: [9, 9], locked: true },
+      },
+    });
+    resolveMovement(state);
+    expect(state.winner).toBeNull();
+    expect(state.turnNumber).toBe(2);
+  });
+
+  it("plots are cleared after resolution", () => {
+    const state = makeState({
+      ships: [
+        makeShip({ id: "ship-0", faction: "mars", position: [0, 0], vector: [0, 0], fuel: 6 }),
+        makeShip({ id: "ship-1", faction: "venus", position: [9, 9], vector: [0, 0], fuel: 6 }),
+      ],
+      plots: {
+        "0": { destination: [0, 0], locked: true },
+        "1": { destination: [9, 9], locked: true },
+      },
+    });
+    resolveMovement(state);
+    expect(Object.keys(state.plots)).toHaveLength(0);
+  });
+});
+
+describe("resolveMovement — integration (multi-turn)", () => {
+  it("ship coasts correctly over two turns with constant velocity", () => {
+    const state = makeState({
+      ships: [
+        makeShip({ id: "ship-0", faction: "mars", position: [0, 0], vector: [1, 0], fuel: 6 }),
+        makeShip({ id: "ship-1", faction: "venus", position: [9, 9], vector: [0, 0], fuel: 6 }),
+      ],
+      plots: {
+        "0": { destination: [1, 0], locked: true },
+        "1": { destination: [9, 9], locked: true },
+      },
+    });
+    resolveMovement(state);
+    expect(state.ships[0]!.position).toEqual([1, 0]);
+    expect(state.ships[0]!.vector).toEqual([1, 0]);
+
+    state.plots = {
+      "0": { destination: [2, 0], locked: true },
+      "1": { destination: [9, 9], locked: true },
+    };
+    resolveMovement(state);
+    expect(state.ships[0]!.position).toEqual([2, 0]);
+    expect(state.ships[0]!.fuel).toBe(6); // still no thrust
+  });
+
+  it("gravity applied on turn N+1 when ship entered gravity hex on turn N", () => {
+    const gravMap = mapWithGravity("1,0", [0, 1]);
+    const state = makeState({
+      ships: [
+        makeShip({ id: "ship-0", faction: "mars", position: [0, 0], vector: [1, 0], fuel: 6 }),
+        makeShip({ id: "ship-1", faction: "venus", position: [9, 9], vector: [0, 0], fuel: 6 }),
+      ],
+      plots: {
+        "0": { destination: [1, 0], locked: true },  // enter gravity hex
+        "1": { destination: [9, 9], locked: true },
+      },
+      mapSnapshot: gravMap,
+    });
+
+    // Turn 1: ship moves to gravity hex [1,0], pendingGravity set to [0,1]
+    resolveMovement(state);
+    expect(state.ships[0]!.position).toEqual([1, 0]);
+    expect(state.ships[0]!.pendingGravity).toEqual([0, 1]);
+
+    // Turn 2: gravity [0,1] is applied to vector [1,0] → effective [1,1]; coast = [2,1]
+    state.plots = {
+      "0": { destination: [2, 1], locked: true },  // coasting with gravity
+      "1": { destination: [9, 9], locked: true },
+    };
+    resolveMovement(state);
+    expect(state.ships[0]!.position).toEqual([2, 1]);
+    expect(state.ships[0]!.vector).toEqual([1, 1]); // [2,1] − [1,0]
+    expect(state.ships[0]!.pendingGravity).toBeNull(); // [2,1] is not a gravity hex
+    expect(state.ships[0]!.fuel).toBe(6);
+  });
+});
diff --git a/packages/shared/src/lib/movement.ts b/packages/shared/src/lib/movement.ts
new file mode 100644
index 0000000..95a7c3f
--- /dev/null
+++ b/packages/shared/src/lib/movement.ts
@@ -0,0 +1,165 @@
+import type { Ship } from "../types/game";
+import type { HexEntry, HexData } from "../types/map";
+
+// The 6 axial unit directions for pointy-top hexes.
+// Duplicated from gravity.ts to avoid a circular dependency refactor in Phase 1b.
+const AXIAL_DIRS: readonly [number, number][] = [
+  [1, 0],
+  [0, 1],
+  [-1, 1],
+  [-1, 0],
+  [0, -1],
+  [1, -1],
+] as const;
+
+/**
+ * Returns the set of valid destination hexes for a ship this turn.
+ *
+ * The ship can coast for free (predicted endpoint = position + effective vector)
+ * or burn 1 fuel to reach any of the 6 neighbors of the predicted endpoint.
+ * No hex-type filtering — all hexes are reachable in Bi-Planetary.
+ *
+ * @param ship   The ship being plotted.
+ * @param hexes  Current hex entries (used to determine gravity; may be empty in tests).
+ */
+export function getValidDestinations(
+  ship: Ship,
+  _hexes: Record<string, HexEntry>,
+): Set<string> {
+  // Effective vector = current velocity + pending gravity (already queued from last turn)
+  const grav = ship.pendingGravity ?? [0, 0];
+  const vq = ship.vector[0] + grav[0];
+  const vr = ship.vector[1] + grav[1];
+
+  // Predicted coast destination
+  const coastQ = ship.position[0] + vq;
+  const coastR = ship.position[1] + vr;
+
+  const valid = new Set<string>();
+  valid.add(`${coastQ},${coastR}`);
+
+  if (ship.fuel > 0) {
+    for (const [dq, dr] of AXIAL_DIRS) {
+      valid.add(`${coastQ + dq},${coastR + dr}`);
+    }
+  }
+
+  return valid;
+}
+
+/**
+ * Returns the target planet hex key for a given playerID in Bi-Planetary.
+ * Player '0' (Mars) must reach Venus; Player '1' (Venus) must reach Mars.
+ */
+function targetBody(playerID: string): string {
+  return playerID === "0" ? "venus" : "mars";
+}
+
+/**
+ * Returns true if the given position matches the planet hex of the target body
+ * for the specified player. Scans map.hexes dynamically so map edits propagate.
+ */
+export function checkLanding(
+  position: [number, number],
+  playerID: string,
+  map: HexData,
+): boolean {
+  const target = targetBody(playerID);
+  for (const [key, entry] of Object.entries(map.hexes)) {
+    if (entry.type === "planet" && entry.body === target) {
+      const [qStr, rStr] = key.split(",");
+      if (
+        position[0] === Number(qStr) &&
+        position[1] === Number(rStr)
+      ) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+export interface PlotMap {
+  [playerID: string]: { destination: [number, number]; locked: boolean };
+}
+
+export interface MovementState {
+  ships: Ship[];
+  plots: PlotMap;
+  mapSnapshot: HexData | null;
+  turnNumber: number;
+  winner: string | null;
+}
+
+/**
+ * Resolves one full movement turn for all players in order '0', '1'.
+ * Mutates the state object in-place (compatible with Immer drafts).
+ *
+ * Resolution order per ship:
+ *   1. Apply pendingGravity to velocity; clear pendingGravity.
+ *   2. Compute fuel cost (0 if coasting, 1 if thrusting).
+ *   3. Update velocity to the new vector (destination − position).
+ *   4. Move ship to destination.
+ *   5. Decrement fuel.
+ *   6. Record new pendingGravity if ship is now in a gravity hex.
+ *
+ * After all ships move, check for landings and update winner/turnNumber.
+ */
+export function resolveMovement(state: MovementState): void {
+  const winners: string[] = [];
+
+  for (const playerID of ["0", "1"] as const) {
+    const ship = state.ships[Number(playerID)];
+    const plot = state.plots[playerID];
+    if (!ship || !plot) continue;
+
+    // Step 1 — apply pending gravity to velocity
+    const grav = ship.pendingGravity ?? [0, 0];
+    ship.vector[0] += grav[0];
+    ship.vector[1] += grav[1];
+    ship.pendingGravity = null;
+
+    // Step 2 — cost: coast (no thrust) is free; any other destination costs 1 fuel
+    const coastQ = ship.position[0] + ship.vector[0];
+    const coastR = ship.position[1] + ship.vector[1];
+    const [destQ, destR] = plot.destination;
+    const isCoasting = destQ === coastQ && destR === coastR;
+    const fuelCost = isCoasting ? 0 : 1;
+
+    // Step 3 — new velocity = destination − current position
+    ship.vector[0] = destQ - ship.position[0];
+    ship.vector[1] = destR - ship.position[1];
+
+    // Step 4 — move
+    ship.position[0] = destQ;
+    ship.position[1] = destR;
+
+    // Step 5 — consume fuel
+    ship.fuel = Math.max(0, ship.fuel - fuelCost);
+
+    // Step 6 — record gravity in new hex (applied next turn)
+    const newKey = `${destQ},${destR}`;
+    const hexEntry = state.mapSnapshot?.hexes[newKey];
+    if (hexEntry?.type === "gravity" && hexEntry.offset) {
+      ship.pendingGravity = [hexEntry.offset[0], hexEntry.offset[1]];
+    } else {
+      ship.pendingGravity = null;
+    }
+
+    // Step 7 — check landing
+    if (state.mapSnapshot && checkLanding([destQ, destR], playerID, state.mapSnapshot)) {
+      winners.push(playerID);
+    }
+  }
+
+  // Determine winner
+  if (winners.length === 1) {
+    state.winner = winners[0]!;
+  } else if (winners.length === 2) {
+    state.winner = "draw";
+  }
+
+  // Advance turn and clear plots
+  state.plots = {};
+  state.turnNumber += 1;
+}
diff --git a/packages/shared/src/types/game.ts b/packages/shared/src/types/game.ts
index 8835d22..89d30c9 100644
--- a/packages/shared/src/types/game.ts
+++ b/packages/shared/src/types/game.ts
@@ -8,9 +8,22 @@ export interface Ship {
   position: [number, number];
   vector: [number, number];
   fuel: number;
+  maxFuel: number;
+  cs: number;
+  pendingGravity: [number, number] | null;
+}
+
+export interface PlotEntry {
+  destination: [number, number];
+  locked: boolean;
 }
 
 export interface TriplanetaryState {
   ships: Ship[];
+  plots: Record<string, PlotEntry>;
   phase: Phase;
+  turnNumber: number;
+  winner: string | null;
+  mapSnapshot: import('./map').HexData | null;
+  scenarioId: string;
 }