add passive swordmasters timing probe

tools/swordmasters_timing_probe.js

@@ -0,0 +1,366 @@
+/*
+  Passive SwordMasters.io timing probe.
+
+  It reads the local Colyseus room state and incoming damage messages only.
+  No game actions or network messages are sent.
+*/
+(() => {
+  "use strict";
+
+  const VERSION = "0.1.0";
+  const DAMAGE_MESSAGE = "Server:EnemyController:getDamage";
+  const POLL_MS = 10;
+
+  if (window.SM_TIMING_PROBE && typeof window.SM_TIMING_PROBE.stop === "function") {
+    window.SM_TIMING_PROBE.stop({ quiet: true });
+  }
+
+  const state = {
+    startedAt: new Date().toISOString(),
+    room: null,
+    roomSource: "",
+    enemies: new Map(),
+    deaths: [],
+    respawns: [],
+    damagePackets: [],
+    hookErrors: [],
+    pollTimer: 0,
+    dispatchWrapper: null,
+    originalDispatchMessage: null,
+  };
+
+  function finite(value) {
+    const number = Number(value);
+    return Number.isFinite(number) ? number : null;
+  }
+
+  function median(values) {
+    const sorted = values.filter(Number.isFinite).slice().sort((a, b) => a - b);
+    if (!sorted.length) return null;
+    const middle = Math.floor(sorted.length / 2);
+    return sorted.length % 2
+      ? sorted[middle]
+      : (sorted[middle - 1] + sorted[middle]) / 2;
+  }
+
+  function mapEntries(mapLike) {
+    if (!mapLike) return [];
+    if (typeof mapLike.entries === "function") return Array.from(mapLike.entries());
+    const rows = [];
+    if (typeof mapLike.forEach === "function") {
+      mapLike.forEach((value, key) => rows.push([key, value]));
+      return rows;
+    }
+    return Object.entries(mapLike);
+  }
+
+  function readMapValue(mapLike, key) {
+    if (!mapLike) return null;
+    if (typeof mapLike.get === "function") {
+      const value = mapLike.get(key);
+      if (value) return value;
+    }
+    if (mapLike[key]) return mapLike[key];
+    for (const [itemKey, value] of mapEntries(mapLike)) {
+      if (String(itemKey) === String(key)) return value;
+    }
+    return null;
+  }
+
+  function readField(value, names) {
+    if (!value) return null;
+    for (const name of names) {
+      try {
+        if (value[name] != null) return value[name];
+      } catch (_) {
+        // Try the next known schema field name.
+      }
+    }
+    try {
+      const json = typeof value.toJSON === "function" ? value.toJSON() : null;
+      if (json) {
+        for (const name of names) {
+          if (json[name] != null) return json[name];
+        }
+      }
+    } catch (_) {
+      // Detached Schema objects can throw while serializing.
+    }
+    return null;
+  }
+
+  function enemySnapshot(enemyId, enemy) {
+    return {
+      enemyId: String(enemyId),
+      enemyType: finite(readField(enemy, ["type", "enemyType", "enemyTypeId", "enemyTypeIndex"])),
+      hp: finite(readField(enemy, ["health", "hp", "currentHp", "currentHP"])),
+      maxHp: finite(readField(enemy, ["maxHealth", "maxHp", "maxHP"])),
+    };
+  }
+
+  function registerRoom(room, source) {
+    if (!room || !room.state) return;
+    state.room = room;
+    state.roomSource = source;
+  }
+
+  function findRoom() {
+    const candidates = [
+      () => window.pc && window.pc.app && window.pc.app.networkManager && window.pc.app.networkManager.room,
+      () => window.pc && window.pc.Application && window.pc.Application.getApplication &&
+        window.pc.Application.getApplication().networkManager &&
+        window.pc.Application.getApplication().networkManager.room,
+      () => window.app && window.app.networkManager && window.app.networkManager.room,
+    ];
+    for (const build of candidates) {
+      try {
+        const room = build();
+        if (room && room.state) return room;
+      } catch (_) {
+        // Keep trying fallback paths.
+      }
+    }
+    for (const key of Object.keys(window)) {
+      let value;
+      try {
+        value = window[key];
+      } catch (_) {
+        continue;
+      }
+      if (value && value.room && value.room.state) return value.room;
+      if (value && value.networkManager && value.networkManager.room && value.networkManager.room.state) {
+        return value.networkManager.room;
+      }
+    }
+    return null;
+  }
+
+  function markDeath(tracker, atMs, reason) {
+    if (!tracker || tracker.deathAtMs != null) return;
+    tracker.deathAtMs = atMs;
+    tracker.deathReason = reason;
+    state.deaths.push({
+      enemyId: tracker.enemyId,
+      enemyType: tracker.enemyType,
+      atMs,
+      reason,
+    });
+  }
+
+  function markRespawn(tracker, snapshot, atMs, reason) {
+    if (!tracker || tracker.deathAtMs == null) return;
+    const respawnMs = atMs - tracker.deathAtMs;
+    if (respawnMs >= 100) {
+      state.respawns.push({
+        enemyId: tracker.enemyId,
+        enemyType: snapshot.enemyType == null ? tracker.enemyType : snapshot.enemyType,
+        respawnMs,
+        deathAtMs: tracker.deathAtMs,
+        respawnAtMs: atMs,
+        deathReason: tracker.deathReason,
+        respawnReason: reason,
+      });
+    }
+    tracker.deathAtMs = null;
+    tracker.deathReason = "";
+  }
+
+  function observeDamage(room, message) {
+    registerRoom(room, "colyseus-dispatch");
+    const atMs = Date.now();
+    const enemyId = String(message && message.enemyId);
+    const tracker = state.enemies.get(enemyId);
+    const damageAmount = finite(message && message.damageAmount);
+    const damagers = Array.isArray(message && message.damagers)
+      ? message.damagers.length
+      : Array.from((message && message.damagers) || []).length;
+
+    state.damagePackets.push({
+      atMs,
+      enemyId,
+      enemyType: tracker ? tracker.enemyType : null,
+      damageAmount,
+      damagers,
+    });
+
+    if (tracker && tracker.hp != null && damageAmount != null && damageAmount >= tracker.hp) {
+      markDeath(tracker, atMs, "lethal-damage-packet");
+    }
+  }
+
+  function pollRoomState() {
+    if (!state.room) registerRoom(findRoom(), "window-scan");
+    const enemies = state.room && state.room.state && state.room.state.enemies;
+    if (!enemies) return;
+
+    const atMs = Date.now();
+    const visible = new Set();
+    for (const [enemyId, enemy] of mapEntries(enemies)) {
+      const snapshot = enemySnapshot(enemyId, enemy);
+      visible.add(snapshot.enemyId);
+      let tracker = state.enemies.get(snapshot.enemyId);
+      if (!tracker) {
+        tracker = {
+          ...snapshot,
+          present: true,
+          deathAtMs: null,
+          deathReason: "",
+        };
+        state.enemies.set(snapshot.enemyId, tracker);
+        continue;
+      }
+
+      const wasPresent = tracker.present;
+      const previousHp = tracker.hp;
+      if (previousHp != null && previousHp > 0 && snapshot.hp != null && snapshot.hp <= 0) {
+        markDeath(tracker, atMs, "hp-zero");
+      }
+      if (
+        snapshot.hp != null &&
+        snapshot.hp > 0 &&
+        (
+          !wasPresent ||
+          (previousHp != null && snapshot.hp > previousHp) ||
+          (previousHp != null && previousHp <= 0)
+        )
+      ) {
+        markRespawn(tracker, snapshot, atMs, !wasPresent ? "enemy-readded" : "hp-reset");
+      }
+
+      Object.assign(tracker, snapshot, { present: true });
+    }
+
+    for (const tracker of state.enemies.values()) {
+      if (tracker.present && !visible.has(tracker.enemyId)) {
+        tracker.present = false;
+        markDeath(tracker, atMs, "enemy-removed");
+      }
+    }
+  }
+
+  function inventorySummary() {
+    const room = state.room;
+    const inventory = room && room.state && readMapValue(room.state.playerInventories, room.sessionId);
+    const attackSpeed = finite(readField(inventory, ["attackSpeed"]));
+    return {
+      sessionId: room && room.sessionId || "",
+      attackSpeed,
+      attackIntervalMs: attackSpeed && attackSpeed > 0 ? 1000 / attackSpeed : null,
+    };
+  }
+
+  function packetRows() {
+    const byEnemy = new Map();
+    for (const packet of state.damagePackets) {
+      const key = `${packet.enemyType}:${packet.enemyId}`;
+      if (!byEnemy.has(key)) byEnemy.set(key, []);
+      byEnemy.get(key).push(packet);
+    }
+    const byType = new Map();
+    for (const packets of byEnemy.values()) {
+      packets.sort((a, b) => a.atMs - b.atMs);
+      for (let index = 1; index < packets.length; index += 1) {
+        const interval = packets[index].atMs - packets[index - 1].atMs;
+        if (interval <= 0 || interval > 900) continue;
+        const type = packets[index].enemyType;
+        if (!byType.has(type)) byType.set(type, []);
+        byType.get(type).push(interval);
+      }
+    }
+    return Array.from(byType, ([enemyType, intervals]) => ({
+      enemyType,
+      shortPacketIntervals: intervals.length,
+      shortPacketIntervalMedianMs: median(intervals),
+    })).sort((a, b) => Number(a.enemyType) - Number(b.enemyType));
+  }
+
+  function respawnRows() {
+    const byType = new Map();
+    for (const row of state.respawns) {
+      if (!byType.has(row.enemyType)) byType.set(row.enemyType, []);
+      byType.get(row.enemyType).push(row.respawnMs);
+    }
+    return Array.from(byType, ([enemyType, values]) => ({
+      enemyType,
+      respawns: values.length,
+      respawnMedianMs: median(values),
+      respawnMinMs: Math.min(...values),
+      respawnMaxMs: Math.max(...values),
+      likelyWholeSeconds: Math.round(median(values) / 1000),
+    })).sort((a, b) => Number(a.enemyType) - Number(b.enemyType));
+  }
+
+  function summary() {
+    pollRoomState();
+    const result = {
+      version: VERSION,
+      startedAt: state.startedAt,
+      roomFound: !!state.room,
+      roomSource: state.roomSource,
+      inventory: inventorySummary(),
+      enemiesTracked: state.enemies.size,
+      damagePackets: state.damagePackets.length,
+      deaths: state.deaths.length,
+      respawns: state.respawns.length,
+      attackValidation: packetRows(),
+      respawnTimings: respawnRows(),
+      recentRespawns: state.respawns.slice(-12),
+      hookErrors: state.hookErrors.slice(),
+    };
+    console.log("Inventory attack speed is the exact client cooldown input. Respawn rows use passive room-state reset timings.");
+    console.table(result.attackValidation);
+    console.table(result.respawnTimings);
+    console.table(result.recentRespawns);
+    return result;
+  }
+
+  function reset() {
+    state.enemies.clear();
+    state.deaths.length = 0;
+    state.respawns.length = 0;
+    state.damagePackets.length = 0;
+    pollRoomState();
+    console.log("SM timing probe reset.");
+  }
+
+  function stop(options = {}) {
+    if (state.pollTimer) window.clearInterval(state.pollTimer);
+    state.pollTimer = 0;
+    const roomProto = window.Colyseus && window.Colyseus.Room && window.Colyseus.Room.prototype;
+    if (roomProto && roomProto.dispatchMessage === state.dispatchWrapper && state.originalDispatchMessage) {
+      roomProto.dispatchMessage = state.originalDispatchMessage;
+    }
+    if (!options.quiet) console.log("SM timing probe stopped.");
+  }
+
+  function install() {
+    const roomProto = window.Colyseus && window.Colyseus.Room && window.Colyseus.Room.prototype;
+    if (roomProto && typeof roomProto.dispatchMessage === "function") {
+      state.originalDispatchMessage = roomProto.dispatchMessage;
+      state.dispatchWrapper = function timingProbeDispatchMessage(type, message) {
+        try {
+          registerRoom(this, "colyseus-dispatch");
+          if (String(type) === DAMAGE_MESSAGE) observeDamage(this, message);
+        } catch (error) {
+          state.hookErrors.push(String(error && error.message || error));
+        }
+        return state.originalDispatchMessage.apply(this, arguments);
+      };
+      roomProto.dispatchMessage = state.dispatchWrapper;
+    }
+    registerRoom(findRoom(), "window-scan");
+    state.pollTimer = window.setInterval(pollRoomState, POLL_MS);
+    pollRoomState();
+  }
+
+  window.SM_TIMING_PROBE = {
+    version: VERSION,
+    summary,
+    reset,
+    stop,
+    state,
+  };
+
+  install();
+  console.log("SM timing probe running. Stay on one mob for several kills, then run SM_TIMING_PROBE.summary().");
+})();