memory_card.h

Go to the documentation of this file.

#ifndef STGMCARD_H
#define STGMCARD_H
 
/* STGMCARD.PRO: the memory card screen (MODE_CONTINUE). Its modules are in
   src/menus/memory_card/, and the functions below are by module, in the order they
   link. */
 
#include "engine/game.h"
 
/* The name of this overlay's copy of a function of src/shared/ */
#define OVL_NAME(name) STGMCARD_##name
 
/* The sprite archive of the screen */
#if VERSION_US || VERSION_JP
#define FILE_GMCARD_SPRITES 0x28F
#define FILE_GMCARD_SHEET 0x28E /* the sprite sheet of its images */
#elif VERSION_EU
#define FILE_GMCARD_SPRITES 0x29E
#define FILE_GMCARD_SHEET 0x29D
#endif
 
/* The root task of the overlay (STGMCARD_start) */
typedef struct MemCardScene {
    TASK_HEADER(MemCardScene);
    /* 0x50 */ s32 pad[2]; /* never read or written: createTask allocates 0x58 bytes */
} MemCardScene;
 
/* A mode (or stage) the screen can be opened from, and the area a save made
   from it shows (STGMCARD_prevModes, which ends with a zero mode) */
typedef struct MemCardModeEntry {
    /* 0x0 */ u8 area; /* a string of TEXT_AREA_NAMES */
    /* 0x1 */ u8 stage; /* a string of TEXT_STAGE_NAMES; nothing reads it */
    /* 0x2 */ s16 mode;
} MemCardModeEntry;
 
/* The main task of the screen (STGMCARD_createScreen) */
typedef struct MemCardScreen {
    TASK_HEADER(MemCardScreen);
    /* 0x50 */ s32 loading; /* opened from the title screen: the game mode's
                               argument is not negative (saving: negative) */
    /* 0x54 */ s32 layer;
    /* 0x58 */ s32 bgScroll; /* the background's offset, 0 to 95 */
    /* 0x5C */ s32 bgTick; /* it moves every other frame */
    /* 0x60 */ s32 pad[2]; /* never read or written */
    /* 0x68 */ s32 area; /* a string of TEXT_AREA_NAMES, from the previous mode */
    /* 0x6C */ s32 place; /* a string of TEXT_SHOP_NAMES (STGMCARD_places) */
} MemCardScreen;
 
struct MemCardMenu;
struct MemCardPanel;
struct MemCardInfo;
struct MemCardSaves;
 
/* The children of the main task */
typedef struct MemCardScreenTasks {
    /* 0x0 */ struct MemCardSaves *saves;
    /* 0x4 */ ScreenFade *fade;
} MemCardScreenTasks;
 
/* The children of the save list */
typedef struct MemCardSavesWindows {
    /* 0x00 */ TextWindow *title; /* save or load */
    /* 0x04 */ TextWindow *windows[5];
    /* 0x18 */ Cursor *cursor;
    /* 0x1C */ struct MemCardPanel *panel;
    /* 0x20 */ struct MemCardMenu *menu;
    /* 0x24 */ struct MemCardInfo *info;
} MemCardSavesWindows;
 
/* A save of the memory card, as the list shows it */
typedef struct MemCardSave {
    /* 0x00 */ u8 name[0x18]; /* empty for a free slot */
    /* 0x18 */ s32 area; /* MemCardScreen's */
    /* 0x1C */ s32 place;
    /* 0x20 */ s32 money;
    /* 0x24 */ PlayTime time;
    /* 0x30 */ s32 partners[3]; /* 3 and up: a partner, whose animation the
                                   details show */
    /* 0x3C */ s16 levels[3];
} MemCardSave;
 
/* The memory card's info section: the three slots' saves, as the list shows
   them (STGMCARD_funcs.infoBuf, and the list's copy) */
typedef struct MemCardFile {
    /* 0x00 */ u8 checksum; /* of the rest, from magic */
    /* 0x01 */ u8 last; /* the slot last saved to */
    /* 0x02 */ u8 version; /* MEMCARD_SAVE_VERSION */
    /* 0x04 */ s32 magic; /* "DMW3" */
    /* 0x08 */ MemCardSave saves[3];
} MemCardFile;
 
#define MEMCARD_FILE_MAGIC 0x33574D44
 
/* A save's data section is GAME's first GAME_SAVE_SIZE bytes (SaveData).
   GameState.checksum and .version hold the checksum of the rest, from byte
   SAVE_CHECKED, and MEMCARD_SAVE_VERSION. */
#if VERSION_US
#define MEMCARD_SAVE_VERSION 3
#elif VERSION_EU || VERSION_JP
#define MEMCARD_SAVE_VERSION 4
#endif
#define SAVE_CHECKED 4
 
/* The durations of the panels shown while loading and saving */
#if VERSION_US
#define MEMCARD_LOAD_FRAMES 1239
#define MEMCARD_SAVE_FRAMES 1266
#elif VERSION_EU || VERSION_JP
#define MEMCARD_LOAD_FRAMES 1240
#define MEMCARD_SAVE_FRAMES 1267
#endif
 
/* The saved part of the game state, to copy it whole */
typedef struct GameSave {
    /* 0x0000 */ s32 data[GAME_SAVE_SIZE / 4];
} GameSave;
 
/* GAME's saved part, which a load overwrites and a save copies: GameState
   (game_state.h) has no GameSave view of itself */
#define GAME_SAVE (*(GameSave *)&GAME)
 
/* A save's data section (STGMCARD_funcs.dataBuf): copied whole to and from
   GAME, read by its fields, and checksummed as bytes */
typedef union SaveData {
    GameSave save;
    GameState game;
    u8 bytes[GAME_SAVE_SIZE];
} SaveData;
 
/* MEMCARD followed by MEMCARD_FUNCS, as STGMCARD_runSaves reaches the functions:
   through MEMCARD's address. */
typedef struct MemCardSystem {
    /* 0x000 */ MemCard card;
    /* 0x328 */ MemCardFuncs funcs;
} MemCardSystem;
 
#define MEMCARD_SYSTEM (*(MemCardSystem *)&MEMCARD)
 
/* A text window of the details (STGMCARD_detailWindows) */
typedef struct MemCardWindowSpec {
    /* 0x00 */ s32 text; /* a string of text file 0x79 */
    /* 0x04 */ s32 type;
    /* 0x08 */ s32 x;
    /* 0x0C */ s32 y;
    /* 0x10 */ s32 isNumber; /* shows 0, right-aligned, for an empty slot */
} MemCardWindowSpec;
 
/* The saves of a memory card (STGMCARD_updateSaves) */
typedef struct MemCardSaves {
    TASK_HEADER(MemCardSaves);
    /* 0x0050 */ MemCardScreen *screen;
    /* 0x0054 */ s32 layer;
    /* 0x0058 */ s32 origin[3]; /* x and y of the list's windows */
    /* 0x0064 */ s32 port;
    /* 0x0068 */ s32 result; /* of the last card operation, then the error
                                (STGMCARD_errorTexts) */
    /* 0x006C */ MemCardFile file; /* the card's */
    /* 0x0140 */ u8 pad[GAME_SAVE_SIZE]; /* never read or written */
    /* 0x27FC */ s32 choice; /* of a yes/no question, 0 for yes; 0x2804 in the
                                European version, as all below */
    /* 0x2800 */ MenuLerp slide[2]; /* the list's x and y offsets */
    /* 0x2838 */ s32 prompting; /* a message waits for the cross button */
    /* 0x283C */ s32 blinkTime;
    /* 0x2840 */ s32 blinkFrame;
    /* 0x2844 */ s32 choosing; /* the cursor's two choices are shown */
    /* 0x2848 */ s32 backToPick; /* the message returns to the slot picker */
    /* 0x284C */ void (*refresh)(struct MemCardSaves *saves);
    /* 0x2850 */ void (*hide)(struct MemCardSaves *saves);
} MemCardSaves;
 
/* The window with the selected save's details (STGMCARD_updateInfo) */
typedef struct MemCardInfo {
    TASK_HEADER(MemCardInfo);
    /* 0x50 */ MemCardSaves *saves;
    /* 0x54 */ s32 layer;
    /* 0x58 */ s32 depth;
    /* 0x5C */ s32 drawing; /* the partners and frame are drawn */
    /* 0x60 */ s32 shown;
    /* 0x64 */ s32 time;
    /* 0x68 */ s32 frames[3]; /* of the three partners' animations */
    /* 0x74 */ PanelAnim fade;
    /* 0x84 */ void (*show)(struct MemCardInfo *info);
    /* 0x88 */ void (*hide)(struct MemCardInfo *info);
    /* 0x8C */ void (*refresh)(struct MemCardInfo *info);
} MemCardInfo;
 
/* The slot picker (STGMCARD_updateMenu): the header with the port, the
   three slots and their cursor, each sliding in and out with a lerp */
typedef struct MemCardMenu {
    TASK_HEADER(MemCardMenu);
    /* 0x50 */ MemCardSaves *saves;
    /* 0x54 */ s32 layer;
    /* 0x58 */ s32 depth;
    /* 0x5C */ MenuLerp lerps[4]; /* slots x, header y, cursor x, cursor move */
    /* 0xCC */ s32 slid; /* the last slide done: 1 header in, 2 slots in,
                           3 slots out */
    /* 0xD0 */ s32 blinkTime;
    /* 0xD4 */ s32 blinkFrame;
    /* 0xD8 */ s32 blinkDown; /* the frame counts down */
    /* 0xDC */ void (*reset)(struct MemCardMenu *menu);
    /* 0xE0 */ void (*slideInHeader)(struct MemCardMenu *menu);
    /* 0xE4 */ void (*startPick)(struct MemCardMenu *menu, s32 slot);
    /* 0xE8 */ void (*slideOutHeader)(struct MemCardMenu *menu);
    /* 0xEC */ void (*slideInSlots)(struct MemCardMenu *menu);
    /* 0xF0 */ void (*slideOutSlots)(struct MemCardMenu *menu);
} MemCardMenu;
 
/* A gradient panel that opens by scaling (STGMCARD_updatePanel) */
typedef struct MemCardPanel {
    TASK_HEADER(MemCardPanel);
    /* 0x50 */ s32 layer;
    /* 0x54 */ s32 depth;
    /* 0x58 */ s32 x;
    /* 0x5C */ s32 y;
    /* 0x60 */ s32 w;
    /* 0x64 */ s32 h;
    /* 0x68 */ s32 done;
    /* 0x6C */ CVECTOR top;
    /* 0x70 */ CVECTOR bottom;
    /* 0x74 */ s32 duration;
    /* 0x78 */ s32 rate; /* ONE / duration */
    /* 0x7C */ s32 pad[2]; /* never read or written */
    /* 0x84 */ s32 pivotX;
    /* 0x88 */ s32 pivotY;
    /* 0x8C */ VECTOR scale;
    /* 0x9C */ SVECTOR rot;
    /* 0xA4 */ MATRIX matrix;
    /* 0xC4 */ void (*reset)(struct MemCardPanel *panel);
    /* 0xC8 */ void (*start)(struct MemCardPanel *panel, s32 substate, s32 duration);
    /* 0xCC */ void (*setTopColor)(struct MemCardPanel *panel, u8 r, u8 g, u8 b);
    /* 0xD0 */ void (*setBottomColor)(struct MemCardPanel *panel, u8 r, u8 g, u8 b);
    /* 0xD4 */ void (*setPos)(struct MemCardPanel *panel, s32 x, s32 y);
} MemCardPanel;
 
/* A frame of the save's icon, a sector of the save file: 16x16 pixels of 4
   bits, the left one of each byte in its low bits, that index the CLUT */
typedef struct SaveIconFrame {
    /* 0x00 */ u8 pixels[16][8];
} SaveIconFrame;
 
/* The save's icon for the memory card's directory */
typedef struct SaveIcon {
    /* 0x0 */ CardClut *clut;
    /* 0x4 */ SaveIconFrame *frames[3];
} SaveIcon;
 
/* The overlay's buffers and helpers (STGMCARD_funcs) */
typedef struct MemCardScreenFuncs {
    /* 0x00 */ s32 lastSlot; /* the card's last saved one */
    /* 0x04 */ s32 slot; /* the selected one */
    /* 0x08 */ s32 prevSlot; /* where the cursor moves from */
    /* 0x0C */ MemCardFile *infoBuf;
    /* 0x10 */ SaveData *dataBuf; /* the saved part of the game state */
    /* 0x14 */ s32 infoSize;
    /* 0x18 */ s32 dataSize;
    /* 0x1C */ void (*loadFiles)(void);
    /* 0x20 */ s32 (*filesLoading)(void);
    /* 0x24 */ void (*freeBuffers)(void);
    /* 0x28 */ void (*startFade)(PanelAnim *fade, s32 fadeIn);
    /* 0x2C */ s32 (*updateFade)(PanelAnim *fade);
    /* 0x30 */ void (*startLerp)(MenuLerp *lerp, s32 from, s32 to, s32 frames);
    /* 0x34 */ s32 (*updateLerp)(MenuLerp *lerp);
} MemCardScreenFuncs;
 
/* scene.c */
void STGMCARD_updateScene(MemCardScene *task, MemCardScreen **child);
void STGMCARD_startFader(ScreenFade *task, s32 fadeIn, s32 duration);
void STGMCARD_drawFader(ScreenFade *task);
void STGMCARD_updateFader(ScreenFade *task);
ScreenFade *STGMCARD_createFader(void);
 
/* info.c */
void STGMCARD_showInfo(MemCardInfo *info);
void STGMCARD_hideInfo(MemCardInfo *info);
void STGMCARD_refreshInfo(MemCardInfo *info);
void STGMCARD_updateInfo(MemCardInfo *info);
MemCardInfo *STGMCARD_createInfo(MemCardSaves *saves);
 
/* panel.c */
void STGMCARD_resetPanel(MemCardPanel *panel);
void STGMCARD_startPanel(MemCardPanel *panel, s32 substate, s32 duration);
void STGMCARD_setPanelTopColor(MemCardPanel *panel, u8 r, u8 g, u8 b);
void STGMCARD_setPanelBottomColor(MemCardPanel *panel, u8 r, u8 g, u8 b);
void STGMCARD_setPanelPos(MemCardPanel *panel, s32 x, s32 y);
void STGMCARD_updatePanel(MemCardPanel *panel);
MemCardPanel *STGMCARD_createPanel(s32 x, s32 y, s32 w, s32 h);
 
/* menu.c */
void STGMCARD_slideInHeader(MemCardMenu *menu);
void STGMCARD_startSlotPick(MemCardMenu *menu, s32 slot);
void STGMCARD_slideOutHeader(MemCardMenu *menu);
void STGMCARD_moveSlotCursor(MemCardMenu *menu);
void STGMCARD_slideInSlots(MemCardMenu *menu);
void STGMCARD_slideOutSlots(MemCardMenu *menu);
void STGMCARD_resetMenu(MemCardMenu *menu);
void STGMCARD_updateMenu(MemCardMenu *menu, TextWindow **windows);
MemCardMenu *STGMCARD_createMenu(MemCardSaves *saves);
 
/* saves.c */
void STGMCARD_showPort(MemCardSaves *saves, MemCardSavesWindows *win, s32 show);
void STGMCARD_showError(MemCardSaves *saves, MemCardSavesWindows *win);
void STGMCARD_closeMenuForError(MemCardSaves *saves, MemCardSavesWindows *win);
void STGMCARD_refreshSaves(MemCardSaves *saves);
void STGMCARD_hideSaves(MemCardSaves *saves);
void STGMCARD_runSaves(MemCardSaves *saves, MemCardSavesWindows *win);
void STGMCARD_drawSaves(MemCardSaves *saves);
void STGMCARD_updateSaves(MemCardSaves *saves, MemCardSavesWindows *win);
MemCardSaves *STGMCARD_createSaves(MemCardScreen *screen);
 
/* screen.c */
void STGMCARD_updateScreen(MemCardScreen *screen, MemCardScreenTasks *tasks);
MemCardScreen *STGMCARD_createScreen(void);
void STGMCARD_loadFiles(void);
s32 STGMCARD_filesLoading(void);
void STGMCARD_freeBuffers(void);
void STGMCARD_startFade(PanelAnim *fade, s32 fadeIn);
s32 STGMCARD_updateFade(PanelAnim *fade);
void STGMCARD_startLerp(MenuLerp *lerp, s32 from, s32 to, s32 frames);
s32 STGMCARD_updateLerp(MenuLerp *lerp);
 
/* STGMCARD's data (data/stgmcard.c) */
extern MemCardScreenFuncs STGMCARD_funcs;
extern SaveIcon STGMCARD_saveIcon;
extern MemCardWindowSpec STGMCARD_detailWindows[];
extern s32 STGMCARD_partnerAnims[][7];
extern s32 STGMCARD_partnerIcons[];
extern s32 STGMCARD_slotIconX[];
extern s32 STGMCARD_errorTexts[]; /* the texts of the errors, by result */
extern s32 STGMCARD_places[];
extern MemCardModeEntry STGMCARD_prevModes[];
 
#endif /* STGMCARD_H */