feat: update relevant settings from imported ini and add jukebox togg…

…le (#385)

* feat: update relevant settings from imported ini

* feat: add jukebox toggle

* show/hide toggle instead of disable

* jukeboxEnabled -> jukebox

src/dolphin/config/config.ts

@@ -1,7 +1,15 @@
+import { defaultAppSettings } from "@settings/defaultSettings";
+
 import type { GeckoCode } from "./geckoCode";
 import { loadGeckoCodes, setCodes } from "./geckoCode";
 import type { IniFile } from "./iniFile";
 
+export type SyncedDolphinSettings = {
+  useMonthlySubfolders: boolean;
+  replayPath: string;
+  jukebox: boolean;
+};
+
 export async function addGamePath(iniFile: IniFile, gameDir: string): Promise<void> {
   const generalSection = iniFile.getOrCreateSection("General");
   const numPaths = generalSection.get("ISOPaths", "0");
@@ -10,24 +18,32 @@ export async function addGamePath(iniFile: IniFile, gameDir: string): Promise<vo
   await iniFile.save();
 }
 
-export async function setSlippiSettings(
-  iniFile: IniFile,
-  options: Partial<{
-    useMonthlySubfolders: boolean;
-    replayPath: string;
-  }>,
-): Promise<void> {
+export async function setSlippiSettings(iniFile: IniFile, options: Partial<SyncedDolphinSettings>): Promise<void> {
   const useMonthlySubfolders = options.useMonthlySubfolders ? "True" : "False";
+  const jukebox = options.jukebox ? "True" : "False";
   const coreSection = iniFile.getOrCreateSection("Core");
   if (options.replayPath !== undefined) {
     coreSection.set("SlippiReplayDir", options.replayPath);
   }
   if (options.useMonthlySubfolders !== undefined) {
     coreSection.set("SlippiReplayMonthFolders", useMonthlySubfolders);
   }
+  if (options.jukebox !== undefined) {
+    coreSection.set("SlippiJukeboxEnabled", jukebox);
+  }
   await iniFile.save();
 }
 
+export async function getSlippiSettings(iniFile: IniFile): Promise<SyncedDolphinSettings> {
+  const coreSection = iniFile.getOrCreateSection("Core");
+  const useMonthlySubfolders = coreSection.get("SlippiReplayMonthFolders", "False") === "True";
+  const replayPath = coreSection.get("SlippiReplayDir", defaultAppSettings.settings.rootSlpPath);
+
+  const jukebox = coreSection.get("SlippiJukeboxEnabled", "True") === "True";
+
+  return { useMonthlySubfolders, replayPath, jukebox };
+}
+
 export async function setBootToCss(globalIni: IniFile, localIni: IniFile, enable: boolean): Promise<void> {
   const geckoCodes = loadGeckoCodes(globalIni, localIni);
   const bootCode = geckoCodes.find((code) => code.name === "Boot to CSS");

src/dolphin/install/installation.ts

@@ -1,4 +1,5 @@
-import { addGamePath, setSlippiSettings } from "@dolphin/config/config";
+import type { SyncedDolphinSettings } from "@dolphin/config/config";
+import { addGamePath, getSlippiSettings, setSlippiSettings } from "@dolphin/config/config";
 import { IniFile } from "@dolphin/config/iniFile";
 import { findDolphinExecutable } from "@dolphin/util";
 import { spawnSync } from "child_process";
@@ -89,6 +90,13 @@ export class DolphinInstallation {
 
     // we shouldn't keep the old cache folder since it might be out of date
     await this.clearCache();
+
+    // read the settings from the ini and update any settings
+    if (this.dolphinLaunchType === DolphinLaunchType.NETPLAY) {
+      const iniPath = path.join(this.userFolder, "Config", "Dolphin.ini");
+      const iniFile = await IniFile.init(iniPath);
+      await getSlippiSettings(iniFile);
+    }
   }
 
   public async validate({
@@ -178,7 +186,13 @@ export class DolphinInstallation {
     await addGamePath(iniFile, gameDir);
   }
 
-  public async updateSettings(options: Partial<{ useMonthlySubfolders: boolean; replayPath: string }>): Promise<void> {
+  public async getSettings(): Promise<SyncedDolphinSettings> {
+    const iniPath = path.join(this.userFolder, "Config", "Dolphin.ini");
+    const iniFile = await IniFile.init(iniPath);
+    return await getSlippiSettings(iniFile);
+  }
+
+  public async updateSettings(options: Partial<SyncedDolphinSettings>): Promise<void> {
     const iniPath = path.join(this.userFolder, "Config", "Dolphin.ini");
     const iniFile = await IniFile.init(iniPath);
     await setSlippiSettings(iniFile, options);

src/dolphin/manager.ts

@@ -56,7 +56,8 @@ export class DolphinManager {
     let playbackInstance = this.playbackDolphinInstances.get(id);
     if (!playbackInstance) {
       playbackInstance = new PlaybackDolphinInstance(dolphinPath, meleeIsoPath);
-      playbackInstance.on("close", (exitCode) => {
+      playbackInstance.on("close", async (exitCode) => {
+        await this._updateLauncherSettings(DolphinLaunchType.PLAYBACK);
         this.eventSubject.next({
           type: DolphinEventType.CLOSED,
           instanceId: id,
@@ -93,7 +94,8 @@ export class DolphinManager {
 
     // Create the Dolphin instance and start it
     this.netplayDolphinInstance = new DolphinInstance(dolphinPath, meleeIsoPath);
-    this.netplayDolphinInstance.on("close", (exitCode) => {
+    this.netplayDolphinInstance.on("close", async (exitCode) => {
+      await this._updateLauncherSettings(DolphinLaunchType.NETPLAY);
       this.eventSubject.next({
         type: DolphinEventType.CLOSED,
         dolphinType: DolphinLaunchType.NETPLAY,
@@ -120,7 +122,8 @@ export class DolphinManager {
     if (launchType === DolphinLaunchType.NETPLAY && !this.netplayDolphinInstance) {
       const instance = new DolphinInstance(dolphinPath);
       this.netplayDolphinInstance = instance;
-      instance.on("close", (exitCode) => {
+      instance.on("close", async (exitCode) => {
+        await this._updateLauncherSettings(launchType);
         this.eventSubject.next({
           type: DolphinEventType.CLOSED,
           dolphinType: DolphinLaunchType.NETPLAY,
@@ -137,7 +140,8 @@ export class DolphinManager {
       const instanceId = "configure";
       const instance = new PlaybackDolphinInstance(dolphinPath);
       this.playbackDolphinInstances.set(instanceId, instance);
-      instance.on("close", (exitCode) => {
+      instance.on("close", async (exitCode) => {
+        await this._updateLauncherSettings(launchType);
         this.eventSubject.next({
           type: DolphinEventType.CLOSED,
           dolphinType: DolphinLaunchType.PLAYBACK,
@@ -209,6 +213,15 @@ export class DolphinManager {
     });
   }
 
+  private async _updateLauncherSettings(launchType: DolphinLaunchType) {
+    const installation = this.getInstallation(launchType);
+    const newSettings = await installation.getSettings();
+
+    await this.settingsManager.setRootSlpPath(newSettings.replayPath);
+    await this.settingsManager.setUseMonthlySubfolders(newSettings.useMonthlySubfolders);
+    await this.settingsManager.setJukebox(newSettings.jukebox);
+  }
+
   private _onStart(dolphinType: DolphinLaunchType) {
     this.eventSubject.next({
       type: DolphinEventType.DOWNLOAD_START,

src/renderer/containers/Settings/MeleeOptions.tsx

@@ -9,11 +9,13 @@ import FormControlLabel from "@mui/material/FormControlLabel";
 import Radio from "@mui/material/Radio";
 import RadioGroup from "@mui/material/RadioGroup";
 import React from "react";
+import { gte } from "semver";
 
+import { Toggle } from "@/components/FormInputs/Toggle";
 import { PathInput } from "@/components/PathInput";
 import { useDolphinStore } from "@/lib/dolphin/useDolphinStore";
 import { useIsoVerification } from "@/lib/hooks/useIsoVerification";
-import { useIsoPath, useLaunchMeleeOnPlay } from "@/lib/hooks/useSettings";
+import { useIsoPath, useJukebox, useLaunchMeleeOnPlay } from "@/lib/hooks/useSettings";
 
 import { SettingItem } from "./SettingItem";
 
@@ -37,9 +39,14 @@ export const MeleeOptions = React.memo(() => {
   const isoValidity = useIsoVerification((state) => state.validity);
   const [isoPath, setIsoPath] = useIsoPath();
   const [launchMeleeOnPlay, setLaunchMelee] = useLaunchMeleeOnPlay();
+  const [jukebox, setJukebox] = useJukebox();
   const netplayDolphinOpen = useDolphinStore((store) => store.netplayOpened);
   const playbackDolphinOpen = useDolphinStore((store) => store.playbackOpened);
 
+  const dolphinVersion = useDolphinStore((store) => store.netplayDolphinVersion);
+
+  const showJukeboxToggle = dolphinVersion !== null && gte(dolphinVersion, "3.2.0");
+
   const onLaunchMeleeChange = async (value: string) => {
     const launchMelee = value === "true";
     await setLaunchMelee(launchMelee);
@@ -79,6 +86,17 @@ export const MeleeOptions = React.memo(() => {
           <FormControlLabel value={false} label="Launch Dolphin" control={<Radio />} />
         </RadioGroup>
       </SettingItem>
+      {showJukeboxToggle && (
+        <SettingItem name="">
+          <Toggle
+            value={jukebox}
+            onChange={(checked) => setJukebox(checked)}
+            label="Enable Music"
+            description="Enable music in game via Slippi Jukebox. Incompatible with WASAPI."
+            disabled={netplayDolphinOpen}
+          />
+        </SettingItem>
+      )}
     </div>
   );
 });

src/renderer/lib/hooks/useSettings.ts

@@ -42,6 +42,14 @@ export const useMonthlySubfolders = () => {
   return [useMonthlySubfolders, setUseMonthlySubfolders] as const;
 };
 
+export const useJukebox = () => {
+  const jukebox = useSettings((store) => store.settings.jukebox);
+  const setJukebox = async (toggle: boolean) => {
+    await window.electron.settings.setJukebox(toggle);
+  };
+  return [jukebox, setJukebox] as const;
+};
+
 export const useSpectateSlpPath = () => {
   const spectateSlpPath = useSettings((store) => store.settings.spectateSlpPath);
   const setSpectateDir = async (path: string) => {

src/settings/api.ts

@@ -9,6 +9,7 @@ import {
   ipc_setAutoUpdateLauncher,
   ipc_setExtraSlpPaths,
   ipc_setIsoPath,
+  ipc_setJukebox,
   ipc_setLaunchMeleeOnPlay,
   ipc_setNetplayDolphinPath,
   ipc_setPlaybackDolphinPath,
@@ -44,6 +45,9 @@ export default {
   async setUseMonthlySubfolders(toggle: boolean): Promise<void> {
     await ipc_setUseMonthlySubfolders.renderer!.trigger({ toggle });
   },
+  async setJukebox(toggle: boolean): Promise<void> {
+    await ipc_setJukebox.renderer!.trigger({ toggle });
+  },
   async setSpectateSlpPath(spectateSlpPath: string): Promise<void> {
     await ipc_setSpectateSlpPath.renderer!.trigger({ path: spectateSlpPath });
   },

src/settings/defaultSettings.ts

@@ -23,6 +23,7 @@ export const defaultAppSettings: AppSettings = {
     isoPath: null,
     rootSlpPath: getDefaultRootSlpPath(),
     useMonthlySubfolders: false,
+    jukebox: true,
     spectateSlpPath: path.join(getDefaultRootSlpPath(), "Spectate"),
     extraSlpPaths: [],
     netplayDolphinPath: path.join(app.getPath("userData"), "netplay"),

src/settings/ipc.ts

@@ -15,6 +15,8 @@ export const ipc_setUseMonthlySubfolders = makeEndpoint.main(
   <SuccessPayload>_,
 );
 
+export const ipc_setJukebox = makeEndpoint.main("setJukebox", <{ toggle: boolean }>_, <SuccessPayload>_);
+
 export const ipc_setSpectateSlpPath = makeEndpoint.main("setSpectateSlpPath", <{ path: string }>_, <SuccessPayload>_);
 
 export const ipc_setExtraSlpPaths = makeEndpoint.main("setExtraSlpPaths", <{ paths: string[] }>_, <SuccessPayload>_);

src/settings/settingsManager.ts

@@ -65,6 +65,10 @@ export class SettingsManager {
     await this._set("settings.useMonthlySubfolders", toggle);
   }
 
+  public async setJukebox(toggle: boolean): Promise<void> {
+    await this._set("settings.jukebox", toggle);
+  }
+
   public async setSpectateSlpPath(slpPath: string): Promise<void> {
     await this._set("settings.spectateSlpPath", slpPath);
   }

src/settings/setup.ts

@@ -11,6 +11,7 @@ import {
   ipc_setAutoUpdateLauncher,
   ipc_setExtraSlpPaths,
   ipc_setIsoPath,
+  ipc_setJukebox,
   ipc_setLaunchMeleeOnPlay,
   ipc_setNetplayDolphinPath,
   ipc_setPlaybackDolphinPath,
@@ -62,6 +63,13 @@ export default function setupSettingsIpc({
     return { success: true };
   });
 
+  ipc_setJukebox.main!.handle(async ({ toggle }) => {
+    await settingsManager.setJukebox(toggle);
+    const installation = dolphinManager.getInstallation(DolphinLaunchType.NETPLAY);
+    await installation.updateSettings({ jukebox: toggle });
+    return { success: true };
+  });
+
   ipc_setSpectateSlpPath.main!.handle(async ({ path }) => {
     await settingsManager.setSpectateSlpPath(path);
     return { success: true };

src/settings/types.ts

@@ -21,6 +21,7 @@ export type AppSettings = {
     isoPath: string | null;
     rootSlpPath: string;
     useMonthlySubfolders: boolean;
+    jukebox: boolean;
     spectateSlpPath: string;
     extraSlpPaths: string[];
     netplayDolphinPath: string;