feat: abstract manual rom file path construction

gbajs3/src/components/modals/load-local-rom.spec.tsx

@@ -58,10 +58,7 @@ describe('<LoadLocalRomModal />', () => {
     vi.spyOn(contextHooks, 'useEmulatorContext').mockImplementation(() => ({
       ...originalEmulator(),
       emulator: {
-        listRoms: () => ['rom1.gba'],
-        filePaths: () => ({
-          gamePath: '/games'
-        })
+        listRoms: () => ['rom1.gba']
       } as GBAEmulator
     }));
 
@@ -74,7 +71,7 @@ describe('<LoadLocalRomModal />', () => {
     await userEvent.click(localRom);
 
     expect(runGameSpy).toHaveBeenCalledOnce();
-    expect(runGameSpy).toHaveBeenCalledWith('/games/rom1.gba');
+    expect(runGameSpy).toHaveBeenCalledWith('rom1.gba');
     expect(setIsModalOpenSpy).toHaveBeenCalledWith(false);
   });
 

gbajs3/src/components/modals/load-local-rom.tsx

@@ -92,7 +92,7 @@ export const LoadLocalRomModal = () => {
             <StyledLi key={`${romName}_${idx}`}>
               <LoadRomButton
                 onClick={() => {
-                  runGame(emulator?.filePaths().gamePath + '/' + romName);
+                  runGame(romName);
                   setIsModalOpen(false);
                 }}
               >

gbajs3/src/components/modals/load-rom.spec.tsx

@@ -37,10 +37,7 @@ describe('<LoadRomModal />', () => {
     vi.spyOn(contextHooks, 'useEmulatorContext').mockImplementation(() => ({
       ...originalEmulator(),
       emulator: {
-        uploadRom: uploadRomSpy,
-        filePaths: () => ({
-          gamePath: '/games'
-        })
+        uploadRom: uploadRomSpy
       } as GBAEmulator
     }));
 
@@ -66,7 +63,7 @@ describe('<LoadRomModal />', () => {
     expect(uploadRomSpy).toHaveBeenCalledOnce();
     expect(syncActionIfEnabledSpy).toHaveBeenCalledOnce();
     expect(runGameSpy).toHaveBeenCalledOnce();
-    expect(runGameSpy).toHaveBeenCalledWith('/games/rom1.gba');
+    expect(runGameSpy).toHaveBeenCalledWith('rom1.gba');
   });
 
   it('renders message when there are no roms', () => {

gbajs3/src/components/modals/load-rom.tsx

@@ -103,7 +103,7 @@ export const LoadRomModal = () => {
     if (shouldUploadRom) {
       const runCallback = () => {
         syncActionIfEnabled();
-        runGame(emulator?.filePaths().gamePath + '/' + romFile.name);
+        runGame(romFile.name);
       };
 
       emulator?.uploadRom(romFile, runCallback);

gbajs3/src/components/modals/load-save.spec.tsx

@@ -34,10 +34,7 @@ describe('<LoadSaveModal />', () => {
     vi.spyOn(contextHooks, 'useEmulatorContext').mockImplementation(() => ({
       ...originalEmulator(),
       emulator: {
-        uploadSaveOrSaveState: uploadSaveOrSaveStateSpy,
-        filePaths: () => ({
-          savePath: '/saves'
-        })
+        uploadSaveOrSaveState: uploadSaveOrSaveStateSpy
       } as GBAEmulator
     }));
 

gbajs3/src/components/modals/upload-public-external-roms.spec.tsx

@@ -38,10 +38,7 @@ describe('<UploadPublicExternalRomsModal />', () => {
     vi.spyOn(contextHooks, 'useEmulatorContext').mockImplementation(() => ({
       ...originalEmulator(),
       emulator: {
-        uploadRom: uploadRomSpy,
-        filePaths: () => ({
-          gamePath: '/games'
-        })
+        uploadRom: uploadRomSpy
       } as GBAEmulator
     }));
 
@@ -79,7 +76,7 @@ describe('<UploadPublicExternalRomsModal />', () => {
     expect(uploadRomSpy).toHaveBeenCalledOnce();
     expect(syncActionIfEnabledSpy).toHaveBeenCalledOnce();
     expect(runGameSpy).toHaveBeenCalledOnce();
-    expect(runGameSpy).toHaveBeenCalledWith('/games/good_rom.gba');
+    expect(runGameSpy).toHaveBeenCalledWith('good_rom.gba');
 
     expect(onLoadOrDismissSpy).toHaveBeenCalledOnce();
     expect(onLoadOrDismissSpy).toHaveBeenCalledWith('loaded');
@@ -100,10 +97,7 @@ describe('<UploadPublicExternalRomsModal />', () => {
     vi.spyOn(contextHooks, 'useEmulatorContext').mockImplementation(() => ({
       ...originalEmulator(),
       emulator: {
-        uploadRom: uploadRomSpy,
-        filePaths: () => ({
-          gamePath: '/games'
-        })
+        uploadRom: uploadRomSpy
       } as GBAEmulator
     }));
 

gbajs3/src/components/modals/upload-public-external-roms.tsx

@@ -72,9 +72,7 @@ export const UploadPublicExternalRomsModal = ({
     if (!isExternalRomLoading && externalRomFile && currentRomURL) {
       const runCallback = () => {
         syncActionIfEnabled();
-        const hasSucceeded = runGame(
-          emulator?.filePaths().gamePath + '/' + externalRomFile.name
-        );
+        const hasSucceeded = runGame(externalRomFile.name);
         if (hasSucceeded) {
           onLoadOrDismiss('loaded');
           setIsModalOpen(false);

gbajs3/src/components/modals/upload-rom.spec.tsx

@@ -38,10 +38,7 @@ describe('<UploadRomModal />', () => {
     vi.spyOn(contextHooks, 'useEmulatorContext').mockImplementation(() => ({
       ...originalEmulator(),
       emulator: {
-        uploadRom: uploadRomSpy,
-        filePaths: () => ({
-          gamePath: '/games'
-        })
+        uploadRom: uploadRomSpy
       } as GBAEmulator
     }));
 
@@ -67,11 +64,12 @@ describe('<UploadRomModal />', () => {
 
     await userEvent.click(screen.getByRole('button', { name: 'Upload' }));
 
+    expect(uploadRomSpy).toHaveBeenCalledOnce();
     expect(uploadRomSpy).toHaveBeenCalledWith(testRom, expect.anything());
 
     expect(syncActionIfEnabledSpy).toHaveBeenCalledOnce();
     expect(runGameSpy).toHaveBeenCalledOnce();
-    expect(runGameSpy).toHaveBeenCalledWith('/games/rom1.gba');
+    expect(runGameSpy).toHaveBeenCalledWith('rom1.gba');
     expect(setIsModalOpenSpy).toHaveBeenCalledWith(false);
   });
 
@@ -94,10 +92,7 @@ describe('<UploadRomModal />', () => {
 
     // needs to be a consistent object
     const testEmu = {
-      uploadRom: uploadRomSpy,
-      filePaths: () => ({
-        gamePath: '/games'
-      })
+      uploadRom: uploadRomSpy
     } as GBAEmulator;
 
     vi.spyOn(contextHooks, 'useModalContext').mockImplementation(() => ({
@@ -140,7 +135,7 @@ describe('<UploadRomModal />', () => {
 
     expect(syncActionIfEnabledSpy).toHaveBeenCalledOnce();
     expect(runGameSpy).toHaveBeenCalledOnce();
-    expect(runGameSpy).toHaveBeenCalledWith('/games/good_rom.gba');
+    expect(runGameSpy).toHaveBeenCalledWith('good_rom.gba');
     expect(setIsModalOpenSpy).toHaveBeenCalledWith(false);
   });
 
@@ -158,10 +153,7 @@ describe('<UploadRomModal />', () => {
       ...originalEmulator(),
       emulator: {
         uploadRom: uploadRomSpy,
-        run: emulatorRunSpy,
-        filePaths: () => ({
-          gamePath: '/games'
-        })
+        run: emulatorRunSpy
       } as GBAEmulator
     }));
 

gbajs3/src/components/modals/upload-rom.tsx

@@ -60,9 +60,7 @@ export const UploadRomModal = () => {
     if (shouldUploadExternalRom) {
       const runCallback = () => {
         syncActionIfEnabled();
-        const hasSucceeded = runGame(
-          emulator?.filePaths().gamePath + '/' + externalRomFile.name
-        );
+        const hasSucceeded = runGame(externalRomFile.name);
         if (hasSucceeded) {
           setIsModalOpen(false);
         }
@@ -96,9 +94,7 @@ export const UploadRomModal = () => {
 
     const runCallback = () => {
       syncActionIfEnabled();
-      const hasSucceeded = runGame(
-        emulator?.filePaths().gamePath + '/' + romFile.name
-      );
+      const hasSucceeded = runGame(romFile.name);
       if (hasSucceeded) {
         setIsModalOpen(false);
       }

gbajs3/src/hooks/emulator/use-quick-reload.spec.tsx

@@ -18,6 +18,7 @@ describe('useQuickReload hook', () => {
       setCanvas: vi.fn(),
       canvas: null,
       emulator: {
+        getCurrentGameName: () => undefined,
         quickReload: emulatorQuickReloadSpy
       } as GBAEmulator
     }));
@@ -46,9 +47,6 @@ describe('useQuickReload hook', () => {
       setCanvas: vi.fn(),
       canvas: null,
       emulator: {
-        filePaths: () => ({
-          gamePath: '/games'
-        }),
         getCurrentGameName: () => 'some_rom.gba'
       } as GBAEmulator
     }));
@@ -67,7 +65,7 @@ describe('useQuickReload hook', () => {
     });
 
     expect(runGameSpy).toHaveBeenCalledOnce();
-    expect(runGameSpy).toHaveBeenCalledWith('/games/some_rom.gba');
+    expect(runGameSpy).toHaveBeenCalledWith('some_rom.gba');
     expect(emulatorQuickReloadSpy).not.toHaveBeenCalled();
 
     expect(setIsRunningSpy).toHaveBeenCalledOnce();
@@ -79,10 +77,7 @@ describe('useQuickReload hook', () => {
     const runGameSpy = vi.fn(() => true);
     const setIsRunningSpy = vi.fn();
 
-    localStorage.setItem(
-      emulatorGameNameLocalStorageKey,
-      '"/games/some_rom_2.gba"'
-    );
+    localStorage.setItem(emulatorGameNameLocalStorageKey, '"some_rom_2.gba"');
 
     vi.spyOn(contextHooks, 'useEmulatorContext').mockImplementation(() => ({
       setCanvas: vi.fn(),
@@ -106,7 +101,7 @@ describe('useQuickReload hook', () => {
     });
 
     expect(runGameSpy).toHaveBeenCalledOnce();
-    expect(runGameSpy).toHaveBeenCalledWith('/games/some_rom_2.gba');
+    expect(runGameSpy).toHaveBeenCalledWith('some_rom_2.gba');
     expect(emulatorQuickReloadSpy).not.toHaveBeenCalled();
 
     expect(setIsRunningSpy).toHaveBeenCalledOnce();

gbajs3/src/hooks/emulator/use-quick-reload.tsx

@@ -14,16 +14,13 @@ export const useQuickReload = () => {
   );
 
   const quickReload = useCallback(() => {
+    const currentGameName = emulator?.getCurrentGameName();
+
     if (isRunning) {
       emulator?.quickReload();
-    } else if (emulator?.getCurrentGameName()) {
-      const isSuccessfulRun = runGame(
-        emulator.filePaths().gamePath + '/' + emulator.getCurrentGameName()
-      );
-      setIsRunning(!!isSuccessfulRun);
-    } else if (storedGameName) {
-      const isSuccessfulRun = runGame(storedGameName);
-      setIsRunning(!!isSuccessfulRun);
+    } else {
+      const gameName = currentGameName ?? storedGameName;
+      if (gameName) setIsRunning(runGame(gameName));
     }
   }, [emulator, isRunning, setIsRunning, runGame, storedGameName]);
 

gbajs3/src/hooks/emulator/use-run-game.spec.tsx

@@ -29,7 +29,10 @@ describe('useRunGame hook', () => {
       canvas: null,
       emulator: {
         run: emulatorRunSpy,
-        setVolume: emulatorSetVolumeSpy
+        setVolume: emulatorSetVolumeSpy,
+        filePaths: () => ({
+          gamePath: '/data/games'
+        })
       } as GBAEmulator
     }));
 
@@ -49,19 +52,19 @@ describe('useRunGame hook', () => {
     const { result } = renderHookWithContext(() => useRunGame());
 
     act(() => {
-      expect(result.current('/games/some_rom.gba')).toBeTruthy();
+      expect(result.current('some_rom.gba')).toBeTruthy();
     });
 
     expect(emulatorRunSpy).toHaveBeenCalledOnce();
-    expect(emulatorRunSpy).toHaveBeenCalledWith('/games/some_rom.gba');
+    expect(emulatorRunSpy).toHaveBeenCalledWith('/data/games/some_rom.gba');
 
     expect(setIsRunningSpy).toHaveBeenCalledOnce();
     expect(setIsRunningSpy).toHaveBeenCalledWith(true);
 
     // set stored game name
     expect(setItemSpy).toHaveBeenCalledWith(
       emulatorGameNameLocalStorageKey,
-      '"/games/some_rom.gba"'
+      '"some_rom.gba"'
     );
 
     // set volume
@@ -97,7 +100,10 @@ describe('useRunGame hook', () => {
         isFastForwardEnabled: () => false,
         setVolume: vi.fn() as (v: number) => void,
         remapKeyBindings: emulatorRemapKeyBindingsSpy,
-        setFastForwardMultiplier: emulatorSetFastForwardMultiplierSpy
+        setFastForwardMultiplier: emulatorSetFastForwardMultiplierSpy,
+        filePaths: () => ({
+          gamePath: '/data/games'
+        })
       } as GBAEmulator
     }));
 
@@ -115,7 +121,7 @@ describe('useRunGame hook', () => {
     const { result } = renderHookWithContext(() => useRunGame());
 
     act(() => {
-      expect(result.current('/games/some_rom.gba')).toBeTruthy();
+      expect(result.current('some_rom.gba')).toBeTruthy();
     });
 
     expect(emulatorRemapKeyBindingsSpy).toHaveBeenCalledOnce();

gbajs3/src/hooks/emulator/use-run-game.tsx

@@ -42,13 +42,15 @@ export const useRunGame = () => {
   const { addCallbacks } = useAddCallbacks();
 
   const run = useCallback(
-    (romPath: string) => {
+    (romName: string) => {
+      const romPath = `${emulator?.filePaths().gamePath}/${romName}`;
       const isSuccessfulRun = emulator?.run(romPath);
       setIsRunning(!!isSuccessfulRun);
-      setStoredGameName(romPath);
-      emulator?.setVolume(currentEmulatorVolume);
+      setStoredGameName(romName);
 
       if (isSuccessfulRun) {
+        emulator?.setVolume(currentEmulatorVolume);
+
         if (currentKeyBindings) emulator?.remapKeyBindings(currentKeyBindings);
 
         if (fastForwardMultiplier > 1 && !emulator?.isFastForwardEnabled())