refactor store

src/service/duel/gameMsg.ts

@@ -111,7 +111,7 @@ export default async function handleGameMsg(
 
   switch (msg.gameMsg) {
     case "start": {
-      await onMsgStart(msg.start);
+      await onMsgStart(container, msg.start);
 
       // We should init agent when the MSG_START reached.
       if (agent) await agent.init();
@@ -371,7 +371,7 @@ export default async function handleGameMsg(
       break;
     }
     case "sibyl_name": {
-      onMsgSibylName(msg.sibyl_name);
+      onMsgSibylName(container, msg.sibyl_name);
 
       break;
     }

src/service/duel/sibylName.ts

 import { ygopro } from "@/api";
-import { roomStore } from "@/stores";
+import { Container } from "@/container";
 type MsgSibylName = ygopro.StocGameMessage.MsgSibylName;
 
-export default (sibylName: MsgSibylName) => {
-  const me = roomStore.getMePlayer();
-  const op = roomStore.getOpPlayer();
+export default (container: Container, sibylName: MsgSibylName) => {
+  const context = container.context;
+  const me = context.roomStore.getMePlayer();
+  const op = context.roomStore.getOpPlayer();
   if (me) {
     me.name = sibylName.name_0;
   }

src/service/duel/start.ts

@@ -3,32 +3,35 @@ import { v4 as v4uuid } from "uuid";
 
 import { ygopro } from "@/api";
 import { useConfig } from "@/config";
+import { Container } from "@/container";
 import { sleep } from "@/infra";
 import {
   cardStore,
   matStore,
   replayStore,
   RoomStage,
-  roomStore,
   SideStage,
-  sideStore,
 } from "@/stores";
 import { replayStart } from "@/ui/Match/ReplayModal";
 
 import { genCard } from "../utils";
 const TOKEN_SIZE = 13; // 每人场上最多就只可能有13个token
 
-export default async (start: ygopro.StocGameMessage.MsgStart) => {
+export default async (
+  container: Container,
+  start: ygopro.StocGameMessage.MsgStart,
+) => {
+  const context = container.context;
   // 先初始化`matStore`
   matStore.selfType = start.playerType;
 
-  if (sideStore.stage !== SideStage.NONE) {
+  if (context.sideStore.stage !== SideStage.NONE) {
     // 更新Side状态
-    sideStore.stage = SideStage.DUEL_START;
+    context.sideStore.stage = SideStage.DUEL_START;
   } else {
     // 通知房间页面决斗开始
     // 这行在该函数中的位置不能随便放，否则可能会block住
-    roomStore.stage = RoomStage.DUEL_START;
+    context.roomStore.stage = RoomStage.DUEL_START;
   }
 
   matStore.initInfo.set(0, {

src/service/mora/deckCount.ts

 import { ygopro } from "@/api";
-import { roomStore } from "@/stores";
+import { Container } from "@/container";
 
 // TODO: 这里设置的player可能顺序会反
-export default function handleDeckCount(pb: ygopro.YgoStocMsg) {
+export default function handleDeckCount(
+  container: Container,
+  pb: ygopro.YgoStocMsg,
+) {
+  const context = container.context;
   const deckCount = pb.stoc_deck_count;
 
-  const me = roomStore.getMePlayer();
-  const op = roomStore.getOpPlayer();
+  const me = context.roomStore.getMePlayer();
+  const op = context.roomStore.getOpPlayer();
 
   if (me) {
     me.deckInfo = {

src/service/mora/selectHand.ts

 import { ygopro } from "@/api";
+import { Container } from "@/container";
 import { eventbus, Task } from "@/infra";
-import { RoomStage, roomStore } from "@/stores";
+import { RoomStage } from "@/stores";
 
-export default function handleSelectHand(_: ygopro.YgoStocMsg) {
-  roomStore.stage = RoomStage.HAND_SELECTING;
+export default function handleSelectHand(
+  container: Container,
+  _: ygopro.YgoStocMsg,
+) {
+  const context = container.context;
+  context.roomStore.stage = RoomStage.HAND_SELECTING;
   eventbus.emit(Task.Mora);
 }

src/service/mora/selectTp.ts

 import { ygopro } from "@/api";
+import { Container } from "@/container";
 import { eventbus, Task } from "@/infra";
-import { RoomStage, roomStore, SideStage, sideStore } from "@/stores";
+import { RoomStage, SideStage } from "@/stores";
 
-export default function handleSelectTp(_: ygopro.YgoStocMsg) {
-  if (sideStore.stage !== SideStage.NONE) {
-    sideStore.stage = SideStage.TP_SELECTING;
+export default function handleSelectTp(
+  container: Container,
+  _: ygopro.YgoStocMsg,
+) {
+  const context = container.context;
+  if (context.sideStore.stage !== SideStage.NONE) {
+    context.sideStore.stage = SideStage.TP_SELECTING;
   } else {
-    roomStore.stage = RoomStage.TP_SELECTING;
+    context.roomStore.stage = RoomStage.TP_SELECTING;
     eventbus.emit(Task.Tp);
   }
 }

src/service/onSocketMessage.ts

@@ -56,47 +56,47 @@ async function _handle(
 
     switch (pb.msg) {
       case "stoc_join_game": {
-        handleJoinGame(pb);
+        handleJoinGame(container, pb);
         break;
       }
       case "stoc_chat": {
-        handleChat(pb);
+        handleChat(container, pb);
         break;
       }
       case "stoc_hs_player_change": {
-        handleHsPlayerChange(pb);
+        handleHsPlayerChange(container, pb);
         break;
       }
       case "stoc_hs_watch_change": {
-        handleHsWatchChange(pb);
+        handleHsWatchChange(container, pb);
         break;
       }
       case "stoc_hs_player_enter": {
-        handleHsPlayerEnter(pb);
+        handleHsPlayerEnter(container, pb);
         break;
       }
       case "stoc_type_change": {
-        handleTypeChange(pb);
+        handleTypeChange(container, pb);
         break;
       }
       case "stoc_select_hand": {
-        handleSelectHand(pb);
+        handleSelectHand(container, pb);
         break;
       }
       case "stoc_hand_result": {
-        handleHandResult(pb);
+        handleHandResult(container, pb);
         break;
       }
       case "stoc_select_tp": {
-        handleSelectTp(pb);
+        handleSelectTp(container, pb);
         break;
       }
       case "stoc_deck_count": {
-        handleDeckCount(pb);
+        handleDeckCount(container, pb);
         break;
       }
       case "stoc_duel_start": {
-        handleDuelStart(pb);
+        handleDuelStart(container, pb);
         break;
       }
       case "stoc_duel_end": {
@@ -117,15 +117,15 @@ async function _handle(
         break;
       }
       case "stoc_error_msg": {
-        await handleErrorMsg(pb.stoc_error_msg);
+        await handleErrorMsg(container, pb.stoc_error_msg);
         break;
       }
       case "stoc_change_side": {
-        handleChangeSide(pb.stoc_change_side);
+        handleChangeSide(container, pb.stoc_change_side);
         break;
       }
       case "stoc_waiting_side": {
-        handleWaitingSide(pb.stoc_waiting_side);
+        handleWaitingSide(container, pb.stoc_waiting_side);
         break;
       }
       default: {

src/service/room/chat.ts

 import { ygopro } from "@/api";
+import { Container } from "@/container";
 import { AudioActionType, playEffect } from "@/infra/audio";
-import { chatStore } from "@/stores";
 
-export default function handleChat(pb: ygopro.YgoStocMsg) {
+export default function handleChat(
+  container: Container,
+  pb: ygopro.YgoStocMsg,
+) {
   playEffect(AudioActionType.SOUND_CHAT);
+  const context = container.context;
   const chat = pb.stoc_chat;
-  chatStore.message = chat.msg;
-  chatStore.sender = chat.player;
+  context.chatStore.message = chat.msg;
+  context.chatStore.sender = chat.player;
 }

src/service/room/duelStart.ts

 import { ygopro } from "@/api";
-import { RoomStage, roomStore, SideStage, sideStore } from "@/stores";
+import { Container } from "@/container";
+import { RoomStage, SideStage } from "@/stores";
 
-export default function handleDuelStart(_pb: ygopro.YgoStocMsg) {
-  if (sideStore.stage !== SideStage.NONE) {
-    sideStore.stage = SideStage.SIDE_CHANGED;
+export default function handleDuelStart(
+  container: Container,
+  _pb: ygopro.YgoStocMsg,
+) {
+  const context = container.context;
+  if (context.sideStore.stage !== SideStage.NONE) {
+    context.sideStore.stage = SideStage.SIDE_CHANGED;
   } else {
-    roomStore.stage = RoomStage.MORA;
+    context.roomStore.stage = RoomStage.MORA;
   }
 }

src/service/room/errorMsg.ts

 import { fetchCard, fetchStrings, Region, ygopro } from "@/api";
-import { roomStore } from "@/stores";
 import ErrorType = ygopro.StocErrorMsg.ErrorType;
+import { Container } from "@/container";
 import { AudioActionType, playEffect } from "@/infra/audio";
 
 // TODO: 是时候需要一个统一管理国际化文案的模块了
@@ -64,10 +64,15 @@ const messages: Record<
 };
 /* End of definition (I18N) */
 
-export default async function handleErrorMsg(errorMsg: ygopro.StocErrorMsg) {
+export default async function handleErrorMsg(
+  container: Container,
+  errorMsg: ygopro.StocErrorMsg,
+) {
   const { error_type, error_code } = errorMsg;
   playEffect(AudioActionType.SOUND_INFO);
 
+  const roomStore = container.context.roomStore;
+
   // Get the language from localStorage or default to 'cn' (I18N)
   const language = (localStorage.getItem("language") || "cn") as Language;
   const mainDeckWarning = messages[language].mainDeckWarning;

src/service/room/handResult.ts

 import { ygopro } from "@/api";
-import { roomStore } from "@/stores";
+import { Container } from "@/container";
 
-export default function handResult(pb: ygopro.YgoStocMsg) {
+export default function handResult(
+  container: Container,
+  pb: ygopro.YgoStocMsg,
+) {
   const msg = pb.stoc_hand_result;
-  const me = roomStore.getMePlayer();
-  const op = roomStore.getOpPlayer();
+  const context = container.context;
+  const me = context.roomStore.getMePlayer();
+  const op = context.roomStore.getOpPlayer();
 
   if (me && op) {
     me.moraResult = msg.meResult;
     op.moraResult = msg.opResult;
-  } else if (roomStore.selfType !== ygopro.StocTypeChange.SelfType.OBSERVER) {
+  } else if (
+    context.roomStore.selfType !== ygopro.StocTypeChange.SelfType.OBSERVER
+  ) {
     console.error("<HandResult>me or op is undefined");
   }
 }

src/service/room/hsPlayerChange.ts

 import { ygopro } from "@/api";
-import { roomStore } from "@/stores";
+import { Container } from "@/container";
 
-export default function handleHsPlayerChange(pb: ygopro.YgoStocMsg) {
+export default function handleHsPlayerChange(
+  container: Container,
+  pb: ygopro.YgoStocMsg,
+) {
   const change = pb.stoc_hs_player_change;
+  const context = container.context;
 
   if (change.pos > 1) {
     console.log("Currently only supported 2v2 mode.");
@@ -21,25 +25,26 @@ export default function handleHsPlayerChange(pb: ygopro.YgoStocMsg) {
             " moved to " +
             change.moved_pos,
         );
-        roomStore.players[change.moved_pos] = roomStore.players[change.pos];
-        roomStore.players[change.pos] = undefined;
+        context.roomStore.players[change.moved_pos] =
+          context.roomStore.players[change.pos];
+        context.roomStore.players[change.pos] = undefined;
         break;
       }
       case ygopro.StocHsPlayerChange.State.READY:
       case ygopro.StocHsPlayerChange.State.NO_READY: {
-        const player = roomStore.players[change.pos];
+        const player = context.roomStore.players[change.pos];
         if (player) {
           player.state = change.state;
         }
         break;
       }
       case ygopro.StocHsPlayerChange.State.LEAVE: {
-        roomStore.players[change.pos] = undefined;
+        context.roomStore.players[change.pos] = undefined;
         break;
       }
       case ygopro.StocHsPlayerChange.State.TO_OBSERVER: {
-        roomStore.players[change.pos] = undefined;
-        roomStore.observerCount += 1;
+        context.roomStore.players[change.pos] = undefined;
+        context.roomStore.observerCount += 1;
         break;
       }
       default: {

src/service/room/hsPlayerEnter.ts

 import { ygopro } from "@/api";
+import { Container } from "@/container";
 import { AudioActionType, playEffect } from "@/infra/audio";
-import { roomStore } from "@/stores";
 
-export default function handleHsPlayerEnter(pb: ygopro.YgoStocMsg) {
+export default function handleHsPlayerEnter(
+  container: Container,
+  pb: ygopro.YgoStocMsg,
+) {
   playEffect(AudioActionType.SOUND_PLAYER_ENTER);
   const name = pb.stoc_hs_player_enter.name;
   const pos = pb.stoc_hs_player_enter.pos;
+  const context = container.context;
 
-  const player = roomStore.players[pos];
+  const player = context.roomStore.players[pos];
 
   if (player) {
     player.name = name;
   } else {
-    roomStore.players[pos] = {
+    context.roomStore.players[pos] = {
       name,
       state: ygopro.StocHsPlayerChange.State.NO_READY,
     };

src/service/room/hsWatchChange.ts

 import { ygopro } from "@/api";
-import { roomStore } from "@/stores";
+import { Container } from "@/container";
 
-export default function handleHsWatchChange(pb: ygopro.YgoStocMsg) {
+export default function handleHsWatchChange(
+  container: Container,
+  pb: ygopro.YgoStocMsg,
+) {
   const count = pb.stoc_hs_watch_change.count;
-  roomStore.observerCount = count;
+  container.context.roomStore.observerCount = count;
 }

src/service/room/joinGame.ts

 import { ygopro } from "@/api";
-import { roomStore } from "@/stores";
+import { Container } from "@/container";
 
-export default function handleJoinGame(pb: ygopro.YgoStocMsg) {
+export default function handleJoinGame(
+  container: Container,
+  pb: ygopro.YgoStocMsg,
+) {
   const _msg = pb.stoc_join_game;
-  // TODO
-  roomStore.joined = true;
+  container.context.roomStore.joined = true;
 }

src/service/room/typeChange.ts

 import { ygopro } from "@/api";
-import { roomStore } from "@/stores";
 import SelfType = ygopro.StocTypeChange.SelfType;
+import { Container } from "@/container";
 
-export default function handleTypeChange(pb: ygopro.YgoStocMsg) {
+export default function handleTypeChange(
+  container: Container,
+  pb: ygopro.YgoStocMsg,
+) {
   const selfType = pb.stoc_type_change.self_type;
   const assertHost = pb.stoc_type_change.is_host;
+  const context = container.context;
 
-  roomStore.isHost = assertHost;
-  roomStore.selfType = selfType;
+  context.roomStore.isHost = assertHost;
+  context.roomStore.selfType = selfType;
 
   switch (selfType) {
     case SelfType.UNKNOWN: {
@@ -15,7 +19,7 @@ export default function handleTypeChange(pb: ygopro.YgoStocMsg) {
       break;
     }
     case SelfType.OBSERVER: {
-      roomStore.players.forEach((player) => {
+      context.roomStore.players.forEach((player) => {
         if (player) {
           player.isMe = false;
         }
@@ -23,13 +27,17 @@ export default function handleTypeChange(pb: ygopro.YgoStocMsg) {
       break;
     }
     default: {
-      const player = roomStore.players[selfType - 1];
+      const player = context.roomStore.players[selfType - 1];
       const state = ygopro.StocHsPlayerChange.State.NO_READY;
       if (player) {
         player.state = state;
         player.isMe = true;
       } else {
-        roomStore.players[selfType - 1] = { name: "?", state, isMe: true };
+        context.roomStore.players[selfType - 1] = {
+          name: "?",
+          state,
+          isMe: true,
+        };
       }
       break;
     }

src/service/side/changeSide.ts

 import { ygopro } from "@/api";
-import { SideStage, sideStore } from "@/stores";
-export function handleChangeSide(_: ygopro.StocChangeSide) {
-  sideStore.stage = SideStage.SIDE_CHANGING;
+import { Container } from "@/container";
+import { SideStage } from "@/stores";
+export function handleChangeSide(
+  container: Container,
+  _: ygopro.StocChangeSide,
+) {
+  container.context.sideStore.stage = SideStage.SIDE_CHANGING;
 }

src/service/side/waitingSide.ts

 import { ygopro } from "@/api";
-import { SideStage, sideStore } from "@/stores";
-export function handleWaitingSide(_: ygopro.StocWaitingSide) {
-  sideStore.stage = SideStage.WAITING;
+import { Container } from "@/container";
+import { SideStage } from "@/stores";
+export function handleWaitingSide(
+  container: Container,
+  _: ygopro.StocWaitingSide,
+) {
+  container.context.sideStore.stage = SideStage.WAITING;
 }

src/ui/Shared/chatHook.ts

@@ -6,6 +6,7 @@ import { useSnapshot } from "valtio";
 
 import { sendChat } from "@/api";
 import { getUIContainer } from "@/container/compat";
+// TODO: access store via `Container`
 import { chatStore, isMe, roomStore } from "@/stores";
 
 interface ChatItem {