rhythia-api 243.0.0 → 244.0.0

package/utils/requestUtils.ts

@@ -1,5 +1,5 @@
 import { NextResponse } from "./response";
-import { ZodObject } from "zod";
+import { ZodObject, ZodTypeAny } from "zod";
 import { getUserBySession } from "./getUserBySession";
 import { supabase } from "./supabase";
 
@@ -61,7 +61,7 @@ interface Props<
   T = ZodObject<any>,
 > {
   request: Request;
-  schema: { input: T; output: T };
+  schema: { input: T; output: ZodTypeAny };
   authorization?: Function;
   activity: K;
 }

package/utils/star-calc/formatSingle.ts

@@ -0,0 +1,107 @@
+const GeneralScientificLowerExponentDotNet = -5;
+const DecimalTieTolerance = Number.EPSILON * 4;
+
+export function formatSingle(value: number) {
+  value = Math.fround(value);
+
+  for (let precision = 1; precision <= 9; precision++) {
+    const rounded = Number(value.toPrecision(precision));
+    const formatted = formatGeneralDotNet(
+      breakDecimalTieDotNet(value, rounded, precision)
+    );
+
+    if (Math.fround(Number(formatted)) === value) {
+      return formatted;
+    }
+  }
+
+  return formatGeneralDotNet(value);
+}
+
+function formatGeneralDotNet(value: number) {
+  if (value === 0) {
+    return "0";
+  }
+
+  const formatted = value.toString();
+  const exponent = getDecimalExponent(value);
+
+  if (
+    formatted.includes("e") ||
+    exponent <= GeneralScientificLowerExponentDotNet
+  ) {
+    return formatExponential(value, getSignificantDigitCount(formatted));
+  }
+
+  return formatted;
+}
+
+function getDecimalExponent(value: number) {
+  return Math.floor(Math.log10(Math.abs(value)));
+}
+
+function getSignificantDigitCount(value: string) {
+  const [mantissa] = value.toLowerCase().split("e");
+  const digits = mantissa!.replace("-", "").replace(".", "").replace(/^0+/, "");
+  return Math.max(digits.length, 1);
+}
+
+function formatExponential(value: number, significantDigitCount: number) {
+  const [mantissa, exponent] = value
+    .toExponential(significantDigitCount - 1)
+    .split("e");
+  const exponentValue = Number(exponent);
+  const exponentSign = exponentValue < 0 ? "-" : "+";
+  const exponentDigits = Math.abs(exponentValue).toString().padStart(2, "0");
+  const normalizedMantissa = mantissa!
+    .replace(/(\.\d*?)0+$/, "$1")
+    .replace(/\.$/, "");
+
+  return `${normalizedMantissa}E${exponentSign}${exponentDigits}`;
+}
+
+function breakDecimalTieDotNet(
+  value: number,
+  rounded: number,
+  precision: number
+) {
+  if (rounded === value || Math.fround(rounded) !== value) {
+    return rounded;
+  }
+
+  const exponent = getDecimalExponent(rounded);
+  const step = 10 ** (exponent - precision + 1);
+  const alternate = Number(
+    (rounded > value ? rounded - step : rounded + step).toPrecision(precision)
+  );
+
+  if (alternate === rounded || Math.fround(alternate) !== value) {
+    return rounded;
+  }
+
+  const roundedDistance = Math.abs(value - rounded);
+  const alternateDistance = Math.abs(value - alternate);
+  const tolerance =
+    DecimalTieTolerance *
+    Math.max(1, Math.abs(value), Math.abs(rounded), Math.abs(alternate));
+
+  if (alternateDistance + tolerance < roundedDistance) {
+    return alternate;
+  }
+
+  if (roundedDistance + tolerance < alternateDistance) {
+    return rounded;
+  }
+
+  return hasEvenLastSignificantDigit(alternate, precision)
+    ? alternate
+    : rounded;
+}
+
+function hasEvenLastSignificantDigit(value: number, precision: number) {
+  const [mantissa] = Math.abs(value).toPrecision(precision).split("e");
+  const digits = mantissa!.replace(".", "").replace(/^0+/, "");
+  const lastDigit = Number(digits.at(-1));
+
+  return lastDigit % 2 === 0;
+}

package/utils/star-calc/rhmParser.ts

@@ -0,0 +1,214 @@
+import { Buffer } from "buffer";
+import { createHash } from "node:crypto";
+import pako from "pako";
+import { formatSingle } from "./formatSingle.ts";
+import type { SSPMParsedMap } from "./sspmParser.ts";
+
+const LocalFileHeaderSignature = 0x04034b50;
+const CentralDirectorySignature = 0x02014b50;
+const EndOfCentralDirectorySignature = 0x06054b50;
+
+interface ZipEntry {
+  name: string;
+  method: number;
+  compressedSize: number;
+  localHeaderOffset: number;
+}
+
+interface RHMNote {
+  Time: number;
+  X: number;
+  Y: number;
+}
+
+export interface RHMMap {
+  OnlineId?: number;
+  OnlineStatus?: string;
+  LegacyId?: string;
+  SongName: string;
+  Mappers: string[];
+  Title: string;
+  Duration: number;
+  Difficulty: number;
+  CustomDifficultyName?: string;
+  StarRating?: number;
+  Notes: RHMNote[];
+  AudioFileName?: string;
+  ImagePath?: string;
+}
+
+export interface RHMParsedMap {
+  map: RHMMap;
+  audio?: Buffer;
+  cover?: Buffer;
+}
+
+export function isRHM(buffer: Buffer) {
+  return (
+    buffer.length >= 4 && buffer.readUInt32LE(0) === LocalFileHeaderSignature
+  );
+}
+
+export function parseRHM(buffer: Buffer): RHMParsedMap {
+  const entries = readZipEntries(buffer);
+  const mapEntry = entries.get("map");
+
+  if (!mapEntry) {
+    throw new Error("Missing RHM map entry.");
+  }
+
+  return {
+    map: JSON.parse(mapEntry.toString("utf8")),
+    audio: entries.get("audio"),
+    cover: entries.get("cover"),
+  };
+}
+
+export function rhmToSSPMParsedMap({ map, audio, cover }: RHMParsedMap) {
+  const notes = [...map.Notes].sort((a, b) => a.Time - b.Time);
+  const fields: SSPMParsedMap["customData"]["fields"] = [];
+
+  if (map.CustomDifficultyName) {
+    fields.push({
+      id: "difficulty_name",
+      type: 0x09,
+      value: map.CustomDifficultyName,
+    });
+  }
+
+  return {
+    header: {
+      signature: Buffer.from("RHM\0"),
+      version: 0,
+      reserved: Buffer.from([]),
+    },
+    metadata: {
+      sha1: Buffer.from([]),
+      lastMarkerPos: map.Duration,
+      noteCount: notes.length,
+      markerCount: notes.length,
+      difficulty: map.Difficulty,
+      rating: 0,
+      hasAudio: !!audio,
+      hasCover: !!cover,
+      requiresMod: false,
+    },
+    pointers: {
+      customDataOffset: 0,
+      customDataLength: 0,
+      audioOffset: 0,
+      audioLength: audio?.length || 0,
+      coverOffset: 0,
+      coverLength: cover?.length || 0,
+      markerDefinitionsOffset: 0,
+      markerDefinitionsLength: 0,
+      markerOffset: 0,
+      markerLength: 0,
+    },
+    strings: {
+      mapID: map.LegacyId || computeRhythiaMapHash(map),
+      mapName: map.Title,
+      songName: map.SongName,
+      mappers: map.Mappers,
+    },
+    customData: { fields },
+    audio,
+    cover,
+    markerDefinitions: [{ id: "ssp_note", values: [0x07] }],
+    markers: notes.map((note) => {
+      const position = { x: note.X, y: note.Y, type: "quantum" as const };
+
+      return {
+        position: note.Time,
+        type: 0,
+        data: {
+          field0: position,
+          position,
+        },
+      };
+    }),
+  } satisfies SSPMParsedMap;
+}
+
+export function computeRhythiaMapHash(map: RHMMap) {
+  const hashString =
+    map.Title +
+    map.SongName +
+    map.Mappers.join(",") +
+    map.Duration +
+    map.Notes.map(
+      (x) => x.Time + formatSingle(x.X) + formatSingle(x.Y)
+    ).join(",") +
+    map.Difficulty +
+    (map.CustomDifficultyName ?? "");
+
+  return createHash("sha256").update(hashString, "utf16le").digest("hex");
+}
+
+function readZipEntries(buffer: Buffer) {
+  const eocdOffset = findEndOfCentralDirectory(buffer);
+  const entryCount = buffer.readUInt16LE(eocdOffset + 10);
+  let offset = buffer.readUInt32LE(eocdOffset + 16);
+  const entries = new Map<string, Buffer>();
+
+  for (let i = 0; i < entryCount; i++) {
+    const entry = readCentralDirectoryEntry(buffer, offset);
+    entries.set(entry.name, readZipEntry(buffer, entry));
+
+    offset +=
+      46 +
+      buffer.readUInt16LE(offset + 28) +
+      buffer.readUInt16LE(offset + 30) +
+      buffer.readUInt16LE(offset + 32);
+  }
+
+  return entries;
+}
+
+function findEndOfCentralDirectory(buffer: Buffer) {
+  for (let i = buffer.length - 22; i >= 0; i--) {
+    if (buffer.readUInt32LE(i) === EndOfCentralDirectorySignature) {
+      return i;
+    }
+  }
+
+  throw new Error("Invalid RHM zip directory.");
+}
+
+function readCentralDirectoryEntry(buffer: Buffer, offset: number): ZipEntry {
+  if (buffer.readUInt32LE(offset) !== CentralDirectorySignature) {
+    throw new Error("Invalid RHM central directory.");
+  }
+
+  const nameLength = buffer.readUInt16LE(offset + 28);
+
+  return {
+    name: buffer.subarray(offset + 46, offset + 46 + nameLength).toString(),
+    method: buffer.readUInt16LE(offset + 10),
+    compressedSize: buffer.readUInt32LE(offset + 20),
+    localHeaderOffset: buffer.readUInt32LE(offset + 42),
+  };
+}
+
+function readZipEntry(buffer: Buffer, entry: ZipEntry) {
+  const localHeaderOffset = entry.localHeaderOffset;
+
+  if (buffer.readUInt32LE(localHeaderOffset) !== LocalFileHeaderSignature) {
+    throw new Error(`Invalid RHM entry header: ${entry.name}`);
+  }
+
+  const nameLength = buffer.readUInt16LE(localHeaderOffset + 26);
+  const extraLength = buffer.readUInt16LE(localHeaderOffset + 28);
+  const dataStart = localHeaderOffset + 30 + nameLength + extraLength;
+  const data = buffer.subarray(dataStart, dataStart + entry.compressedSize);
+
+  if (entry.method === 0) {
+    return data;
+  }
+
+  if (entry.method === 8) {
+    return Buffer.from(pako.inflateRaw(data));
+  }
+
+  throw new Error(`Unsupported RHM zip compression: ${entry.method}`);
+}