@quake2ts/shared 0.0.1

package/src/net/netchan.ts

@@ -0,0 +1,451 @@
+import { BinaryWriter } from '../io/binaryWriter.js';
+
+export interface NetAddress {
+  type: string;
+  port: number;
+}
+
+/**
+ * NetChan handles reliable message delivery over an unreliable channel (UDP/WebSocket).
+ * Fragmentation support is planned but not fully implemented.
+ *
+ * Ported from qcommon/net_chan.c
+ */
+export class NetChan {
+  // Constants from net_chan.c
+  static readonly MAX_MSGLEN = 1400;
+  static readonly FRAGMENT_SIZE = 1024;
+  static readonly PACKET_HEADER = 10; // sequence(4) + ack(4) + qport(2)
+  static readonly HEADER_OVERHEAD = NetChan.PACKET_HEADER + 2; // +2 for reliable length prefix
+
+  // Increase internal reliable buffer to support large messages (fragmentation)
+  // Quake 2 uses MAX_MSGLEN for the reliable buffer, limiting single messages to ~1400 bytes.
+  // We expand this to allow larger messages (e.g. snapshots, downloads) which are then fragmented.
+  static readonly MAX_RELIABLE_BUFFER = 0x40000; // 256KB
+
+  // Public state
+  qport = 0; // qport value to distinguish multiple clients from same IP
+
+  // Sequencing
+  incomingSequence = 0;
+  outgoingSequence = 0;
+  incomingAcknowledged = 0;
+
+  // Reliable messaging
+  incomingReliableAcknowledged = false; // single bit
+  incomingReliableSequence = 0; // last reliable message sequence received
+  outgoingReliableSequence = 0; // reliable message sequence number to send
+  reliableMessage: BinaryWriter;
+  reliableLength = 0;
+
+  // Fragmentation State (Sending)
+  fragmentSendOffset = 0;
+
+  // Fragmentation State (Receiving)
+  fragmentBuffer: Uint8Array | null = null;
+  fragmentLength = 0;
+  fragmentReceived = 0;
+
+  // Timing
+  lastReceived = 0;
+  lastSent = 0;
+
+  remoteAddress: NetAddress | null = null;
+
+  constructor() {
+    // Initialize buffers
+    this.reliableMessage = new BinaryWriter(NetChan.MAX_RELIABLE_BUFFER);
+
+    // Set initial timestamps
+    const now = Date.now();
+    this.lastReceived = now;
+    this.lastSent = now;
+
+    // Random qport by default (can be overridden)
+    // Ensure we use global Math.random which is usually seeded or random enough for basic collision avoidance
+    this.qport = Math.floor(Math.random() * 65536);
+  }
+
+  /**
+   * Setup the netchan with specific settings
+   */
+  setup(qport: number, address: NetAddress | null = null): void {
+    this.qport = qport;
+    this.remoteAddress = address;
+    this.reset();
+  }
+
+  /**
+   * Reset the netchan state
+   */
+  reset(): void {
+    this.incomingSequence = 0;
+    this.outgoingSequence = 0;
+    this.incomingAcknowledged = 0;
+    this.incomingReliableAcknowledged = false;
+    this.incomingReliableSequence = 0;
+    this.outgoingReliableSequence = 0;
+    this.reliableLength = 0;
+    this.reliableMessage.reset();
+
+    this.fragmentSendOffset = 0;
+    this.fragmentBuffer = null;
+    this.fragmentLength = 0;
+    this.fragmentReceived = 0;
+
+    this.lastReceived = Date.now();
+    this.lastSent = Date.now();
+  }
+
+  /**
+   * Transmits a packet containing reliable and unreliable data
+   */
+  transmit(unreliableData?: Uint8Array): Uint8Array {
+    this.outgoingSequence++;
+    this.lastSent = Date.now();
+
+    // Determine how much reliable data to send in this packet
+    let sendReliableLength = 0;
+    let isFragment = false;
+    let fragmentStart = 0;
+
+    if (this.reliableLength > 0) {
+      // Check if we need to fragment
+      if (this.reliableLength > NetChan.FRAGMENT_SIZE) {
+        // We are in fragment mode
+        isFragment = true;
+
+        // If we have finished sending all fragments but still haven't received ACK,
+        // we must loop back to the beginning to retransmit.
+        if (this.fragmentSendOffset >= this.reliableLength) {
+          this.fragmentSendOffset = 0;
+        }
+
+        // Calculate chunk size
+        const remaining = this.reliableLength - this.fragmentSendOffset;
+        sendReliableLength = remaining;
+        if (sendReliableLength > NetChan.FRAGMENT_SIZE) {
+          sendReliableLength = NetChan.FRAGMENT_SIZE;
+        }
+
+        fragmentStart = this.fragmentSendOffset;
+
+        // Advance offset for the next packet
+        this.fragmentSendOffset += sendReliableLength;
+      } else {
+        // Fits in one packet
+        sendReliableLength = this.reliableLength;
+      }
+    }
+
+    // Calculate total size
+    // Header + Reliable + Unreliable
+    const headerSize = NetChan.PACKET_HEADER;
+    const reliableHeaderSize = sendReliableLength > 0 ? 2 + (isFragment ? 8 : 0) : 0; // +2 length, +8 fragment info
+
+    let unreliableSize = unreliableData ? unreliableData.length : 0;
+
+    // Check for overflow
+    if (headerSize + reliableHeaderSize + sendReliableLength + unreliableSize > NetChan.MAX_MSGLEN) {
+      unreliableSize = NetChan.MAX_MSGLEN - headerSize - reliableHeaderSize - sendReliableLength;
+      // We truncate unreliable data if it doesn't fit with reliable data
+      if (unreliableSize < 0) unreliableSize = 0;
+    }
+
+    const buffer = new ArrayBuffer(headerSize + reliableHeaderSize + sendReliableLength + unreliableSize);
+    const view = new DataView(buffer);
+    const result = new Uint8Array(buffer);
+
+    // Write Header
+    // Sequence
+    let sequence = this.outgoingSequence;
+
+    // Set reliable bit if we are sending reliable data
+    if (sendReliableLength > 0) {
+      sequence |= 0x80000000;
+      // Also set the reliable sequence bit (0/1 toggle) at bit 30
+      if ((this.outgoingReliableSequence & 1) !== 0) {
+        sequence |= 0x40000000;
+      }
+    }
+
+    view.setUint32(0, sequence, true);
+
+    // Acknowledge
+    // Set reliable ack bit at bit 31
+    let ack = this.incomingSequence;
+    if ((this.incomingReliableSequence & 1) !== 0) {
+      ack |= 0x80000000;
+    }
+    view.setUint32(4, ack, true);
+
+    view.setUint16(8, this.qport, true);
+
+    // Copy Reliable Data
+    let offset = headerSize;
+    if (sendReliableLength > 0) {
+      // Write length of reliable data (2 bytes)
+      // Extension: If length has high bit (0x8000), it's a fragment.
+      let lengthField = sendReliableLength;
+      if (isFragment) {
+        lengthField |= 0x8000;
+      }
+
+      view.setUint16(offset, lengthField, true);
+      offset += 2;
+
+      if (isFragment) {
+        // Write fragment info: 4 bytes start offset, 4 bytes total length
+        view.setUint32(offset, fragmentStart, true);
+        offset += 4;
+        view.setUint32(offset, this.reliableLength, true);
+        offset += 4;
+      }
+
+      // Copy data
+      const reliableBuffer = this.reliableMessage.getBuffer();
+      const reliableBytes = reliableBuffer.subarray(fragmentStart, fragmentStart + sendReliableLength);
+      result.set(reliableBytes, offset);
+      offset += sendReliableLength;
+    }
+
+    // Copy Unreliable Data
+    if (unreliableData && unreliableSize > 0) {
+      const chunk = unreliableData.slice(0, unreliableSize);
+      result.set(chunk, offset);
+    }
+
+    return result;
+  }
+
+  /**
+   * Processes a received packet
+   * Returns the payload data (reliable + unreliable) to be processed, or null if discarded
+   */
+  process(packet: Uint8Array): Uint8Array | null {
+    if (packet.length < NetChan.PACKET_HEADER) {
+      return null;
+    }
+
+    this.lastReceived = Date.now();
+
+    const view = new DataView(packet.buffer, packet.byteOffset, packet.byteLength);
+    const sequence = view.getUint32(0, true);
+    const ack = view.getUint32(4, true);
+    const qport = view.getUint16(8, true);
+
+    if (this.qport !== qport) {
+      return null;
+    }
+
+    // Check for duplicate or out of order
+    const seqNumberClean = sequence & ~(0x80000000 | 0x40000000); // Mask out flags
+
+    // Handle wrapping using signed difference
+    if (((seqNumberClean - this.incomingSequence) | 0) <= 0) {
+      return null;
+    }
+
+    // Update incoming sequence
+    this.incomingSequence = seqNumberClean;
+
+    // Handle reliable acknowledgment
+    const ackNumber = ack & ~0x80000000;
+    const ackReliable = (ack & 0x80000000) !== 0;
+
+    if (ackNumber > this.incomingAcknowledged) {
+      this.incomingAcknowledged = ackNumber;
+    }
+
+    // Check if our reliable message was acknowledged
+    // If the receiver has toggled their reliable bit, it means they got the WHOLE message
+    if (this.reliableLength > 0) {
+       const receivedAckBit = ackReliable ? 1 : 0;
+       const currentReliableBit = this.outgoingReliableSequence & 1;
+
+       if (receivedAckBit !== currentReliableBit) {
+         // Acked!
+         this.reliableLength = 0;
+         this.reliableMessage.reset();
+         this.outgoingReliableSequence ^= 1;
+         this.fragmentSendOffset = 0; // Reset fragment offset
+       }
+    }
+
+    // Handle incoming reliable data
+    const hasReliableData = (sequence & 0x80000000) !== 0;
+    const reliableSeqBit = (sequence & 0x40000000) !== 0 ? 1 : 0;
+
+    let payloadOffset = NetChan.PACKET_HEADER;
+    let reliableData: Uint8Array | null = null;
+
+    if (hasReliableData) {
+       if (payloadOffset + 2 > packet.byteLength) return null; // Malformed
+
+       let reliableLen = view.getUint16(payloadOffset, true);
+       payloadOffset += 2;
+
+       const isFragment = (reliableLen & 0x8000) !== 0;
+       reliableLen &= 0x7FFF;
+
+       // Check if this is the expected reliable sequence
+       const expectedBit = this.incomingReliableSequence & 1;
+
+       if (reliableSeqBit === expectedBit) {
+          // It's the sequence we are waiting for
+
+          if (isFragment) {
+             // Read fragment info
+             if (payloadOffset + 8 > packet.byteLength) return null;
+             const fragStart = view.getUint32(payloadOffset, true);
+             payloadOffset += 4;
+             const fragTotal = view.getUint32(payloadOffset, true);
+             payloadOffset += 4;
+
+             // Validate fragTotal against MAX_RELIABLE_BUFFER
+             if (fragTotal > NetChan.MAX_RELIABLE_BUFFER) {
+               console.warn(`NetChan: received invalid fragment total ${fragTotal} > ${NetChan.MAX_RELIABLE_BUFFER}`);
+               return null;
+             }
+
+             // Initialize fragment buffer if needed
+             if (!this.fragmentBuffer || this.fragmentBuffer.length !== fragTotal) {
+                this.fragmentBuffer = new Uint8Array(fragTotal);
+                this.fragmentLength = fragTotal;
+                this.fragmentReceived = 0;
+             }
+
+             // Check for valid fragment offset
+             if (payloadOffset + reliableLen > packet.byteLength) return null;
+             const data = packet.subarray(payloadOffset, payloadOffset + reliableLen);
+
+             // Only accept if it matches our expected offset (enforce in-order delivery for simplicity)
+             // or check if we haven't received this part yet.
+             // Since we use a simple 'fragmentReceived' counter, we effectively expect in-order delivery
+             // of streams if we just use append logic.
+             // BUT UDP can reorder.
+             // To be robust, we should enforce strict ordering: fragStart must equal fragmentReceived.
+             // If we miss a chunk, we ignore subsequent chunks until the missing one arrives (via retransmit loop).
+
+             if (fragStart === this.fragmentReceived && fragStart + reliableLen <= fragTotal) {
+               this.fragmentBuffer.set(data, fragStart);
+               this.fragmentReceived += reliableLen;
+
+               // Check if complete
+               if (this.fragmentReceived >= fragTotal) {
+                 reliableData = this.fragmentBuffer;
+                 this.incomingReliableSequence++;
+                 this.fragmentBuffer = null;
+                 this.fragmentLength = 0;
+                 this.fragmentReceived = 0;
+               }
+             }
+
+          } else {
+             // Not a fragment (standard)
+             this.incomingReliableSequence++;
+             if (payloadOffset + reliableLen > packet.byteLength) return null;
+             reliableData = packet.slice(payloadOffset, payloadOffset + reliableLen);
+          }
+       }
+
+       // Advance past reliable data regardless
+       payloadOffset += reliableLen;
+    }
+
+    // Get unreliable data
+    const unreliableData = packet.slice(payloadOffset);
+
+    // Combine if we have reliable data
+    if (reliableData && reliableData.length > 0) {
+        const totalLen = reliableData.length + unreliableData.length;
+        const result = new Uint8Array(totalLen);
+        result.set(reliableData, 0);
+        result.set(unreliableData, reliableData.length);
+        return result;
+    }
+
+    if (unreliableData) {
+      return unreliableData;
+    }
+
+    return new Uint8Array(0);
+  }
+
+  /**
+   * Checks if reliable message buffer is empty and ready for new data
+   */
+  canSendReliable(): boolean {
+    return this.reliableLength === 0;
+  }
+
+  /**
+   * Writes a byte to the reliable message buffer
+   */
+  writeReliableByte(value: number): void {
+    if (this.reliableLength + 1 > NetChan.MAX_RELIABLE_BUFFER) {
+      throw new Error('NetChan reliable buffer overflow');
+    }
+    this.reliableMessage.writeByte(value);
+    this.reliableLength++;
+  }
+
+  /**
+   * Writes a short to the reliable message buffer
+   */
+  writeReliableShort(value: number): void {
+    if (this.reliableLength + 2 > NetChan.MAX_RELIABLE_BUFFER) {
+      throw new Error('NetChan reliable buffer overflow');
+    }
+    this.reliableMessage.writeShort(value);
+    this.reliableLength += 2;
+  }
+
+  /**
+   * Writes a long to the reliable message buffer
+   */
+  writeReliableLong(value: number): void {
+    if (this.reliableLength + 4 > NetChan.MAX_RELIABLE_BUFFER) {
+      throw new Error('NetChan reliable buffer overflow');
+    }
+    this.reliableMessage.writeLong(value);
+    this.reliableLength += 4;
+  }
+
+  /**
+   * Writes a string to the reliable message buffer
+   */
+  writeReliableString(value: string): void {
+    const len = value.length + 1; // +1 for null terminator
+    if (this.reliableLength + len > NetChan.MAX_RELIABLE_BUFFER) {
+      throw new Error('NetChan reliable buffer overflow');
+    }
+    this.reliableMessage.writeString(value);
+    this.reliableLength += len;
+  }
+
+  /**
+   * Returns the current reliable data buffer
+   */
+  getReliableData(): Uint8Array {
+    if (this.reliableLength === 0) {
+      return new Uint8Array(0);
+    }
+    const buffer = this.reliableMessage.getBuffer();
+    return buffer.subarray(0, this.reliableLength);
+  }
+
+  /**
+   * Checks if we need to send a keepalive packet
+   */
+  needsKeepalive(currentTime: number): boolean {
+    return (currentTime - this.lastSent) > 1000;
+  }
+
+  /**
+   * Checks if the connection has timed out
+   */
+  isTimedOut(currentTime: number, timeoutMs: number = 30000): boolean {
+    return (currentTime - this.lastReceived) > timeoutMs;
+  }
+}

package/src/pmove/apply.ts

@@ -0,0 +1,151 @@
+
+import { PmoveCmd, PmoveTraceFn } from './types.js';
+import { Vec3 } from '../math/vec3.js';
+
+import { applyPmoveAccelerate, applyPmoveFriction, buildAirGroundWish, buildWaterWish } from './pmove.js';
+import { PlayerState } from '../protocol/player-state.js';
+import { angleVectors } from '../math/angles.js';
+import { MASK_WATER } from '../bsp/contents.js';
+
+const FRAMETIME = 0.025;
+
+// Local definition to avoid dependency issues if constants.ts is missing
+// Matches packages/shared/src/pmove/constants.ts
+const WaterLevel = {
+  None: 0,
+  Feet: 1,
+  Waist: 2,
+  Under: 3,
+} as const;
+
+const categorizePosition = (state: PlayerState, trace: PmoveTraceFn): PlayerState => {
+  const point = { ...state.origin };
+  point.z -= 0.25;
+  const traceResult = trace(state.origin, point);
+
+  return {
+    ...state,
+    onGround: traceResult.fraction < 1,
+  };
+};
+
+const checkWater = (state: PlayerState, pointContents: (point: Vec3) => number): PlayerState => {
+  const point = { ...state.origin };
+  const { mins, maxs } = state;
+
+  // Default to feet
+  point.z = state.origin.z + mins.z + 1;
+
+  const feetContents = pointContents(point);
+
+  if (!(feetContents & MASK_WATER)) {
+    return { ...state, waterLevel: WaterLevel.None, watertype: 0 };
+  }
+
+  let waterLevel: number = WaterLevel.Feet;
+  let watertype = feetContents;
+
+  // Check waist
+  const waist = state.origin.z + (mins.z + maxs.z) * 0.5;
+  point.z = waist;
+  const waistContents = pointContents(point);
+
+  if (waistContents & MASK_WATER) {
+    waterLevel = WaterLevel.Waist;
+    watertype = waistContents;
+
+    // Check head (eyes)
+    // Standard Quake 2 viewheight is 22. maxs.z is typically 32.
+    // So eyes are roughly at origin.z + 22.
+    // We'll use origin.z + 22 to check if eyes are underwater.
+    // If viewheight was available in PlayerState, we'd use that.
+    const head = state.origin.z + 22;
+    point.z = head;
+    const headContents = pointContents(point);
+
+    if (headContents & MASK_WATER) {
+      waterLevel = WaterLevel.Under;
+      watertype = headContents;
+    }
+  }
+
+  return { ...state, waterLevel, watertype };
+};
+
+
+export const applyPmove = (
+  state: PlayerState,
+  cmd: PmoveCmd,
+  trace: PmoveTraceFn,
+  pointContents: (point: Vec3) => number
+): PlayerState => {
+  let newState = { ...state };
+  newState = categorizePosition(newState, trace);
+  newState = checkWater(newState, pointContents);
+
+  const { origin, velocity, onGround, waterLevel, viewAngles } = newState;
+
+  // Calculate forward and right vectors from view angles
+  // For water movement, use full view angles including pitch
+  // For ground/air movement, reduce pitch influence by dividing by 3
+  // See: rerelease/p_move.cpp lines 1538, 1686-1691, 800, 858
+  const adjustedAngles = waterLevel >= 2
+    ? viewAngles
+    : {
+        // For ground/air movement, reduce pitch influence (rerelease/p_move.cpp:1689)
+        x: viewAngles.x > 180 ? (viewAngles.x - 360) / 3 : viewAngles.x / 3,
+        y: viewAngles.y,
+        z: viewAngles.z,
+      };
+
+  const { forward, right } = angleVectors(adjustedAngles);
+
+  // Apply friction BEFORE acceleration to match original Quake 2 rerelease behavior
+  // See: rerelease/src/game/player/pmove.c lines 1678 (PM_Friction) then 1693 (PM_AirMove->PM_Accelerate)
+  const frictionedVelocity = applyPmoveFriction({
+    velocity,
+    frametime: FRAMETIME,
+    onGround,
+    groundIsSlick: false,
+    onLadder: false,
+    waterlevel: waterLevel,
+    pmFriction: 6,
+    pmStopSpeed: 100,
+    pmWaterFriction: 1,
+  });
+
+  const wish = waterLevel >= 2
+    ? buildWaterWish({
+        forward,
+        right,
+        cmd,
+        maxSpeed: 320,
+      })
+    : buildAirGroundWish({
+        forward,
+        right,
+        cmd,
+        maxSpeed: 320,
+      });
+
+  const finalVelocity = applyPmoveAccelerate({
+    velocity: frictionedVelocity,
+    wishdir: wish.wishdir,
+    wishspeed: wish.wishspeed,
+    // Water movement uses ground acceleration (10), not air acceleration (1)
+    accel: (onGround || waterLevel >= 2) ? 10 : 1,
+    frametime: FRAMETIME,
+  });
+
+  const traceResult = trace(origin, {
+    x: origin.x + finalVelocity.x * FRAMETIME,
+    y: origin.y + finalVelocity.y * FRAMETIME,
+    z: origin.z + finalVelocity.z * FRAMETIME,
+  });
+
+  return {
+    ...newState,
+    origin: traceResult.endpos,
+    velocity: finalVelocity,
+  };
+};