quake2ts 0.0.197 → 0.0.199

package/packages/client/dist/cjs/index.cjs

@@ -3843,6 +3843,150 @@ var AMMO_TYPE_COUNT2 = Object.keys(AmmoType2).length / 2;
 var import_cgame2 = require("@quake2ts/cgame");
 var import_cgame3 = require("@quake2ts/cgame");
 
+// src/cgameBridge.ts
+function createCGameImport(imports, state) {
+  const picCache = /* @__PURE__ */ new Map();
+  const pendingPics = /* @__PURE__ */ new Set();
+  const getRenderer = () => imports.engine.renderer;
+  return {
+    // Frame timing
+    get tick_rate() {
+      return state.tickRate;
+    },
+    get frame_time_s() {
+      return state.frameTimeMs / 1e3;
+    },
+    get frame_time_ms() {
+      return state.frameTimeMs;
+    },
+    // Console
+    Com_Print: (msg) => {
+      console.log(`[CGAME] ${msg}`);
+    },
+    Com_Error: (msg) => {
+      console.error(`[CGAME ERROR] ${msg}`);
+    },
+    // Config strings
+    get_configstring: (num) => {
+      return state.configStrings.get(num) || "";
+    },
+    // Memory (No-op in JS)
+    TagMalloc: (size, tag) => ({}),
+    TagFree: (ptr) => {
+    },
+    FreeTags: (tag) => {
+    },
+    // Cvars
+    cvar: (name, value, flags) => {
+      const existing = imports.host?.cvars?.get(name);
+      if (existing) return existing;
+      return null;
+    },
+    cvar_set: (name, value) => {
+      imports.host?.cvars?.setValue(name, value);
+    },
+    cvar_forceset: (name, value) => {
+      imports.host?.cvars?.setValue(name, value);
+    },
+    // Client state
+    CL_FrameValid: () => true,
+    // Always assume valid for now
+    CL_FrameTime: () => state.frameTimeMs,
+    CL_ClientTime: () => state.frameTimeMs,
+    // Use frame time as client time
+    CL_ServerFrame: () => state.serverFrame,
+    CL_ServerProtocol: () => state.serverProtocol,
+    // Client info
+    CL_GetClientName: (playerNum) => {
+      return state.getClientName(playerNum);
+    },
+    CL_GetClientPic: (playerNum) => {
+      return "";
+    },
+    CL_GetClientDogtag: (playerNum) => {
+      return "";
+    },
+    CL_GetKeyBinding: (key) => {
+      return state.getKeyBinding(key);
+    },
+    // Drawing
+    Draw_RegisterPic: (name) => {
+      if (picCache.has(name)) {
+        return name;
+      }
+      if (pendingPics.has(name)) {
+        return name;
+      }
+      pendingPics.add(name);
+      if (imports.engine.assets) {
+        imports.engine.assets.loadTexture(name).then((texture) => {
+          if (imports.engine.renderer) {
+            const pic = imports.engine.renderer.registerTexture(name, texture);
+            picCache.set(name, pic);
+          }
+          pendingPics.delete(name);
+        }).catch((err) => {
+          console.warn(`[CGameImport] Failed to load pic: ${name}`, err);
+          pendingPics.delete(name);
+        });
+      }
+      return name;
+    },
+    Draw_GetPicSize: (picHandle) => {
+      const name = picHandle;
+      const pic = picCache.get(name);
+      if (pic) {
+        return { width: pic.width, height: pic.height };
+      }
+      return { width: 0, height: 0 };
+    },
+    SCR_DrawChar: (x, y, char) => {
+      getRenderer()?.drawString(x, y, String.fromCharCode(char));
+    },
+    SCR_DrawPic: (x, y, picHandle) => {
+      const name = picHandle;
+      const pic = picCache.get(name);
+      if (pic) {
+        getRenderer()?.drawPic(x, y, pic);
+      }
+    },
+    SCR_DrawColorPic: (x, y, picHandle, color, alpha) => {
+      const name = picHandle;
+      const pic = picCache.get(name);
+      if (pic) {
+        getRenderer()?.drawPic(x, y, pic, [color.x, color.y, color.z, alpha]);
+      }
+    },
+    SCR_DrawFontString: (x, y, str3) => {
+      getRenderer()?.drawString(x, y, str3);
+    },
+    SCR_DrawCenterString: (y, str3) => {
+      getRenderer()?.drawCenterString(y, str3);
+    },
+    SCR_MeasureFontString: (str3) => {
+      const stripped = str3.replace(/\^[0-9]/g, "");
+      return stripped.length * 8;
+    },
+    SCR_FontLineHeight: () => 8,
+    SCR_SetAltTypeface: (alt) => {
+    },
+    SCR_DrawBind: (x, y, command) => {
+      const key = state.getKeyBinding(command);
+      getRenderer()?.drawString(x, y, `[${command}]`);
+    },
+    // Localization
+    Localize: (key) => key,
+    // State queries
+    CL_GetTextInput: () => "",
+    CL_GetWarnAmmoCount: () => 5,
+    CL_InAutoDemoLoop: () => state.inAutoDemo,
+    // Prediction Trace
+    PM_Trace: (start, end, mins, maxs) => {
+      return imports.engine.trace(start, end, mins, maxs);
+    }
+  };
+}
+
 // src/hud/crosshair.ts
 var crosshairPic = null;
 var crosshairIndex = 0;
@@ -4740,6 +4884,9 @@ var ClientNetworkHandler = class {
     }
     return latestState;
   }
+  get latestServerFrame() {
+    return this.latestFrame?.serverFrame ?? 0;
+  }
 };
 
 // src/configStrings.ts
@@ -6154,6 +6301,33 @@ function createClient(imports) {
   let lastRendered;
   let lastView;
   let camera;
+  let clientInAutoDemo = false;
+  const stateProvider = {
+    get tickRate() {
+      return 10;
+    },
+    // Default 10Hz
+    get frameTimeMs() {
+      return latestFrame?.timeMs ?? 0;
+    },
+    get serverFrame() {
+      return demoHandler.latestServerFrame;
+    },
+    // Corrected access
+    get serverProtocol() {
+      return 34;
+    },
+    get configStrings() {
+      return configStrings;
+    },
+    getClientName: (num) => `Player ${num}`,
+    getKeyBinding: (key) => `[${key}]`,
+    get inAutoDemo() {
+      return clientInAutoDemo;
+    }
+  };
+  const cgameImport = createCGameImport(imports, stateProvider);
+  const cg = (0, import_cgame2.GetCGameAPI)(cgameImport);
   let fovValue = 90;
   let isZooming = false;
   if (imports.host) {
@@ -6230,6 +6404,7 @@ function createClient(imports) {
       if (initial?.state) {
         prediction.setAuthoritative(initial);
       }
+      cg.Init();
       if (imports.engine.assets && imports.engine.renderer) {
         loadingScreen.start(100, "Loading assets...");
         Init_Hud(imports.engine.renderer, imports.engine.assets).then(() => {
@@ -6459,6 +6634,7 @@ function createClient(imports) {
       this.Shutdown();
     },
     Shutdown() {
+      cg.Shutdown();
       latestFrame = void 0;
       lastRendered = void 0;
       if (imports.host?.cvars) {