quake2ts 0.0.469 → 0.0.472

package/packages/server/dist/index.js

@@ -111,7 +111,6 @@ var WebSocketNetDriver = class {
 };
 
 // src/dedicated.ts
-import { WebSocketServer } from "ws";
 import { createGame, MulticastType, Solid } from "@quake2ts/game";
 
 // src/client.ts
@@ -769,25 +768,71 @@ function writeTempEntity(writer, type, args) {
 
 // src/dedicated.ts
 import { lerpAngle } from "@quake2ts/shared";
-var MAX_CLIENTS = 16;
+
+// src/transports/websocket.ts
+import { WebSocketServer } from "ws";
+var WebSocketTransport = class {
+  constructor() {
+    this.wss = null;
+    this.connectionCallback = null;
+    this.errorCallback = null;
+  }
+  async listen(port) {
+    return new Promise((resolve) => {
+      this.wss = new WebSocketServer({ port });
+      this.wss.on("listening", () => resolve());
+      this.wss.on("connection", (ws, req) => {
+        const driver = new WebSocketNetDriver();
+        driver.attach(ws);
+        if (this.connectionCallback) {
+          this.connectionCallback(driver, req);
+        }
+      });
+      this.wss.on("error", (err) => {
+        if (this.errorCallback) this.errorCallback(err);
+      });
+    });
+  }
+  close() {
+    if (this.wss) {
+      this.wss.close();
+      this.wss = null;
+    }
+  }
+  onConnection(callback) {
+    this.connectionCallback = callback;
+  }
+  onError(callback) {
+    this.errorCallback = callback;
+  }
+};
+
+// src/dedicated.ts
+var DEFAULT_MAX_CLIENTS = 16;
 var FRAME_RATE = 10;
 var FRAME_TIME_MS = 1e3 / FRAME_RATE;
 var DedicatedServer = class {
-  constructor(port = 27910) {
-    this.port = port;
-    this.wss = null;
+  constructor(optionsOrPort = {}) {
     this.game = null;
     this.frameTimeout = null;
     this.entityIndex = null;
     // History buffer: Map<EntityIndex, HistoryArray>
     this.history = /* @__PURE__ */ new Map();
     this.backup = /* @__PURE__ */ new Map();
+    const options = typeof optionsOrPort === "number" ? { port: optionsOrPort } : optionsOrPort;
+    this.options = {
+      port: 27910,
+      maxPlayers: DEFAULT_MAX_CLIENTS,
+      deathmatch: true,
+      ...options
+    };
+    this.transport = this.options.transport || new WebSocketTransport();
     this.svs = {
       initialized: false,
       realTime: 0,
       mapCmd: "",
       spawnCount: 0,
-      clients: new Array(MAX_CLIENTS).fill(null),
+      clients: new Array(this.options.maxPlayers).fill(null),
       lastHeartbeat: 0,
       challenges: []
     };
@@ -807,20 +852,114 @@ var DedicatedServer = class {
     };
     this.entityIndex = new CollisionEntityIndex();
   }
+  setTransport(transport) {
+    if (this.svs.initialized) {
+      throw new Error("Cannot set transport after server started");
+    }
+    this.transport = transport;
+  }
+  async startServer(mapName) {
+    const map = mapName || this.options.mapName;
+    if (!map) {
+      throw new Error("No map specified");
+    }
+    await this.start(map);
+  }
+  stopServer() {
+    this.stop();
+  }
+  kickPlayer(clientId) {
+    if (clientId < 0 || clientId >= this.svs.clients.length) return;
+    const client = this.svs.clients[clientId];
+    if (client && client.state >= 2 /* Connected */) {
+      console.log(`Kicking client ${clientId}`);
+      if (client.netchan) {
+        const writer = new BinaryWriter2();
+        writer.writeByte(ServerCommand2.print);
+        writer.writeByte(2);
+        writer.writeString("Kicked by server.\n");
+        try {
+          const packet = client.netchan.transmit(writer.getData());
+          client.net.send(packet);
+        } catch (e) {
+        }
+      }
+      this.dropClient(client);
+    }
+  }
+  async changeMap(mapName) {
+    console.log(`Changing map to ${mapName}`);
+    this.multicast(
+      { x: 0, y: 0, z: 0 },
+      MulticastType.All,
+      ServerCommand2.print,
+      2,
+      `Changing map to ${mapName}...
+`
+    );
+    if (this.frameTimeout) clearTimeout(this.frameTimeout);
+    this.sv.state = 1 /* Loading */;
+    this.sv.collisionModel = null;
+    this.sv.time = 0;
+    this.sv.frame = 0;
+    this.sv.configStrings.fill("");
+    this.sv.baselines.fill(null);
+    this.history.clear();
+    this.entityIndex = new CollisionEntityIndex();
+    await this.loadMap(mapName);
+    this.initGame();
+    for (const client of this.svs.clients) {
+      if (client && client.state >= 2 /* Connected */) {
+        client.edict = null;
+        client.state = 2 /* Connected */;
+        this.sendServerData(client);
+        client.netchan.writeReliableByte(ServerCommand2.stufftext);
+        client.netchan.writeReliableString(`map ${mapName}
+`);
+        this.handleBegin(client);
+      }
+    }
+    this.runFrame();
+  }
+  getConnectedClients() {
+    const list = [];
+    for (const client of this.svs.clients) {
+      if (client && client.state >= 2 /* Connected */) {
+        list.push({
+          id: client.index,
+          name: "Player",
+          // TODO: Parse userinfo for name
+          ping: client.ping,
+          address: "unknown"
+        });
+      }
+    }
+    return list;
+  }
   async start(mapName) {
-    console.log(`Starting Dedicated Server on port ${this.port}...`);
+    console.log(`Starting Dedicated Server on port ${this.options.port}...`);
     this.sv.name = mapName;
     this.svs.initialized = true;
     this.svs.spawnCount++;
-    this.wss = new WebSocketServer({ port: this.port });
-    this.wss.on("connection", (ws) => {
-      console.log("New connection");
-      this.handleConnection(ws);
+    this.transport.onConnection((driver, info) => {
+      console.log("New connection", info ? `from ${info.socket?.remoteAddress}` : "");
+      this.handleConnection(driver, info);
+    });
+    this.transport.onError((err) => {
+      if (this.onServerError) this.onServerError(err);
     });
+    await this.transport.listen(this.options.port);
+    await this.loadMap(mapName);
+    this.initGame();
+    this.runFrame();
+    console.log("Server started.");
+  }
+  async loadMap(mapName) {
     try {
-      console.log(`Loading map ${this.sv.name}...`);
+      console.log(`Loading map ${mapName}...`);
       this.sv.state = 1 /* Loading */;
-      const mapData = await fs.readFile(this.sv.name);
+      this.sv.name = mapName;
+      const mapData = await fs.readFile(mapName);
       const arrayBuffer = mapData.buffer.slice(mapData.byteOffset, mapData.byteOffset + mapData.byteLength);
       const bspMap = parseBsp(arrayBuffer);
       const planes = bspMap.planes.map((p) => {
@@ -897,7 +1036,10 @@ var DedicatedServer = class {
       console.log(`Map loaded successfully.`);
     } catch (e) {
       console.warn("Failed to load map:", e);
+      if (this.onServerError) this.onServerError(e);
     }
+  }
+  initGame() {
     this.sv.startTime = Date.now();
     const imports = {
       trace: (start, mins, maxs, end, passent, contentmask) => {
@@ -954,7 +1096,6 @@ var DedicatedServer = class {
         };
       },
       pointcontents: (p) => 0,
-      // Empty
       linkentity: (ent) => {
         if (!this.entityIndex) return;
         this.entityIndex.link({
@@ -963,7 +1104,6 @@ var DedicatedServer = class {
           mins: ent.mins,
           maxs: ent.maxs,
           contents: ent.solid === 0 ? 0 : 1,
-          // Simplified contents
           surfaceFlags: 0
         });
       },
@@ -981,14 +1121,12 @@ var DedicatedServer = class {
     };
     this.game = createGame(imports, this, {
       gravity: { x: 0, y: 0, z: -800 },
-      deathmatch: true
+      deathmatch: this.options.deathmatch !== false
     });
     this.game.init(0);
     this.game.spawnWorld();
     this.populateBaselines();
     this.sv.state = 2 /* Game */;
-    this.runFrame();
-    console.log("Server started.");
   }
   populateBaselines() {
     if (!this.game) return;
@@ -1011,21 +1149,18 @@ var DedicatedServer = class {
       renderfx: ent.renderfx,
       solid: ent.solid,
       sound: ent.sounds,
-      // Assuming ent.sounds maps to 'sound' field in EntityState
       event: 0
     };
   }
   stop() {
     if (this.frameTimeout) clearTimeout(this.frameTimeout);
-    if (this.wss) this.wss.close();
+    this.transport.close();
     this.game?.shutdown();
     this.sv.state = 0 /* Dead */;
   }
-  handleConnection(ws) {
-    const driver = new WebSocketNetDriver();
-    driver.attach(ws);
+  handleConnection(driver, info) {
     let clientIndex = -1;
-    for (let i = 0; i < MAX_CLIENTS; i++) {
+    for (let i = 0; i < this.options.maxPlayers; i++) {
       if (this.svs.clients[i] === null || this.svs.clients[i].state === 0 /* Free */) {
         clientIndex = i;
         break;
@@ -1033,14 +1168,14 @@ var DedicatedServer = class {
     }
     if (clientIndex === -1) {
       console.log("Server full, rejecting connection");
-      ws.close();
+      driver.disconnect();
       return;
     }
     const client = createClient(clientIndex, driver);
     client.lastMessage = this.sv.frame;
     client.lastCommandTime = Date.now();
     this.svs.clients[clientIndex] = client;
-    console.log(`Client ${clientIndex} attached to slot from ${ws._socket?.remoteAddress || "unknown"}`);
+    console.log(`Client ${clientIndex} attached to slot from ${info?.socket?.remoteAddress || "unknown"}`);
     driver.onMessage((data) => this.onClientMessage(client, data));
     driver.onClose(() => this.onClientDisconnect(client));
   }
@@ -1053,6 +1188,9 @@ var DedicatedServer = class {
     if (client.edict && this.game) {
       this.game.clientDisconnect(client.edict);
     }
+    if (this.onClientDisconnected) {
+      this.onClientDisconnected(client.index);
+    }
     client.state = 0 /* Free */;
     this.svs.clients[client.index] = null;
     if (this.entityIndex && client.edict) {
@@ -1101,7 +1239,7 @@ var DedicatedServer = class {
     }
     let status = `map: ${this.sv.name}
 `;
-    status += `players: ${activeClients} active (${MAX_CLIENTS} max)
+    status += `players: ${activeClients} active (${this.options.maxPlayers} max)
 
 `;
     status += `num score ping name            lastmsg address               qport rate
@@ -1142,6 +1280,9 @@ var DedicatedServer = class {
       client.state = 2 /* Connected */;
       client.userInfo = userInfo;
       console.log(`Client ${client.index} connected: ${userInfo}`);
+      if (this.onClientConnected) {
+        this.onClientConnected(client.index, "Player");
+      }
       try {
         this.sendServerData(client);
         client.netchan.writeReliableByte(ServerCommand2.stufftext);
@@ -1361,10 +1502,8 @@ var DedicatedServer = class {
       pm_time: snapshot.pm_time,
       pm_flags: snapshot.pmFlags,
       gravity: Math.abs(snapshot.gravity.z),
-      // Usually only Z is relevant for gravity value
       delta_angles: snapshot.deltaAngles,
       viewoffset: { x: 0, y: 0, z: 22 },
-      // Default view offset if not in snapshot
       viewangles: snapshot.viewangles,
       kick_angles: snapshot.kick_angles,
       gun_index: snapshot.gunindex,
@@ -1533,7 +1672,6 @@ var DedicatedServer = class {
         }
         if (i < 0) {
           i = 0;
-        } else if (i >= hist.length - 1) {
         }
         const s1 = hist[i];
         const s2 = i + 1 < hist.length ? hist[i + 1] : s1;
@@ -1559,7 +1697,6 @@ var DedicatedServer = class {
           maxs: { ...ent.maxs },
           angles: { ...ent.angles },
           link: true
-          // assume linked if we are tracking it
         });
         ent.origin = origin;
         ent.angles = angles;
@@ -1579,7 +1716,6 @@ var DedicatedServer = class {
           mins: ent.mins,
           maxs: ent.maxs,
           contents: ent.solid === 0 ? 0 : 1,
-          // Simplified
           surfaceFlags: 0
         });
       });
@@ -1605,10 +1741,14 @@ var DedicatedServer = class {
     }
   }
 };
+function createServer(options = {}) {
+  return new DedicatedServer(options);
+}
 export {
   ClientMessageParser,
   ClientState,
   DedicatedServer,
   WebSocketNetDriver,
-  createClient
+  createClient,
+  createServer
 };