bug fix

Author: aki91-g

backend/app/game_manager.py

@@ -1,4 +1,3 @@
-import asyncio
 import random
 import string
 import time
@@ -47,8 +46,6 @@ def _expire_player_effects(status: PlayerStatus, now: float) -> None:
 class GameManager:
     def __init__(self, store: RedisStore) -> None:
         self._store = store
-        # Map data is immutable after creation — cache it in-process to avoid Redis GETs on every move.
-        self._map_cache: dict[str, MapData] = {}
 
     # ── create_room ───────────────────────────────────────────
 
@@ -71,7 +68,6 @@ async def create_room(self, sid: str) -> tuple[str, GameState, MapData]:
                 "score": {"red": 0, "blue": 0},
             }
             if await self._store.create_room_atomic(room_id, state, map_data, sid):
-                self._map_cache[room_id] = map_data
                 break
 
         return room_id, state, map_data
@@ -105,7 +101,6 @@ async def join_room(self, sid: str, room_id: str) -> tuple[GameState, MapData]:
             map_data = await self._store.load_map(room_id)
             if map_data is None:
                 raise GameError("room_not_found")
-            self._map_cache[room_id] = map_data
             return state, map_data
 
     # ── start_game ────────────────────────────────────────────
@@ -137,7 +132,7 @@ async def move_player(self, sid: str, direction: str) -> tuple[str, GameState] |
             return None
 
         try:
-            async with self._store.lock(room_id, timeout=2.0, blocking_timeout=0.5):
+            async with self._store.lock(room_id, timeout=5.0):
                 state = await self._store.load_state(room_id)
                 if state is None or state["status"] != "playing":
                     return None
@@ -146,12 +141,9 @@ async def move_player(self, sid: str, direction: str) -> tuple[str, GameState] |
                 if player is None:
                     return None
 
-                map_data = self._map_cache.get(room_id)
+                map_data = await self._store.load_map(room_id)
                 if map_data is None:
-                    map_data = await self._store.load_map(room_id)
-                    if map_data is None:
-                        return None
-                    self._map_cache[room_id] = map_data
+                    return None
 
                 now = time.time()
                 status = player["status"]
@@ -201,12 +193,11 @@ async def move_player(self, sid: str, direction: str) -> tuple[str, GameState] |
 
     async def tick(self, room_id: str) -> GameState | None:
         async with self._store.lock(room_id, blocking_timeout=0.5):
-            state, end_time = await asyncio.gather(
-                self._store.load_state(room_id),
-                self._store.get_game_end_time(room_id),
-            )
+            state = await self._store.load_state(room_id)
             if state is None or state["status"] != "playing":
                 return None
+
+            end_time = await self._store.get_game_end_time(room_id)
             if end_time is None:
                 return None
 
@@ -230,9 +221,7 @@ async def tick(self, room_id: str) -> GameState | None:
                     still_waiting.append(pending)
 
             if respawning:
-                map_data = self._map_cache.get(room_id) or await self._store.load_map(room_id)
-                if map_data is not None:
-                    self._map_cache[room_id] = map_data
+                map_data = await self._store.load_map(room_id)
                 if map_data is None:
                     # マップ取得失敗 → 次 tick で再試行
                     still_waiting.extend(respawning)
@@ -267,6 +256,9 @@ async def disconnect(self, sid: str) -> tuple[str | None, GameState | None]:
         if room_id is None:
             return None, None
 
+        if not await self._store.room_exists(room_id):
+            return room_id, None
+
         remaining: GameState | None = None
 
         async with self._store.lock(room_id):
@@ -278,7 +270,6 @@ async def disconnect(self, sid: str) -> tuple[str | None, GameState | None]:
 
             if not state["players"]:
                 await self._store.delete_room(room_id)
-                self._map_cache.pop(room_id, None)
                 remaining = None
             else:
                 if state["host"] == sid and state["status"] == "waiting":

backend/app/redis_store.py

@@ -1,7 +1,6 @@
+import json
 from typing import Optional
 
-import orjson
-
 import redis.asyncio as aioredis
 
 from app.models import GameState, MapData
@@ -34,28 +33,28 @@ async def create_room_atomic(
         """
         # SET NX で room_id の唯一性を保証
         room_set = await self._client.set(
-            f"room:{room_id}", orjson.dumps(state), nx=True, ex=ROOM_TTL
+            f"room:{room_id}", json.dumps(state), nx=True, ex=ROOM_TTL
         )
         if not room_set:
             return False
 
         # 成功したら map と sid をパイプラインで一括書き込み
         # (transaction=False: MULTI/EXEC を使わず RTT を 1 回に圧縮)
         async with self._client.pipeline(transaction=False) as pipe:
-            pipe.set(f"map:{room_id}", orjson.dumps(map_data), ex=MAP_TTL)
+            pipe.set(f"map:{room_id}", json.dumps(map_data), ex=MAP_TTL)
             pipe.set(f"sid:{sid}", room_id, ex=SID_TTL)
             await pipe.execute()
 
         return True
 
     async def save_state(self, room_id: str, state: GameState) -> None:
         await self._client.set(
-            f"room:{room_id}", orjson.dumps(state), ex=ROOM_TTL
+            f"room:{room_id}", json.dumps(state), ex=ROOM_TTL
         )
 
     async def load_state(self, room_id: str) -> Optional[GameState]:
         raw = await self._client.get(f"room:{room_id}")
-        return orjson.loads(raw) if raw else None
+        return json.loads(raw) if raw else None
 
     async def room_exists(self, room_id: str) -> bool:
         return bool(await self._client.exists(f"room:{room_id}"))
@@ -64,12 +63,12 @@ async def room_exists(self, room_id: str) -> bool:
 
     async def save_map(self, room_id: str, map_data: MapData) -> None:
         await self._client.set(
-            f"map:{room_id}", orjson.dumps(map_data), ex=MAP_TTL
+            f"map:{room_id}", json.dumps(map_data), ex=MAP_TTL
         )
 
     async def load_map(self, room_id: str) -> Optional[MapData]:
         raw = await self._client.get(f"map:{room_id}")
-        return orjson.loads(raw) if raw else None
+        return json.loads(raw) if raw else None
 
     # ── SID ↔ Room ────────────────────────────────────────────
 

backend/requirements.txt

@@ -4,4 +4,3 @@ python-socketio
 python-dotenv
 redis[asyncio]
 gunicorn
-orjson