Merge pull request #86 from hrfarmer/lazer-support

Add Lazer Support

Author: hrfarmer

bun.lockb

@@ -36,9 +36,10 @@
     "fastest-levenshtein": "^1.0.16",
     "get-audio-duration": "^4.0.1",
     "graceful-fs": "^4.2.11",
-    "lucide-solid": "^0.452.0",
+    "lucide-solid": "^0.460.0",
     "node-addon-api": "^8.2.1",
     "polished": "^4.3.1",
+    "realm": "~20.1.0",
     "sharp": "^0.33.5",
     "solid-focus-trap": "^0.1.7",
     "tailwind-merge": "^2.5.3"

package.json

@@ -1,4 +1,5 @@
 import { OsuFile } from "./OsuFile";
+import { BeatmapSet } from "./lazer.types";
 import { access } from "@main/lib/fs-promises";
 import { fail, ok } from "@shared/lib/rust-types/Result";
 import { assertNever } from "@shared/lib/tungsten/assertNever";
@@ -7,6 +8,7 @@ import fs from "graceful-fs";
 import os from "os";
 import path from "path/posix";
 import readline from "readline";
+import Realm from "realm";
 
 const bgFileNameRegex = /.*"(?<!Video.*)(.*)".*/;
 const beatmapSetIDRegex = /([0-9]+) .*/;
@@ -32,9 +34,6 @@ export type DirParseResult = Promise<
   Result<[Table<Song>, Table<AudioSource>, Table<ImageSource>], string>
 >;
 
-// Overriding Buffer prototype because I'm lazy.
-// Should probably get moved to another file, or make a wrapper instead.
-
 class BufferReader {
   buffer: Buffer;
   pos: number;
@@ -113,7 +112,129 @@ class BufferReader {
 }
 
 export class OsuParser {
-  static async parseDatabase(
+  static async parseLazerDatabase(
+    databasePath: string,
+    update?: (i: number, total: number, file: string) => any,
+  ): DirParseResult {
+    const currentDir = databasePath.replaceAll("\\", "/");
+
+    const sourceRealm = path.join(currentDir, "client.realm");
+    const destinationRealm = path.join(currentDir, "radio_client.realm");
+
+    // clone the realm file so it can be upgraded if needed by the realm sdk
+    // without bricking the user's lazer installation
+    fs.copyFileSync(sourceRealm, destinationRealm);
+
+    const realm = await Realm.open({
+      path: currentDir + "/radio_client.realm",
+    });
+    const beatmapSets = realm.objects<BeatmapSet>("BeatmapSet");
+
+    const songTable = new Map<ResourceID, Song>();
+    const audioTable = new Map<ResourceID, AudioSource>();
+    const imageTable = new Map<ResourceID, ImageSource>();
+
+    let i = 0;
+    for (const beatmapSet of beatmapSets) {
+      try {
+        const beatmaps = beatmapSet.Beatmaps;
+
+        for (const beatmap of beatmaps) {
+          try {
+            const song: Song = {
+              lazer: true,
+              audio: "",
+              osuFile: "",
+              path: "",
+              ctime: "",
+              dateAdded: beatmapSet.DateAdded,
+              title: beatmap.Metadata.Title,
+              artist: beatmap.Metadata.Artist,
+              creator: beatmap.Metadata.Author?.Username ?? "No Creator",
+              bpm: [[beatmap.BPM]],
+              duration: beatmap.Length,
+              diffs: [beatmap.DifficultyName ?? "Unknown difficulty"],
+            };
+
+            song.osuFile = path.join(
+              currentDir,
+              "files",
+              beatmap.Hash[0],
+              beatmap.Hash.substring(0, 2),
+              beatmap.Hash,
+            );
+
+            const songHash = beatmapSet.Files.find(
+              (file) => file.Filename.toLowerCase() === beatmap.Metadata.AudioFile.toLowerCase(),
+            )?.File.Hash;
+
+            if (songHash) {
+              song.audio = path.join(
+                currentDir,
+                "files",
+                songHash[0],
+                songHash.substring(0, 2),
+                songHash,
+              );
+            }
+
+            const existingSong = songTable.get(song.audio);
+            if (existingSong) {
+              existingSong.diffs.push(song.diffs[0]);
+              continue;
+            }
+
+            /* Note: in lots of places throughout the application, it relies on the song.path parameter, which in the
+            stable parser is the path of the folder that holds all the files. This folder doesn't exist in lazer's
+            file structure, so for now I'm just passing the audio location as the path parameter. In initial testing
+            this doesn't seem to break anything but just leaving this note in case it does */
+            song.path = song.audio;
+
+            const bgHash = beatmapSet.Files.find(
+              (file) => file.Filename === beatmap.Metadata.BackgroundFile,
+            )?.File.Hash;
+
+            if (bgHash) {
+              song.bg = path.join(currentDir, "files", bgHash[0], bgHash.substring(0, 2), bgHash);
+            }
+
+            song.beatmapSetID = beatmapSet.OnlineID;
+
+            songTable.set(song.audio, song);
+            audioTable.set(song.audio, {
+              songID: song.audio,
+              path: song.audio,
+              ctime: String(beatmapSet.DateAdded),
+            });
+
+            if (update) {
+              update(i + 1, beatmapSets.length, song.title);
+              i++;
+            }
+          } catch (err) {
+            console.error("Error while parsing beatmap: ", err);
+          }
+        }
+      } catch (err) {
+        console.error("Error while parsing beatmapset: ", err);
+      }
+    }
+
+    // Done with the file now
+    realm.close();
+
+    // Delete the cloned lazer realm file(s)
+    fs.unlinkSync(path.join(currentDir, "radio_client.realm"));
+    fs.unlinkSync(path.join(currentDir, "radio_client.realm.lock"));
+    fs.rmSync(path.join(currentDir, "radio_client.realm.management"), {
+      recursive: true,
+      force: true,
+    });
+
+    return ok([songTable, audioTable, imageTable]);
+  }
+
+  static async parseStableDatabase(
     databasePath: string,
     update?: (i: number, total: number, file: string) => any,
   ): DirParseResult {
@@ -196,6 +317,7 @@ export class OsuParser {
         }
 
         const song: Song = {
+          lazer: false,
           audio: "",
           osuFile: "",
           path: "",
@@ -303,11 +425,11 @@ export class OsuParser {
         db.readInt(); // last edit time
         db.readByte(); // mania scroll speed
 
-        const audioFilePath = songsFolderPath + "/" + folder + "/" + audio_filename;
-        const osuFilePath = songsFolderPath + "/" + folder + "/" + osu_filename;
+        const audioFilePath = path.join(songsFolderPath, folder, audio_filename);
+        const osuFilePath = path.join(songsFolderPath, folder, osu_filename);
         song.osuFile = osuFilePath;
         song.audio = audioFilePath;
-        song.path = songsFolderPath + "/" + folder;
+        song.path = path.join(songsFolderPath, folder);
 
         // Check if the song has already been processed, and add the diff name to the existing song if so
         const existingSong = songTable.get(audioFilePath);
@@ -323,7 +445,9 @@ export class OsuParser {
         }
 
         const bgSrc = osuFile.value.props.get("bgSrc");
-        song.bg = songsFolderPath + "/" + folder + "/" + bgSrc;
+        if (bgSrc) {
+          song.bg = path.join(songsFolderPath, folder, bgSrc);
+        }
 
         if (song.audio != last_audio_filepath) {
           songTable.set(song.audio, song);

src/main/lib/osu-file-parser/OsuParser.ts

@@ -0,0 +1,67 @@
+type BeatmapMetadata = {
+  Title: string;
+  TitleUnicode: string;
+  Artist: string;
+  ArtistUnicode: string;
+  Author?: { OnlineID: number; Username: string; CountryCode: string };
+  Source?: string;
+  Tags?: string;
+  PreviewTime: number;
+  AudioFile: string;
+  BackgroundFile?: string;
+};
+
+export type Beatmap = {
+  ID: Realm.BSON.UUID;
+  DifficultyName?: string;
+  Metadata: BeatmapMetadata;
+  BeatmapSet?: BeatmapSet;
+  Status: number;
+  OnlineID: number;
+  Length: number;
+  BPM: number;
+  Hash: string;
+  StarRating: number;
+  MD5Hash?: string;
+  OnlineMD5Hash?: string;
+  LastLocalUpdate?: string;
+  LastOnlineUpdate?: string;
+  Hidden: boolean;
+  EndTimeObjectCount: number;
+  TotalObjectCount: number;
+  AudioLeadIn: number;
+  StackLeniency: number;
+  SpecialStyle: boolean;
+  LetterboxInBreaks: boolean;
+  WidescreenStoryboard: boolean;
+  EpilepsyWarning: boolean;
+  SamplesMatchPlaybackRate: boolean;
+  LastPlayed?: string;
+  DistanceSpacing: number;
+  BeatDivisor: number;
+  GridSize: number;
+  TimelineZoom: number;
+  EditorTimestamp?: number;
+  CountdownOffset: number;
+};
+
+type RealmFile = {
+  File: {
+    Hash: string;
+  };
+  Filename: string;
+};
+
+export type BeatmapSet = {
+  ID: Realm.BSON.UUID;
+  OnlineID: number;
+  DateAdded: string;
+  DateSubmitted?: string;
+  DateRanked?: string;
+  Beatmaps: Beatmap[];
+  Status: number;
+  DeletePending: boolean;
+  Hash?: string;
+  Protected: boolean;
+  Files: RealmFile[];
+};

src/main/lib/osu-file-parser/lazer.types.ts

@@ -54,7 +54,7 @@ async function configureOsuDir(mainWindow: BrowserWindow) {
 
   while (true) {
     await Router.dispatch(mainWindow, "changeScene", "dir-select");
-    const dir = await dirSubmit();
+    const dirData = await dirSubmit();
 
     await Router.dispatch(mainWindow, "changeScene", "loading");
     await Router.dispatch(mainWindow, "loadingScene::setTitle", "Importing songs from osu!");
@@ -68,7 +68,11 @@ async function configureOsuDir(mainWindow: BrowserWindow) {
       });
     }, UPDATE_DELAY_MS);
 
-    tables = await OsuParser.parseDatabase(dir, update);
+    if (dirData.version == "stable") {
+      tables = await OsuParser.parseStableDatabase(dirData.path, update);
+    } else {
+      tables = await OsuParser.parseLazerDatabase(dirData.path, update);
+    }
     // Cancel ongoing throttled update, so it does not look bad when it finishes and afterward the update overwrites
     // finished state
     cancelUpdate();
@@ -82,14 +86,14 @@ async function configureOsuDir(mainWindow: BrowserWindow) {
     if (tables.value[SONGS].size === 0) {
       await showError(
         mainWindow,
-        `No songs found in folder: ${dir}. Please make sure this is the directory where you have all your songs saved.`,
+        `No songs found in folder: ${dirData.path}. Please make sure this is the directory where you have all your songs saved.`,
       );
       // Try again
       continue;
     }
 
     // All went smoothly. Save osu directory and continue with import procedure
-    settings.write("osuSongsDir", dir);
+    settings.write("osuSongsDir", dirData.path);
     break;
   }