rhythia-api 242.0.0 → 244.0.0

package/utils/rhrReplay.ts

@@ -0,0 +1,122 @@
+const VERSION_EXTENDED_FIELDS = 20260125;
+const VERSION_FAIL_TIME = 20260222;
+const VERSION_BEATMAP_HASH = 20260517;
+const REPLAY_FRAME_SIZE = 17;
+
+export function parseReplaySubmitData(bytes: Buffer) {
+  let offset = 0;
+
+  const ensure = (length: number) => {
+    if (offset + length > bytes.length) {
+      throw new Error("Invalid replay file");
+    }
+  };
+
+  const skip = (length: number) => {
+    ensure(length);
+    offset += length;
+  };
+
+  const readU8 = () => {
+    ensure(1);
+    return bytes[offset++];
+  };
+
+  const readInt32 = () => {
+    ensure(4);
+    const value = bytes.readInt32LE(offset);
+    offset += 4;
+    return value;
+  };
+
+  const readFloat = () => {
+    ensure(4);
+    const value = bytes.readFloatLE(offset);
+    offset += 4;
+    return value;
+  };
+
+  const readString = () => {
+    let length = 0;
+    let shift = 0;
+
+    while (true) {
+      const byte = readU8();
+      length += (byte & 0x7f) * 2 ** shift;
+
+      if ((byte & 0x80) === 0) {
+        break;
+      }
+
+      shift += 7;
+      if (shift > 35) {
+        throw new Error("Invalid replay file");
+      }
+    }
+
+    ensure(length);
+    const value = bytes.toString("utf8", offset, offset + length);
+    offset += length;
+    return value;
+  };
+
+  const version = readInt32();
+
+  skip(8);
+  readString();
+  readString();
+  const onlineMapId = readInt32();
+  readInt32();
+  readString();
+
+  let mods = "[]";
+  let spin = false;
+  let speed = 1;
+
+  if (version >= VERSION_EXTENDED_FIELDS) {
+    readU8();
+    mods = readString();
+    spin = readU8() !== 0;
+    speed = readFloat();
+    skip(8);
+  }
+
+  readFloat();
+  const hits = readInt32();
+  const misses = readInt32();
+  readFloat();
+
+  let failTime: number | null = null;
+  if (version >= VERSION_FAIL_TIME) {
+    const value = readInt32();
+    failTime = value >= 0 ? value : null;
+  }
+
+  const beatmapHash =
+    version >= VERSION_BEATMAP_HASH ? readString() || null : null;
+  const frameCount = readInt32();
+
+  if (frameCount < 0) {
+    throw new Error("Invalid replay file");
+  }
+
+  ensure(frameCount * REPLAY_FRAME_SIZE);
+
+  const parsedMods = JSON.parse(mods || "[]");
+  if (!Array.isArray(parsedMods)) {
+    throw new Error("Invalid replay mods");
+  }
+
+  return {
+    beatmapHash,
+    onlineMapId,
+    misses,
+    hits,
+    speed,
+    mods: parsedMods,
+    spin,
+    replayBytes: bytes.toString("base64"),
+    pauses: null,
+    failTime,
+  };
+}

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}`);
+}