nandmgr progress

include/evtmgr_cmd.h

@@ -34,6 +34,17 @@
 #define EVTDAT_GW_BASE 50000000
 #define EVTDAT_LW_BASE 30000000
 
+#define UF(id) (id - EVTDAT_UF_BASE)
+#define UW(id) (id - EVTDAT_UW_BASE)
+#define GSW(id) (id - EVTDAT_GSW_BASE)
+#define LSW(id) (id - EVTDAT_LSW_BASE)
+#define GSWF(id) (id - EVTDAT_GSWF_BASE)
+#define LSWF(id) (id - EVTDAT_LSWF_BASE)
+#define GF(id) (id - EVTDAT_GF_BASE)
+#define LF(id) (id - EVTDAT_LF_BASE)
+#define GW(id) (id - EVTDAT_GW_BASE)
+#define LW(id) (id - EVTDAT_LW_BASE)
+
 // Return values
 #define EVT_END 0xff
 #define EVT_CONTINUE 2

include/nandmgr.h

@@ -13,6 +13,8 @@
 
 #define NAND_FLAG_Exec 1
 #define NAND_FLAG_Waiting 2
+// 4 is had an error?
+#define NAND_FLAG_NoSave 0x1000
 
 #define NAND_BLOCK_COUNT 7
 #define NAND_INODE_COUNT 5
@@ -22,17 +24,18 @@ enum {
     NANDMGR_TASK_NONE,
     NANDMGR_TASK_CHECK,
     NANDMGR_TASK_WRITE_BANNER,
-    NANDMGR_TASK_WRITE_ALL,
-    NANDMGR_TASK_WRITE,
-    NANDMGR_TASK_5,
-    NANDMGR_TASK_6
+    NANDMGR_TASK_WRITE_ALL_SAVES,
+    NANDMGR_TASK_WRITE_SAVE,
+    NANDMGR_TASK_WRITE_BANNER_LOAD_ALL_SAVES,
+    NANDMGR_TASK_DELETE_SAVE
 };
 
 typedef struct {
-    u16 flags;
+    u16 flags; // 2 is corrupt?
     u8 unknown_0x2[0x8 - 0x2];
     SpmarioGlobals spmarioGlobals;
-    u8 unknown_0x1b10[0x25b0 - 0x1b10];
+    u8 unknown_0x1b10[0x6a0];
+    u8 unknown_0x21b0[0x400];
     u32 checksum;
     u32 checksumNOT;
 } SaveFile;
@@ -54,39 +57,144 @@ typedef struct {
     u32 task;
     u32 stage;
     s32 code;
-    u32 saveId;
+    s32 saveId;
 } NandWork;
 
+/*
+    Initialises banner, work and saves
+    Saves are zerod with hashes corrected, not loaded from NAND
+*/
 void nandInit(); // 8023e60c
+
+/*
+    Continues the current asynchronous task
+*/
 void nandMain(); // 8023e97c
+
+/*
+    Checks whether an asynchronous task is still running
+*/
 bool nandIsExec(); // 8023e9c0
+
+/*
+    Gets the latest NAND library function return
+*/
 s32 nandGetCode(); // 8023e9e0
-SaveFile * nandGetSaveFiles(); // 8023e9ec, pointer to all 4
 
+/*
+    Returns a pointer to the array of all 4 save files
+*/
+SaveFile * nandGetSaveFiles(); // 8023e9ec
+
+/*
+    Starts NANDCheck being called to see that the game's files can all be created asynchronously
+*/
 void nandCheck(); // 8023e9f8
-void nandWriteBanner(); // 8023ea70
-void nandWriteAll(); // 8023eaec
-void nandWrite(u32 saveId); // 8023eb68
-void nandmgrStartTask5(); // 8023ebf0
-void nandmgrStartTask6(); // 8023ec6c
 
-void nandCopy(s32 sourceId, s32 destId); // 8023ece8
-void nandErase(s32 saveId); // 8023ed08
+/*
+    Starts banner.bin being written to NAND asynchronously 
+*/
+void nandWriteBanner(); // 8023ea70
+
+/*
+    Starts all save files being written to NAND asynchronously 
+*/
+void nandWriteAllSaves(); // 8023eaec
+
+/*
+    Starts a save file being written to NAND asynchronously 
+*/
+void nandWriteSave(s32 saveId); // 8023eb68
+
+/*
+    Starts writing banner.bin to and reading all save files from NAND asynchronously 
+*/
+void nandWriteBannerLoadAllSaves(); // 8023ebf0
+
+/*
+    Starts a save file being deleted from NAND asynchronously
+    Bugged to always delete the first save file
+*/
+void nandDeleteSave(s32 saveId); // 8023ec6c
+
+/*
+    Copies the contents of one save file to another
+    Changes copies in memory only, NAND is not written
+*/
+void nandCopySave(s32 sourceId, s32 destId); // 8023ece8
+
+/*
+    Clears the contents of a save file
+    Changes the copy in memory only, NAND is not written
+*/
+void nandClearSave(s32 saveId); // 8023ed08
+
+/*
+    Updates the contents of a save file
+    Changes the copy in memory only, NAND is not written
+*/
 void nandUpdateSave(s32 saveId); // 8023edcc
+
+/*
+    Loads the contents of a save file into the game's systems
+    For example, SPMarioGlobals are copied to gp.
+    Uses the copy in memory, NAND is not read
+*/
 void nandLoadSave(s32 saveId); // 8023efe0
 
-void nandmgrSetFlag0x1000(); // 8023f0a0
-void nandmgrClearFlag0x1000(); // 8023f0b4
-bool nandmgrCheckFlag0x1000(); // 8023f0c8
+/*
+    Disables saving to NAND, all saves are cleared on game over.
+*/
+void nandDisableSaving(); // 8023f0a0
 
+/*
+    Re-enables saving to NAND
+*/
+void nandEnableSaving(); // 8023f0b4
+
+/*
+    Returns whether saving to NAND is enabled
+*/
+bool nandCheckSaving(); // 8023f0c8
+
+/*
+    Carries out the asynchronous process for nandCheck
+*/
 void nandCheckMain(); // 8023f0d8
-void nandWriteBannerMain(); // 8023f200
-void nandWriteAllMain(); // 8023f570
-void nandWriteMain(); // 8023fa24
-void nandmgrTask5(); // 8023fd64
-void nandmgrTask6(); // 80240414
 
+/*
+    Carries out the asynchronous process for nandWriteBanner
+*/
+void nandWriteBannerMain(); // 8023f200
+
+/*
+    Carries out the asynchronous process for nandWriteAllSaves
+*/
+void nandWriteAllSavesMain(); // 8023f570
+
+/*
+    Carries out the asynchronous process for nandWriteSave
+*/
+void nandWriteSaveMain(); // 8023fa24
+
+/*
+    Carries out the asynchronous process for nandWriteBannerLoadAllSaves
+*/
+void nandWriteBannerLoadAllSavesMain(); // 8023fd64
+
+/*
+    Carries out the asynchronous process for nandDeleteSave
+*/
+void nandDeleteSaveMain(); // 80240414
+
+/*
+    Callback for NAND library functions
+*/
 void genericCallback(s32 result, NANDCommandBlock * commandBlock); // 80240620
+
+/*
+    Unique callback for NANDCheck
+*/
 void checkCallback(s32 result, NANDCommandBlock * commandBlock); // 80240648
 
 #endif

include/os.h

@@ -81,4 +81,6 @@ bool OSLink(RelHeader * relFile, void * bss); // 80274c0c
 
 void OSYieldThread(); // 802776c0
 
+s64 OSGetTime(); // 80278370
+
 #endif

include/relmgr.h

@@ -21,9 +21,9 @@ typedef struct {
 void relInit(); // 8023e434
 
 /*
-    Attempts to continue the process of loading the rel, called every frame
+    Attempts to continue the process of loading the rel, if it hasn't already finished
 */
-void loadRel(); // 8023e444
+void relMain(); // 8023e444
 
 /*
     Returns whether the rel has finished loading and had its prolog run

include/somewhere.h

@@ -7,7 +7,29 @@
 
 #include <common.h>
 
-extern s32 * unknown_805adf40; // referenced in swdrv.c
-void * unknown_80121f48();
+ // referenced in swdrv.c
+extern s32 * unknown_805adf40;
+
+// referenced in nandmgr.c
+typedef struct {
+    u8 unknown_0x0[0x4 - 0x0];
+    u32 unknown_0x4;
+    u32 unknown_0x8;
+    u8 unknown_0xc[0x38 - 0xc];
+    s8 unknown_0x38;
+    u8 unknown_0x39[0x5c - 0x39];
+    float unknown_0x5c;
+    float unknown_0x60;
+    float unknown_0x64;
+    // unknown size
+} UnkStruct80510458;
+typedef struct {
+    u8 unknown_0x0[0x728 - 0x0];
+    u8 unknown_0x728[0x400];
+} UnkStruct805283e0;
+u16 * unknown_0x8011fa2c();
+UnkStruct80510458 * unknown_0x80121f48();
+void * unknown_0x8014c088();
+UnkStruct805283e0 * unknown_0x801c9adc();
 
 #endif

include/spmario.h

@@ -8,14 +8,31 @@
 #include <common.h>
 
 typedef struct {
-    u8 unknown_0x0[0x4 - 0x0];
+    u32 flags;
     u32 unknown_0x4;
-    u32 language;
-    u8 unknown_0xc[0x10 - 0xc];
+    s32 language;
+    u32 unknown_0xc;
     u32 systemLevelFlags;
-    u8 unknown_0x14[0xf8 - 0x14];
+    u8 unknown_0x14[0x18 - 0x14];
+    u16 framebufferWidth;
+    u16 framebufferHeight;
+    float unknown_0x1c;
+    char saveName[32]; // size needs checking
+    u32 unknown_0x40;
+    char mapName[32];
+    char doorName[32];
+    u8 unknown_0x84[0xc8 - 0x84];
+    s64 lastSaveUpdateTime; // last time save file in memory was written to ()
+    float unknown_0xd0;
+    float unknown_0xd4;
+    float unknown_0xd8;
+    int saveFileId;
+    u32 unknown_0xe0;
+    u8 unknown_0xe4[0xf8 - 0xe4];
     s64 time;
-    u8 unknown_0x100[0x140 - 0x100];
+    u8 unknown_0x100[0x110 - 0x100];
+    s64 lastSaveLoadTime;
+    u8 unknown_0x118[0x140 - 0x118];
     s32 gsw0;
     u32 gswf[256]; // 8192 flags
     s8 gsw[2048];

src/nandmgr.c

@@ -1,8 +1,10 @@
 #include <common.h>
+#include <evtmgr_cmd.h>
 #include <lzss10.h>
 #include <memory.h>
 #include <nand.h>
 #include <nandmgr.h>
+#include <os.h>
 #include <somewhere.h>
 #include <string.h>
 #include <system.h>
@@ -15,7 +17,7 @@ static NandWork * wp = &nandWork;
 
 #include "files/saveImagesTpl.inc" // static const u8 saveImagesTpl[0x5058]
 
-// Register usage not matching, might need nandErase inlined?
+// Register usage not matching, might need nandClearSave inlined?
 void nandInit() {
     memset(wp, 0, sizeof(*wp));
     wp->openingBufferSize = 0x4000;
@@ -86,17 +88,17 @@ void nandMain() {
         case NANDMGR_TASK_WRITE_BANNER:
             nandWriteBannerMain();
             break;
-        case NANDMGR_TASK_WRITE_ALL:
-            nandWriteAllMain();
+        case NANDMGR_TASK_WRITE_ALL_SAVES:
+            nandWriteAllSavesMain();
             break;
-        case NANDMGR_TASK_WRITE:
-            nandWriteMain();
+        case NANDMGR_TASK_WRITE_SAVE:
+            nandWriteSaveMain();
             break;
-        case NANDMGR_TASK_5:
-            nandmgrTask5();
+        case NANDMGR_TASK_WRITE_BANNER_LOAD_ALL_SAVES:
+            nandWriteBannerLoadAllSavesMain();
             break;
-        case NANDMGR_TASK_6:
-            nandmgrTask6();
+        case NANDMGR_TASK_DELETE_SAVE:
+            nandDeleteSaveMain();
             break;
     }
 }
@@ -136,52 +138,52 @@ void nandWriteBanner() {
     wp->saveId = 0;
 }
 
-void nandWriteAll() {
+void nandWriteAllSaves() {
     // "Already running"
     assert(!flag(wp->flag, NAND_FLAG_Exec), "すでに実行中");
     wp->flag = NAND_FLAG_Exec;
-    wp->task = NANDMGR_TASK_WRITE_ALL;
+    wp->task = NANDMGR_TASK_WRITE_ALL_SAVES;
     wp->code = 0;
     wp->stage = 0;
     wp->saveId = 0;
 }
 
-
-void nandWrite(u32 saveId) {
+void nandWriteSave(s32 saveId) {
     // "Already running"
     assert(!flag(wp->flag, NAND_FLAG_Exec), "すでに実行中");
     wp->flag = NAND_FLAG_Exec;
-    wp->task = NANDMGR_TASK_WRITE;
+    wp->task = NANDMGR_TASK_WRITE_SAVE;
     wp->code = 0;
     wp->stage = 0;
     wp->saveId = saveId;
 }
 
-void nandmgrStartTask5() {
+void nandWriteBannerLoadAllSaves() {
     // "Already running"
     assert(!flag(wp->flag, NAND_FLAG_Exec), "すでに実行中");
     wp->flag = NAND_FLAG_Exec;
-    wp->task = NANDMGR_TASK_5;
+    wp->task = NANDMGR_TASK_WRITE_BANNER_LOAD_ALL_SAVES;
     wp->code = 0;
     wp->stage = 0;
     wp->saveId = 0;
 }
 
-void nandmgrStartTask6() {
+void nandDeleteSave(s32 saveId) {
     // "Already running"
     assert(!flag(wp->flag, NAND_FLAG_Exec), "すでに実行中");
     wp->flag = NAND_FLAG_Exec;
-    wp->task = NANDMGR_TASK_6;
+    wp->task = NANDMGR_TASK_DELETE_SAVE;
     wp->code = 0;
     wp->stage = 0;
-    wp->saveId = 0;
+    wp->saveId = 0; // bug
+    (void) saveId;
 }
 
-void nandCopy(s32 sourceId, s32 destId) {
+void nandCopySave(s32 sourceId, s32 destId) {
     memcpy(&wp->saves[destId], &wp->saves[sourceId], sizeof(SaveFile));
 }
 
-void nandErase(s32 saveId) {
+void nandClearSave(s32 saveId) {
     SaveFile * save = &wp->saves[saveId];
     memset(save, 0, sizeof(*save));
     save->flags |= 1;
@@ -196,17 +198,70 @@ void nandErase(s32 saveId) {
     save->checksumNOT = ~checksum;
 }
 
-// void nandUpdateSave(s32 saveId);
-// void nandLoadSave(s32 saveId);
-// void nandmgrSetFlag0x1000();
-// void nandmgrClearFlag0x1000();
-// bool nandmgrCheckFlag0x1000();
+void nandUpdateSave(s32 saveId) {
+    SaveFile * save = &wp->saves[saveId];
+    UnkStruct80510458 * r29 = unknown_0x80121f48();
+    memset(save, 0, sizeof(SaveFile));
+    SpmarioGlobals * _gp = gp; // a sign of inlining?
+    _gp->lastSaveUpdateTime = OSGetTime();
+    _gp->unknown_0xd0 = r29->unknown_0x5c;
+    _gp->unknown_0xd4 = r29->unknown_0x60;
+    _gp->unknown_0xd8 = r29->unknown_0x64;
+    evtSetValue(NULL, GSWF(401), (s32) ((r29->unknown_0x4 >> 21) & 1));
+    evtSetValue(NULL, GSWF(402), (s32) ((r29->unknown_0x4 >> 19) & 1));
+    s32 temp = (*unknown_0x8011fa2c() & 0x80);
+    evtSetValue(NULL, GSWF(403), temp == 0);
+    evtSetValue(NULL, GSWF(404), (s32) ((r29->unknown_0x8 >> 23) & 1));
+    evtSetValue(NULL, GSW(23), r29->unknown_0x38);
+    gp->flags &= ~1;
+    gp->flags &= ~2;
+    gp->flags &= ~4;
+    gp->flags &= ~8;
+    gp->unknown_0xc = 0;
+    gp->unknown_0x1c = 1.0f;
+    memcpy(&save->spmarioGlobals, gp, sizeof(SpmarioGlobals));
+    memcpy(&save->unknown_0x1b10, unknown_0x8014c088(), sizeof(save->unknown_0x1b10));
+    memcpy(&save->unknown_0x21b0, unknown_0x801c9adc()->unknown_0x728, sizeof(save->unknown_0x21b0));
+    save->flags &= ~3;
+    save->checksum = 0;
+    save->checksumNOT = 0xffffffff;
+    u32 checksum = 0;
+    for (int i = 0; i < sizeof(*save); i += 2) {
+        checksum += ((u8 *)save)[i];
+        checksum += ((u8 *)save)[i+1];
+    }
+    save->checksum = checksum;
+    save->checksumNOT = ~checksum;
+}
+
+// Register usage not matching
+void nandLoadSave(s32 saveId) {
+    SaveFile * save = &wp->saves[saveId];
+    s32 language = gp->language;
+    u32 unk4 = gp->unknown_0x4;
+    u32 unk40 = gp->unknown_0x40;
+    memcpy(gp, &save->spmarioGlobals, sizeof(SpmarioGlobals));
+    memcpy(unknown_0x8014c088(), &save->unknown_0x1b10, sizeof(save->unknown_0x1b10));
+    memcpy(unknown_0x801c9adc()->unknown_0x728, &save->unknown_0x21b0, sizeof(save->unknown_0x21b0));
+    gp->unknown_0xc = 0;
+    SpmarioGlobals * _gp = gp; // probably another inline function
+    _gp->lastSaveLoadTime = OSGetTime();
+    _gp->unknown_0x1c = 1.0f;
+    gp->unknown_0x40 = unk40;
+    gp->language = language;
+    gp->unknown_0x4 = unk4;
+    gp->unknown_0xe0 = 0;
+}
+
+// void nandDisableSaving();
+// void nandEnableSaving();
+// bool nandCheckSaving();
 // void nandCheckMain();
 // void nandWriteBannerMain();
-// void nandWriteAllMain();
-// void nandWriteMain();
-// void nandmgrTask5();
-// void nandmgrTask6();
+// void nandWriteAllSavesMain();
+// void nandWriteSaveMain();
+// void nandWriteBannerLoadAllSavesMain();
+// void nandDeleteSaveMain();
 // void genericCallback(s32 result, NANDCommandBlock * commandBlock);
 // void checkCallback(s32 result, NANDCommandBlock * commandBlock);
 

src/relmgr.c

@@ -20,7 +20,7 @@ void relInit() {
     relHolder->loaded = false;
 }
 
-void loadRel() {
+void relMain() {
     char relPath[0x48];
 
     if (relHolder->loaded) return;