[Feat] Add positional data towards monsters

Denoder · Denoder · commit 5c715a357225 · 2025-11-05T18:06:45.000+02:00
diff --git a/.gitignore b/.gitignore
@@ -10,7 +10,7 @@
 /logs
 /logs_dps.json
 dist/logs/
-information_log.txt
+information_log.txt*
 
 # Build output
 /dist
diff --git a/algo/packet.ts b/algo/packet.ts
@@ -291,6 +291,23 @@ class PacketProcessor {
             } else if (isTargetMonster) {
                 this.#processEnemyAttrs(targetUuid.toNumber(), attrCollection.Attrs);
             }
+
+            for (const attr of attrCollection.Attrs) {
+                if ((attr.Id === 52 || attr.Id === 53) && attr.RawData) {
+                    try {
+                        const position = pb.Position.decode(attr.RawData);
+                        const x = position.X ?? 0;
+                        const y = position.Y ?? 0;
+                        const z = position.Z ?? 0;
+
+                        if (isTargetMonster) {
+                            this.userDataManager.enemyCache.position.set(targetUuid.toNumber(), { x, y, z });
+                        } else if (isTargetPlayer && targetUuid.toNumber() === this.userDataManager.localPlayerUid) {
+                            this.userDataManager.setLocalPlayerPosition({ x, y, z });
+                        }
+                    } catch (e) {}
+                }
+            }
         }
 
         const skillEffect = aoiSyncDelta.SkillEffects;
@@ -376,13 +393,12 @@ class PacketProcessor {
                     }
 
                     if (isDead) {
-                        const enemyUid = `E${targetUuid.toNumber()}`;
+                        const enemyUid = `${targetUuid.toNumber()}`;
                         const monsterId = this.userDataManager.enemyCache.monsterId.get(enemyUid);
                         if (monsterId && TRACKED_MONSTER_IDS.has(String(monsterId))) {
-                            // Only reset tracking if BPTimer submission is enabled
                             if (this.userDataManager.globalSettings.enableBPTimerSubmission !== false) {
                                 const line = this.userDataManager.getCurrentLineId();
-                                const bpTimer = initialize(this.logger);
+                                const bpTimer = initialize(this.logger, this.userDataManager.globalSettings);
                                 setTimeout(() => {
                                     bpTimer.resetMonster(monsterId, line);
                                     this.logger.debug(`[BPTimer] Reset tracking for monster ${monsterId} on line ${line} (isDead flag)`);
@@ -678,7 +694,8 @@ class PacketProcessor {
         for (const attr of attrs) {
             if (!attr.Id || !attr.RawData) continue;
             const reader = pbjs.Reader.create(attr.RawData);
-            this.logger.debug(`Found attrId ${attr.Id} for E${enemyUid} ${attr.RawData.toString('base64')}`);
+            const base64Data = attr.RawData.toString('base64');
+
             switch (attr.Id) {
                 case AttrType.AttrName:
                     const enemyName = reader.string();
@@ -704,7 +721,6 @@ class PacketProcessor {
                     this.userDataManager.enemyCache.lastSeen.set(enemyUid, Date.now());
                     break;
                 default:
-                    // this.logger.debug(`Found unknown attrId ${attr.Id} for E${enemyUid} ${attr.RawData.toString('base64')}`);
                     break;
             }
         }
@@ -713,7 +729,7 @@ class PacketProcessor {
     #reportBossHpThreshold(enemyUid: string, currentHp: number) {
         try {
             // Check if BPTimer submission is enabled
-            if (this.userDataManager.globalSettings.enableBPTimerSubmission === false) {
+            if (this.userDataManager.globalSettings?.enableBPTimerSubmission === false) {
                 return;
             }
 
@@ -730,7 +746,7 @@ class PacketProcessor {
 
             if (currentHp === 0 || currentHp <= maxHp * 0.001) {
                 const line = this.userDataManager.getCurrentLineId();
-                const bpTimer = initialize(this.logger);
+                const bpTimer = initialize(this.logger, this.userDataManager.globalSettings);
                 setTimeout(() => {
                     bpTimer.resetMonster(monsterId, line);
                     this.logger.debug(`[BPTimer] Reset tracking for monster ${monsterId} on line ${line} (HP reached 0)`);
@@ -742,7 +758,7 @@ class PacketProcessor {
 
             const line = this.userDataManager.getCurrentLineId();
 
-            const bpTimer = initialize(this.logger);
+            const bpTimer = initialize(this.logger, this.userDataManager.globalSettings);
             bpTimer.createHpReport(monsterId, hpPercentage, line).catch(err => {
                 this.logger.debug(`[BPTimer] Failed to report HP threshold: ${err.message}`);
             });
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "bpsr-meter",
-    "version": "0.3.4",
+    "version": "0.3.5",
     "description": "BPSR Meter",
     "author": "Denoder",
     "type": "module",
diff --git a/src/main/index.ts b/src/main/index.ts
@@ -361,7 +361,6 @@ function setupIpcHandlers() {
             Object.assign(currentSettings, settings);
             await fs.promises.writeFile(settingsPath, JSON.stringify(currentSettings, null, 4));
 
-            // Broadcast transparency changes to all windows
             if (settings.hasOwnProperty("disableTransparency")) {
                 Object.values(windows).forEach((window) => {
                     if (window && !window.isDestroyed()) {
@@ -370,7 +369,6 @@ function setupIpcHandlers() {
                 });
             }
 
-            // Broadcast heightStep changes to main window
             if (settings.hasOwnProperty("heightStep")) {
                 if (windows.main && !windows.main.isDestroyed()) {
                     windows.main.webContents.send("height-step-changed", settings.heightStep);
@@ -386,19 +384,16 @@ function setupIpcHandlers() {
             const logsDir = path.join(userDataPath, "logs");
             const logPath = path.join(logsDir, logId);
 
-            // Security check: ensure the path is within the logs directory
             if (!logPath.startsWith(logsDir)) {
                 return { success: false, error: "Invalid log path" };
             }
 
-            // Check if directory exists
             try {
                 await fs.promises.access(logPath);
             } catch {
                 return { success: false, error: "Log not found" };
             }
 
-            // Delete the directory recursively
             await fs.promises.rm(logPath, { recursive: true, force: true });
             logToFile(`Deleted history log: ${logId}`);
 
diff --git a/src/renderer/src/monsters/App.tsx b/src/renderer/src/monsters/App.tsx
@@ -5,22 +5,26 @@ import { useTranslations } from "../shared/hooks/useTranslations";
 import { useWindowControls, useSocket } from "../shared/hooks";
 import MonstersHeader from "./MonstersHeader";
 import SortDropdown from "./SortDropdown";
+import { TRACKED_MONSTER_IDS } from "../shared/constants";
 
 interface MonsterEntry {
     name?: string | null;
     hp?: number | null;
     max_hp?: number | null;
     monster_id?: number | null;
     last_seen?: number | null;
+    position?: { x: number; y: number; z: number } | null;
+    distance?: number | null;
 }
 
 export default function MonstersApp(): React.JSX.Element {
     const [monsters, setMonsters] = useState<Record<string, MonsterEntry>>({});
     const [isLoading, setIsLoading] = useState<boolean>(true);
     const [error, setError] = useState<string | null>(null);
-    const [sortKey, setSortKey] = useState<"id" | "name" | "hp">("hp");
-    const [sortDesc, setSortDesc] = useState<boolean>(true);
+    const [sortKey, setSortKey] = useState<"id" | "name" | "hp" | "distance">("distance");
+    const [sortDesc, setSortDesc] = useState<boolean>(false);
     const [zhNames, setZhNames] = useState<Record<number, string>>({});
+    const [bossOnlyMode, setBossOnlyMode] = useState<boolean>(false);
 
     const { scale, zoomIn, zoomOut, handleDragStart, handleClose, isDragging } = useWindowControls({
         baseWidth: 560,
@@ -149,7 +153,25 @@ export default function MonstersApp(): React.JSX.Element {
             ) : (
                 <div className="monsters-container">
                     <div className="flex justify-between items-center mb-2 gap-2">
-                        <div className="text-sm font-semibold">Monsters ({Object.keys(monsters).length})</div>
+                        <div className="flex items-center gap-2">
+                            <div className="text-sm font-semibold">
+                                Monsters ({
+                                    bossOnlyMode 
+                                        ? Object.values(monsters).filter(m => m.monster_id && TRACKED_MONSTER_IDS.has(String(m.monster_id))).length
+                                        : Object.keys(monsters).length
+                                })
+                            </div>
+                            <button 
+                                onClick={() => setBossOnlyMode((prev) => !prev)}
+                                className="text-xs px-2 py-1 rounded"
+                                style={{ 
+                                    background: bossOnlyMode ? "#3498db" : "rgba(255,255,255,0.1)",
+                                    color: bossOnlyMode ? "#fff" : "rgba(255,255,255,0.7)"
+                                }}
+                            >
+                                {bossOnlyMode ? "Bosses Only" : "All Monsters"}
+                            </button>
+                        </div>
                         <div className="flex items-center gap-2">
                             <label className="text-xs">Sort:</label>
                             <div className="min-w-[140px]">
@@ -162,16 +184,20 @@ export default function MonstersApp(): React.JSX.Element {
                     <table className="monsters-table w-full border-collapse">
                         <thead>
                             <tr>
-                                <th className="text-left p-1">ID</th>
                                 <th className="text-left p-1">Name</th>
                                 <th className="text-right p-1">HP</th>
                                 <th className="text-right p-1">Max HP</th>
                                 <th className="text-right p-1">HP %</th>
+                                <th className="text-right p-1 pl-5">Distance</th>
                             </tr>
                         </thead>
                         <tbody>
                             {Object.entries(monsters)
                                 .map(([id, m]) => ({ id, ...m }))
+                                .filter((m) => {
+                                    if (!bossOnlyMode) return true;
+                                    return m.monster_id && TRACKED_MONSTER_IDS.has(String(m.monster_id));
+                                })
                                 .sort((a, b) => {
                                     if (sortKey === "hp") {
                                         const ah = a.hp ?? -Infinity;
@@ -183,17 +209,21 @@ export default function MonstersApp(): React.JSX.Element {
                                         const bn = (b.name || "").toString();
                                         return sortDesc ? bn.localeCompare(an) : an.localeCompare(bn);
                                     }
-                                    // id
-                                    const ai = Number(a.id);
-                                    const bi = Number(b.id);
-                                    return sortDesc ? bi - ai : ai - bi;
+                                    if (sortKey === "distance") {
+                                        const ad = a.distance ?? Infinity;
+                                        const bd = b.distance ?? Infinity;
+                                        return sortDesc ? bd - ad : ad - bd;
+                                    }
+                                    return 0;
                                 })
                                 .map((m) => {
-                                    const displayName = `${t(`monsters.${m.monster_id}`, m?.name ?? "Unknown")} (${m.monster_id})`;
+                                    const displayName = `${t(`monsters.${m.monster_id}`, m?.name ?? "Unknown")}`;
                                     const pct = m.max_hp && m.hp ? Math.max(0, Math.min(1, (m.hp / m.max_hp))) : null;
+                                    const distanceText = m.distance !== null && m.distance !== undefined
+                                        ? `${m.distance.toFixed(1)}m`
+                                        : "-";
                                     return (
                                         <tr key={m.id} style={{ borderTop: "1px solid rgba(255,255,255,0.06)" }}>
-                                            <td className="p-2">{m.id}</td>
                                             <td className="p-2">{displayName}</td>
                                             <td className="p-2 text-right">{m?.hp ?? "-"}</td>
                                             <td className="p-2 text-right">{m?.max_hp ?? "-"}</td>
@@ -209,6 +239,7 @@ export default function MonstersApp(): React.JSX.Element {
                                                     </div>
                                                 )}
                                             </td>
+                                            <td className="p-2 text-right text-xs font-mono">{distanceText}</td>
                                         </tr>
                                     );
                                 })}
diff --git a/src/renderer/src/monsters/SortDropdown.tsx b/src/renderer/src/monsters/SortDropdown.tsx
@@ -8,7 +8,7 @@ interface Option {
 const OPTIONS: Option[] = [
     { value: "hp", label: "HP" },
     { value: "name", label: "Name" },
-    { value: "id", label: "ID" },
+    { value: "distance", label: "Distance" },
 ];
 
 export function SortDropdown({ value, onChange }: { value: string; onChange: (v: string) => void; }): React.JSX.Element {
diff --git a/src/renderer/src/shared/constants.ts b/src/renderer/src/shared/constants.ts
@@ -0,0 +1,27 @@
+// Boss monster IDs that are tracked for BPTimer
+export const TRACKED_MONSTER_IDS = new Set([
+    // Golden Juggernaut
+    '80006', '10032',
+    // Frost Ogre
+    '108', '10009', '20100', '20127', '80002', '2000129', '2000140', '2004172', '3000006', '3000019',
+    // Inferno Ogre
+    '80004', '10018',
+    // Phantom Arachnocrab
+    '80008', '10069',
+    // Brigand Leader
+    '10056',
+    // Venobzzar Incubator
+    '80009', '10077', '3000025',
+    // Muku Chief
+    '80007', '10059', '3000022',
+    // Iron Fang
+    '8611', '80010', '10081', '3000024',
+    // Storm Goblin King
+    '80001', '10007', '61219', '61220', '61221',
+    // Tempest Ogre
+    '4301', '10010', '20024', '20072', '20092', '80003', '2000131', '2000137', '3000001', '3000020', '530354',
+    // Celestial Flier
+    '8614', '80011', '10082', '3000023',
+    // Earth Ogre
+    '80005', '10025',
+]);
diff --git a/src/server/dataManager.ts b/src/server/dataManager.ts
@@ -495,6 +495,13 @@ interface EnemyCache {
     maxHp: Map<string, number>;
     monsterId: Map<string, number>;
     lastSeen: Map<string, number>;
+    position: Map<string, { x: number; y: number; z: number; }>;
+}
+
+interface PlayerPosition {
+    x: number;
+    y: number;
+    z: number;
 }
 
 interface SceneInfo {
@@ -515,6 +522,7 @@ export class UserDataManager {
     logDirExist: Set<string>;
     enemyCache: EnemyCache;
     localPlayerUid: number | null;
+    localPlayerPosition: PlayerPosition | null;
     lastLogTime?: number;
     sceneData: Map<string, SceneInfo>;
 
@@ -535,9 +543,11 @@ export class UserDataManager {
             maxHp: new Map(),
             monsterId: new Map(),
             lastSeen: new Map(),
+            position: new Map(),
         };
         this.sceneData = new Map();
         this.localPlayerUid = null;
+        this.localPlayerPosition = null;
     }
 
     setLocalPlayerUid(uid: number): void {
@@ -546,6 +556,20 @@ export class UserDataManager {
         }
     }
 
+    setLocalPlayerPosition(position: { x: number; y: number; z: number }): void {
+        this.localPlayerPosition = position;
+    }
+
+    calculateDistance(enemyPosition: { x: number; y: number; z: number }): number | null {
+        if (!this.localPlayerPosition) return null;
+
+        const dx = enemyPosition.x - this.localPlayerPosition.x;
+        const dy = enemyPosition.y - this.localPlayerPosition.y;
+        const dz = enemyPosition.z - this.localPlayerPosition.z;
+
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+
     async initialize(): Promise<void> { }
 
     getUser(uid: number): UserData {
@@ -774,7 +798,16 @@ export class UserDataManager {
         ]);
         const now = Date.now();
         const STALE_MS = 4500;
+        // Exclude companions
+        const EXCLUDED_MONSTER_IDS = new Set([3100000, 3100001, 3100002]);
+
         enemyIds.forEach((id) => {
+            const monsterId = this.enemyCache.monsterId.get(id);
+
+            if (monsterId && EXCLUDED_MONSTER_IDS.has(monsterId)) {
+                return;
+            }
+
             const last = this.enemyCache.lastSeen.get(id) || 0;
             let hpVal = this.enemyCache.hp.get(id);
 
@@ -786,12 +819,17 @@ export class UserDataManager {
                 }
             }
 
+            const position = this.enemyCache.position.get(id);
+            const distance = position ? this.calculateDistance(position) : null;
+
             result[id] = {
                 name: this.enemyCache.name.get(id),
                 hp: hpVal,
                 max_hp: this.enemyCache.maxHp.get(id),
                 monster_id: this.enemyCache.monsterId.get(id) ?? null,
                 last_seen: this.enemyCache.lastSeen.get(id) ?? null,
+                position: position ? { x: position.x, y: position.y, z: position.z } : null,
+                distance: distance,
             };
         });
         return result;
@@ -803,12 +841,13 @@ export class UserDataManager {
         this.enemyCache.maxHp.clear();
         this.enemyCache.monsterId.clear();
         this.enemyCache.lastSeen.clear();
+        this.enemyCache.position.clear();
     }
 
     async clearAll(isLineSwitch: boolean = false): Promise<void> {
-        const shouldSave = this.users.size > 0 && 
-                          this.globalSettings.enableHistorySave &&
-                          (!isLineSwitch || this.globalSettings.saveOnLineSwitch !== false);
+        const shouldSave = this.users.size > 0 &&
+            this.globalSettings.enableHistorySave &&
+            (!isLineSwitch || this.globalSettings.saveOnLineSwitch !== false);
 
         if (shouldSave) {
             await this.saveAllUserData();
diff --git a/src/utils/bpTimer.ts b/src/utils/bpTimer.ts

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "bpsr-meter",`
`3`		`- "version": "0.3.4",`
	`3`	`+ "version": "0.3.5",`
`4`	`4`	`"description": "BPSR Meter",`
`5`	`5`	`"author": "Denoder",`
`6`	`6`	`"type": "module",`