Merge pull request #41 from KotRikD/fix-graph-background

Graph fixes and various adjustments

Author: KotRikD

packages/tosu/src/entities/BeatmapPpData/index.ts

@@ -122,10 +122,7 @@ export class BeatmapPPData extends AbstractEntity {
         wLogger.debug(
             `maxPP -> ${this.currAttributes.maxThisPlayPP} pp -> ${pp} stars -> ${stars}`
         );
-        const maxThisPlayPP =
-            pp > this.currAttributes.maxThisPlayPP
-                ? pp
-                : this.currAttributes.maxThisPlayPP;
+        const maxThisPlayPP = Math.max(pp, this.currAttributes.maxThisPlayPP);
 
         this.currAttributes = {
             ...this.currAttributes,
@@ -143,9 +140,9 @@ export class BeatmapPPData extends AbstractEntity {
     }
 
     updateBPM(commonBPM: number, minBPM: number, maxBPM: number) {
-        this.commonBPM = commonBPM;
-        this.minBPM = minBPM;
-        this.maxBPM = maxBPM;
+        this.commonBPM = Math.round(commonBPM);
+        this.minBPM = Math.round(minBPM);
+        this.maxBPM = Math.round(maxBPM);
     }
 
     updateTimings(firstObj: number, full: number) {
@@ -227,25 +224,28 @@ export class BeatmapPPData extends AbstractEntity {
 
         let oldStrains: number[] = [];
 
-        const offset: number = strains.sectionLength;
-
         let lazerBeatmap: ParsedBeatmap;
-
         try {
             const decoder = new BeatmapDecoder();
 
             lazerBeatmap = await decoder.decodeFromPath(mapPath, {
                 parseColours: false,
                 parseDifficulty: false,
                 parseEditor: false,
-                parseEvents: false,
+                parseEvents: true,
                 parseGeneral: false,
                 parseMetadata: false
             });
 
             const { bpm, bpmMin, bpmMax } = lazerBeatmap;
 
-            this.updateBPM(bpm, bpmMin, bpmMax);
+            menuData.BackgroundFilename =
+                lazerBeatmap.events.backgroundPath || '';
+            this.updateBPM(
+                bpm * mapAttributes.clockRate,
+                bpmMin * mapAttributes.clockRate,
+                bpmMax * mapAttributes.clockRate
+            );
 
             const firstObj = Math.round(
                 lazerBeatmap.hitObjects.at(0)?.startTime ?? 0
@@ -261,28 +261,45 @@ export class BeatmapPPData extends AbstractEntity {
             return;
         }
 
+        const offset = strains.sectionLength;
+        const firstObj = this.timings.firstObj / mapAttributes.clockRate;
+        const lastObj = this.timings.full / mapAttributes.clockRate;
+        const graphLength = lastObj - firstObj;
+        const mp3Length = menuData.MP3Length / mapAttributes.clockRate;
+
         const beatmap_parse_time = performance.now();
         wLogger.debug(
             `(updateMapMetadata) Spend:${(
                 beatmap_parse_time - calculation_time
             ).toFixed(2)}ms on parsing beatmap`
         );
 
-        const LEFT_OFFSET = Math.floor(this.timings.firstObj / offset);
+        const LEFT_OFFSET = Math.floor(firstObj / offset);
         const RIGHT_OFFSET =
-            menuData.MP3Length > this.timings.full
-                ? Math.ceil((menuData.MP3Length - this.timings.full) / offset)
+            mp3Length >= lastObj
+                ? Math.ceil((mp3Length - lastObj) / offset)
                 : 0;
 
         const updateWithOffset = (name: string, values: number[]) => {
             let data: number[] = [];
+            let approximateTime =
+                LEFT_OFFSET * offset +
+                values.length * offset +
+                RIGHT_OFFSET * offset;
 
             if (Number.isFinite(LEFT_OFFSET) && LEFT_OFFSET > 0)
                 data = Array(LEFT_OFFSET).fill(-100);
             data = data.concat(values);
             if (Number.isFinite(RIGHT_OFFSET) && RIGHT_OFFSET > 0)
                 data = data.concat(Array(RIGHT_OFFSET).fill(-100));
 
+            const missingPoints =
+                mp3Length >= approximateTime
+                    ? Math.ceil((mp3Length - approximateTime) / offset)
+                    : 0;
+            if (missingPoints > 0)
+                data = data.concat(Array(missingPoints).fill(-100));
+
             resultStrains.series.push({ name, data });
         };
 
@@ -335,13 +352,13 @@ export class BeatmapPPData extends AbstractEntity {
             resultStrains.xaxis.push(i * offset);
         }
 
-        const amount = Math.ceil(this.timings.full / offset);
+        const amount = Math.ceil(graphLength / offset);
         for (let i = 0; i < amount; i++) {
-            resultStrains.xaxis.push(this.timings.firstObj + i * offset);
+            resultStrains.xaxis.push(firstObj + i * offset);
         }
 
         for (let i = 0; i < RIGHT_OFFSET; i++) {
-            resultStrains.xaxis.push(this.timings.full + i * offset);
+            resultStrains.xaxis.push(lastObj + i * offset);
         }
 
         const end_time = performance.now();

packages/tosu/src/entities/MenuData/index.ts

@@ -94,9 +94,9 @@ export class MenuData extends AbstractEntity {
             process.readInt(beatmapAddr + 0x64)
         );
         // //  [[Beatmap] + 0x68]
-        this.BackgroundFilename = process.readSharpString(
-            process.readInt(beatmapAddr + 0x68)
-        );
+        // this.BackgroundFilename = process.readSharpString(
+        //     process.readInt(beatmapAddr + 0x68)
+        // );
         //  [[Beatmap] + 0x78]
         this.Folder = process.readSharpString(
             process.readInt(beatmapAddr + 0x78)

packages/tosu/src/objects/instanceManager/instanceManager.ts

@@ -1,4 +1,4 @@
-import { sleep } from '@tosu/common';
+import { sleep, wLogger } from '@tosu/common';
 import { process_by_name } from '@tosu/find-process';
 
 import { OsuInstance } from './osuInstance';
@@ -21,10 +21,9 @@ export class InstanceManager {
         delete this.osuInstances[pid];
     }
 
-    async runWatcher() {
-        while (true) {
+    private handleProcesses() {
+        try {
             const osuProcesses = process_by_name('osu!.exe');
-
             for (const process of osuProcesses || []) {
                 if (process.pid in this.osuInstances) {
                     // dont deploy not needed instances
@@ -48,6 +47,14 @@ export class InstanceManager {
                 this.osuInstances[process.pid] = osuInstance;
                 osuInstance.start();
             }
+        } catch (error) {
+            wLogger.error(error);
+        }
+    }
+
+    async runWatcher() {
+        while (true) {
+            this.handleProcesses();
 
             await sleep(5000);
         }

packages/tosu/src/objects/instanceManager/osuInstance.ts

@@ -264,6 +264,7 @@ export class OsuInstance {
                         // Reset gameplay data on retry
                         if (prevTime > allTimesData.PlayTime) {
                             gamePlayData.init(true);
+                            beatmapPpData.resetCurrentAttributes();
                         }
 
                         prevTime = allTimesData.PlayTime;