smoother player animations

Author: PssbleTrngle

simulator/.dockerignore

@@ -12,4 +12,5 @@ helm-charts
 .env
 .editorconfig
 .idea
-coverage*
+coverage*
+.cache

simulator/.gitignore

@@ -173,3 +173,5 @@ dist
 
 # Finder (MacOS) folder config
 .DS_Store
+
+.cache

simulator/Dockerfile

@@ -13,6 +13,8 @@ RUN cd /temp && bun install --frozen-lockfile --production
 
 # copy production dependencies and source code into final image
 FROM base AS release
+ENV NODE_ENV=production
+
 COPY --from=install /temp/node_modules node_modules
 COPY . .
 

simulator/app.ts

@@ -1,9 +1,11 @@
-import { schedule } from "node-cron";
 import { v4 as createUUID } from "uuid";
+import { loadCache, saveCache } from "./cache";
 import type { Point } from "./messages";
 import { publish, subscribe } from "./rabbitmq";
 
-const players = new Map<string, Point>();
+const players = loadCache();
+const goals = new Map<string, Point>();
+const speeds = new Map<string, number>();
 
 const MAX_PLAYERS = 20;
 
@@ -12,56 +14,110 @@ console.log("simulator started");
 function addPlayer() {
   const uuid = createUUID();
   console.log(`${uuid} joined the game (${players.size}/${MAX_PLAYERS})`);
-  players.set(uuid, {
-    x: Math.floor(Math.random() * 200 - 100),
-    y: Math.floor(Math.random() * 40 + 100),
-    z: Math.floor(Math.random() * 200 - 100),
-    world: "overworld",
-  });
+  const pos = randomPos();
+  players.set(uuid, pos);
+  publish("PlayerMoveMessage", { pos, player: uuid });
 }
 
-function removePlayer() {
-  const index = Math.floor(Math.random() * players.size);
-  const uuid = [...players.keys()][index];
+function removePlayer(uuid: string) {
   console.log(`${uuid} left the game (${players.size}/${MAX_PLAYERS})`);
   players.delete(uuid);
   publish("PlayerDisconnectMessage", { player: uuid });
 }
 
-for (let i = 0; i < MAX_PLAYERS / 2; i++) {
-  addPlayer();
+if (players.size === 0) {
+  for (let i = 0; i < MAX_PLAYERS / 2; i++) {
+    addPlayer();
+  }
 }
 
-const interval = process.env.INTERVAL || "*/2 * * * * *";
+let interval = Number.parseInt(process.env.INTERVAL ?? "");
+if (isNaN(interval)) interval = 100;
+
+function randomPos(): Point {
+  const x = Math.random() * 1000 - 500;
+  const z = Math.random() * 1000 - 500;
+  const y = 80;
+  const world = "overworld";
+  return { x, y, z, world };
+}
+
+function step(pos: Point, uuid: string) {
+  let goal = goals.get(uuid);
+
+  if (!goal) {
+    if (Math.random() < 0.1) return removePlayer(uuid);
+    goal = randomPos();
+    goals.set(uuid, goal);
+  }
+
+  if (Math.random() > 0.2) return;
+
+  const diff = {
+    x: goal.x - pos.x,
+    z: goal.z - pos.z,
+  };
+
+  const dist = Math.sqrt(Math.pow(diff.x, 2) + Math.pow(diff.x, 2));
+
+  const speed = speeds.get(uuid) ?? 0.1;
+
+  if (Math.random() < 0.2) {
+    speeds.set(uuid, Math.max(0, speed - 0.1));
+  } else if (Math.random() > 0.5) {
+    speeds.set(uuid, Math.min(3, speed + 0.1));
+  }
 
-schedule(
-  interval,
-  () => {
-    if (players.size > 0 && Math.random() < 0.5) {
-      removePlayer();
-    }
+  const vec = {
+    x: (diff.x / dist) * speed,
+    z: (diff.z / dist) * speed,
+  };
 
-    players.forEach((pos, key) => {
-      if (Math.random() > 0.2) return;
+  function add(a: number, b: number) {
+    if (b < 0) return Math.floor(a + b);
+    return Math.ceil(a + b);
+  }
 
-      const dx = Math.floor(Math.random() * 24 - 12);
-      const dz = Math.floor(Math.random() * 24 - 12);
-      players.set(key, { ...pos, x: pos.x + dx, z: pos.z + dz });
-    });
+  const newPos: Point = {
+    ...pos,
+    x: add(pos.x, vec.x),
+    z: add(pos.z, vec.z),
+  };
 
-    if (players.size < MAX_PLAYERS && Math.random() < 0.5) {
-      addPlayer();
-    }
+  publish("PlayerMoveMessage", { pos: newPos, player: uuid });
 
-    players.forEach((pos, player) => {
-      publish("PlayerMoveMessage", { pos, player });
-    });
-  },
-  { runOnInit: true }
-);
+  players.set(uuid, newPos);
+}
+
+setInterval(() => {
+  players.forEach(step);
+
+  if (players.size < MAX_PLAYERS && Math.random() < 0.5) {
+    addPlayer();
+  }
+
+  saveCache(players);
+}, interval);
 
 publish("ServerStatusMessage", { status: "STARTED" });
 
 subscribe("RestartMessage", () => {
   publish("ServerStatusMessage", { status: "RECOVERED" });
 });
+
+function shutdown() {
+  console.log("shutting down simulator");
+
+  players.forEach((_, player) => {
+    publish("PlayerDisconnectMessage", { player });
+  });
+
+  publish("ServerStatusMessage", { status: "STOPPED" });
+}
+
+process.on("exit", shutdown);
+process.on("SIGINT", shutdown);
+process.on("SIGUSR1", shutdown);
+process.on("SIGUSR2", shutdown);
+process.on("SIGTERM", shutdown);
+process.on("SIGBREAK", shutdown);

simulator/cache.ts

@@ -0,0 +1,18 @@
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import type { Point } from "./messages";
+
+const cacheFile = ".cache";
+
+const isProduction = process.env.NODE_ENV === "production";
+
+export function loadCache(): Map<string, Point> {
+  if (isProduction || !existsSync(cacheFile)) return new Map();
+  const json = JSON.parse(readFileSync(cacheFile).toString());
+  return new Map(json);
+}
+
+export function saveCache(state: Map<string, Point>) {
+  if (isProduction) return;
+  const json = JSON.stringify([...state.entries()]);
+  writeFileSync(cacheFile, json);
+}

simulator/package.json

@@ -2,6 +2,12 @@
   "name": "simulator",
   "module": "app.ts",
   "type": "module",
+  "scripts": {
+    "start": "bun src/app.ts",
+    "dev": "bun --watch app.ts",
+    "clear": "rm .cache",
+    "type-check": "tsc"
+  },
   "devDependencies": {
     "@types/amqplib": "^0.10.5",
     "@types/bun": "latest",