checkpoint; working position updates

1 files changed, 47 insertions, 30 deletions

diff --git a/kennel/engine/systems/network.py b/kennel/engine/systems/network.py
index 1c1d71c..d1542e9 100644
--- a/kennel/engine/systems/network.py
+++ b/kennel/engine/systems/network.py
@@ -1,7 +1,7 @@
 import asyncio
 from abc import abstractmethod
 from enum import Enum
-from typing import List, Optional
+from typing import List, Optional, Dict
 
 from kennel.app import logger
 from kennel.engine.entities.entity import Entity, EntityManager
@@ -55,7 +55,9 @@ class Event:
 
 
 class InitialStateEvent(Event):
-    def __init__(self, world_width: int, world_height: int, entities: List[Entity]):
+    def __init__(
+        self, world_width: int, world_height: int, entities: Dict[str, Entity]
+    ):
         self.world_width = world_width
         self.world_height = world_height
         self.entities = entities
@@ -63,7 +65,7 @@ class InitialStateEvent(Event):
             EventType.INITIAL_STATE,
             {
                 "world": {"width": world_width, "height": world_height},
-                "entities": [entity.to_dict() for entity in entities],
+                "entities": entities,
             },
         )
 
@@ -98,51 +100,66 @@ class EntityDeathEvent(Event):
 
 class Publishable:
     @abstractmethod
-    async def publish(self, event: Event):
+    async def publish(self, event: List[Event]):
         pass
 
 
-class EventProcessor:
+class UpstreamEventProcessor:
     @abstractmethod
     def accept(
-        self, entity_manager: EntityManager, event: Event | tuple[Event, str]
-    ) -> None:
+        self, entity_manager: EntityManager, client_event: tuple[Event, str]
+    ) -> Optional[Event]:
         pass
 
 
 class NetworkSystem(System):
-    def __init__(self, event_processor: EventProcessor):
+    event_processor: UpstreamEventProcessor
+    sever_events: List[Event]
+    client_upstream_events: List[tuple[Event, str]]
+    clients: Dict[str, tuple[Publishable, List[Event]]]
+
+    def __init__(self, upstream_event_processor: UpstreamEventProcessor):
         super().__init__(SystemType.NETWORK)
-        self.event_processor = event_processor
+        self.upstream_event_processor = upstream_event_processor
+
+        self.server_events = []  # events to propogate to the entire network
+        self.client_upstream_events = []  # events that come from the clients
 
-        self.events = []
-        self.client_events = []
         self.clients = {}
 
     async def update(self, entity_manager: EntityManager, delta_time: float) -> None:
-        if len(self.events) + len(self.client_events) == 0:
-            return
-        for event in self.events + self.client_events:
-            self.event_processor.accept(entity_manager, event)
-        client_sendable = self.events + [event for event, _ in self.client_events]
-        await asyncio.gather(
-            *[
-                client.publish(event)
-                for client in self.clients.values()
-                for event in client_sendable
-            ]
-        )
-        self.events = []
-        self.client_events = []
+        for event in self.client_upstream_events:
+            produced_event = self.upstream_event_processor.accept(entity_manager, event)
+            if produced_event is not None:
+                self.server_events.append(produced_event)
+        promises = [
+            client.publish(self.server_events + events)
+            for client, events in self.clients.values()
+            if len(self.server_events + events) > 0
+        ]
+        await asyncio.gather(*promises)
 
-    def client_event(self, client_id: str, event: Event) -> None:
-        self.client_events.append((event, client_id))
+        self.server_events = []
+        self.client_upstream_events = []
+        for client_id in self.clients.keys():
+            (client, _) = self.clients[client_id]
+            self.clients[client_id] = (client, [])
 
-    def add_event(self, event: Event) -> None:
-        self.events.append(event)
+    def server_global_event(self, event: Event) -> None:
+        self.server_events.append(event)
+
+    def client_upstream_event(self, client_id: str, event: Event) -> None:
+        self.client_upstream_events.append((event, client_id))
+
+    def client_downstream_event(self, client_id: str, event: Event) -> None:
+        if client_id not in self.clients:
+            logger.info(f"client {client_id} not found")
+            return
+        (client, events) = self.clients[client_id]
+        self.clients[client_id] = (client, events + [event])
 
     def add_client(self, client_id: str, client: Publishable) -> None:
-        self.clients[client_id] = client
+        self.clients[client_id] = (client, [])
 
     def remove_client(self, client_id: str) -> None:
         del self.clients[client_id]