feat(ui): работа с новыми классами состояний приложения

docs/protocol.md

@@ -0,0 +1,12 @@
+# Описание протокола
+## Формат сообщений
+```json
+{
+    "version": "1.0",
+    "id": 0,
+    "event": "role_changed",
+    "payload": {
+        "role": "NONE" 
+    }
+}
+```

src/mind_reader/core/__init__.py

@@ -1,5 +1,7 @@
-from mind_reader.core.game_state import GameState
+from .state import AppState, LobbyState, SessionState
 
 __all__ = [
-    "GameState",
+    "AppState",
+    "LobbyState",
+    "SessionState",
 ]

src/mind_reader/core/game_state.py

@@ -1,33 +0,0 @@
-class GameState:
-    def __init__(self, local_player_name: str):
-        self.local_player_name: str = local_player_name
-        self.remote_player_name: str | None = None
-        self.lobby_players: dict[str, str] = {self.local_player_name: "NONE"}
-
-    def add_remote_player(self, player_name: str):
-        self.remote_player_name = player_name
-        self.lobby_players[self.remote_player_name] = "NONE"
-
-    def delete_remote_player(self):
-        if self.remote_player_name in self.lobby_players:
-            del self.lobby_players[self.remote_player_name]
-        self.remote_player_name = None
-
-    def set_player_role(self, player_name: str, role: str) -> bool:
-        current_role = self.lobby_players.get(player_name)
-        if current_role == role:
-            return False
-
-        if role in ["NONE", "SETTER", "GUESSER"]:
-            self.lobby_players[player_name] = role
-            return True
-
-        return False
-
-    @property
-    def local_player_role(self) -> str:
-        return self.lobby_players[self.local_player_name]
-
-    def is_session_ready(self) -> bool:
-        roles = list(self.lobby_players.values())
-        return ("SETTER" in roles) and ("GUESSER" in roles)

src/mind_reader/core/state.py

@@ -0,0 +1,172 @@
+from typing import Callable, Optional
+
+from wx.lib.pubsub import pub
+
+from ..network import NetworkController, NetworkMesssage
+
+OnNetworkEventCallback = Callable[[dict[str, str]], None]
+
+
+class BaseState:
+    def __init__(self, app_state: "AppState"):
+        self.app_state = app_state
+
+    def handle_network_message(self, message: NetworkMesssage) -> None:
+        pass
+
+
+class LobbyState(BaseState):
+    def __init__(self, app_state: "AppState", local_player_name: str):
+        super().__init__(app_state)
+        self.local_player_name: str = local_player_name
+        self.remote_player_name: Optional[str] = None
+        self.players: dict[str, str] = {self.local_player_name: "NONE"}
+
+    def handle_network_message(self, message: NetworkMesssage) -> None:
+        callbacks: dict[str, OnNetworkEventCallback] = {
+            "add_player": self.handle_add_player,
+            "get_player": self.handle_get_player,
+            "set_role": self.handle_set_player_role,
+            "disconnect": self.handle_disconnect,
+            "server_stop": self.handle_server_stop,
+        }
+
+        callback = callbacks.get(message.event, None)
+        if callback:
+            callback(message.payload)
+            pub.sendMessage("lobby.refresh", state=self)
+
+    def send_local_player(self) -> None:
+        player_name = self.local_player_name
+        player_role = self.players.get(player_name, "NONE")
+
+        self.app_state.network.send(
+            "add_player",
+            {
+                "player_name": player_name,
+                "player_role": player_role,
+            },
+        )
+
+    def get_remote_player(self) -> None:
+        self.app_state.network.send("get_player")
+
+    def set_player_role(self, role: str) -> bool:
+        current_role = self.players[self.local_player_name]
+        result = False
+
+        if current_role == role:
+            result = False
+
+        if role in ["NONE", "SETTER", "GUESSER"]:
+            self.players[self.local_player_name] = role
+            result = True
+
+        if result:
+            if self.app_state.network.conn:
+                self.app_state.network.send(
+                    "set_role",
+                    {
+                        "player_name": self.local_player_name,
+                        "player_role": role,
+                    },
+                )
+
+        return result
+
+    def send_client_disconnect(self) -> None:
+        self.app_state.network.send(
+            "disconnect", {"player_name": self.local_player_name}
+        )
+
+    def send_server_stop(self) -> None:
+        self.app_state.network.send("server_stop")
+
+    def handle_add_player(self, payload: dict[str, str]) -> None:
+        player_name = payload["player_name"]
+        player_role = payload["player_role"]
+        self.remote_player_name = player_name
+        self.players[self.remote_player_name] = player_role
+
+    def handle_get_player(self, payload: dict[str, str]) -> None:
+        self.send_local_player()
+
+    def handle_set_player_role(self, payload: dict[str, str]) -> None:
+        player_name = payload["player_name"]
+        player_role = payload["player_role"]
+
+        self.players[player_name] = player_role
+
+    def handle_disconnect(self, payload: dict[str, str]) -> None:
+        player_name = payload["player_name"]
+        self.players.pop(player_name)
+        self.remote_player_name = None
+
+    def handle_server_stop(self, payload: dict[str, str]) -> None:
+        pub.sendMessage("mainframe.remote_server_stop", state=self.app_state)
+
+    @property
+    def local_player_role(self) -> str:
+        return self.players[self.local_player_name]
+
+    def is_ready(self) -> bool:
+        roles = list(self.players.values())
+        return ("SETTER" in roles) and ("GUESSER" in roles)
+
+
+class SessionState(BaseState):
+    def __init__(self, app_state: "AppState"):
+        super().__init__(app_state)
+
+
+class AppState:
+    def __init__(self):
+        self.network = NetworkController(
+            self.handle_network_message,
+            self.handle_network_notice,
+        )
+
+        self.lobby: Optional[LobbyState] = None
+        self.session: Optional[SessionState] = None
+
+    def handle_network_message(self, message: NetworkMesssage) -> None:
+        if self.lobby:
+            self.lobby.handle_network_message(message)
+
+        if self.session:
+            self.session.handle_network_message(message)
+
+    def handle_network_notice(self, notice: str) -> None:
+        pub.sendMessage("mainframe.statusbar", notice=notice)
+
+    def recreate_network_controller(self) -> None:
+        self.network.stop()
+        self.network = NetworkController(
+            self.handle_network_message,
+            self.handle_network_notice,
+        )
+
+    def connect(self, player_name: str, host: str, port: int = 8994) -> bool:
+        if self.network.connect(host, port):
+            self.lobby = LobbyState(self, player_name)
+            self.lobby.send_local_player()
+            self.lobby.get_remote_player()
+            return True
+        else:
+            self.recreate_network_controller()
+            return False
+
+    def serve(self, player_name: str, host: str, port: int = 8994) -> None:
+        self.network.serve(host, port)
+        self.lobby = LobbyState(self, player_name)
+
+    def disconnect(self) -> None:
+        if self.lobby:
+            if self.network.is_server:
+                self.lobby.send_server_stop()
+            else:
+                self.lobby.send_client_disconnect()
+
+            self.lobby = None
+
+        self.recreate_network_controller()

src/mind_reader/network/__init__.py

@@ -0,0 +1,7 @@
+from .controller import NetworkController
+from .protocol import NetworkMesssage
+
+__all__ = [
+    "NetworkController",
+    "NetworkMesssage",
+]

src/mind_reader/network/controller.py

@@ -0,0 +1,150 @@
+import socket
+import struct
+import threading
+from typing import Callable, Optional
+
+import wx
+
+from .protocol import NetworkMesssage
+
+OnMessageCallback = Callable[[NetworkMesssage], None]
+OnNoticeCallback = Callable[[str], None]
+
+
+def receive_exact(sock: socket.socket, n: int) -> Optional[bytes]:
+    data = bytearray()
+
+    while len(data) < n:
+        packet = sock.recv(n - len(data))
+        if not packet:
+            return None
+        data.extend(packet)
+
+    return bytes(data)
+
+
+class NetworkController(threading.Thread):
+    def __init__(
+        self,
+        on_message_callback: OnMessageCallback,
+        on_notice_callback: Optional[OnNoticeCallback] = None,
+    ):
+        super().__init__(daemon=True)
+        self.on_message_callback = on_message_callback
+        self.on_notice_callback = on_notice_callback
+
+        self.sock: Optional[socket.socket] = None
+        self.conn: Optional[socket.socket] = None
+
+        self.is_running: bool = False
+        self.is_server: bool = False
+
+    def serve(self, host: str = "0.0.0.0", port: int = 8994) -> None:
+        self.is_server = True
+
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self.sock.bind((host, port))
+        self.sock.listen(1)
+
+        self.is_running = True
+        self.start()
+
+    def connect(self, host: str, port: int = 8994) -> bool:
+        self.is_server = False
+
+        try:
+            self.conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.conn.connect((host, port))
+
+            self.is_running = True
+            self._notify("Connected to host")
+            self.start()
+            return True
+        except Exception as e:
+            self._notify(f"Connection failed: {e}")
+            return False
+
+    def send(self, event: str, payload: dict = {}) -> None:
+        if not self.conn or not self.is_running:
+            return
+
+        m = NetworkMesssage(event, payload)
+
+        try:
+            self.conn.sendall(m.encode())
+        except Exception as e:
+            self._notify(f"Send error: {e}")
+            self._close_active_connection()
+
+    def run(self) -> None:
+        HEADER_SIZE = 4
+
+        while self.is_running:
+            if self.is_server and self.sock and not self.conn:
+                self._notify("Waiting for peer to connect...")
+
+                try:
+                    self.conn, addr = self.sock.accept()
+                    self._notify(f"Peer connected from {addr[0]}:{addr[1]}")
+                except Exception:
+                    break
+
+            while self.is_running and self.conn:
+                try:
+                    header_bytes = receive_exact(self.conn, HEADER_SIZE)
+                    if not header_bytes:
+                        self._notify("Peer disconnected")
+                        break
+
+                    body_size = struct.unpack(">I", header_bytes)[0]
+
+                    body_bytes = receive_exact(self.conn, body_size)
+                    if not body_bytes:
+                        self._notify("Peer disconnected unexpectedly")
+                        break
+
+                    json_str = body_bytes.decode("utf-8")
+                    m = NetworkMesssage.from_json(json_str)
+
+                    wx.CallAfter(self.on_message_callback, m)
+
+                except Exception as e:
+                    self._notify(f"Read error: {e}")
+                    break
+
+            self._close_active_connection()
+
+            if not self.is_server:
+                break
+
+        self.stop()
+
+    def _close_active_connection(self) -> None:
+        if self.conn:
+            try:
+                self.conn.shutdown(socket.SHUT_RDWR)
+                self.conn.close()
+            except Exception:
+                pass
+            finally:
+                self.conn = None
+
+    def _notify(self, notice: str) -> None:
+        if self.on_notice_callback:
+            wx.CallAfter(self.on_notice_callback, notice)
+
+    def stop(self) -> None:
+        self.is_running = False
+
+        self._close_active_connection()
+
+        if self.sock:
+            try:
+                self.sock.close()
+            except Exception:
+                pass
+            finally:
+                self.sock = None
+
+        self._notify("Connection closed")

src/mind_reader/network/protocol.py

@@ -0,0 +1,46 @@
+import itertools
+import json
+import struct
+from dataclasses import dataclass, field
+
+_id_generator = itertools.count(0)
+
+
+@dataclass
+class NetworkMesssage:
+    event: str
+    payload: dict[str, str] = field(default_factory=dict)
+    id: int = field(default_factory=lambda: next(_id_generator))
+    version: str = "1.0"
+
+    def to_json(self) -> str:
+        return json.dumps(
+            {
+                "version": self.version,
+                "id": self.id,
+                "event": self.event,
+                "payload": self.payload,
+            },
+            ensure_ascii=False,
+        )
+
+    @classmethod
+    def from_json(cls, json_str: str) -> "NetworkMesssage":
+        data = json.loads(json_str)
+        return cls(
+            event=data.get("event", "unknown"),
+            payload=data.get("payload", {}),
+            id=data.get("id", -1),
+            version=data.get("version", "unknown"),
+        )
+
+    def encode(self) -> bytes:
+        raw_bytes = self.to_json().encode("utf-8")
+        length_prefix = struct.pack(">I", len(raw_bytes))
+        return length_prefix + raw_bytes
+
+
+if __name__ == "__main__":
+    for i in range(10):
+        message = NetworkMesssage("none")
+        print(message.encode())

src/mind_reader/ui/main_frame.py

@@ -1,9 +1,12 @@
-import wx
+from typing import Optional
 
-from mind_reader.core import GameState
+import wx
-from mind_reader.ui.dialogs import ClientConnectDialog, ServerStartDialog
+from wx.lib.pubsub import pub
-from mind_reader.ui.menu_bar import AppMenuBar
+
-from mind_reader.ui.views import LobbyPanel
+from ..core import AppState
+from ..ui.dialogs import ClientConnectDialog, ServerStartDialog
+from ..ui.menu_bar import AppMenuBar
+from ..ui.views import LobbyPanel
 
 
 class MainFrame(wx.Frame):
@@ -15,8 +18,9 @@ class MainFrame(wx.Frame):
             size=wx.Size(700, 500),
             style=wx.DEFAULT_FRAME_STYLE,
         )
-        self.state: GameState | None = None
+        self.state: AppState = AppState()
-        self.lobby_panel: LobbyPanel | None = None
+
+        self.lobby_panel: Optional[LobbyPanel] = None
 
         self.Center()
 
@@ -27,7 +31,8 @@ class MainFrame(wx.Frame):
         self.SetMenuBar(self.menu_bar)
 
         self.CreateStatusBar(1)
-        self.SetStatusText("Подключение отсутствует")
+        pub.subscribe(self.set_statusbar_text, "mainframe.statusbar")
+        pub.subscribe(self.remote_server_stop, "mainframe.remote_server_stop")
 
         self._bind_menu_events()
 
@@ -40,11 +45,17 @@ class MainFrame(wx.Frame):
             wx.EVT_MENU, self.on_disconnect, self.menu_bar.item_disconnect
         )
 
+    def set_statusbar_text(self, notice: str):
+        self.SetStatusText(notice)
+
+    def remote_server_stop(self, state: AppState):
+        self.on_disconnect(None)
+
     def _show_lobby(self):
         self._destroy_lobby()
 
-        if self.state:
+        if self.state.lobby:
-            self.lobby_panel = LobbyPanel(self, self.state)
+            self.lobby_panel = LobbyPanel(self, self.state.lobby)
             self.main_sizer.Add(self.lobby_panel, 1, wx.EXPAND)
             self.Layout()
 
@@ -57,32 +68,27 @@ class MainFrame(wx.Frame):
 
     def on_client_connect(self, event):
         d = ClientConnectDialog(self)
+
         if d.ShowModal() == wx.ID_OK:
-            name, ip = d.get_data()
+            player_name, ip = d.get_data()
-            self.state = GameState(name)
+            if self.state.connect(player_name, ip):
+                self.menu_bar.set_connected_state(True)
+                self._show_lobby()
 
-            self._show_lobby()
-
-            self.menu_bar.set_connected_state(True)
-            self.SetStatusText(f"Подключено к {ip} | Ваше имя {name}")
         d.Destroy()
 
     def on_server_start(self, event):
         d = ServerStartDialog(self)
-        if d.ShowModal() == wx.ID_OK:
-            name, ip = d.get_data()
-            self.state = GameState(name)
 
+        if d.ShowModal() == wx.ID_OK:
+            player_name, ip = d.get_data()
+            self.state.serve(player_name, ip)
+            self.menu_bar.set_connected_state(True)
             self._show_lobby()
 
-            self.menu_bar.set_connected_state(True)
-            self.SetStatusText(f"Сервер запущен на {ip} | Ваше имя {name}")
         d.Destroy()
 
     def on_disconnect(self, event):
         self._destroy_lobby()
-
+        self.state.disconnect()
-        self.state = None
-
         self.menu_bar.set_connected_state(False)
-        self.SetStatusText("Подключение отсутствует")

src/mind_reader/ui/views/lobby_view.py

@@ -1,16 +1,28 @@
-import wx
+from typing import Callable, Optional
 
-from mind_reader.core import GameState
+import wx
+from wx.lib.pubsub import pub
+
+from ...core import LobbyState
 
 
 class RoleColumn(wx.Panel):
-    def __init__(self, parent, role_key: str, button_label: str):
+    def __init__(
+        self,
+        parent,
+        role_key: str,
+        button_label: str,
+        on_role_selected: Optional[Callable[[str], None]] = None,
+    ):
         super().__init__(parent)
         self.role_key = role_key
+        self.on_role_selected = on_role_selected
+        self.is_active = False
 
         sizer = wx.BoxSizer(wx.VERTICAL)
 
-        self.button_select = wx.Button(self, label=button_label)
+        self.button_select = wx.ToggleButton(self, label=button_label)
+        self.button_select.Bind(wx.EVT_TOGGLEBUTTON, self._on_button_click)
         sizer.Add(self.button_select, 0, wx.EXPAND | wx.ALL, 5)
 
         self.list_players = wx.ListBox(self)
@@ -18,45 +30,51 @@ class RoleColumn(wx.Panel):
 
         self.SetSizer(sizer)
 
+    def _on_button_click(self, event):
+        if self.is_active:
+            self.button_select.SetValue(True)
+            return
+
+        if self.on_role_selected:
+            self.on_role_selected(self.role_key)
+
     def set_players(self, players: list[str]):
         self.list_players.Clear()
         if players:
             self.list_players.AppendItems(players)
 
-    def disable_on_role_match(self, role: str):
+    def set_role_state(self, role: str):
-        self.button_select.Enable(self.role_key != role)
+        self.is_active = self.role_key == role
+        self.button_select.SetValue(self.is_active)
 
 
 class LobbyPanel(wx.Panel):
-    def __init__(self, parent, state: GameState):
+    def __init__(self, parent, state: LobbyState):
         super().__init__(parent)
         self.state = state
-
         self._init_ui()
 
+        self.Bind(wx.EVT_WINDOW_DESTROY, self._on_destroy)
+
     def _init_ui(self):
         main_sizer = wx.BoxSizer(wx.VERTICAL)
 
         columns_sizer = wx.BoxSizer(wx.HORIZONTAL)
 
-        self.column_none = RoleColumn(self, "NONE", "👤 Без роли")
+        self.column_none = RoleColumn(
-        self.column_setter = RoleColumn(self, "SETTER", "🧠 Загадывает")
+            self, "NONE", "👤 Без роли", self._on_role_click
-        self.column_guesser = RoleColumn(self, "GUESSER", "🕵️ Угадывает")
+        )
+        self.column_setter = RoleColumn(
+            self, "SETTER", "🧠 Загадывает", self._on_role_click
+        )
+        self.column_guesser = RoleColumn(
+            self, "GUESSER", "🕵️ Угадывает", self._on_role_click
+        )
 
         columns_sizer.Add(self.column_none, 1, wx.EXPAND | wx.ALL, 5)
         columns_sizer.Add(self.column_setter, 1, wx.EXPAND | wx.ALL, 5)
         columns_sizer.Add(self.column_guesser, 1, wx.EXPAND | wx.ALL, 5)
 
-        self.column_none.button_select.Bind(
-            wx.EVT_BUTTON, lambda evt: self._on_role_click("NONE")
-        )
-        self.column_setter.button_select.Bind(
-            wx.EVT_BUTTON, lambda evt: self._on_role_click("SETTER")
-        )
-        self.column_guesser.button_select.Bind(
-            wx.EVT_BUTTON, lambda evt: self._on_role_click("GUESSER")
-        )
-
         self.button_start = wx.Button(self, label="➔ Начать сессию")
         self.button_start.Bind(wx.EVT_BUTTON, self._on_start_click)
 
@@ -67,12 +85,12 @@ class LobbyPanel(wx.Panel):
 
         self.SetSizer(main_sizer)
 
-        self.refresh_from_state()
+        pub.subscribe(self.refresh, "lobby.refresh")
+
+        self.refresh(self.state)
 
     def _on_role_click(self, target_role: str):
-        success = self.state.set_player_role(
+        success = self.state.set_player_role(target_role)
-            self.state.local_player_name, target_role
-        )
 
         if not success:
             wx.MessageBox(
@@ -82,15 +100,19 @@ class LobbyPanel(wx.Panel):
             )
             return
 
-        self.refresh_from_state()
+        self.refresh(self.state)
 
     def _on_start_click(self, event):
         wx.MessageBox("Сессия запущена!", "Старт", wx.OK | wx.ICON_INFORMATION)
 
-    def refresh_from_state(self):
+    def _on_destroy(self, event):
+        pub.unsubscribe(self.refresh, "lobby.refresh")
+        event.Skip()
+
+    def refresh(self, state: LobbyState):
         players_by_role = {"NONE": [], "SETTER": [], "GUESSER": []}
 
-        for player, role in self.state.lobby_players.items():
+        for player, role in state.players.items():
             if role in players_by_role:
                 players_by_role[role].append(player)
 
@@ -98,9 +120,9 @@ class LobbyPanel(wx.Panel):
         self.column_setter.set_players(players_by_role["SETTER"])
         self.column_guesser.set_players(players_by_role["GUESSER"])
 
-        local_player_role = self.state.local_player_role
+        local_player_role = state.local_player_role
-        self.column_none.disable_on_role_match(local_player_role)
+        self.column_none.set_role_state(local_player_role)
-        self.column_setter.disable_on_role_match(local_player_role)
+        self.column_setter.set_role_state(local_player_role)
-        self.column_guesser.disable_on_role_match(local_player_role)
+        self.column_guesser.set_role_state(local_player_role)
 
-        self.button_start.Enable(self.state.is_session_ready())
+        self.button_start.Enable(state.is_ready())