tosuapp · cyperdark · Jan 23, 2025 · Jan 21, 2025 · Jan 21, 2025 · Jan 21, 2025
diff --git a/packages/common/utils/downloader.ts b/packages/common/utils/downloader.ts
@@ -18,9 +18,7 @@ export const updateProgressBar = (
     const progressBar = '█'.repeat(filledWidth) + '░'.repeat(emptyWidth);
 
     process.stdout.write(
-        `${coloredText} ${title}: [${progressBar}] ${(progress * 100).toFixed(
-            2
-        )}%${message}\r`
+        `${coloredText} ${title}: [${progressBar}] ${(progress * 100).toFixed(2)}%${message}\r`
     );
 
     if (progress === 1) {

diff --git a/packages/server/index.ts b/packages/server/index.ts
@@ -121,7 +121,6 @@ export class Server {
             }
 
             wLogger.warn('[request]', 'Unallowed request', req.url, {
-                address: req.socket.remoteAddress,
                 origin: req.headers.origin,
                 referer: req.headers.referer
             });

diff --git a/packages/server/router/index.ts b/packages/server/router/index.ts
@@ -436,6 +436,24 @@ export default function buildBaseApi(server: Server) {
         );
     });
 
+    server.app.route('/favicon.ico', 'GET', (req, res) => {
+        fs.readFile(path.join(pkgAssetsPath, 'favicon.ico'), (err, content) => {
+            if (err) {
+                wLogger.debug(`/${'favicon.ico'}`, err);
+                res.writeHead(404, { 'Content-Type': 'text/html' });
+
+                res.end('<html>page not found</html>');
+                return;
+            }
+
+            res.writeHead(200, {
+                'Content-Type': 'image/vnd.microsoft.icon; charset=utf-8'
+            });
+
+            res.end(content);
+        });
+    });
+
     server.app.route(/.*/, 'GET', (req, res) => {
         const url = req.pathname || '/';
         const staticPath = getStaticPath();

diff --git a/packages/server/scripts/beatmapFile.ts b/packages/server/scripts/beatmapFile.ts
@@ -1,17 +1,15 @@
-import { ServerResponse } from 'http';
+import fs from 'fs';
+import type { ServerResponse } from 'http';
 import path from 'path';
 
-import { directoryWalker } from '../utils/directories';
-import { ExtendedIncomingMessage } from '../utils/http';
-import { sendJson } from '../utils/index';
+import type { ExtendedIncomingMessage } from '../utils/http';
+import { getContentType, sendJson } from '../utils/index';
 
 export function beatmapFileShortcut(
     req: ExtendedIncomingMessage,
     res: ServerResponse,
     beatmapFileType: 'audio' | 'background' | 'file'
 ) {
-    const url = req.pathname || '/';
-
     const osuInstance: any = req.instanceManager.getInstance(
         req.instanceManager.focusedClient
     );
@@ -40,10 +38,36 @@ export function beatmapFileShortcut(
         });
     }
 
-    directoryWalker({
-        res,
-        baseUrl: url,
-        pathname: fileName || '',
-        folderPath: folder
+    const filePath = path.join(folder, fileName);
+    const fileStat = fs.statSync(filePath);
+
+    if (req.headers.range) {
+        const range = req.headers.range.replace('bytes=', '').split('-');
+        const start = parseInt(range[0]);
+        const end = range[1] ? parseInt(range[1]) : fileStat.size - 1;
+
+        if (start >= fileStat.size || end >= fileStat.size) {
+            res.writeHead(416, {
+                'Content-Range': `bytes */${fileStat.size}`
+            });
+            return res.end();
+        }
+
+        res.writeHead(206, {
+            'Accept-Ranges': 'bytes',
+            'Content-Type': getContentType(fileName),
+            'Content-Range': `bytes ${start}-${end}/${fileStat.size}`,
+            'Content-Length': end - start + 1
+        });
+
+        fs.createReadStream(filePath, { start, end }).pipe(res);
+        return;
+    }
+
+    res.writeHead(200, {
+        'Content-Type': getContentType(fileName),
+        'Content-Length': fileStat.size
     });
+
+    fs.createReadStream(filePath).pipe(res);
 }
diff --git a/packages/server/utils/counters.ts b/packages/server/utils/counters.ts
@@ -712,7 +712,7 @@ export function buildSettings(res: http.ServerResponse) {
         .replace('{NAME}', 'ALLOWED_IPS')
         .replace(
             '{DESCRIPTION}',
-            `Specify IP's which allowed to change and access tosu API's`
+            `IP's or domain names, which allowed to change and access tosu API's.<br /><br />- Supports wildcard syntax: 192.*.60.*<br />- Compares against values printed out in «Unallowed request» message in console`
         )
         .replace(
             '{INPUT}',

diff --git a/packages/server/utils/directories.ts b/packages/server/utils/directories.ts
@@ -120,9 +120,7 @@ export function readDirectory(
         const html = folders.map((r) => {
             const slashAtTheEnd = getContentType(r) === '' ? '/' : '';
 
-            return `<li><a href="${
-                url === '/' ? '' : url
-            }${encodeURIComponent(r)}${slashAtTheEnd}">${r}</a></li>`;
+            return `<li><a href="${url === '/' ? '' : url}${encodeURIComponent(r)}${slashAtTheEnd}">${r}</a></li>`;
         });
 
         return callback(

diff --git a/packages/server/utils/index.ts b/packages/server/utils/index.ts
@@ -116,12 +116,29 @@ function isAllowedIP(url: string | undefined) {
 
     const allowedIPs = config.allowedIPs.split(',');
     try {
-        const parseURL = new URL(url);
-        return allowedIPs.some(
-            (r) =>
-                r.toLowerCase().trim() ===
-                parseURL.hostname.toLowerCase().trim()
-        );
+        const hostname = new URL(url).hostname.toLowerCase().trim();
+        return allowedIPs.some((pattern) => {
+            // compare IP's length and match wildcard like comparision
+            if (pattern.includes('*') && pattern.includes('.')) {
+                const patternLength = pattern.match(/\./g)?.length || 0;
+                const hostnameLength = hostname.match(/\./g)?.length || 0;
+
+                if (patternLength !== 3 || hostnameLength !== 3) return false;
+
+                const patternParts = pattern.split('.');
+                const hostnameParts = hostname.split('.');
+
+                const matches = hostnameParts.filter((r, index) => {
+                    if (patternParts[index] === '*') return true;
+
+                    return patternParts[index] === r;
+                });
+
+                return matches.length === 4;
+            }
+
+            return pattern.toLowerCase().trim() === hostname;
+        });
     } catch (error) {
         return allowedIPs.some(
             (r) => r.toLowerCase().trim() === url.toLowerCase().trim()

diff --git a/packages/tosu/src/api/types/v2.ts b/packages/tosu/src/api/types/v2.ts
@@ -117,6 +117,8 @@ export interface Profile {
 }
 
 export interface Beatmap {
+    isKiai: boolean;
+    isBreak: boolean;
     isConvert: boolean;
     time: BeatmapTime;
     status: NumberName;

diff --git a/packages/tosu/src/api/utils/buildResult.ts b/packages/tosu/src/api/utils/buildResult.ts
@@ -230,6 +230,7 @@ export const buildResult = (instanceManager: InstanceManager): ApiAnswer => {
             name: resultScreen.playerName,
             score: resultScreen.score,
             accuracy: calculateAccuracy({
+                isRound: true,
                 hits: resultScreenHits,
                 mode: gameplay.mode
             }),

diff --git a/packages/tosu/src/api/utils/buildResultSC.ts b/packages/tosu/src/api/utils/buildResultSC.ts
@@ -123,7 +123,11 @@ export const buildResult = (instanceManager: InstanceManager): ApiAnswer => {
             acc[v] = value <= 0 ? 0 : value;
             return acc;
         }, {}),
-        mapBreaks: beatmapPP.breaks,
+        mapBreaks: beatmapPP.breaks.map((r) => ({
+            startTime: r.start,
+            endTime: r.end,
+            hasEffect: r.hasEffect
+        })),
         mapKiaiPoints: [], // TODO: add
         mapPosition: formatMilliseconds(global.playTime), // convert to osu format
         mapTimingPoints: beatmapPP.timingPoints.map((r) => ({

diff --git a/packages/tosu/src/api/utils/buildResultV2.ts b/packages/tosu/src/api/utils/buildResultV2.ts
@@ -32,7 +32,8 @@ import { CalculateMods } from '@/utils/osuMods.types';
 
 const convertMemoryPlayerToResult = (
     memoryPlayer: MemoryLeaderboardPlayer,
-    gameMode: any
+    gameMode: any,
+    client: ClientType
 ): Leaderboard => {
     const hits = {
         300: memoryPlayer.h300,
@@ -53,7 +54,7 @@ const convertMemoryPlayerToResult = (
         name: memoryPlayer.name,
 
         score: memoryPlayer.score,
-        accuracy: calculateAccuracy({ hits, mode: gameMode }),
+        accuracy: calculateAccuracy({ isRound: true, hits, mode: gameMode }),
 
         hits,
 
@@ -69,6 +70,7 @@ const convertMemoryPlayerToResult = (
             rate: memoryPlayer.mods.rate
         },
         rank: calculateGrade({
+            isLazer: client === ClientType.lazer,
             mods: memoryPlayer.mods.number,
             mode: gameMode,
             hits
@@ -228,6 +230,8 @@ export const buildResult = (instanceManager: InstanceManager): ApiAnswer => {
             backgroundColour: user.backgroundColour?.toString(16)
         },
         beatmap: {
+            isKiai: beatmapPP.isKiai,
+            isBreak: beatmapPP.isBreak,
             isConvert:
                 beatmapPP.mode === 0 ? beatmapPP.mode !== currentMode : false,
             time: {
@@ -263,7 +267,11 @@ export const buildResult = (instanceManager: InstanceManager): ApiAnswer => {
         },
         play: buildPlay(gameplay, beatmapPP, currentMods),
         leaderboard: gameplay.leaderboardScores.map((slot) =>
-            convertMemoryPlayerToResult(slot, Rulesets[gameplay.mode])
+            convertMemoryPlayerToResult(
+                slot,
+                Rulesets[gameplay.mode],
+                osuInstance.client
+            )
         ),
         performance: {
             accuracy: beatmapPP.ppAcc,

diff --git a/packages/tosu/src/instances/lazerInstance.ts b/packages/tosu/src/instances/lazerInstance.ts
@@ -108,7 +108,7 @@ export class LazerInstance extends AbstractInstance {
                     this.previousMP3Length = menu.mp3Length;
                 }
 
-                beatmapPP.updateRealTimeBPM(global.playTime, currentMods.rate);
+                beatmapPP.updateEventsStatus(global.playTime, currentMods.rate);
 
                 switch (global.status) {
                     case GameState.menu:

diff --git a/packages/tosu/src/instances/osuInstance.ts b/packages/tosu/src/instances/osuInstance.ts
@@ -123,7 +123,7 @@ export class OsuInstance extends AbstractInstance {
                     this.previousMP3Length = menu.mp3Length;
                 }
 
-                beatmapPP.updateRealTimeBPM(global.playTime, currentMods.rate);
+                beatmapPP.updateEventsStatus(global.playTime, currentMods.rate);
 
                 switch (global.status) {
                     case GameState.menu:

diff --git a/packages/tosu/src/states/beatmap.ts b/packages/tosu/src/states/beatmap.ts
@@ -1,11 +1,7 @@
 import rosu from '@kotrikd/rosu-pp';
 import { ClientType, config, wLogger } from '@tosu/common';
 import fs from 'fs';
-import {
-    BeatmapBreakEvent,
-    Beatmap as ParsedBeatmap,
-    TimingPoint
-} from 'osu-classes';
+import { Beatmap as ParsedBeatmap, TimingPoint } from 'osu-classes';
 import { BeatmapDecoder } from 'osu-parsers';
 import path from 'path';
 
@@ -77,7 +73,21 @@ interface BeatmapPPTimings {
     full: number;
 }
 
+interface BreakPoint {
+    hasEffect: boolean;
+    start: number;
+    end: number;
+}
+
+interface KiaiPoint {
+    start: number;
+    end: number;
+}
+
 export class BeatmapPP extends AbstractState {
+    isKiai: boolean;
+    isBreak: boolean;
+
     beatmap?: rosu.Beatmap;
     lazerBeatmap?: ParsedBeatmap;
     performanceAttributes?: rosu.PerformanceAttributes;
@@ -123,7 +133,8 @@ export class BeatmapPP extends AbstractState {
     };
 
     timingPoints: TimingPoint[] = [];
-    breaks: BeatmapBreakEvent[] = [];
+    breaks: BreakPoint[] = [];
+    kiais: KiaiPoint[] = [];
 
     constructor(game: AbstractInstance) {
         super(game);
@@ -132,6 +143,9 @@ export class BeatmapPP extends AbstractState {
     }
 
     init() {
+        this.isKiai = false;
+        this.isBreak = false;
+
         this.strains = [];
         this.strainsAll = {
             series: [],
@@ -208,6 +222,7 @@ export class BeatmapPP extends AbstractState {
         };
         this.timingPoints = [];
         this.breaks = [];
+        this.kiais = [];
     }
 
     updatePPAttributes(
@@ -466,7 +481,11 @@ export class BeatmapPP extends AbstractState {
                 this.minBPM = Math.round(bpmMin * this.clockRate);
                 this.maxBPM = Math.round(bpmMax * this.clockRate);
 
-                this.breaks = this.lazerBeatmap.events.breaks;
+                this.breaks = this.lazerBeatmap.events.breaks.map((r) => ({
+                    hasEffect: r.hasEffect,
+                    start: r.startTime,
+                    end: r.endTime
+                }));
 
                 const firstObj = Math.round(
                     this.lazerBeatmap.hitObjects.at(0)?.startTime ?? 0
@@ -481,6 +500,20 @@ export class BeatmapPP extends AbstractState {
                 this.timingPoints =
                     this.lazerBeatmap.controlPoints.timingPoints;
 
+                const kiais: KiaiPoint[] = [];
+                const points = this.lazerBeatmap.controlPoints.effectPoints;
+                for (let i = 0; i < points.length; i++) {
+                    const point = points[i];
+                    if (point.kiai === false) {
+                        kiais[kiais.length - 1].end = point.startTime;
+                        continue;
+                    }
+
+                    kiais.push({ start: point.startTime, end: -1 });
+                }
+
+                this.kiais = kiais;
+
                 this.resetReportCount('beatmapPP updateMapMetadataTimings');
             } catch (exc) {
                 this.reportError(
@@ -799,17 +832,20 @@ export class BeatmapPP extends AbstractState {
         }
     }
 
-    updateRealTimeBPM(timeMS: number, multiply: number) {
+    updateEventsStatus(ms: number, multiply: number) {
         if (!this.lazerBeatmap) return;
 
         const bpm =
             this.lazerBeatmap.controlPoints.timingPoints
-                // @ts-ignore
+                // @ts-expect-error
                 .toReversed()
-                .find((r) => r.startTime <= timeMS && r.bpm !== 0)?.bpm ||
+                .find((r) => r.startTime <= ms && r.bpm !== 0)?.bpm ||
             this.lazerBeatmap.controlPoints.timingPoints[0]?.bpm ||
             0.0;
 
         this.realtimeBPM = Math.round(bpm * multiply);
+
+        this.isKiai = this.kiais.some((r) => ms >= r.start && ms <= r.end);
+        this.isBreak = this.breaks.some((r) => ms >= r.start && ms <= r.end);
     }
 }