fork/training-mode-ce

git clone https://git.julia.blue/fork/training-mode-ce

Nick CondronMenu overhaul (#298)a385936

master
41.5 KiB1291 linesraw
1#include "lab_common.h"
2#include <stddef.h>
3
4// Static Variables
5static Arch_ImportData *stc_import_assets;
6static ImportData import_data;
7static char *slots_names[] = {"A", "B"};
8static GXColor text_white = {255, 255, 255, 255};
9static GXColor text_gold = {255, 211, 0, 255};
10
11static EventDesc *event_desc;
12
13ExportHeader *GetExportHeaderFromCard(int slot, char *fileName, void *buffer);
14int CSS_ID(int ext_id);
15int GetSelectedFighterIdOnCssForHmn();
16void Memcard_Wait(void);
17void Menu_Left_Right(int down, u8* cursor);
18void Menu_SelFile_Init(GOBJ *menu_gobj);
19void Menu_SelFile_Exit(GOBJ *menu_gobj);
20void Menu_SelFile_Think(GOBJ *menu_gobj);
21int Menu_SelFile_LoadPage(GOBJ *menu_gobj, int page);
22void Menu_SelCard_Init(GOBJ *menu_gobj);
23void Menu_SelCard_Exit(GOBJ *menu_gobj);
24void Menu_SelCard_Think(GOBJ *menu_gobj);
25
26// OnLoad
27void OnCSSLoad(HSD_Archive *archive)
28{
29    // get assets from this file
30    stc_import_assets = Archive_GetPublicAddress(archive, "labCSS");
31
32    // Create a cobj for the menu
33    COBJ *cam_cobj = COBJ_LoadDesc(stc_import_assets->import_cam);
34    GOBJ *cam_gobj = GObj_Create(2, 3, 128);
35    GObj_AddObject(cam_gobj, R13_U8(-0x3E55), cam_cobj);
36    GOBJ_InitCamera(cam_gobj, CObjThink_Common, 1);
37    GObj_AddProc(cam_gobj, MainMenu_CamRotateThink, 5);
38    cam_gobj->cobj_links = 1 << MENUCAM_GXLINK;
39
40    // Create text canvas
41    import_data.canvas = Text_CreateCanvas(SIS_ID, 0, 2, 3, 128, MENUCAM_GXLINK, 129, 0);
42    import_data.confirm.canvas = Text_CreateCanvas(SIS_ID, 0, 2, 3, 128, MENUCAM_GXLINK, 131, 0);
43
44    // allocate filename array
45    import_data.file_info = calloc(CARD_MAX_FILE * sizeof(FileInfo)); // allocate 128 entries
46    // allocate filename buffers
47    for (int i = 0; i < CARD_MAX_FILE; i++)
48    {
49        import_data.file_info[i].file_name = calloc(CARD_FILENAME_MAX);
50    }
51
52    // alloc file header array
53    import_data.header = calloc(IMPORT_FILESPERPAGE * sizeof(ExportHeader));
54
55    // alloc image (needs to be 32 byte aligned)
56    import_data.snap.image = calloc(GXGetTexBufferSize(RESIZE_WIDTH, RESIZE_HEIGHT, 4, 0, 0)); // allocate 128 entries
57
58    // HUGE HACK ALERT -- manually gets function offset of TM_GetEventDesc
59    EventDesc *(*GetEventDesc)(int page, int event) = RTOC_PTR(TM_FUNC + (1 * 4));
60    event_desc = GetEventDesc(1, 0);
61    event_desc->stage = -1;
62    *onload_fileno = -1;
63
64    Cam_Button_Create();
65    Hazards_Button_Create();
66}
67
68void Read_Recordings()
69{
70    // search card for save files
71    import_data.file_num = 0;
72    import_data.hidden_file_num = 0;
73    int slot = import_data.memcard_slot;
74    s32 memSize, sectorSize;
75
76    int hmnCSSId = CSS_ID(GetSelectedFighterIdOnCssForHmn());
77
78    if (CARDProbeEx(slot, &memSize, &sectorSize) == CARD_RESULT_READY)
79    {
80        // mount card
81        stc_memcard_work->is_done = 0;
82        if (CARDMountAsync(slot, stc_memcard_work->work_area, 0, Memcard_RemovedCallback) == CARD_RESULT_READY)
83        {
84            // check card
85            Memcard_Wait();
86            stc_memcard_work->is_done = 0;
87            if (CARDCheckAsync(slot, Memcard_RemovedCallback) == CARD_RESULT_READY)
88            {
89                Memcard_Wait();
90
91                // get free blocks
92                s32 byteNotUsed, filesNotUsed;
93                if (CARDFreeBlocks(slot, &byteNotUsed, &filesNotUsed) == CARD_RESULT_READY)
94                {
95                    void *buffer = calloc(CARD_READ_SIZE);
96
97                    // search for files with name TMREC
98                    for (int i = 0; i < CARD_MAX_FILE; i++)
99                    {
100                        CARDStat card_stat;
101
102                        if (CARDGetStatus(slot, i, &card_stat) != CARD_RESULT_READY)
103                            continue;
104
105                        // check file matches expectations
106                        if (strncmp(os_info->company, (char *)card_stat.company, sizeof(os_info->company)) != 0 ||
107                                strncmp(os_info->gameName, (char *)card_stat.gameName, sizeof(os_info->gameName)) != 0 ||
108                                strncmp("TMREC", card_stat.fileName, 5) != 0)
109                            continue;
110
111                        if (hmnCSSId != -1)
112                        {
113                            ExportHeader *header = GetExportHeaderFromCard(slot, card_stat.fileName, buffer);
114
115                            if (CSS_ID(header->metadata.hmn) != hmnCSSId && CSS_ID(header->metadata.cpu) != hmnCSSId)
116                            {
117                                import_data.hidden_file_num++;
118                                continue;
119                            }
120                        }
121
122                        import_data.file_info[import_data.file_num].file_size = card_stat.length;                                      // save file size
123                        import_data.file_info[import_data.file_num].file_no = i;                                                       // save file no
124                        memcpy(import_data.file_info[import_data.file_num].file_name, card_stat.fileName, sizeof(card_stat.fileName)); // save file name
125                        import_data.file_num++;                                                                                        // increment file amount
126                    }
127
128                    // free temp read buffer
129                    HSD_Free(buffer);
130                }
131            }
132
133            CARDUnmount(slot);
134            stc_memcard_work->is_done = 0;
135        }
136    }
137}
138
139// Button Functions
140void Cam_Button_Create()
141{
142    // Create GOBJ
143    GOBJ *button_gobj = GObj_Create(4, 5, 0);
144    GObj_AddGXLink(button_gobj, GXLink_Common, 1, 128);
145    GObj_AddProc(button_gobj, Cam_Button_Think, 8);
146    JOBJ *button_jobj = JOBJ_LoadJoint(stc_import_assets->import_button);
147    GObj_AddObject(button_gobj, R13_U8(-0x3E55), button_jobj);
148
149    // scale message jobj
150    Vec3 *scale = &button_jobj->scale;
151    button_jobj->trans.Y += 3.0;
152
153    // Create text object
154    Text *button_text = Text_CreateText(SIS_ID, 0);
155    button_text->kerning = 1;
156    button_text->align = 1;
157    button_text->use_aspect = 1;
158    button_text->viewport_scale.X = (scale->X * 0.01) * 3;
159    button_text->viewport_scale.Y = (scale->Y * 0.01) * 3;
160    button_text->trans.X = button_jobj->trans.X + (0 * (scale->X / 4.0));
161    button_text->trans.Y = (button_jobj->trans.Y * -1) + (-1.6 * (scale->Y / 4.0));
162
163    Text_AddSubtext(button_text, 0, 0, "Import");
164}
165
166void Cam_Button_Think(GOBJ *button_gobj)
167{
168
169#define BUTTON_WIDTH 5
170#define BUTTON_HEIGHT 2.2
171
172    // init
173    CSSCursor *this_cursor = stc_css_cursors[0]; // get the main player's hand cursor data
174    Vec2 cursor_pos = this_cursor->pos;
175    cursor_pos.X += 5;
176    cursor_pos.Y -= 1;
177    HSD_Pad *pads = stc_css_pad;
178    HSD_Pad *this_pad = &pads[*stc_css_hmnport];
179    int down = this_pad->down;                   // get this cursors inputs
180    JOBJ *button_jobj = button_gobj->hsd_object; // get jobj
181    Vec3 *button_pos = &button_jobj->trans;
182
183    // check if cursor is hovered over button
184    if ((import_data.menu_gobj == 0) &&
185        (cursor_pos.X < (button_pos->X + BUTTON_WIDTH)) &&
186        (cursor_pos.X > (button_pos->X - BUTTON_WIDTH)) &&
187        (cursor_pos.Y < (button_pos->Y + BUTTON_HEIGHT)) &&
188        (cursor_pos.Y > (button_pos->Y - BUTTON_HEIGHT)) &&
189        (down & HSD_BUTTON_A))
190    {
191        import_data.menu_gobj = Menu_Create();
192        SFX_PlayCommon(1);
193    }
194}
195
196static char *hazard_button_text_options[] = {"Hazards: On", "Hazards: Off"};
197static Text *hazard_button_text;
198static int hazard_button_subtext;
199
200void Hazards_Button_Create()
201{
202    // Create GOBJ
203    GOBJ *button_gobj = GObj_Create(4, 5, 0);
204    GObj_AddGXLink(button_gobj, GXLink_Common, 1, 128);
205    GObj_AddProc(button_gobj, Hazards_Button_Think, 8);
206    JOBJ *button_jobj = JOBJ_LoadJoint(stc_import_assets->import_button);
207    GObj_AddObject(button_gobj, R13_U8(-0x3E55), button_jobj);
208
209    // scale message jobj
210    Vec3 *scale = &button_jobj->scale;
211    button_jobj->scale.X = 3.0;
212    button_jobj->trans.Y -= 3.0;
213
214    // Create text object
215    hazard_button_text = Text_CreateText(SIS_ID, 0);
216    hazard_button_text->kerning = 1;
217    hazard_button_text->align = 1;
218    hazard_button_text->use_aspect = 1;
219    hazard_button_text->viewport_scale.X = (scale->X * 0.01) * 2;
220    hazard_button_text->viewport_scale.Y = (scale->Y * 0.01) * 3;
221    hazard_button_text->trans.X = button_jobj->trans.X + (0 * (scale->X / 4.0));
222    hazard_button_text->trans.Y = (button_jobj->trans.Y * -1) + (-1.6 * (scale->Y / 4.0));
223
224    char *text = hazard_button_text_options[event_desc->disable_hazards];
225    hazard_button_subtext = Text_AddSubtext(hazard_button_text, 0, 0, text);
226}
227
228void Hazards_Button_Think(GOBJ *button_gobj)
229{
230    // init
231    CSSCursor *this_cursor = stc_css_cursors[0]; // get the main player's hand cursor data
232    Vec2 cursor_pos = this_cursor->pos;
233    cursor_pos.X += 5;
234    cursor_pos.Y -= 1;
235    HSD_Pad *pads = stc_css_pad;
236    HSD_Pad *this_pad = &pads[*stc_css_hmnport];
237    int down = this_pad->down;                   // get this cursors inputs
238    JOBJ *button_jobj = button_gobj->hsd_object; // get jobj
239    Vec3 *button_pos = &button_jobj->trans;
240
241    // check if cursor is hovered over button
242    if ((import_data.menu_gobj == 0) &&
243        (cursor_pos.X < (button_pos->X + BUTTON_WIDTH)) &&
244        (cursor_pos.X > (button_pos->X - BUTTON_WIDTH)) &&
245        (cursor_pos.Y < (button_pos->Y + BUTTON_HEIGHT)) &&
246        (cursor_pos.Y > (button_pos->Y - BUTTON_HEIGHT)) &&
247        (down & HSD_BUTTON_A))
248    {
249        SFX_PlayCommon(1);
250        int new_hazard_state = !event_desc->disable_hazards;
251        event_desc->disable_hazards = new_hazard_state;
252        char *new_text = hazard_button_text_options[new_hazard_state];
253        Text_SetText(hazard_button_text, hazard_button_subtext, new_text);
254    }
255}
256
257// Import Menu Functions
258GOBJ *Menu_Create()
259{
260    // Create GOBJ
261    GOBJ *menu_gobj = GObj_Create(4, 5, 0);
262    GObj_AddGXLink(menu_gobj, GXLink_Common, MENUCAM_GXLINK, 128);
263    GObj_AddProc(menu_gobj, Menu_Think, 1);
264    JOBJ *menu_jobj = JOBJ_LoadJoint(stc_import_assets->import_menu);
265    GObj_AddObject(menu_gobj, R13_U8(-0x3E55), menu_jobj);
266
267    // save jobj pointers
268    JOBJ_GetChild(menu_jobj, &import_data.memcard_jobj[0], 2, -1);
269    JOBJ_GetChild(menu_jobj, &import_data.memcard_jobj[1], 4, -1);
270    JOBJ_GetChild(menu_jobj, &import_data.screenshot_jobj, 6, -1);
271    JOBJ_GetChild(menu_jobj, &import_data.scroll_jobj, 7, -1);
272    JOBJ_GetChild(menu_jobj, &import_data.scroll_top, 9, -1);
273    JOBJ_GetChild(menu_jobj, &import_data.scroll_bot, 10, -1);
274
275    // hide all
276    JOBJ_SetFlagsAll(import_data.memcard_jobj[0], JOBJ_HIDDEN);
277    JOBJ_SetFlagsAll(import_data.memcard_jobj[1], JOBJ_HIDDEN);
278    JOBJ_SetFlagsAll(import_data.screenshot_jobj, JOBJ_HIDDEN);
279    JOBJ_SetFlagsAll(import_data.scroll_jobj, JOBJ_HIDDEN);
280
281    // create title and desc text
282    Text *title_text = Text_CreateText(SIS_ID, import_data.canvas);
283    title_text->kerning = 1;
284    title_text->use_aspect = 1;
285    title_text->aspect.X = 305;
286    title_text->trans.X = -28;
287    title_text->trans.Y = -21;
288    title_text->trans.Z = menu_jobj->trans.Z;
289    title_text->viewport_scale.X = (menu_jobj->scale.X * 0.01) * 11;
290    title_text->viewport_scale.Y = (menu_jobj->scale.Y * 0.01) * 11;
291    Text_AddSubtext(title_text, 0, 0, "-");
292    import_data.title_text = title_text;
293    Text *desc_text = Text_CreateText(SIS_ID, import_data.canvas);
294    desc_text->kerning = 1;
295    desc_text->use_aspect = 1;
296    desc_text->aspect.X = 930;
297    desc_text->trans.X = -28;
298    desc_text->trans.Y = 14.5;
299    desc_text->trans.Z = menu_jobj->trans.Z;
300    desc_text->viewport_scale.X = (menu_jobj->scale.X * 0.01) * 5;
301    desc_text->viewport_scale.Y = (menu_jobj->scale.Y * 0.01) * 5;
302    Text_AddSubtext(desc_text, 0, 0, "-");
303    Text_AddSubtext(desc_text, 0, 80, "");
304    import_data.desc_text = desc_text;
305
306    // disable inputs for CSS
307    *stc_css_exitkind = 5;
308
309    // init card select menu
310    Menu_SelCard_Init(menu_gobj);
311
312    return menu_gobj;
313}
314void Menu_Destroy(GOBJ *menu_gobj)
315{
316    // run specific menu state code
317    switch (import_data.menu_state)
318    {
319    case (IMP_SELCARD):
320    {
321        Menu_SelCard_Exit(menu_gobj);
322        break;
323    }
324    case (IMP_SELFILE):
325    {
326        Menu_SelFile_Exit(menu_gobj);
327        break;
328    }
329    }
330
331    // destroy text
332    Text_Destroy(import_data.title_text);
333    import_data.title_text = 0;
334    Text_Destroy(import_data.desc_text);
335    import_data.desc_text = 0;
336
337    // destroy gobj
338    GObj_Destroy(menu_gobj);
339    import_data.menu_gobj = 0;
340
341    // enable CSS inputs
342    *stc_css_exitkind = 0;
343    *stc_css_delay = 0;
344}
345void Menu_Think(GOBJ *menu_gobj)
346{
347
348    *stc_css_delay = 2;
349
350    switch (import_data.menu_state)
351    {
352    case (IMP_SELCARD):
353    {
354        Menu_SelCard_Think(menu_gobj);
355        break;
356    }
357    case (IMP_SELFILE):
358    {
359        Menu_SelFile_Think(menu_gobj);
360        break;
361    }
362    case (IMP_CONFIRM):
363    {
364        Menu_Confirm_Think(menu_gobj);
365        break;
366    }
367    }
368}
369// Select Card
370void Menu_SelCard_Init(GOBJ *menu_gobj)
371{
372
373    // get jobj
374    JOBJ *menu_jobj = menu_gobj->hsd_object;
375
376    // init state and cursor
377    import_data.menu_state = IMP_SELCARD;
378    import_data.cursor = 0;
379
380    // init memcard inserted state
381    import_data.memcard_inserted[0] = 0;
382    import_data.memcard_inserted[1] = 0;
383
384    // show memcards
385    JOBJ_ClearFlagsAll(import_data.memcard_jobj[0], JOBJ_HIDDEN);
386    JOBJ_ClearFlagsAll(import_data.memcard_jobj[1], JOBJ_HIDDEN);
387
388    // create memcard text
389    Text *memcard_text = Text_CreateText(SIS_ID, import_data.canvas);
390    memcard_text->kerning = 1;
391    memcard_text->align = 1;
392    memcard_text->trans.Z = menu_jobj->trans.Z + 2;
393    memcard_text->viewport_scale.X = (menu_jobj->scale.X * 0.01) * 5;
394    memcard_text->viewport_scale.Y = (menu_jobj->scale.Y * 0.01) * 5;
395    import_data.option_text = memcard_text;
396    Text_AddSubtext(memcard_text, -159, 45, "Slot A");
397    Text_AddSubtext(memcard_text, 159, 45, "Slot B");
398
399    // edit title
400    Text_SetText(import_data.title_text, 0, "Select Memory Card");
401
402    // edit description
403    Text_SetText(import_data.desc_text, 0, "");
404}
405void Menu_SelCard_Think(GOBJ *menu_gobj)
406{
407    // update memcard info
408    for (int i = 0; i <= 1; i++)
409    {
410        // probe slot
411        s32 memSize, sectorSize;
412        if (CARDProbeEx(i, &memSize, &sectorSize) != CARD_RESULT_READY)
413        {
414            import_data.memcard_inserted[i] = 0;
415            continue;
416        }
417
418        // skip good memcards
419        if (import_data.memcard_inserted[i] == 1)
420            continue;
421
422        // mount card
423        stc_memcard_work->is_done = 0;
424        if (CARDMountAsync(i, stc_memcard_work->work_area, 0, Memcard_RemovedCallback) != CARD_RESULT_READY)
425            continue;
426
427        // check card
428        Memcard_Wait();
429        stc_memcard_work->is_done = 0;
430        if (CARDCheckAsync(i, Memcard_RemovedCallback) == CARD_RESULT_READY)
431        {
432            Memcard_Wait();
433
434            // if we get this far, a valid memcard is inserted
435            import_data.memcard_inserted[i] = 1;
436            SFX_PlayCommon(2);
437        }
438
439        CARDUnmount(i);
440        stc_memcard_work->is_done = 0;
441    }
442
443    // cursor movement
444    int down = Pad_GetRapidHeld(*stc_css_hmnport);
445    Menu_Left_Right(down, &import_data.cursor);
446
447    // highlight cursor
448    for (int i = 0; i < 2; i++)
449    {
450        Text_SetColor(import_data.option_text, i, &text_white);
451    }
452    Text_SetColor(import_data.option_text, import_data.cursor, &text_gold);
453
454    if (import_data.memcard_inserted[import_data.cursor] == 0) {
455        Text_SetText(import_data.desc_text, 0, "No device is inserted in Slot %s.", slots_names[import_data.cursor]);
456    } else {
457        Text_SetText(import_data.desc_text, 0, "Load recording from the memory card in Slot %s.", slots_names[import_data.cursor]);
458        int hmnFighterId = GetSelectedFighterIdOnCssForHmn();
459        if (hmnFighterId != -1) {
460            Text_SetText(import_data.desc_text, 1, "(!) Filtered to selected character on CSS.");
461            Text_SetColor(import_data.desc_text, 1, &text_gold);
462        }
463    }
464
465    if (down & HSD_BUTTON_B)
466    {
467        Menu_Destroy(menu_gobj);
468        SFX_PlayCommon(0);
469    }
470    else if (down & HSD_BUTTON_A)
471    {
472        // check if valid memcard inserted
473        if (import_data.memcard_inserted[import_data.cursor])
474        {
475            import_data.memcard_slot = import_data.cursor;
476            SFX_PlayCommon(1);
477            Menu_SelCard_Exit(menu_gobj);
478            Menu_SelFile_Init(menu_gobj);
479        }
480        else
481            SFX_PlayCommon(3);
482    }
483}
484void Menu_SelCard_Exit(GOBJ *menu_gobj)
485{
486    JOBJ_SetFlagsAll(import_data.memcard_jobj[0], JOBJ_HIDDEN);
487    JOBJ_SetFlagsAll(import_data.memcard_jobj[1], JOBJ_HIDDEN);
488
489    // destroy memcard text
490    Text_Destroy(import_data.option_text);
491    import_data.option_text = 0;
492}
493// Select File
494void Menu_SelFile_Init(GOBJ *menu_gobj)
495{
496    Read_Recordings();
497    if (import_data.file_num == 0)
498    {
499        Menu_Confirm_Init(menu_gobj, CFRM_NONE);
500        SFX_PlayCommon(3);
501        return;
502    }
503
504    // get jobj
505    JOBJ *menu_jobj = menu_gobj->hsd_object;
506
507    // init state and cursor
508    import_data.menu_state = IMP_SELFILE;
509    import_data.cursor = 0;
510    import_data.page = 0;
511
512    JOBJ_ClearFlagsAll(import_data.scroll_jobj, JOBJ_HIDDEN);
513
514    // create file name text
515    Text *filename_text = Text_CreateText(SIS_ID, import_data.canvas);
516    filename_text->kerning = 1;
517    filename_text->align = 0;
518    filename_text->use_aspect = 1;
519    filename_text->aspect.X = 525;
520    filename_text->trans.X = -27.8;
521    filename_text->trans.Y = -13.6;
522    filename_text->trans.Z = menu_jobj->trans.Z;
523    filename_text->viewport_scale.X = (menu_jobj->scale.X * 0.01) * 5;
524    filename_text->viewport_scale.Y = (menu_jobj->scale.Y * 0.01) * 5;
525    import_data.filename_text = filename_text;
526    for (int i = 0; i < IMPORT_FILESPERPAGE; i++)
527    {
528        Text_AddSubtext(filename_text, 0, i * 40, "");
529    }
530
531#define FILEINFO_X 235
532#define FILEINFO_Y -20
533#define FILEINFO_YOFFSET 35
534#define FILEINFO_STAGEY FILEINFO_Y
535#define FILEINFO_HMNY FILEINFO_STAGEY + FILEINFO_YOFFSET
536#define FILEINFO_CPUY FILEINFO_HMNY + FILEINFO_YOFFSET
537#define FILEINFO_DATEY FILEINFO_CPUY + (FILEINFO_YOFFSET * 2)
538#define FILEINFO_TIMEY FILEINFO_DATEY + FILEINFO_YOFFSET
539
540    // create file info text
541    Text *fileinfo_text = Text_CreateText(SIS_ID, import_data.canvas);
542    fileinfo_text->kerning = 1;
543    fileinfo_text->align = 0;
544    fileinfo_text->use_aspect = 1;
545    fileinfo_text->aspect.X = 300;
546    fileinfo_text->trans.Z = menu_jobj->trans.Z;
547    fileinfo_text->viewport_scale.X = (menu_jobj->scale.X * 0.01) * 4.5;
548    fileinfo_text->viewport_scale.Y = (menu_jobj->scale.Y * 0.01) * 4.5;
549    import_data.fileinfo_text = fileinfo_text;
550    Text_AddSubtext(fileinfo_text, FILEINFO_X, FILEINFO_STAGEY, "Stage: ");
551    Text_AddSubtext(fileinfo_text, FILEINFO_X, FILEINFO_HMNY, "HMN: ");
552    Text_AddSubtext(fileinfo_text, FILEINFO_X, FILEINFO_CPUY, "CPU: ");
553    Text_AddSubtext(fileinfo_text, FILEINFO_X, FILEINFO_DATEY, "Date: ");
554    Text_AddSubtext(fileinfo_text, FILEINFO_X, FILEINFO_TIMEY, "Time: ");
555
556    // edit title
557    Text_SetText(import_data.title_text, 0, "Select Recording");
558
559    // edit description
560    Text_SetText(import_data.desc_text, 0, "A = Select   B = Return   X = Delete   Y = Swap Sheik/Zelda");
561    if (import_data.hidden_file_num > 0)
562    {
563        Text_SetText(import_data.desc_text, 1, "(!) Filtered to selected character on CSS, %d hidden.", import_data.hidden_file_num);
564        Text_SetColor(import_data.desc_text, 1, &text_gold);
565    }
566
567    // init scroll bar according to import_data.file_num
568    int page_total = (import_data.file_num + IMPORT_FILESPERPAGE - 1) / IMPORT_FILESPERPAGE;
569    if (page_total <= 1)
570        JOBJ_SetFlagsAll(import_data.scroll_jobj, JOBJ_HIDDEN);
571    else
572        import_data.scroll_bot->trans.Y = -16.2 / page_total;
573
574    // load in first page recordings
575    int page_result = Menu_SelFile_LoadPage(menu_gobj, 0);
576    if (page_result == -1)
577    {
578        // create dialog
579        Menu_Confirm_Init(menu_gobj, CFRM_ERR);
580        SFX_PlayCommon(3);
581    }
582}
583void Menu_SelFile_Think(GOBJ *menu_gobj)
584{
585    // init
586    int down = Pad_GetRapidHeld(*stc_css_hmnport);
587
588    // first ensure memcard is still inserted
589    s32 memSize, sectorSize;
590    if (CARDProbeEx(import_data.memcard_slot, &memSize, &sectorSize) != CARD_RESULT_READY)
591        goto EXIT;
592
593    // if no files exist
594    if (import_data.file_num == 0)
595    {
596        if (down & (HSD_BUTTON_B | HSD_BUTTON_A))
597            goto EXIT;
598        return;
599    }
600
601    // cursor movement
602    int curr_page = import_data.page;
603    int curr_cursor = import_data.cursor;
604    if (down & (HSD_BUTTON_UP | HSD_BUTTON_DPAD_UP))
605    {
606        import_data.cursor--;
607    }
608    else if (down & (HSD_BUTTON_LEFT | HSD_BUTTON_DPAD_LEFT))
609    {
610        import_data.cursor = 0;
611        import_data.page--;
612    }
613    else if (down & (HSD_BUTTON_DOWN | HSD_BUTTON_DPAD_DOWN))
614    {
615        import_data.cursor++;
616    }
617    else if (down & (HSD_BUTTON_RIGHT | HSD_BUTTON_DPAD_RIGHT))
618    {
619        import_data.cursor = 0;
620        import_data.page++;
621    }
622
623    // handle cursor/page overflow and wrap pages
624    int total_pages = (import_data.file_num + IMPORT_FILESPERPAGE - 1) / IMPORT_FILESPERPAGE;
625    if (import_data.cursor == 255)
626    {
627        import_data.cursor = IMPORT_FILESPERPAGE - 1;
628        import_data.page--;
629    }
630    else if (import_data.cursor >= IMPORT_FILESPERPAGE ||
631        (import_data.page == total_pages - 1 &&
632        import_data.cursor > (import_data.file_num - 1) % IMPORT_FILESPERPAGE))
633    {
634        import_data.cursor = 0;
635        import_data.page++;
636    }
637    if (import_data.page == 255)
638    {
639        import_data.page = total_pages - 1;
640        if (import_data.cursor > (import_data.file_num - 1) % IMPORT_FILESPERPAGE)
641            import_data.cursor = (import_data.file_num - 1) % IMPORT_FILESPERPAGE;
642    }
643    else if (import_data.page >= total_pages)
644    {
645        import_data.page = 0;
646    }
647
648    // Load new page if necessary and play sound
649    if (import_data.page != curr_page)
650    {
651        // try to load page
652        int page_result = Menu_SelFile_LoadPage(menu_gobj, import_data.page);
653        if (page_result == -1)
654        {
655            // create dialog
656            Menu_Confirm_Init(menu_gobj, CFRM_ERR);
657            SFX_PlayCommon(3);
658            return;
659        }
660        SFX_PlayCommon(2);
661    }
662    else if (import_data.cursor != curr_cursor)
663    {
664        SFX_PlayCommon(2);
665    }
666
667    // highlight cursor
668    int cursor = import_data.cursor;
669    for (int i = 0; i < IMPORT_FILESPERPAGE; i++)
670    {
671        Text_SetColor(import_data.filename_text, i, &text_white);
672    }
673    Text_SetColor(import_data.filename_text, cursor, &text_gold);
674
675    // update file info text from header data
676    ExportHeader *header = &import_data.header[cursor];
677
678    // update file info text
679    Text_SetText(import_data.fileinfo_text, 0, "Stage: %s", stage_names[header->metadata.stage_internal]);
680    Text_SetText(import_data.fileinfo_text, 1, "HMN: %s", Fighter_GetName(header->metadata.hmn));
681    Text_SetText(import_data.fileinfo_text, 2, "CPU: %s", Fighter_GetName(header->metadata.cpu));
682    Text_SetText(import_data.fileinfo_text, 3, "Date: %d/%d/%d", header->metadata.month, header->metadata.day, header->metadata.year);
683    Text_SetText(import_data.fileinfo_text, 4, "Time: %d:%02d:%02d", header->metadata.hour, header->metadata.minute, header->metadata.second);
684
685
686    // check for exit
687    if (down & HSD_BUTTON_B)
688    {
689    EXIT:
690        SFX_PlayCommon(0);
691        Menu_SelFile_Exit(menu_gobj);
692        Menu_SelCard_Init(menu_gobj);
693    }
694
695    // check to delete
696    else if (down & HSD_BUTTON_X)
697    {
698        Menu_Confirm_Init(menu_gobj, CFRM_DEL);
699        SFX_PlayCommon(1);
700    }
701    
702    else if (down & HSD_BUTTON_Y)
703    {
704        // Rwing exports only swap the hmn. 
705        if (header->metadata.hmn == CKIND_ZELDA)
706            header->metadata.hmn = CKIND_SHEIK; 
707        else if (header->metadata.hmn == CKIND_SHEIK)
708            header->metadata.hmn = CKIND_ZELDA;
709             
710        SFX_PlayCommon(1);
711    }
712
713    // check for select
714    else if (down & HSD_BUTTON_A)
715    {
716        int kind;                                               // init confirm kind
717        int vers = import_data.header[cursor].metadata.version; // get version number
718
719        // check if version is compatible with this release
720        if (vers == REC_VERS)
721            kind = CFRM_LOAD;
722        else if (vers > REC_VERS)
723            kind = CFRM_NEW;
724        else if (vers < REC_VERS)
725            kind = CFRM_OLD;
726
727        // open confirm dialog
728        Menu_Confirm_Init(menu_gobj, kind);
729        SFX_PlayCommon(1);
730    }
731}
732void Menu_SelFile_Exit(GOBJ *menu_gobj)
733{
734    Text_SetText(import_data.desc_text, 1, "");
735    JOBJ_SetFlagsAll(import_data.scroll_jobj, JOBJ_HIDDEN);
736    JOBJ_SetFlagsAll(import_data.screenshot_jobj, JOBJ_HIDDEN);
737
738    // destroy option text
739    Text_Destroy(import_data.filename_text);
740    import_data.filename_text = 0;
741    Text_Destroy(import_data.fileinfo_text);
742    import_data.fileinfo_text = 0;
743
744    // cancel card read if in progress
745    int memcard_status = Memcard_CheckStatus();
746    if (memcard_status == 11)
747    {
748        // cancel read
749        stc_memcard_work->card_file_info.length = -1;
750
751        // wait for callback to fire
752        // i do this because the callback will always set some
753        // variable in the workarea regardless of its cancelled
754        while (memcard_status == 11)
755        {
756            memcard_status = Memcard_CheckStatus();
757        }
758    }
759
760    // free prev buffers
761    for (int i = 0; i < IMPORT_FILESPERPAGE; i++)
762    {
763        // if exists
764        if (import_data.snap.file_data[i] != 0)
765        {
766            HSD_Free(import_data.snap.file_data[i]);
767            import_data.snap.file_data[i] = 0;
768        }
769    }
770}
771int Menu_SelFile_LoadPage(GOBJ *menu_gobj, int page)
772{
773    int result = 0;
774    int page_total = (import_data.file_num + IMPORT_FILESPERPAGE - 1) / IMPORT_FILESPERPAGE;
775
776    // ensure page exists
777    if (page < 0 || page >= page_total)
778        assert("page index out of bounds");
779
780    // determine files on page
781    int files_on_page = IMPORT_FILESPERPAGE;
782    if (page == page_total - 1)
783        files_on_page = ((import_data.file_num-1) % IMPORT_FILESPERPAGE) + 1;
784
785    // cancel card read if in progress
786    int memcard_status = Memcard_CheckStatus();
787    if (memcard_status == 11)
788    {
789        // cancel read
790        stc_memcard_work->card_file_info.length = -1;
791
792        // wait for callback to fire
793        while (memcard_status == 11)
794        {
795            memcard_status = Memcard_CheckStatus();
796        }
797    }
798
799    void *buffer = calloc(CARD_READ_SIZE);
800    import_data.snap.loaded_num = 0;
801    import_data.snap.load_inprogress = 0;
802    for (int i = 0; i < IMPORT_FILESPERPAGE; i++)
803    {
804        import_data.snap.is_loaded[i] = 0; // init files as unloaded
805    }
806    result = 1; // set page as toggled
807    int slot = import_data.memcard_slot;
808
809    // update scroll bar position
810    import_data.scroll_top->trans.Y = page * import_data.scroll_bot->trans.Y;
811    JOBJ_SetMtxDirtySub(menu_gobj->hsd_object);
812
813    // free prev buffers
814    for (int i = 0; i < IMPORT_FILESPERPAGE; i++)
815    {
816        // if exists
817        if (import_data.snap.file_data[i] != 0)
818        {
819            HSD_Free(import_data.snap.file_data[i]);
820            import_data.snap.file_data[i] = 0;
821        }
822    }
823
824    // blank out all text
825    for (int i = 0; i < IMPORT_FILESPERPAGE; i++)
826    {
827        Text_SetText(import_data.filename_text, i, "");
828    }
829
830    // mount card
831    s32 memSize, sectorSize;
832    if (CARDProbeEx(slot, &memSize, &sectorSize) == CARD_RESULT_READY)
833    {
834        // mount card
835        stc_memcard_work->is_done = 0;
836        if (CARDMountAsync(slot, stc_memcard_work->work_area, 0, Memcard_RemovedCallback) == CARD_RESULT_READY)
837        {
838            Memcard_Wait();
839
840            // check card
841            stc_memcard_work->is_done = 0;
842            if (CARDCheckAsync(slot, Memcard_RemovedCallback) == CARD_RESULT_READY)
843            {
844                Memcard_Wait();
845
846                // begin loading this page's files
847                for (int i = 0; i < files_on_page; i++)
848                {
849                    // get file info
850                    int this_file_index = (page * IMPORT_FILESPERPAGE) + i;
851                    char *file_name = import_data.file_info[this_file_index].file_name;
852                    int file_no = import_data.file_info[this_file_index].file_no;
853
854                    // get comment from card
855                    CARDStat card_stat;
856
857                    // get status
858                    if (CARDGetStatus(slot, file_no, &card_stat) != CARD_RESULT_READY)
859                        continue;
860
861                    ExportHeader *header = GetExportHeaderFromCard(slot, file_name, buffer);
862                    if (!header)
863                        continue;
864
865                    memcpy(&import_data.header[i], header, sizeof(ExportHeader));
866                    Text_SetText(import_data.filename_text, i, header->metadata.filename);
867                }
868            }
869            // unmount
870            CARDUnmount(slot);
871            stc_memcard_work->is_done = 0;
872        }
873    }
874
875    // free temp read buffer
876    HSD_Free(buffer);
877
878    return result;
879}
880
881int Menu_SelFile_DeleteFile(GOBJ *menu_gobj, int file_index)
882{
883    int result = 0;
884    int slot = import_data.memcard_slot;
885
886    // mount card
887    s32 memSize, sectorSize;
888    if (CARDProbeEx(slot, &memSize, &sectorSize) == CARD_RESULT_READY)
889    {
890        // mount card
891        stc_memcard_work->is_done = 0;
892        if (CARDMountAsync(slot, stc_memcard_work->work_area, 0, Memcard_RemovedCallback) == CARD_RESULT_READY)
893        {
894            Memcard_Wait();
895
896            // check card
897            stc_memcard_work->is_done = 0;
898            if (CARDCheckAsync(slot, Memcard_RemovedCallback) == CARD_RESULT_READY)
899            {
900                Memcard_Wait();
901
902                // get file info
903                char *file_name = import_data.file_info[file_index].file_name;
904                CARDFileInfo card_file_info;
905
906                // open card (get file info)
907                if (CARDOpen(slot, file_name, &card_file_info) == CARD_RESULT_READY)
908                {
909                    // delete this file
910                    stc_memcard_work->is_done = 0;
911                    if (CARDDeleteAsync(slot, file_name, Memcard_RemovedCallback) == CARD_RESULT_READY)
912                    {
913                        Memcard_Wait();
914                        result = 1;
915                    }
916
917                    CARDClose(&card_file_info);
918                }
919            }
920            // unmount
921            CARDUnmount(slot);
922            stc_memcard_work->is_done = 0;
923        }
924    }
925
926    return result;
927}
928// Confirm Dialog
929void Menu_Confirm_Init(GOBJ *menu_gobj, int kind)
930{
931
932    // init cursor
933    import_data.confirm.cursor = 0;
934    import_data.menu_state = IMP_CONFIRM;
935    import_data.confirm.kind = kind;
936
937    // Create GOBJ
938    GOBJ *confirm_gobj = GObj_Create(4, 5, 0);
939    GObj_AddGXLink(confirm_gobj, GXLink_Common, MENUCAM_GXLINK, 130);
940    JOBJ *confirm_jobj = JOBJ_LoadJoint(stc_import_assets->import_popup);
941    GObj_AddObject(confirm_gobj, R13_U8(-0x3E55), confirm_jobj);
942    import_data.confirm.gobj = confirm_gobj;
943
944    // create text
945    Text *text = Text_CreateText(SIS_ID, import_data.confirm.canvas);
946    text->kerning = 1;
947    text->align = 1;
948    text->use_aspect = 1;
949    text->aspect.X = 380;
950    text->trans.Z = confirm_jobj->trans.Z;
951    text->viewport_scale.X = (confirm_jobj->scale.X * 0.01) * 6;
952    text->viewport_scale.Y = (confirm_jobj->scale.Y * 0.01) * 6;
953    import_data.confirm.text = text;
954
955    // decide text based on kind
956    switch (kind)
957    {
958    case (CFRM_LOAD):
959    {
960        Text_AddSubtext(text, 0, -50, "Load this recording?");
961        Text_AddSubtext(text, -65, 20, "Yes");
962        Text_AddSubtext(text, 65, 20, "No");
963        break;
964    }
965    case (CFRM_OLD):
966    {
967        Text_AddSubtext(text, 0, -50, "Cannot load outdated recording.");
968        Text_AddSubtext(text, 0, 20, "OK");
969        Text_SetColor(import_data.confirm.text, 1, &text_gold);
970        break;
971    }
972    case (CFRM_NEW):
973    {
974        Text_AddSubtext(text, 0, -50, "Cannot load newer recording.");
975        Text_AddSubtext(text, 0, 20, "OK");
976        Text_SetColor(import_data.confirm.text, 1, &text_gold);
977        break;
978    }
979    case(CFRM_NONE):
980    {
981        Text_AddSubtext(text, 0, -50, "No recordings found");
982        Text_AddSubtext(text, 0, 20, "OK");
983        Text_SetColor(import_data.confirm.text, 1, &text_gold);
984        break;
985    }
986    case (CFRM_DEL):
987    {
988        Text_AddSubtext(text, 0, -50, "Delete this recording?");
989        Text_AddSubtext(text, -65, 20, "Yes");
990        Text_AddSubtext(text, 65, 20, "No");
991        break;
992    }
993    case (CFRM_ERR):
994    {
995        Text_AddSubtext(text, 0, -70, "Corrupted recording(s) detected.");
996        Text_AddSubtext(text, 0, -35, "Would you like to delete them?");
997        Text_AddSubtext(text, -65, 40, "Yes");
998        Text_AddSubtext(text, 65, 40, "No");
999        break;
1000    }
1001    }
1002}
1003
1004void Menu_Left_Right(int down, u8* cursor)
1005{
1006    if (import_data.confirm.cursor > 1)
1007        assert("cursor out of bounds");
1008
1009    // cursor movement
1010    if (down & (HSD_BUTTON_RIGHT | HSD_BUTTON_DPAD_RIGHT))
1011    {
1012        if (*cursor == 0)
1013        {
1014            *cursor = 1;
1015            SFX_PlayCommon(2);
1016        }
1017    }
1018    else if (down & (HSD_BUTTON_LEFT | HSD_BUTTON_DPAD_LEFT))
1019    {
1020        if (*cursor == 1)
1021        {
1022            *cursor = 0;
1023            SFX_PlayCommon(2);
1024        }
1025    }
1026}
1027
1028void Menu_Confirm_Think(GOBJ *menu_gobj)
1029{
1030
1031    // init
1032    int down = Pad_GetRapidHeld(*stc_css_hmnport);
1033
1034    // first ensure memcard is still inserted
1035    s32 memSize, sectorSize;
1036    if (CARDProbeEx(import_data.memcard_slot, &memSize, &sectorSize) != CARD_RESULT_READY)
1037    {
1038        Menu_Confirm_Exit(menu_gobj);
1039        SFX_PlayCommon(0);
1040        import_data.menu_state = IMP_SELFILE;
1041        return;
1042    }
1043
1044    switch (import_data.confirm.kind)
1045    {
1046    case (CFRM_LOAD):
1047    {
1048        Menu_Left_Right(down, &import_data.confirm.cursor);
1049
1050        // highlight cursor
1051        int cursor = import_data.confirm.cursor;
1052        for (int i = 0; i < 2; i++)
1053        {
1054            Text_SetColor(import_data.confirm.text, i + 1, &text_white);
1055        }
1056        Text_SetColor(import_data.confirm.text, cursor + 1, &text_gold);
1057
1058        // check for exit
1059        if (down & HSD_BUTTON_B || (down & HSD_BUTTON_A && cursor == 1))
1060        {
1061            Menu_Confirm_Exit(menu_gobj);
1062            SFX_PlayCommon(0);
1063            import_data.menu_state = IMP_SELFILE;
1064        }
1065        else if (down & HSD_BUTTON_A)
1066        {
1067            // get variables and junk
1068            VSMinorData *css_minorscene = *stc_css_minorscene;
1069            int this_file_index = (import_data.page * IMPORT_FILESPERPAGE) + import_data.cursor;
1070            ExportHeader *header = &import_data.header[import_data.cursor];
1071            Preload *preload = Preload_GetTable();
1072
1073            // get match data
1074            u8 hmn_kind = header->metadata.hmn;
1075            u8 hmn_costume = header->metadata.hmn_costume;
1076            u8 cpu_kind = header->metadata.cpu;
1077            u8 cpu_costume = header->metadata.cpu_costume;
1078            u16 stage_kind = header->metadata.stage_external;
1079
1080            // set fighters
1081            css_minorscene->vs_data.match_init.playerData[0].c_kind = hmn_kind;
1082            css_minorscene->vs_data.match_init.playerData[0].costume = hmn_costume;
1083            preload->queued.fighters[0].kind = hmn_kind;
1084            preload->queued.fighters[0].costume = hmn_costume;
1085            css_minorscene->vs_data.match_init.playerData[1].c_kind = cpu_kind;
1086            css_minorscene->vs_data.match_init.playerData[1].costume = cpu_costume;
1087            preload->queued.fighters[1].kind = cpu_kind;
1088            preload->queued.fighters[1].costume = cpu_costume;
1089
1090            // set stage
1091            css_minorscene->vs_data.match_init.stage = stage_kind;
1092            preload->queued.stage = stage_kind;
1093
1094            // load files
1095            Preload_Update();
1096
1097            // advance scene
1098            *stc_css_exitkind = 1;
1099
1100            // HUGE HACK ALERT
1101            event_desc->stage = stage_kind;
1102            *onload_fileno = import_data.file_info[this_file_index].file_no;
1103            *onload_slot = import_data.memcard_slot;
1104            
1105            // prevent sheik/zelda transformation
1106            for (int i = 0; i < 4; ++i)
1107                stc_css_pad[i].held &= ~PAD_BUTTON_A;
1108
1109            SFX_PlayCommon(1);
1110        }
1111
1112        break;
1113    }
1114    case (CFRM_OLD):
1115    {
1116        // check for select
1117        if (down & (HSD_BUTTON_A | HSD_BUTTON_B))
1118        {
1119            Menu_Confirm_Exit(menu_gobj);
1120            SFX_PlayCommon(0);
1121            import_data.menu_state = IMP_SELFILE;
1122        }
1123        break;
1124    }
1125    case (CFRM_NEW):
1126    {
1127        // check for select
1128        if (down & (HSD_BUTTON_A | HSD_BUTTON_B))
1129        {
1130            Menu_Confirm_Exit(menu_gobj);
1131            SFX_PlayCommon(0);
1132            import_data.menu_state = IMP_SELFILE;
1133        }
1134        break;
1135    }
1136    case(CFRM_NONE):
1137    {
1138        // check for select
1139        if (down & (HSD_BUTTON_A | HSD_BUTTON_B))
1140        {
1141            Menu_Confirm_Exit(menu_gobj);
1142            SFX_PlayCommon(0);
1143            import_data.menu_state = IMP_SELCARD;
1144            Menu_SelCard_Init(menu_gobj);
1145        }
1146        break;
1147    }
1148    case (CFRM_DEL):
1149    {
1150        Menu_Left_Right(down, &import_data.confirm.cursor);
1151
1152        // highlight cursor
1153        int cursor = import_data.confirm.cursor;
1154        for (int i = 0; i < 2; i++)
1155        {
1156            Text_SetColor(import_data.confirm.text, i + 1, &text_white);
1157        }
1158        Text_SetColor(import_data.confirm.text, cursor + 1, &text_gold);
1159
1160        if (down & HSD_BUTTON_B || (down & HSD_BUTTON_A && cursor == 1))
1161        {
1162            // go back
1163            Menu_Confirm_Exit(menu_gobj);
1164            SFX_PlayCommon(0);
1165            import_data.menu_state = IMP_SELFILE;
1166        }
1167        else if (down & HSD_BUTTON_A)
1168        {
1169            SFX_PlayCommon(1);
1170
1171            // delete selected recording
1172            int file_idx = (import_data.page * IMPORT_FILESPERPAGE) + import_data.cursor;
1173            Menu_SelFile_DeleteFile(menu_gobj, file_idx);
1174
1175            // close dialog
1176            Menu_Confirm_Exit(menu_gobj);
1177
1178            // reload selfile menu
1179            Menu_SelFile_Exit(menu_gobj);
1180            Menu_SelFile_Init(menu_gobj);
1181
1182            // if there's no errors and we're still selecting files
1183            // reset the cursor to the location of the prev deleted file
1184            if (import_data.menu_state == IMP_SELFILE) {
1185                if (file_idx == import_data.file_num && file_idx > 0)
1186                    file_idx--;
1187                import_data.page = file_idx / IMPORT_FILESPERPAGE;
1188                import_data.cursor = file_idx % IMPORT_FILESPERPAGE;
1189
1190                int page_result = Menu_SelFile_LoadPage(menu_gobj, import_data.page);
1191                if (page_result == -1)
1192                {
1193                    // create dialog
1194                    Menu_Confirm_Init(menu_gobj, CFRM_ERR);
1195                    SFX_PlayCommon(3);
1196                }
1197            }
1198        }
1199        break;
1200    }
1201    case (CFRM_ERR):
1202    {
1203        Menu_Left_Right(down, &import_data.confirm.cursor);
1204
1205        // highlight cursor
1206        int cursor = import_data.confirm.cursor;
1207        for (int i = 0; i < 2; i++)
1208        {
1209            Text_SetColor(import_data.confirm.text, i + 2, &text_white);
1210        }
1211        Text_SetColor(import_data.confirm.text, cursor + 2, &text_gold);
1212
1213        // check for back
1214        if (down & HSD_BUTTON_B || (down & HSD_BUTTON_A && cursor == 1))
1215        {
1216            Menu_Confirm_Exit(menu_gobj); // close dialog
1217            Menu_SelFile_Exit(menu_gobj); // close select file
1218            Menu_SelCard_Init(menu_gobj); // open select card
1219            SFX_PlayCommon(0);
1220            //import_data.menu_state = IMP_SELCARD;
1221        }
1222        else if (down & HSD_BUTTON_A)
1223        {
1224            SFX_PlayCommon(1);
1225
1226            // close dialog
1227            Menu_Confirm_Exit(menu_gobj);
1228
1229            // reload selfile
1230            Menu_SelFile_Exit(menu_gobj); // close select file
1231            Menu_SelFile_Init(menu_gobj); // open select file
1232        }
1233        break;
1234    }
1235    }
1236}
1237void Menu_Confirm_Exit(GOBJ *menu_gobj)
1238{
1239    // destroy option text
1240    Text_Destroy(import_data.confirm.text);
1241    import_data.confirm.text = 0;
1242
1243    // destroy gobj
1244    GObj_Destroy(import_data.confirm.gobj);
1245    import_data.confirm.gobj = 0;
1246}
1247
1248// Misc functions
1249void Memcard_Wait(void)
1250{
1251    while (stc_memcard_work->is_done == 0)
1252    {
1253        blr2();
1254    }
1255}
1256ExportHeader *GetExportHeaderFromCard(int slot, char *fileName, void *buffer) {
1257    CARDFileInfo card_file_info;
1258
1259    // open card (get file info)
1260    if (CARDOpen(slot, fileName, &card_file_info) != CARD_RESULT_READY) {
1261        return NULL;
1262    }
1263
1264    if (CARDRead(&card_file_info, buffer, CARD_READ_SIZE, 0x1E00) != CARD_RESULT_READY) {
1265        CARDClose(&card_file_info);
1266        return NULL;
1267    }
1268
1269    // deobfuscate stupid melee bullshit
1270    Memcard_Deobfuscate(buffer, CARD_READ_SIZE);
1271    ExportHeader *header = buffer + 0x90; // get to header (need to find a less hardcoded way of doing this)
1272
1273    CARDClose(&card_file_info);
1274    return header;
1275}
1276
1277// converts from external character IDs to CSSs idx - i.e. sheik/zelda popo/nana become the same.
1278int CSS_ID(int ext_id) {
1279    if (ext_id == CKIND_SHEIK) return CKIND_ZELDA;
1280    if (ext_id == CKIND_POPO) return CKIND_ICECLIMBERS;
1281    return ext_id;
1282}
1283
1284int GetSelectedFighterIdOnCssForHmn() {
1285    // Get selected fighter for hmn in CSS
1286    VSMinorData *css_minorscene = *stc_css_minorscene;
1287    int hmnFighterId = css_minorscene->vs_data.match_init.playerData[*stc_css_hmnport].c_kind;
1288
1289    // When any fighters are not selected, this ID seems to be unplayable fighter's ID (26=Masterhand or 33=None basically?). 0-25 are playable fighter's ID.
1290    return hmnFighterId < 26 ? hmnFighterId : -1;
1291}