improve event parsing and begin sending events from the client
continuous-integration/drone/pr Build is failing Details

This commit is contained in:
Elizabeth Hunt 2024-08-24 19:11:26 -07:00
parent b144ad5df7
commit a0a2068b66
14 changed files with 284 additions and 82 deletions

View File

@ -12,5 +12,5 @@ class Component:
self.component_type = component_type
@abstractmethod
def dict(self) -> dict:
def to_dict(self) -> dict:
pass

View File

@ -9,6 +9,6 @@ class Controllable(Component):
def __repr__(self) -> str:
return f"Controllable(by={self.by})"
def dict(self) -> dict:
def to_dict(self) -> dict:
# don't serialize who owns this
return {}

View File

@ -10,5 +10,5 @@ class Position(Component):
def __repr__(self) -> str:
return f"Position(x={self.x}, y={self.y})"
def dict(self) -> dict:
def to_dict(self) -> dict:
return {"x": self.x, "y": self.y}

View File

@ -27,7 +27,7 @@ class Entity:
return {
"entity_type": self.entity_type,
"id": self.id,
"components": {k: v.dict() for k, v in self.components.items()},
"components": {k: v.to_dict() for k, v in self.components.items()},
}

View File

@ -1,15 +1,17 @@
from enum import Enum
from kennel.engine.entities.entity import EntityManager
from kennel.engine.entities.entity import Entity, EntityType, EntityManager
from .system import System, SystemType
from abc import abstractmethod
from typing import Optional, List
import asyncio
class EventType(str, Enum):
INITIAL_STATE = "INITIAL_STATE"
SET_CONTROLLABLE = "SET_CONTROLLABLE"
ENTITY_BORN = "ENTITY_BORN"
ENTITY_POSITION_UPDATE = "ENTITY_POSITION_UPDATE"
ENTITY_DEATH = "ENTITY_DEATH"
ENTITY_POSITION_UPDATE = "ENTITY_POSITION_UPDATE"
class Event:
@ -17,29 +19,86 @@ class Event:
self.event_type = event_type
self.data = data
def __str__(self):
def __str__(self) -> str:
return f"Event({self.event_type}, {self.data})"
def dict(self):
def to_dict(self) -> dict:
return {"event_type": self.event_type, "data": self.data}
@staticmethod
def from_dict(data: dict):
def from_dict(data: dict) -> Optional["Event"]:
if "event_type" not in data or "data" not in data:
return
event_type = data["event_type"]
if event_type == EventType.INITIAL_STATE:
return InitialStateEvent(
data["data"]["world"]["width"],
data["data"]["world"]["height"],
data["data"]["entities"],
)
if event_type == EventType.SET_CONTROLLABLE:
return SetControllableEvent(data["data"]["id"], data["data"]["client_id"])
if event_type == EventType.ENTITY_BORN:
return EntityBornEvent(data["data"])
if event_type == EventType.ENTITY_POSITION_UPDATE:
return EntityPositionUpdateEvent(
data["data"]["id"], data["data"]["position"]
)
if event_type == EventType.ENTITY_DEATH:
return EntityDeathEvent(data["data"]["id"])
logger.warn(f"Unknown event type: {data['event_type']}")
return Event(EventType(data["event_type"]), data["data"])
class InitialStateEvent(Event):
def __init__(self, world_width: int, world_height: int, entities: List[Entity]):
self.world_width = world_width
self.world_height = world_height
self.entities = entities
super().__init__(
EventType.INITIAL_STATE,
{
"world": {"width": world_width, "height": world_height},
"entities": [entity.to_dict() for entity in entities],
},
)
class SetControllableEvent(Event):
def __init__(self, entity_id: str, client_id: str):
self.entity_id = entity_id
self.client_id = client_id
super().__init__(
EventType.SET_CONTROLLABLE, {"id": entity_id, "client_id": client_id}
)
class EntityBornEvent(Event):
def __init__(self, entity: Entity):
self.entity = entity
super().__init__(EventType.ENTITY_BORN, {"entity": entity.to_dict()})
class EntityPositionUpdateEvent(Event):
def __init__(self, entity_id: str, position: dict):
super().__init__(
EventType.ENTITY_POSITION_UPDATE,
{"id": entity_id, "position": position},
)
class EntityDeathEvent(Event):
def __init__(self, entity_id: str):
super().__init__(EventType.ENTITY_DEATH, {"id": entity_id})
class Publishable:
@abstractmethod
async def publish(self, event: Event):
pass
class ClientEventTransformer:
@abstractmethod
def apply(self, event: Event) -> Event:
pass
class EventProcessor:
@abstractmethod
def accept(self, entity_manager: EntityManager, event: Event) -> None:
@ -47,37 +106,32 @@ class EventProcessor:
class NetworkSystem(System):
def __init__(
self,
event_processor: EventProcessor,
client_event_transformer: ClientEventTransformer,
):
def __init__(self, event_processor: EventProcessor):
super().__init__(SystemType.NETWORK)
self.event_processor = event_processor
self.client_event_transformer = client_event_transformer
self.events = []
self.client_events = []
self.clients = {}
async def update(self, entity_manager: EntityManager, delta_time: float) -> None:
for event in self.events:
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_events = [
self.client_event_transformer.apply(entity_manager, event)
for event in self.events
]
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_events
for event in client_sendable
]
)
self.events = []
self.client_events = []
def client_event(self, client_id: str, event: Event) -> None:
event.data["client_id"] = client_id
self.events.append(event)
self.client_events.append((event, client_id))
def add_event(self, event: Event) -> None:
self.events.append(event)

View File

@ -6,7 +6,6 @@ from kennel.engine.systems.system import SystemManager
from kennel.engine.systems.network import (
NetworkSystem,
EventProcessor,
ClientEventTransformer,
Event,
EventType,
)
@ -21,28 +20,33 @@ system_manager = SystemManager()
class KennelEventProcessor(EventProcessor):
def accept(self, entity_manager: EntityManager, event: Event) -> None:
def accept(
self, entity_manager: EntityManager, event: type[Event | tuple[Event, str]]
) -> None:
if isinstance(event, tuple):
client_event, client_id = event
self._process_client_event(entity_manager, client_event, client_id)
return
def _process_client_event(
self, entity_manager: EntityManager, event: Event, client_id: str
) -> None:
if event.event_type == EventType.ENTITY_POSITION_UPDATE:
self._process_entity_position_update(entity_manager, event)
self._process_entity_position_update(entity_manager, event, client_id)
def _process_entity_position_update(
self, entity_manager: EntityManager, event: Event
self, entity_manager: EntityManager, event: Event, client_id: str
) -> None:
entity = entity_manager.get_entity(event.data["entity_id"])
entity = entity_manager.get_entity(event.data["id"])
if entity is None:
logger.error(f"Entity {event.data['entity_id']} does not exist")
return
if event.data["client_id"] is None:
logger.error("Client ID is required for position updates")
logger.error(f"Entity(id={event.data['id']}) does not exist")
return
controllable = entity.get_component(ComponentType.CONTROLLABLE)
if controllable is None:
logger.error(f"Entity {entity} is not controllable")
return
if controllable.by != event.data["client_id"]:
logger.error(
f"Entity {entity} is not controllable by client {event.data['client_id']}"
)
if controllable.by != client_id:
logger.error(f"Entity {entity} is not controllable by client {client_id}")
return
position = entity.get_component(ComponentType.POSITION)
if position is None:
@ -51,30 +55,14 @@ class KennelEventProcessor(EventProcessor):
entity.add_component(position)
class KennelClientEventTransformer(ClientEventTransformer):
def apply(self, entity_manager: EntityManager, event: Event) -> Event:
if event.event_type == EventType.ENTITY_BORN:
id = event.data["id"]
entity = entity_manager.get_entity(id)
if entity is None:
logger.error(f"Entity {id} does not exist")
return event
for component_type in entity.components:
component = entity.get_component(component_type)
if component is not None:
event.data[component_type] = component.dict()
return event
system_manager.add_system(WorldSystem(config.WORLD_WIDTH, config.WORLD_HEIGHT))
system_manager.add_system(
NetworkSystem(EventProcessor(), KennelClientEventTransformer()),
NetworkSystem(KennelEventProcessor()),
)
kennel = Game(entity_manager, system_manager, config.MIN_TIME_STEP)
def create_session_controllable_entities(session: str) -> List[Entity]:
laser = Laser(uuid.uuid4().hex, session)
laser = Laser(uuid.uuid4().hex[:10], session)
return [laser]

View File

@ -11,7 +11,14 @@ from fastapi import (
from fastapi.responses import FileResponse
from fastapi.staticfiles import StaticFiles
from kennel.engine.systems.system import SystemType
from kennel.engine.systems.network import Event, Publishable, EventType
from kennel.engine.systems.network import (
Event,
Publishable,
EventType,
InitialStateEvent,
SetControllableEvent,
EntityBornEvent,
)
from typing import Annotated, Optional
from kennel.kennel import (
kennel,
@ -76,7 +83,7 @@ class WebSocketClient(Publishable):
self.websocket = websocket
async def publish(self, event: Event):
await self.websocket.send_json(event.dict())
await self.websocket.send_json([event.event_type, event.data])
@app.websocket("/ws")
@ -85,19 +92,16 @@ async def websocket_endpoint(
session: Annotated[str, Depends(get_cookie_or_token)],
):
await websocket.accept()
client = WebSocketClient(websocket)
logger.info(f"Websocket connection established for session {session}")
await websocket.send_json(
{
"event_type": EventType.INITIAL_STATE,
"data": {
"world": {"width": config.WORLD_WIDTH, "height": config.WORLD_HEIGHT},
"entities": kennel.entity_manager.to_dict(),
},
}
initial_state = InitialStateEvent(
config.WORLD_WIDTH, config.WORLD_HEIGHT, kennel.entity_manager.to_dict()
)
await client.publish(initial_state)
session_entities = create_session_controllable_entities(session)
logger.info(f"Creating {len(session_entities)} entities for session {session}")
try:
network_system = system_manager.get_system(SystemType.NETWORK)
if network_system is None:
@ -106,14 +110,26 @@ async def websocket_endpoint(
for entity in session_entities:
logger.info(f"Adding entity {entity.id} for session {session}")
entity_manager.add_entity(entity)
network_system.add_event(Event(EventType.ENTITY_BORN, {"id": entity.id}))
network_system.add_event(EntityBornEvent(entity))
set_controllable_event = SetControllableEvent(entity.id, session)
await client.publish(set_controllable_event)
network_system.add_client(session, WebSocketClient(websocket))
while True:
message = await websocket.receive_json()
network_system.client_event(session, Event.from_dict(message))
if type(message) is not list:
message = [message]
events = [Event.from_dict(event) for event in message]
if not all([event is not None for event in events]):
logger.info(f"Invalid events in: {message}"[:100])
continue
for event in events:
network_system.client_event(session, event)
except WebSocketDisconnect as e:
logger.info(f"Websocket connection closed by client: {session}")
except Exception as e:
logger.error(f"WebSocket exception {e}")
logger.error("Exception occurred", exc_info=e)
finally:
logger.info("Websocket connection closed")
for entity in session_entities:

8
static/src/component.ts Normal file
View File

@ -0,0 +1,8 @@
export enum ComponentType {
POSITION = "POSITION",
RENDERABLE = "RENDERABLE",
}
export interface Component {
name: string;
}

11
static/src/entity.ts Normal file
View File

@ -0,0 +1,11 @@
import type { Component } from "./component";
export enum EntityType {
LASER = "LASER",
}
export interface Entity {
entity_type: EntityType;
id: string;
components: Record<string, Component>;
}

28
static/src/event.ts Normal file
View File

@ -0,0 +1,28 @@
export enum EventType {
INITIAL_STATE = "INITIAL_STATE",
SET_CONTROLLABLE = "SET_CONTROLLABLE",
ENTITY_BORN = "ENTITY_BORN",
ENTITY_DEATH = "ENTITY_DEATH",
ENTITY_POSITION_UPDATE = "ENTITY_POSITION_UPDATE",
}
export interface Event {
event_type: EventType;
data: any;
}
export interface InitialStateEvent extends Event {
event_type: EventType.INITIAL_STATE;
data: {
world: { width: number; height: number };
entities: any[];
};
}
export interface SetControllableEvent extends Event {
event_type: EventType.SET_CONTROLLABLE;
data: {
id: string;
client_id: string;
};
}

View File

@ -1,18 +1,51 @@
import $ from "jquery";
import { Vec2 } from "./vector";
import { EventType, type SetControllableEvent, type Event } from "./event";
import { MouseController } from "./mouse_controller";
$(document).ready(async () => {
await fetch("/assign", {
const session_id = await fetch("/assign", {
credentials: "include",
})
.then((res) => res.json())
.then(({ session }) => session);
const controllable_entities = new Set<string>();
const control_callback = (movement: Vec2) => {
for (const id of controllable_entities) {
const message = JSON.stringify({
event_type: EventType.ENTITY_POSITION_UPDATE,
data: { id, position: movement },
});
ws.send(message);
}
};
const mouse_controller = new MouseController(control_callback);
$(document).on("mousemove", (event) => {
mouse_controller.move(event.clientX, event.clientY);
});
mouse_controller.start();
const ws = new WebSocket("/ws");
ws.onopen = () => {
console.log("connected");
};
await new Promise<void>((resolve) => {
ws.onopen = () => {
console.log("connected");
resolve();
};
});
ws.onmessage = ({ data }) => {
console.log(JSON.parse(data));
const [event_type, event_data] = JSON.parse(data);
const message = { event_type, data: event_data } as Event;
console.log("Received message", message);
if (message.event_type === EventType.SET_CONTROLLABLE) {
const event = message as SetControllableEvent;
if (event.data.client_id === session_id) {
controllable_entities.add(event.data.id);
}
}
};
ws.onclose = (e) => {
console.log("disconnected", e);
ws.onclose = () => {
controllable_entities.clear();
};
});

View File

@ -0,0 +1,54 @@
import { Vec2 } from "./vector";
export class MouseController {
private readonly debounce_ms = 400;
private readonly movement_threshold = 40;
private last_event_time = Date.now();
private movement_queue: Vec2[] = [];
private interval_id: number | null = null;
constructor(private readonly callback: (new_movement: Vec2) => void) {}
public start() {
if (this.interval_id !== null) {
return;
}
this.interval_id = setInterval(() => {
this.publish_movement();
}, this.debounce_ms);
}
public stop() {
if (this.interval_id === null) {
return;
}
clearInterval(this.interval_id);
this.interval_id = null;
}
public move(x: number, y: number) {
const new_movement = new Vec2(x, y);
const last_movement = this.movement_queue.at(-1);
this.movement_queue.push(new_movement);
if (
typeof last_movement === "undefined" ||
new_movement.distance_to(last_movement) < this.movement_threshold
) {
return;
}
this.publish_movement();
}
private publish_movement() {
if (
Date.now() - this.last_event_time < this.debounce_ms ||
this.movement_queue.length === 0
) {
return;
}
this.last_event_time = Date.now();
this.callback(this.movement_queue.at(-1)!);
this.movement_queue = [];
}
}

10
static/src/vector.ts Normal file
View File

@ -0,0 +1,10 @@
export class Vec2 {
constructor(
private readonly x: number,
private readonly y: number,
) {}
public distance_to(that: Vec2): number {
return Math.sqrt((this.x - that.x) ** 2 + (this.y - that.y) ** 2);
}
}

View File

@ -1,9 +1,9 @@
{
"compilerOptions": {
"target": "ES2020",
"target": "ES2022",
"useDefineForClassFields": true,
"module": "ESNext",
"lib": ["ES2020", "DOM", "DOM.Iterable"],
"lib": ["ES2022", "DOM", "DOM.Iterable"],
"skipLibCheck": true,
/* Bundler mode */