chore(release): 4.65.0 [skip ci]

## [4.65.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.64.2...v4.65.0) (2025-10-22)

### Features

* **complement-race:** implement position broadcasting for ghost trains ([c5fba5b](c5fba5b7dd))

CHANGELOG.md

@@ -1,3 +1,24 @@
+## [4.65.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.64.2...v4.65.0) (2025-10-22)
+
+
+### Features
+
+* **complement-race:** implement position broadcasting for ghost trains ([c5fba5b](https://github.com/antialias/soroban-abacus-flashcards/commit/c5fba5b7dd0f36fd3bbe596409e01b0d3dbd4fbe))
+
+## [4.64.2](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.64.1...v4.64.2) (2025-10-22)
+
+
+### Bug Fixes
+
+* **complement-race:** use individual player positions for ghost trains ([00dc4b1](https://github.com/antialias/soroban-abacus-flashcards/commit/00dc4b1d06a4e1763deb16333a298145cafd9187))
+
+## [4.64.1](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.64.0...v4.64.1) (2025-10-22)
+
+
+### Bug Fixes
+
+* **complement-race:** use local player instead of first player for train display ([915d8a5](https://github.com/antialias/soroban-abacus-flashcards/commit/915d8a5343e70a30c7a82bed645e6628fcc08a86))
+
 ## [4.64.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.63.11...v4.64.0) (2025-10-22)
 
 

apps/web/src/app/arcade/complement-race/components/RaceTrack/GhostTrain.tsx

@@ -1,6 +1,6 @@
 'use client'
 
-import { useMemo, useRef } from 'react'
+import { useEffect, useMemo, useRef } from 'react'
 import type { PlayerState } from '@/arcade-games/complement-race/types'
 import type { RailroadTrackGenerator } from '../../lib/RailroadTrackGenerator'
 
@@ -43,6 +43,15 @@ export function GhostTrain({ player, trainPosition, trackGenerator, pathRef }: G
     }
   }, [trainPosition, pathRef])
 
+  // Log only once when this ghost train first renders
+  const hasLoggedRef = useRef(false)
+  useEffect(() => {
+    if (!hasLoggedRef.current && trainTransform.opacity > 0) {
+      console.log('[GhostTrain] rendering:', player.name, 'at position:', trainPosition.toFixed(1))
+      hasLoggedRef.current = true
+    }
+  }, [trainTransform.opacity, player.name, trainPosition])
+
   // Don't render if position data isn't ready
   if (trainTransform.opacity === 0) {
     return null

apps/web/src/app/arcade/complement-race/components/RaceTrack/SteamTrainJourney.tsx

@@ -1,7 +1,7 @@
 'use client'
 
 import { animated, useSpring } from '@react-spring/web'
-import { memo, useMemo, useRef, useState } from 'react'
+import { memo, useEffect, useMemo, useRef, useState } from 'react'
 import { useGameMode } from '@/contexts/GameModeContext'
 import { useUserProfile } from '@/contexts/UserProfileContext'
 import { useComplementRace } from '@/arcade-games/complement-race/Provider'
@@ -101,10 +101,20 @@ export function SteamTrainJourney({
   const { players } = useGameMode()
   const { profile: _profile } = useUserProfile()
 
-  // Get the first active player's emoji
+  // Get the LOCAL player's emoji (not just the first player!)
   const activePlayers = Array.from(players.values()).filter((p) => p.isActive)
-  const firstActivePlayer = activePlayers[0]
-  const playerEmoji = firstActivePlayer?.emoji ?? '👤'
+  const localPlayer = activePlayers.find((p) => p.isLocal)
+  const playerEmoji = localPlayer?.emoji ?? '👤'
+
+  // Log only when localPlayer changes
+  useEffect(() => {
+    console.log(
+      '[SteamTrainJourney] localPlayer:',
+      localPlayer?.name,
+      'isLocal:',
+      localPlayer?.isLocal
+    )
+  }, [localPlayer?.id, localPlayer?.name, localPlayer?.isLocal])
 
   const svgRef = useRef<SVGSVGElement>(null)
   const pathRef = useRef<SVGPathElement>(null)
@@ -165,14 +175,13 @@ export function SteamTrainJourney({
 
   // Memoize filtered passenger lists to avoid recalculating on every render
   // Arcade room multiplayer uses claimedBy/deliveredBy instead of isBoarded/isDelivered
-  // Only show passengers claimed by the first active player
+  // Only show passengers claimed by the LOCAL player
   const boardedPassengers = useMemo(
     () =>
       displayPassengers.filter(
-        (p) =>
-          p.claimedBy === firstActivePlayer?.id && p.claimedBy !== null && p.deliveredBy === null
+        (p) => p.claimedBy === localPlayer?.id && p.claimedBy !== null && p.deliveredBy === null
       ),
-    [displayPassengers, firstActivePlayer?.id]
+    [displayPassengers, localPlayer?.id]
   )
 
   const nonDeliveredPassengers = useMemo(
@@ -194,12 +203,28 @@ export function SteamTrainJourney({
 
   // Get other players for ghost trains (filter out local player)
   const otherPlayers = useMemo(() => {
-    if (!multiplayerState?.players || !localPlayerId) return []
-    return Object.entries(multiplayerState.players)
+    if (!multiplayerState?.players || !localPlayerId) {
+      return []
+    }
+
+    const filtered = Object.entries(multiplayerState.players)
       .filter(([playerId, player]) => playerId !== localPlayerId && player.isActive)
       .map(([_, player]) => player)
+
+    return filtered
   }, [multiplayerState?.players, localPlayerId])
 
+  // Log only when otherPlayers count changes
+  useEffect(() => {
+    console.log('[SteamTrainJourney] otherPlayers count:', otherPlayers.length)
+    if (otherPlayers.length > 0) {
+      console.log(
+        '[SteamTrainJourney] ghost positions:',
+        otherPlayers.map((p) => `${p.name}: ${p.position.toFixed(1)}`).join(', ')
+      )
+    }
+  }, [otherPlayers.length, otherPlayers])
+
   if (!trackData) return null
 
   return (
@@ -266,7 +291,7 @@ export function SteamTrainJourney({
           <GhostTrain
             key={player.id}
             player={player}
-            trainPosition={trainPosition} // For now, use same position calculation
+            trainPosition={player.position} // Use each player's individual position
             trackGenerator={trackGenerator}
             pathRef={pathRef}
           />

apps/web/src/arcade-games/complement-race/Provider.tsx

@@ -306,12 +306,18 @@ export function ComplementRaceProvider({ children }: { children: ReactNode }) {
 
   // Get local player ID
   const localPlayerId = useMemo(() => {
-    return activePlayers.find((id) => {
+    const foundId = activePlayers.find((id) => {
       const player = players.get(id)
       return player?.isLocal
     })
+    return foundId
   }, [activePlayers, players])
 
+  // Log only when localPlayerId changes
+  useEffect(() => {
+    console.log('[Provider] localPlayerId:', localPlayerId)
+  }, [localPlayerId])
+
   // Debug logging ref (track last logged values)
   const lastLogRef = useState({ key: '', count: 0 })[0]
 
@@ -558,6 +564,23 @@ export function ComplementRaceProvider({ children }: { children: ReactNode }) {
     }
   }, [multiplayerState.currentRoute, compatibleState.style, multiplayerState.passengers.length])
 
+  // Broadcast position to server for multiplayer ghost trains
+  useEffect(() => {
+    if (!compatibleState.isGameActive || compatibleState.style !== 'sprint') {
+      return
+    }
+
+    // Send position update every 200ms
+    const interval = setInterval(() => {
+      makeMove({
+        type: 'UPDATE_POSITION',
+        data: { position: clientPosition },
+      })
+    }, 200)
+
+    return () => clearInterval(interval)
+  }, [compatibleState.isGameActive, compatibleState.style, clientPosition, makeMove])
+
   // Keep lastLogRef for future debugging needs
   // (removed debug logging)
 

apps/web/src/arcade-games/complement-race/Validator.ts

@@ -97,6 +97,9 @@ export class ComplementRaceValidator
       case 'UPDATE_INPUT':
         return this.validateUpdateInput(state, move.playerId, move.data.input)
 
+      case 'UPDATE_POSITION':
+        return this.validateUpdatePosition(state, move.playerId, move.data.position)
+
       case 'CLAIM_PASSENGER':
         return this.validateClaimPassenger(
           state,
@@ -397,6 +400,39 @@ export class ComplementRaceValidator
     return { valid: true, newState }
   }
 
+  private validateUpdatePosition(
+    state: ComplementRaceState,
+    playerId: string,
+    position: number
+  ): ValidationResult {
+    if (state.gamePhase !== 'playing') {
+      return { valid: false, error: 'Game not in playing phase' }
+    }
+
+    const player = state.players[playerId]
+    if (!player) {
+      return { valid: false, error: 'Player not found' }
+    }
+
+    // Validate position is a reasonable number (0-100)
+    if (typeof position !== 'number' || position < 0 || position > 100) {
+      return { valid: false, error: 'Invalid position value' }
+    }
+
+    const newState: ComplementRaceState = {
+      ...state,
+      players: {
+        ...state.players,
+        [playerId]: {
+          ...player,
+          position,
+        },
+      },
+    }
+
+    return { valid: true, newState }
+  }
+
   // ==========================================================================
   // Sprint Mode: Passenger Management
   // ==========================================================================

apps/web/src/arcade-games/complement-race/types.ts

@@ -143,6 +143,7 @@ export type ComplementRaceMove = BaseGameMove &
     // Playing phase
     | { type: 'SUBMIT_ANSWER'; data: { answer: number; responseTime: number } }
     | { type: 'UPDATE_INPUT'; data: { input: string } } // Show "thinking" indicator
+    | { type: 'UPDATE_POSITION'; data: { position: number } } // Sprint mode: sync train position
     | { type: 'CLAIM_PASSENGER'; data: { passengerId: string; carIndex: number } } // Sprint mode: pickup
     | { type: 'DELIVER_PASSENGER'; data: { passengerId: string } } // Sprint mode: delivery
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "soroban-monorepo",
-  "version": "4.64.0",
+  "version": "4.65.0",
   "private": true,
   "description": "Beautiful Soroban Flashcard Generator - Monorepo",
   "workspaces": [