quake2ts 0.0.417 → 0.0.420

package/packages/client/dist/esm/index.js

@@ -13938,6 +13938,33 @@ var ClientEffectSystem = class {
   }
 };
 
+// src/blend.ts
+var createBlendState = () => ({
+  damageAlpha: 0,
+  bonusAlpha: 0,
+  lastFlashes: 0
+});
+var updateBlend = (state, ps, dt, damageIntensity = 0) => {
+  state.damageAlpha -= dt;
+  if (state.damageAlpha < 0) state.damageAlpha = 0;
+  if (damageIntensity > 0) {
+    state.damageAlpha = damageIntensity;
+  }
+  state.bonusAlpha -= dt;
+  if (state.bonusAlpha < 0) state.bonusAlpha = 0;
+  const flashes = ps.stats ? ps.stats[PlayerStat.STAT_FLASHES] ?? 0 : 0;
+  if (flashes !== state.lastFlashes) {
+    state.bonusAlpha = 0.6;
+    state.lastFlashes = flashes;
+  }
+  if (state.bonusAlpha > 0) {
+    return [1, 1, 0, state.bonusAlpha * 0.3];
+  } else if (state.damageAlpha > 0) {
+    return [1, 0, 0, state.damageAlpha * 0.5];
+  }
+  return [0, 0, 0, 0];
+};
+
 // src/input/bindings.ts
 var DEFAULT_BINDINGS = [
   { code: "KeyW", command: "+forward" },
@@ -14548,13 +14575,111 @@ var GameSession = class {
     }
   }
   loadSavedGame(saveData) {
+    if (this.host) {
+      this.shutdown();
+    }
+    const mapName = saveData.map;
+    const skill = saveData.difficulty;
+    const gameOptions = {
+      gravity: { x: 0, y: 0, z: -800 },
+      skill,
+      deathmatch: false,
+      coop: false
+    };
+    const gameEngineAdapter = {
+      trace: (start, end) => {
+        return this.engine.trace(start, end);
+      },
+      centerprintf: (ent, msg) => {
+        if (this.client) {
+          this.client.ParseCenterPrint(msg);
+        }
+      },
+      configstring: (idx, val) => {
+        if (this.client) {
+          this.client.ParseConfigString(idx, val);
+        }
+      },
+      multicast: () => {
+      },
+      unicast: () => {
+      },
+      serverCommand: () => {
+      }
+    };
+    const gameImports = {
+      trace: (start, mins, maxs, end, passent, contentmask) => {
+        const tr = this.engine.trace(start, end, mins || void 0, maxs || void 0);
+        let plane = null;
+        if (tr.planeNormal) {
+          plane = {
+            normal: tr.planeNormal,
+            dist: 0,
+            type: 0,
+            signbits: 0
+          };
+        }
+        return {
+          allsolid: tr.allsolid,
+          startsolid: tr.startsolid,
+          fraction: tr.fraction,
+          endpos: tr.endpos,
+          plane,
+          surfaceFlags: tr.surfaceFlags ?? 0,
+          contents: tr.contents ?? 0,
+          ent: null
+        };
+      },
+      pointcontents: (p) => {
+        const t = this.engine.trace(p, p, void 0, void 0);
+        return t.contents || 0;
+      },
+      multicast: () => {
+      },
+      unicast: () => {
+      },
+      configstring: (idx, val) => {
+        if (this.client) {
+          this.client.ParseConfigString(idx, val);
+        }
+      },
+      serverCommand: (cmd) => {
+      }
+    };
+    this.game = createGame(gameImports, gameEngineAdapter, gameOptions);
+    const clientProxy = {
+      init: (initial) => this.client?.init(initial),
+      render: (sample) => this.client?.render(sample),
+      shutdown: () => this.client?.shutdown(),
+      get camera() {
+        return this.client?.camera;
+      }
+    };
+    this.host = new EngineHost(this.game, clientProxy);
+    const clientImports = {
+      engine: this.engine,
+      host: this.host
+    };
+    this.client = createClient(clientImports);
+    if (this.engine.cmd) {
+      this.engine.cmd.executeText(`map ${mapName}`);
+    } else if (this.host.commands) {
+      this.host.commands.execute(`map ${mapName}`);
+    }
+    if (this.game) {
+      this.game.loadSave(saveData);
+    }
+    this.host.start();
   }
   shutdown() {
     if (this.host) {
       this.host.stop();
       this.host = null;
     }
-    this.client = null;
+    if (this.client) {
+      this.client.shutdown();
+      this.client = null;
+    }
     this.game = null;
   }
   getClient() {
@@ -14635,6 +14760,9 @@ function createClient(imports) {
   let pauseMenuFactory;
   let optionsFactory;
   const configStrings = new ClientConfigStrings();
+  const blendState = createBlendState();
+  let currentBlend = [0, 0, 0, 0];
+  let pendingDamage = 0;
   let latestFrame;
   let lastRenderTime = 0;
   let clientInAutoDemo = false;
@@ -14706,6 +14834,9 @@ function createClient(imports) {
       if (pos) {
         effectSystem.onTempEntity(type, pos, time);
       }
+    },
+    onDamage: (indicators) => {
+      pendingDamage = 0.5;
     }
   });
   demoPlayback.setHandler(demoHandler);
@@ -15016,7 +15147,16 @@ function createClient(imports) {
         }
       }
       const frameTimeMs = sample.latest && sample.previous ? Math.max(0, sample.latest.timeMs - sample.previous.timeMs) : 0;
+      if (frameTimeMs > 0) {
+        prediction.decayError(frameTimeMs / 1e3);
+      }
       lastView = view.sample(lastRendered, frameTimeMs);
+      if (lastRendered) {
+        currentBlend = updateBlend(blendState, lastRendered, frameTimeMs / 1e3, pendingDamage);
+        pendingDamage = 0;
+      } else {
+        currentBlend = [0, 0, 0, 0];
+      }
       const command = {};
       const timeSeconds = sample.nowMs / 1e3;
       dlightManager.update(timeSeconds);
@@ -15072,23 +15212,18 @@ function createClient(imports) {
         }, renderEntities);
       }
       if (imports.engine.renderer && lastRendered && lastRendered.client) {
-        const stats = imports.engine.renderer.stats ? {
-          ...imports.engine.renderer.stats,
-          batches: 0,
-          facesDrawn: 0,
-          drawCalls: 0,
-          skyDrawn: false,
-          viewModelDrawn: false,
-          fps: 0,
-          vertexCount: 0
-        } : {
-          batches: 0,
-          facesDrawn: 0,
-          drawCalls: 0,
+        const perfReport = imports.engine.renderer.getPerformanceReport();
+        const stats = {
+          batches: perfReport.textureBinds,
+          facesDrawn: perfReport.triangles,
+          // approximate
+          drawCalls: perfReport.drawCalls,
           skyDrawn: false,
+          // Not exposed in report
           viewModelDrawn: false,
+          // Not exposed in report
           fps: 0,
-          vertexCount: 0
+          vertexCount: perfReport.vertices
         };
         const timeMs = sample.latest?.timeMs ?? 0;
         this.DrawHUD(stats, timeMs);
@@ -15111,7 +15246,7 @@ function createClient(imports) {
           maxs: { x: 16, y: 16, z: 32 },
           damageAlpha: lastRendered.damageAlpha ?? 0,
           damageIndicators: lastRendered.damageIndicators ?? [],
-          blend: lastRendered.blend ?? [0, 0, 0, 0],
+          blend: currentBlend,
           pickupIcon: lastRendered.pickupIcon,
           centerPrint: void 0,
           // Handled by CGame MessageSystem now