quake2ts 0.0.288 → 0.0.289

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

@@ -775,6 +775,333 @@ var BinaryStream = class {
     out.z = norm[2];
   }
 };
+var BinaryWriter = class {
+  constructor(sizeOrBuffer = 1400) {
+    if (typeof sizeOrBuffer === "number") {
+      this.buffer = new Uint8Array(sizeOrBuffer);
+      this.fixed = false;
+    } else {
+      this.buffer = sizeOrBuffer;
+      this.fixed = true;
+    }
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+    this.offset = 0;
+  }
+  ensureSpace(bytes) {
+    if (this.offset + bytes > this.buffer.byteLength) {
+      if (this.fixed) {
+        throw new Error(`Buffer overflow: capacity ${this.buffer.byteLength}, needed ${this.offset + bytes}`);
+      }
+      const newSize = Math.max(this.buffer.byteLength * 2, this.offset + bytes);
+      const newBuffer = new Uint8Array(newSize);
+      newBuffer.set(this.buffer);
+      this.buffer = newBuffer;
+      this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+    }
+  }
+  writeByte(value) {
+    this.ensureSpace(1);
+    this.view.setUint8(this.offset, value);
+    this.offset += 1;
+  }
+  writeChar(value) {
+    this.ensureSpace(1);
+    this.view.setInt8(this.offset, value);
+    this.offset += 1;
+  }
+  writeShort(value) {
+    this.ensureSpace(2);
+    this.view.setInt16(this.offset, value, true);
+    this.offset += 2;
+  }
+  writeLong(value) {
+    this.ensureSpace(4);
+    this.view.setInt32(this.offset, value, true);
+    this.offset += 4;
+  }
+  writeFloat(value) {
+    this.ensureSpace(4);
+    this.view.setFloat32(this.offset, value, true);
+    this.offset += 4;
+  }
+  writeString(value) {
+    const len = value.length;
+    this.ensureSpace(len + 1);
+    for (let i = 0; i < len; i++) {
+      this.view.setUint8(this.offset + i, value.charCodeAt(i));
+    }
+    this.view.setUint8(this.offset + len, 0);
+    this.offset += len + 1;
+  }
+  writeCoord(value) {
+    this.writeShort(Math.trunc(value * 8));
+  }
+  writeAngle(value) {
+    this.writeByte(Math.trunc(value * 256 / 360) & 255);
+  }
+  writeAngle16(value) {
+    this.writeShort(Math.trunc(value * 65536 / 360) & 65535);
+  }
+  writePos(pos) {
+    this.writeCoord(pos.x);
+    this.writeCoord(pos.y);
+    this.writeCoord(pos.z);
+  }
+  writeDir(dir) {
+    let maxDot = -1;
+    let bestIndex = 0;
+    if (dir.x === 0 && dir.y === 0 && dir.z === 0) {
+      this.writeByte(0);
+      return;
+    }
+    for (let i = 0; i < ANORMS.length; i++) {
+      const norm = ANORMS[i];
+      const dot = dir.x * norm[0] + dir.y * norm[1] + dir.z * norm[2];
+      if (dot > maxDot) {
+        maxDot = dot;
+        bestIndex = i;
+      }
+    }
+    this.writeByte(bestIndex);
+  }
+  getData() {
+    return this.buffer.slice(0, this.offset);
+  }
+  getBuffer() {
+    return this.buffer;
+  }
+  getOffset() {
+    return this.offset;
+  }
+  reset() {
+    this.offset = 0;
+  }
+};
+var _NetChan = class _NetChan2 {
+  constructor() {
+    this.qport = 0;
+    this.incomingSequence = 0;
+    this.outgoingSequence = 0;
+    this.incomingAcknowledged = 0;
+    this.incomingReliableAcknowledged = false;
+    this.incomingReliableSequence = 0;
+    this.outgoingReliableSequence = 0;
+    this.reliableLength = 0;
+    this.lastReceived = 0;
+    this.lastSent = 0;
+    this.remoteAddress = null;
+    this.reliableMessage = new BinaryWriter(_NetChan2.MAX_MSGLEN);
+    const now = Date.now();
+    this.lastReceived = now;
+    this.lastSent = now;
+    this.qport = Math.floor(Math.random() * 65536);
+  }
+  /**
+   * Setup the netchan with specific settings
+   */
+  setup(qport, address = null) {
+    this.qport = qport;
+    this.remoteAddress = address;
+    this.reset();
+  }
+  /**
+   * Reset the netchan state
+   */
+  reset() {
+    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.lastReceived = Date.now();
+    this.lastSent = Date.now();
+  }
+  /**
+   * Transmits a packet containing reliable and unreliable data
+   */
+  transmit(unreliableData) {
+    this.outgoingSequence++;
+    this.lastSent = Date.now();
+    const headerSize = _NetChan2.PACKET_HEADER;
+    const reliableSize = this.reliableLength > 0 ? this.reliableLength + 2 : 0;
+    let unreliableSize = unreliableData ? unreliableData.length : 0;
+    if (headerSize + reliableSize + unreliableSize > _NetChan2.MAX_MSGLEN) {
+      unreliableSize = _NetChan2.MAX_MSGLEN - headerSize - reliableSize;
+      if (unreliableSize < 0) unreliableSize = 0;
+    }
+    const buffer = new ArrayBuffer(headerSize + reliableSize + unreliableSize);
+    const view = new DataView(buffer);
+    const result = new Uint8Array(buffer);
+    let sequence = this.outgoingSequence;
+    if (this.reliableLength > 0) {
+      sequence |= 2147483648;
+      if ((this.outgoingReliableSequence & 1) !== 0) {
+        sequence |= 1073741824;
+      }
+    }
+    view.setUint32(0, sequence, true);
+    let ack = this.incomingSequence;
+    if ((this.incomingReliableSequence & 1) !== 0) {
+      ack |= 2147483648;
+    }
+    view.setUint32(4, ack, true);
+    view.setUint16(8, this.qport, true);
+    let offset = headerSize;
+    if (this.reliableLength > 0) {
+      view.setUint16(offset, this.reliableLength, true);
+      offset += 2;
+      const reliableBuffer = this.reliableMessage.getBuffer();
+      const reliableBytes = reliableBuffer.subarray(0, this.reliableLength);
+      result.set(reliableBytes, offset);
+      offset += this.reliableLength;
+    }
+    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) {
+    if (packet.length < _NetChan2.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;
+    }
+    const seqNumberClean = sequence & ~(2147483648 | 1073741824);
+    if ((seqNumberClean - this.incomingSequence | 0) <= 0) {
+      return null;
+    }
+    this.incomingSequence = seqNumberClean;
+    const ackNumber = ack & ~2147483648;
+    const ackReliable = (ack & 2147483648) !== 0;
+    if (ackNumber > this.incomingAcknowledged) {
+      this.incomingAcknowledged = ackNumber;
+    }
+    if (this.reliableLength > 0) {
+      const receivedAckBit = ackReliable ? 1 : 0;
+      const currentReliableBit = this.outgoingReliableSequence & 1;
+      if (receivedAckBit !== currentReliableBit) {
+        this.reliableLength = 0;
+        this.reliableMessage.reset();
+        this.outgoingReliableSequence ^= 1;
+      }
+    }
+    const hasReliableData = (sequence & 2147483648) !== 0;
+    const reliableSeqBit = (sequence & 1073741824) !== 0 ? 1 : 0;
+    let payloadOffset = _NetChan2.PACKET_HEADER;
+    let reliableData = null;
+    if (hasReliableData) {
+      if (payloadOffset + 2 > packet.byteLength) return null;
+      const reliableLen = view.getUint16(payloadOffset, true);
+      payloadOffset += 2;
+      const expectedBit = this.incomingReliableSequence & 1;
+      if (reliableSeqBit === expectedBit) {
+        this.incomingReliableSequence++;
+        if (payloadOffset + reliableLen > packet.byteLength) return null;
+        reliableData = packet.slice(payloadOffset, payloadOffset + reliableLen);
+      }
+      payloadOffset += reliableLen;
+    }
+    const unreliableData = packet.slice(payloadOffset);
+    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() {
+    return this.reliableLength === 0;
+  }
+  /**
+   * Writes a byte to the reliable message buffer
+   */
+  writeReliableByte(value) {
+    if (this.reliableLength + 1 > _NetChan2.MAX_MSGLEN - _NetChan2.HEADER_OVERHEAD) {
+      throw new Error("NetChan reliable buffer overflow");
+    }
+    this.reliableMessage.writeByte(value);
+    this.reliableLength++;
+  }
+  /**
+   * Writes a short to the reliable message buffer
+   */
+  writeReliableShort(value) {
+    if (this.reliableLength + 2 > _NetChan2.MAX_MSGLEN - _NetChan2.HEADER_OVERHEAD) {
+      throw new Error("NetChan reliable buffer overflow");
+    }
+    this.reliableMessage.writeShort(value);
+    this.reliableLength += 2;
+  }
+  /**
+   * Writes a long to the reliable message buffer
+   */
+  writeReliableLong(value) {
+    if (this.reliableLength + 4 > _NetChan2.MAX_MSGLEN - _NetChan2.HEADER_OVERHEAD) {
+      throw new Error("NetChan reliable buffer overflow");
+    }
+    this.reliableMessage.writeLong(value);
+    this.reliableLength += 4;
+  }
+  /**
+   * Writes a string to the reliable message buffer
+   */
+  writeReliableString(value) {
+    const len = value.length + 1;
+    if (this.reliableLength + len > _NetChan2.MAX_MSGLEN - _NetChan2.HEADER_OVERHEAD) {
+      throw new Error("NetChan reliable buffer overflow");
+    }
+    this.reliableMessage.writeString(value);
+    this.reliableLength += len;
+  }
+  /**
+   * Returns the current reliable data buffer
+   */
+  getReliableData() {
+    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) {
+    return currentTime - this.lastSent > 1e3;
+  }
+  /**
+   * Checks if the connection has timed out
+   */
+  isTimedOut(currentTime, timeoutMs = 3e4) {
+    return currentTime - this.lastReceived > timeoutMs;
+  }
+};
+_NetChan.MAX_MSGLEN = 1400;
+_NetChan.FRAGMENT_SIZE = 1024;
+_NetChan.PACKET_HEADER = 10;
+_NetChan.HEADER_OVERHEAD = _NetChan.PACKET_HEADER + 2;
 var AmmoType = /* @__PURE__ */ ((AmmoType2) => {
   AmmoType2[AmmoType2["Bullets"] = 0] = "Bullets";
   AmmoType2[AmmoType2["Shells"] = 1] = "Shells";