falso
/
tp
mirror of https://github.com/zeldaret/tp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

m_Do_MemCard/d_file_select wii/debug work (#2976) 

* m_Do_MemCard/d_file_select wii/debug work

* fix builds
This commit is contained in:
TakaRikka 2025-12-20 18:30:04 -08:00 committed by GitHub
parent 762159a990
commit bd0c601a52
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
16 changed files with 3923 additions and 1778 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
config/RZDE01_00/splits.txt
View File

@ -109,7 +109,7 @@ m_Do/m_Do_dvd_thread.cpp:
.ctors start:0x803CE254 end:0x803CE258
.data start:0x803F6A80 end:0x803F6DC8
.bss start:0x804539E0 end:0x80455D60
.sdata start:0x80537770 end:0x805377B8
.sdata start:0x80537770 end:0x805377B0
m_Do/m_Do_DVDError.cpp:
.text start:0x8001B8E8 end:0x8001BA54
@ -120,6 +120,7 @@ m_Do/m_Do_MemCard.cpp:
.ctors start:0x803CE258 end:0x803CE25C
.data start:0x803F6DC8 end:0x803F6FB8
.bss start:0x804580C0 end:0x8046A3E0
.sdata start:0x805377B0 end:0x805377B8
m_Do/m_Do_MemCardRWmng.cpp:
.text start:0x8001CDAC end:0x8001D9F8

3
configure.py
View File

@ -426,6 +426,9 @@ if config.version != "ShieldD":
else:
cflags_framework.extend(["-inline noauto", "-O3,s", "-sym on", "-str reuse,pool,readonly"])
if config.version in ["RZDE01_00", "RZDE01_02", "RZDP01", "RZDJ01"]:
cflags_framework.extend(["-DSDK_SEP2006"])
# REL flags
cflags_rel = [
*cflags_framework,

4
include/d/d_com_inf_game.h
View File

@ -1216,8 +1216,8 @@ inline void dComIfGs_setCollectClothes(u8 i_clothesNo) {
g_dComIfG_gameInfo.info.getPlayer().getCollect().setCollect(COLLECT_CLOTHING, i_clothesNo);
}
inline void dComIfGs_setCardToMemory(char* card_ptr, int dataNum) {
g_dComIfG_gameInfo.info.card_to_memory(card_ptr, dataNum);
inline void dComIfGs_setCardToMemory(u8* card_ptr, int dataNum) {
g_dComIfG_gameInfo.info.card_to_memory((char*)card_ptr, dataNum);
}
inline void dComIfGs_setRodTypeLevelUp() {

2
include/d/d_file_sel_warning.h
View File

@ -38,7 +38,7 @@ public:
virtual ~dFile_warning_c();
u8 getStatus() { return mStatus; }
BOOL getStatus() { return mStatus != 0; }
void draw() { _draw(); }
/* 0x04 */ JKRArchive* mpArchive;

432
include/d/d_file_select.h
View File

@ -2,6 +2,7 @@
#define D_FILE_D_FILE_SELECT_H
#include "d/d_com_inf_game.h"
#include "m_Do/m_Do_MemCard.h"
#include "d/d_file_sel_warning.h"
#include "d/d_msg_string.h"
#include "d/d_name.h"
@ -15,18 +16,23 @@ public:
void draw();
virtual ~dDlst_FileSel_c() {
delete Scr;
delete mpMessageString;
delete mMessageString;
}
dDlst_FileSel_c() {
mpMessageFont[0] = mDoExt_getMesgFont();
mpMessageFont[1] = mDoExt_getSubFont();
mpMessageString = new dMsgString_c();
font[0] = mDoExt_getMesgFont();
JUT_ASSERT(104, font[0] != NULL);
font[1] = mDoExt_getSubFont();
JUT_ASSERT(107, font[1] != NULL);
mMessageString = new dMsgString_c();
JUT_ASSERT(110, mMessageString != NULL);
}
/* 0x04 */ J2DScreen* Scr;
/* 0x08 */ JUTFont* mpMessageFont[2];
/* 0x0C */ dMsgString_c* mpMessageString;
/* 0x08 */ JUTFont* font[2];
/* 0x0C */ dMsgString_c* mMessageString;
};
class dFile_select3D_c {
@ -51,7 +57,7 @@ public:
void setBasePane(CPaneMgr* paneMgr) { mPaneMgr = paneMgr; }
void setBase2Pane(J2DPane* pane) { mPane = pane; }
/* 0x0004 */ JKRSolidHeap* mpHeap;
/* 0x0004 */ JKRSolidHeap* mpSolidHeap;
/* 0x0008 */ J3DModel* mpModel;
/* 0x000C */ mDoExt_bckAnm* mBckAnm;
/* 0x0010 */ mDoExt_brkAnm* mBrkAnm;
@ -62,8 +68,8 @@ public:
/* 0x03B0 */ csXyz field_0x03b0;
/* 0x03B6 */ u8 padding[2];
/* 0x03B8 */ cXyz field_0x03b8;
/* 0x03C4 */ float field_0x03c4;
/* 0x03C8 */ float field_0x03c8;
/* 0x03C4 */ f32 field_0x03c4;
/* 0x03C8 */ f32 field_0x03c8;
/* 0x03CC */ u8 field_0x03CC[0x03CE - 0x03CC];
/* 0x03CE */ u8 mMirrorIdx;
/* 0x03CF */ u8 mMaskIdx;
@ -94,7 +100,7 @@ public:
virtual ~dDlst_FileSelCp_c() { delete Scr; }
/* 0x04 */ J2DScreen* Scr;
/* 0x08 */ bool field_0x08;
/* 0x08 */ bool isShow;
/* 0x0C */ J2DPane* mpPane1;
/* 0x10 */ J2DPane* mpPane2;
};
@ -107,44 +113,153 @@ public:
/* 0x04 */ J2DScreen* Scr3m;
};
class dFs_HIO_c {
class dFs_HIO_c : public JORReflexible {
public:
dFs_HIO_c();
virtual ~dFs_HIO_c() {}
void genMessage(JORMContext*);
/* 0x0000 */ // void* vtable;
/* 0x0004 */ s8 field_0x0004;
/* 0x0005 */ u8 field_0x0005;
/* 0x0006 */ u8 field_0x0006;
/* 0x0007 */ u8 field_0x0007;
/* 0x0008 */ u8 field_0x0008;
/* 0x0009 */ u8 field_0x0009;
/* 0x0004 */ s8 no;
/* 0x0005 */ u8 select_icon_appear_frames;
/* 0x0006 */ u8 base_effect_appear_frames;
/* 0x0007 */ u8 char_switch_frames;
/* 0x0008 */ u8 select_box_appear_frames;
/* 0x0009 */ u8 copy_erase_frames;
/* 0x000A */ u8 field_0x000a;
/* 0x000B */ u8 field_0x000b;
/* 0x000C */ u8 field_0x000c;
/* 0x000B */ u8 appear_display_wait_frames;
/* 0x000C */ u8 card_wait_frames;
/* 0x000D */ u8 field_0x000d;
/* 0x000E */ u8 field_0x000e[2];
/* 0x0010 */ float field_0x0010[3];
/* 0x0010 */ f32 test_frame_counts[3];
#if VERSION == VERSION_GCN_PAL
u8 temp_padding[0x1D];
#endif
/* 0x001C */ u8 field_0x001c;
/* 0x001D */ u8 field_0x001d;
/* 0x001E */ u8 field_0x001e;
/* 0x001F */ u8 field_0x001f;
/* 0x0020 */ u8 field_0x0020;
/* 0x0021 */ u8 field_0x0021;
/* 0x0022 */ u8 field_0x0022;
/* 0x001C */ u8 title_mesg_check;
/* 0x001D */ u8 title_msg_check_sel;
/* 0x001E */ u8 error_mesg_check;
/* 0x001F */ u8 error_msg_check_sel;
/* 0x0020 */ u8 mask_mirror_test_display;
/* 0x0021 */ u8 test_mask_display;
/* 0x0022 */ u8 test_mirror_display;
/* 0x0023 */ u8 field_0x0023;
};
// Trying to define this using dSv_save_c causes alignment issues
typedef char SaveData[0xa94];
typedef u8 SaveDataBuf[SAVEDATA_SIZE];
class dFile_select_c {
public:
typedef void (dFile_select_c::*DispFunc)();
enum DataSelProc_e {
DATASELPROC_MEMCARD_CHECK_MAIN,
DATASELPROC_DATA_SELECT_IN,
DATASELPROC_DATA_SELECT_INIT,
DATASELPROC_DATA_SELECT,
DATASELPROC_DATA_SELECT_MOVE_ANIME,
DATASELPROC_SELECT_DATA_OPEN_MOVE,
DATASELPROC_SELECT_DATA_NAME_MOVE,
DATASELPROC_SELECT_DATA_OPENERASE_MOVE,
DATASELPROC_MENU_SELECT,
DATASELPROC_MENU_SELECT_MOVE_ANM,
DATASELPROC_TO_NAME_MOVE,
DATASELPROC_TO_COPY_PANE_MOVE,
DATASELPROC_TO_ERASE_PANE_MOVE,
DATASELPROC_BACK_SELECT_MOVE,
DATASELPROC_NAME_TO_DATA_SELECT_MOVE,
DATASELPROC_NAME_INPUT_WAIT,
DATASELPROC_NAME_INPUT,
DATASELPROC_NAME_INPUT_FADE,
DATASELPROC_NAME_INPUT2_MOVE,
DATASELPROC_NAME_INPUT2,
DATASELPROC_BACK_NAME_INPUT_MOVE0,
DATASELPROC_BACK_NAME_INPUT_MOVE,
DATASELPROC_COPY_DATA_TO_SELECT,
DATASELPROC_COPY_DATA_TO_SELECT_MOVE_ANM,
DATASELPROC_COPY_TO_SEL_BACK,
DATASELPROC_COPY_TO_SEL_PANE_MOVE,
DATASELPROC_YES_NO_SELECT,
DATASELPROC_YES_NO_CANCEL_MOVE,
DATASELPROC_YES_NO_CURSOR_MOVE_ANM,
DATASELPROC_CMD_EXEC_PANE_MOVE0,
DATASELPROC_COMMAND_EXEC,
DATASELPROC_DATA_ERASE_WAIT,
DATASELPROC_DATA_ERASE_WAIT2,
DATASELPROC_DATA_COPY_WAIT,
DATASELPROC_DATA_COPY_WAIT2,
DATASELPROC_COPY_PANE_MOVE_OK,
DATASELPROC_COPY_PANE_MOVE_OK2,
DATASELPROC_ERASE_PANE_MOVE_OK,
DATASELPROC_ERASE_PANE_MOVE_OK2,
DATASELPROC_ERROR_MSG_PANE_MOVE,
DATASELPROC_ERASE_END_BACK_SELECT_WAIT,
DATASELPROC_ERASE_END_BACK_SELECT,
DATASELPROC_BACK_DAT_SEL_WAIT,
DATASELPROC_BACK_DAT_SEL_WAIT2,
DATASELPROC_BACK_DAT_SEL_PANE_MOVE,
DATASELPROC_TO_NAME_MOVE2,
DATASELPROC_NEXT_MODE_WAIT,
#if PLATFORM_WII || PLATFORM_SHIELD
DATASELPROC_DATA_SELECT_IN_COPY,
DATASELPROC_CARD_TO_NAND_DATA_COPY,
DATASELPROC_CARD_TO_NAND_DATA_COPY_WAIT,
DATASELPROC_CARD_TO_NAND_DATA_COPY_WAIT2,
DATASELPROC_CARD_TO_NAND_DATA_COPY_OK_DISP,
DATASELPROC_CARD_TO_NAND_DATA_COPY_OK_DISP2,
DATASELPROC_CARD_TO_NAND_DATA_COPY_OK_DISP3,
DATASELPROC_CARD_TO_NAND_DATA_COPY_ERR_DISP,
DATASELPROC_CARD_TO_NAND_DATA_COPY_ERR_DISP2,
DATASELPROC_CARD_TO_NAND_DATA_COPY_ERR_DISP3,
#endif
};
enum MemCardCheckProc_e {
MEMCARDCHECKPROC_STAT_CHECK,
MEMCARDCHECKPROC_LOAD_WAIT,
MEMCARDCHECKPROC_ERRMSG_WAIT_KEY,
MEMCARDCHECKPROC_NO_SAVE_SEL_DISP,
MEMCARDCHECKPROC_ERRMSG_WAIT_NO_SAVE_SEL,
MEMCARDCHECKPROC_ERRMSG_WAIT_FORMAT_SEL,
MEMCARDCHECKPROC_FORMAT_YES_SEL_DISP,
MEMCARDCHECKPROC_FORMAT_NO_SEL_DISP,
MEMCARDCHECKPROC_ERRMSG_WAIT_FORMAT_SEL2,
MEMCARDCHECKPROC_FORMAT_YES_SEL2_DISP,
MEMCARDCHECKPROC_FORMAT,
MEMCARDCHECKPROC_FORMAT_WAIT,
MEMCARDCHECKPROC_FORMAT_CHECK,
MEMCARDCHECKPROC_MAKE_GAMEFILE_SEL,
MEMCARDCHECKPROC_MAKE_GAMEFILE_SEL_DISP,
MEMCARDCHECKPROC_MAKE_GAMEFILE,
MEMCARDCHECKPROC_MAKE_GAMEFILE_WAIT,
MEMCARDCHECKPROC_MAKE_GAMEFILE_CHECK,
MEMCARDCHECKPROC_NO_FILESPACE_DISP,
MEMCARDCHECKPROC_GOTO_IPL_SELECT_DISP,
MEMCARDCHECKPROC_GOTO_IPL_SELECT,
MEMCARDCHECKPROC_GOTO_IPL,
MEMCARDCHECKPROC_MSG_WINDOW_INIT_OPEN,
MEMCARDCHECKPROC_MSG_WINDOW_OPEN,
MEMCARDCHECKPROC_MSG_WINDOW_CLOSE,
MEMCARDCHECKPROC_ERR_YESNO_CURSOR_MOVE_ANM,
MEMCARDCHECKPROC_SAVEDATA_CLEAR,
#if PLATFORM_WII || PLATFORM_SHIELD
MEMCARDCHECKPROC_NAND_STAT_CHECK,
MEMCARDCHECKPROC_GAMEFILE_INIT_SEL,
MEMCARDCHECKPROC_GAMEFILE_INIT_SEL_DISP,
MEMCARDCHECKPROC_GAMEFILE_INIT,
MEMCARDCHECKPROC_GAMEFILE_INIT_CHECK,
MEMCARDCHECKPROC_LOAD_WAIT_CARD,
MEMCARDCHECKPROC_CARD_DATA_COPY_SEL,
MEMCARDCHECKPROC_CARD_DATA_COPY_SEL2_DISP,
MEMCARDCHECKPROC_CARD_DATA_COPY_SEL2,
MEMCARDCHECKPROC_LOAD_WAIT_NAND,
MEMCARDCHECKPROC_LOAD_NAND_FILE,
#endif
};
dFile_select_c(JKRArchive*);
virtual ~dFile_select_c();
void _create();
@ -303,9 +418,43 @@ public:
void setInitSaveData();
void dataSave();
#if PLATFORM_WII || PLATFORM_SHIELD
bool GCtoWiiTimeConvert();
void dataSelectInCopy();
void cardToNandDataCopy();
void cardToNandDataCopyWait();
void cardToNandDataCopyWait2();
void cardToNandDataCopyOkDisp();
void cardToNandDataCopyOkDisp2();
void cardToNandDataCopyOkDisp3();
void cardToNandDataCopyErrDisp();
void cardToNandDataCopyErrDisp2();
void cardToNandDataCopyErrDisp3();
void loadFileNAND();
void errDispInitSet(char*);
void nandStatCheck();
void MemCardLoadWaitCard();
void cardDataCopySel();
void cardDataCopySel2Disp();
void cardDataCopySel2();
void cardDataCopyNoSelect();
void loadWaitNand();
void loadNandFile();
void gameFileInitSel();
void gameFileInitSelDisp();
void gameFileInit();
void gameFileInitCheck();
void saveDataClearInit();
#endif
#if DEBUG
void titleMsgCheck();
void errorMsgCheck();
#endif
bool getFadeFlag() { return mFadeFlag; }
int isDataNew(u8 i) { return mDataNew[i]; }
int isSelectEnd() { return mSelectEnd; }
int isDataNew(u8 i) { return mIsDataNew[i]; }
int isSelectEnd() { return mIsSelectEnd; }
u8 getSelectNum() { return mSelectNum; }
void setUseType(u8 type) { mUseType = type; }
@ -322,114 +471,114 @@ public:
/* 0x0064 */ dSelect_cursor_c* mSelIcon2;
/* 0x0068 */ dName_c* mpName;
/* 0x006C */ dFile_warning_c* mpFileWarning;
/* 0x0070 */ dFile_info_c* field_0x0070[3];
/* 0x007C */ dFile_info_c* mpFileInfo[2];
/* 0x0084 */ J2DAnmTransform* field_0x0084;
/* 0x0070 */ dFile_info_c* mFileInfo[3];
/* 0x007C */ dFile_info_c* mCpFileInfo[2];
/* 0x0084 */ J2DAnmTransform* mBaseMoveAnm;
/* 0x0088 */ J2DAnmTransform* field_0x0088;
/* 0x008C */ J2DAnmTransform* field_0x008c;
/* 0x008C */ J2DAnmTransform* mYnSelBck3;
/* 0x0090 */ J2DAnmTransform* field_0x0090;
/* 0x0094 */ J2DAnmTransform* field_0x0094;
/* 0x0098 */ J2DAnmTransform* field_0x0098;
/* 0x009C */ J2DAnmTransform* field_0x009c;
/* 0x00A0 */ s32 field_0x00a0;
/* 0x00A4 */ CPaneMgr* field_0x00a4;
/* 0x00A4 */ CPaneMgr* mBaseMovePane;
/* 0x00A8 */ u8 field_0x00a8[0xb0-0xa8];
/* 0x00B0 */ s32 field_0x00b0;
/* 0x00B4 */ s32 field_0x00b4;
/* 0x00B0 */ s32 mBaseMoveAnmFrame;
/* 0x00B4 */ s32 mBaseMoveAnmFrameMax;
/* 0x00B8 */ u8 field_0x00b8;
/* 0x00B9 */ u8 field_0x00b9;
/* 0x00BA */ u8 field_0x00ba;
/* 0x00BB */ u8 field_0x00bb;
/* 0x00BC */ CPaneMgr* field_0x00bc[3];
/* 0x00BC */ CPaneMgr* mSelFilePanes[3];
/* 0x00C8 */ f32 field_0x00c8[3];
/* 0x00D4 */ f32 field_0x00d4[3];
/* 0x00E0 */ s32 field_0x00e0[3];
/* 0x00EC */ s32 field_0x00ec;
/* 0x00F0 */ CPaneMgr* field_0x00f0[2];
/* 0x00F0 */ CPaneMgr* mYnSelPane[2];
/* 0x00F8 */ s32 field_0x00f8[2];
/* 0x0100 */ s32 field_0x0100;
/* 0x0104 */ s32 field_0x0104;
/* 0x0108 */ bool field_0x0108;
/* 0x0109 */ bool field_0x0109;
/* 0x010A */ u8 field_0x10a[2];
/* 0x010C */ J2DPane* mpPane;
/* 0x010C */ J2DPane* mBaseSubPane;
/* 0x0110 */ int field_0x0110;
/* 0x0114 */ int field_0x0114;
/* 0x0118 */ J2DPane* field_0x0118;
/* 0x011C */ J2DPane* field_0x011c;
/* 0x0118 */ J2DPane* m3mMenuPane;
/* 0x011C */ J2DPane* mNameBasePane;
/* 0x0120 */ int field_0x0120;
/* 0x0124 */ int field_0x0124;
/* 0x0128 */ bool field_0x0128;
/* 0x0129 */ u8 field_0x0129[0x012C - 0x0129];
/* 0x012C */ J2DPane* field_0x012c;
/* 0x012C */ J2DPane* mErrorMsgPane;
/* 0x0130 */ int field_0x0130;
/* 0x0134 */ int field_0x0134;
/* 0x0138 */ CPaneMgrAlpha* field_0x0138[2];
/* 0x0140 */ char* field_0x0140[2];
/* 0x0148 */ u8 field_0x0148;
/* 0x0138 */ CPaneMgrAlpha* mErrorMsgTxtPane[2];
/* 0x0140 */ char* mErrorMsgStringPtr[2];
/* 0x0148 */ u8 mErrorTxtDispIdx;
/* 0x0149 */ u8 field_0x0149;
/* 0x014A */ bool field_0x014a;
/* 0x014B */ bool field_0x014b;
/* 0x014C */ CPaneMgrAlpha* field_0x014c[3];
/* 0x0158 */ CPaneMgrAlpha* field_0x0158[3];
/* 0x0164 */ CPaneMgr* field_0x0164[3];
/* 0x0170 */ CPaneMgr* field_0x0170[3];
/* 0x017C */ CPaneMgr* field_0x017c[3];
/* 0x0188 */ CPaneMgr* field_0x0188[3];
/* 0x014C */ CPaneMgrAlpha* mDeleteEfPane[3];
/* 0x0158 */ CPaneMgrAlpha* mCopyEfPane[3];
/* 0x0164 */ CPaneMgr* mSelFileMoyoPane[3];
/* 0x0170 */ CPaneMgr* mSelFileGoldPane[3];
/* 0x017C */ CPaneMgr* mSelFileGold2Pane[3];
/* 0x0188 */ CPaneMgr* mSelFilePane_Book_l[3];
/* 0x0194 */ u8 field_0x0194[3];
/* 0x0197 */ u8 field_0x0197[3];
/* 0x019A */ u8 field_0x019a[3];
/* 0x019D */ u8 field_0x019d[3];
/* 0x01A0 */ CPaneMgrAlpha* field_0x01a0[2];
/* 0x01A8 */ CPaneMgrAlpha* field_0x01a8[2];
/* 0x01B0 */ CPaneMgrAlpha* field_0x01b0[2];
/* 0x01A0 */ CPaneMgrAlpha* mYnSelPane_m[2];
/* 0x01A8 */ CPaneMgrAlpha* mYnSelPane_g[2];
/* 0x01B0 */ CPaneMgrAlpha* mYnSelPane_gr[2];
/* 0x01B8 */ u8 field_0x01b8[2];
/* 0x01BA */ u8 field_0x01ba[2];
/* 0x01BC */ u8 field_0x01bc[2];
/* 0x01BE */ u8 field_0x01be[2];
/* 0x01C0 */ CPaneMgr* field_0x01c0[2];
/* 0x01C8 */ J2DAnmColor* field_0x01c8;
/* 0x01CC */ s32 field_0x01cc;
/* 0x01D0 */ J2DAnmTextureSRTKey* field_0x01d0;
/* 0x01D4 */ s32 field_0x01d4;
/* 0x01D8 */ J2DAnmColor* field_0x01d8;
/* 0x01DC */ s32 field_0x01dc;
/* 0x01E0 */ J2DAnmTextureSRTKey* field_0x01e0;
/* 0x01E4 */ s32 field_0x01e4;
/* 0x01E8 */ J2DAnmTevRegKey* field_0x01e8;
/* 0x01EC */ s32 field_0x01ec;
/* 0x01F0 */ J2DAnmTextureSRTKey* field_0x01f0;
/* 0x01F4 */ s32 field_0x01f4;
/* 0x01F8 */ J2DAnmTextureSRTKey* field_0x01f8;
/* 0x01FC */ s32 field_0x01fc;
/* 0x0200 */ J2DAnmTevRegKey* field_0x0200;
/* 0x0204 */ s32 field_0x0204;
/* 0x01C0 */ CPaneMgr* mYnSelTxtPane[2];
/* 0x01C8 */ J2DAnmColor* mFileSelBpk;
/* 0x01CC */ s32 mSelFileBpkFrame;
/* 0x01D0 */ J2DAnmTextureSRTKey* mFileSel05Btk;
/* 0x01D4 */ s32 mSelFileBtk05Frame;
/* 0x01D8 */ J2DAnmColor* mSelFileBookBpk;
/* 0x01DC */ s32 mSelFileBookBpkFrame;
/* 0x01E0 */ J2DAnmTextureSRTKey* mSelFileBookBtk;
/* 0x01E4 */ s32 mSelFileBookBtkFrame;
/* 0x01E8 */ J2DAnmTevRegKey* mSelFileBookBrk;
/* 0x01EC */ s32 mSelFileBookBrkFrame;
/* 0x01F0 */ J2DAnmTextureSRTKey* mDtEffBtk;
/* 0x01F4 */ s32 mDtEffBtkFrame;
/* 0x01F8 */ J2DAnmTextureSRTKey* mCpEffBtk;
/* 0x01FC */ s32 mCpEffBtkFrame;
/* 0x0200 */ J2DAnmTevRegKey* mCpDtEffBrk;
/* 0x0204 */ s32 mCpDtEffBrkFrame;
/* 0x0208 */ u8 field_0x0208;
/* 0x0209 */ u8 field_0x0209;
/* 0x020A */ u8 field_0x020a;
/* 0x020A */ u8 mFadeTimer;
/* 0x020B */ u8 field_0x020b;
/* 0x020C */ CPaneMgrAlpha* field_0x020c[2];
/* 0x0214 */ char* field_0x0214[2];
/* 0x021C */ u8 field_0x021c;
/* 0x020C */ CPaneMgrAlpha* mHeaderTxtPane[2];
/* 0x0214 */ char* mHeaderStringPtr[2];
/* 0x021C */ u8 mHeaderTxtDispIdx;
/* 0x021D */ u8 field_0x021d;
/* 0x021E */ u8 field_0x021e;
/* 0x021F */ u8 field_0x021f;
/* 0x0220 */ CPaneMgrAlpha* field_0x0220[3];
/* 0x022C */ CPaneMgrAlpha* field_0x022c[3];
/* 0x0238 */ CPaneMgrAlpha* field_0x0238;
/* 0x023C */ CPaneMgrAlpha* field_0x023c;
/* 0x0240 */ CPaneMgrAlpha* field_0x0240;
/* 0x0244 */ CPaneMgrAlpha* field_0x0244;
/* 0x0220 */ CPaneMgrAlpha* mFileInfoDatBasePane[3];
/* 0x022C */ CPaneMgrAlpha* mFileInfoNoDatBasePane[3];
/* 0x0238 */ CPaneMgrAlpha* mBbtnPane;
/* 0x023C */ CPaneMgrAlpha* mAbtnPane;
/* 0x0240 */ CPaneMgrAlpha* mModoruTxtPane;
/* 0x0244 */ CPaneMgrAlpha* mKetteiTxtPane;
/* 0x024A */ bool field_0x0248;
/* 0x024A */ bool field_0x0249;
/* 0x024A */ u8 field_0x024a;
/* 0x024B */ u8 field_0x024b;
/* 0x024C */ u8 field_0x024c;
/* 0x024B */ u8 field_0x024d[3];
/* 0x0250 */ char* field_0x0250;
/* 0x0254 */ STControl* mStick;
/* 0x0258 */ u8 mDataNew[3];
/* 0x025B */ u8 field_0x025b[3];
/* 0x0250 */ char* mModoruStringPtr;
/* 0x0254 */ STControl* stick;
/* 0x0258 */ u8 mIsDataNew[3];
/* 0x025B */ u8 mIsNoData[3];
/* 0x025C */ u8 field_0x025e[0x0264 - 0x025e];
/* 0x0264 */ u8 mLastSelectNum; // previously selected quest log
/* 0x0265 */ u8 mSelectNum; // currently selected quest log
@ -437,88 +586,95 @@ public:
/* 0x0267 */ u8 mSelectMenuNum; // currently selected menu number (for copy / start / delete)
/* 0x0268 */ u8 field_0x0268;
/* 0x0269 */ u8 field_0x0269;
/* 0x026A */ u8 field_0x026a;
/* 0x026A */ u8 mCpDataNum;
/* 0x026B */ u8 field_0x026b;
/* 0x026C */ u8 field_0x026c;
/* 0x026D */ u8 field_0x026d;
/* 0x026E */ u8 field_0x026e;
/* 0x026F */ u8 field_0x026f;
/* 0x0270 */ bool mSelectEnd;
/* 0x0271 */ u8 field_0x0271;
/* 0x026D */ u8 mCpDataToNum;
/* 0x026E */ u8 mCommand;
/* 0x026F */ u8 mDataSelProc;
/* 0x0270 */ bool mIsSelectEnd;
/* 0x0271 */ u8 mCardCheckProc;
/* 0x0272 */ u8 field_0x0272;
/* 0x0273 */ u8 field_0x0273;
/* 0x0274 */ u8 field_0x0274;
/* 0x0273 */ u8 mNextCardCheckProc;
/* 0x0274 */ u8 mKeyWaitCardCheckProc;
/* 0x0272 */ u8 field_0x0275[0x0280 - 0x0275];
/* 0x0281 */ bool field_0x0280;
/* 0x0281 */ bool field_0x0281;
/* 0x0282 */ bool field_0x0282;
/* 0x0283 */ bool field_0x0283;
/* 0x0284 */ DispFunc field_0x0284;
/* 0x0290 */ DispFunc field_0x0290;
/* 0x029C */ J2DAnmTransform* field_0x029c;
/* 0x02A0 */ J2DAnmTransform* field_0x02a0;
/* 0x02A4 */ CPaneMgr* field_0x02a4[3];
/* 0x0284 */ DispFunc mWindowCloseMsgDispCb;
/* 0x0290 */ DispFunc mKeyWaitMsgDispCb;
/* 0x029C */ J2DAnmTransform* mCpSelBck;
/* 0x02A0 */ J2DAnmTransform* mCpSelBck2;
/* 0x02A4 */ CPaneMgr* mCpSelPane[3];
/* 0x02B0 */ u8 field_0x02b0[0x2b4-0x2b0];
/* 0x02B4 */ int field_0x02b4[3];
/* 0x02C0 */ CPaneMgr* field_0x02c0[2];
/* 0x02C8 */ CPaneMgr* field_0x02c8[2];
/* 0x02D0 */ CPaneMgr* field_0x02d0[2];
/* 0x02D8 */ CPaneMgr* field_0x02d8[2];
/* 0x02C0 */ CPaneMgr* mCpSelPane_moyo[2];
/* 0x02C8 */ CPaneMgr* mCpSelPane_gold[2];
/* 0x02D0 */ CPaneMgr* mCpSelPane_gold2[2];
/* 0x02D8 */ CPaneMgr* mCpSelPane_book[2];
/* 0x02E0 */ u8 field_0x02e0[2];
/* 0x02E2 */ u8 field_0x02e2[2];
/* 0x02E4 */ u8 field_0x02e4[2];
/* 0x02E4 */ u8 field_0x02e6[0x2e8-0x2e6];
/* 0x02E8 */ J2DAnmColor* field_0x02e8;
/* 0x02EC */ s32 field_0x02ec;
/* 0x02F0 */ J2DAnmTextureSRTKey* field_0x02f0;
/* 0x02F4 */ s32 field_0x02f4;
/* 0x02F8 */ J2DAnmColor* field_0x02f8;
/* 0x02FC */ s32 field_0x02fc;
/* 0x0300 */ J2DAnmTextureSRTKey* field_0x0300;
/* 0x0304 */ s32 field_0x0304;
/* 0x0308 */ J2DAnmTevRegKey* field_0x0308;
/* 0x030C */ s32 field_0x030c;
/* 0x0310 */ J2DAnmTransform* field_0x0310;
/* 0x0314 */ J2DAnmTransform* field_0x0314;
/* 0x0318 */ J2DAnmColor* field_0x0318;
/* 0x031C */ s32 field_0x031c;
/* 0x0320 */ J2DAnmTextureSRTKey* field_0x0320;
/* 0x0324 */ s32 field_0x0324;
/* 0x0328 */ J2DAnmTransform* field_0x0328;
/* 0x032C */ J2DAnmTransform* field_0x032c;
/* 0x0330 */ J2DAnmColor* field_0x0330;
/* 0x0334 */ s32 field_0x0334;
/* 0x0338 */ J2DAnmTextureSRTKey* field_0x0338;
/* 0x033C */ s32 field_0x033c;
/* 0x0340 */ CPaneMgr* field_0x0340[3];
/* 0x02E8 */ J2DAnmColor* mCpSelBpk;
/* 0x02EC */ s32 mCpSelBpkFrame;
/* 0x02F0 */ J2DAnmTextureSRTKey* mCpSel03Btk;
/* 0x02F4 */ s32 mCpSel03BtkFrame;
/* 0x02F8 */ J2DAnmColor* mCpSelBookBpk;
/* 0x02FC */ s32 mCpSelBookBpkFrame;
/* 0x0300 */ J2DAnmTextureSRTKey* mCpSelBookBtk;
/* 0x0304 */ s32 mCpSelBookBtkFrame;
/* 0x0308 */ J2DAnmTevRegKey* mCpSelBookBrk;
/* 0x030C */ s32 mCpSelBookBrkFrame;
/* 0x0310 */ J2DAnmTransform* mYnSelBck;
/* 0x0314 */ J2DAnmTransform* mYnSelBck2;
/* 0x0318 */ J2DAnmColor* mYnSelBpk;
/* 0x031C */ s32 mYnSelBpkFrame;
/* 0x0320 */ J2DAnmTextureSRTKey* mYnSelBtk;
/* 0x0324 */ s32 mYnSelBtkFrame;
/* 0x0328 */ J2DAnmTransform* m3mBck;
/* 0x032C */ J2DAnmTransform* m3mBck2;
/* 0x0330 */ J2DAnmColor* m3mBpk;
/* 0x0334 */ s32 m3mBpkFrame;
/* 0x0338 */ J2DAnmTextureSRTKey* m3mBtk;
/* 0x033C */ s32 m3mBtkFrame;
/* 0x0340 */ CPaneMgr* m3mSelPane[3];
/* 0x034C */ s32 field_0x034c[3];
/* 0x0358 */ int field_0x0358;
/* 0x035C */ int field_0x035c;
/* 0x0360 */ bool field_0x0360;
/* 0x0361 */ u8 field_0x0361[3];
/* 0x0364 */ CPaneMgr* mpPaneAlpha1[3];
/* 0x0370 */ CPaneMgr* mpPaneAlpha2[3];
/* 0x037C */ CPaneMgr* mpPaneAlpha3[3];
/* 0x0364 */ CPaneMgr* m3mSelPane_mo[3];
/* 0x0370 */ CPaneMgr* m3mSelPane_g[3];
/* 0x037C */ CPaneMgr* m3mSelPane_gr[3];
/* 0x0388 */ u8 field_0x0388[3];
/* 0x038B */ u8 field_0x038b[3];
/* 0x038E */ u8 field_0x038e[3];
/* 0x0390 */ u8 field_0x0391[3];
/* 0x0394 */ CPaneMgr* mpPaneMgr2[3];
/* 0x03A0 */ J2DAnmTextureSRTKey* field_0x03a0;
/* 0x03A4 */ s32 field_0x03a4;
/* 0x03A8 */ CPaneMgr* field_0x03a8;
/* 0x03AC */ s16 field_0x03ac;
/* 0x0394 */ CPaneMgr* m3mSelTextPane[3];
/* 0x03A0 */ J2DAnmTextureSRTKey* mSelDtBtk;
/* 0x03A4 */ s32 mSelDtBtkFrame;
/* 0x03A8 */ CPaneMgr* mSelDtPane_mset;
/* 0x03AC */ s16 mWaitTimer;
/* 0x03AE */ u8 field_0x03AE[0x03B0 - 0x03AE];
/* 0x03B0 */ u8 mUseType;
/* 0x03B1 */ u8 field_0x03b1;
/* 0x03B2 */ u16 field_0x03b2;
/* 0x03B4 */ s32 field_0x03b4;
/* 0x03B8 */ SaveData mSave[3];
/* 0x0D10 */ //u8 field_0x0D10[0x2374 - 0xD10];
/* 0x03B8 */ SaveDataBuf mSaveData[SAVEDATA_NUM];
/* 0x2374 */ bool mFadeFlag;
/* 0x2375 */ bool mHasDrawn;
/* 0x2376 */ u8 field_0x2376[0x2378 - 0x2376];
/* 0x2378 */ J2DPicture* field_0x2378;
#if PLATFORM_GCN
/* 0x2378 */ J2DPicture* mpFadePict;
#endif
#if PLATFORM_WII || PLATFORM_SHIELD
/* 0x2376 */ u8 field_0x2376[SAVEFILE_SIZE];
/* 0x4332 */ u8 field_0x4332;
/* 0x4333 */ u8 field_0x4333;
#endif
};
STATIC_ASSERT(sizeof(dFile_select_c) == 0x237C);

1
include/d/d_save.h
View File

@ -469,6 +469,7 @@ class dSv_player_info_c {
public:
void init();
char* getLinkName() { return mPlayerName; }
const char* getPlayerName() const { return mPlayerName; }
char* getHorseName() { return mHorseName; }
void setPlayerName(const char* i_name) { strcpy((char*)mPlayerName, i_name); }
void setHorseName(const char* i_name) { strcpy((char*)mHorseName, i_name); }

77
include/m_Do/m_Do_MemCard.h
View File

@ -5,10 +5,13 @@
#include <dolphin/os.h>
#include "global.h"
#define SAVEDATA_SIZE 0xA94
#define SECTOR_SIZE 0x2000
#define SAVEDATA_FILE_SIZE 0x8000
#define SAVEDATA_VERSION 6
#define SAVEDATA_SIZE 0xA94 // Size of 1 Quest Log
#define SAVEDATA_NUM 3 // Max number of Quest Logs
#define SECTOR_SIZE 0x2000 // MemCard sector size
#define CARD_FILE_SIZE 0x8000 // MemCard file size
#define SAVEDATA_VERSION 6 // Save Data version
#define SAVEFILE_SIZE (SAVEDATA_SIZE * SAVEDATA_NUM)
class mDoMemCd_Ctrl_c {
public:
@ -19,6 +22,12 @@ public:
COMM_FORMAT_e,
COMM_ATTACH_e,
COMM_DETACH_e,
#if PLATFORM_WII || PLATFORM_SHIELD
COMM_RESTORE_NAND_e,
COMM_STORE_NAND_e,
COMM_STORE_SETUP_NAND_e,
#endif
};
enum CardState_e {
@ -38,6 +47,20 @@ public:
CARD_STATE_13_e,
};
enum NANDState_e {
NAND_STATE_AUTHENTICATION_e,
NAND_STATE_READY_e,
NAND_STATE_NO_FILE_e,
NAND_STATE_READ_e,
NAND_STATE_WRITE_e,
NAND_STATE_FORMAT_e,
NAND_STATE_BROKEN_e,
NAND_STATE_INSSPACE_e,
NAND_STATE_NOENT_e,
NAND_STATE_FATAL_ERROR_e,
NAND_STATE_10_e,
};
mDoMemCd_Ctrl_c();
void ThdInit();
@ -61,6 +84,20 @@ public:
s32 checkspace();
void setCardState(s32);
#if PLATFORM_WII || PLATFORM_SHIELD
void loadNAND();
void restoreNAND();
s32 LoadSyncNAND(void* i_buffer, u32 i_size, u32 i_position);
void saveNAND(void* i_buffer, u32 i_size, u32 i_position);
void storeNAND();
s32 SaveSyncNAND();
void storeSetUpNAND();
void setNandState(s32);
u32 getStatusNAND();
s32 chekNANDFile();
s32 checkspaceNAND();
#endif
bool isCardCommNone() { return mCardCommand == COMM_NONE_e; }
u8 getProbeStat() { return mProbeStat; }
void clearProbeStat() { mProbeStat = 2; }
@ -75,7 +112,7 @@ public:
mSerialNo = serial_no;
}
/* 0x0000 */ u8 mData[SAVEDATA_SIZE * 3];
/* 0x0000 */ u8 mData[SAVEFILE_SIZE];
/* 0x1FBC */ u8 mChannel;
/* 0x1FBD */ u8 mCopyToPos;
/* 0x1FBE */ u8 mProbeStat;
@ -84,7 +121,7 @@ public:
/* 0x1FC8 */ s32 field_0x1fc8;
/* 0x1FCC */ OSMutex mMutex;
/* 0x1FE4 */ OSCond mCond;
/* 0x1FEC */ u32 mNandState;
/* 0x1FEC */ s32 mNandState;
/* 0x1FF0 */ u64 mSerialNo;
/* 0x1FF8 */ u32 mDataVersion;
}; // Size: 0x2000
@ -135,7 +172,7 @@ inline void mDoMemCd_setCopyToPos(u8 i_pos) {
g_mDoMemCd_control.setCopyToPos(i_pos);
}
inline u32 mDoMemCd_getStatus(u8 param_0) {
inline u32 mDoMemCd_getStatus(u32 param_0) {
return g_mDoMemCd_control.getStatus(param_0);
}
@ -167,4 +204,30 @@ inline void mDoMemCd_UpDate() {
g_mDoMemCd_control.update();
}
#if PLATFORM_WII || PLATFORM_SHIELD
inline void mDoMemCd_saveNAND(void* data, u32 length, u32 position) {
g_mDoMemCd_control.saveNAND(data, length, position);
}
inline s32 mDoMemCd_SaveSyncNAND() {
return g_mDoMemCd_control.SaveSyncNAND();
}
inline u32 mDoMemCd_LoadSyncNAND(void* i_buffer, u32 i_size, u32 i_position) {
return g_mDoMemCd_control.LoadSyncNAND(i_buffer, i_size, i_position);
}
inline u32 mDoMemCd_getStatusNAND() {
return g_mDoMemCd_control.getStatusNAND();
}
inline void mDoMemCd_LoadNAND() {
g_mDoMemCd_control.loadNAND();
}
inline s32 mDoMemCd_checkNANDFile() {
return g_mDoMemCd_control.chekNANDFile();
}
#endif
#endif /* M_DO_M_DO_MEMCARD_H */

11
include/m_Do/m_Do_MemCardRWmng.h
View File

@ -1,8 +1,13 @@
#ifndef M_DO_M_DO_MEMCARDRWMNG_H
#define M_DO_M_DO_MEMCARDRWMNG_H
#include "global.h"
#include <dolphin/card.h>
#if PLATFORM_WII || PLATFORM_SHIELD
#include <revolution/nand.h>
#endif
struct mDoMemCdRWm_HeaderData {
/* 0x0000 */ u8 mBannerTexData[0xC00];
/* 0x0C00 */ u8 mBannerPalData[0x200];
@ -26,4 +31,10 @@ static u64 mDoMemCdRWm_CalcCheckSumGameData(void* data, u32 size);
BOOL mDoMemCdRWm_TestCheckSumGameData(void* data);
void mDoMemCdRWm_SetCheckSumGameData(u8* data, u8 dataNum);
#if PLATFORM_WII || PLATFORM_SHIELD
s32 mDoMemCdRWm_RestoreNAND(NANDFileInfo* param_0, void* param_1, u32 param_2);
s32 mDoMemCdRWm_StoreNAND(NANDFileInfo* param_0, void* param_1, u32 param_2);
s32 mDoMemCdRWm_StoreBannerNAND(NANDFileInfo*);
#endif
#endif /* M_DO_M_DO_MEMCARDRWMNG_H */

16
include/revolution/nand.h
View File

@ -120,6 +120,16 @@ typedef struct {
u8 iconTexture[8][48 * 48 * 2];
} NANDBanner;
#define NAND_STAT_SPEED_END 0
#define NAND_STAT_SPEED_FAST 1
#define NAND_STAT_SPEED_MIDDLE 2
#define NAND_STAT_SPEED_SLOW 3
#define NAND_STAT_SPEED_MASK 3
#define NANDSetIconSpeed(stat, n, f) \
((stat).iconSpeed = \
(u16)(((stat).iconSpeed & ~(NAND_STAT_SPEED_MASK << (2 * (n)))) | ((f) << (2 * (n)))))
typedef void (*NANDCallback)(s32, NANDCommandBlock*);
typedef void (*NANDAsyncCallback)(s32 result, struct NANDCommandBlock* block);
@ -181,8 +191,14 @@ s32 NANDPrivateOpenAsync(const char*, NANDFileInfo*, const u8, NANDCallback, NAN
s32 NANDClose(NANDFileInfo*);
s32 NANDCloseAsync(NANDFileInfo*, NANDCallback, NANDCommandBlock*);
#ifdef SDK_SEP2006
s32 NANDSafeOpen(const char* path, NANDFileInfo* info, const u8 accType, void* buf, const u32 length);
s32 NANDSafeClose(NANDFileInfo* info);
#else
s32 NANDSimpleSafeOpen(const char* path, NANDFileInfo* info, const u8 accType, void* buf, const u32 length);
s32 NANDSimpleSafeClose(NANDFileInfo* info);
#endif
s32 NANDPrivateSafeOpenAsync(const char* path, NANDFileInfo* info, const u8 accType, void* buf, const u32 length, NANDCallback cb, NANDCommandBlock* block);
s32 NANDSafeCloseAsync(NANDFileInfo* info, NANDCallback cb, NANDCommandBlock* block);

2
include/revolution/sc.h
View File

@ -147,6 +147,8 @@ BOOL SCReplaceU8Item(u8 data, SCItemID id);
u32 SCCheckStatus(void);
s32 SCReloadConfFileAsync(u8* bufp, u32 bufSize, SCReloadConfFileCallback callback);
BOOL SCFlush(void);
#ifdef __cplusplus
}
#endif

4570
src/d/d_file_select.cpp
View File

File diff suppressed because it is too large Load Diff

1
src/d/d_map.cpp
View File

@ -7,6 +7,7 @@
#include "d/d_map.h"
#include "JSystem/JHostIO/JORFile.h"
#include "JSystem/JHostIO/JORServer.h"
#include "JSystem/JUtility/JUTTexture.h"
#include "SSystem/SComponent/c_counter.h"
#include "SSystem/SComponent/c_math.h"

4
src/d/d_menu_option.cpp
View File

@ -1030,7 +1030,7 @@ void dMenu_Option_c::confirm_open_init() {
}
void dMenu_Option_c::confirm_open_move() {
bool status = mpWarning->getStatus();
u32 status = mpWarning->getStatus();
bool yesNoMenuMove = yesnoMenuMoveAnm();
if (field_0x374 != 1.0f) {
@ -1113,7 +1113,7 @@ void dMenu_Option_c::confirm_close_init() {
}
void dMenu_Option_c::confirm_close_move() {
bool status = mpWarning->getStatus();
u32 status = mpWarning->getStatus();
yesnoMenuMoveAnm();
if (field_0x374 != 0.0f) {
cLib_addCalc2(&field_0x374, 0.0f, 0.4f, 0.5);

10
src/d/d_menu_save.cpp
View File

@ -1296,7 +1296,7 @@ void dMenu_save_c::memCardCommandEnd2() {
bool headerTxtChanged = headerTxtChangeAnm();
bool ketteiDispAnm = ketteiTxtDispAnm();
bool modoruDispAnm = modoruTxtDispAnm();
u32 check = mWarning->getStatus() != 0;
u32 check = mWarning->getStatus();
if (headerTxtChanged == true && ketteiDispAnm == true && modoruDispAnm == true && check == 1) {
mpErrFunc = NULL;
@ -1388,7 +1388,7 @@ void dMenu_save_c::gameContinueDisp() {
bool headerTxtChanged = headerTxtChangeAnm();
bool moveAnm = yesnoMenuMoveAnm();
bool ketteiDispAnm = ketteiTxtDispAnm();
u32 check = mWarning->getStatus() != 0;
u32 check = mWarning->getStatus();
if (headerTxtChanged == true && moveAnm == true && ketteiDispAnm == true && check == 1) {
yesnoCursorShow();
@ -1466,7 +1466,7 @@ void dMenu_save_c::gameContinue3() {
void dMenu_save_c::saveEnd() {
bool headerTxtChanged = headerTxtChangeAnm();
bool ketteiDispAnm = ketteiTxtDispAnm();
u32 check = mWarning->getStatus() != 0;
u32 check = mWarning->getStatus();
if (headerTxtChanged == true && ketteiDispAnm == true && check == 1) {
if (mUseType == TYPE_BLACK_EVENT) {
@ -1938,7 +1938,7 @@ void dMenu_save_c::saveMoveDisp() {
bool yesnoAnmComplete = yesnoMenuMoveAnm();
bool ketteiAnmComplete = ketteiTxtDispAnm();
bool modoruAnmComplete = modoruTxtDispAnm();
u32 check = mWarning->getStatus() != 0;
u32 check = mWarning->getStatus();
if (headerTxtChanged == true && yesnoAnmComplete == true && ketteiAnmComplete == true &&
modoruAnmComplete == 1 && check == 1) {
@ -1956,7 +1956,7 @@ void dMenu_save_c::saveMoveDisp2() {
bool wakuAnmComplete = selectWakuAlpahAnm(mSelectedFile);
bool ketteiAnmComplete = ketteiTxtDispAnm();
bool modoruAnmComplete = modoruTxtDispAnm();
u32 check = mWarning->getStatus() != 0;
u32 check = mWarning->getStatus();
if (headerTxtChanged == true && dataMoveAnm == true && wakuAnmComplete == true &&
ketteiAnmComplete == true && modoruAnmComplete == 1 && check == 1) {

405
src/m_Do/m_Do_MemCard.cpp
View File

@ -10,6 +10,11 @@
#include "m_Do/m_Do_MemCardRWmng.h"
#include "m_Do/m_Do_Reset.h"
#if PLATFORM_WII || PLATFORM_SHIELD
#include <revolution/nand.h>
#include <revolution/sc.h>
#endif
#define SLOT_A 0
#define CHECKSPACE_RESULT_READY 0
@ -17,14 +22,60 @@
#define CHECKSPACE_RESULT_NOENT 2
#define CHECKSPACE_RESULT_ERROR 3
#if PLATFORM_WII
s32 my_CARDOpen(s32 chan, const char* fileName, CARDFileInfo* fileInfo) {
CARDStat stat;
DVDDiskID* diskID = DVDGetCurrentDiskID();
for (int i = 0; i < CARD_MAX_FILE; i++) {
s32 ret = CARDGetStatus(chan, i, &stat);
if (ret == CARD_RESULT_READY) {
if (memcmp(stat.gameName, "GZ2E", 4) == 0 &&
memcmp(stat.company, diskID->company, 2) == 0 &&
strncmp(stat.fileName, fileName, 32) == 0)
{
return CARDFastOpen(chan, i, fileInfo);
}
} else if (ret != CARD_RESULT_NOFILE) {
return ret;
}
}
return CARD_RESULT_NOFILE;
}
#endif
#if PLATFORM_WII
#define CARD_OPEN my_CARDOpen
#else
#define CARD_OPEN CARDOpen
#endif
#if PLATFORM_WII
#define NAND_OPEN NANDSafeOpen
#define NAND_CLOSE NANDSafeClose
#elif PLATFORM_SHIELD
#define NAND_OPEN NANDSimpleSafeOpen
#define NAND_CLOSE NANDSimpleSafeClose
#endif
mDoMemCd_Ctrl_c::mDoMemCd_Ctrl_c() {}
static u8 MemCardStack[0x1000];
#if PLATFORM_GCN
#define STACK_SIZE 0x1000
#else
#define STACK_SIZE 0x2000
#endif
static u8 MemCardStack[STACK_SIZE];
static OSThread MemCardThread;
void mDoMemCd_Ctrl_c::ThdInit() {
#if !PLATFORM_SHIELD
CARDInit();
#endif
mCopyToPos = 0;
mProbeStat = 2;
mCardState = CARD_STATE_NO_CARD_e;
@ -33,10 +84,8 @@ void mDoMemCd_Ctrl_c::ThdInit() {
OSInitMutex(&mMutex);
OSInitCond(&mCond);
int priority = OSGetThreadPriority(OSGetCurrentThread());
OSCreateThread(&MemCardThread, (void*(*)(void*))mDoMemCd_main, NULL, MemCardStack + sizeof(MemCardStack),
sizeof(MemCardStack), priority + 1, 1);
sizeof(MemCardStack), OSGetThreadPriority(OSGetCurrentThread()) + 1, 1);
OSResumeThread(&MemCardThread);
// "Memory Card Thread Init\n"
@ -52,6 +101,7 @@ void mDoMemCd_Ctrl_c::main() {
OSUnlockMutex(&mMutex);
switch (mCardCommand) {
#if PLATFORM_GCN || PLATFORM_WII
case COMM_RESTORE_e:
restore();
break;
@ -67,6 +117,26 @@ void mDoMemCd_Ctrl_c::main() {
case COMM_DETACH_e:
detach();
break;
#elif PLATFORM_SHIELD
case COMM_RESTORE_e:
case COMM_STORE_e:
case COMM_FORMAT_e:
case COMM_ATTACH_e:
case COMM_DETACH_e:
break;
#endif
#if PLATFORM_WII || PLATFORM_SHIELD
case COMM_RESTORE_NAND_e:
restoreNAND();
break;
case COMM_STORE_NAND_e:
storeNAND();
break;
case COMM_STORE_SETUP_NAND_e:
storeSetUpNAND();
break;
#endif
}
OSLockMutex(&mMutex);
@ -83,6 +153,7 @@ void mDoMemCd_Ctrl_c::update() {
OSUnlockMutex(&mMutex);
OSSignalCond(&mCond);
} else if (getStatus(0) != 14) {
#if PLATFORM_GCN || PLATFORM_WII
if (CARDProbe(SLOT_A) && getStatus(0) == 0) {
OSLockMutex(&mMutex);
mProbeStat = 0;
@ -98,6 +169,7 @@ void mDoMemCd_Ctrl_c::update() {
OSUnlockMutex(&mMutex);
OSSignalCond(&mCond);
}
#endif
}
}
@ -110,11 +182,12 @@ void mDoMemCd_Ctrl_c::load() {
}
}
#if !PLATFORM_SHIELD
void mDoMemCd_Ctrl_c::restore() {
CARDFileInfo file;
field_0x1fc8 = 0;
s32 ret = CARDOpen(mChannel, "gczelda2", &file);
s32 ret = CARD_OPEN(mChannel, "gczelda2", &file);
OS_REPORT("\x1b[43;30mCret=%d\n\x1b[m", ret);
if (ret == CARD_RESULT_READY) {
s32 ret2 = mDoMemCdRWm_Restore(&file, this, sizeof(mData));
@ -131,6 +204,7 @@ void mDoMemCd_Ctrl_c::restore() {
field_0x1fc8 = 1;
}
#endif
s32 mDoMemCd_Ctrl_c::LoadSync(void* i_buffer, u32 i_size, u32 i_position) {
int ret = 0;
@ -164,13 +238,18 @@ void mDoMemCd_Ctrl_c::save(void* i_buffer, u32 i_size, u32 i_position) {
}
}
#if !PLATFORM_SHIELD
void mDoMemCd_Ctrl_c::store() {
CARDFileInfo file;
s32 ret;
field_0x1fc8 = 0;
if (mCardState == CARD_STATE_NO_FILE_e) {
ret = CARDCreate(mChannel, "gczelda2", SAVEDATA_FILE_SIZE, &file);
#if PLATFORM_GCN
ret = CARDCreate(mChannel, "gczelda2", CARD_FILE_SIZE, &file);
#else
ret = CARDCreate(mChannel, "zeldaTp.dat", CARD_FILE_SIZE, &file);
#endif
if (ret == CARD_RESULT_READY || ret == CARD_RESULT_EXIST) {
mCardState = CARD_STATE_READY_e;
} else {
@ -179,7 +258,7 @@ void mDoMemCd_Ctrl_c::store() {
}
if (mCardState == CARD_STATE_READY_e) {
ret = CARDOpen(mChannel, "gczelda2", &file);
ret = CARD_OPEN(mChannel, "gczelda2", &file);
if (ret == CARD_RESULT_READY) {
ret = mDoMemCdRWm_Store(&file, this, sizeof(mData));
if (ret != CARD_RESULT_READY) {
@ -199,6 +278,7 @@ void mDoMemCd_Ctrl_c::store() {
field_0x1fc8 = 1;
}
#endif
s32 mDoMemCd_Ctrl_c::SaveSync() {
int ret = 0;
@ -217,7 +297,6 @@ s32 mDoMemCd_Ctrl_c::SaveSync() {
ret = 2;
}
OS_REPORT("CARD Save Sync ret:%d stat:%d\n", ret, mCardState);
OSUnlockMutex(&mMutex);
}
@ -287,6 +366,7 @@ void mDoMemCd_Ctrl_c::command_format() {
}
}
#if !PLATFORM_SHIELD
void mDoMemCd_Ctrl_c::format() {
field_0x1fc8 = 0;
@ -302,6 +382,7 @@ void mDoMemCd_Ctrl_c::format() {
OSUnlockMutex(&mMutex);
}
}
#endif
s32 mDoMemCd_Ctrl_c::FormatSync() {
int ret = 0;
@ -325,6 +406,7 @@ s32 mDoMemCd_Ctrl_c::FormatSync() {
return ret;
}
#if !PLATFORM_SHIELD
void mDoMemCd_Ctrl_c::attach() {
s32 mem_size;
s32 sector_size;
@ -418,7 +500,7 @@ s32 mDoMemCd_Ctrl_c::mount() {
s32 mDoMemCd_Ctrl_c::loadfile() {
CARDFileInfo file;
s32 ret = CARDOpen(mChannel, "gczelda2", &file);
s32 ret = CARD_OPEN(mChannel, "gczelda2", &file);
if (ret == CARD_RESULT_READY) {
CARDClose(&file);
return TRUE;
@ -428,7 +510,6 @@ s32 mDoMemCd_Ctrl_c::loadfile() {
}
}
//
s32 mDoMemCd_Ctrl_c::checkspace() {
s32 bytesNotUsed, filesNotUsed;
s32 result = CARDFreeBlocks(mChannel, &bytesNotUsed, &filesNotUsed);
@ -438,7 +519,7 @@ s32 mDoMemCd_Ctrl_c::checkspace() {
return CHECKSPACE_RESULT_ERROR;
}
if (bytesNotUsed < SAVEDATA_FILE_SIZE) {
if (bytesNotUsed < CARD_FILE_SIZE) {
return CHECKSPACE_RESULT_INSSPACE;
}
@ -472,13 +553,313 @@ void mDoMemCd_Ctrl_c::setCardState(s32 i_result) {
break;
}
}
#endif
#if PLATFORM_WII || PLATFORM_SHIELD
void mDoMemCd_Ctrl_c::loadNAND() {
if (OSTryLockMutex(&mMutex)) {
field_0x1fc8 = 0;
mCardCommand = COMM_RESTORE_NAND_e;
OSUnlockMutex(&mMutex);
OSSignalCond(&mCond);
}
}
void mDoMemCd_Ctrl_c::restoreNAND() {
NANDFileInfo file;
s32 ret, ret2;
field_0x1fc8 = 0;
ret = NANDOpen("zeldaTp.dat", &file, NAND_ACCESS_RW);
OS_REPORT("\x1b[43;30mCret=%d\n\x1b[m", ret);
if (ret == NAND_RESULT_OK) {
ret2 = mDoMemCdRWm_RestoreNAND(&file, this, sizeof(mData));
OS_REPORT("\x1b[43;30mret2=%d\n\x1b[m", ret2);
if (ret2 == NAND_RESULT_OK) {
mNandState = NAND_STATE_READ_e;
} else {
setNandState(ret);
}
NANDClose(&file);
} else {
setNandState(ret);
}
field_0x1fc8 = 1;
}
s32 mDoMemCd_Ctrl_c::LoadSyncNAND(void* i_buffer, u32 i_size, u32 i_position) {
int ret = 0;
if (field_0x1fc8 == 0) {
return 0;
}
if (OSTryLockMutex(&mMutex)) {
if (mNandState == NAND_STATE_READ_e) {
memcpy(i_buffer, &mData[i_position], i_size);
mNandState = NAND_STATE_READY_e;
ret = 1;
} else {
ret = 2;
}
OSUnlockMutex(&mMutex);
}
return ret;
}
void mDoMemCd_Ctrl_c::saveNAND(void* i_buffer, u32 i_size, u32 i_position) {
if (OSTryLockMutex(&mMutex)) {
memcpy(&mData[i_position], i_buffer, i_size);
field_0x1fc8 = 0;
mCardCommand = COMM_STORE_NAND_e;
OSUnlockMutex(&mMutex);
OSSignalCond(&mCond);
}
}
static u8 l_safeCopyBuf[0x4000];
void mDoMemCd_Ctrl_c::storeNAND() {
NANDFileInfo file;
s32 ret;
field_0x1fc8 = 0;
if (mNandState == NAND_STATE_NO_FILE_e) {
ret = NANDCreate("zeldaTp.dat", NAND_PERM_RUSR | NAND_PERM_WUSR | NAND_PERM_RGRP, 0);
if (ret == NAND_RESULT_OK) {
mNandState = NAND_STATE_READY_e;
} else {
setNandState(ret);
}
}
if (mNandState == NAND_STATE_READY_e) {
u8 sp8 = 1;
ret = NANDCreate("banner.bin", NAND_PERM_RUSR | NAND_PERM_WUSR | NAND_PERM_RGRP, 0);
printf("NAND bannerFile Create ret:%d\n", ret);
if (ret == NAND_RESULT_OK || ret == NAND_RESULT_EXISTS) {
ret = NAND_OPEN("banner.bin", &file, NAND_ACCESS_RW, l_safeCopyBuf, sizeof(l_safeCopyBuf));
if (ret == NAND_RESULT_OK) {
ret = mDoMemCdRWm_StoreBannerNAND(&file);
if (ret == NAND_RESULT_OK) {
printf("NAND bannerFile Write OK ret:%d\n", ret);
} else {
setNandState(ret);
printf("NAND bannerFile Write ERR ret:%d\n", ret);
}
NAND_CLOSE(&file);
} else {
setNandState(ret);
}
} else {
setNandState(ret);
}
if (ret == NAND_RESULT_OK) {
ret = NAND_OPEN("zeldaTp.dat", &file, NAND_ACCESS_RW, l_safeCopyBuf, sizeof(l_safeCopyBuf));
if (ret == NAND_RESULT_OK) {
ret = mDoMemCdRWm_StoreNAND(&file, this, sizeof(mData));
if (ret == NAND_RESULT_OK) {
mNandState = NAND_STATE_WRITE_e;
printf("NAND Write OK ret:%d stat:%d\n", ret, mNandState);
} else {
setNandState(ret);
printf("NAND Write ERR ret:%d\n", ret);
}
NAND_CLOSE(&file);
} else {
setNandState(ret);
}
}
} else {
setNandState(ret);
}
field_0x1fc8 = 1;
}
s32 mDoMemCd_Ctrl_c::SaveSyncNAND() {
int ret = 0;
if (field_0x1fc8 == 0) {
return 0;
}
if (OSTryLockMutex(&mMutex)) {
if (mNandState == NAND_STATE_WRITE_e) {
mNandState = NAND_STATE_READY_e;
ret = 1;
} else {
ret = 2;
}
printf("NAND Save Sync ret:%d stat:%d\n", ret, mNandState);
OSUnlockMutex(&mMutex);
}
return ret;
}
void mDoMemCd_Ctrl_c::storeSetUpNAND() {
field_0x1fc8 = 0;
while ((int)SCCheckStatus() != 0) {}
#if PLATFORM_WII
if (!SCFlush()) {
mNandState = NAND_STATE_WRITE_e;
printf("== 本体設定Write OK ==\n");
} else {
mNandState = NAND_STATE_FATAL_ERROR_e;
printf("== 本体設定Write ERR ==\n");
}
#else
mNandState = NAND_STATE_WRITE_e;
#endif
field_0x1fc8 = 1;
}
void m_Do_MemCard_cpp__dummyString() {
DEAD_STRING("本体設定 Save Sync ret:%d stat:%d\n");
}
void mDoMemCd_Ctrl_c::setNandState(s32 i_result) {
switch (i_result) {
case NAND_RESULT_CORRUPT:
mNandState = NAND_STATE_BROKEN_e;
break;
case NAND_RESULT_MAXBLOCKS:
mNandState = NAND_STATE_INSSPACE_e;
break;
case NAND_RESULT_MAXFILES:
case NAND_RESULT_MAXFD:
mNandState = NAND_STATE_NOENT_e;
break;
case NAND_RESULT_ECC_CRIT:
case NAND_RESULT_AUTHENTICATION:
mNandState = NAND_STATE_AUTHENTICATION_e;
break;
case NAND_RESULT_NOEXISTS:
mNandState = NAND_STATE_NO_FILE_e;
break;
case NAND_RESULT_UNKNOWN:
case NAND_RESULT_FATAL_ERROR:
mNandState = NAND_STATE_FATAL_ERROR_e;
break;
case -7:
case NAND_RESULT_BUSY:
case NAND_RESULT_ALLOC_FAILED:
case NAND_RESULT_ACCESS:
break;
}
}
u32 mDoMemCd_Ctrl_c::getStatusNAND() {
u32 status;
if (OSTryLockMutex(&mMutex)) {
switch (mNandState) {
case NAND_STATE_READY_e:
status = 1;
break;
case NAND_STATE_NO_FILE_e:
status = 0;
break;
case NAND_STATE_READ_e:
status = 2;
break;
case NAND_STATE_WRITE_e:
status = 3;
break;
case NAND_STATE_FORMAT_e:
status = 6;
break;
case NAND_STATE_AUTHENTICATION_e:
status = 4;
break;
case NAND_STATE_BROKEN_e:
status = 5;
break;
case NAND_STATE_INSSPACE_e:
status = 7;
break;
case NAND_STATE_NOENT_e:
status = 8;
break;
case NAND_STATE_FATAL_ERROR_e:
status = 9;
break;
case NAND_STATE_10_e:
status = 10;
break;
}
OSUnlockMutex(&mMutex);
return status;
}
return 10;
}
s32 mDoMemCd_Ctrl_c::chekNANDFile() {
NANDFileInfo file;
s32 ret = NANDOpen("zeldaTp.dat", &file, NAND_ACCESS_RW);
if (ret == NAND_RESULT_OK) {
mNandState = NAND_STATE_READY_e;
NANDClose(&file);
return 1;
}
switch (checkspaceNAND()) {
case CHECKSPACE_RESULT_READY:
mNandState = NAND_STATE_NO_FILE_e;
break;
case CHECKSPACE_RESULT_INSSPACE:
mNandState = NAND_STATE_INSSPACE_e;
break;
case CHECKSPACE_RESULT_NOENT:
mNandState = NAND_STATE_NOENT_e;
break;
case CHECKSPACE_RESULT_ERROR:
setNandState(ret);
break;
}
return 0;
}
s32 mDoMemCd_Ctrl_c::checkspaceNAND() {
u32 answer = -1;
s32 ret;
s32 result = NANDCheck(3, 2, &answer);
if (result != NAND_RESULT_OK) {
setNandState(result);
return CHECKSPACE_RESULT_ERROR;
}
if (answer == 0) {
ret = 0;
} else if (answer & 5) {
ret = 1;
} else if (answer & 10) {
ret = 2;
}
return ret;
}
#endif
mDoMemCd_Ctrl_c g_mDoMemCd_control;
static int mDoMemCd_main(void*) {
{ JKRThread thread(OSGetCurrentThread(), 0); }
mDoExt_getAssertHeap()->becomeCurrentHeap();
JKRSetCurrentHeap(mDoExt_getAssertHeap());
g_mDoMemCd_control.main();
return 0;

160
src/m_Do/m_Do_MemCardRWmng.cpp
View File

@ -13,6 +13,9 @@
#if VERSION == VERSION_GCN_JPN
#define HEADER_TITLE "ゼルダの伝説 ﾄﾜｲﾗｲﾄﾌﾟﾘﾝｾｽ"
#define HEADER_COMMENT "%d月%d日のセーブデータです"
#elif PLATFORM_WII
#define HEADER_TITLE "The Legend of Zelda: TP"
#define HEADER_COMMENT "%d/%d Save Data"
#else
#define HEADER_TITLE "Zelda: Twilight Princess"
#define HEADER_COMMENT "%d/%d Save Data"
@ -21,12 +24,13 @@
struct data_s {
int unk_0x0;
int data_version;
u8 data[(SAVEDATA_SIZE * 3) + 0x38]; // unsure what the extra 0x38 is
u8 data[(SAVEFILE_SIZE) + 0x38]; // unsure what the extra 0x38 is
u32 checksum;
};
static u8 sTmpBuf[SECTOR_SIZE * 2];
#if !PLATFORM_SHIELD
s32 mDoMemCdRWm_Store(CARDFileInfo* file, void* data, u32 length) {
mDoMemCdRWm_BuildHeader((mDoMemCdRWm_HeaderData*)sTmpBuf);
@ -152,6 +156,160 @@ s32 mDoMemCdRWm_Restore(CARDFileInfo* file, void* data, u32 length) {
return CARD_RESULT_READY;
}
#endif
#if PLATFORM_WII || PLATFORM_SHIELD
s32 mDoMemCdRWm_StoreNAND(NANDFileInfo* file, void* data, u32 length) {
s32 ret;
memset(sTmpBuf, 0, sizeof(sTmpBuf));
data_s* tmp_data = (data_s*)sTmpBuf;
tmp_data->unk_0x0 = 0;
tmp_data->data_version = SAVEDATA_VERSION;
memcpy(tmp_data->data, data, length);
u32 checksum = tmp_data->checksum = mDoMemCdRWm_CalcCheckSum(tmp_data, sizeof(data_s) - 4);
ret = NANDWrite(file, sTmpBuf, 0x2000);
if (ret != 0x2000) {
return ret;
}
NANDSeek(file, 0, 0);
ret = NANDRead(file, sTmpBuf, 0x2000);
if (ret != 0x2000) {
return ret;
}
if (checksum != mDoMemCdRWm_CalcCheckSum(sTmpBuf, sizeof(data_s) - 4)) {
return ret;
}
NANDSeek(file, 0x2000, 0);
ret = NANDWrite(file, sTmpBuf, 0x2000);
if (ret != 0x2000) {
return ret;
}
NANDSeek(file, 0x2000, 0);
ret = NANDRead(file, sTmpBuf, 0x2000);
if (ret != 0x2000) {
return ret;
}
if (checksum != mDoMemCdRWm_CalcCheckSum(sTmpBuf, sizeof(data_s) - 4)) {
return ret;
}
return NAND_RESULT_OK;
}
s32 mDoMemCdRWm_RestoreNAND(NANDFileInfo* file, void* data, u32 length) {
BOOL rewrite = FALSE;
data_s* saves = (data_s*)sTmpBuf;
data_s* backup_saves = (data_s*)(sTmpBuf + SECTOR_SIZE);
NANDSeek(file, 0, 0);
s32 ret = NANDRead(file, saves, 0x2000);
if (ret != 0x2000) {
return ret;
}
BOOL save1_valid = mDoMemCdRWm_TestCheckSumGameData(&saves->data[SAVEDATA_SIZE * 0]);
BOOL save2_valid = mDoMemCdRWm_TestCheckSumGameData(&saves->data[SAVEDATA_SIZE * 1]);
BOOL save3_valid = mDoMemCdRWm_TestCheckSumGameData(&saves->data[SAVEDATA_SIZE * 2]);
NANDSeek(file, 0x2000, 0);
ret = NANDRead(file, backup_saves, 0x2000);
if (ret != 0x2000) {
return ret;
}
BOOL backup1_valid = mDoMemCdRWm_TestCheckSumGameData(&backup_saves->data[SAVEDATA_SIZE * 0]);
BOOL backup2_valid = mDoMemCdRWm_TestCheckSumGameData(&backup_saves->data[SAVEDATA_SIZE * 1]);
BOOL backup3_valid = mDoMemCdRWm_TestCheckSumGameData(&backup_saves->data[SAVEDATA_SIZE * 2]);
if (!save1_valid && backup1_valid) {
memcpy(&saves->data[SAVEDATA_SIZE * 0], &backup_saves->data[SAVEDATA_SIZE * 0], SAVEDATA_SIZE);
rewrite = TRUE;
}
if (!save2_valid && backup2_valid) {
memcpy(&saves->data[SAVEDATA_SIZE * 1], &backup_saves->data[SAVEDATA_SIZE * 1], SAVEDATA_SIZE);
rewrite = TRUE;
}
if (!save3_valid && backup3_valid) {
memcpy(&saves->data[SAVEDATA_SIZE * 2], &backup_saves->data[SAVEDATA_SIZE * 2], SAVEDATA_SIZE);
rewrite = TRUE;
}
BOOL sp10 = FALSE;
if (!save1_valid && !backup1_valid &&
!save2_valid && !backup2_valid &&
!save3_valid && !backup3_valid)
{
sp10 = TRUE;
}
if (rewrite) {
NANDSeek(file, 0, 0);
ret = NANDWrite(file, saves, 0x2000);
if (ret != 0x2000) {
return ret;
}
NANDSeek(file, 0x2000, 0);
ret = NANDWrite(file, saves, 0x2000);
if (ret != 0x2000) {
return ret;
}
}
memcpy(data, saves->data, length);
mDoMemCd_setDataVersion(saves->data_version);
return NAND_RESULT_OK;
}
#endif
#if PLATFORM_WII || PLATFORM_SHIELD
s32 mDoMemCdRWm_StoreBannerNAND(NANDFileInfo* file) {
static NANDBanner info;
static wchar_t titleTxt[] = L"The Legend of Zelda:";
static wchar_t commentTxt[] = L"Twilight Princess";
u32 size;
s32 ret;
NANDInitBanner(&info, 0, (u16*)titleTxt, (u16*)commentTxt);
ResTIMG* banner_data = (ResTIMG*)dComIfGp_getCardIconResArchive()->getResource("zelda2_wii_banner.bti");
ResTIMG* icon_data = (ResTIMG*)dComIfGp_getCardIconResArchive()->getResource("zelda2_wii_icon.bti");
u8* banner_base_ptr = (u8*)banner_data;
u8* icon_base_ptr = (u8*)icon_data;
memcpy(info.bannerTexture, banner_base_ptr + banner_data->imageOffset, sizeof(info.bannerTexture));
memcpy(info.iconTexture, icon_base_ptr + icon_data->imageOffset, 0x1200);
dComIfGp_getCardIconResArchive()->removeResourceAll();
NANDSetIconSpeed(info, 0, NAND_STAT_SPEED_MIDDLE);
NANDSetIconSpeed(info, 1, NAND_STAT_SPEED_END);
size = 0x72A0;
ret = NANDWrite(file, &info, size);
if (ret != size) {
return ret;
}
return NAND_RESULT_OK;
}
#endif
static void mDoMemCdRWm_BuildHeader(mDoMemCdRWm_HeaderData* header) {
snprintf(header->mTitle, sizeof(header->mTitle), HEADER_TITLE);