From f741a0c8e83ca7d5bcd70fb88de303ccc3ed5991 Mon Sep 17 00:00:00 2001
From: wfz <1040079213@qq.com>
Date: Sun, 26 Jul 2026 14:41:36 +0800
Subject: [PATCH] Initial commit
---
.gitignore | 5 +
backend/dependency-reduced-pom.xml | 62 +
backend/pom.xml | 92 +
.../java/com/zombie/game/GameServerMain.java | 34 +
.../java/com/zombie/game/ecs/ECSWorld.java | 133 +
.../main/java/com/zombie/game/ecs/System.java | 7 +
.../game/ecs/components/BlocksMovement.java | 5 +
.../zombie/game/ecs/components/Collision.java | 15 +
.../zombie/game/ecs/components/Health.java | 28 +
.../game/ecs/components/MovementCost.java | 14 +
.../game/ecs/components/PlayerInput.java | 27 +
.../zombie/game/ecs/components/Position.java | 42 +
.../game/ecs/components/RenderInfo.java | 21 +
.../zombie/game/ecs/components/ZombieAI.java | 26 +
.../java/com/zombie/game/model/Constants.java | 56 +
.../java/com/zombie/game/model/FlowField.java | 194 +
.../java/com/zombie/game/model/GameMap.java | 197 +
.../java/com/zombie/game/model/MapData.java | 144 +
.../com/zombie/game/model/PlayerInfo.java | 26 +
.../main/java/com/zombie/game/model/Room.java | 106 +
.../java/com/zombie/game/server/GameLoop.java | 73 +
.../com/zombie/game/server/GameService.java | 163 +
.../game/server/GameWebSocketServer.java | 370 ++
.../com/zombie/game/server/MapStorage.java | 136 +
.../com/zombie/game/server/MessageUtils.java | 73 +
.../com/zombie/game/server/RoomManager.java | 103 +
.../game/systems/FlowFieldUpdateSystem.java | 30 +
.../game/systems/PlayerInputSystem.java | 46 +
.../zombie/game/systems/StateSyncSystem.java | 108 +
.../game/systems/ZombieMovementSystem.java | 235 +
.../game/systems/ZombieSpawnSystem.java | 47 +
.../com/zombie/game/GameServerMain.class | Bin 0 -> 2487 bytes
.../com/zombie/game/ecs/ECSWorld.class | Bin 0 -> 8566 bytes
.../classes/com/zombie/game/ecs/System.class | Bin 0 -> 167 bytes
.../game/ecs/components/BlocksMovement.class | Bin 0 -> 329 bytes
.../game/ecs/components/Collision.class | Bin 0 -> 1621 bytes
.../zombie/game/ecs/components/Health.class | Bin 0 -> 2052 bytes
.../game/ecs/components/MovementCost.class | Bin 0 -> 1633 bytes
.../game/ecs/components/PlayerInput.class | Bin 0 -> 2560 bytes
.../zombie/game/ecs/components/Position.class | Bin 0 -> 2537 bytes
.../components/RenderInfo$EntityType.class | Bin 0 -> 1346 bytes
.../game/ecs/components/RenderInfo.class | Bin 0 -> 2070 bytes
.../zombie/game/ecs/components/ZombieAI.class | Bin 0 -> 3011 bytes
.../com/zombie/game/model/Constants.class | Bin 0 -> 1429 bytes
.../zombie/game/model/FlowField$Node.class | Bin 0 -> 547 bytes
.../com/zombie/game/model/FlowField.class | Bin 0 -> 7094 bytes
.../com/zombie/game/model/GameMap.class | Bin 0 -> 8605 bytes
.../com/zombie/game/model/MapData.class | Bin 0 -> 5544 bytes
.../com/zombie/game/model/PlayerInfo.class | Bin 0 -> 825 bytes
.../classes/com/zombie/game/model/Room.class | Bin 0 -> 4409 bytes
.../com/zombie/game/server/GameLoop.class | Bin 0 -> 3790 bytes
.../GameService$GameStateBroadcast.class | Bin 0 -> 330 bytes
.../com/zombie/game/server/GameService.class | Bin 0 -> 7834 bytes
.../game/server/GameWebSocketServer$1.class | Bin 0 -> 749 bytes
.../game/server/GameWebSocketServer.class | Bin 0 -> 13988 bytes
.../com/zombie/game/server/MapStorage.class | Bin 0 -> 6551 bytes
.../com/zombie/game/server/MessageUtils.class | Bin 0 -> 2188 bytes
.../com/zombie/game/server/RoomManager.class | Bin 0 -> 3503 bytes
.../game/systems/FlowFieldUpdateSystem.class | Bin 0 -> 1773 bytes
.../game/systems/PlayerInputSystem.class | Bin 0 -> 2286 bytes
.../zombie/game/systems/StateSyncSystem.class | Bin 0 -> 4682 bytes
.../game/systems/ZombieMovementSystem.class | Bin 0 -> 7891 bytes
.../game/systems/ZombieSpawnSystem.class | Bin 0 -> 2537 bytes
backend/target/maven-archiver/pom.properties | 3 +
.../compile/default-compile/createdFiles.lst | 24 +
.../compile/default-compile/inputFiles.lst | 28 +
.../original-zombie-crisis-server-1.0.0.jar | Bin 0 -> 2794159 bytes
backend/target/zombie-crisis-server-1.0.0.jar | Bin 0 -> 2794159 bytes
docs/architecture.md | 597 +++
docs/migration-plan-zh.md | 256 ++
docs/migration-plan.md | 143 +
frontend/dist/assets/index-BeHdn1hs.css | 1 +
frontend/dist/assets/index-BpzQrr0d.js | 3863 +++++++++++++++++
frontend/dist/index.html | 13 +
frontend/index.html | 12 +
frontend/package-lock.json | 1152 +++++
frontend/package.json | 17 +
frontend/src/game/engine.js | 337 ++
frontend/src/game/scene.js | 302 ++
frontend/src/main.js | 141 +
frontend/src/network/client.js | 107 +
frontend/src/style.css | 180 +
frontend/src/ui/lobby.js | 114 +
frontend/src/utils/constants.js | 40 +
frontend/src/utils/grid.js | 68 +
frontend/src/utils/input.js | 94 +
frontend/vite.config.js | 14 +
maps/d540209a.json | 464 ++
script/start.bat | 81 +
script/start.sh | 105 +
90 files changed, 10774 insertions(+)
create mode 100644 .gitignore
create mode 100644 backend/dependency-reduced-pom.xml
create mode 100644 backend/pom.xml
create mode 100644 backend/src/main/java/com/zombie/game/GameServerMain.java
create mode 100644 backend/src/main/java/com/zombie/game/ecs/ECSWorld.java
create mode 100644 backend/src/main/java/com/zombie/game/ecs/System.java
create mode 100644 backend/src/main/java/com/zombie/game/ecs/components/BlocksMovement.java
create mode 100644 backend/src/main/java/com/zombie/game/ecs/components/Collision.java
create mode 100644 backend/src/main/java/com/zombie/game/ecs/components/Health.java
create mode 100644 backend/src/main/java/com/zombie/game/ecs/components/MovementCost.java
create mode 100644 backend/src/main/java/com/zombie/game/ecs/components/PlayerInput.java
create mode 100644 backend/src/main/java/com/zombie/game/ecs/components/Position.java
create mode 100644 backend/src/main/java/com/zombie/game/ecs/components/RenderInfo.java
create mode 100644 backend/src/main/java/com/zombie/game/ecs/components/ZombieAI.java
create mode 100644 backend/src/main/java/com/zombie/game/model/Constants.java
create mode 100644 backend/src/main/java/com/zombie/game/model/FlowField.java
create mode 100644 backend/src/main/java/com/zombie/game/model/GameMap.java
create mode 100644 backend/src/main/java/com/zombie/game/model/MapData.java
create mode 100644 backend/src/main/java/com/zombie/game/model/PlayerInfo.java
create mode 100644 backend/src/main/java/com/zombie/game/model/Room.java
create mode 100644 backend/src/main/java/com/zombie/game/server/GameLoop.java
create mode 100644 backend/src/main/java/com/zombie/game/server/GameService.java
create mode 100644 backend/src/main/java/com/zombie/game/server/GameWebSocketServer.java
create mode 100644 backend/src/main/java/com/zombie/game/server/MapStorage.java
create mode 100644 backend/src/main/java/com/zombie/game/server/MessageUtils.java
create mode 100644 backend/src/main/java/com/zombie/game/server/RoomManager.java
create mode 100644 backend/src/main/java/com/zombie/game/systems/FlowFieldUpdateSystem.java
create mode 100644 backend/src/main/java/com/zombie/game/systems/PlayerInputSystem.java
create mode 100644 backend/src/main/java/com/zombie/game/systems/StateSyncSystem.java
create mode 100644 backend/src/main/java/com/zombie/game/systems/ZombieMovementSystem.java
create mode 100644 backend/src/main/java/com/zombie/game/systems/ZombieSpawnSystem.java
create mode 100644 backend/target/classes/com/zombie/game/GameServerMain.class
create mode 100644 backend/target/classes/com/zombie/game/ecs/ECSWorld.class
create mode 100644 backend/target/classes/com/zombie/game/ecs/System.class
create mode 100644 backend/target/classes/com/zombie/game/ecs/components/BlocksMovement.class
create mode 100644 backend/target/classes/com/zombie/game/ecs/components/Collision.class
create mode 100644 backend/target/classes/com/zombie/game/ecs/components/Health.class
create mode 100644 backend/target/classes/com/zombie/game/ecs/components/MovementCost.class
create mode 100644 backend/target/classes/com/zombie/game/ecs/components/PlayerInput.class
create mode 100644 backend/target/classes/com/zombie/game/ecs/components/Position.class
create mode 100644 backend/target/classes/com/zombie/game/ecs/components/RenderInfo$EntityType.class
create mode 100644 backend/target/classes/com/zombie/game/ecs/components/RenderInfo.class
create mode 100644 backend/target/classes/com/zombie/game/ecs/components/ZombieAI.class
create mode 100644 backend/target/classes/com/zombie/game/model/Constants.class
create mode 100644 backend/target/classes/com/zombie/game/model/FlowField$Node.class
create mode 100644 backend/target/classes/com/zombie/game/model/FlowField.class
create mode 100644 backend/target/classes/com/zombie/game/model/GameMap.class
create mode 100644 backend/target/classes/com/zombie/game/model/MapData.class
create mode 100644 backend/target/classes/com/zombie/game/model/PlayerInfo.class
create mode 100644 backend/target/classes/com/zombie/game/model/Room.class
create mode 100644 backend/target/classes/com/zombie/game/server/GameLoop.class
create mode 100644 backend/target/classes/com/zombie/game/server/GameService$GameStateBroadcast.class
create mode 100644 backend/target/classes/com/zombie/game/server/GameService.class
create mode 100644 backend/target/classes/com/zombie/game/server/GameWebSocketServer$1.class
create mode 100644 backend/target/classes/com/zombie/game/server/GameWebSocketServer.class
create mode 100644 backend/target/classes/com/zombie/game/server/MapStorage.class
create mode 100644 backend/target/classes/com/zombie/game/server/MessageUtils.class
create mode 100644 backend/target/classes/com/zombie/game/server/RoomManager.class
create mode 100644 backend/target/classes/com/zombie/game/systems/FlowFieldUpdateSystem.class
create mode 100644 backend/target/classes/com/zombie/game/systems/PlayerInputSystem.class
create mode 100644 backend/target/classes/com/zombie/game/systems/StateSyncSystem.class
create mode 100644 backend/target/classes/com/zombie/game/systems/ZombieMovementSystem.class
create mode 100644 backend/target/classes/com/zombie/game/systems/ZombieSpawnSystem.class
create mode 100644 backend/target/maven-archiver/pom.properties
create mode 100644 backend/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst
create mode 100644 backend/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst
create mode 100644 backend/target/original-zombie-crisis-server-1.0.0.jar
create mode 100644 backend/target/zombie-crisis-server-1.0.0.jar
create mode 100644 docs/architecture.md
create mode 100644 docs/migration-plan-zh.md
create mode 100644 docs/migration-plan.md
create mode 100644 frontend/dist/assets/index-BeHdn1hs.css
create mode 100644 frontend/dist/assets/index-BpzQrr0d.js
create mode 100644 frontend/dist/index.html
create mode 100644 frontend/index.html
create mode 100644 frontend/package-lock.json
create mode 100644 frontend/package.json
create mode 100644 frontend/src/game/engine.js
create mode 100644 frontend/src/game/scene.js
create mode 100644 frontend/src/main.js
create mode 100644 frontend/src/network/client.js
create mode 100644 frontend/src/style.css
create mode 100644 frontend/src/ui/lobby.js
create mode 100644 frontend/src/utils/constants.js
create mode 100644 frontend/src/utils/grid.js
create mode 100644 frontend/src/utils/input.js
create mode 100644 frontend/vite.config.js
create mode 100644 maps/d540209a.json
create mode 100644 script/start.bat
create mode 100755 script/start.sh
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..2f00653
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,5 @@
+node_modules/
+*.log
+.backend.pid
+.DS_Store
+.env
diff --git a/backend/dependency-reduced-pom.xml b/backend/dependency-reduced-pom.xml
new file mode 100644
index 0000000..e6c7967
--- /dev/null
+++ b/backend/dependency-reduced-pom.xml
@@ -0,0 +1,62 @@
+
+
+ 4.0.0
+ com.zombie
+ zombie-crisis-server
+ 1.0.0
+
+
+
+ maven-compiler-plugin
+ 3.11.0
+
+ 17
+ 17
+
+
+ org.projectlombok
+ lombok
+ 1.18.30
+
+
+
+
+
+ maven-jar-plugin
+ 3.3.0
+
+
+
+ com.zombie.game.GameServerMain
+
+
+
+
+
+ maven-shade-plugin
+ 3.5.1
+
+
+ package
+
+ shade
+
+
+
+
+
+
+
+
+ org.projectlombok
+ lombok
+ 1.18.30
+ provided
+
+
+
+ 17
+ 17
+ UTF-8
+
+
diff --git a/backend/pom.xml b/backend/pom.xml
new file mode 100644
index 0000000..f63a2f2
--- /dev/null
+++ b/backend/pom.xml
@@ -0,0 +1,92 @@
+
+
+ 4.0.0
+
+ com.zombie
+ zombie-crisis-server
+ 1.0.0
+ jar
+
+
+ 17
+ 17
+ UTF-8
+
+
+
+
+ org.projectlombok
+ lombok
+ 1.18.30
+ provided
+
+
+ org.java-websocket
+ Java-WebSocket
+ 1.5.4
+
+
+ com.google.code.gson
+ gson
+ 2.10.1
+
+
+ com.fasterxml.jackson.core
+ jackson-databind
+ 2.15.2
+
+
+ org.slf4j
+ slf4j-simple
+ 2.0.9
+
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+ 3.11.0
+
+ 17
+ 17
+
+
+ org.projectlombok
+ lombok
+ 1.18.30
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-jar-plugin
+ 3.3.0
+
+
+
+ com.zombie.game.GameServerMain
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-shade-plugin
+ 3.5.1
+
+
+ package
+
+ shade
+
+
+
+
+
+
+
diff --git a/backend/src/main/java/com/zombie/game/GameServerMain.java b/backend/src/main/java/com/zombie/game/GameServerMain.java
new file mode 100644
index 0000000..b4b9baa
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/GameServerMain.java
@@ -0,0 +1,34 @@
+package com.zombie.game;
+
+import com.zombie.game.server.GameWebSocketServer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class GameServerMain {
+ private static final Logger logger = LoggerFactory.getLogger(GameServerMain.class);
+
+ public static void main(String[] args) throws Exception {
+ int port = 8080;
+ if (args.length > 0) {
+ try {
+ port = Integer.parseInt(args[0]);
+ } catch (NumberFormatException e) {
+ logger.warn("Invalid port number, using default: 8080");
+ }
+ }
+
+ GameWebSocketServer server = new GameWebSocketServer(port);
+ server.start();
+
+ logger.info("ZP2 Server started on port {}", port);
+
+ Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+ logger.info("Shutting down server...");
+ try {
+ server.stop();
+ } catch (Exception e) {
+ logger.error("Error during shutdown", e);
+ }
+ }));
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/ecs/ECSWorld.java b/backend/src/main/java/com/zombie/game/ecs/ECSWorld.java
new file mode 100644
index 0000000..58d5959
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/ecs/ECSWorld.java
@@ -0,0 +1,133 @@
+package com.zombie.game.ecs;
+
+import com.zombie.game.ecs.components.*;
+import com.zombie.game.model.Constants;
+import com.zombie.game.model.GameMap;
+import lombok.Getter;
+
+import java.util.*;
+
+/** ECS world that manages all entities, components, and systems / ECS世界，管理所有实体、组件和系统 */
+@Getter
+public class ECSWorld {
+ private final Object lock = new Object();
+ private final GameMap map;
+ private int nextEntityId;
+ private final Set entities = new LinkedHashSet<>();
+ private final Set players = new LinkedHashSet<>();
+ private final Set zombies = new LinkedHashSet<>();
+ private final Map positions = new HashMap<>();
+ private final Map healths = new HashMap<>();
+ private final Map collisions = new HashMap<>();
+ private final Map renderInfos = new HashMap<>();
+ private final Map playerInputs = new HashMap<>();
+ private final Map blocksMovements = new HashMap<>();
+ private final Map movementCosts = new HashMap<>();
+ private final Map zombieAIs = new HashMap<>();
+ private final List systems = new ArrayList<>();
+ private float gameTime;
+ private final Map playerIdToEntity = new HashMap<>();
+
+ public ECSWorld(String mapFilePath) {
+ this.map = new GameMap(mapFilePath);
+ this.nextEntityId = 0;
+ this.gameTime = 0;
+
+ // Wire GameMap to ECS component maps
+ map.setComponentMaps(blocksMovements, movementCosts);
+
+ // Create wall entities from map data
+ createWallsFromMapData();
+ }
+
+ /** Create static wall and nut wall entities from map JSON data */
+ private void createWallsFromMapData() {
+ for (int[] pos : map.getStaticWallData()) {
+ createStaticWallEntity(pos[0], pos[1]);
+ }
+ for (int[] pos : map.getNutWallData()) {
+ createNutWallEntity(pos[0], pos[1]);
+ }
+ }
+
+ /** Create a static wall entity (indestructible, blocks movement) */
+ public int createStaticWallEntity(int gx, int gy) {
+ int entityId = createEntity();
+ positions.put(entityId, new Position(gx + 0.5f, gy + 0.5f));
+ blocksMovements.put(entityId, new BlocksMovement());
+ map.registerWall(gx, gy, entityId);
+ return entityId;
+ }
+
+ /** Create a nut wall entity (destructible, blocks movement with cost) */
+ public int createNutWallEntity(int gx, int gy) {
+ int entityId = createEntity();
+ positions.put(entityId, new Position(gx + 0.5f, gy + 0.5f));
+ healths.put(entityId, new Health(Constants.NUT_WALL_MAX_HEALTH));
+ blocksMovements.put(entityId, new BlocksMovement());
+ movementCosts.put(entityId, new MovementCost(Constants.NUT_WALL_MOVEMENT_COST));
+ map.registerWall(gx, gy, entityId);
+ return entityId;
+ }
+
+ /** Create a zombie entity for testing pathfinding */
+ public int createZombieEntity(float x, float y) {
+ int entityId = createEntity();
+ positions.put(entityId, new Position(x, y));
+ healths.put(entityId, new Health(100));
+ collisions.put(entityId, new Collision(Constants.ZOMBIE_SIZE));
+ renderInfos.put(entityId, new RenderInfo(RenderInfo.EntityType.ZOMBIE));
+ zombieAIs.put(entityId, new ZombieAI());
+ zombies.add(entityId);
+ return entityId;
+ }
+
+ public int createEntity() {
+ int id = nextEntityId++;
+ entities.add(id);
+ return id;
+ }
+
+ public void destroyEntity(int id) {
+ entities.remove(id);
+ players.remove(id);
+ zombies.remove(id);
+ positions.remove(id);
+ healths.remove(id);
+ collisions.remove(id);
+ renderInfos.remove(id);
+ playerInputs.remove(id);
+ blocksMovements.remove(id);
+ movementCosts.remove(id);
+ zombieAIs.remove(id);
+ }
+
+ public int createPlayerEntity(String playerId, String name, float x, float y) {
+ int entityId = createEntity();
+ positions.put(entityId, new Position(x, y));
+ healths.put(entityId, new Health(100));
+ collisions.put(entityId, new Collision(Constants.PLAYER_SIZE));
+ renderInfos.put(entityId, new RenderInfo(RenderInfo.EntityType.PLAYER));
+ playerInputs.put(entityId, new PlayerInput());
+ players.add(entityId);
+ playerIdToEntity.put(playerId, entityId);
+ return entityId;
+ }
+
+ public Integer getPlayerEntity(String playerId) {
+ return playerIdToEntity.get(playerId);
+ }
+
+ public int[][] getMapData() { return map.getCells(); }
+
+ public void update(float dt) {
+ gameTime += dt;
+ for (System system : systems) {
+ system.update(dt, this);
+ }
+ }
+
+ public void addSystem(System system) {
+ systems.add(system);
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/ecs/System.java b/backend/src/main/java/com/zombie/game/ecs/System.java
new file mode 100644
index 0000000..956ca0d
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/ecs/System.java
@@ -0,0 +1,7 @@
+package com.zombie.game.ecs;
+
+/** Interface for ECS systems that process entities each frame / ECS系统接口，每帧处理实体 */
+public interface System {
+ // Updates the system with delta time and world reference / 使用增量时间和世界引用更新系统
+ void update(float dt, ECSWorld world);
+}
diff --git a/backend/src/main/java/com/zombie/game/ecs/components/BlocksMovement.java b/backend/src/main/java/com/zombie/game/ecs/components/BlocksMovement.java
new file mode 100644
index 0000000..4bf7b2c
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/ecs/components/BlocksMovement.java
@@ -0,0 +1,5 @@
+package com.zombie.game.ecs.components;
+
+/** Tag component: entity blocks movement on its grid cell / 标记组件：实体在其网格格子上阻挡移动 */
+public class BlocksMovement {
+}
diff --git a/backend/src/main/java/com/zombie/game/ecs/components/Collision.java b/backend/src/main/java/com/zombie/game/ecs/components/Collision.java
new file mode 100644
index 0000000..0698e0f
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/ecs/components/Collision.java
@@ -0,0 +1,15 @@
+package com.zombie.game.ecs.components;
+
+import lombok.Data;
+
+/** Component storing collision size for entity hitboxes / 存储实体碰撞体大小的组件 */
+@Data
+public class Collision {
+ // Collision radius/size for hitbox detection / 用于碰撞检测的碰撞体半径/大小
+ private float size;
+
+ // Constructor setting the collision size / 构造函数，设置碰撞体大小
+ public Collision(float size) {
+ this.size = size;
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/ecs/components/Health.java b/backend/src/main/java/com/zombie/game/ecs/components/Health.java
new file mode 100644
index 0000000..2b81970
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/ecs/components/Health.java
@@ -0,0 +1,28 @@
+package com.zombie.game.ecs.components;
+
+import lombok.Data;
+
+/** Component storing entity health points / 存储实体生命值的组件 */
+@Data
+public class Health {
+ // Current health value / 当前生命值
+ private float health;
+ // Maximum health value / 最大生命值
+ private float maxHealth;
+
+ // Constructor setting initial and max health / 构造函数，设置初始和最大生命值
+ public Health(float maxHealth) {
+ this.health = maxHealth;
+ this.maxHealth = maxHealth;
+ }
+
+ // Checks if the entity is still alive / 检查实体是否仍然存活
+ public boolean isAlive() {
+ return health > 0;
+ }
+
+ // Resets health to maximum value / 将生命值重置为最大值
+ public void reset() {
+ this.health = maxHealth;
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/ecs/components/MovementCost.java b/backend/src/main/java/com/zombie/game/ecs/components/MovementCost.java
new file mode 100644
index 0000000..65fa344
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/ecs/components/MovementCost.java
@@ -0,0 +1,14 @@
+package com.zombie.game.ecs.components;
+
+import lombok.Data;
+
+/** Component storing extra movement cost for flow field pathfinding / 存储流场寻路额外移动代价的组件 */
+@Data
+public class MovementCost {
+ /** Extra cost added on top of base (1.0 for straight, 1.414 for diagonal) / 基础代价之外的额外代价 */
+ private float cost;
+
+ public MovementCost(float cost) {
+ this.cost = cost;
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/ecs/components/PlayerInput.java b/backend/src/main/java/com/zombie/game/ecs/components/PlayerInput.java
new file mode 100644
index 0000000..5ce4523
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/ecs/components/PlayerInput.java
@@ -0,0 +1,27 @@
+package com.zombie.game.ecs.components;
+
+import lombok.Data;
+
+/** Component storing player input state for movement and aiming / 存储玩家移动和瞄准输入状态的组件 */
+@Data
+public class PlayerInput {
+ // Movement direction X component / 移动方向X分量
+ private float dx;
+ // Movement direction Y component / 移动方向Y分量
+ private float dy;
+ // Aim target X coordinate / 瞄准目标X坐标
+ private float aimX;
+ // Aim target Y coordinate / 瞄准目标Y坐标
+ private float aimY;
+ // Input sequence number for ordering / 用于排序的输入序列号
+ private int seq;
+
+ // Default constructor initializing all values to zero / 默认构造函数，将所有值初始化为零
+ public PlayerInput() {
+ this.dx = 0;
+ this.dy = 0;
+ this.aimX = 0;
+ this.aimY = 0;
+ this.seq = 0;
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/ecs/components/Position.java b/backend/src/main/java/com/zombie/game/ecs/components/Position.java
new file mode 100644
index 0000000..4c18b61
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/ecs/components/Position.java
@@ -0,0 +1,42 @@
+package com.zombie.game.ecs.components;
+
+import lombok.Data;
+
+/** Component storing entity position and facing angle / 存储实体位置和朝向角度的组件 */
+@Data
+public class Position {
+ // X coordinate / X坐标
+ private float x;
+ // Y coordinate / Y坐标
+ private float y;
+ // Facing angle in radians / 朝向角度（弧度）
+ private float angle;
+
+ // Default constructor initializing to origin / 默认构造函数，初始化为原点
+ public Position() {
+ this.x = 0;
+ this.y = 0;
+ this.angle = 0;
+ }
+
+ // Constructor with position only / 仅带位置的构造函数
+ public Position(float x, float y) {
+ this.x = x;
+ this.y = y;
+ this.angle = 0;
+ }
+
+ // Constructor with position and angle / 带位置和角度的构造函数
+ public Position(float x, float y, float angle) {
+ this.x = x;
+ this.y = y;
+ this.angle = angle;
+ }
+
+ // Calculates Euclidean distance to a point / 计算到某点的欧几里得距离
+ public float distanceTo(float px, float py) {
+ float dx = px - x;
+ float dy = py - y;
+ return (float) Math.sqrt(dx * dx + dy * dy);
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/ecs/components/RenderInfo.java b/backend/src/main/java/com/zombie/game/ecs/components/RenderInfo.java
new file mode 100644
index 0000000..dd2813f
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/ecs/components/RenderInfo.java
@@ -0,0 +1,21 @@
+package com.zombie.game.ecs.components;
+
+import lombok.Data;
+
+/** Component storing rendering information for an entity / 存储实体渲染信息的组件 */
+@Data
+public class RenderInfo {
+ // Enum defining possible entity types / 定义可能实体类型的枚举
+ public enum EntityType {
+ PLAYER,
+ ZOMBIE
+ }
+
+ // The type of this entity / 此实体的类型
+ private EntityType type;
+
+ // Constructor setting the entity type / 构造函数，设置实体类型
+ public RenderInfo(EntityType type) {
+ this.type = type;
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/ecs/components/ZombieAI.java b/backend/src/main/java/com/zombie/game/ecs/components/ZombieAI.java
new file mode 100644
index 0000000..733359e
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/ecs/components/ZombieAI.java
@@ -0,0 +1,26 @@
+package com.zombie.game.ecs.components;
+
+import lombok.Data;
+
+/** Zombie AI component storing pathfinding target and state / 僵尸AI组件，存储寻路目标和状态 */
+@Data
+public class ZombieAI {
+ /** Current movement target X / 当前移动目标X */
+ private float targetX;
+ /** Current movement target Y / 当前移动目标Y */
+ private float targetY;
+ /** Whether zombie has an active target / 是否有活跃目标 */
+ private boolean hasTarget;
+ /** Reserved grid X to prevent overlap / 预留网格X防止重叠 */
+ private int reservedGridX = -1;
+ /** Reserved grid Y to prevent overlap / 预留网格Y防止重叠 */
+ private int reservedGridY = -1;
+ /** Whether zombie holds a grid reservation / 是否持有网格预留 */
+ private boolean reservation;
+
+ public ZombieAI() {
+ this.targetX = 0;
+ this.targetY = 0;
+ this.hasTarget = false;
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/model/Constants.java b/backend/src/main/java/com/zombie/game/model/Constants.java
new file mode 100644
index 0000000..42a1a91
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/model/Constants.java
@@ -0,0 +1,56 @@
+package com.zombie.game.model;
+
+/** Game constants / 游戏常量 */
+public class Constants {
+ // Grid cell size in pixels / 网格单元格大小（像素）
+ public static final int GRID_SIZE = 32;
+ // Tick rate per second / 每秒逻辑帧率
+ public static final int TICK_RATE = 30;
+ // Duration of one tick in seconds / 每帧持续时间（秒）
+ public static final float TICK_INTERVAL = 1.0f / TICK_RATE;
+ // Player collision size / 玩家碰撞体积
+ public static final float PLAYER_SIZE = 0.8f;
+ // Player movement speed / 玩家移动速度
+ public static final float PLAYER_SPEED = 5.0f;
+ // Zombie collision size / 僵尸碰撞体积
+ public static final float ZOMBIE_SIZE = 0.8f;
+ // Zombie movement speed / 僵尸移动速度
+ public static final float ZOMBIE_SPEED = 2.0f;
+ // Nut wall max health / 坚果墙最大生命值
+ public static final float NUT_WALL_MAX_HEALTH = 500.0f;
+ // Nut wall extra movement cost for flow field / 坚果墙流场额外移动代价
+ public static final float NUT_WALL_MOVEMENT_COST = 20.0f;
+ // Grid center threshold for retarget / 到达网格中心后重新选方向的阈值
+ public static final float GRID_CENTER_THRESHOLD = 0.15f;
+ // Zombie spawn interval in seconds / 僵尸刷新间隔（秒）
+ public static final float ZOMBIE_SPAWN_INTERVAL = 3.0f;
+ // Max zombie count / 最大僵尸数量
+ public static final int ZOMBIE_MAX_COUNT = 20;
+
+ // Create room message type / 创建房间消息类型
+ public static final String MSG_CREATE_ROOM = "create_room";
+ // Join room message type / 加入房间消息类型
+ public static final String MSG_JOIN_ROOM = "join_room";
+ // Leave room message type / 离开房间消息类型
+ public static final String MSG_LEAVE_ROOM = "leave_room";
+ // Room list message type / 房间列表消息类型
+ public static final String MSG_ROOM_LIST = "room_list";
+ // Room state message type / 房间状态消息类型
+ public static final String MSG_ROOM_STATE = "room_state";
+ // Ready state message type / 准备状态消息类型
+ public static final String MSG_READY = "ready";
+ // Start game message type / 开始游戏消息类型
+ public static final String MSG_START_GAME = "start_game";
+ // Game started notification / 游戏已开始通知
+ public static final String MSG_GAME_STARTED = "game_started";
+ // Player input message type / 玩家输入消息类型
+ public static final String MSG_PLAYER_INPUT = "player_input";
+ // Game state broadcast / 游戏状态广播
+ public static final String MSG_GAME_STATE = "game_state";
+ // Player joined notification / 玩家加入通知
+ public static final String MSG_PLAYER_JOIN = "player_join";
+ // Player left notification / 玩家离开通知
+ public static final String MSG_PLAYER_LEAVE = "player_leave";
+ // Error message type / 错误消息类型
+ public static final String MSG_ERROR = "error";
+}
diff --git a/backend/src/main/java/com/zombie/game/model/FlowField.java b/backend/src/main/java/com/zombie/game/model/FlowField.java
new file mode 100644
index 0000000..5216f60
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/model/FlowField.java
@@ -0,0 +1,194 @@
+package com.zombie.game.model;
+
+import com.zombie.game.ecs.components.BlocksMovement;
+import com.zombie.game.ecs.components.MovementCost;
+
+import java.util.*;
+
+/** Flow field navigation using Dijkstra with ECS component-based wall queries / 基于ECS组件查询的Dijkstra流场导航 */
+public class FlowField {
+ private final int width;
+ private final int height;
+ private float[][] distanceField;
+ private float[][] flowFieldX;
+ private float[][] flowFieldY;
+ private boolean valid;
+
+ public FlowField(int width, int height) {
+ this.width = width;
+ this.height = height;
+ this.distanceField = new float[height][width];
+ this.flowFieldX = new float[height][width];
+ this.flowFieldY = new float[height][width];
+ this.valid = false;
+ }
+
+ /**
+ * Update flow field based on player positions and ECS wall components.
+ * @param wallGrid spatial index "x,y" -> entityId
+ * @param blocksMovements blocks-movement component map
+ * @param movementCosts movement-cost component map
+ * @param playerPositions list of [x, y] player positions
+ */
+ public void update(Map wallGrid,
+ Map blocksMovements,
+ Map movementCosts,
+ List playerPositions) {
+ for (int y = 0; y < height; y++) {
+ for (int x = 0; x < width; x++) {
+ distanceField[y][x] = Float.MAX_VALUE;
+ }
+ }
+
+ PriorityQueue queue = new PriorityQueue<>(Comparator.comparingDouble(n -> n.dist));
+
+ for (float[] pos : playerPositions) {
+ int px = (int) Math.floor(pos[0]);
+ int py = (int) Math.floor(pos[1]);
+ if (px >= 0 && px < width && py >= 0 && py < height) {
+ if (!isBlocked(wallGrid, blocksMovements, px, py)) {
+ distanceField[py][px] = 0;
+ queue.add(new Node(px, py, 0));
+ }
+ }
+ }
+
+ int[][] dirs = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}, {-1, -1}, {1, -1}, {-1, 1}, {1, 1}};
+
+ while (!queue.isEmpty()) {
+ Node current = queue.poll();
+ int cx = current.x;
+ int cy = current.y;
+ float currentDist = current.dist;
+
+ if (currentDist > distanceField[cy][cx]) continue;
+
+ for (int[] dir : dirs) {
+ int nx = cx + dir[0];
+ int ny = cy + dir[1];
+
+ if (nx < 0 || nx >= width || ny < 0 || ny >= height) continue;
+
+ // Diagonal: check corner blocking
+ if (dir[0] != 0 && dir[1] != 0) {
+ if (isBlocked(wallGrid, blocksMovements, cx + dir[0], cy) ||
+ isBlocked(wallGrid, blocksMovements, cx, cy + dir[1])) {
+ continue;
+ }
+ }
+
+ float moveCost = getMovementCost(wallGrid, blocksMovements, movementCosts, nx, ny, dir);
+ if (moveCost == Float.MAX_VALUE) continue;
+
+ float newDist = currentDist + moveCost;
+
+ if (newDist < distanceField[ny][nx]) {
+ distanceField[ny][nx] = newDist;
+ queue.add(new Node(nx, ny, newDist));
+ }
+ }
+ }
+
+ // Compute flow directions
+ for (int y = 0; y < height; y++) {
+ for (int x = 0; x < width; x++) {
+ if (isBlocked(wallGrid, blocksMovements, x, y) || distanceField[y][x] == Float.MAX_VALUE) {
+ flowFieldX[y][x] = 0;
+ flowFieldY[y][x] = 0;
+ continue;
+ }
+
+ float bestDist = distanceField[y][x];
+ float bestDirX = 0;
+ float bestDirY = 0;
+
+ for (int[] dir : dirs) {
+ int nx = x + dir[0];
+ int ny = y + dir[1];
+
+ if (nx < 0 || nx >= width || ny < 0 || ny >= height) continue;
+ if (isBlocked(wallGrid, blocksMovements, nx, ny)) continue;
+
+ if (dir[0] != 0 && dir[1] != 0) {
+ if (isBlocked(wallGrid, blocksMovements, x + dir[0], y) ||
+ isBlocked(wallGrid, blocksMovements, x, y + dir[1])) {
+ continue;
+ }
+ }
+
+ if (distanceField[ny][nx] < bestDist) {
+ bestDist = distanceField[ny][nx];
+ float len = (float) Math.sqrt(dir[0] * dir[0] + dir[1] * dir[1]);
+ bestDirX = dir[0] / len;
+ bestDirY = dir[1] / len;
+ }
+ }
+
+ flowFieldX[y][x] = bestDirX;
+ flowFieldY[y][x] = bestDirY;
+ }
+ }
+
+ valid = true;
+ }
+
+ /** Get flow direction at world position / 获取世界坐标处的流场方向 */
+ public float[] getDirection(float wx, float wy) {
+ int gx = (int) Math.floor(wx);
+ int gy = (int) Math.floor(wy);
+ if (gx < 0 || gx >= width || gy < 0 || gy >= height) {
+ return new float[]{0, 0};
+ }
+ return new float[]{flowFieldX[gy][gx], flowFieldY[gy][gx]};
+ }
+
+ /** Get distance to nearest player at world position / 获取世界坐标处到最近玩家的距离 */
+ public float getDistance(float wx, float wy) {
+ int gx = (int) Math.floor(wx);
+ int gy = (int) Math.floor(wy);
+ if (gx < 0 || gx >= width || gy < 0 || gy >= height) {
+ return Float.MAX_VALUE;
+ }
+ return distanceField[gy][gx];
+ }
+
+ public boolean isValid() { return valid; }
+ public void invalidate() { valid = false; }
+
+ private boolean isBlocked(Map wallGrid,
+ Map blocksMovements,
+ int gx, int gy) {
+ if (gx < 0 || gx >= width || gy < 0 || gy >= height) return true;
+ Integer entityId = wallGrid.get(gx + "," + gy);
+ if (entityId == null) return false;
+ return blocksMovements.containsKey(entityId);
+ }
+
+ private float getMovementCost(Map wallGrid,
+ Map blocksMovements,
+ Map movementCosts,
+ int gx, int gy, int[] dir) {
+ float baseCost = (dir[0] != 0 && dir[1] != 0) ? 1.414f : 1.0f;
+ Integer entityId = wallGrid.get(gx + "," + gy);
+ if (entityId == null) return baseCost;
+ // Completely blocked (no MovementCost but has BlocksMovement)
+ if (blocksMovements.containsKey(entityId) && !movementCosts.containsKey(entityId)) {
+ return Float.MAX_VALUE;
+ }
+ MovementCost mc = movementCosts.get(entityId);
+ if (mc != null) {
+ return baseCost + mc.getCost();
+ }
+ return baseCost;
+ }
+
+ private static class Node {
+ int x, y;
+ float dist;
+ Node(int x, int y, float dist) {
+ this.x = x;
+ this.y = y;
+ this.dist = dist;
+ }
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/model/GameMap.java b/backend/src/main/java/com/zombie/game/model/GameMap.java
new file mode 100644
index 0000000..342a910
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/model/GameMap.java
@@ -0,0 +1,197 @@
+package com.zombie.game.model;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.zombie.game.ecs.components.BlocksMovement;
+import com.zombie.game.ecs.components.MovementCost;
+import lombok.Getter;
+
+import java.io.File;
+import java.util.*;
+
+/** Game map: spatial index for wall entities, flow field, and spawn points / 游戏地图：墙体实体空间索引、流场和出生点 */
+@Getter
+public class GameMap {
+ private final int[][] cells;
+ private final int width;
+ private final int height;
+ /** Spatial index: "x,y" -> wall entity ID / 空间索引："x,y" -> 墙体实体ID */
+ private final Map wallGrid = new HashMap<>();
+ private final List spawnPoints;
+ /** Raw static wall positions loaded from JSON / 从JSON加载的静态墙位置 */
+ private final List staticWallData = new ArrayList<>();
+ /** Raw nut wall positions loaded from JSON / 从JSON加载的坚果墙位置 */
+ private final List nutWallData = new ArrayList<>();
+ /** Flow field for zombie pathfinding / 僵尸寻路流场 */
+ private final FlowField flowField;
+
+ // References to ECS component maps, set by ECSWorld after construction
+ private Map blocksMovements;
+ private Map movementCosts;
+
+ public GameMap(String mapFilePath) {
+ JsonNode root = loadMapFile(mapFilePath);
+ this.width = root.get("width").asInt();
+ this.height = root.get("height").asInt();
+ this.cells = new int[height][width];
+ this.spawnPoints = new ArrayList<>();
+ this.flowField = new FlowField(width, height);
+ loadFromJson(root);
+ }
+
+ /** Set ECS component map references (called by ECSWorld) */
+ public void setComponentMaps(Map bm, Map mc) {
+ this.blocksMovements = bm;
+ this.movementCosts = mc;
+ }
+
+ /** Register a wall entity in the spatial index */
+ public void registerWall(int gx, int gy, int entityId) {
+ wallGrid.put(key(gx, gy), entityId);
+ }
+
+ /** Unregister a wall entity and invalidate flow field */
+ public void unregisterWall(int gx, int gy) {
+ wallGrid.remove(key(gx, gy));
+ flowField.invalidate();
+ }
+
+ /** Check if grid cell blocks movement / 检查网格格子是否阻挡移动 */
+ public boolean isWall(int gx, int gy) {
+ if (gx < 0 || gx >= width || gy < 0 || gy >= height) return true;
+ Integer entityId = wallGrid.get(key(gx, gy));
+ if (entityId == null) return false;
+ return blocksMovements != null && blocksMovements.containsKey(entityId);
+ }
+
+ /** Check if world-space area is walkable / 检查世界坐标区域是否可行走 */
+ public boolean isWalkable(float wx, float wy, float size) {
+ float half = size / 2;
+ float[][] corners = {
+ {wx - half, wy - half}, {wx + half, wy - half},
+ {wx - half, wy + half}, {wx + half, wy + half}
+ };
+ for (float[] c : corners) {
+ int gx = (int) Math.floor(c[0]);
+ int gy = (int) Math.floor(c[1]);
+ if (isWall(gx, gy)) return false;
+ }
+ return true;
+ }
+
+ /** Update flow field with current player positions */
+ public void updateFlowField(List playerPositions) {
+ flowField.update(wallGrid, blocksMovements, movementCosts, playerPositions);
+ }
+
+ /** Get flow direction at world position */
+ public float[] getFlowDirection(float wx, float wy) {
+ return flowField.getDirection(wx, wy);
+ }
+
+ /** Check if flow field is valid */
+ public boolean isFlowFieldValid() {
+ return flowField.isValid();
+ }
+
+ /** Get cell grid with wall info (for sync) / 获取包含墙壁信息的格子网格 */
+ public int[][] getCells() {
+ int[][] result = new int[height][width];
+ for (int y = 0; y < height; y++) {
+ for (int x = 0; x < width; x++) {
+ result[y][x] = cells[y][x];
+ }
+ }
+ // Mark wall cells from spatial index
+ for (Map.Entry entry : wallGrid.entrySet()) {
+ String[] parts = entry.getKey().split(",");
+ int x = Integer.parseInt(parts[0]);
+ int y = Integer.parseInt(parts[1]);
+ if (x >= 0 && x < width && y >= 0 && y < height) {
+ Integer entityId = entry.getValue();
+ if (blocksMovements != null && blocksMovements.containsKey(entityId)) {
+ // Check if it's a nut wall (has MovementCost) or static wall
+ if (movementCosts != null && movementCosts.containsKey(entityId)) {
+ result[y][x] = 4; // nut wall
+ } else {
+ result[y][x] = 1; // static wall
+ }
+ }
+ }
+ }
+ return result;
+ }
+
+ /** Get player spawn points */
+ public List getSpawnPoints() {
+ return spawnPoints;
+ }
+
+ // --- Private ---
+
+ private JsonNode loadMapFile(String mapFilePath) {
+ try {
+ ObjectMapper mapper = new ObjectMapper();
+ return mapper.readTree(new File(mapFilePath));
+ } catch (Exception e) {
+ throw new RuntimeException("Failed to load map file: " + mapFilePath, e);
+ }
+ }
+
+ private void loadFromJson(JsonNode root) {
+ JsonNode wallsNode = root.get("walls");
+ if (wallsNode != null && wallsNode.isArray()) {
+ for (JsonNode wallNode : wallsNode) {
+ int x = (int) wallNode.get("x").asDouble();
+ int y = (int) wallNode.get("y").asDouble();
+ String type = wallNode.get("type").asText();
+ if (x < 0 || x >= width || y < 0 || y >= height) continue;
+ if ("static".equals(type)) {
+ staticWallData.add(new int[]{x, y});
+ } else if ("nut".equals(type)) {
+ nutWallData.add(new int[]{x, y});
+ }
+ }
+ }
+
+ JsonNode playerSpawns = root.get("playerSpawns");
+ if (playerSpawns != null && playerSpawns.isArray()) {
+ for (JsonNode spawn : playerSpawns) {
+ int x = spawn.get("x").asInt();
+ int y = spawn.get("y").asInt();
+ if (x >= 0 && x < width && y >= 0 && y < height) {
+ cells[y][x] = 2;
+ spawnPoints.add(new int[]{x, y});
+ }
+ }
+ }
+
+ JsonNode zombieSpawns = root.get("zombieSpawns");
+ if (zombieSpawns != null && zombieSpawns.isArray()) {
+ for (JsonNode spawn : zombieSpawns) {
+ int x = spawn.get("x").asInt();
+ int y = spawn.get("y").asInt();
+ if (x >= 0 && x < width && y >= 0 && y < height) {
+ cells[y][x] = 3;
+ }
+ }
+ }
+ }
+
+ /** Get zombie spawn points from cells / 从格子中获取僵尸出生点 */
+ public List getZombieSpawnPoints() {
+ List points = new ArrayList<>();
+ for (int y = 0; y < height; y++) {
+ for (int x = 0; x < width; x++) {
+ if (cells[y][x] == 3) {
+ points.add(new int[]{x, y});
+ }
+ }
+ }
+ return points;
+ }
+
+ private static String key(int x, int y) {
+ return x + "," + y;
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/model/MapData.java b/backend/src/main/java/com/zombie/game/model/MapData.java
new file mode 100644
index 0000000..db5665d
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/model/MapData.java
@@ -0,0 +1,144 @@
+package com.zombie.game.model;
+
+import java.util.List;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.ArrayList;
+
+/** Serializable map data for storage or network transfer / 可序列化的地图数据，用于存储或网络传输 */
+public class MapData {
+ // Map unique identifier / 地图唯一标识
+ private String id;
+ // Map display name / 地图显示名称
+ private String name;
+ // Map width in grid units / 地图宽度（网格单位）
+ private int width;
+ // Map height in grid units / 地图高度（网格单位）
+ private int height;
+ // List of wall data maps / 墙壁数据映射列表
+ private List> walls;
+ // List of player spawn coordinates / 玩家出生点坐标列表
+ private List> playerSpawns;
+ // List of zombie spawn coordinates / 僵尸出生点坐标列表
+ private List> zombieSpawns;
+
+ // Default constructor / 默认构造函数
+ public MapData() {
+ this.walls = new ArrayList<>();
+ this.playerSpawns = new ArrayList<>();
+ this.zombieSpawns = new ArrayList<>();
+ }
+
+ // Full constructor with all fields / 全字段构造函数
+ public MapData(String id, String name, int width, int height,
+ List> walls,
+ List> playerSpawns,
+ List> zombieSpawns) {
+ this.id = id;
+ this.name = name;
+ this.width = width;
+ this.height = height;
+ this.walls = walls;
+ this.playerSpawns = playerSpawns;
+ this.zombieSpawns = zombieSpawns;
+ }
+
+ // Get map ID / 获取地图ID
+ public String getId() { return id; }
+ // Set map ID / 设置地图ID
+ public void setId(String id) { this.id = id; }
+ // Get map name / 获取地图名称
+ public String getName() { return name; }
+ // Set map name / 设置地图名称
+ public void setName(String name) { this.name = name; }
+ // Get map width / 获取地图宽度
+ public int getWidth() { return width; }
+ // Set map width / 设置地图宽度
+ public void setWidth(int width) { this.width = width; }
+ // Get map height / 获取地图高度
+ public int getHeight() { return height; }
+ // Set map height / 设置地图高度
+ public void setHeight(int height) { this.height = height; }
+ // Get walls list / 获取墙壁列表
+ public List> getWalls() { return walls; }
+ // Set walls list / 设置墙壁列表
+ public void setWalls(List> walls) { this.walls = walls; }
+ // Get player spawns / 获取玩家出生点
+ public List> getPlayerSpawns() { return playerSpawns; }
+ // Set player spawns / 设置玩家出生点
+ public void setPlayerSpawns(List> playerSpawns) { this.playerSpawns = playerSpawns; }
+ // Get zombie spawns / 获取僵尸出生点
+ public List> getZombieSpawns() { return zombieSpawns; }
+ // Set zombie spawns / 设置僵尸出生点
+ public void setZombieSpawns(List> zombieSpawns) { this.zombieSpawns = zombieSpawns; }
+
+ // Convert this map data to a 2D cell array / 将此地图数据转换为二维格子数组
+ public int[][] toCells() {
+ int[][] cells = new int[height][width];
+ for (int y = 0; y < height; y++) {
+ for (int x = 0; x < width; x++) {
+ cells[y][x] = 0;
+ }
+ }
+ // Mark wall cells / 标记墙壁格子
+ for (Map wall : walls) {
+ int x = (Integer) wall.get("x");
+ int y = (Integer) wall.get("y");
+ if (x >= 0 && x < width && y >= 0 && y < height) {
+ cells[y][x] = 1;
+ }
+ }
+ // Mark player spawn cells / 标记玩家出生点格子
+ for (Map spawn : playerSpawns) {
+ int x = spawn.get("x");
+ int y = spawn.get("y");
+ if (x >= 0 && x < width && y >= 0 && y < height) {
+ cells[y][x] = 2;
+ }
+ }
+ // Mark zombie spawn cells / 标记僵尸出生点格子
+ for (Map spawn : zombieSpawns) {
+ int x = spawn.get("x");
+ int y = spawn.get("y");
+ if (x >= 0 && x < width && y >= 0 && y < height) {
+ cells[y][x] = 3;
+ }
+ }
+ return cells;
+ }
+
+ // Create MapData from a GameMap instance / 从GameMap实例创建MapData
+ public static MapData fromGameMap(String id, String name, GameMap map) {
+ List> walls = new ArrayList<>();
+ List> playerSpawns = new ArrayList<>();
+ List> zombieSpawns = new ArrayList<>();
+
+ // Convert static walls from raw data
+ for (int[] pos : map.getStaticWallData()) {
+ Map wallData = new HashMap<>();
+ wallData.put("x", pos[0]);
+ wallData.put("y", pos[1]);
+ wallData.put("type", "static");
+ walls.add(wallData);
+ }
+
+ // Convert nut walls from raw data
+ for (int[] pos : map.getNutWallData()) {
+ Map wallData = new HashMap<>();
+ wallData.put("x", pos[0]);
+ wallData.put("y", pos[1]);
+ wallData.put("type", "nut");
+ walls.add(wallData);
+ }
+
+ // Convert player spawn points
+ for (int[] spawn : map.getSpawnPoints()) {
+ Map sp = new HashMap<>();
+ sp.put("x", spawn[0]);
+ sp.put("y", spawn[1]);
+ playerSpawns.add(sp);
+ }
+
+ return new MapData(id, name, map.getWidth(), map.getHeight(), walls, playerSpawns, zombieSpawns);
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/model/PlayerInfo.java b/backend/src/main/java/com/zombie/game/model/PlayerInfo.java
new file mode 100644
index 0000000..4c098db
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/model/PlayerInfo.java
@@ -0,0 +1,26 @@
+package com.zombie.game.model;
+
+import lombok.Getter;
+
+/** Player information within a room / 房间内的玩家信息 */
+@Getter
+public class PlayerInfo {
+ // Player unique identifier / 玩家唯一标识
+ private final String id;
+ // Player display name / 玩家显示名称
+ private final String name;
+ // Whether the player is ready / 玩家是否已准备
+ private boolean ready;
+
+ // Create a new player info / 创建新的玩家信息
+ public PlayerInfo(String id, String name) {
+ this.id = id;
+ this.name = name;
+ this.ready = false;
+ }
+
+ // Set the ready state / 设置准备状态
+ public void setReady(boolean ready) {
+ this.ready = ready;
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/model/Room.java b/backend/src/main/java/com/zombie/game/model/Room.java
new file mode 100644
index 0000000..9ab3d3d
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/model/Room.java
@@ -0,0 +1,106 @@
+package com.zombie.game.model;
+
+import lombok.Getter;
+import java.util.*;
+
+import static com.zombie.game.model.Constants.*;
+
+/** Game room holding players and game state / 游戏房间，管理玩家和游戏状态 */
+@Getter
+public class Room {
+ // Room unique identifier / 房间唯一标识
+ private String id;
+ // Host player ID / 房主玩家ID
+ private String hostId;
+ // Map of playerId to PlayerInfo / 玩家ID到玩家信息的映射
+ private Map players;
+ // Whether the game has started / 游戏是否已开始
+ private boolean gameStarted;
+ // Maximum number of players allowed / 最大玩家数量
+ private final int maxPlayers = 4;
+
+ // Set game started flag / 设置游戏开始标志
+ public void setGameStarted(boolean started) { this.gameStarted = started; }
+
+ // Create a new room with the host player / 创建新房间并添加房主
+ public Room(String id, String hostId, String hostName) {
+ this.id = id;
+ this.hostId = hostId;
+ this.players = new LinkedHashMap<>();
+ players.put(hostId, new PlayerInfo(hostId, hostName));
+ }
+
+ // Add a player to the room / 添加玩家到房间
+ public boolean addPlayer(String playerId, String playerName) {
+ if (players.size() >= maxPlayers) return false;
+ if (players.containsKey(playerId)) return false;
+ players.put(playerId, new PlayerInfo(playerId, playerName));
+ return true;
+ }
+
+ // Remove a player from the room / 从房间移除玩家
+ public void removePlayer(String playerId) {
+ players.remove(playerId);
+ }
+
+ // Get player by ID / 根据ID获取玩家
+ public PlayerInfo getPlayer(String playerId) {
+ return players.get(playerId);
+ }
+
+ // Get all players / 获取所有玩家
+ public Collection getPlayers() {
+ return players.values();
+ }
+
+ // Get current player count / 获取当前玩家数量
+ public int getPlayerCount() {
+ return players.size();
+ }
+
+ // Check if a player is the host / 检查玩家是否为房主
+ public boolean isHost(String playerId) {
+ return hostId.equals(playerId);
+ }
+
+ // Check if all non-host players are ready / 检查所有非房主玩家是否已准备
+ public boolean allReady() {
+ for (PlayerInfo p : players.values()) {
+ if (!p.getId().equals(hostId) && !p.isReady()) return false;
+ }
+ return true;
+ }
+
+ // Convert room state to a map for a specific player / 将房间状态转换为指定玩家的Map
+ public Map toStateMap(String playerId) {
+ Map map = new LinkedHashMap<>();
+ map.put("roomId", id);
+ map.put("hostId", hostId);
+ map.put("isHost", hostId.equals(playerId));
+ map.put("playerId", playerId);
+
+ // Build player list with index / 构建带索引的玩家列表
+ List> playerList = new ArrayList<>();
+ int index = 0;
+ for (PlayerInfo p : players.values()) {
+ Map pm = new LinkedHashMap<>();
+ pm.put("id", p.getId());
+ pm.put("name", p.getName());
+ pm.put("ready", p.isReady());
+ pm.put("index", index++);
+ playerList.add(pm);
+ }
+ map.put("players", playerList);
+ return map;
+ }
+
+ // Convert to a lightweight room list entry / 转换为轻量级房间列表条目
+ public Map toRoomListMap() {
+ Map map = new LinkedHashMap<>();
+ map.put("id", id);
+ PlayerInfo host = players.get(hostId);
+ map.put("hostName", host != null ? host.getName() : "Unknown");
+ map.put("playerCount", players.size());
+ return map;
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/server/GameLoop.java b/backend/src/main/java/com/zombie/game/server/GameLoop.java
new file mode 100644
index 0000000..0b90e00
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/server/GameLoop.java
@@ -0,0 +1,73 @@
+package com.zombie.game.server;
+
+import com.zombie.game.ecs.ECSWorld;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Game loop running at fixed tick rate for a single room / 以固定帧率运行的游戏循环，为单个房间服务
+ */
+public class GameLoop {
+ // Room ID this loop serves / 该循环服务的房间ID
+ private String roomId;
+ // The ECS world being updated / 正在更新的ECS世界
+ private ECSWorld world;
+ // Callback to broadcast state each tick / 每帧广播状态的回调
+ private GameService.GameStateBroadcast broadcaster;
+ // Whether the loop is currently running / 循环当前是否正在运行
+ private volatile boolean running;
+ // Target tick rate (30 ticks per second) / 目标帧率（每秒30帧）
+ private static final int TICK_RATE = 30;
+ // Interval between ticks in milliseconds / 帧间隔（毫秒）
+ private static final long TICK_INTERVAL_MS = 1000 / TICK_RATE;
+ // Interval between ticks in seconds / 帧间隔（秒）
+ private static final float TICK_INTERVAL_SEC = 1.0f / TICK_RATE;
+ // Scheduler for running the loop / 运行循环的调度器
+ private ScheduledExecutorService scheduler;
+
+ // Constructor: sets up the game loop for a room / 构造函数：为房间设置游戏循环
+ public GameLoop(String roomId, ECSWorld world, GameService.GameStateBroadcast broadcaster) {
+ this.roomId = roomId;
+ this.world = world;
+ this.broadcaster = broadcaster;
+ this.running = true;
+ // Create single-threaded daemon scheduler / 创建单线程守护调度器
+ this.scheduler = Executors.newSingleThreadScheduledExecutor(r -> {
+ Thread t = new Thread(r, "GameLoop-" + roomId);
+ t.setDaemon(true);
+ return t;
+ });
+ }
+
+ // Start the game loop / 启动游戏循环
+ public void start() {
+ scheduler.scheduleAtFixedRate(this::tick, 0, TICK_INTERVAL_MS, TimeUnit.MILLISECONDS);
+ }
+
+ // Single tick: update world and broadcast state / 单帧：更新世界并广播状态
+ private void tick() {
+ if (!running) return;
+ synchronized (world.getLock()) {
+ world.update(TICK_INTERVAL_SEC);
+ }
+ broadcaster.broadcast(roomId, world);
+ }
+
+ // Stop the game loop / 停止游戏循环
+ public void stop() {
+ running = false;
+ if (scheduler != null && !scheduler.isShutdown()) {
+ scheduler.shutdown();
+ try {
+ // Force shutdown if graceful shutdown fails / 优雅关闭失败则强制关闭
+ if (!scheduler.awaitTermination(1, TimeUnit.SECONDS)) {
+ scheduler.shutdownNow();
+ }
+ } catch (InterruptedException e) {
+ scheduler.shutdownNow();
+ }
+ }
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/server/GameService.java b/backend/src/main/java/com/zombie/game/server/GameService.java
new file mode 100644
index 0000000..ac43691
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/server/GameService.java
@@ -0,0 +1,163 @@
+package com.zombie.game.server;
+
+import com.zombie.game.ecs.ECSWorld;
+import com.zombie.game.ecs.components.*;
+import com.zombie.game.model.*;
+import com.zombie.game.systems.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Core game service managing game lifecycle and state / 核心游戏服务，管理游戏生命周期和状态
+ */
+public class GameService {
+ // Logger for game events / 游戏事件日志记录器
+ private static final Logger logger = LoggerFactory.getLogger(GameService.class);
+
+ // Active game worlds mapped by room ID / 活跃的游戏世界，以房间ID映射
+ private final Map activeGames = new ConcurrentHashMap<>();
+ // Game loops mapped by room ID / 游戏循环，以房间ID映射
+ private final Map gameLoops = new ConcurrentHashMap<>();
+ // Callback for broadcasting game state / 广播游戏状态的回调
+ private final GameStateBroadcast broadcaster;
+
+ // Interface for broadcasting game state to clients / 向客户端广播游戏状态的接口
+ public interface GameStateBroadcast {
+ void broadcast(String roomId, ECSWorld world);
+ }
+
+ // Constructor with broadcast callback / 带广播回调的构造函数
+ public GameService(GameStateBroadcast broadcaster) {
+ this.broadcaster = broadcaster;
+ }
+
+ // Start a new game for the given room / 为指定房间启动新游戏
+ public Map> startGame(Room room) {
+ // Load map from system property or default / 从系统属性或默认路径加载地图
+ String mapPath = System.getProperty("map.path", "maps/d540209a.json");
+ ECSWorld world = new ECSWorld(mapPath);
+
+ // Add systems in order: input -> flow field -> zombie spawn -> zombie movement
+ world.addSystem(new PlayerInputSystem());
+ world.addSystem(new FlowFieldUpdateSystem());
+ world.addSystem(new ZombieSpawnSystem());
+ world.addSystem(new ZombieMovementSystem());
+
+ // Spawn players at map spawn points / 在地图出生点生成玩家
+ int index = 0;
+ List spawnPoints = world.getMap().getSpawnPoints();
+
+ for (PlayerInfo playerInfo : room.getPlayers()) {
+ int[] sp = spawnPoints.get(index % spawnPoints.size());
+ float wx = sp[0] + 0.5f;
+ float wy = sp[1] + 0.5f;
+ world.createPlayerEntity(playerInfo.getId(), playerInfo.getName(), wx, wy);
+ index++;
+ }
+
+ // Spawn test zombies at zombie spawn points / 在僵尸出生点生成测试僵尸
+ List zombieSpawns = world.getMap().getZombieSpawnPoints();
+ for (int[] zsp : zombieSpawns) {
+ int zombieId = world.createZombieEntity(zsp[0] + 0.5f, zsp[1] + 0.5f);
+ logger.info("Initial zombie created: id={} at ({}, {})", zombieId, zsp[0], zsp[1]);
+ }
+
+ activeGames.put(room.getId(), world);
+
+ // Build initial data for each player / 为每位玩家构建初始数据
+ Map> playerInitData = new LinkedHashMap<>();
+ for (PlayerInfo playerInfo : room.getPlayers()) {
+ Map data = new LinkedHashMap<>();
+ data.put("playerId", playerInfo.getId());
+ data.put("mapData", serializeMapData(world.getMapData()));
+
+ // Build player list with positions / 构建包含位置的玩家列表
+ List> playerList = new ArrayList<>();
+ int idx = 0;
+ for (PlayerInfo p : room.getPlayers()) {
+ Integer entityId = world.getPlayerEntity(p.getId());
+ Map pm = new LinkedHashMap<>();
+ pm.put("id", p.getId());
+ pm.put("name", p.getName());
+ if (entityId != null) {
+ Position pos = world.getPositions().get(entityId);
+ if (pos != null) {
+ pm.put("x", pos.getX());
+ pm.put("y", pos.getY());
+ }
+ }
+ pm.put("index", idx++);
+ playerList.add(pm);
+ }
+ data.put("players", playerList);
+ playerInitData.put(playerInfo.getId(), data);
+ }
+
+ // Create game loop (not started yet) / 创建游戏循环（尚未启动）
+ GameLoop loop = new GameLoop(room.getId(), world, broadcaster);
+ gameLoops.put(room.getId(), loop);
+
+ logger.info("Game initialized for room: {}", room.getId());
+ return playerInitData;
+ }
+
+ // Start the game loop for a room (call after sending game_started) / 启动房间的游戏循环（在发送 game_started 之后调用）
+ public void startGameLoop(String roomId) {
+ GameLoop loop = gameLoops.get(roomId);
+ if (loop != null) {
+ loop.start();
+ }
+ }
+
+ // Stop the game for a room / 停止指定房间的游戏
+ public void stopGame(String roomId) {
+ GameLoop loop = gameLoops.remove(roomId);
+ if (loop != null) {
+ loop.stop();
+ }
+ activeGames.remove(roomId);
+ logger.info("Game stopped for room: {}", roomId);
+ }
+
+ // Process player input for movement and aiming / 处理玩家输入（移动和瞄准）
+ public void processPlayerInput(String roomId, String playerId,
+ float dx, float dy, float aimX, float aimY, int seq) {
+ ECSWorld world = activeGames.get(roomId);
+ if (world == null) return;
+
+ synchronized (world.getLock()) {
+ Integer entityId = world.getPlayerEntity(playerId);
+ if (entityId == null) return;
+
+ // Skip if player is dead / 如果玩家已死亡则跳过
+ Health health = world.getHealths().get(entityId);
+ if (health == null || !health.isAlive()) return;
+
+ // Apply input to player entity / 将输入应用到玩家实体
+ PlayerInput input = world.getPlayerInputs().get(entityId);
+ if (input == null) return;
+
+ input.setDx(dx);
+ input.setDy(dy);
+ input.setAimX(aimX);
+ input.setAimY(aimY);
+ input.setSeq(seq);
+ }
+ }
+
+ // Convert 2D int array to nested list for JSON serialization / 将二维整数数组转换为嵌套列表用于JSON序列化
+ private List> serializeMapData(int[][] cells) {
+ List> result = new ArrayList<>();
+ for (int[] row : cells) {
+ List rowList = new ArrayList<>();
+ for (int cell : row) {
+ rowList.add(cell);
+ }
+ result.add(rowList);
+ }
+ return result;
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/server/GameWebSocketServer.java b/backend/src/main/java/com/zombie/game/server/GameWebSocketServer.java
new file mode 100644
index 0000000..616fcdb
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/server/GameWebSocketServer.java
@@ -0,0 +1,370 @@
+package com.zombie.game.server;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+import com.zombie.game.ecs.ECSWorld;
+import com.zombie.game.model.*;
+import com.zombie.game.model.Constants;
+import com.zombie.game.systems.StateSyncSystem;
+import org.java_websocket.WebSocket;
+import org.java_websocket.handshake.ClientHandshake;
+import org.java_websocket.server.WebSocketServer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.net.InetSocketAddress;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Main WebSocket server handling all client connections / 主WebSocket服务器，处理所有客户端连接
+ * Manages game rooms, player connections, and message routing / 管理游戏房间、玩家连接和消息路由
+ */
+public class GameWebSocketServer extends WebSocketServer {
+ // SLF4J logger for server events / SLF4J日志记录器，用于服务器事件
+ private static final Logger logger = LoggerFactory.getLogger(GameWebSocketServer.class);
+ // JSON serializer/deserializer / JSON序列化/反序列化工具
+ private Gson gson;
+ // Room manager for creating and tracking game rooms / 房间管理器，用于创建和追踪游戏房间
+ private RoomManager roomManager;
+ // Game service for game logic / 游戏服务，用于游戏逻辑处理
+ private GameService gameService;
+ // Map connection to player ID / 连接映射到玩家ID
+ private Map connectionToPlayer;
+ // Map player ID to connection / 玩家ID映射到连接
+ private Map playerToConnection;
+ // Timer for broadcasting room list periodically / 定时器，用于定期广播房间列表
+ private Timer roomListTimer;
+
+ // Constructor: initializes server with given port / 构造函数：用指定端口初始化服务器
+ public GameWebSocketServer(int port) {
+ super(new InetSocketAddress(port));
+ this.gson = new Gson();
+ this.roomManager = new RoomManager();
+ this.connectionToPlayer = new ConcurrentHashMap<>();
+ this.playerToConnection = new ConcurrentHashMap<>();
+ this.gameService = new GameService(this::broadcastGameState);
+ }
+
+ // Called when a new client connects / 新客户端连接时调用
+ @Override
+ public void onOpen(WebSocket conn, ClientHandshake handshake) {
+ logger.info("New connection: {}", conn.getRemoteSocketAddress());
+ }
+
+ // Called when a client disconnects / 客户端断开连接时调用
+ @Override
+ public void onClose(WebSocket conn, int code, String reason, boolean remote) {
+ logger.info("Connection closed: {}", conn.getRemoteSocketAddress());
+ // Remove player mapping and handle room leave / 移除玩家映射并处理离开房间
+ String playerId = connectionToPlayer.remove(conn);
+ if (playerId != null) {
+ playerToConnection.remove(playerId);
+ handleLeaveRoomByPlayerId(playerId);
+ }
+ }
+
+ // Called when a message is received from a client / 收到客户端消息时调用
+ @Override
+ public void onMessage(WebSocket conn, String message) {
+ try {
+ // Parse message type and data / 解析消息类型和数据
+ JsonObject msg = gson.fromJson(message, JsonObject.class);
+ String type = msg.get("type").getAsString();
+ JsonObject data = msg.has("data") ? msg.getAsJsonObject("data") : new JsonObject();
+
+ // Route message to appropriate handler / 将消息路由到对应的处理函数
+ switch (type) {
+ case Constants.MSG_CREATE_ROOM:
+ handleCreateRoom(conn, data);
+ break;
+ case Constants.MSG_JOIN_ROOM:
+ handleJoinRoom(conn, data);
+ break;
+ case Constants.MSG_LEAVE_ROOM:
+ handleLeaveRoomByConn(conn);
+ break;
+ case Constants.MSG_ROOM_LIST:
+ handleRoomList(conn);
+ break;
+ case Constants.MSG_READY:
+ handleReady(conn);
+ break;
+ case Constants.MSG_START_GAME:
+ handleStartGame(conn);
+ break;
+ case Constants.MSG_PLAYER_INPUT:
+ handlePlayerInput(conn, data);
+ break;
+ }
+ } catch (Exception e) {
+ logger.error("Error processing message from {}", conn.getRemoteSocketAddress(), e);
+ sendError(conn, "Invalid message format");
+ }
+ }
+
+ // Called when a WebSocket error occurs / WebSocket错误发生时调用
+ @Override
+ public void onError(WebSocket conn, Exception ex) {
+ logger.error("WebSocket error on {}", conn != null ? conn.getRemoteSocketAddress() : "null", ex);
+ }
+
+ // Called when the server starts successfully / 服务器成功启动时调用
+ @Override
+ public void onStart() {
+ logger.info("Game WebSocket Server started on port {}", getPort());
+ // Start periodic room list broadcast (every 2 seconds) / 启动定期房间列表广播（每2秒）
+ roomListTimer = new Timer(true);
+ roomListTimer.scheduleAtFixedRate(new TimerTask() {
+ @Override
+ public void run() {
+ broadcastRoomList();
+ }
+ }, 0, 2000);
+ }
+
+ // Handle create room request / 处理创建房间请求
+ private void handleCreateRoom(WebSocket conn, JsonObject data) {
+ // Validate required fields / 验证必需字段
+ if (!MessageUtils.hasRequired(data, "playerName")) {
+ sendError(conn, "Missing playerName");
+ return;
+ }
+ String playerName = MessageUtils.getString(data, "playerName");
+ // Generate unique IDs for player and room / 为玩家和房间生成唯一ID
+ String playerId = UUID.randomUUID().toString();
+ String roomId = UUID.randomUUID().toString().substring(0, 8);
+
+ // Track connection mappings / 记录连接映射
+ connectionToPlayer.put(conn, playerId);
+ playerToConnection.put(playerId, conn);
+
+ // Create new room with player as host / 创建新房间，玩家作为房主
+ Room room = new Room(roomId, playerId, playerName);
+ roomManager.addRoom(roomId, room);
+
+ // Send room state back to creator / 向创建者发送房间状态
+ sendToConnection(conn, Constants.MSG_ROOM_STATE, room.toStateMap(playerId));
+ logger.info("Room created: {} by {}", roomId, playerName);
+ }
+
+ // Handle join room request / 处理加入房间请求
+ private void handleJoinRoom(WebSocket conn, JsonObject data) {
+ // Validate required fields / 验证必需字段
+ if (!MessageUtils.hasRequired(data, "roomId", "playerName")) {
+ sendError(conn, "Missing roomId or playerName");
+ return;
+ }
+ String roomId = MessageUtils.getString(data, "roomId");
+ String playerName = MessageUtils.getString(data, "playerName");
+
+ Room room = roomManager.getRoom(roomId);
+ if (room == null) {
+ sendError(conn, "Room not found");
+ return;
+ }
+
+ // Check if room is full (max 4 players) / 检查房间是否已满（最多4人）
+ if (room.getPlayerCount() >= 4) {
+ sendError(conn, "Room is full");
+ return;
+ }
+
+ // Generate player ID and track connection / 生成玩家ID并追踪连接
+ String playerId = UUID.randomUUID().toString();
+ connectionToPlayer.put(conn, playerId);
+ playerToConnection.put(playerId, conn);
+
+ // Add player to room / 将玩家添加到房间
+ room.addPlayer(playerId, playerName);
+ roomManager.joinRoom(roomId, playerId, playerName);
+
+ // Notify all players of updated room state / 通知所有玩家房间状态已更新
+ broadcastRoomState(room);
+ logger.info("Player {} joined room {}", playerName, roomId);
+ }
+
+ // Handle leave room by connection / 通过连接处理离开房间
+ private void handleLeaveRoomByConn(WebSocket conn) {
+ String playerId = connectionToPlayer.get(conn);
+ if (playerId == null) return;
+ handleLeaveRoomByPlayerId(playerId);
+ }
+
+ // Handle leave room by player ID / 通过玩家ID处理离开房间
+ private void handleLeaveRoomByPlayerId(String playerId) {
+ Room room = roomManager.leaveRoom(playerId);
+ if (room == null) return;
+
+ Room updatedRoom = roomManager.getRoom(room.getId());
+ if (updatedRoom == null) {
+ // Room was deleted, stop the game / 房间被删除，停止游戏
+ gameService.stopGame(room.getId());
+ } else {
+ // Notify remaining players / 通知剩余玩家
+ broadcastRoomState(updatedRoom);
+ }
+ }
+
+ // Handle room list request / 处理房间列表请求
+ private void handleRoomList(WebSocket conn) {
+ List> roomList = new ArrayList<>();
+ for (Room room : roomManager.getAvailableRooms()) {
+ roomList.add(room.toRoomListMap());
+ }
+ Map data = new LinkedHashMap<>();
+ data.put("rooms", roomList);
+ sendToConnection(conn, Constants.MSG_ROOM_LIST, data);
+ }
+
+ // Handle player ready toggle / 处理玩家准备状态切换
+ private void handleReady(WebSocket conn) {
+ String playerId = connectionToPlayer.get(conn);
+ if (playerId == null) return;
+
+ Room room = roomManager.getRoomByPlayerId(playerId);
+ if (room == null) return;
+
+ PlayerInfo player = room.getPlayer(playerId);
+ if (player != null) {
+ // Toggle ready state / 切换准备状态
+ player.setReady(!player.isReady());
+ broadcastRoomState(room);
+ }
+ }
+
+ // Handle start game request (host only) / 处理开始游戏请求（仅房主）
+ private void handleStartGame(WebSocket conn) {
+ String playerId = connectionToPlayer.get(conn);
+ if (playerId == null) {
+ sendError(conn, "Not in a room / 未在房间中");
+ return;
+ }
+
+ Room room = roomManager.getRoomByPlayerId(playerId);
+ if (room == null) {
+ sendError(conn, "Room not found / 房间不存在");
+ return;
+ }
+
+ if (!room.isHost(playerId)) {
+ sendError(conn, "Only host can start game / 只有房主可以开始游戏");
+ return;
+ }
+ if (room.isGameStarted()) {
+ sendError(conn, "Game already started / 游戏已经开始");
+ return;
+ }
+ if (!room.allReady()) {
+ sendError(conn, "Not all players are ready / 不是所有玩家都已准备");
+ return;
+ }
+
+ // Set game started flag after startGame succeeds / startGame 成功后再设置标志
+ try {
+ startGame(room);
+ room.setGameStarted(true);
+ } catch (Exception e) {
+ logger.error("Failed to start game for room {}", room.getId(), e);
+ sendError(conn, "Failed to start game: " + e.getMessage());
+ }
+ }
+
+ // Start the game for a room / 为房间启动游戏
+ private void startGame(Room room) {
+ // Initialize game world and create player entities / 初始化游戏世界并创建玩家实体
+ Map> playerInitData = gameService.startGame(room);
+
+ // Send initial game data to each player / 向每位玩家发送初始游戏数据
+ for (Map.Entry> entry : playerInitData.entrySet()) {
+ WebSocket pConn = playerToConnection.get(entry.getKey());
+ if (pConn != null) {
+ sendToConnection(pConn, Constants.MSG_GAME_STARTED, entry.getValue());
+ }
+ }
+
+ // Start game loop after game_started is sent / game_started 发送完毕后再启动游戏循环
+ gameService.startGameLoop(room.getId());
+ }
+
+ // Handle player input (movement, aim) / 处理玩家输入（移动、瞄准）
+ private void handlePlayerInput(WebSocket conn, JsonObject data) {
+ String playerId = connectionToPlayer.get(conn);
+ if (playerId == null) return;
+
+ Room room = roomManager.getRoomByPlayerId(playerId);
+ if (room == null || !room.isGameStarted()) return;
+
+ // Extract input data / 提取输入数据
+ float dx = MessageUtils.getFloat(data, "dx", 0);
+ float dy = MessageUtils.getFloat(data, "dy", 0);
+ float aimX = MessageUtils.getFloat(data, "aimX", 0);
+ float aimY = MessageUtils.getFloat(data, "aimY", 0);
+ int seq = MessageUtils.getInt(data, "seq", 0);
+
+ gameService.processPlayerInput(room.getId(), playerId, dx, dy, aimX, aimY, seq);
+ }
+
+ // Broadcast game state to all players in a room / 向房间内所有玩家广播游戏状态
+ private void broadcastGameState(String roomId, ECSWorld world) {
+ Room room = roomManager.getRoom(roomId);
+ if (room == null) return;
+
+ StateSyncSystem syncSystem = new StateSyncSystem();
+
+ // Sync state under world lock / 在世界锁下同步状态
+ synchronized (world.getLock()) {
+ Map state = syncSystem.buildGameState(world);
+ for (PlayerInfo playerInfo : room.getPlayers()) {
+ WebSocket pConn = playerToConnection.get(playerInfo.getId());
+ if (pConn != null && pConn.isOpen()) {
+ sendToConnection(pConn, Constants.MSG_GAME_STATE, state);
+ }
+ }
+ }
+ }
+
+ // Broadcast room state to all players in a room / 向房间内所有玩家广播房间状态
+ private void broadcastRoomState(Room room) {
+ for (PlayerInfo player : room.getPlayers()) {
+ WebSocket pConn = playerToConnection.get(player.getId());
+ if (pConn != null && pConn.isOpen()) {
+ sendToConnection(pConn, Constants.MSG_ROOM_STATE, room.toStateMap(player.getId()));
+ }
+ }
+ }
+
+ // Broadcast room list to all unconnected clients / 向所有未连接的玩家广播房间列表
+ private void broadcastRoomList() {
+ List> roomList = new ArrayList<>();
+ for (Room room : roomManager.getAvailableRooms()) {
+ roomList.add(room.toRoomListMap());
+ }
+ Map data = new LinkedHashMap<>();
+ data.put("rooms", roomList);
+
+ // Only send to clients not in a room / 只发送给不在房间中的客户端
+ for (WebSocket conn : getConnections()) {
+ if (connectionToPlayer.get(conn) == null) {
+ sendToConnection(conn, Constants.MSG_ROOM_LIST, data);
+ }
+ }
+ }
+
+ // Send a message to a specific connection / 向指定连接发送消息
+ private void sendToConnection(WebSocket conn, String type, Object data) {
+ if (conn != null && conn.isOpen()) {
+ Map msg = new LinkedHashMap<>();
+ msg.put("type", type);
+ msg.put("data", data);
+ conn.send(gson.toJson(msg));
+ }
+ }
+
+ // Send error message to a connection / 向连接发送错误消息
+ private void sendError(WebSocket conn, String message) {
+ Map data = new LinkedHashMap<>();
+ data.put("message", message);
+ sendToConnection(conn, Constants.MSG_ERROR, data);
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/server/MapStorage.java b/backend/src/main/java/com/zombie/game/server/MapStorage.java
new file mode 100644
index 0000000..6f46d8b
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/server/MapStorage.java
@@ -0,0 +1,136 @@
+package com.zombie.game.server;
+
+import com.google.gson.Gson;
+import com.zombie.game.model.MapData;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.*;
+import java.nio.file.*;
+import java.util.*;
+
+/**
+ * Storage service for game maps (save, load, list, delete) / 地图存储服务（保存、加载、列出、删除）
+ */
+public class MapStorage {
+ // Logger for map operations / 地图操作日志记录器
+ private static final Logger logger = LoggerFactory.getLogger(MapStorage.class);
+ // Directory where map files are stored / 地图文件存储目录
+ private static final String MAPS_DIR = "maps";
+ // JSON serializer/deserializer / JSON序列化/反序列化工具
+ private final Gson gson;
+ // In-memory cache of loaded maps / 已加载地图的内存缓存
+ private final Map cache;
+
+ // Constructor: initializes storage and ensures maps directory exists / 构造函数：初始化存储并确保地图目录存在
+ public MapStorage() {
+ this.gson = new Gson();
+ this.cache = new HashMap<>();
+ ensureMapsDir();
+ }
+
+ // Create maps directory if it doesn't exist / 如果地图目录不存在则创建
+ private void ensureMapsDir() {
+ Path mapsPath = Paths.get(MAPS_DIR);
+ if (!Files.exists(mapsPath)) {
+ try {
+ Files.createDirectories(mapsPath);
+ } catch (IOException e) {
+ logger.error("Failed to create maps directory", e);
+ }
+ }
+ }
+
+ // Save a map to disk and cache / 将地图保存到磁盘并缓存
+ public MapData save(MapData mapData) {
+ // Assign ID if missing / 如果缺少ID则生成
+ if (mapData.getId() == null || mapData.getId().isEmpty()) {
+ mapData.setId(UUID.randomUUID().toString().substring(0, 8));
+ }
+ // Set default name if missing / 如果缺少名称则使用默认值
+ if (mapData.getName() == null || mapData.getName().isEmpty()) {
+ mapData.setName("untitled");
+ }
+
+ String filename = mapData.getId() + ".json";
+ Path filePath = Paths.get(MAPS_DIR, filename);
+
+ try (Writer writer = Files.newBufferedWriter(filePath)) {
+ gson.toJson(mapData, writer);
+ cache.put(mapData.getId(), mapData);
+ logger.info("Map saved: {} ({})", mapData.getName(), mapData.getId());
+ return mapData;
+ } catch (IOException e) {
+ logger.error("Failed to save map: {}", mapData.getId(), e);
+ throw new RuntimeException("Failed to save map", e);
+ }
+ }
+
+ // Load a map from cache or disk / 从缓存或磁盘加载地图
+ public MapData load(String id) {
+ // Check cache first / 先检查缓存
+ MapData cached = cache.get(id);
+ if (cached != null) {
+ return cached;
+ }
+
+ String filename = id + ".json";
+ Path filePath = Paths.get(MAPS_DIR, filename);
+
+ if (!Files.exists(filePath)) {
+ return null;
+ }
+
+ try (Reader reader = Files.newBufferedReader(filePath)) {
+ MapData mapData = gson.fromJson(reader, MapData.class);
+ cache.put(id, mapData);
+ return mapData;
+ } catch (IOException e) {
+ logger.error("Failed to load map: {}", id, e);
+ return null;
+ }
+ }
+
+ // List all maps from disk / 列出磁盘上的所有地图
+ public List listMaps() {
+ List maps = new ArrayList<>();
+ Path mapsPath = Paths.get(MAPS_DIR);
+
+ if (!Files.exists(mapsPath)) {
+ return maps;
+ }
+
+ try (DirectoryStream stream = Files.newDirectoryStream(mapsPath, "*.json")) {
+ for (Path file : stream) {
+ try (Reader reader = Files.newBufferedReader(file)) {
+ MapData mapData = gson.fromJson(reader, MapData.class);
+ maps.add(mapData);
+ } catch (IOException e) {
+ logger.warn("Failed to read map file: {}", file);
+ }
+ }
+ } catch (IOException e) {
+ logger.error("Failed to list maps", e);
+ }
+
+ return maps;
+ }
+
+ // Delete a map from disk and cache / 从磁盘和缓存中删除地图
+ public boolean delete(String id) {
+ String filename = id + ".json";
+ Path filePath = Paths.get(MAPS_DIR, filename);
+
+ try {
+ boolean deleted = Files.deleteIfExists(filePath);
+ if (deleted) {
+ cache.remove(id);
+ logger.info("Map deleted: {}", id);
+ }
+ return deleted;
+ } catch (IOException e) {
+ logger.error("Failed to delete map: {}", id, e);
+ return false;
+ }
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/server/MessageUtils.java b/backend/src/main/java/com/zombie/game/server/MessageUtils.java
new file mode 100644
index 0000000..2ea0096
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/server/MessageUtils.java
@@ -0,0 +1,73 @@
+package com.zombie.game.server;
+
+import com.google.gson.JsonObject;
+
+/**
+ * Utility class for extracting values from JSON messages / 工具类，用于从JSON消息中提取值
+ */
+public class MessageUtils {
+
+ // Get string value from JSON with default / 从JSON获取字符串值，带默认值
+ public static String getString(JsonObject data, String key, String defaultValue) {
+ if (data == null || !data.has(key) || data.get(key).isJsonNull()) {
+ return defaultValue;
+ }
+ try {
+ return data.get(key).getAsString();
+ } catch (Exception e) {
+ return defaultValue;
+ }
+ }
+
+ // Get string value from JSON (null default) / 从JSON获取字符串值（默认null）
+ public static String getString(JsonObject data, String key) {
+ return getString(data, key, null);
+ }
+
+ // Get float value from JSON with default / 从JSON获取浮点数值，带默认值
+ public static float getFloat(JsonObject data, String key, float defaultValue) {
+ if (data == null || !data.has(key) || data.get(key).isJsonNull()) {
+ return defaultValue;
+ }
+ try {
+ return data.get(key).getAsFloat();
+ } catch (Exception e) {
+ return defaultValue;
+ }
+ }
+
+ // Get int value from JSON with default / 从JSON获取整数值，带默认值
+ public static int getInt(JsonObject data, String key, int defaultValue) {
+ if (data == null || !data.has(key) || data.get(key).isJsonNull()) {
+ return defaultValue;
+ }
+ try {
+ return data.get(key).getAsInt();
+ } catch (Exception e) {
+ return defaultValue;
+ }
+ }
+
+ // Get boolean value from JSON with default / 从JSON获取布尔值，带默认值
+ public static boolean getBoolean(JsonObject data, String key, boolean defaultValue) {
+ if (data == null || !data.has(key) || data.get(key).isJsonNull()) {
+ return defaultValue;
+ }
+ try {
+ return data.get(key).getAsBoolean();
+ } catch (Exception e) {
+ return defaultValue;
+ }
+ }
+
+ // Check if all required keys are present and non-null / 检查所有必需键是否存在且非空
+ public static boolean hasRequired(JsonObject data, String... keys) {
+ if (data == null) return false;
+ for (String key : keys) {
+ if (!data.has(key) || data.get(key).isJsonNull()) {
+ return false;
+ }
+ }
+ return true;
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/server/RoomManager.java b/backend/src/main/java/com/zombie/game/server/RoomManager.java
new file mode 100644
index 0000000..b265f2e
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/server/RoomManager.java
@@ -0,0 +1,103 @@
+package com.zombie.game.server;
+
+import com.zombie.game.model.PlayerInfo;
+import com.zombie.game.model.Room;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Room manager for tracking game rooms and player-room assignments / 房间管理器，用于追踪游戏房间和玩家房间分配
+ */
+public class RoomManager {
+ // All active rooms mapped by room ID / 所有活跃房间，以房间ID映射
+ private final Map rooms = new ConcurrentHashMap<>();
+ // Player ID to room ID mapping / 玩家ID到房间ID的映射
+ private final Map playerToRoom = new ConcurrentHashMap<>();
+
+ // Add a new room to the manager / 向管理器添加新房间
+ public void addRoom(String roomId, Room room) {
+ rooms.put(roomId, room);
+ // Map existing players in room to room ID / 将房间中现有玩家映射到房间ID
+ for (PlayerInfo player : room.getPlayers()) {
+ playerToRoom.put(player.getId(), roomId);
+ }
+ }
+
+ // Add a player to a room / 将玩家添加到房间
+ public boolean joinRoom(String roomId, String playerId, String playerName) {
+ Room room = rooms.get(roomId);
+ if (room == null) return false;
+ // Reject if room is full / 房间已满则拒绝
+ if (room.getPlayerCount() >= 4) return false;
+
+ boolean added = room.addPlayer(playerId, playerName);
+ if (added) {
+ playerToRoom.put(playerId, roomId);
+ }
+ return added;
+ }
+
+ // Remove a player from their room / 从房间中移除玩家
+ public Room leaveRoom(String playerId) {
+ String roomId = playerToRoom.remove(playerId);
+ if (roomId == null) return null;
+
+ Room room = rooms.get(roomId);
+ if (room == null) return null;
+
+ room.removePlayer(playerId);
+ // Delete room if empty / 如果房间为空则删除
+ if (room.getPlayerCount() == 0) {
+ rooms.remove(roomId);
+ return null;
+ }
+ return room;
+ }
+
+ // Get room by player ID / 通过玩家ID获取房间
+ public Room getRoomByPlayerId(String playerId) {
+ String roomId = playerToRoom.get(playerId);
+ if (roomId == null) return null;
+ return rooms.get(roomId);
+ }
+
+ // Get room by room ID / 通过房间ID获取房间
+ public Room getRoom(String roomId) {
+ return rooms.get(roomId);
+ }
+
+ // Get all rooms / 获取所有房间
+ public Collection getAllRooms() {
+ return rooms.values();
+ }
+
+ // Get rooms that haven't started a game yet / 获取尚未开始游戏的房间
+ public List getAvailableRooms() {
+ List available = new ArrayList<>();
+ for (Room room : rooms.values()) {
+ if (!room.isGameStarted()) {
+ available.add(room);
+ }
+ }
+ return available;
+ }
+
+ // Remove a room and all player mappings / 移除房间及其所有玩家映射
+ public void removeRoom(String roomId) {
+ Room room = rooms.remove(roomId);
+ if (room != null) {
+ for (PlayerInfo player : room.getPlayers()) {
+ playerToRoom.remove(player.getId());
+ }
+ }
+ }
+
+ // Check if a player is in any room / 检查玩家是否在任意房间中
+ public boolean isPlayerInRoom(String playerId) {
+ return playerToRoom.containsKey(playerId);
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/systems/FlowFieldUpdateSystem.java b/backend/src/main/java/com/zombie/game/systems/FlowFieldUpdateSystem.java
new file mode 100644
index 0000000..816e068
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/systems/FlowFieldUpdateSystem.java
@@ -0,0 +1,30 @@
+package com.zombie.game.systems;
+
+import com.zombie.game.ecs.ECSWorld;
+import com.zombie.game.ecs.System;
+import com.zombie.game.ecs.components.Position;
+import com.zombie.game.model.GameMap;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/** Updates flow field each frame based on player positions / 每帧根据玩家位置更新流场 */
+public class FlowFieldUpdateSystem implements System {
+
+ @Override
+ public void update(float dt, ECSWorld world) {
+ GameMap map = world.getMap();
+
+ List playerPositions = new ArrayList<>();
+ for (int entityId : world.getPlayers()) {
+ Position pos = world.getPositions().get(entityId);
+ if (pos != null) {
+ playerPositions.add(new float[]{pos.getX(), pos.getY()});
+ }
+ }
+
+ if (!playerPositions.isEmpty()) {
+ map.updateFlowField(playerPositions);
+ }
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/systems/PlayerInputSystem.java b/backend/src/main/java/com/zombie/game/systems/PlayerInputSystem.java
new file mode 100644
index 0000000..680e92e
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/systems/PlayerInputSystem.java
@@ -0,0 +1,46 @@
+package com.zombie.game.systems;
+
+import com.zombie.game.ecs.ECSWorld;
+import com.zombie.game.ecs.System;
+import com.zombie.game.ecs.components.*;
+
+import static com.zombie.game.model.Constants.*;
+
+/**
+ * Processes player input to update positions and aim angles.
+ * 处理玩家输入以更新位置和瞄准角度。
+ */
+public class PlayerInputSystem implements System {
+
+ @Override
+ public void update(float dt, ECSWorld world) {
+ // Iterate over all player entities / 遍历所有玩家实体
+ for (int entityId : world.getPlayers()) {
+ // Retrieve components for this entity / 获取该实体的组件
+ PlayerInput input = world.getPlayerInputs().get(entityId);
+ Position pos = world.getPositions().get(entityId);
+ Health health = world.getHealths().get(entityId);
+
+ // Skip if any required component is missing or player is dead / 若缺少必要组件或玩家已死亡则跳过
+ if (input == null || pos == null || health == null || !health.isAlive()) continue;
+
+ // Calculate movement speed based on tick interval / 根据 tick 间隔计算移动速度
+ float speed = PLAYER_SPEED * TICK_INTERVAL;
+ // Compute new position from input direction / 根据输入方向计算新位置
+ float newX = pos.getX() + input.getDx() * speed;
+ float newY = pos.getY() + input.getDy() * speed;
+
+ // Update X position if walkable, clamped to grid bounds / 若可行走则更新 X 位置，限制在网格边界内
+ if (world.getMap().isWalkable(newX, pos.getY(), PLAYER_SIZE)) {
+ pos.setX(Math.max(0.5f, Math.min(GRID_SIZE - 0.5f, newX)));
+ }
+ // Update Y position if walkable, clamped to grid bounds / 若可行走则更新 Y 位置，限制在网格边界内
+ if (world.getMap().isWalkable(pos.getX(), newY, PLAYER_SIZE)) {
+ pos.setY(Math.max(0.5f, Math.min(GRID_SIZE - 0.5f, newY)));
+ }
+
+ // Update facing angle based on aim direction / 根据瞄准方向更新朝向角度
+ pos.setAngle((float) Math.atan2(input.getAimX() - pos.getX(), input.getAimY() - pos.getY()));
+ }
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/systems/StateSyncSystem.java b/backend/src/main/java/com/zombie/game/systems/StateSyncSystem.java
new file mode 100644
index 0000000..ffc14ba
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/systems/StateSyncSystem.java
@@ -0,0 +1,108 @@
+package com.zombie.game.systems;
+
+import com.zombie.game.ecs.ECSWorld;
+import com.zombie.game.ecs.System;
+import com.zombie.game.ecs.components.*;
+
+import java.util.*;
+
+/**
+ * Collects and serializes game state for network synchronization.
+ * 收集并序列化游戏状态以进行网络同步。
+ */
+public class StateSyncSystem implements System {
+
+ /**
+ * Builds a map representing the current game state including all players and zombies.
+ */
+ public Map buildGameState(ECSWorld world) {
+ Map state = new LinkedHashMap<>();
+
+ // Players
+ List> playerStates = new ArrayList<>();
+ for (int entityId : world.getPlayers()) {
+ Map map = new LinkedHashMap<>();
+ Position pos = world.getPositions().get(entityId);
+ Health health = world.getHealths().get(entityId);
+
+ String playerId = null;
+ for (var entry : world.getPlayerIdToEntity().entrySet()) {
+ if (entry.getValue() == entityId) {
+ playerId = entry.getKey();
+ break;
+ }
+ }
+
+ map.put("id", playerId);
+ if (pos != null) {
+ map.put("x", pos.getX());
+ map.put("y", pos.getY());
+ map.put("angle", pos.getAngle());
+ }
+ if (health != null) {
+ map.put("health", health.getHealth());
+ }
+
+ PlayerInput input = world.getPlayerInputs().get(entityId);
+ if (input != null) {
+ map.put("lastProcessedSeq", input.getSeq());
+ }
+
+ playerStates.add(map);
+ }
+
+ // Zombies (only alive)
+ List> zombieStates = new ArrayList<>();
+ for (int entityId : world.getZombies()) {
+ Health health = world.getHealths().get(entityId);
+ if (health == null || !health.isAlive()) continue;
+
+ Map map = new LinkedHashMap<>();
+ Position pos = world.getPositions().get(entityId);
+
+ map.put("id", entityId);
+ if (pos != null) {
+ map.put("x", pos.getX());
+ map.put("y", pos.getY());
+ map.put("angle", pos.getAngle());
+ }
+ map.put("health", health.getHealth());
+ map.put("maxHealth", health.getMaxHealth());
+
+ zombieStates.add(map);
+ }
+
+ // Nut walls
+ List> nutWallStates = new ArrayList<>();
+ for (Map.Entry entry : world.getHealths().entrySet()) {
+ int entityId = entry.getKey();
+ // Skip non-wall entities (players and zombies have health too)
+ if (world.getPlayers().contains(entityId) || world.getZombies().contains(entityId)) continue;
+ if (!world.getBlocksMovements().containsKey(entityId)) continue;
+
+ Health health = entry.getValue();
+ Position pos = world.getPositions().get(entityId);
+ if (pos == null) continue;
+
+ Map wallState = new LinkedHashMap<>();
+ wallState.put("id", entityId);
+ wallState.put("x", (int) Math.floor(pos.getX()));
+ wallState.put("y", (int) Math.floor(pos.getY()));
+ wallState.put("health", health.getHealth());
+ wallState.put("maxHealth", health.getMaxHealth());
+ nutWallStates.add(wallState);
+ }
+
+ state.put("players", playerStates);
+ state.put("zombies", zombieStates);
+ state.put("nutWalls", nutWallStates);
+ state.put("gameTime", world.getGameTime());
+
+ return state;
+ }
+
+ @Override
+ public void update(float dt, ECSWorld world) {
+ // No per-frame logic; state is built on demand
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/systems/ZombieMovementSystem.java b/backend/src/main/java/com/zombie/game/systems/ZombieMovementSystem.java
new file mode 100644
index 0000000..cd32f3e
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/systems/ZombieMovementSystem.java
@@ -0,0 +1,235 @@
+package com.zombie.game.systems;
+
+import com.zombie.game.ecs.ECSWorld;
+import com.zombie.game.ecs.System;
+import com.zombie.game.ecs.components.*;
+import com.zombie.game.model.GameMap;
+
+import java.util.*;
+
+import static com.zombie.game.model.Constants.*;
+
+/** Zombie movement system using flow field pathfinding / 僵尸移动系统，使用流场寻路 */
+public class ZombieMovementSystem implements System {
+
+ @Override
+ public void update(float dt, ECSWorld world) {
+ GameMap map = world.getMap();
+ if (!map.isFlowFieldValid()) return;
+
+ List sortedZombies = new ArrayList<>(world.getZombies());
+ Collections.sort(sortedZombies);
+
+ for (int entityId : sortedZombies) {
+ Position pos = world.getPositions().get(entityId);
+ Health health = world.getHealths().get(entityId);
+ ZombieAI ai = world.getZombieAIs().get(entityId);
+
+ if (pos == null || health == null || !health.isAlive()) continue;
+ if (ai == null) continue;
+
+ // Target selection: query flow field for next grid
+ float centerDist = Float.MAX_VALUE;
+ if (ai.isHasTarget()) {
+ float dx = ai.getTargetX() - pos.getX();
+ float dy = ai.getTargetY() - pos.getY();
+ centerDist = (float) Math.sqrt(dx * dx + dy * dy);
+ }
+
+ if (!ai.isHasTarget() || centerDist < GRID_CENTER_THRESHOLD) {
+ float[] flowDir = map.getFlowDirection(pos.getX(), pos.getY());
+ float dirX = flowDir[0];
+ float dirY = flowDir[1];
+
+ if (dirX == 0 && dirY == 0) continue;
+
+ int currentGridX = (int) Math.floor(pos.getX());
+ int currentGridY = (int) Math.floor(pos.getY());
+ int nextGridX = currentGridX + (int) Math.round(dirX);
+ int nextGridY = currentGridY + (int) Math.round(dirY);
+
+ // If next grid is wall, try to slide along single axis
+ if (map.isWall(nextGridX, nextGridY)) {
+ nextGridX = currentGridX + (int) Math.signum(dirX);
+ nextGridY = currentGridY + (int) Math.signum(dirY);
+ if (map.isWall(nextGridX, nextGridY)) {
+ if (!map.isWall(currentGridX + (int) Math.signum(dirX), currentGridY)) {
+ nextGridX = currentGridX + (int) Math.signum(dirX);
+ nextGridY = currentGridY;
+ } else if (!map.isWall(currentGridX, currentGridY + (int) Math.signum(dirY))) {
+ nextGridX = currentGridX;
+ nextGridY = currentGridY + (int) Math.signum(dirY);
+ } else {
+ ai.setReservation(false);
+ continue;
+ }
+ }
+ }
+
+ // Check grid occupation by other zombies
+ if (isGridOccupiedOrReserved(nextGridX, nextGridY, world, entityId)) {
+ int[] alt = findAlternativeDirection(currentGridX, currentGridY, dirX, dirY, map, world, entityId);
+ if (alt != null) {
+ nextGridX = alt[0];
+ nextGridY = alt[1];
+ } else {
+ ai.setReservation(false);
+ continue;
+ }
+ }
+
+ ai.setReservedGridX(nextGridX);
+ ai.setReservedGridY(nextGridY);
+ ai.setReservation(true);
+ ai.setTargetX(nextGridX + 0.5f);
+ ai.setTargetY(nextGridY + 0.5f);
+ ai.setHasTarget(true);
+ }
+
+ // Move toward target
+ float dx = ai.getTargetX() - pos.getX();
+ float dy = ai.getTargetY() - pos.getY();
+ float dist = (float) Math.sqrt(dx * dx + dy * dy);
+
+ if (dist < 0.01f) {
+ ai.setHasTarget(false);
+ continue;
+ }
+
+ float moveDirX = dx / dist;
+ float moveDirY = dy / dist;
+ float speed = ZOMBIE_SPEED;
+
+ float moveX = moveDirX * speed * dt;
+ float moveY = moveDirY * speed * dt;
+ float newX = pos.getX() + moveX;
+ float newY = pos.getY() + moveY;
+
+ boolean canMoveX = map.isWalkable(newX, pos.getY(), ZOMBIE_SIZE);
+ boolean canMoveY = map.isWalkable(pos.getX(), newY, ZOMBIE_SIZE);
+
+ if (moveX != 0 && moveY != 0) {
+ // Diagonal: check corner blocking
+ int checkX = (int) Math.floor(newX);
+ int checkY = (int) Math.floor(newY);
+ int checkCurrentX = (int) Math.floor(pos.getX());
+ int checkCurrentY = (int) Math.floor(pos.getY());
+
+ boolean blockedByCorner = false;
+ if (checkX != checkCurrentX && checkY != checkCurrentY) {
+ boolean wallInX = map.isWall(checkX, checkCurrentY);
+ boolean wallInY = map.isWall(checkCurrentX, checkY);
+ if (wallInX || wallInY) {
+ blockedByCorner = true;
+ if (!wallInX && canMoveX) {
+ pos.setX(newX);
+ } else if (!wallInY && canMoveY) {
+ pos.setY(newY);
+ }
+ }
+ }
+
+ if (!blockedByCorner) {
+ boolean canMoveDiag = map.isWalkable(newX, newY, ZOMBIE_SIZE);
+ if (canMoveDiag) {
+ pos.setX(newX);
+ pos.setY(newY);
+ } else {
+ if (canMoveX) pos.setX(newX);
+ if (canMoveY) pos.setY(newY);
+ }
+ }
+ } else {
+ if (canMoveX) pos.setX(newX);
+ if (canMoveY) pos.setY(newY);
+ }
+
+ // Zombie separation
+ for (int otherId : world.getZombies()) {
+ if (otherId == entityId) continue;
+ Health otherHealth = world.getHealths().get(otherId);
+ if (otherHealth == null || !otherHealth.isAlive()) continue;
+ Position otherPos = world.getPositions().get(otherId);
+ if (otherPos == null) continue;
+
+ float sepDx = pos.getX() - otherPos.getX();
+ float sepDy = pos.getY() - otherPos.getY();
+ float sepDist = (float) Math.sqrt(sepDx * sepDx + sepDy * sepDy);
+
+ if (sepDist < ZOMBIE_SIZE && sepDist > 0.01f) {
+ float overlap = ZOMBIE_SIZE - sepDist;
+ float pushX = (sepDx / sepDist) * overlap * 0.5f;
+ float pushY = (sepDy / sepDist) * overlap * 0.5f;
+
+ if (map.isWalkable(pos.getX() + pushX, pos.getY() + pushY, ZOMBIE_SIZE)) {
+ pos.setX(pos.getX() + pushX);
+ pos.setY(pos.getY() + pushY);
+ } else {
+ if (map.isWalkable(pos.getX() + pushX, pos.getY(), ZOMBIE_SIZE)) {
+ pos.setX(pos.getX() + pushX);
+ }
+ if (map.isWalkable(pos.getX(), pos.getY() + pushY, ZOMBIE_SIZE)) {
+ pos.setY(pos.getY() + pushY);
+ }
+ }
+ }
+ }
+
+ // Update facing angle
+ if (moveDirX != 0 || moveDirY != 0) {
+ pos.setAngle((float) Math.atan2(moveDirX, moveDirY));
+ }
+ }
+ }
+
+ private boolean isGridOccupiedOrReserved(int gridX, int gridY, ECSWorld world, int selfId) {
+ for (int otherId : world.getZombies()) {
+ if (otherId == selfId) continue;
+ Health otherHealth = world.getHealths().get(otherId);
+ if (otherHealth == null || !otherHealth.isAlive()) continue;
+
+ Position otherPos = world.getPositions().get(otherId);
+ if (otherPos == null) continue;
+
+ int otherGridX = (int) Math.floor(otherPos.getX());
+ int otherGridY = (int) Math.floor(otherPos.getY());
+ if (otherGridX == gridX && otherGridY == gridY) return true;
+
+ ZombieAI otherAi = world.getZombieAIs().get(otherId);
+ if (otherAi != null && otherAi.isReservation() &&
+ otherAi.getReservedGridX() == gridX && otherAi.getReservedGridY() == gridY) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private int[] findAlternativeDirection(int currentGridX, int currentGridY, float dirX, float dirY,
+ GameMap map, ECSWorld world, int selfId) {
+ int[][] allDirs = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}, {-1, -1}, {1, -1}, {-1, 1}, {1, 1}};
+ List candidates = new ArrayList<>();
+
+ for (int[] dir : allDirs) {
+ int nx = currentGridX + dir[0];
+ int ny = currentGridY + dir[1];
+
+ if (map.isWall(nx, ny)) continue;
+
+ if (dir[0] != 0 && dir[1] != 0) {
+ if (map.isWall(currentGridX + dir[0], currentGridY) ||
+ map.isWall(currentGridX, currentGridY + dir[1])) {
+ continue;
+ }
+ }
+
+ if (isGridOccupiedOrReserved(nx, ny, world, selfId)) continue;
+
+ float dotProduct = dir[0] * dirX + dir[1] * dirY;
+ candidates.add(new int[]{nx, ny, (int) (dotProduct * 1000)});
+ }
+
+ if (candidates.isEmpty()) return null;
+ candidates.sort((a, b) -> b[2] - a[2]);
+ return new int[]{candidates.get(0)[0], candidates.get(0)[1]};
+ }
+}
diff --git a/backend/src/main/java/com/zombie/game/systems/ZombieSpawnSystem.java b/backend/src/main/java/com/zombie/game/systems/ZombieSpawnSystem.java
new file mode 100644
index 0000000..eadc2ed
--- /dev/null
+++ b/backend/src/main/java/com/zombie/game/systems/ZombieSpawnSystem.java
@@ -0,0 +1,47 @@
+package com.zombie.game.systems;
+
+import com.zombie.game.ecs.ECSWorld;
+import com.zombie.game.ecs.System;
+import com.zombie.game.ecs.components.Health;
+import com.zombie.game.model.GameMap;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+import java.util.Random;
+
+import static com.zombie.game.model.Constants.*;
+
+/** Periodically spawns zombies at map spawn points / 定期在地图出生点生成僵尸 */
+public class ZombieSpawnSystem implements System {
+ private static final Logger logger = LoggerFactory.getLogger(ZombieSpawnSystem.class);
+ private final Random random = new Random();
+ private float spawnTimer = 0;
+
+ @Override
+ public void update(float dt, ECSWorld world) {
+ spawnTimer += dt;
+ if (spawnTimer < ZOMBIE_SPAWN_INTERVAL) return;
+ spawnTimer -= ZOMBIE_SPAWN_INTERVAL;
+
+ // Count alive zombies
+ int aliveCount = 0;
+ for (int entityId : world.getZombies()) {
+ Health health = world.getHealths().get(entityId);
+ if (health != null && health.isAlive()) {
+ aliveCount++;
+ }
+ }
+
+ if (aliveCount >= ZOMBIE_MAX_COUNT) return;
+
+ // Pick a random spawn point
+ GameMap map = world.getMap();
+ List spawns = map.getZombieSpawnPoints();
+ if (spawns.isEmpty()) return;
+
+ int[] sp = spawns.get(random.nextInt(spawns.size()));
+ int newZombie = world.createZombieEntity(sp[0] + 0.5f, sp[1] + 0.5f);
+ logger.info("Zombie spawned: id={} at ({}, {}), alive={}", newZombie, sp[0], sp[1], aliveCount + 1);
+ }
+}
diff --git a/backend/target/classes/com/zombie/game/GameServerMain.class b/backend/target/classes/com/zombie/game/GameServerMain.class
new file mode 100644
index 0000000000000000000000000000000000000000..fa15fe79bb2663361c70626f5a11eddac95e192f
GIT binary patch
literal 2487
zcmb7GZC4XV6n-WIHZ03q5LD!4u_!T8LanyeplzX`X%kUHv1)5O$qr#*vzzX2K&1BN
zAM_XWtDkMpLC|yj0X_W*{Vi?p>_%8#j>mq;?#`V%_dd^k?#$%Re_p%-a23C(h@nYA
zTthQj7`j&Y8qZkVu4Lv*E28W(v`m?{>0e`LN}XF&kwB{gRYMyzhVDK0ob8K>a2XOc
z?s|fT485uRo{fK4TR~Do4~{Vm
zm7Qwlu~RLXB2(d2k-1KfqHx!QTi~WmC@rTFq)+A@x03O!rHd<>d|=Ba(8rL<*=yV~
z4ZY^LzHSFO$Mw2Lm~=xd@w(+-(JxP4o@~PjoK(=S;S>g_A_v1U#Mik?DUW2gs9=a8
zeGsk}Kn+me6{Vt6UKM@_U&SDFS^W_ToXW`(58@pSqf(A$&*!e6z*&aD`?oIW;SxQt
z3PX47kj>^3sY^=3IiwjB;#n8-OALJ!FQPz0qO4>%uHjuwP)gHYau~*rP%5%A?1iiZ
zH;MNYT+r}7F7DI+PTls+s$ftn!rvYArlJ5E=B$Db_O;r=vMaceq>j9-;Uiq3UUTbI
z;ptTV?F*SbkjdsHOJr4C!jvrURfgkHl7uDn2uXdc;S+qy(8&#>xLo%QXWhQxII9O_
z4v|tJ5}2WY($fz*h}`v1Rb&-~lP-bqzP9m~qc{Y6?DQ=-F%j-G)yfPq}7Y
z*Ku{DF1L#AHE_sqH#N-T7IlP>9@Jq`E{&}f5sYv;>p=k|y*nr>SkUk#776shhMwbP
z-*Gn>T1mNZ%P^dY#-Fjc=TUtRuFMjt8OI>eJM*S3!i~Hj(=yOLEOTp-yQUmBjB$V2
z^ceI*vhLr`GHx~4)_ti55mv8{5Mse7#Ykl8$U{WN;ckU8_8bw0CgoW`v2t{NgyJ!b
zAHo*S9JO~TetXg9<<$bO1q>B%+5o$nQsQ=tS4##Tm2^fY88ZK`rHN^8gyn8z%AA-g
zTaA-hEjo3#EapsE_@4c>oRGanyKUNWe9w1ztswkm$MCw)(%Ax6rE}KPU}A+vbrow^
zSMW%~1|Bn<-s@A-UUODOCLge&5Pa!%*R)lmqrakk(^wQ{yuoe565eQ@c2&KWjj%f0
zzWWv~Y}7>5{p}~ily6=eJvADUXSih*OetF%|SDe1-LZ;_k8fECs=-r%t4)%;bV)%-lavD%@kDglSfctnr
zqgH&4Z^%n7{+og|(Yw$+{OeTu)o(bFZo04yW$Gz93csT>*}H?|F}%d!y;ILITo~WN
zX=y%lY8zuaINyYAWM1OZz3~_L5O|L47Op*`bn=SsK|2MPU?%7v0q7SeD6Qy_*Eh{}
z5}Pgz(Q^#FIFI9Wyq`p#7)#J;@;(L?5Akilzku(+$sR`zC6p=07|z0gpxGs|cO&*M
z1&t}FP(c*5t5^=)8FF2!Y+_m>Id2juSC?n^ixeiBB&T3`!LN6B1!P+iVgtxQPd=ne27(AOYsA62*4?b-Byrmqnp^;Rc<73
uBSDf~+qnG)I;DCnqF#bBSIHKG4Ts)RN1tppd{4hkvZ!SF0YBnrocs?7sC~=;
literal 0
HcmV?d00001
diff --git a/backend/target/classes/com/zombie/game/ecs/ECSWorld.class b/backend/target/classes/com/zombie/game/ecs/ECSWorld.class
new file mode 100644
index 0000000000000000000000000000000000000000..8308ea68505cc0804740ccba31a0b3a6b1711b90
GIT binary patch
literal 8566
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
YBq&5<8%S{=I@r{iyoW-Bp=g59AM_(mw*UYD
literal 0
HcmV?d00001
diff --git a/backend/target/classes/com/zombie/game/ecs/components/Collision.class b/backend/target/classes/com/zombie/game/ecs/components/Collision.class
new file mode 100644
index 0000000000000000000000000000000000000000..e55f29c264579faeffd7b76d9ee836231c2b69ff
GIT binary patch
literal 1621
zcma)6U2hXd6g?ArKVmkv6A~y8D3nlaC$OZYAK(PqxVTtyT7;t@!AmEbX}n~;`vZ82sv@-%@lci5{w9RD<6WEuEYydcxp(&7bI(0@cK>_z{2u_T_`ZM%}~nN-Qhjq
z3NLo)tS>_ms@QGFAn;>fh79@Ge;^oGvp^6<2PKplY>$W6ei`t9VXo4Cw|2dHTL;fL
zIEYyWYe%Tg5QLZz%pn}M@R5TfILc7kPi_X16K_lN;1Sg{D$QoKr4!~I9LEWU;?Fu}
zL$*S-=Bt?4RVZSHBsuBe6h2`%+~d2VAw!R=TfXX&6)R3HX`;<)hH6Jeez;RlAU0`h
z$Ze`wYWt!1VbI$W(FWfN=wzlXJsxcG$k%>)m{(n&Fl+7qD_Ynkk9dqQDzBTkF>diEJ|x@gN`xZ6%ZT7-lPD
zn=W+ZAo4`h*Bur|<36vc&}~|iQpGCb{dJ+bayzzhnPGYqR?&B2l~qe7Rtj_*uUNRM
z_5X%pVZRwayeD^sn=na6(&V0!(S3$T*;|taCbh2fa61t3LR-q+LBF06C!JX477;>il`CrI2N&m2E&>6dKyR70*&FsheK&bNna$E
zOr4MuKn@n6{MOSPw%8oFdmFVXW1bHD1>`8`U?
z4g1fQJeh!vN-kp&OH^tO^EgLZOyE4_9YEf)U!rKiE|F~X4@=oxqFr}oXd1dgR+4N}
z#;AfpxVi#^iwh~t&9tf6a(yMgI$y4LHT`Ee_S5S8c+`aVY>Jx0G?wuhp&3N(bFwDL
zzKAbU{EM{f$rUv0b9@Z^F_vpGzQPFg%VE@4_?mW`5bE??!nYcUtTlW`_w2}PnZ!jI
literal 0
HcmV?d00001
diff --git a/backend/target/classes/com/zombie/game/ecs/components/Health.class b/backend/target/classes/com/zombie/game/ecs/components/Health.class
new file mode 100644
index 0000000000000000000000000000000000000000..2c099f8c9df456cbe22e8bdb97964c6b8d152eed
GIT binary patch
literal 2052
zcma)7TW=dx5dMyDYdf1bO`C-D5)ztH#|bre(mE+k(wG?RrjRH|F2%je9To%v?wn>o9G{{7@P04sPmj|7qi
zQYO;K2#h|IC$ely=b*f`_fR!`fy}bySpIE+WO05shb(di@+O903S4Wt?eb@Cd(Tqk
z1KCz()%40dJ8~W6_+EKaN!xD`qZJ9Fsu4y^6tsJ;Ek6xS@;p6fVhra6vQ6o1d~z&p
zf$?JfY(ka!2ikbt!~`Y@aiIKe6ed{BV+t1yTrzPPR|E=u_p0qmmSgDjWJd|4i`D9U
zO@lpaVn&0R1Z(tDn!g;
z9v!CqmPOF(_5Z~@qZpRAYFj77BRvlUhPQp$JZ#9L2r%7Io+2+fu3aKc$~_*~J*B(B
zsKV7*^(hTUghA4--%=g6t|dLzuIpj68Xw$$uh!V0C*=$y9or0*_1%yJfeXcf)a19_
z<4#jmEzQGFnAQy)mlL|?y1wUkHZVM<{OtFr04oks#+#s@Gm4C8J}XWv%dT-|jKkB=%bR-y*S
zPX6V%^XNzoF#jNCAMqNeCW2U(w!LlnikzD@$5EYiTY8@I3^aHf|5MYTR1ItiOh4U}
z%?j(nEU!m`bDrRjS3ZzpCfE&~ZpkECH6)5Ay2>dQ>gnm}~3C7SD-@r(Hhg9;EM@eY#Oz?O-
z0MyPJCIozmavF)@I~wujz)+|AMueCv5ptN>_7l}_MBpOpz7)gDMR>f=m?V@2DRbAc
z(mJj0DI{XaeJMxyL#$uOT$uTLhxQGt9YFqNtE7A
z?wYQ&&P#`gH!99nw^4d#mVyuhH*qV1`7o+-cC@mbTDd%0Y3X_%WA>x2!a}q%I7C>*
zY*a-O)2LvX&}n|ERw(Hizl}GeU`v6{8>3@ro}SRqCRL-aW4!A~
z<%ypG`~aRJ1QH)r9}v9qn-JoRcX5_tA@SgyJG1AWd+xcj{{7EKzW~_AI|a-k=OFLF
zf-O+GFHdAWkl|7N{e%0e7Yo>1e(1-y1#;!e{ybdFJ1BTK2T!2Z(}ViwdT`*Y`jH%{
zy6Q!Bo(*-V!Z@mT^@$oVYU+qg`QBs^tpZsVJrq$AaC6gf$P(;F7@Nrv|g9
z+hM%p#}U<)iCCs9mpwd(=LIed
zAF^h#_K@!&v>_T)jpljV-?$zWfOe6vpv^KsuN=e5rN@RGHh=x-}*W$Yt`(5A$h
z3&{kDwRGH9BY}n8SoV&)a+sEO`!Zr*MlAho6ZpZscK0rs7~3NijRU&q#yaUxV5K~>
z@4~Jgk9w-*n%+*!EwW{iWpg>UMWtwCtH7Ii+rb?(
zh&Kh+&sy@s6Md}eiJoLOE!m6p=z+kO+3S-6lXCCM@Gwx(dPnQy@vxDxC>>qq
zmtQj=_~hrw$YE^Z3ZLuTwRmpc7pgx)RImI9=X>tvaFx$Rg-?ft5e4{Ra1ISh>^MuW-8?)t|61*)mw#;O`+;zcR1$r%cLC
z`p=fUoRCdRZlZ<_mRiLcuF;D*TxTA=a@;?#=)f(~HvXBVYHo5hU0FtksgSiK+mtn}
zV3F5U5UAs&l;&RA)JmzbmET?~HTp*WLp=S-_S$ULME6R{n!^${@iN&gihG689OD~!
wHRZp-)l9BnXdmHO;JcYxlkpX%tglT_uj37_E*Tp9-NajliO~+;<~_Uk7m!m)`Tzg`
literal 0
HcmV?d00001
diff --git a/backend/target/classes/com/zombie/game/ecs/components/PlayerInput.class b/backend/target/classes/com/zombie/game/ecs/components/PlayerInput.class
new file mode 100644
index 0000000000000000000000000000000000000000..f31e0ec61e1c1d81fe7d4a317f10de5fc16a506b
GIT binary patch
literal 2560
zcma)7TT>iW5dO~IW+4N+;TCh12+?IhR=g)bG+frKE(r!CA@RatcZ3Pc4A~h{!B_u;
z`r?~Ul%-WhQ+cq=tG~&z{Ca0#CpeX2tLB{3J>B2w{<^34?|+~E31AxaP9%^tkTQ`*
zMj?M+Kh&j$b~Z{k*Y8_3Um-JPJGOsSAz2t%=|C1820BfgfT>Wdx!a|0-0gMSDsAX(
zt7O%@5_LPSV>!N8T5RY&t66b&b_tZIKT=R-f#^1o6aPegPsEcZdPGcVd;5+k`b_j6
zC{{&r%EU`J%@{oE0YNIA)SWeP4(AoJHSNql*wqb%{zCO=0+SsE7F
zuQ#aask$}YSkX;e8-JQt@V`0f7n&%vs_jarp^Lr8dkn<>EA;he1G?r}NVm-`?<53=!Jg=%13;lhheS;8PMT;w;CVDqQBa@z2ekg3tyIWAf|r$lS#aNwQ;8vz-v
z)0Ea|uee_*{sC1y@fe0IU9#k5=`AK7W8l}8|5dSr!L<)5&Ylhopc|*q%dsQa=Wzxf
z@U0mj;zL}cq-3Uqx0SfdZRz4~Fn;DC0Rfd@K)AMZ`p}tkB*wYxsPlD2z{Gh}~2I=Mgk7qSau#ouwJCGv1#jL#Fi^1ZyKT%cTt$fJ};
zBl0-q@rXP@dE!TLPDwW;BVRyJ&%q#)!+JXS7@siCeypO(Pbz^0`sI){vj3plKsLvp
z$uE+B^kF)exl7xmC6A*$7wwvZ?@R_rwRMZajlDFIowWmj
ziMIu2-4>W~TbQ6jd>BEp^I@_{%;09LI1<<*Pcof8#jP-}Iff~t;*7*0-18abGtOt?
rDJ}!Q@NIOc1j$O<(ChG)rIyt)KI5L{yE}YV@Fk^Ap1y)c4X6JDjL*Dh
literal 0
HcmV?d00001
diff --git a/backend/target/classes/com/zombie/game/ecs/components/Position.class b/backend/target/classes/com/zombie/game/ecs/components/Position.class
new file mode 100644
index 0000000000000000000000000000000000000000..05990193db0047408da59e471db295b4ee30042b
GIT binary patch
literal 2537
zcma)7ZBr9h6n<{9$;P-Lh$x~KQ9+VGNndQM0=9~#(t?6eU;E-FEMy_<#_Zxq|3hc`
zvF*ox=qIMr&h*9cL#O@P-_+^!IlCK@+AZTSx%ZyC_dL&e&N=t;=ikqN12BVH76~ME
zXa-V9EA(!dPt0<|bk@tasvB0#S4dCWj_qGoNEV8B4j_XAI!N8UUWU%w_Qg;J>{<=?mY(b;;VMVI%J?vtQ095Ru=s@qT{H6
z0UT54=|r<&`gH}(d)#73TH#vpT9)3&4V=J9g-p$Ku0P&38wy7X^Bu2H!&LEs93C=o
z3d8hXxBPp7oJtmFa8}2Nfl-`O$ag#|4c8=-E@I4<#Q+PHN^wqb3I>X8ocppdZeT(-
zG6cR7$~c2b17*BM4Qqn5;?6n#RonL@c;fUi`)?R{6Xz8Mw#-dy)^%#8f7kZwTzS69
z?C}dZE5$B7%YMst)~5(E>#j1W{Jia0H@CN{R%^wqHn`I_@7B!59kXSN9c^lU-6mXd
z{w2#rfo`;-X>^-Sz8MOCh)Ho3+gavl+?A)J>1+5#j8`IUZcRJ-2Y3NL;5|mbcwt
z$uhnhrb(f{5SzU0vb)`?SruCnmTULuq!gbw;HvBTp5HQ?3zlDZSG^1<<3#&Z;pvQ;
z7~YW~=-3%m%%^cLi~D$>;YmQBlaM%j}!YufIS@gN7zIPGzIYnswDOlrXs!u`Lr0m(HJd5Jb8+I
z!{j?nzB2(|DfHimPhyZfCdoO?=RVBhQ`(ZDp|ho*ps!U%IOWzZXrrSW1KNPLQT^f>
z4uAPQPb47u>+v{Umtg;Rq$vcaf|DHOYJJO?rTv%2OWz@-
z?T-I}%r{6ScgKH6W?`cA3kCy|i&rN2dxq0r%V*kSw8y&a675pk)^-V+4Em@$r0}jR
z?WJf5@8bqTIl?}jB4?>XN&*#*uvfb|!ZNhm
zhewGl910&|K7x^3D6%Jer>3=;lf6@Q5%>(RK583O)-fncjCj6K(`2M6iE%9O#gaQ;
z#I5M=+j@N-7V%3B%SKl7`?cmfhRyb#fbeF%6@CmIfSD)e$
Hsu=tS+d{0`
literal 0
HcmV?d00001
diff --git a/backend/target/classes/com/zombie/game/ecs/components/RenderInfo$EntityType.class b/backend/target/classes/com/zombie/game/ecs/components/RenderInfo$EntityType.class
new file mode 100644
index 0000000000000000000000000000000000000000..dd3107ffe6628cc0a7a891f5f1d0bf64a5d41a21
GIT binary patch
literal 1346
zcmbVM?N8HS5dS@EN4HYgmXT!Mb;%EKt>TGDnT_{l#>
zArYd{@Yz4gcuyJGjGCA=X|H$B-S6&xz3Y#kU%mr)foBS03^SHjH{N^os?Cj>S?30~
z0)uRap3B`ZFt)h6%l)Fe=ZzQK&<>Bcj}Lhg46=qex){1POUpZjErz*LCs28TmC%rk
zu-nwqa6w(TMH1r|E5Vss^jiEoMmk!J$({N0;
zW^7asxE1DA^y9jM0S$w=!O+`sD7cL}RdZxI4Zg9*Fq>Mmje0v4~
z5aDMv+{7>uw_v+=xX3Wj4%Lh->XiiIDiM)QASvXChEa?OLZTW1hUYoGLrN(56^Ojz
z?GhWQlI`;KM!m}YZL{i-<@H~x(mVSC44IN=nNG#@Z2{iQAiFeg;;hATvwMd08V~oq
z-A&UcpOE|1t{m>$B$8#j=9*!{r%)-US7>?`ET>83Y8#dye4(>~7xN5i*=zU~e`O0Y
zQmr+Z64g@DbsmJPUJxpnWzhe7^cl3G>vBID8BYDEt+iU3rtjQO%PB1liRA)F(qaJV
ztk?!RiIYB#G4i`d+9*kJsV7iBqxS--kEAi&r)O7mmL&f{JU}e+pCKtC)C`+A$F&PE
z;UD|WKSvhr(hE8!NSmZPPGKK}D~&Fs2yB|9L`TZR`sFne
literal 0
HcmV?d00001
diff --git a/backend/target/classes/com/zombie/game/ecs/components/RenderInfo.class b/backend/target/classes/com/zombie/game/ecs/components/RenderInfo.class
new file mode 100644
index 0000000000000000000000000000000000000000..486da7348864cc429881160af13299ed2929c559
GIT binary patch
literal 2070
zcmbVNT~ixX7=BK&n_a^4(FoKi7HetE2Q+?QTL{$J2sWBfr*v>eZ(PDD*%Ed!yI}@@
zg_n*$z}|3CXB3@YIC`Tq{wB3PXLn1sz&IUd;Ou$Nz8}x?zR#Zg_3x8k0W4uPixkoZ
zGz&U10;3P@J-gDe-L1;qjfb)o2xJx=*9mS4qzlFM0hkytkhL%fOQ6{Db}C?5norExdwP
z38!uQ?V7jA5^PaDi`Q_$z?6m8aq+p1t_5Ak-6EttyVH|*9|&AI4Ss@A6j9A_R+lVH
zBpE&{Rx_)4@*T<5@k;RkA1m+88>qBv!Q;dj?G#pp1_I5U8_rAT+
zA@y9tYuTN3yXz=BKGcG?LuBO_uUBPz{AUvrlua(dAd)0qbT4SjuE2oGKOG4x8=l3+
z&{|-(wwv~D3`GC*UcI?2AnF`pSNgpUm959lX5c*=%@{S(7gXFtf$W;s>$c>IqnM8L
zRee?Y3Jk7FKWIwT4d1|$z}#6hPOaSbyuc5-_HI)KZEw>zaf==3*DENhOQJZE!R;(+
z_|U+z(#49vbRV|k?s?m?5}}WzvSPOaue&esZBlWuV^r*p?QV9YKi%-W?cQ$nWE&DE
z&jp6xXX0htwJ#D!@!*oZjZ@U@PG`*tB!_C%T~~H%9ozRMMU(A+{RTc3xO{@(X}AqE
z1TOr)Da;9d;xMVlGO51fqsnTxIcbt`&ACMb%E>Em~>%
ztQN^@X~#
z<22tePGj`cXmwFr3aL(xR@)?Mj+P(6m_5YHUoK6aPOub(#s$)t#JiYdVx0xv<1WSF
zkK=C)KmV1Xrv_sDM5&*
pi-!5oYXMb0H6~faP3}zYKH&fR_=r}H5EglM=T;tde1azO{{fq5#~lCw
literal 0
HcmV?d00001
diff --git a/backend/target/classes/com/zombie/game/ecs/components/ZombieAI.class b/backend/target/classes/com/zombie/game/ecs/components/ZombieAI.class
new file mode 100644
index 0000000000000000000000000000000000000000..4c38ec4611bee604abb623ed569ee22084aab201
GIT binary patch
literal 3011
zcma)8-*XdH6#j00G-2A$#n8Ck9
zeDO_R7)NJB86F&c)Cd0}NBqw2Hrd1-rtR##_uPBVchCLKkI7&EzW5EmEUXM-h^LUy
zkVKzC?xFrjFEw;)vvhs^p;2=c`YxK5>0VNZ=L@U-NTWZ6jD`Vd3TJEfcIhj7d)+ij
zoBFmI|~N5k9V3sZHCBXWrf*0og^
z)nLA)UEAkPVK^VjW@g!LHETxM6b1)(%j>+{&nL~-L6|26yl7YUP7c
znpG1g{N=P(RX`6w>BDvb9&LXw^}t(xeXxZ
z^+sdabPa}1t5}xNoNwrkV>l^1R5~XWEd{urMG#?z$N%aP(KMza$`pYA@-`k=27&@G{mY?3G~M&k_c6-TmBaF%e5qvTr0
zpQBwl^=f}4n+4}OZbadv_UeyRgW!A`jWf7c9H}P3xf%VgqkF}XY80Gh*0RsfpNvJE
zJhjG)-yxZJI{pXJ-yj)(I{rJ-OB2OkFy@I|ygtG2Io^08$CM{1PlV(W<VxLl)fyIn_r2khL-&0I{(9?Q+tg@@;uy}v7v
zfR0dlf^_cs_ekdSw!&n4HPv2Ccj>)~g?j-Daa6J9B|(zzRk`w6IETbbl;rntTG4g&
zlI{mWOev#B=HVUO2ufJZR5D-X?>0_
VIH!rf&hI|zlrmhI*upjr{|A~WA({XH
literal 0
HcmV?d00001
diff --git a/backend/target/classes/com/zombie/game/model/Constants.class b/backend/target/classes/com/zombie/game/model/Constants.class
new file mode 100644
index 0000000000000000000000000000000000000000..54fc4d83edfc3bc243b121d51a4e6bae2231a15f
GIT binary patch
literal 1429
zcmai!+fvg|6o%J^0HGE{6cmr(5s&qJLX?;W8b}jNLlJKFq$Pu4+Qdl%Gx!Ah2zuo!
zc;$>2K7gYyI;kI}odPM;H$eSG8X%R?$d8o`{
zgA1-%<~4KOV8l#DL)}z$zqK9oqVyz!JX2rduI3rSa28RS!L&WYt!oyP^UAFH{sW^!
z%a*ogxLHEwh4u3nqhi;zY#3!_?lTd>)}880)5z-UXI
zrr)ajNhmlsD(RcB!)VI-&o_o;6l(Ey(hTN9k!-m8$#iasXF*eVOA4OO1pWr806GNf
zp(1!l;$iS%8rkz70gp<26nsqLG4Qy=!hc-i6W|GnPl8TKd>VX4;JAsr2fu>
zFVMxk{w{&9NIVU`Ch>LfO^I)TZ%cd!d{5&0;D-`F0zZ-XDfpShv)~sJ&w*b`tb+}S
z=fM?;O-#bX?;_46+(;>7qP}ZisrO5EMHbF}mnQ*d0Y*_Lg*%Wh1+n
zY)wZM>kR5d#H7S*QtR~lc6UUzUfNn7h=330{+LHs&e)@2)j{Yw-pGlBPi(ORhDiHd2#ZT!45G6bu?0JqD82YmjasPUHbx;
Cm1zn9
literal 0
HcmV?d00001
diff --git a/backend/target/classes/com/zombie/game/model/FlowField.class b/backend/target/classes/com/zombie/game/model/FlowField.class
new file mode 100644
index 0000000000000000000000000000000000000000..efa39cff728ac62b9fc1108f3f73eb9f5e1ef78c
GIT binary patch
literal 7094
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
literal 0
HcmV?d00001
diff --git a/backend/target/classes/com/zombie/game/model/PlayerInfo.class b/backend/target/classes/com/zombie/game/model/PlayerInfo.class
new file mode 100644
index 0000000000000000000000000000000000000000..312b902402e366235aae5c5f4ff0b5d356733314
GIT binary patch
literal 825
zcmah{%Wl&^6g}hEag#btnuhQwkG3pG48k8!=mrU?QdAH{S#&o}hA@>MlH($kZ(>2E
zMo29B0sSb%8QY@JL}D}d;W_8rd&bwleqI51ji*gmsJXB`IH(JBPUROFL^7EL@4{0x
z$pz}KbfWVEf!bg=ZeR@!7flcA@C0@yX&ih_<4~($CSw)E=~P9*`$(Rv>@fM13Rrq7
z&>h|I9_N`(X8VR|!$aH9*a@+wvFV|UEdeJ}a(XTxP6VC}mch%N;g~dUs4mbR=|ml!
z#i7bR$}nQ5J4z=q8p}+Zx@y|_XFV6#8~tyGeSx*P%0HAN*@F|K<;+xm$jy3#;qov7
zE;U#3PM=rFUcv53(!&M-QlIC?zq
zunNudG4}i)5dQN8T>r%aEx)!v=b}LMdG?6_Ic26;Bfv_+1)?Cz9!+{1lVWGZw;
zkr`!+N)NDI=^d~(^VR+Be-zAb1adfJF|7Ua)*se-F+Cp?5Amqt3K)%!<6px4&cq^&
q)J3yV(0JvAibmk^N^t8oczq@K33n}B`&+s5?Ur(DC3v^Ewf7qxH-Q-d
literal 0
HcmV?d00001
diff --git a/backend/target/classes/com/zombie/game/model/Room.class b/backend/target/classes/com/zombie/game/model/Room.class
new file mode 100644
index 0000000000000000000000000000000000000000..238d9c1dce36ae43e284b9e9b04b8f4292c823d5
GIT binary patch
literal 4409
zcma)9`EwNK5q-0VW_LA`&>{f>j4+r(tCeLefsG_&8*ylZBy0r2$VW2Lj--LrjMyDv
zq#VxS#7CUOi4!Lwr*n}*Ih