fork/training-mode-ce

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

Alex Harrisonfix counter delay042fd34

techchase-camera
231.4 KiB6793 linesraw
1#include "lab.h"
2#include "recovery.c"
3
4#include <stddef.h>
5
6// Static Variables
7static DIDraw didraws[6];
8static SDIDraw sdidraws[6];
9static GOBJ *infodisp_gobj_hmn;
10static GOBJ *infodisp_gobj_cpu;
11static RecData rec_data;
12static Savestate_v1 *rec_state;
13static _HSD_ImageDesc snap_image = {0};
14static _HSD_ImageDesc resized_image = {
15    .format = 4,
16    .height = RESIZE_HEIGHT,
17    .width = RESIZE_WIDTH,
18};
19static u8 snap_status;
20static u8 export_status;
21static Arch_LabData *stc_lab_data;
22static char *tm_filename = "TMREC_%02d%02d%04d_%02d%02d%02d";
23static char stc_save_name[32] = "TM Input Recording";
24static u8 stc_hmn_controller;             // making this static so importing recording doesnt overwrite
25static u8 stc_cpu_controller;             // making this static so importing recording doesnt overwrite
26static u8 stc_null_controller;            // making this static so importing recording doesnt overwrite
27
28// Aitch: not really a better way to do this that I can think of.
29// Feel free to change if you find a way to implement playback takeover without a global.
30static int stc_playback_cancelled_hmn = false;
31static int stc_playback_cancelled_cpu = false;
32
33// Computed on random slot counter action start.
34static int stc_rndm_counter_slot = -1;
35
36static u8 stc_tdi_val_num;                // number of custom tdi values set
37static CustomTDI stc_tdi_vals[TDI_HITNUM]; // contains the custom tdi values
38static u8 stc_custom_osd_state_num = 0;
39static int stc_custom_osd_states[OPTCUSTOMOSD_MAX_ADDED]; // contains the custom osd action states
40
41// Static Export Variables
42static u32 stc_transfer_buf_size;
43static u8 *stc_transfer_buf;
44static MemcardSave memcard_save;
45static int save_pre_tick;
46static char *slots_names[] = {"A", "B"};
47
48// timer variables
49static int lockout_timer = 0;
50const int LOCKOUT_DURATION = 30;
51
52static float cpu_locked_percent = 0;
53static float hmn_locked_percent = 0;
54
55// We need to know if an lcancel was hit for the overlays.
56// There is no flag in the game that stores the lcancel state,
57// so we calculate it on the first frame of landing and store it here. 
58static bool did_player_miss_lcancel[2] = {false, false};
59
60// Menu Callbacks
61
62RecInputData *Lab_GetAlteringRecording(void) {
63    int ply = LabOptions_SlotManagement[OPTSLOT_PLAYER].val;
64    int slot = LabOptions_SlotManagement[OPTSLOT_SRC].val;
65    RecInputData **rec_list = ply == PLAYER_HMN ? rec_data.hmn_inputs : rec_data.cpu_inputs;
66    return rec_list[slot];
67}
68
69RecInputs *Lab_GetAlteringInputs(void) {
70    RecInputData *rec = Lab_GetAlteringRecording();
71    int frame_idx = LabOptions_AlterInputs[OPTINPUT_FRAME].val - 1;
72    return &rec->inputs[frame_idx];
73}
74
75void Lab_ChangeAlterInputsFrame(GOBJ *menu_gobj, int value) {
76    RecInputData *rec = Lab_GetAlteringRecording();
77    int frame = LabOptions_AlterInputs[OPTINPUT_FRAME].val;
78    if (rec->num < frame)
79        rec->num = frame;
80
81    RecInputs *inputs = Lab_GetAlteringInputs();
82    LabOptions_AlterInputs[OPTINPUT_LSTICK_X].val = inputs->stickX;
83    LabOptions_AlterInputs[OPTINPUT_LSTICK_Y].val = inputs->stickY;
84    LabOptions_AlterInputs[OPTINPUT_CSTICK_X].val = inputs->substickX;
85    LabOptions_AlterInputs[OPTINPUT_CSTICK_Y].val = inputs->substickY;
86    LabOptions_AlterInputs[OPTINPUT_TRIGGER].val  = inputs->trigger;
87    LabOptions_AlterInputs[OPTINPUT_A].val        = inputs->btn_a;
88    LabOptions_AlterInputs[OPTINPUT_B].val        = inputs->btn_b;
89    LabOptions_AlterInputs[OPTINPUT_X].val        = inputs->btn_x;
90    LabOptions_AlterInputs[OPTINPUT_Y].val        = inputs->btn_y;
91    LabOptions_AlterInputs[OPTINPUT_L].val        = inputs->btn_L;
92    LabOptions_AlterInputs[OPTINPUT_R].val        = inputs->btn_R;
93    LabOptions_AlterInputs[OPTINPUT_Z].val        = inputs->btn_Z;
94}
95
96void Lab_ChangeInputs(GOBJ *menu_gobj, int value) {
97    RecInputs *inputs = Lab_GetAlteringInputs();
98    inputs->stickX    = LabOptions_AlterInputs[OPTINPUT_LSTICK_X].val;
99    inputs->stickY    = LabOptions_AlterInputs[OPTINPUT_LSTICK_Y].val;
100    inputs->substickX = LabOptions_AlterInputs[OPTINPUT_CSTICK_X].val;
101    inputs->substickY = LabOptions_AlterInputs[OPTINPUT_CSTICK_Y].val;
102    inputs->trigger   = LabOptions_AlterInputs[OPTINPUT_TRIGGER].val;
103    inputs->btn_a     = LabOptions_AlterInputs[OPTINPUT_A].val;
104    inputs->btn_b     = LabOptions_AlterInputs[OPTINPUT_B].val;
105    inputs->btn_x     = LabOptions_AlterInputs[OPTINPUT_X].val;
106    inputs->btn_y     = LabOptions_AlterInputs[OPTINPUT_Y].val;
107    inputs->btn_L     = LabOptions_AlterInputs[OPTINPUT_L].val;
108    inputs->btn_R     = LabOptions_AlterInputs[OPTINPUT_R].val;
109    inputs->btn_Z     = LabOptions_AlterInputs[OPTINPUT_Z].val;
110}
111
112void Lab_ChangeAdvCounterHitNumber(GOBJ *menu_gobj, int value) {
113    // copy current hit number to all options 
114    for (int i = 0; i < ADV_COUNTER_COUNT; ++i)
115        LabOptions_AdvCounter[i][OPTCTR_HITNUM].val = value;
116    LabMenu_AdvCounter.options = LabOptions_AdvCounter[value - 1];
117}
118
119void Lab_ChangeAdvCounterLogic(GOBJ *menu_gobj, int value) {
120    int disable = value != CTRLOGIC_CUSTOM;
121    EventOption *options = LabMenu_AdvCounter.options;
122    for (int i = OPTCTR_CTRGRND; i < OPTCTR_COUNT; ++i)
123        options[i].disable = disable;
124}
125
126void Lab_AddCustomOSD(GOBJ *menu_gobj) {
127    int row = OPTCUSTOMOSD_FIRST_CUSTOM + stc_custom_osd_state_num;
128    if (row == OPTCUSTOMOSD_MAX_COUNT) {
129        SFX_PlayCommon(3);
130        return;
131    }
132
133    char state_buf[64];
134    GOBJ *hmn = Fighter_GetGObj(0);
135    FighterData *hmn_data = hmn->userdata;
136    stc_custom_osd_states[stc_custom_osd_state_num++] = hmn_data->state_id;
137    int found = GetCurrentStateName(hmn, state_buf);
138    if (!found) strcpy(state_buf, "Unknown");
139
140    char *row_text = HSD_MemAlloc(128);
141    sprintf(row_text, "Remove OSD: %s", state_buf);
142
143    LabOptions_CustomOSDs[row]= (EventOption) {
144        .kind = OPTKIND_FUNC,
145        .name = row_text,
146        .desc = {"Remove this Custom OSD."},
147        .OnSelect = Lab_RemoveCustomOSD,
148    };
149}
150
151void Lab_RemoveCustomOSD(GOBJ *menu_gobj) {
152    int remove_idx = LabMenu_CustomOSDs.cursor;
153    int osd_idx = remove_idx - OPTCUSTOMOSD_FIRST_CUSTOM;
154    HSD_Free(LabOptions_CustomOSDs[remove_idx].name);
155    int move_count = OPTCUSTOMOSD_MAX_COUNT - remove_idx - 1;
156    memmove(&LabOptions_CustomOSDs[remove_idx], &LabOptions_CustomOSDs[remove_idx+1], move_count * sizeof(EventOption));
157    memmove(&stc_custom_osd_states[osd_idx], &stc_custom_osd_states[osd_idx+1], move_count * sizeof(*stc_custom_osd_states));
158    LabOptions_CustomOSDs[OPTCUSTOMOSD_MAX_COUNT-1] = (EventOption) { .name = 0, .disable = true };
159    stc_custom_osd_state_num--;
160    if (LabMenu_CustomOSDs.cursor - OPTCUSTOMOSD_FIRST_CUSTOM >= stc_custom_osd_state_num)
161        LabMenu_CustomOSDs.cursor = OPTCUSTOMOSD_FIRST_CUSTOM + stc_custom_osd_state_num - 1;
162
163    SFX_PlayCommon(0);
164}
165
166void Lab_CustomOSDsThink(void) {
167    GOBJ *hmn = Fighter_GetGObj(0);
168    FighterData *hmn_data = hmn->userdata;
169
170    for (int i = 0; i < stc_custom_osd_state_num; ++i) {
171        int state_id = stc_custom_osd_states[i];
172
173        if (hmn_data->state_id == state_id) {
174            char state_buf[128];
175            int found = GetCurrentStateName(hmn, state_buf);
176            if (!found) strcpy(state_buf, "Unknown");
177
178            event_vars->Message_Display(
179                15, hmn_data->ply, 0, 
180                "%s:\n%i Frames", state_buf, hmn_data->TM.state_frame
181            );
182
183            break;
184        }
185    }
186}
187
188void Lab_ChangeStadiumTransformation(GOBJ *menu_gobj, int value) {
189    // Transformation decision making is entirely located in one HUGE function (PokemonStadium_TransformationDecide),
190    // so instead of just having a simple "SetTransformation(Fire)" function call,
191    // we need to directly set the timers and overwrite the randomness call to set the transformation.
192    // Incredibly hacky, but no better way I can think of.
193
194    if (value == 0) return; // TODO
195
196    GOBJ *gobj = Stage_GetMapGObj(2);
197
198    u8 *tform_data = gobj->userdata;
199    *(u32*)(tform_data + 0xD8) = -1; // set transformation timer
200
201    s32 *timers = *TRANSFORMATION_TIMER_PTR;
202    timers[2] = 0x1000001; // max transformation length
203    timers[3] = 0x1000000; // default transformation length
204    timers[4] = 0;         // screen flash length
205
206    // We overwrite the HSD_Randi call in Event_Init before PokemonStadium_TransformationDecide is run
207    // to prevent dolphin from jitting before we run the modified asm. It's overwritten to instead read
208    // from the global address modified here.
209    int transformation_id = value - 1;
210    *TRANSFORMATION_ID_PTR = transformation_id;
211}
212
213void Lab_ChangeInputDisplay(GOBJ *menu_gobj, int value) {
214    stc_memcard->TM_LabCPUInputDisplay = value;
215}
216
217void Lab_ChangeTauntEnabled(GOBJ *menu_gobj, int value) {
218    stc_memcard->TM_LabTauntEnabled = value;
219}
220
221void Lab_ChangeOverlays(GOBJ *menu_gobj, int value) {
222    Memcard *memcard = stc_memcard;
223
224    memset(&memcard->TM_LabSavedOverlays_HMN, 0, sizeof(memcard->TM_LabSavedOverlays_HMN));
225    memset(&memcard->TM_LabSavedOverlays_CPU, 0, sizeof(memcard->TM_LabSavedOverlays_CPU));
226
227    int overlay_save_count = sizeof(memcard->TM_LabSavedOverlays_HMN) / sizeof(OverlaySave);
228    int overlay_save_idx_hmn = 0;
229    int overlay_save_idx_cpu = 0;
230    for (u8 group = 0; group < OVERLAY_COUNT; ++group) {
231        u8 overlay_hmn = LabOptions_OverlaysHMN[group].val;
232        u8 overlay_cpu = LabOptions_OverlaysCPU[group].val;
233
234        if (overlay_hmn != 0 && overlay_save_idx_hmn < overlay_save_count) {
235            memcard->TM_LabSavedOverlays_HMN[overlay_save_idx_hmn] = (OverlaySave) { group, overlay_hmn };
236            overlay_save_idx_hmn += 1;
237        }
238
239        if (overlay_cpu != 0 && overlay_save_idx_cpu < overlay_save_count) {
240            memcard->TM_LabSavedOverlays_CPU[overlay_save_idx_cpu] = (OverlaySave) { group, overlay_cpu };
241            overlay_save_idx_cpu += 1;
242        }
243    }
244}
245
246void Lab_ChangeOSDs(GOBJ *menu_gobj, int value) {
247    int new_osds_value = 0;
248
249    for (int i = 0; i < LabMenu_OSDs.option_num; i++) {
250        new_osds_value |= LabOptions_OSDs[i].val << osd_memory_bit_position[i];
251    }
252
253    stc_memcard->TM_OSDEnabled = new_osds_value;
254}
255
256void Lab_ChangePlayerPercent(GOBJ *menu_gobj, int value)
257{
258    GOBJ *fighter = Fighter_GetGObj(0);
259    FighterData *fighter_data = fighter->userdata;
260
261    fighter_data->dmg.percent = value;
262    if (LabOptions_General[OPTGEN_HMNPCNTLOCK].val)
263        hmn_locked_percent = fighter_data->dmg.percent;
264
265    Fighter_SetHUDDamage(0, value);
266}
267void Lab_ChangePlayerLockPercent(GOBJ *menu_gobj, int value)
268{
269    GOBJ *fighter = Fighter_GetGObj(0);
270    FighterData *fighter_data = fighter->userdata;
271
272    if (value)
273        hmn_locked_percent = fighter_data->dmg.percent;
274}
275
276// CHARACTER RNG CHANGE CALLBACKS --------------------------------------------------------
277
278void Lab_ChangeCharacterRng_Turnip(GOBJ *menu_gobj, int value) {
279    event_vars->rng->peach_item = value;
280}
281void Lab_ChangeCharacterRng_PeachFSmash(GOBJ *menu_gobj, int value) {
282    event_vars->rng->peach_fsmash = value;
283}
284
285void Lab_ChangeCharacterRng_Misfire(GOBJ *menu_gobj, int value) {
286    event_vars->rng->luigi_misfire = value;
287}
288
289void Lab_ChangeCharacterRng_Hammer(GOBJ *menu_gobj, int value) {
290    event_vars->rng->gnw_hammer = value;
291}
292
293void Lab_ChangeCharacterRng_NanaThrow(GOBJ *menu_gobj, int value) {
294    event_vars->rng->nana_throw = value;
295}
296
297// --------------------------------------------------------
298
299void Lab_StartMoveCPU(GOBJ *menu_gobj) {
300    LabOptions_CPU[OPTCPU_SET_POS] = LabOptions_CPU_FinishMoveCPU;
301
302    GOBJ *hmn = Fighter_GetGObj(0);
303    GOBJ *cpu = Fighter_GetGObj(1);
304    FighterData *cpu_data = cpu->userdata;
305    FighterData *hmn_data = hmn->userdata;
306
307    cpu_data->cpu.ai = 15;
308    hmn_data->pad_index = stc_null_controller;
309}
310
311void Lab_FinishMoveCPU(GOBJ *menu_gobj) {
312    LabOptions_CPU[OPTCPU_SET_POS] = LabOptions_CPU_MoveCPU;
313
314    GOBJ *hmn = Fighter_GetGObj(0);
315    FighterData *hmn_data = hmn->userdata;
316
317    hmn_data->pad_index = stc_hmn_controller;
318}
319
320void Lab_FreezeCPU(GOBJ *menu_gobj) {
321    GOBJ *cpu = Fighter_GetGObj(1);
322    FrameSpeedChange(cpu, 0.f);
323}
324
325void Lab_ChangeFrameAdvance(GOBJ *menu_gobj, int value)
326{
327    // remove colanim if toggling off
328    if (value == 0)
329        LabOptions_General[OPTGEN_FRAMEBTN].disable = 1;
330    // apply colanim
331    else
332        LabOptions_General[OPTGEN_FRAMEBTN].disable = 0;
333}
334
335void Lab_ChangeFrameAdvanceButton(GOBJ *menu_gobj, int value) {
336    stc_memcard->TM_LabFrameAdvanceButton = (u8)value;
337}
338
339void Lab_ChangeRandom(GOBJ *menu_gobj, int value)
340{
341
342    // remove colanim if toggling off
343    if (value == 0)
344        LabOptions_General[OPTGEN_FRAMEBTN].disable = 1;
345    // apply colanim
346    else
347        LabOptions_General[OPTGEN_FRAMEBTN].disable = 0;
348}
349void Lab_ChangeCPUPercent(GOBJ *menu_gobj, int value)
350{
351    GOBJ *fighter = Fighter_GetGObj(1);
352    FighterData *fighter_data = fighter->userdata;
353
354    fighter_data->dmg.percent = value;
355    Fighter_SetHUDDamage(1, value);
356
357    if (LabOptions_CPU[OPTCPU_LOCKPCNT].val)
358        cpu_locked_percent = fighter_data->dmg.percent;
359}
360void Lab_ChangeCPULockPercent(GOBJ *menu_gobj, int value)
361{
362        
363    GOBJ *fighter = Fighter_GetGObj(1);
364    FighterData *fighter_data = fighter->userdata;
365
366    if (value)
367        cpu_locked_percent = fighter_data->dmg.percent;
368}
369void Lab_ChangeTech(GOBJ *menu_gobj, int value)
370{
371    LabOptions_Tech[OPTTECH_TECHINPLACECHANCE].disable = value == 0 ? 0 : 1;
372    LabOptions_Tech[OPTTECH_TECHAWAYCHANCE].disable = value == 0 ? 0 : 1;
373    LabOptions_Tech[OPTTECH_TECHTOWARDCHANCE].disable = value == 0 ? 0 : 1;
374    LabOptions_Tech[OPTTECH_MISSTECHCHANCE].disable = value == 0 ? 0 : 1;
375}
376void Lab_ChangeGetup(GOBJ *menu_gobj, int value)
377{
378    LabOptions_Tech[OPTTECH_GETUPSTANDCHANCE].disable = value == 0 ? 0 : 1;
379    LabOptions_Tech[OPTTECH_GETUPAWAYCHANCE].disable = value == 0 ? 0 : 1;
380    LabOptions_Tech[OPTTECH_GETUPTOWARDCHANCE].disable = value == 0 ? 0 : 1;
381    LabOptions_Tech[OPTTECH_GETUPATTACKCHANCE].disable = value == 0 ? 0 : 1;
382}
383
384static int MenuLookup_TechOption[4] = {
385    OPTTECH_TECHINPLACECHANCE,
386    OPTTECH_TECHAWAYCHANCE,
387    OPTTECH_TECHTOWARDCHANCE,
388    OPTTECH_MISSTECHCHANCE,
389};
390
391static int MenuLookup_GetupOption[4] = {
392    OPTTECH_GETUPSTANDCHANCE,
393    OPTTECH_GETUPAWAYCHANCE,
394    OPTTECH_GETUPTOWARDCHANCE,
395    OPTTECH_GETUPATTACKCHANCE,
396};
397
398static void ReboundTechChances(EventOption tech_menu[4], int menu_lookup[], int slot_idx_changed) {
399    s16 *chances[4];
400    int enabled_slots = 0;
401
402    for (int i = 0; i < 4; i++) {
403        int tech_menu_idx = menu_lookup[i];
404        chances[enabled_slots] = &tech_menu[tech_menu_idx].val;
405        enabled_slots++;
406    }
407
408    ReboundChances(chances, 4, slot_idx_changed);
409}
410
411void Lab_ChangeTechInPlaceChance (GOBJ *menu_gobj, int _new_val) { ReboundTechChances(LabOptions_Tech, MenuLookup_TechOption, 0); }
412void Lab_ChangeTechAwayChance    (GOBJ *menu_gobj, int _new_val) { ReboundTechChances(LabOptions_Tech, MenuLookup_TechOption, 1); }
413void Lab_ChangeTechTowardChance  (GOBJ *menu_gobj, int _new_val) { ReboundTechChances(LabOptions_Tech, MenuLookup_TechOption, 2); }
414void Lab_ChangeMissTechChance    (GOBJ *menu_gobj, int _new_val) { ReboundTechChances(LabOptions_Tech, MenuLookup_TechOption, 3); }
415
416void Lab_ChangeStandChance       (GOBJ *menu_gobj, int _new_val) { ReboundTechChances(LabOptions_Tech, MenuLookup_GetupOption, 0); }
417void Lab_ChangeRollAwayChance    (GOBJ *menu_gobj, int _new_val) { ReboundTechChances(LabOptions_Tech, MenuLookup_GetupOption, 1); }
418void Lab_ChangeRollTowardChance  (GOBJ *menu_gobj, int _new_val) { ReboundTechChances(LabOptions_Tech, MenuLookup_GetupOption, 2); }
419void Lab_ChangeGetupAttackChance (GOBJ *menu_gobj, int _new_val) { ReboundTechChances(LabOptions_Tech, MenuLookup_GetupOption, 3); }
420
421static int EnabledSlotChances(EventOption slot_menu[REC_SLOTS], s16 *chances[REC_SLOTS]) {
422    int enabled_slots = 0;
423    for (int i = 0; i < REC_SLOTS; i++) {
424        int slot_menu_idx = OPTSLOTCHANCE_1 + i;
425
426        if (!slot_menu[slot_menu_idx].disable) {
427            chances[enabled_slots] = &slot_menu[slot_menu_idx].val;
428            enabled_slots++;
429        }
430    }
431
432    return enabled_slots;
433}
434
435static void ReboundSlotChances(EventOption slot_menu[REC_SLOTS], int slot_idx_changed) {
436    s16 *chances[REC_SLOTS];
437    int chance_count = EnabledSlotChances(slot_menu, chances);
438    ReboundChances(chances, chance_count, slot_idx_changed);
439}
440
441void Lab_ChangeSlot1ChanceHMN (GOBJ *menu_gobj, int _new_val) { ReboundSlotChances(LabOptions_SlotChancesHMN, 0); }
442void Lab_ChangeSlot2ChanceHMN (GOBJ *menu_gobj, int _new_val) { ReboundSlotChances(LabOptions_SlotChancesHMN, 1); }
443void Lab_ChangeSlot3ChanceHMN (GOBJ *menu_gobj, int _new_val) { ReboundSlotChances(LabOptions_SlotChancesHMN, 2); }
444void Lab_ChangeSlot4ChanceHMN (GOBJ *menu_gobj, int _new_val) { ReboundSlotChances(LabOptions_SlotChancesHMN, 3); }
445void Lab_ChangeSlot5ChanceHMN (GOBJ *menu_gobj, int _new_val) { ReboundSlotChances(LabOptions_SlotChancesHMN, 4); }
446void Lab_ChangeSlot6ChanceHMN (GOBJ *menu_gobj, int _new_val) { ReboundSlotChances(LabOptions_SlotChancesHMN, 5); }
447
448void Lab_ChangeSlot1ChanceCPU (GOBJ *menu_gobj, int _new_val) { ReboundSlotChances(LabOptions_SlotChancesCPU, 0); }
449void Lab_ChangeSlot2ChanceCPU (GOBJ *menu_gobj, int _new_val) { ReboundSlotChances(LabOptions_SlotChancesCPU, 1); }
450void Lab_ChangeSlot3ChanceCPU (GOBJ *menu_gobj, int _new_val) { ReboundSlotChances(LabOptions_SlotChancesCPU, 2); }
451void Lab_ChangeSlot4ChanceCPU (GOBJ *menu_gobj, int _new_val) { ReboundSlotChances(LabOptions_SlotChancesCPU, 3); }
452void Lab_ChangeSlot5ChanceCPU (GOBJ *menu_gobj, int _new_val) { ReboundSlotChances(LabOptions_SlotChancesCPU, 4); }
453void Lab_ChangeSlot6ChanceCPU (GOBJ *menu_gobj, int _new_val) { ReboundSlotChances(LabOptions_SlotChancesCPU, 5); }
454
455void Lab_ChangeCPUIntang(GOBJ *menu_gobj, int value)
456{
457    GOBJ *fighter = Fighter_GetGObj(1);
458    FighterData *fighter_data = fighter->userdata;
459
460    if (value == 0)
461        Fighter_ColAnim_Remove(fighter_data, INTANG_COLANIM);
462    else
463        Fighter_ColAnim_Apply(fighter_data, INTANG_COLANIM, 0);
464}
465
466void Lab_ChangeModelDisplay(GOBJ *menu_gobj, int value)
467{
468    bool hide_chars = !LabValues_CharacterModelDisplay[value];
469
470    // loop through all fighters
471    GOBJ *this_fighter = (*stc_gobj_lookup)[MATCHPLINK_FIGHTER];
472    while (this_fighter != 0)
473    {
474        // get data
475        FighterData *thisFighterData = this_fighter->userdata;
476
477        // toggle
478        thisFighterData->show_model = !hide_chars;
479
480        // get next fighter
481        this_fighter = this_fighter->next;
482    }
483
484    bool hide_stage = !LabValues_StageModelDisplay[value];
485    stc_matchcam->hide_stage = hide_stage;
486    stc_matchcam->hide_stage2 = hide_stage;
487    stc_matchcam->hide_background = hide_stage;
488
489    bool hide_misc = hide_stage || hide_chars;
490
491    stc_matchcam->hide_effects = hide_misc;
492}
493void Lab_ChangeHitDisplay(GOBJ *menu_gobj, int value)
494{
495    // loop through all fighters
496    GOBJ *this_fighter = (*stc_gobj_lookup)[MATCHPLINK_FIGHTER];
497    while (this_fighter != 0)
498    {
499        // get data
500        FighterData *thisFighterData = this_fighter->userdata;
501
502        // toggle
503        thisFighterData->show_hit = value;
504
505        // get next fighter
506        this_fighter = this_fighter->next;
507    }
508}
509void Lab_ChangeEnvCollDisplay(GOBJ *menu_gobj, int value)
510{
511    stc_matchcam->show_coll = value;
512}
513void Lab_ChangeItemGrabDisplay(GOBJ *menu_gobj, int value)
514{
515    GOBJ *hmn = Fighter_GetGObj(0);
516    GOBJ *cpu = Fighter_GetGObj(1);
517    FighterData *cpu_data = cpu->userdata;
518    FighterData *hmn_data = hmn->userdata;
519    cpu_data->show_item_pickup = value;
520    hmn_data->show_item_pickup = value;
521}
522void Lab_ChangeCamMode(GOBJ *menu_gobj, int value)
523{
524    // normal cam
525    if (value == 0)
526    {
527        Match_SetNormalCamera();
528    }
529    // zoom cam
530    else if (value == 1)
531    {
532        Match_SetFreeCamera(0, 3);
533        stc_matchcam->freecam_fov.X = 140;
534        stc_matchcam->freecam_rotate.Y = 10;
535    }
536    // fixed
537    else if (value == 2)
538    {
539        Match_SetFixedCamera();
540    }
541    // advanced or static
542    else if (value == 3 || value == 4)
543    {
544        Match_SetDevelopCamera();
545    }
546    Match_CorrectCamera();
547}
548
549static void Lab_ChangeInfoPreset(EventOption options[], int preset_id)
550{
551    int *preset = LabValues_InfoPresetStates[preset_id];
552
553    for (int i = 0; i < OPTINF_ROW_COUNT; ++i)
554        options[OPTINF_ROW1 + i].val = preset[i];
555}
556
557void Lab_ChangeInfoPresetHMN(GOBJ *menu_gobj, int preset_id)
558{
559    Lab_ChangeInfoPreset(LabOptions_InfoDisplayHMN, preset_id);
560}
561
562void Lab_ChangeInfoPresetCPU(GOBJ *menu_gobj, int preset_id)
563{
564    Lab_ChangeInfoPreset(LabOptions_InfoDisplayCPU, preset_id);
565}
566
567void Lab_ChangeHUD(GOBJ *menu_gobj, int show_hud)
568{
569    bool *hide_hud_ptr = (bool *)(R13 + -0x4948);
570    *hide_hud_ptr = !show_hud;
571    event_vars->watermark->hidden = !show_hud;
572}
573
574void Lab_Exit(GOBJ *menu)
575{
576    // reset rng
577    memset(event_vars->rng, 0, sizeof(*event_vars->rng));
578
579    // end game
580    stc_match->state = 3;
581
582    // cleanup
583    Match_EndVS();
584}
585
586// Event Functions
587GOBJ *InfoDisplay_Init(int ply)
588{
589    // Create Info Display GOBJ
590    GOBJ *idGOBJ = GObj_Create(0, 0, 0);
591    InfoDisplayData *idData = calloc(sizeof(InfoDisplayData));
592    GObj_AddUserData(idGOBJ, 4, HSD_Free, idData);
593    // Load jobj
594    evMenu *menuAssets = event_vars->menu_assets;
595    JOBJ *menu = JOBJ_LoadJoint(menuAssets->popup);
596    idData->menuModel = menu;
597    // Add to gobj
598    GObj_AddObject(idGOBJ, 3, menu);
599    // Add gxlink
600    GObj_AddGXLink(idGOBJ, GXLink_Common, GXLINK_INFDISP, GXPRI_INFDISP);
601    // Save pointers to corners
602    JOBJ *corners[4];
603    JOBJ_GetChild(menu, corners, 2, 3, 4, 5, -1);
604    idData->botLeftEdge = corners[0];
605    idData->botRightEdge = corners[1];
606
607    menu->trans.X = INFDISP_X;
608    menu->trans.Y = INFDISP_Y;
609    corners[0]->trans.X = 0;
610    corners[1]->trans.X = INFDISP_WIDTH;
611    corners[2]->trans.X = 0;
612    corners[3]->trans.X = INFDISP_WIDTH;
613    corners[0]->trans.Y = 0;
614    corners[1]->trans.Y = 0;
615    corners[2]->trans.Y = 0;
616    corners[3]->trans.Y = 0;
617
618    //JOBJ_SetFlags(menu, JOBJ_HIDDEN);
619    menu->dobj->next->mobj->mat->alpha = 0.6;
620
621    // Create text object
622    int canvas_index = Text_CreateCanvas(2, idGOBJ, 14, 15, 0, GXLINK_INFDISPTEXT, GXPRI_INFDISPTEXT, 19);
623    Text *text = Text_CreateText(2, canvas_index);
624    text->kerning = 1;
625    text->use_aspect = 1;
626    text->aspect.X = 545;
627
628    // Create subtexts for each row
629    for (int i = 0; i < 8; i++)
630    {
631        Text_AddSubtext(text, 0, (INFDISPTEXT_YOFFSET * i), " ");
632    }
633    idData->text = text;
634
635    // adjust size based on the console / settings
636    //if ((OSGetConsoleType() == OS_CONSOLE_DEVHW3) || (stc_HSD_VI->is_prog == 1)) // 480p / dolphin uses medium by default
637    //    LabOptions_InfoDisplay[OPT_SCALE].val = 1;
638    //else // 480i on wii uses large (shitty composite!)
639    //    LabOptions_InfoDisplay[OPT_SCALE].val = 2;
640
641    GXColor shield_color = (*stc_shieldcolors)[ply];
642    shield_color.a = 255;
643    GXColor *border_color = &menu->dobj->mobj->mat->diffuse;
644    *border_color = shield_color;
645
646    return idGOBJ;
647}
648
649// Returns length of string, including null terminator. Zero if not found.
650static int GetCurrentStateName(GOBJ *fighter, char *buf) {
651    FighterData *fighter_data = fighter->userdata;
652
653    if (fighter_data->action_id == -1) return 0;
654
655    FtAction *action = Fighter_GetFtAction(fighter_data, fighter_data->action_id);
656    // extract state name from symbol
657    char *symbol = action->anim_symbol;
658
659    // extract from the opponent fighter actions if there is no symbol in the fighter action
660    // (e.g. getting Yoshi's Neutral-B, Mewtwo's Side-B, Bowser's Side-B, etc.)
661    if (symbol == NULL) {
662        // loop through all humans
663        for (int i = 0; i < 6; i++) {
664            if (i == fighter_data->ply) { continue; }
665
666            GOBJ *other_fighter = Fighter_GetGObj(i);
667            if (other_fighter == 0) { continue; }
668
669            FighterData *other_fighter_data = other_fighter->userdata;
670            action = Fighter_GetFtAction(other_fighter_data, fighter_data->action_id);
671            symbol = action->anim_symbol;
672            if (symbol != NULL) { break; }
673        }
674    }
675
676    if (symbol == NULL) return 0;
677
678    int start = 0;
679    int len = 0;
680    for (int i = 0; i < 50; i++) {
681        if (strncmp(symbol + i, "N_", 2) == 0) {
682            start = i + 2;
683            break;
684        }
685    }
686    for (int i = start + 1; i < 50; i++) {
687        if (symbol[i] == '_') {
688            len = i - start;
689            break;
690        }
691    }
692
693    if (start == 0 || len == 0) return 0;
694    memcpy(buf, symbol + start, len);
695    buf[len] = '\0';
696
697    return len + 1;
698}
699
700void InfoDisplay_Update(GOBJ *menu_gobj, EventOption menu[], GOBJ *fighter, GOBJ *below)
701{
702    InfoDisplayData *idData = menu_gobj->userdata;
703    Text *text = idData->text;
704    if (Pause_CheckStatus(1) != 2)
705    {
706        // get the last row enabled
707        int rowsEnabled = 8;
708        while (rowsEnabled > 0)
709        {
710            if (menu[rowsEnabled - 1 + OPTINF_ROW1].val != 0)
711                break;
712            rowsEnabled--;
713        }
714
715        // scale window Y based on rows enabled
716        JOBJ *leftCorner = idData->botLeftEdge;
717        JOBJ *rightCorner = idData->botRightEdge;
718        float yPos = (rowsEnabled * INFDISP_BOTYOFFSET) + INFDISP_BOTY;
719        leftCorner->trans.Y = yPos;
720        rightCorner->trans.Y = yPos;
721        JOBJ_SetMtxDirtySub(idData->menuModel);
722
723        // if a row is enabled, display
724        if (rowsEnabled != 0)
725        {
726            // show model and text
727            JOBJ_ClearFlags(idData->menuModel, JOBJ_HIDDEN);
728            idData->text->hidden = 0;
729
730            // update info display strings
731            FighterData *fighter_data = fighter->userdata;
732
733            for (int i = 0; i < 8; i++)
734            {
735                int value = menu[i + OPTINF_ROW1].val;
736
737                // hide text if set to 0 or fighter DNE
738                if (menu[i + OPTINF_ROW1].val == 0) {
739                    Text_SetText(text, i, "");
740                    continue;
741                }
742
743                // display info
744                switch (value)
745                {
746                case (INFDISP_POS):
747                {
748                    Text_SetText(text, i, "Pos: (%+.3f , %+.3f)", fighter_data->phys.pos.X, fighter_data->phys.pos.Y);
749                    break;
750                }
751                case (INFDISP_STATE):
752                {
753                    char buf[64];
754                    int found = GetCurrentStateName(fighter, buf);
755                    if (found) {
756                        Text_SetText(text, i, "State: %s", buf);
757                    } else {
758                        Text_SetText(text, i, "State: Unknown");
759                    }
760
761                    break;
762                }
763                case (INFDISP_FRAME):
764                {
765                    Figatree *animStruct = fighter_data->figatree_curr;
766                    int frameCurr = 0;
767                    int frameTotal = 0;
768
769                    // if exists
770                    if (animStruct != 0)
771                    {
772                        // determine how many frames shield stun is
773                        float animFrameTotal = animStruct->frame_num;
774                        float animFrameCurr = fighter_data->state.frame;
775                        float animSpeed = fighter_data->state.rate;
776                        frameTotal = (animFrameTotal / animSpeed);
777                        frameCurr = (animFrameCurr / animSpeed);
778                    }
779
780                    Text_SetText(text, i, "State Frame: %d/%d", frameCurr, frameTotal);
781                    break;
782                }
783                case (INFDISP_SELFVEL):
784                {
785                    Text_SetText(text, i, "SelfVel: (%+.3f , %+.3f)", fighter_data->phys.self_vel.X, fighter_data->phys.self_vel.Y);
786                    break;
787                }
788                case (INFDISP_KBVEL):
789                {
790                    Text_SetText(text, i, "KBVel: (%+.3f , %+.3f)", fighter_data->phys.kb_vel.X, fighter_data->phys.kb_vel.Y);
791                    break;
792                }
793                case (INFDISP_TOTALVEL):
794                {
795                    Text_SetText(text, i, "TotalVel: (%+.3f , %+.3f)", fighter_data->phys.self_vel.X + fighter_data->phys.kb_vel.X, fighter_data->phys.self_vel.Y + fighter_data->phys.kb_vel.Y);
796                    break;
797                }
798                case (INFDISP_ENGLSTICK):
799                {
800                    Text_SetText(text, i, "LStick:      (%+.4f , %+.4f)", fighter_data->input.lstick.X, fighter_data->input.lstick.Y);
801                    break;
802                }
803                case (INFDISP_SYSLSTICK):
804                {
805                    HSD_Pad *pad = PadGetMaster(fighter_data->pad_index);
806                    Text_SetText(text, i, "LStick Sys: (%+.4f , %+.4f)", pad->fstickX, pad->fstickY);
807                    break;
808                }
809                case (INFDISP_ENGCSTICK):
810                {
811                    Text_SetText(text, i, "CStick:     (%+.4f , %+.4f)", fighter_data->input.cstick.X, fighter_data->input.cstick.Y);
812                    break;
813                }
814                case (INFDISP_SYSCSTICK):
815                {
816                    HSD_Pad *pad = PadGetMaster(fighter_data->pad_index);
817                    Text_SetText(text, i, "CStick Sys: (%+.4f , %+.4f)", pad->fsubstickX, pad->fsubstickY);
818                    break;
819                }
820                case (INFDISP_ENGTRIGGER):
821                {
822                    Text_SetText(text, i, "Trigger:     (%+.3f)", fighter_data->input.trigger);
823                    break;
824                }
825                case (INFDISP_SYSTRIGGER):
826                {
827                    HSD_Pad *pad = PadGetMaster(fighter_data->pad_index);
828                    Text_SetText(text, i, "Trigger Sys: (%+.3f , %+.3f)", pad->ftriggerLeft, pad->ftriggerRight);
829                    break;
830                }
831                case (INFDISP_LEDGECOOLDOWN):
832                {
833                    Text_SetText(text, i, "Ledgegrab Timer: %d", fighter_data->ledge_cooldown);
834                    break;
835                }
836                case (INFDISP_INTANGREMAIN):
837                {
838                    int intang = fighter_data->hurt.intang_frames.respawn;
839                    if (fighter_data->hurt.intang_frames.ledge > fighter_data->hurt.intang_frames.respawn)
840                        intang = fighter_data->hurt.intang_frames.ledge;
841
842                    Text_SetText(text, i, "Intangibility Timer: %d", intang);
843                    break;
844                }
845                case (INFDISP_HITSTOP):
846                {
847                    Text_SetText(text, i, "Hitlag: %.0f", fighter_data->dmg.hitlag_frames);
848                    break;
849                }
850                case (INFDISP_HITSTUN):
851                {
852                    // get hitstun
853                    float hitstun = 0;
854                    if (fighter_data->flags.hitstun == 1)
855                        memcpy(&hitstun, &fighter_data->state_var.state_var1, sizeof(float));
856
857                    Text_SetText(text, i, "Hitstun: %.0f", hitstun);
858                    break;
859                }
860                case (INFDISP_SHIELDHEALTH):
861                {
862                    Text_SetText(text, i, "Shield Health: %.3f", fighter_data->shield.health);
863                    break;
864                }
865                case (INFDISP_SHIELDSTUN):
866                {
867                    int stunTotal = 0;
868                    int stunLeft = 0;
869
870                    // check if taking shield stun
871                    if (fighter_data->state_id == ASID_GUARDSETOFF)
872                    {
873                        // determine how many frames shield stun is
874                        float frameTotal = JOBJ_GetJointAnimFrameTotal(fighter->hsd_object);
875                        float frameCurr = fighter_data->state.frame;
876                        float animSpeed = fighter_data->state.rate;
877                        stunTotal = (frameTotal / animSpeed);
878                        stunLeft = stunTotal - (frameCurr / animSpeed);
879                        // 0 index
880                        stunTotal++;
881                        stunLeft++;
882                    }
883
884                    Text_SetText(text, i, "Shield Stun: %d/%d", stunLeft, stunTotal);
885                    break;
886                }
887                case (INFDISP_GRIP):
888                {
889                    float grip = 0;
890                    if (fighter_data->grab.victim != 0)
891                    {
892                        GOBJ *victim = fighter_data->grab.victim;
893                        FighterData *victim_data = victim->userdata;
894                        grip = victim_data->grab.grab_timer;
895                    }
896
897                    Text_SetText(text, i, "Grip Strength: %.0f", grip);
898                    break;
899                }
900                case (INFDISP_ECBLOCK):
901                {
902                    Text_SetText(text, i, "ECB Lock: %d", fighter_data->coll_data.u.ecb_bot_lock_frames);
903                    break;
904                }
905                case (INFDISP_ECBBOT):
906                {
907                    Text_SetText(text, i, "ECB Bottom: %.3f", fighter_data->coll_data.ecbCurr_bot.Y);
908                    break;
909                }
910                case (INFDISP_JUMPS):
911                {
912                    Text_SetText(text, i, "Jumps: %d/%d", fighter_data->jump.jumps_used, fighter_data->attr.max_jumps);
913                    break;
914                }
915                case (INFDISP_WALLJUMPS):
916                {
917                    Text_SetText(text, i, "Walljumps: %d", fighter_data->jump.walljumps_used);
918                    break;
919                }
920                case (INFDISP_CANWALLJUMP):
921                {
922                    // no boolean specifier in c
923                    const char *str;
924                    if (CanWalljump(fighter))
925                        str = "Can Walljump: true";
926                    else
927                        str = "Can Walljump: false";
928                    Text_SetText(text, i, str);
929                    break;
930                }
931                case (INFDISP_JAB):
932                {
933                    Text_SetText(text, i, "Jab Counter: IDK");
934                    break;
935                }
936                case (INFDISP_LINE):
937                {
938                    CollData *colldata = &fighter_data->coll_data;
939                    int ground = -1;
940                    int ceil = -1;
941                    int left = -1;
942                    int right = -1;
943
944                    if ((colldata->envFlags & ECB_GROUND) != 0)
945                        ground = colldata->ground_index;
946                    if ((colldata->envFlags & ECB_CEIL) != 0)
947                        ceil = colldata->ceil_index;
948                    if ((colldata->envFlags & ECB_WALLLEFT) != 0)
949                        left = colldata->leftwall_index;
950                    if ((colldata->envFlags & ECB_WALLRIGHT) != 0)
951                        right = colldata->rightwall_index;
952
953                    Text_SetText(text, i, "Lines: G:%d, C:%d, L:%d, R:%d,", ground, ceil, left, right);
954                    break;
955                }
956                case (INFDISP_BLASTLR):
957                {
958                    Stage *stage = stc_stage;
959                    Text_SetText(text, i, "Blastzone L/R: (%+.3f,%+.3f)", stage->blastzoneLeft, stage->blastzoneRight);
960                    break;
961                }
962                case (INFDISP_BLASTUD):
963                {
964                    Stage *stage = stc_stage;
965                    Text_SetText(text, i, "Blastzone U/D: (%.2f,%.2f)", stage->blastzoneTop, stage->blastzoneBottom);
966                    break;
967                }
968                }
969            }
970
971            if (below != NULL) {
972                InfoDisplayData *belowData = below->userdata;
973                float y_above = belowData->menuModel->trans.Y + belowData->botLeftEdge->trans.Y*belowData->menuModel->scale.X;
974                float new_y = y_above + INFDISP_BOTYOFFSET*3;
975                idData->menuModel->trans.Y = new_y;
976            }
977
978            float scale = LabValues_InfoSizes[menu[OPTINF_SIZE].val];
979            idData->menuModel->scale.Y = scale * INFDISP_SCALE;
980            idData->menuModel->scale.X = scale * INFDISP_SCALE;
981            idData->text->viewport_scale.X = scale * INFDISPTEXT_SCALE;
982            idData->text->viewport_scale.Y = scale * INFDISPTEXT_SCALE;
983            idData->text->trans.X =  idData->menuModel->trans.X + scale * INFDISPTEXT_X;
984            idData->text->trans.Y = -idData->menuModel->trans.Y + scale * INFDISPTEXT_Y;
985
986            JOBJ_SetMtxDirtySub(idData->menuModel);
987        }
988        else
989        {
990            // hide model and text
991            JOBJ_SetFlags(idData->menuModel, JOBJ_HIDDEN);
992            idData->text->hidden = 1;
993        }
994    }
995    else
996    {
997        // hide model and text
998        JOBJ_SetFlags(idData->menuModel, JOBJ_HIDDEN);
999        idData->text->hidden = 1;
1000    }
1001}
1002int Fighter_GetOpponentDir(FighterData *from, FighterData *to)
1003{
1004    return (from->phys.pos.X <= to->phys.pos.X) ? 1 : -1;
1005}
1006
1007static int IsHitlagVictim(GOBJ *character) {
1008    FighterData *data = character->userdata;
1009    int state = data->state_id;
1010    return data->flags.hitlag && (InHitstunAnim(state) || state == ASID_GUARDSETOFF);
1011}
1012
1013static int InShieldStun(int state) {
1014    return state == ASID_GUARDSETOFF;
1015} 
1016
1017static int in_tumble_anim(int state) {
1018    return state == ASID_DAMAGEFALL || (ASID_DAMAGEFLYHI <= state && state <= ASID_DAMAGEFLYROLL);
1019}
1020
1021static int CheckIASA(FighterData *data) {
1022    // For some reason, the iasa flag isn't reset when the state changes, only when a new action that has iasa starts.
1023    // So we need to do some bs tracking to figure out if the character is in iasa.
1024    return data->TM.iasa_frames && data->TM.iasa_frames <= data->TM.state_frame;
1025}
1026
1027static int CheckOverlay(GOBJ *character, OverlayGroup overlay)
1028{
1029    FighterData *data = character->userdata;
1030    int state = data->state_id;
1031    int in_air = data->phys.air_state;
1032    int kind = data->kind;
1033
1034    switch (overlay)
1035    {
1036        case (OVERLAY_ACTIONABLE):
1037        {
1038            if (InHitstunAnim(state) && HitstunEnded(character))
1039                return true;
1040
1041            if (state == ASID_LANDING && data->state.frame >= data->attr.normal_landing_lag)
1042                return true;
1043
1044            if (CheckIASA(data)) return true;
1045
1046            if (state == ASID_CLIFFWAIT && data->TM.state_frame > 1) return true;
1047
1048            if (ASID_WAIT <= state && state <= ASID_WALKFAST) return true;
1049            if (ASID_GUARD <= state && state <= ASID_GUARDREFLECT) return true;
1050            if (ASID_JUMPF <= state && state <= ASID_FALLAERIALB) return true;
1051
1052            return state == ASID_TURN
1053                || state == ASID_PASS
1054                || state == ASID_CATCHWAIT
1055                || state == ASID_SQUATWAIT
1056                || state == ASID_OTTOTTOWAIT;
1057        }
1058
1059        case (OVERLAY_HITSTUN):
1060            return InHitstunAnim(state) && !HitstunEnded(character);
1061
1062        case (OVERLAY_LEDGE_ACTIONABLE):
1063            return state == ASID_CLIFFWAIT && data->TM.state_frame > 1;
1064
1065        case (OVERLAY_MISSED_LCANCEL):
1066        {
1067            if (state < ASID_LANDINGAIRN || ASID_LANDINGAIRLW < state)
1068                return false;
1069
1070            if (data->TM.state_frame == 0) {
1071                did_player_miss_lcancel[data->ply] = data->input.timer_trigger_any_ignore_hitlag >= 7;
1072            }
1073            return did_player_miss_lcancel[data->ply];
1074        }
1075
1076        case (OVERLAY_CAN_FASTFALL):
1077        {
1078            if (!in_air)
1079                return false;
1080
1081            if (InHitstunAnim(state) && !HitstunEnded(character))
1082                return false;
1083
1084            if ((state < ASID_JUMPF || state > ASID_DAMAGEFALL)
1085                    && (state < ASID_DAMAGEHI1 || state > ASID_DAMAGEFLYROLL)
1086                    && (state < ASID_ATTACKAIRN || state > ASID_ATTACKAIRLW)
1087                    && state != ASID_PASS)
1088                return false;
1089
1090            // peach, yoshi, ness, mewtwo cannot fastfall in dj animation for whatever reason.
1091            if ((kind == FTKIND_PEACH || kind == FTKIND_YOSHI || kind == FTKIND_NESS || kind == FTKIND_MEWTWO)
1092                    && (state == ASID_JUMPAERIALF || state == ASID_JUMPAERIALB))
1093                return false;
1094
1095            if (data->flags.is_fastfall) 
1096                return false;
1097
1098            // We can only fastfall on second frame with negative velocity.
1099            // This check prunes the first frame.
1100            if (data->phys.pos_delta.Y >= 0.0)
1101                return false;
1102
1103            return data->phys.self_vel.Y < 0.0f;
1104        }
1105
1106        case (OVERLAY_INVINCIBLE):
1107        {
1108            return data->hurt.kind_script != 0 || data->hurt.kind_game != 0;
1109        }
1110
1111        case (OVERLAY_AUTOCANCEL):
1112        {
1113            if (state < ASID_ATTACKAIRN || ASID_ATTACKAIRLW < state)
1114                return false;
1115
1116            return data->ftcmd_var.flag0 == 0;
1117        }
1118
1119        case (OVERLAY_CROUCH):
1120            return state >= ASID_SQUAT && state <= ASID_SQUATRV;
1121
1122        case (OVERLAY_WAIT):
1123            return CheckIASA(data)
1124                || state == ASID_WAIT
1125                || state == ASID_CATCHWAIT
1126                || state == ASID_SQUATWAIT;
1127
1128        case (OVERLAY_WALK):
1129            return state == ASID_WALKSLOW
1130                || state == ASID_WALKMIDDLE
1131                || state == ASID_WALKFAST;
1132
1133        case (OVERLAY_DASH): return state == ASID_DASH;
1134        case (OVERLAY_RUN): return state == ASID_RUN;
1135
1136        case (OVERLAY_JUMPS_USED):
1137            return data->jump.jumps_used > 1;
1138
1139        case (OVERLAY_FULLHOP):
1140        {
1141            if (state != ASID_JUMPF && state != ASID_JUMPB)
1142                return false;
1143
1144            return data->state_var.state_var1 == 0;
1145        }
1146
1147        case (OVERLAY_SHORTHOP):
1148        {
1149            if (state != ASID_JUMPF && state != ASID_JUMPB)
1150                return false;
1151
1152            return data->state_var.state_var1 == 1;
1153        }
1154
1155        case (OVERLAY_IASA):
1156            return CheckIASA(data);
1157
1158        case (OVERLAY_SHIELD_STUN):
1159            return InShieldStun(state);
1160        default:
1161            assert("unhandled overlay");
1162    }
1163
1164    char * err = HSD_MemAlloc(64);
1165    sprintf(err, "unhandled overlay idx %i", overlay);
1166    assert(err);
1167    return false;
1168}
1169
1170// returns true if the cpu should counter in this asid state
1171int CPUAction_CheckASID(GOBJ *cpu, int asid_kind)
1172{
1173    FighterData *cpu_data = cpu->userdata;
1174    int cpu_state = cpu_data->state_id;
1175    int in_air = cpu_data->phys.air_state;
1176
1177    switch (asid_kind)
1178    {
1179        // check custom ASID groups
1180        case (ASID_ANY): return true;
1181        case (ASID_DAMAGEAIR):
1182            return in_air
1183                && (InHitstunAnim(cpu_state) || cpu_state == ASID_DAMAGEFALL)
1184                && HitstunEnded(cpu);
1185
1186        case (ASID_ACTIONABLE):
1187        {
1188            if (in_air)
1189                goto ACTIONABLEAIR;
1190            else
1191                goto ACTIONABLEGROUND;
1192        }
1193
1194        case (ASID_ACTIONABLEAIR):
1195        ACTIONABLEAIR:
1196        {
1197            if (!in_air)
1198                return false;
1199
1200            if (InHitstunAnim(cpu_state) && HitstunEnded(cpu))
1201                return true;
1202
1203            return cpu_state == ASID_JUMPF 
1204                || cpu_state == ASID_JUMPB
1205                || cpu_state == ASID_JUMPAERIALF
1206                || cpu_state == ASID_JUMPAERIALB
1207                || cpu_state == ASID_FALL
1208                || cpu_state == ASID_FALLAERIALF
1209                || cpu_state == ASID_FALLAERIALB
1210                || cpu_state == ASID_DAMAGEFALL;
1211        }
1212
1213        case (ASID_ACTIONABLEGROUND):
1214        ACTIONABLEGROUND:
1215        {
1216            if (in_air)
1217                return false;
1218
1219            if (InHitstunAnim(cpu_state) && HitstunEnded(cpu))
1220                return true;
1221
1222            if (cpu_state == ASID_LANDING && cpu_data->state.frame >= cpu_data->attr.normal_landing_lag)
1223                return true;
1224
1225            return cpu_state == ASID_WAIT
1226                || cpu_state == ASID_WALKSLOW
1227                || cpu_state == ASID_WALKMIDDLE
1228                || cpu_state == ASID_WALKFAST
1229                || cpu_state == ASID_RUN
1230                || cpu_state == ASID_SQUATWAIT
1231                || cpu_state == ASID_OTTOTTOWAIT
1232                || cpu_state == ASID_GUARD;
1233        }
1234
1235        // check normal action states
1236        default: return cpu_state == asid_kind;
1237    }
1238}
1239
1240int IsThrown(GOBJ *fighter) {
1241    FighterData *data = fighter->userdata;
1242
1243    int state = data->state_id;
1244
1245    GOBJ *attacker = data->grab.attacker;
1246    if (attacker) {
1247        FighterData *attacker_data = attacker->userdata;
1248        int attacker_kind = attacker_data->kind;
1249
1250        // hardcode DK cargo throw
1251        if (attacker_kind == FTKIND_DK && (state == ASID_THROWNF || state == ASID_THROWNFF)) return 0;
1252    }
1253
1254    return (ASID_THROWNF <= state && state <= ASID_THROWNLW)
1255        || (ASID_THROWNFF <= state && state <= ASID_THROWNFLW)
1256        || state == ASID_CAPTURECAPTAIN
1257        || state == ASID_THROWNKOOPAF
1258        || state == ASID_THROWNKOOPAB
1259        || state == ASID_THROWNKOOPAAIRF
1260        || state == ASID_THROWNKOOPAAIRB;
1261}
1262
1263int CPU_IsGrabbed(GOBJ *cpu, GOBJ *hmn)
1264{
1265    FighterData *cpu_data = cpu->userdata;
1266    FighterData *hmn_data = hmn->userdata;
1267
1268    int cpu_state = cpu_data->state_id;
1269    int hmn_kind = hmn_data->kind;
1270
1271    return (ASID_CAPTUREPULLEDHI <= cpu_state && cpu_state <= ASID_CAPTURECUT)
1272        || cpu_state == ASID_CAPTUREWAITKOOPA
1273        || cpu_state == ASID_CAPTUREWAITKOOPAAIR
1274        || cpu_state == ASID_CAPTUREWAITKIRBY
1275        || cpu_state == ASID_DAMAGEICE
1276        || cpu_state == ASID_CAPTUREMASTERHAND
1277        || cpu_state == ASID_YOSHIEGG
1278        || cpu_state == ASID_CAPTUREKIRBYYOSHI
1279        || cpu_state == ASID_KIRBYYOSHIEGG
1280        || cpu_state == ASID_CAPTURELEADEAD
1281        || cpu_state == ASID_CAPTURELIKELIKE
1282        || cpu_state == ASID_CAPTUREWAITCRAZYHAND
1283        // hardcode DK cargo throw
1284        || (ASID_SHOULDEREDWAIT <= cpu_state && cpu_state <= ASID_SHOULDEREDTURN)
1285        || (hmn_kind == 3 && (cpu_state == ASID_THROWNF || cpu_state == ASID_THROWNFF));
1286
1287    return 0;
1288}
1289
1290int Lab_CPUPerformAction(GOBJ *cpu, int action_id, GOBJ *hmn)
1291{
1292    LabData *eventData = event_vars->event_gobj->userdata;
1293
1294    // pre-set flag in case of early return.
1295    eventData->cpu_countering_no_interrupt = false;
1296
1297    FighterData *cpu_data = cpu->userdata;
1298    FighterData *hmn_data = hmn->userdata;
1299
1300    // get CPU action
1301    int action_done = 0;
1302    CPUAction *action_list = Lab_CPUActions[action_id];
1303
1304    // clear inputs
1305    Fighter_ZeroCPUInputs(cpu_data);
1306    if (action_list == 0) return true;
1307
1308    if (action_list[0].random) {
1309        if (stc_rndm_counter_slot == -1) {
1310            // get action list for counter type
1311            u8 *actions;
1312            int action_count;
1313        
1314            if (eventData->cpu_hitkind == HITKIND_SHIELD) {
1315                actions = CPUCounterActionsShield;
1316                action_count = countof(CPUCounterActionsShield);
1317            } else if (eventData->cpu_groundstate == 0) {
1318                actions = CPUCounterActionsGround;
1319                action_count = countof(CPUCounterActionsGround);
1320            } else {
1321                actions = CPUCounterActionsAir;
1322                action_count = countof(CPUCounterActionsAir);
1323            }
1324            
1325            // choose random normal counter action in action list 
1326            for (;;) {
1327                action_id = actions[HSD_Randi(action_count)];
1328                if (CPUACT_NORMAL_START <= action_id && action_id < CPUACT_NORMAL_END)
1329                    break;
1330            }
1331
1332            stc_rndm_counter_slot = action_id;
1333        }
1334        
1335        action_id = stc_rndm_counter_slot;
1336        action_list = Lab_CPUActions[action_id];
1337    }
1338
1339    if (action_list[0].randomAdv) {
1340        if (stc_rndm_counter_slot == -1) {
1341            int hittype_menu_idx;
1342            u8 *actions;
1343            if (eventData->cpu_hitkind == HITKIND_SHIELD) {
1344                actions = CPUCounterActionsShield;
1345                hittype_menu_idx = OPTCTR_CTRSHIELD;
1346            } else if (eventData->cpu_groundstate == 0) {
1347                actions = CPUCounterActionsGround;
1348                hittype_menu_idx = OPTCTR_CTRGRND;
1349            } else {
1350                actions = CPUCounterActionsAir;
1351                hittype_menu_idx = OPTCTR_CTRAIR;
1352            };
1353            
1354            // gather custom counter actions
1355            u8 custom_action_ids[ADV_COUNTER_COUNT];
1356            int custom_action_ids_count = 0;
1357            for (int i = 0; i < ADV_COUNTER_COUNT; ++i) {
1358                EventOption *custom_action_menu = LabOptions_AdvCounter[i];
1359                
1360                if (custom_action_menu[OPTCTR_LOGIC].val != CTRLOGIC_CUSTOM)
1361                    continue;
1362
1363                u8 custom_id = actions[custom_action_menu[hittype_menu_idx].val];
1364                custom_action_ids[custom_action_ids_count++] = custom_id;
1365            }
1366            
1367            if (custom_action_ids_count == 0)
1368                return true;
1369    
1370            action_id = custom_action_ids[HSD_Randi(custom_action_ids_count)];
1371            stc_rndm_counter_slot = action_id;
1372        }
1373
1374        action_id = stc_rndm_counter_slot;
1375        action_list = Lab_CPUActions[action_id];
1376    }
1377    
1378    int recSlot = action_list[0].recSlot;
1379    if (recSlot != 0) {
1380        eventData->cpu_countering_no_interrupt = true;
1381
1382        int frame = eventData->counter_slot_frame;
1383        if (frame == 0 && !CPUAction_CheckASID(cpu, ASID_ACTIONABLE)) return false; // wait until actionable
1384
1385        int rec_idx;
1386        if (recSlot == RECSLOT_RANDOM) {
1387            if (stc_rndm_counter_slot == -1)
1388                stc_rndm_counter_slot = Record_GetRandomSlot(rec_data.cpu_inputs, LabOptions_SlotChancesCPU);
1389            rec_idx = stc_rndm_counter_slot;
1390        } else {
1391            rec_idx = recSlot-1;
1392        }
1393        RecInputData *data = rec_data.cpu_inputs[rec_idx];
1394
1395        if (data->start_frame < 0 || frame >= data->num) {
1396            stc_rndm_counter_slot = -1;
1397            eventData->counter_slot_frame = 0;
1398            return true;
1399        }
1400
1401        // cpu inputs have a different range than normal inputs, so we need to convert them.
1402        // This will be slightly lossy, but there's not much we can do.
1403        RecInputs *inputs = &data->inputs[frame];
1404        cpu_data->cpu.lstickX = (s8)((float)inputs->stickX * 1.5875f);
1405        cpu_data->cpu.lstickY = (s8)((float)inputs->stickY * 1.5875f);
1406        cpu_data->cpu.cstickX = (s8)((float)inputs->substickX * 1.5875f);
1407        cpu_data->cpu.cstickY = (s8)((float)inputs->substickY * 1.5875f);
1408        cpu_data->cpu.ltrigger = (u8)((float)inputs->trigger / 140.f * 255.f);
1409        cpu_data->cpu.held = Record_RearrangeButtons(inputs);
1410        eventData->counter_slot_frame = frame + 1;
1411        return false;
1412    }
1413
1414    s16 cpu_frame = cpu_data->state.frame;
1415    if (cpu_frame == -1)
1416        cpu_frame = 0;
1417
1418    // perform command
1419    // loop through all inputs
1420    for (int action_i = 0; ; action_i++)
1421    {
1422        CPUAction *action_input = &action_list[action_i];
1423        if (action_input->state == 0xFFFF)
1424            break;
1425
1426        if (!CPUAction_CheckASID(cpu, action_input->state))
1427            continue;
1428
1429        if (action_input->custom_check && !action_input->custom_check(cpu))
1430            continue;
1431
1432        // check if im on the right frame
1433        if (cpu_frame < action_input->frameLow)
1434            continue;
1435
1436        // stick direction
1437        int dir = 1;
1438        switch (action_input->stickDir) {
1439        case STCKDIR_NONE:
1440            break;
1441        case STCKDIR_TOWARD:
1442            dir = Fighter_GetOpponentDir(cpu_data, hmn_data);
1443            break;
1444        case STCKDIR_AWAY:
1445            dir = -Fighter_GetOpponentDir(cpu_data, hmn_data);
1446            break;
1447        case STCKDIR_FRONT:
1448            dir = cpu_data->facing_direction;
1449            break;
1450        case STCKDIR_BACK:
1451            dir = -cpu_data->facing_direction;
1452            break;
1453        case STICKDIR_RDM:
1454            dir = HSD_Randi(2) ? -1 : 1;
1455            break;
1456        default:
1457            assert("Invalid stick dir");
1458        }
1459
1460        // perform this action
1461        cpu_data->cpu.held = action_input->input;
1462        cpu_data->cpu.lstickX = dir * action_input->stickX;
1463        cpu_data->cpu.lstickY = action_input->stickY;
1464        cpu_data->cpu.cstickX = dir * action_input->cstickX;
1465        cpu_data->cpu.cstickY = action_input->cstickY;
1466
1467        // check if this was the last action
1468        if (action_input->isLast == 1)
1469            action_done = 1;
1470
1471        break;
1472    }
1473    
1474    if (action_done)
1475        stc_rndm_counter_slot = -1;
1476
1477    return action_done;
1478}
1479
1480void CPUResetVars(void) {
1481    LabData *eventData = event_vars->event_gobj->userdata;
1482
1483    // reset CPU think variables
1484    eventData->cpu_state = CPUSTATE_START;
1485    eventData->cpu_hitshield = 0;
1486    eventData->cpu_hitnum = 0;
1487    eventData->cpu_countertimer = 0;
1488    eventData->cpu_lasthit = -1;
1489    eventData->cpu_lastshieldstun = -1;
1490    eventData->cpu_hitkind = -1;
1491    eventData->cpu_isactionable = 0;
1492    eventData->cpu_sdinum = 0;
1493    eventData->cpu_miss_tech_wait_timer = 0;
1494
1495    eventData->counter_slot_frame = 0;
1496    stc_rndm_counter_slot = -1;
1497}
1498
1499void CPUThink(GOBJ *event, GOBJ *hmn, GOBJ *cpu)
1500{
1501    // get gobjs data
1502    LabData *eventData = event->userdata;
1503    FighterData *hmn_data = hmn->userdata;
1504    FighterData *cpu_data = cpu->userdata;
1505    GOBJ **gobj_lookup = (*stc_gobj_lookup);
1506    int cpu_state = cpu_data->state_id;
1507    eventData->cpu_countering = false;
1508
1509    // noact
1510    cpu_data->cpu.ai = 15;
1511
1512    // Check for grab release
1513    int last_state = cpu_data->TM.state_prev[0];
1514    bool exited_capture_cut = last_state == ASID_CAPTURECUT && cpu_state != ASID_CAPTURECUT;
1515    bool exited_capture_jump = last_state == ASID_CAPTUREJUMP && cpu_state != ASID_CAPTUREJUMP;
1516    if((exited_capture_cut || exited_capture_jump) && cpu_data->TM.state_frame == 1)
1517    {
1518        eventData->cpu_hitnum++;
1519        eventData->cpu_state = CPUSTATE_COUNTER;
1520        goto CPULOGIC_COUNTER;
1521    }
1522
1523    // if first throw frame, advance hitnum
1524    int is_thrown = IsThrown(cpu);
1525    if (is_thrown == 1 && eventData->cpu_isthrown == 0)
1526        eventData->cpu_hitnum++;
1527    eventData->cpu_isthrown = is_thrown;
1528
1529    // ALWAYS CHECK FOR X AND OVERRIDE STATE
1530
1531    // Simulate tech lockouts
1532    if (ASID_PASSIVE <= cpu_state && cpu_state <= ASID_PASSIVESTANDB && cpu_data->TM.state_frame == 1) {
1533        int lockout;
1534        int lockout_type = LabOptions_Tech[OPTTECH_LOCKOUT].val;
1535
1536        if (lockout_type == TECHLOCKOUT_EARLIEST) {
1537            // If we have passed the lockout window (cpu_tech_lockout <= 0),
1538            // We can say the CPU could have teched right after the lockout ended.
1539            lockout = 40 + eventData->cpu_tech_lockout;
1540            if (lockout < 20) lockout = 20;
1541            if (lockout > 40) lockout = 40;
1542        } else {
1543            lockout = 40;
1544        }
1545
1546        eventData->cpu_tech_lockout = lockout;
1547    }
1548
1549    // check if damaged
1550    if (cpu_data->flags.hitstun == 1)
1551    {
1552        eventData->cpu_hitkind = HITKIND_DAMAGE;
1553        // go to SDI state
1554        eventData->cpu_state = CPUSTATE_SDI;
1555        Fighter_ZeroCPUInputs(cpu_data);
1556    }
1557    // check if being held in a grab
1558    if (CPU_IsGrabbed(cpu, hmn) == 1)
1559    {
1560        eventData->cpu_state = CPUSTATE_GRABBED;
1561    }
1562    // check if being thrown
1563    if (is_thrown == 1)
1564    {
1565        eventData->cpu_state = CPUSTATE_TDI;
1566    }
1567    // check for shield hit
1568    if ((cpu_state == ASID_GUARDSETOFF) || ((cpu_data->kind == 0xE) && (cpu_state == 344)))
1569    {
1570        Fighter_ZeroCPUInputs(cpu_data);
1571
1572        // check if new shield hit
1573        if (eventData->cpu_lastshieldstun != cpu_data->atk_instance)
1574        {
1575            eventData->cpu_lastshieldstun = cpu_data->atk_instance;
1576            eventData->cpu_hitnum++;
1577        }
1578
1579        // Keep holding shield during hitstop/hitlag. Prevents nana from dropping shield.
1580        cpu_data->cpu.held |= PAD_TRIGGER_R;
1581        cpu_data->input.held |= PAD_TRIGGER_R;
1582        cpu_data->input.trigger = 1.0f;
1583        cpu_data->cpu.ai = 15; // Ensure AI doesn't override this input
1584
1585        eventData->cpu_hitkind = HITKIND_SHIELD;
1586        eventData->cpu_state = CPUSTATE_COUNTER;
1587    }
1588    // check for missed tech
1589    if ((cpu_state == ASID_DOWNBOUNDD) || (cpu_state == ASID_DOWNBOUNDU) || (cpu_state == ASID_DOWNWAITU) || (cpu_state == ASID_DOWNWAITD) || (cpu_state == ASID_PASSIVE) || (cpu_state == ASID_PASSIVESTANDB) || (cpu_state == ASID_PASSIVESTANDF))
1590        eventData->cpu_state = CPUSTATE_GETUP;
1591    // check for cliffgrab
1592    if (cpu_state == ASID_CLIFFWAIT)
1593        eventData->cpu_state = CPUSTATE_RECOVER;
1594    // check if dead
1595    if (cpu_data->flags.dead)
1596        goto CPUSTATE_ENTERSTART;
1597
1598    // run CPU state logic
1599    switch (eventData->cpu_state)
1600    {
1601    // Initial State, hasn't been hit yet
1602    case (CPUSTATE_START):
1603    CPULOGIC_START:
1604    {
1605        // if in the air somehow, enter recovery
1606        if (cpu_data->phys.air_state == 1)
1607        {
1608            eventData->cpu_state = CPUSTATE_RECOVER;
1609            goto CPULOGIC_RECOVER;
1610        }
1611
1612        // clear held inputs
1613        Fighter_ZeroCPUInputs(cpu_data);
1614
1615        // perform default behavior
1616        int behavior = LabOptions_CPU[OPTCPU_BEHAVE].val;
1617        switch (behavior)
1618        {
1619        case (CPUBEHAVE_STAND):
1620        {
1621            break;
1622        }
1623
1624        case (CPUBEHAVE_SHIELD):
1625        {
1626            // hold R
1627            cpu_data->cpu.held |= PAD_TRIGGER_R;
1628            cpu_data->input.held |= PAD_TRIGGER_R;
1629            cpu_data->input.trigger = 1.0f;
1630            cpu_data->cpu.ai = 15; // Ensure AI doesn't override this input
1631
1632            // input shield angle if appropriate
1633            u16 shield_ang = LabOptions_CPU[OPTCPU_SHIELDDIR].val;
1634            // if you do not check action state before inputting a shield angle, it can cause slight
1635            // bugs with OOS options, like trying to input shield angle while doing a grounded up-b OOS.
1636            if (shield_ang != CPUSHIELDANG_NONE && (CPUAction_CheckASID(cpu, ASID_ACTIONABLEGROUND) || CPUAction_CheckASID(cpu, ASID_GUARD))) {
1637                s8 stickX = 0;
1638                s8 stickY = 0;
1639                if (shield_ang == CPUSHIELDANG_TOWARD || shield_ang == CPUSHIELDANG_AWAY) {
1640                    int dir = (int)Fighter_GetOpponentDir(cpu_data, hmn_data);
1641                    stickX = 127 * (dir * (shield_ang == CPUSHIELDANG_AWAY ? -1 : 1));
1642                } else {
1643                    stickY = 127 * (shield_ang == CPUSHIELDANG_DOWN ? -1 : 1);
1644                }
1645                // overwrite the last-frame stick inputs, so 
1646                // rolls/jumps/spotdodges arent triggered by the shield tilt input.
1647                cpu_data->input.lstick.X = stickX;
1648                cpu_data->input.lstick.Y = stickY;
1649                cpu_data->cpu.lstickX = stickX;
1650                cpu_data->cpu.lstickY = stickY;
1651            }
1652            break;
1653        }
1654
1655        case (CPUBEHAVE_CROUCH):
1656        {
1657            // hold down
1658            cpu_data->cpu.lstickY = -127;
1659            break;
1660        }
1661
1662        case (CPUBEHAVE_JUMP):
1663        {
1664            // run jump command
1665            Lab_CPUPerformAction(cpu, 12, hmn);
1666            break;
1667        }
1668        }
1669
1670        break;
1671    }
1672
1673    case (CPUSTATE_GRABBED):
1674    {
1675        // if no longer being grabbed, exit
1676        if (CPU_IsGrabbed(cpu, hmn) == 0)
1677        {
1678            eventData->cpu_state = CPUSTATE_RECOVER;
1679            goto CPULOGIC_RECOVER;
1680        }
1681
1682        int mash = LabOptions_CPU[OPTCPU_MASH].val;
1683        if (mash == CPUMASH_NONE) {
1684            Fighter_ZeroCPUInputs(cpu_data);
1685        }
1686        else if ((mash == CPUMASH_MED && HSD_Randi(100) <= CPUMASHRNG_MED)
1687                || (mash == CPUMASH_HIGH && HSD_Randi(100) <= CPUMASHRNG_HIGH)
1688                || mash == CPUMASH_PERFECT)
1689        {
1690            // remove last frame inputs
1691            cpu_data->input.held = 0;
1692            cpu_data->input.lstick.X = 0;
1693            cpu_data->input.lstick.Y = 0;
1694
1695            // input
1696            cpu_data->cpu.held = PAD_BUTTON_A;
1697            cpu_data->cpu.lstickX = 127;
1698        }
1699
1700        if (LabOptions_CPU[OPTCPU_GRABRELEASE].val == CPUGRABRELEASE_AIRBORN)
1701        {
1702            cpu_data->cpu.held |= HSD_BUTTON_X;
1703        }
1704
1705        break;
1706    }
1707
1708    case (CPUSTATE_SDI):
1709    CPULOGIC_SDI:
1710    {
1711        static int lastSDIWasCardinal = 0;
1712
1713        // update move instance
1714        if (eventData->cpu_lasthit != cpu_data->dmg.atk_instance_hurtby)
1715        {
1716            eventData->cpu_isactionable = 0;
1717            eventData->cpu_countertimer = 0;
1718            eventData->cpu_hitnum++;
1719            eventData->cpu_lasthit = cpu_data->dmg.atk_instance_hurtby;
1720
1721            // decide random SDI direction for grounded cpu
1722            if ((LabOptions_CPU[OPTCPU_SDINUM].val > 0) && (LabOptions_CPU[OPTCPU_SDIDIR].val == SDIDIR_RANDOM))
1723            {
1724                eventData->cpu_sdidir = HSD_Randi(2);
1725            }
1726        }
1727
1728        // if no more hitlag, enter tech state
1729        if (cpu_data->flags.hitlag == 0)
1730        {
1731            eventData->cpu_sdinum = 0; // Done SDIing, reset
1732            eventData->cpu_state = CPUSTATE_TECH;
1733            goto CPULOGIC_TECH;
1734        }
1735
1736        // if hit during a techable animation, enter tech lockout.
1737        if (in_tumble_anim(cpu_data->TM.state_prev[0])) {
1738            int trap_type = LabOptions_Tech[OPTTECH_TRAP].val;
1739            if (trap_type == TECHTRAP_EARLIEST)
1740                eventData->cpu_tech_lockout = 20;
1741            else if (trap_type == TECHTRAP_LATEST)
1742                eventData->cpu_tech_lockout = 40;
1743        }
1744
1745        // if final frame of hitlag, enter TDI state
1746        if (cpu_data->dmg.hitlag_frames == 1)
1747        {
1748            eventData->cpu_sdinum = 0; // Done SDIing, reset
1749            eventData->cpu_state = CPUSTATE_TDI;
1750            goto CPULOGIC_TDI;
1751        }
1752
1753        // perform SDI behavior
1754        if (eventData->cpu_sdinum < LabOptions_CPU[OPTCPU_SDINUM].val)
1755        {
1756            eventData->cpu_sdinum++;
1757            float angle = 0.f;
1758            float magnitude = 0.f;
1759
1760            switch (LabOptions_CPU[OPTCPU_SDIDIR].val)
1761            {
1762            case SDIDIR_RANDOM:
1763            {
1764                // when grounded, only left right
1765                if (cpu_data->phys.air_state == 0)
1766                {
1767                    magnitude = 1;
1768
1769                    // decide left or right
1770                    if (eventData->cpu_sdidir == 0)
1771                        angle = lastSDIWasCardinal ? M_1DEGREE * 17 : M_1DEGREE * 0; // right
1772                    else
1773                        angle = lastSDIWasCardinal ? M_1DEGREE * 197 : M_1DEGREE * 180; // left
1774                }
1775                // when airborne, any direction
1776                else
1777                {
1778                    // random input
1779                    angle = HSD_Randi(360) * M_1DEGREE;
1780                    magnitude = 0.49 + (HSD_Randf() * 0.51);
1781
1782                    angle = GetAngleOutOfDeadzone(angle, lastSDIWasCardinal);
1783                }
1784
1785                break;
1786            }
1787            case SDIDIR_AWAY:
1788            {
1789                int dir = Fighter_GetOpponentDir(cpu_data, hmn_data) * -1;
1790                if (dir == 1)
1791                {
1792                    angle = 0;
1793                }
1794                else
1795                {
1796                    angle = 180;
1797                }
1798                angle = lastSDIWasCardinal ? (angle + 17) * M_1DEGREE : angle * M_1DEGREE;
1799                magnitude = 1;
1800
1801                break;
1802            }
1803            case SDIDIR_TOWARD:
1804            {
1805                int dir = Fighter_GetOpponentDir(cpu_data, hmn_data);
1806                if (dir == 1)
1807                {
1808                    angle = 0;
1809                }
1810                else
1811                {
1812                    angle = 180;
1813                }
1814                angle = lastSDIWasCardinal ? (angle + 17) * M_1DEGREE : angle * M_1DEGREE;
1815                magnitude = 1;
1816
1817                break;
1818            }
1819            case SDIDIR_UP:
1820            {
1821                angle = lastSDIWasCardinal ? M_1DEGREE * 107 : M_1DEGREE * 90;
1822                magnitude = 1;
1823                break;
1824            }
1825            case SDIDIR_DOWN:
1826            {
1827                angle = lastSDIWasCardinal ? M_1DEGREE * 287 : M_1DEGREE * 270;
1828                magnitude = 1;
1829                break;
1830            }
1831            case SDIDIR_LEFT:
1832            {
1833                angle = lastSDIWasCardinal ? M_1DEGREE * 197 : M_1DEGREE * 180;
1834                magnitude = 1;
1835                break;
1836            }
1837            case SDIDIR_RIGHT:
1838            {
1839                angle = lastSDIWasCardinal ? M_1DEGREE * 17 : M_1DEGREE * 0;
1840                magnitude = 1;
1841                break;
1842            }
1843            }
1844
1845            // flip if the last sdi was cardinal
1846            lastSDIWasCardinal = lastSDIWasCardinal ? 0 : 1;
1847
1848            // store
1849            cpu_data->cpu.lstickX = cos(angle) * 127 * magnitude;
1850            cpu_data->cpu.lstickY = sin(angle) * 127 * magnitude;
1851        }
1852
1853        break;
1854    }
1855
1856    case (CPUSTATE_TDI):
1857    CPULOGIC_TDI:
1858    {
1859        // if no more hitlag and not being thrown, enter tech state. this might never be hit, just being safe
1860        if ((cpu_data->flags.hitlag == 0) && (is_thrown == 0))
1861        {
1862            eventData->cpu_state = CPUSTATE_TECH;
1863            goto CPULOGIC_TECH;
1864        }
1865
1866        // if in shield, no need to TDI
1867        if ((cpu_data->state_id >= ASID_GUARDON) && (cpu_data->state_id <= ASID_GUARDREFLECT))
1868            break;
1869
1870        if (cpu_data->dmg.hitlag_frames > 1)
1871            goto CPULOGIC_SDI;
1872
1873        float hit_angle; // knockback angle, ignoring direction.
1874        float dir; // x direction from cpu to attacker to DI based on.
1875        if (is_thrown)
1876        {
1877            FighterData *attacker_data = cpu_data->grab.attacker->userdata;
1878
1879            float reverse_min_angle = 95.0f * M_1DEGREE;
1880
1881            hit_angle = (float)attacker_data->throw_hitbox[0].angle * M_1DEGREE;
1882
1883            if (attacker_data->state_id != ASID_THROWB) {
1884                if (hit_angle < reverse_min_angle) {
1885                    // Most throws
1886                    dir = -attacker_data->facing_direction;
1887                } else {
1888                    // Is a "reverse" throw (e.x. marth dthrow)
1889                    dir = attacker_data->facing_direction;
1890                    hit_angle = M_PI - hit_angle;
1891                }
1892            } else {
1893                // Bthrow is special - we can't use attacker direction cuz it's different between throws,
1894                // e.x. peach doesn't turn around, but fox does. So we need to use cpu direction.
1895                // We assume that bthrows will always be a "reverse" throw.
1896
1897                dir = cpu_data->facing_direction;
1898                if (hit_angle > reverse_min_angle)
1899                    hit_angle = M_PI - hit_angle;
1900            }
1901        }
1902        else
1903        {
1904            hit_angle = Fighter_GetKnockbackAngle(cpu_data);
1905            dir = Fighter_GetOpponentDir(cpu_data, hmn_data);
1906        }
1907
1908        float kb_angle; // actual knockback angle.
1909        if (dir < 0)
1910            kb_angle = hit_angle;
1911        else
1912            kb_angle = M_PI - hit_angle;
1913
1914        // modulus angle
1915        float M_PI2 = M_PI*2;
1916        while (kb_angle < 0) kb_angle += M_PI2;
1917        while (kb_angle >= M_PI2) kb_angle -= M_PI2;
1918
1919        // perform TDI behavior
1920        int tdi_kind = LabOptions_CPU[OPTCPU_TDI].val;
1921        int asdi_kind = LabOptions_CPU[OPTCPU_ASDI].val;
1922        switch (tdi_kind)
1923        {
1924            case (CPUTDI_RANDOM):
1925            TDI_RANDOM:
1926            {
1927                switch (HSD_Randi(3)) {
1928                    case 0: goto TDI_IN;
1929                    case 1: goto TDI_OUT;
1930                    case 2: goto TDI_NONE;
1931                    default: goto TDI_IN;
1932                }
1933            }
1934
1935            case (CPUTDI_IN):
1936            TDI_IN:
1937            {
1938                float tdi_angle;
1939                if (kb_angle <= M_PI)
1940                    tdi_angle = kb_angle - M_PI * 0.5 * dir;
1941                else
1942                    tdi_angle = kb_angle + M_PI * 0.5 * dir;
1943
1944                cpu_data->cpu.lstickX = cos(tdi_angle) * 127;
1945                cpu_data->cpu.lstickY = sin(tdi_angle) * 127;
1946
1947                break;
1948            }
1949
1950            case (CPUTDI_OUT):
1951            TDI_OUT:
1952            {
1953                float tdi_angle;
1954                if (kb_angle <= M_PI)
1955                    tdi_angle = kb_angle + M_PI * 0.5 * dir;
1956                else
1957                    tdi_angle = kb_angle - M_PI * 0.5 * dir;
1958
1959                cpu_data->cpu.lstickX = cos(tdi_angle) * 127;
1960                cpu_data->cpu.lstickY = sin(tdi_angle) * 127;
1961
1962                break;
1963            }
1964            case (CPUTDI_NATURAL):
1965            {
1966                struct DI { s8 x; s8 y; };
1967                static const struct DI di_options[] = {
1968                    // upper half TDI angles
1969                    {-127, 0},
1970                    {127, 0},
1971                    {-89, 89},
1972                    {89, 89},
1973                    {0, 127},
1974                    
1975                    // downwards TDI angles - only apply during combos to avoid floorhugging
1976                    {89, -89},
1977                    {-89, -89},
1978                    {0, -127},
1979                };
1980                
1981                int di_num = eventData->cpu_hitnum > 1 ? 8 : 5;
1982                struct DI di = di_options[HSD_Randi(di_num)];
1983                
1984                cpu_data->cpu.lstickX = di.x;
1985                cpu_data->cpu.lstickY = di.y;
1986                break;
1987            }
1988            case (CPUTDI_CUSTOM):
1989            {
1990                int cpu_hitnum = eventData->cpu_hitnum;
1991
1992                // ensure we have a DI input for this hitnum
1993                if (cpu_hitnum <= stc_tdi_val_num)
1994                {
1995                    // get the stick values for this hit num
1996                    cpu_hitnum--;
1997                    CustomTDI_Apply(cpu, hmn, &stc_tdi_vals[cpu_hitnum]);
1998
1999                    // increment
2000                } else {
2001                    goto TDI_RANDOM;
2002                }
2003
2004                break;
2005            }
2006            case (CPUTDI_RANDOM_CUSTOM):
2007            {
2008                int i = HSD_Randi(stc_tdi_val_num);
2009
2010                CustomTDI_Apply(cpu, hmn, &stc_tdi_vals[i]);
2011
2012                break;
2013            }
2014            case (CPUTDI_NONE):
2015            TDI_NONE:
2016            {
2017                Fighter_ZeroCPUInputs(cpu_data);
2018                break;
2019            }
2020        }
2021        
2022        // only apply ASDI setting when not using custom TDI.
2023        if (
2024            (tdi_kind != CPUTDI_CUSTOM || eventData->cpu_hitnum > stc_tdi_val_num)
2025            && tdi_kind != CPUTDI_RANDOM_CUSTOM
2026        ) {
2027            switch (asdi_kind)
2028            {
2029                case (ASDI_NONE):
2030                case (ASDI_AUTO):
2031                {
2032                    // follow TDI, or custom SDI
2033                    break;
2034                }
2035                case (ASDI_AWAY):
2036                {
2037                    int dir = Fighter_GetOpponentDir(cpu_data, hmn_data) * -1;
2038                    if (dir == 1)
2039                    {
2040                        cpu_data->cpu.cstickX = 127;
2041                        cpu_data->cpu.cstickY = 0;
2042                    }
2043                    else
2044                    {
2045                        cpu_data->cpu.cstickX = -127;
2046                        cpu_data->cpu.cstickY = 0;
2047                    }
2048                    break;
2049                }
2050                case (ASDI_TOWARD):
2051                {
2052                    int dir = Fighter_GetOpponentDir(cpu_data, hmn_data);
2053                    if (dir == 1)
2054                    {
2055                        cpu_data->cpu.cstickX = 127;
2056                        cpu_data->cpu.cstickY = 0;
2057                    }
2058                    else
2059                    {
2060                        cpu_data->cpu.cstickX = -127;
2061                        cpu_data->cpu.cstickY = 0;
2062                    }
2063                    break;
2064                }
2065                case (ASDI_LEFT):
2066                {
2067                    cpu_data->cpu.cstickX = -127;
2068                    cpu_data->cpu.cstickY = 0;
2069                    break;
2070                }
2071                case (ASDI_RIGHT):
2072                {
2073                    cpu_data->cpu.cstickX = 127;
2074                    cpu_data->cpu.cstickY = 0;
2075                    break;
2076                }
2077                case (ASDI_UP):
2078                {
2079                    cpu_data->cpu.cstickX = 0;
2080                    cpu_data->cpu.cstickY = 127;
2081                    break;
2082                }
2083                case (ASDI_DOWN):
2084                {
2085                    cpu_data->cpu.cstickX = 0;
2086                    cpu_data->cpu.cstickY = -127;
2087                    break;
2088                }
2089            }
2090        }
2091
2092        // this is kinda meh, maybe i can come up with something better later
2093        // spoof last input as current input as to not trigger SDI
2094        // also spoof input as held for more than the SDI window
2095        cpu_data->input.lstick.X = ((float)cpu_data->cpu.lstickX * 0.0078125);
2096        cpu_data->input.timer_lstick_tilt_x = 5;
2097        cpu_data->input.lstick.Y = ((float)cpu_data->cpu.lstickY * 0.0078125);
2098        cpu_data->input.timer_lstick_tilt_y = 5;
2099
2100        break;
2101    }
2102
2103    case (CPUSTATE_NONE):
2104    CPULOGIC_NONE:
2105    {
2106        int state = cpu_data->state_id;
2107        if ((ASID_DAMAGEFLYHI <= state && state <= ASID_DAMAGEFLYROLL) || state == ASID_DAMAGEFALL)
2108            goto CPULOGIC_FORCE_TECH;
2109        else
2110            goto CPUSTATE_ENTERSTART;
2111    }
2112
2113    case (CPUSTATE_TECH):
2114    CPULOGIC_TECH:
2115    {
2116        // if no more hitstun, go to counter
2117        if (cpu_data->flags.hitstun == 0)
2118        {
2119            // also reset stick timer (messes with airdodge wiggle)
2120            cpu_data->input.lstick.X = 0;
2121            cpu_data->input.timer_lstick_tilt_x = 254;
2122            eventData->cpu_state = CPUSTATE_COUNTER;
2123            goto CPULOGIC_COUNTER;
2124        }
2125
2126        CPULOGIC_FORCE_TECH:
2127
2128        // Nick: idk the purpose of these lines of code, but I'm keeping them
2129        // since the original logic by UP had them.
2130        cpu_data->input.since_rapid_lr = -1;
2131        cpu_data->input.timer_lstick_smash_x = -1;
2132
2133        // disallow techs if we're in lockout
2134        if (eventData->cpu_tech_lockout > 0) {
2135            cpu_data->input.timer_LR = -1;
2136            cpu_data->cpu.lstickX = 0;
2137            break;
2138        }
2139
2140        // perform tech behavior
2141        int tech = LabOptions_Tech[OPTTECH_TECH].val;
2142        if (tech == CPUTECH_RANDOM) {
2143            float roll = HSD_Randf() * 100.0f;
2144            float tip_chance = LabOptions_Tech[OPTTECH_TECHINPLACECHANCE].val;
2145            float away_chance = LabOptions_Tech[OPTTECH_TECHAWAYCHANCE].val;
2146            float toward_chance = LabOptions_Tech[OPTTECH_TECHTOWARDCHANCE].val;
2147
2148            if (roll < tip_chance)
2149                tech = CPUTECH_NEUTRAL;
2150            else if (roll < tip_chance + away_chance)
2151                tech = CPUTECH_AWAY;
2152            else if (roll < tip_chance + away_chance + toward_chance)
2153                tech = CPUTECH_TOWARDS;
2154            else
2155                tech = CPUTECH_NONE;
2156        }
2157
2158        s8 stick_x = 0;
2159        s8 since_press = 0;
2160        switch (tech) {
2161        case (CPUTECH_NEUTRAL):
2162            break;
2163        case (CPUTECH_AWAY):
2164            stick_x = 40 * -Fighter_GetOpponentDir(cpu_data, hmn_data);
2165            break;
2166        case (CPUTECH_TOWARDS):
2167            stick_x = 40 * Fighter_GetOpponentDir(cpu_data, hmn_data);
2168            break;
2169        case (CPUTECH_NONE):
2170            since_press = -1;
2171            break;
2172        }
2173
2174        // input tech
2175        cpu_data->input.timer_LR = since_press;
2176        cpu_data->cpu.lstickX = stick_x;
2177        break;
2178    }
2179
2180    case (CPUSTATE_GETUP):
2181    {
2182        // if cpu is not in a down state, enter COUNTER
2183        if (cpu_data->state_id < ASID_DOWNBOUNDU || cpu_data->state_id > ASID_DOWNSPOTD)
2184        {
2185            eventData->cpu_state = CPUSTATE_COUNTER;
2186            goto CPULOGIC_COUNTER;
2187            break;
2188        }
2189        // if cpu is in non-wait down state, do nothing
2190        else if (cpu_data->state_id != ASID_DOWNWAITD && cpu_data->state_id != ASID_DOWNWAITU)
2191        {
2192            break;
2193        }
2194
2195        // check to wait in miss tech
2196        if (eventData->cpu_miss_tech_wait_timer) {
2197            eventData->cpu_miss_tech_wait_timer--;
2198            break;
2199        } else {
2200            int wait_chance = LabOptions_Tech[OPTTECH_GETUPWAITCHANCE].val;
2201            if (HSD_Randi(100) < wait_chance) {
2202                eventData->cpu_miss_tech_wait_timer = 15;
2203                break;
2204            }
2205        }
2206
2207        int getup = LabOptions_Tech[OPTTECH_GETUP].val;
2208        if (getup == CPUGETUP_RANDOM) {
2209            float roll = HSD_Randf() * 100.0f;
2210            float stand_chance = LabOptions_Tech[OPTTECH_GETUPSTANDCHANCE].val;
2211            float away_chance = LabOptions_Tech[OPTTECH_GETUPAWAYCHANCE].val;
2212            float toward_chance = LabOptions_Tech[OPTTECH_GETUPTOWARDCHANCE].val;
2213
2214            if (roll < stand_chance)
2215                getup = CPUGETUP_STAND;
2216            else if (roll < stand_chance + away_chance)
2217                getup = CPUGETUP_AWAY;
2218            else if (roll < stand_chance + away_chance + toward_chance)
2219                getup = CPUGETUP_TOWARD;
2220            else
2221                getup = CPUGETUP_ATTACK;
2222        }
2223
2224        // Execute the getup action
2225        switch (getup) {
2226        case CPUGETUP_STAND:
2227            cpu_data->cpu.lstickY = 127;
2228            break;
2229        case CPUGETUP_TOWARD:
2230            cpu_data->cpu.lstickX = 127 * Fighter_GetOpponentDir(cpu_data, hmn_data);
2231            break;
2232        case CPUGETUP_AWAY:
2233            cpu_data->cpu.lstickX = -127 * Fighter_GetOpponentDir(cpu_data, hmn_data);
2234            break;
2235        case CPUGETUP_ATTACK:
2236            cpu_data->cpu.held = PAD_BUTTON_A;
2237            break;
2238        }
2239
2240        break;
2241    }
2242
2243    case (CPUSTATE_COUNTER):
2244    CPULOGIC_COUNTER:
2245    {
2246        int actionable_this_frame = CPUAction_CheckASID(cpu, ASID_ACTIONABLE);
2247
2248        // check if the CPU has been actionable yet
2249        if (eventData->cpu_isactionable == 0)
2250        {
2251            if (!actionable_this_frame) break;
2252
2253            eventData->cpu_isactionable = 1;                       // set actionable flag to begin running code
2254            eventData->cpu_groundstate = cpu_data->phys.air_state; // remember initial ground state
2255        }
2256
2257        // If started in the air, didnt finish action, but now grounded, perform ground action.
2258        // We don't do this for the ground->air transition because some grounded counter actions
2259        // put the CPU in the air. E.x. wavedash, aerial.
2260        if (
2261            eventData->cpu_countering_no_interrupt == 0
2262            && eventData->cpu_groundstate == 1
2263            && cpu_data->phys.air_state == 0
2264        ) {
2265            eventData->cpu_groundstate = 0;
2266        }
2267        
2268        if (
2269            eventData->cpu_hitkind != HITKIND_DAMAGE
2270            && eventData->cpu_hitkind != HITKIND_SHIELD 
2271
2272            // Additional check for countering on grab release
2273            && last_state != ASID_CAPTURECUT 
2274            && last_state != ASID_CAPTUREJUMP
2275        ) {
2276            // wasnt hit, fell or something idk. enter start again
2277            goto CPUSTATE_ENTERSTART;
2278        }
2279
2280        CounterInfo info = GetCounterInfo();
2281        if (info.disable && info.counter_delay == 0)
2282            goto CPULOGIC_START;
2283        
2284        // run counter logic
2285        if (info.action_id == 0) {
2286            eventData->cpu_state = CPUSTATE_NONE;
2287            goto CPULOGIC_NONE;
2288        } else {
2289            eventData->cpu_countering = true;
2290            if (!info.disable && Lab_CPUPerformAction(cpu, info.action_id, hmn)) {
2291                CPUAction *action = Lab_CPUActions[info.action_id];
2292                if (action->noActAfter) {
2293                    eventData->cpu_state = CPUSTATE_NONE;
2294                    goto CPULOGIC_NONE;
2295                } else {
2296                    eventData->cpu_state = CPUSTATE_RECOVER;
2297                }
2298            }
2299        }
2300
2301        break;
2302    }
2303
2304    case (CPUSTATE_RECOVER):
2305    CPULOGIC_RECOVER:
2306    {
2307        // if onstage, go back to start
2308        if (cpu_data->phys.air_state == 0)
2309        {
2310
2311        CPUSTATE_ENTERSTART:
2312            // clear inputs
2313
2314            // go to start
2315            CPUResetVars();
2316            goto CPULOGIC_START;
2317        }
2318        
2319        u32 opt_flags = RecoveryMenuOptFlags(cpu);
2320        Recovery_Think(cpu, opt_flags);
2321
2322        break;
2323    }
2324    }
2325
2326    // We need to reset the counter whenever the CPU is inactionable.
2327    // Otherwise, if the cpu is actionable in the air before landing,
2328    // then the countertimer value will increment even during tech options.
2329    if (CPUAction_CheckASID(cpu, ASID_ACTIONABLE) || eventData->cpu_countering) {
2330        eventData->cpu_countertimer++;
2331    } else {
2332        eventData->cpu_countertimer = 0;
2333    }
2334
2335    // update cpu_hitshield
2336    if (eventData->cpu_hitshield == 0)
2337    {
2338        GOBJ *fighter = gobj_lookup[MATCHPLINK_FIGHTER];
2339        while (fighter != 0)
2340        {
2341            FighterData *fighter_data = fighter->userdata;
2342
2343            // check if in guard off
2344            if (fighter_data->state_id == ASID_GUARDSETOFF)
2345            {
2346                eventData->cpu_hitshield = 1;
2347                break;
2348            }
2349
2350            fighter = fighter->next;
2351        }
2352    }
2353}
2354int Update_CheckPause()
2355{
2356    HSD_Update *update = stc_hsd_update;
2357    int isChange = 0;
2358
2359    // get their pad
2360    int controller = Fighter_GetControllerPort(stc_hmn_controller);
2361    HSD_Pad *pad = PadGetMaster(controller);
2362
2363    // if event menu not showing, develop mode + pause input, toggle frame advance
2364    if ((Pause_CheckStatus(1) != 2) && (*stc_dblevel >= 3) && (pad->down & HSD_BUTTON_START))
2365    {
2366        LabOptions_General[OPTGEN_FRAME].val ^= 1;
2367        Lab_ChangeFrameAdvance(0, LabOptions_General[OPTGEN_FRAME].val);
2368        isChange = 1;
2369    }
2370
2371    // menu paused
2372    else if (LabOptions_General[OPTGEN_FRAME].val == 1)
2373    {
2374        // check if unpaused
2375        if (update->pause_kind != PAUSEKIND_SYS)
2376        {
2377            // pause
2378            isChange = 1;
2379        }
2380    }
2381
2382    // menu unpaused
2383    else
2384    {
2385        if (LabOptions_Record[OPTREC_STARTPAUSED].val && Record_GetCurrFrame() == 0)
2386        {
2387            HSD_Pad *pad = PadGetMaster(stc_hmn_controller);
2388            
2389            int input = false;
2390            int buttons = PAD_TRIGGER_Z | PAD_TRIGGER_L | PAD_TRIGGER_R
2391                | PAD_BUTTON_A | PAD_BUTTON_B | PAD_BUTTON_X | PAD_BUTTON_Y;  
2392            input |= (pad->held & buttons) != 0; 
2393            input |= fabs(pad->fstickX) >= STICK_DEADZONE; 
2394            input |= fabs(pad->fstickY) >= STICK_DEADZONE; 
2395            input |= fabs(pad->fsubstickX) >= STICK_DEADZONE; 
2396            input |= fabs(pad->fsubstickY) >= STICK_DEADZONE; 
2397            input |= pad->triggerLeft >= ANALOG_TRIGGER_THRESHOLD;
2398            input |= pad->triggerRight >= ANALOG_TRIGGER_THRESHOLD;
2399            
2400            if (update->pause_kind == PAUSEKIND_SYS) {
2401                isChange = input;
2402            } else {
2403                isChange = !input;
2404            }
2405        } else if (update->pause_kind == PAUSEKIND_SYS) {
2406            isChange = 1;
2407        }
2408    }
2409
2410    return isChange;
2411}
2412int Update_CheckAdvance()
2413{
2414
2415    static int timer = 0;
2416
2417    HSD_Update *update = stc_hsd_update;
2418    int isAdvance = 0;
2419
2420    int controller = Fighter_GetControllerPort(0);
2421
2422    // get their pad
2423    HSD_Pad *pad = PadGetMaster(controller);
2424    HSD_Pad *engine_pad = PadGetEngine(controller);
2425
2426    // get their advance input
2427    static int stc_advance_btns[] = {HSD_TRIGGER_L, HSD_TRIGGER_Z, HSD_BUTTON_X, HSD_BUTTON_Y, HSD_TRIGGER_R};
2428    int advance_btn = stc_advance_btns[LabOptions_General[OPTGEN_FRAMEBTN].val];
2429
2430    // check if holding L
2431    if (!LabOptions_General[OPTGEN_FRAMEBTN].disable && (pad->held & advance_btn))
2432    {
2433        timer++;
2434
2435        // advance if first press or holding more than 10 frames
2436        if (timer == 1 || timer > 30)
2437        {
2438            isAdvance = 1;
2439
2440            // remove button input
2441            pad->down &= ~advance_btn;
2442            pad->held &= ~advance_btn;
2443            engine_pad->down &= ~advance_btn;
2444            engine_pad->held &= ~advance_btn;
2445
2446            // if using L, remove analog press too
2447            if (advance_btn == HSD_TRIGGER_L)
2448            {
2449                pad->triggerLeft = 0;
2450                pad->ftriggerLeft = 0;
2451                engine_pad->triggerLeft = 0;
2452                engine_pad->ftriggerLeft = 0;
2453            }
2454            else if (advance_btn == HSD_TRIGGER_R)
2455            {
2456                pad->triggerRight = 0;
2457                pad->ftriggerRight = 0;
2458                engine_pad->triggerRight = 0;
2459                engine_pad->ftriggerRight = 0;
2460            }
2461        }
2462    }
2463
2464    else
2465    {
2466        update->advance = 0;
2467        timer = 0;
2468    }
2469
2470    return isAdvance;
2471}
2472void DIDraw_Init(void)
2473{
2474    // Create DIDraw GOBJ
2475    GOBJ *didraw_gobj = GObj_Create(0, 0, 0);
2476    // Add gxlink
2477    GObj_AddGXLink(didraw_gobj, DIDraw_GX, 6, 0);
2478    // init didraw pointers
2479    for (int i = 0; i < 6; i++)
2480    {
2481        // for each subchar
2482        for (int j = 0; j < 2; j++)
2483        {
2484            didraws[i].num[j] = 0;
2485            didraws[i].vertices[j] = 0;
2486
2487            sdidraws[i].num[j] = 0;
2488            sdidraws[i].cap[j] = 0;
2489            sdidraws[i].vertices[j] = 0;
2490        }
2491    }
2492}
2493void DIDraw_Update(void)
2494{
2495    static ECBSize ecb_size_def = {
2496        .topY = 9,
2497        .botY = 2.5,
2498        .left = {-3.3, 5.7},
2499        .right = {3.3, 5.7},
2500    };
2501    
2502    // if enabled and pause menu isnt shown, update di draw
2503    if ((LabOptions_General[OPTGEN_DI].val == 1)) //  && (Pause_CheckStatus(1) != 2)
2504    {
2505        for (int i = 0; i < 4; ++i) {
2506            GOBJ *fighter = Fighter_GetGObj(i);
2507            if (fighter == 0) continue;
2508
2509            FighterData *fighter_data = fighter->userdata;
2510            int ply = fighter_data->ply;
2511            
2512            // SDI DISPLAY ---------------------------------------------------
2513            
2514            SDIDraw *sdidraw = &sdidraws[ply];
2515
2516            if (IsHitlagVictim(fighter))
2517            { 
2518                int hitlag_left = fighter_data->dmg.hitlag_frames;
2519                int hitlag_passed = sdidraw->num[ply];
2520                int total_hitlag = hitlag_left + hitlag_passed;
2521
2522                // realloc if undersized.
2523                if (total_hitlag > sdidraw->cap[ply]) {
2524                    Vec2 *vertices = calloc(sizeof(Vec2) * total_hitlag);
2525                    if (sdidraw->vertices[ply]) {
2526                        memcpy(vertices, sdidraw->vertices[ply], sdidraw->num[ply] * sizeof(Vec2));
2527                        HSD_Free(sdidraw->vertices[ply]);
2528                    }
2529                    sdidraw->vertices[ply] = vertices;
2530                    sdidraw->cap[ply] = total_hitlag;
2531                }
2532                
2533                sdidraw->vertices[ply][hitlag_passed] = (Vec2) {
2534                    .X = fighter_data->phys.pos.X,
2535                    .Y = fighter_data->phys.pos.Y,
2536                };
2537                
2538                // only actually draw if there was SDI
2539                if (
2540                    hitlag_passed == 0
2541                    || sdidraw->vertices[ply][hitlag_passed].X != sdidraw->vertices[ply][hitlag_passed-1].X
2542                    || sdidraw->vertices[ply][hitlag_passed].Y != sdidraw->vertices[ply][hitlag_passed-1].Y
2543                ) {
2544                    sdidraw->num[ply]++;
2545                }
2546            }
2547            else if (fighter_data->flags.hitstun == 0)
2548            {
2549                // don't show after histun ends
2550                sdidraw->num[ply] = 0;
2551            }
2552            
2553            // DI DISPLAY ---------------------------------------------------
2554            
2555            DIDraw *didraw = &didraws[ply];
2556
2557            // if in hitlag and hitstun simulate and update trajectory
2558            if (fighter_data->flags.hitstun == 1)
2559            {
2560                // free old
2561                if (didraw->vertices[ply] != 0)
2562                {
2563                    HSD_Free(didraw->vertices[ply]);
2564                    didraw->num[ply] = 0;
2565                    didraw->vertices[ply] = 0;
2566                }
2567
2568                // get player's inputs
2569                float lstickX;
2570                float lstickY;
2571                float cstickX;
2572                float cstickY;
2573                // for HMN players
2574                if (Fighter_GetSlotType(fighter_data->ply) == 0)
2575                {
2576                    HSD_Pad *pad;
2577                    if (Pause_CheckStatus(0) == 1) // if frame advance enabled, use master inputs
2578                        pad = PadGetMaster(fighter_data->pad_index);
2579                    else
2580                        pad = PadGetEngine(fighter_data->pad_index);
2581                    lstickX = pad->fstickX;
2582                    lstickY = pad->fstickY;
2583                    cstickX = pad->fsubstickX;
2584                    cstickY = pad->fsubstickY;
2585                }
2586                // for CPUs
2587                else
2588                {
2589                    lstickX = fighter_data->input.lstick.X;
2590                    lstickY = fighter_data->input.lstick.Y;
2591                    cstickX = fighter_data->input.cstick.X;
2592                    cstickY = fighter_data->input.cstick.Y;
2593                }
2594
2595                // get kb vector
2596                Vec3 kb = fighter_data->phys.kb_vel;
2597                float kb_angle = atan2(kb.Y, kb.X);
2598                // init ASDI vector
2599                Vec3 asdi = {0, 0, 0};
2600                Vec3 asdi_orig = {0, 0, 0};
2601                // get fighter constants
2602                ftCommonData *ft_common = *stc_ftcommon;
2603
2604                if (fighter_data->flags.hitlag) {
2605                    // Calculate ASDI
2606                    float asdi_mag = squaref(ft_common->asdi_mag);
2607                    float asdi_units = ft_common->asdi_units;
2608                    // CStick has priority, check if mag > 0.7
2609                    if (squaref(cstickX) + squaref(cstickY) >= asdi_mag)
2610                    {
2611                        asdi.X = cstickX * asdi_units;
2612                        asdi.Y = cstickY * asdi_units;
2613                    }
2614                    // now check if lstick mag > 0.7
2615                    else if (squaref(lstickX) + squaref(lstickY) >= asdi_mag)
2616                    {
2617                        asdi.X = lstickX * asdi_units;
2618                        asdi.Y = lstickY * asdi_units;
2619                    }
2620                    // Remember original ASDI
2621                    asdi_orig = asdi;
2622
2623                    // Calculate TDI
2624                    if ((lstickX != 0) || (lstickY != 0)) // exclude input vector 0,0
2625                    {
2626                        // kb vector must exceed 0.00001
2627                        float kb_mult = (kb.Y * kb.Y) + (kb.X * kb.X);
2628                        if (kb_mult >= 0.00001)
2629                        {
2630
2631                            // get values
2632                            float tdi_input = squaref((-1 * kb.X * lstickY) + (lstickX * kb.Y)) / kb_mult;
2633                            float max_angle = ft_common->tdi_maxAngle * M_1DEGREE;
2634                            float kb_mag = sqrtf(kb_mult);
2635
2636                            // check to negate
2637                            Vec3 inputs = {lstickX, lstickY, 0};
2638                            Vec3 result;
2639                            VECCrossProduct(&kb, &inputs, &result);
2640                            if (result.Z < 0)
2641                                tdi_input *= -1;
2642
2643                            // apply TDI
2644                            kb_angle = (max_angle * tdi_input) + kb_angle;
2645
2646                            // New X KB
2647                            kb.X = cos(kb_angle) * kb_mag;
2648                            // New Y KB
2649                            kb.Y = sin(kb_angle) * kb_mag;
2650                        }
2651                    }
2652                }
2653
2654                //simulation variables
2655                int air_state = fighter_data->phys.air_state;
2656                float y_vel = fighter_data->phys.self_vel.Y;
2657                Vec3 pos = fighter_data->phys.pos;
2658                float decay = ft_common->kb_frameDecay;
2659                float hitstun_frames;
2660                memcpy(&hitstun_frames, &fighter_data->state_var.state_var1, sizeof(float));
2661                int vertices_num = 0;    // used to track how many vertices will be needed
2662                int override_frames = 0; // used as an alternate countdown
2663                DIDrawCalculate *DICollData = calloc(sizeof(DIDrawCalculate) * hitstun_frames);
2664                CollData ecb;
2665                ECBSize ecb_size;
2666
2667                // init ecb struct
2668                Coll_InitECB(&ecb);
2669                if (fighter_data->phys.air_state == 0) // copy ecb struct if grounded
2670                {
2671                    memcpy(&ecb.envFlags, &fighter_data->coll_data.envFlags, 0x28);
2672                }
2673
2674                // simulate each frame of knockback
2675                for (int i = 0; i < hitstun_frames; i++)
2676                {
2677
2678                    // update bone positions.  If loop count < noECBUpdate-remaining hitlag fraes, use current ECB bottom Y offset
2679                    if (vertices_num < (fighter_data->coll_data.u.ecb_bot_lock_frames - fighter_data->dmg.hitlag_frames))
2680                    {
2681
2682                        ecb_size.topY = fighter_data->coll_data.ecbCurr_top.Y;
2683                        ecb_size.botY = fighter_data->coll_data.ecbCurr_bot.Y;
2684                        ecb_size.left = fighter_data->coll_data.ecbCurr_left;
2685                        ecb_size.right = fighter_data->coll_data.ecbCurr_right;
2686
2687                        // if grounded, ECB bottom is 0
2688                        if (air_state == 0)
2689                        {
2690                            ecb_size.botY = 0;
2691                        }
2692                    }
2693                    else
2694                    {
2695                        // use default ecb size
2696                        memcpy(&ecb_size, &ecb_size_def, sizeof(ECBSize));
2697                    }
2698                    // update ecb topN position
2699                    ecb.topN_Curr = pos;
2700                    ecb.topN_CurrCorrect = pos;
2701
2702                    // apply ASDI
2703                    pos.X += asdi.X;
2704                    if (air_state != 0) // only apply Y asdi in the air
2705                    {
2706                        pos.Y += asdi.Y;
2707                    }
2708                    asdi.X = 0; // zero out ASDI
2709                    asdi.Y = 0; // zero out ASDI
2710
2711                    // update y_vel
2712                    y_vel -= fighter_data->attr.gravity;
2713                    float terminal_velocity = fighter_data->attr.terminal_velocity * -1;
2714                    if (y_vel < terminal_velocity)
2715                        y_vel = terminal_velocity;
2716                    // decay KB vector
2717                    float angle = atan2(kb.Y, kb.X);
2718                    kb.X = kb.X - (cos(angle) * decay);
2719                    kb.Y = kb.Y - (sin(angle) * decay);
2720
2721                    // add knockback
2722                    VECAdd(&pos, &kb, &pos);
2723                    // apply y_vel
2724                    pos.Y += y_vel;
2725
2726                    // ecb prev = ecb curr
2727                    ecb.topN_Prev = ecb.topN_Curr;
2728                    // ecb curr = new position
2729                    ecb.topN_Curr = pos;
2730
2731                    // only run X collision checks because theyre expensive
2732                    if (vertices_num >= DI_MaxColl)
2733                    {
2734                        DICollData[i].envFlags = 0; // spoof as not touching
2735                        pos = ecb.topN_Curr;        // position = projected
2736                    }
2737
2738                    // update collision
2739                    else
2740                    {
2741                        // ground coll
2742                        if (air_state == 0)
2743                        {
2744                            int result = ECB_CollGround_PassLedge(&ecb, &ecb_size);
2745                            if (result == 0)
2746                            {
2747                                air_state = 1;
2748                            }
2749                        }
2750                        // air coll
2751                        else
2752                        {
2753                            ECB_CollAir(&ecb, &ecb_size);
2754                        }
2755
2756                        // get corrected position
2757                        pos = ecb.topN_Curr;
2758
2759                        // increment collision ID
2760                        ecb.coll_test += 1;
2761
2762                        // perform stage collision code
2763                        if ((ecb.envFlags & ECB_GROUND) != 0)
2764                        {
2765                            // check if air->ground just occurred
2766                            if (air_state == 1)
2767                            {
2768                                // set grounded
2769                                air_state = 0;
2770
2771                                // check if over max horizontal velocity
2772                                if (kb.X > ft_common->kb_maxVelX)
2773                                    kb.X = ft_common->kb_maxVelX;
2774                                if (kb.X < -ft_common->kb_maxVelX)
2775                                    kb.X = -ft_common->kb_maxVelX;
2776
2777                                // adjust KB direction from slope
2778                                kb.X *= ecb.ground_slope.Y;
2779                                kb.Y *= ecb.ground_slope.X;
2780
2781                                // zero out y_vel
2782                                y_vel = 0;
2783
2784                                // zero out Y KB
2785                                kb.Y = 0;
2786                            }
2787                        }
2788                        else if ((ecb.envFlags & ECB_CEIL) != 0)
2789                        {
2790                            // only run this code when in the air
2791                            if (air_state == 1)
2792                            {
2793                                // combine KB and Gravity
2794                                Vec3 kb_temp = kb;
2795                                Vec3 vel_temp = {0, y_vel, 0};
2796                                VECAdd(&vel_temp, &kb_temp, &vel_temp);
2797
2798                                // apply slope
2799                                VECMultAndAdd(&vel_temp, &ecb.ceil_slope);
2800
2801                                // decay kb
2802                                kb.X = vel_temp.X * ft_common->kb_bounceDecay;
2803                                kb.Y = vel_temp.Y * ft_common->kb_bounceDecay;
2804                            }
2805                        }
2806                        else if ((ecb.envFlags & (ECB_WALLLEFT | ECB_WALLRIGHT)) != 0)
2807                        {
2808                            // only run this code when in the air
2809                            if (air_state == 1)
2810                            {
2811
2812                                // get slope
2813                                Vec3 *slope;
2814                                if ((ecb.envFlags & ECB_WALLLEFT) != 0)
2815                                {
2816                                    slope = &ecb.leftwall_slope;
2817                                }
2818                                else
2819                                {
2820                                    slope = &ecb.rightwall_slope;
2821                                }
2822
2823                                // combine KB and Gravity
2824                                Vec3 kb_temp = kb;
2825                                Vec3 vel_temp = {0, y_vel, 0};
2826                                VECAdd(&vel_temp, &kb_temp, &vel_temp);
2827
2828                                // apply slope
2829                                VECMultAndAdd(&vel_temp, slope);
2830
2831                                // decay kb
2832                                kb.X = vel_temp.X * ft_common->kb_bounceDecay;
2833                                kb.Y = vel_temp.Y * ft_common->kb_bounceDecay;
2834
2835                                // zero y_vel
2836                                y_vel = 0;
2837                            }
2838                        }
2839
2840                        // check for slide off
2841                        if (((ecb.envFlags & ECB_GROUND) == 0) && ((ecb.envFlags_prev & ECB_GROUND) != 0)) // not touching ground this frame, was touching last frame
2842                        {
2843                            if (override_frames == 0)
2844                                override_frames = 5; // terminate in 5 frames
2845                        }
2846                    }
2847
2848                    // save this position
2849                    DICollData[i].pos.X = pos.X;
2850                    DICollData[i].pos.Y = pos.Y;
2851                    DICollData[i].kb_Y = kb.Y;
2852                    DICollData[i].ECBLeftY = ecb_size.left.Y;
2853                    DICollData[i].ECBTopY = ecb_size.topY;
2854
2855                    // inc vertices count
2856                    vertices_num++;
2857
2858                    // if override frames are set, decrement and exit
2859                    if (override_frames > 0)
2860                    {
2861                        override_frames--;
2862                        if (override_frames == 0)
2863                            break;
2864                    }
2865                }
2866
2867                // alloc draw struct
2868                didraw->num[ply] = vertices_num + 2; // +2 for ASDI vertices
2869                // alloc vertices
2870                didraw->vertices[ply] = calloc(sizeof(Vec2) * (vertices_num + 2));
2871
2872                // save ASDI first
2873                didraw->vertices[ply][0].X = fighter_data->coll_data.topN_Curr.X;
2874                didraw->vertices[ply][0].Y = fighter_data->coll_data.topN_Curr.Y + fighter_data->coll_data.ecbCurr_left.Y;
2875                didraw->vertices[ply][1].X = fighter_data->coll_data.topN_Curr.X + asdi_orig.X;
2876                didraw->vertices[ply][1].Y = fighter_data->coll_data.topN_Curr.Y + fighter_data->coll_data.ecbCurr_left.Y + asdi_orig.Y;
2877
2878                // save this info to the draw struct
2879                for (int i = 0; i < vertices_num; i++)
2880                {
2881                    didraw->vertices[ply][i + 2].X = DICollData[i].pos.X;
2882                    didraw->vertices[ply][i + 2].Y = DICollData[i].pos.Y + ((DICollData[i].ECBLeftY + DICollData[i].ECBTopY) / 2);
2883                }
2884
2885                // free the collision info
2886                HSD_Free(DICollData);
2887            }
2888            // if not in hitstun, zero out didraw
2889            else if (fighter_data->flags.hitstun == 0)
2890            {
2891                if (didraw->vertices[ply] != 0)
2892                {
2893                    HSD_Free(didraw->vertices[ply]);
2894                    didraw->num[ply] = 0;
2895                    didraw->vertices[ply] = 0;
2896                }
2897            }
2898        }
2899    }
2900
2901    // is off, remove all di draw
2902    else
2903    {
2904        // all slots
2905        for (int i = 0; i < 6; i++)
2906        {
2907            DIDraw *didraw = &didraws[i];
2908            SDIDraw *sdidraw = &sdidraws[i];
2909
2910            // all subchars
2911            for (int j = 0; j < 2; j++)
2912            {
2913                if (didraw->vertices[j] != 0)
2914                {
2915                    HSD_Free(didraw->vertices[j]);
2916                    didraw->num[j] = 0;
2917                    didraw->vertices[j] = 0;
2918                }
2919
2920                sdidraw->num[j] = 0;
2921            }
2922        }
2923    }
2924}
2925void DIDraw_GX(void)
2926{
2927    // if toggle enabled
2928    if (LabOptions_General[OPTGEN_DI].val == 1)
2929    {
2930        // draw each
2931        for (int i = 0; i < 6; i++)
2932        {
2933            // for each subchar
2934            for (int j = 0; j < 2; j++)
2935            {
2936                // SDI DISPLAY -------------------------------------------
2937                
2938                SDIDraw *sdidraw = &sdidraws[i];
2939
2940                // if it exists
2941                if (sdidraw->num[j] > 1) {
2942                    int vertex_num = sdidraw->num[j];
2943                    Vec2 *vertices = sdidraw->vertices[j];
2944                
2945                    // alloc prim
2946                    PRIM_DrawMode draw_mode = {
2947                        .line_width = 31,
2948                        .z_compare_enable = false,
2949                        .z_update_enable = true,
2950                        .z_logic_eq = true,
2951                        .z_logic_lt = true,
2952                        .shape = PRIM_SHAPE_LINE_STRIP,
2953                    };
2954                    PRIM_BlendMode blend_mode = { 0 };
2955                    PRIM_NEW(vertex_num + vertex_num - 2, draw_mode, blend_mode);
2956
2957                    // draw each
2958                    for (int k = 1;;)
2959                    {
2960                        // alternate yellow/orange so it's easier to see individual inputs
2961                        PRIM_DRAW(vertices[k-1].X, vertices[k-1].Y, 0, 0xffff00ff);
2962                        PRIM_DRAW(vertices[k].X, vertices[k].Y, 0, 0xffff00ff);
2963                        if (++k >= vertex_num) break;
2964
2965                        PRIM_DRAW(vertices[k-1].X, vertices[k-1].Y, 0, 0xffa500ff);
2966                        PRIM_DRAW(vertices[k].X, vertices[k].Y, 0, 0xffa500ff);
2967                        if (++k >= vertex_num) break;
2968                    }
2969    
2970                    // close
2971                    PRIM_CLOSE();
2972                }
2973
2974                // DI DISPLAY --------------------------------------------
2975                
2976                DIDraw *didraw = &didraws[i];
2977                
2978                // if it exists
2979                if (didraw->num[j] != 0)
2980                {
2981                    int vertex_num = didraw->num[j];
2982                    Vec2 *vertices = didraw->vertices[j];
2983
2984                    // alloc prim
2985                    PRIM_DrawMode draw_mode = {
2986                        .line_width = 31,
2987                        .z_compare_enable = true,
2988                        .z_logic_eq = true,
2989                        .z_logic_lt = true,
2990                        .shape = PRIM_SHAPE_LINE_STRIP,
2991                    };
2992                    PRIM_BlendMode blend_mode = { 0 };
2993                    PRIM_NEW(vertex_num, draw_mode, blend_mode);
2994
2995                    // draw each
2996                    for (int k = 0; k < vertex_num; k++)
2997                    {
2998                        PRIM_DRAW(vertices[k].X, vertices[k].Y, 0, 0x008affff);
2999                    }
3000
3001                    // close
3002                    PRIM_CLOSE();
3003                }
3004            }
3005        }
3006    }
3007}
3008
3009void CustomTDI_Apply(GOBJ *cpu, GOBJ *hmn, CustomTDI *di)
3010{
3011    FighterData *hmn_data = hmn->userdata;
3012    FighterData *cpu_data = cpu->userdata;
3013
3014    float di_direction = 1.f;
3015    float diff = cpu_data->phys.pos.X - hmn_data->phys.pos.X;
3016
3017    int cur_direction;
3018    if (diff > 3.f) {
3019        cur_direction = 1;
3020    } else if (diff < -3.f) {
3021        cur_direction = 0;
3022    } else {
3023        cur_direction = hmn_data->facing_direction > 0.f;
3024    }
3025
3026    if (di->reversing && di->direction != cur_direction)
3027        di_direction = -1.f;
3028
3029    cpu_data->cpu.lstickX = di->lstickX * 127.f * di_direction;
3030    cpu_data->cpu.lstickY = di->lstickY * 127.f;
3031    cpu_data->cpu.cstickX = di->cstickX * 127.f * di_direction;
3032    cpu_data->cpu.cstickY = di->cstickY * 127.f;
3033}
3034
3035void Lab_SelectCustomTDI(GOBJ *menu_gobj)
3036{
3037    MenuData *menu_data = menu_gobj->userdata;
3038    evMenu *menuAssets = event_vars->menu_assets;
3039
3040    // create bg gobj
3041    GOBJ *tdi_gobj = GObj_Create(0, 0, 0);
3042    TDIData *userdata = calloc(sizeof(TDIData));
3043    GObj_AddUserData(tdi_gobj, 4, HSD_Free, userdata);
3044
3045    // load menu joint
3046    JOBJ *tdi_joint = JOBJ_LoadJoint(menuAssets->menu);
3047    GObj_AddObject(tdi_gobj, 3, tdi_joint);                                     // add to gobj
3048    GObj_AddGXLink(tdi_gobj, GXLink_Common, GXLINK_MENUMODEL, GXPRI_MENUMODEL); // add gx link
3049    menu_data->custom_gobj_think = CustomTDI_Update;                            // set callback
3050
3051    // load current stick joints
3052    JOBJ *stick_joint = JOBJ_LoadJoint(stc_lab_data->stick);
3053    stick_joint->scale = (Vec3) {2, 2, 1};
3054    stick_joint->trans = (Vec3) {-6, -6, 0};
3055    userdata->stick_curr[0] = stick_joint;
3056    JOBJ_AddChild(tdi_gobj->hsd_object, stick_joint);
3057    // current c stick
3058    stick_joint = JOBJ_LoadJoint(stc_lab_data->cstick);
3059    stick_joint->scale = (Vec3) {2, 2, 1};
3060    stick_joint->trans = (Vec3) {6, -6, 0};
3061    userdata->stick_curr[1] = stick_joint;
3062    JOBJ_AddChild(tdi_gobj->hsd_object, stick_joint);
3063
3064    // create stick curr text
3065    Text *text_curr = Text_CreateText(2, menu_data->canvas_menu);
3066    userdata->text_curr = text_curr;
3067    text_curr->kerning = 1;
3068    // scale canvas
3069    text_curr->viewport_scale.X = MENU_CANVASSCALE;
3070    text_curr->viewport_scale.Y = MENU_CANVASSCALE;
3071    // create hit num
3072    Text_AddSubtext(text_curr, -50, 185, " ");
3073    // create lstick coords
3074    for (int i = 0; i < 2; i++)
3075    {
3076        Text_AddSubtext(text_curr, -400, (80 + i * 40), " ");
3077    }
3078    // create cstick coords
3079    for (int i = 0; i < 2; i++)
3080    {
3081        Text_AddSubtext(text_curr, 250, (80 + i * 40), " ");
3082    }
3083
3084    // create prev sticks
3085    for (int i = 0; i < TDI_DISPNUM; i++)
3086    {
3087        // left stick
3088        JOBJ *prevstick_joint = JOBJ_LoadJoint(stc_lab_data->stick);
3089        prevstick_joint->rot.X = 0.4;
3090        prevstick_joint->trans.X = -22 + (i * (55 / TDI_DISPNUM));
3091        prevstick_joint->trans.Y = 10;
3092        JOBJ_SetFlags(prevstick_joint, JOBJ_HIDDEN);
3093        userdata->stick_prev[i][0] = prevstick_joint;
3094        JOBJ_AddChild(tdi_gobj->hsd_object, prevstick_joint);
3095
3096        // cstick
3097        prevstick_joint = JOBJ_LoadJoint(stc_lab_data->cstick);
3098        prevstick_joint->rot.X = 0.4;
3099        prevstick_joint->trans.X = -18 + (i * (55 / TDI_DISPNUM));
3100        prevstick_joint->trans.Y = 8;
3101        JOBJ_SetFlags(prevstick_joint, JOBJ_HIDDEN);
3102        userdata->stick_prev[i][1] = prevstick_joint;
3103        JOBJ_AddChild(tdi_gobj->hsd_object, prevstick_joint);
3104
3105        // create text
3106        Text_AddSubtext(text_curr, (-460 + (i * ((55 * 19.6) / TDI_DISPNUM))), -100, " ");
3107    }
3108
3109    // create description text
3110    Text_AddSubtext(text_curr, -460, 240, "Input TDI angles for the CPU to use.");
3111    Text_AddSubtext(text_curr, -460, 285, "A = Save Input  X = Delete Input  B = Return");
3112    Text_AddSubtext(text_curr, -460, 320, "Z = Reversible");
3113
3114    // set pointers to custom gobj
3115    menu_data->custom_gobj = tdi_gobj;
3116    menu_data->custom_gobj_destroy = CustomTDI_Destroy;
3117}
3118int CustomTDI_Update(GOBJ *gobj)
3119{
3120    // get data
3121    TDIData *tdi_data = gobj->userdata;
3122    MenuData *menu_data = event_vars->menu_gobj->userdata;
3123
3124    // get pausing players inputs
3125    HSD_Pad *pad = PadGetMaster(menu_data->controller_index);
3126    int inputs = pad->down;
3127
3128    // if press A, save stick
3129    if ((inputs & HSD_BUTTON_A) && stc_tdi_val_num < TDI_HITNUM) {
3130        GOBJ *hmn = Fighter_GetGObj(0);
3131        GOBJ *cpu = Fighter_GetGObj(1);
3132        FighterData *hmn_data = hmn->userdata;
3133        FighterData *cpu_data = cpu->userdata;
3134        int direction = cpu_data->phys.pos.X < hmn_data->phys.pos.X ? 0 : 1;
3135
3136        stc_tdi_vals[stc_tdi_val_num++] = (CustomTDI) {
3137            .lstickX = pad->fstickX,
3138            .lstickY = pad->fstickY,
3139            .cstickX = pad->fsubstickX,
3140            .cstickY = pad->fsubstickY,
3141            .reversing = false,
3142            .direction = direction,
3143        };
3144        SFX_PlayCommon(1);
3145    }
3146
3147    if ((inputs & HSD_TRIGGER_Z) != 0 && stc_tdi_val_num > 0) {
3148        stc_tdi_vals[stc_tdi_val_num-1].reversing ^= 1;
3149        SFX_PlayCommon(1);
3150    }
3151
3152    // if press X, go back a hit
3153    if ((inputs & HSD_BUTTON_X) && stc_tdi_val_num > 0) {
3154        stc_tdi_val_num--;
3155        SFX_PlayCommon(0);
3156    }
3157
3158    // if press B, exit
3159    if (inputs & HSD_BUTTON_B)
3160    {
3161        CustomTDI_Destroy(gobj);
3162        return 1;
3163    }
3164
3165    // update curr lstick
3166    JOBJ *stick_curr = tdi_data->stick_curr[0];
3167    stick_curr->rot.Y = pad->fstickX * 0.75;
3168    stick_curr->rot.X = pad->fstickY * 0.75 * -1;
3169    // update curr cstick
3170    stick_curr = tdi_data->stick_curr[1];
3171    stick_curr->rot.Y = pad->fsubstickX * 0.75;
3172    stick_curr->rot.X = pad->fsubstickY * 0.75 * -1;
3173
3174    // Update curr stick coordinates
3175    Text *text_curr = tdi_data->text_curr;
3176    Text_SetText(text_curr, 0, "TDI: %d", stc_tdi_val_num + 1);
3177    Text_SetText(text_curr, 1, "X: %+.4f", pad->fstickX);
3178    Text_SetText(text_curr, 2, "Y: %+.4f", pad->fstickY);
3179    Text_SetText(text_curr, 3, "X: %+.4f", pad->fsubstickX);
3180    Text_SetText(text_curr, 4, "Y: %+.4f", pad->fsubstickY);
3181
3182    // display previous sticks
3183    for (int i = 0; i < TDI_DISPNUM; i++)
3184    {
3185        JOBJ *lstick_prev = tdi_data->stick_prev[i][0];
3186        JOBJ *cstick_prev = tdi_data->stick_prev[i][1];
3187        int this_hit = i;
3188        if (stc_tdi_val_num > TDI_DISPNUM)
3189            this_hit = (stc_tdi_val_num - TDI_DISPNUM + i);
3190
3191        // show stick
3192        if (i < stc_tdi_val_num)
3193        {
3194            // remove hidden flag
3195            JOBJ_ClearFlags(lstick_prev, JOBJ_HIDDEN);
3196            JOBJ_ClearFlags(cstick_prev, JOBJ_HIDDEN);
3197
3198            // update rotation
3199            CustomTDI di = stc_tdi_vals[this_hit];
3200            lstick_prev->rot.Y = di.lstickX * 0.75;
3201            lstick_prev->rot.X = di.lstickY * -0.75;
3202            cstick_prev->rot.Y = di.cstickX * 0.75;
3203            cstick_prev->rot.X = di.cstickY * -0.75;
3204
3205            // update text
3206            const char *str = di.reversing ? "TDI %d R" : "TDI %d";
3207            Text_SetText(text_curr, i + 5, str, this_hit + 1);
3208        }
3209        // hide stick
3210        else
3211        {
3212            // set hidden flag
3213            JOBJ_SetFlags(lstick_prev, JOBJ_HIDDEN);
3214            JOBJ_SetFlags(cstick_prev, JOBJ_HIDDEN);
3215
3216            Text_SetText(text_curr, i + 5, " ");
3217        }
3218    }
3219
3220    // update jobj
3221    JOBJ_SetMtxDirtySub(gobj->hsd_object);
3222    
3223    return 1;
3224}
3225void CustomTDI_Destroy(GOBJ *gobj)
3226{
3227    // get data
3228    TDIData *tdi_data = gobj->userdata;
3229    MenuData *menu_data = event_vars->menu_gobj->userdata;
3230
3231    // set TDI to custom
3232    if (stc_tdi_val_num > 0) {
3233        int prev = LabOptions_CPU[OPTCPU_TDI].val;
3234        if (prev != CPUTDI_CUSTOM && prev != CPUTDI_RANDOM_CUSTOM)
3235            LabOptions_CPU[OPTCPU_TDI].val = CPUTDI_CUSTOM;
3236    }
3237
3238    // free text
3239    Text_Destroy(tdi_data->text_curr);
3240
3241    // destroy
3242    GObj_Destroy(gobj);
3243
3244    // show menu
3245    menu_data->custom_gobj = 0;
3246    menu_data->custom_gobj_think = 0;
3247    menu_data->custom_gobj_destroy = 0;
3248
3249    // play sfx
3250    SFX_PlayCommon(0);
3251}
3252
3253static DOBJ *JOBJ_GetDObjChild(JOBJ *joint, int dobj_index)
3254{
3255
3256    int count = 0;
3257    DOBJ *dobj = joint->dobj;
3258
3259    while (count < dobj_index)
3260    {
3261        if (dobj->next == 0)
3262            assert("dobj not found!");
3263
3264        else
3265            dobj = dobj->next;
3266
3267        count++;
3268    }
3269
3270    return dobj;
3271}
3272
3273void Inputs_Think(GOBJ *gobj)
3274{
3275    Controller *controllers = gobj->userdata;
3276    bool show[4] = {false};
3277
3278    if (Pause_CheckStatus(1) != 2) {
3279        switch (LabOptions_General[OPTGEN_INPUT].val) {
3280        case INPUTDISPLAY_OFF:
3281            break;
3282        case INPUTDISPLAY_HMN:
3283            show[0] = true;
3284            break;
3285        case INPUTDISPLAY_CPU:
3286            show[1] = true;
3287            break;
3288        case INPUTDISPLAY_HMN_AND_CPU:
3289            show[0] = true;
3290            show[1] = true;
3291            break;
3292        }
3293    }
3294
3295    // update controllers
3296    for (int i = 0; i < 4; i++)
3297    {
3298        Controller *controller = &controllers[i];
3299        JOBJ *controller_jobj = controller->jobj;
3300
3301        if (controller_jobj == NULL) continue;
3302        if (!show[i]) {
3303            // Aitch: I would LOVE to set the hidden flag instead of abusing the Z axis.
3304            // But for some reason it doesn't work! Lmk if you have a better idea.
3305
3306            controller_jobj->trans.Z = -99999.0;
3307            //JOBJ_SetFlags(controller_jobj, JOBJ_HIDDEN);
3308
3309            JOBJ_SetMtxDirtySub(controller_jobj);
3310            continue;
3311        }
3312
3313        controller_jobj->trans.Z = 0.0;
3314
3315        // get port and controller data
3316        GOBJ *fighter = Fighter_GetGObj(i);
3317        FighterData *ft_data = fighter->userdata;
3318        HSD_Pad *pad = PadGetEngine(ft_data->pad_index);
3319
3320        float stickX, stickY, substickX, substickY, triggerR, triggerL;
3321        int held;
3322
3323        if (Fighter_GetSlotType(ft_data->ply) == 0) {
3324            // show controller inputs
3325            stickX = pad->fstickX;
3326            stickY = pad->fstickY;
3327            substickX = pad->fsubstickX;
3328            substickY = pad->fsubstickY;
3329            triggerR = pad->ftriggerRight;
3330            triggerL = pad->ftriggerLeft;
3331            held = pad->held;
3332        } else {
3333            // show CPU inputs
3334            stickX = (float)ft_data->cpu.lstickX / 127.f;
3335            stickY = (float)ft_data->cpu.lstickY / 127.f;
3336            substickX = (float)ft_data->cpu.cstickX / 127.f;
3337            substickY = (float)ft_data->cpu.cstickY / 127.f;
3338            triggerR = (float)pad->ftriggerRight / 255.f;
3339            triggerL = (float)pad->ftriggerLeft / 255.f;
3340            held = ft_data->cpu.held;
3341        }
3342
3343        // move lstick
3344        JOBJ *lstick_joint;
3345        JOBJ_GetChild(controller_jobj, &lstick_joint, 10, -1);
3346        lstick_joint->trans.X = stickX * 2.3;
3347        lstick_joint->trans.Y = stickY * 2.3;
3348
3349        // move lstick
3350        JOBJ *rstick_joint;
3351        JOBJ_GetChild(controller_jobj, &rstick_joint, 8, -1);
3352        rstick_joint->trans.X = substickX * 2.3;
3353        rstick_joint->trans.Y = substickY * 2.3;
3354
3355        // move ltrigger
3356        JOBJ *ltrig_joint;
3357        JOBJ_GetChild(controller_jobj, &ltrig_joint, button_lookup[BTN_L].jobj, -1);
3358        ltrig_joint->trans.X = triggerL * 0.5 + controller->ltrig_origin.X;
3359        ltrig_joint->trans.Z = triggerL * 1.5 + controller->ltrig_origin.Y;
3360
3361        // move rtrigger
3362        JOBJ *rtrig_joint;
3363        JOBJ_GetChild(controller_jobj, &rtrig_joint, button_lookup[BTN_R].jobj, -1);
3364        rtrig_joint->trans.X = triggerR * -0.5 + controller->rtrig_origin.X;
3365        rtrig_joint->trans.Z = triggerR *  1.5 + controller->rtrig_origin.Y;
3366
3367        // update button colors
3368        for (int i = 0; i < BTN_NUM; i++)
3369        {
3370            // Get buttons jobj and dobj from the lookup table
3371            JOBJ *button_jobj;
3372            JOBJ_GetChild(controller_jobj, &button_jobj, button_lookup[i].jobj, -1);
3373            DOBJ *button_dobj = JOBJ_GetDObjChild(button_jobj, button_lookup[i].dobj);
3374
3375            // check if button is pressed
3376            if (held & button_bits[i])
3377            {
3378                // make white i guess for now
3379                GXColor color_pressed = INPUT_COLOR_PRESSED;
3380                button_dobj->mobj->mat->diffuse = color_pressed;
3381            }
3382            // not pressed, make the default color
3383            else
3384            {
3385                GXColor *color_released = &button_colors[i];
3386                button_dobj->mobj->mat->diffuse = *color_released;
3387            }
3388        }
3389
3390        JOBJ_SetMtxDirtySub(controller_jobj);
3391    }
3392}
3393
3394void Inputs_Init()
3395{
3396    // Create Input Display GOBJ
3397    GOBJ *input_gobj = GObj_Create(0, 0, 0);
3398    Controller *controllers = calloc(sizeof(Controller) * 4);
3399    GObj_AddUserData(input_gobj, 4, HSD_Free, controllers);
3400    GObj_AddProc(input_gobj, Inputs_Think, 4);
3401
3402    // alloc a dummy root jobj
3403    JOBJDesc *root_desc = calloc(sizeof(JOBJDesc));
3404    root_desc->flags = JOBJ_ROOT_XLU | JOBJ_ROOT_TEXEDGE;
3405    root_desc->scale.X = 1;
3406    root_desc->scale.Y = 1;
3407    root_desc->scale.Z = 1;
3408    JOBJ *root = JOBJ_LoadJoint(root_desc);
3409
3410    static Vec2 stc_pos[4] = {
3411        {13, 20},
3412        {23, 20},
3413        {13, 10},
3414        {23, 10},
3415    };
3416
3417    int controller_count = 0;
3418    for (int i = 0; i < 4; i++)
3419    {
3420        int slot = Fighter_GetSlotType(i);
3421        if (slot != 0 && slot != 1)
3422            continue;
3423
3424        Vec2 pos = stc_pos[controller_count++];
3425
3426        Controller *controller = &controllers[i];
3427
3428        // create jobj
3429        JOBJ *controller_jobj = JOBJ_LoadJoint(stc_lab_data->controller);
3430        controller->jobj = controller_jobj;
3431        controller_jobj->trans.X = pos.X;
3432        controller_jobj->trans.Y = pos.Y;
3433        JOBJ_AddChild(root, controller_jobj);
3434
3435        // save trigger origins
3436        JOBJ *ltrig_jobj, *rtrig_jobj;
3437        JOBJ_GetChild(controller_jobj, &ltrig_jobj, button_lookup[BTN_L].jobj, -1);
3438        JOBJ_GetChild(controller_jobj, &rtrig_jobj, button_lookup[BTN_R].jobj, -1);
3439        controller->ltrig_origin.X = ltrig_jobj->trans.X;
3440        controller->ltrig_origin.Y = ltrig_jobj->trans.Z;
3441        controller->rtrig_origin.X = rtrig_jobj->trans.X;
3442        controller->rtrig_origin.Y = rtrig_jobj->trans.Z;
3443    }
3444
3445    GObj_AddObject(input_gobj, 3, root);                              // add to gobj
3446    GObj_AddGXLink(input_gobj, GXLink_Common, INPUT_GXLINK, INPUT_GXPRI); // add gx link
3447}
3448
3449void Record_CopySlot(GOBJ *menu_gobj) {
3450    int player = LabOptions_SlotManagement[OPTSLOT_PLAYER].val;
3451    int copy_slot = LabOptions_SlotManagement[OPTSLOT_SRC].val;
3452    int target_slot = LabOptions_SlotManagement[OPTSLOT_DST].val;
3453    if (copy_slot == target_slot) return;
3454
3455    RecInputData **data;
3456    EventOption *chances;
3457    if (player == PLAYER_HMN) {
3458        data = rec_data.hmn_inputs;
3459        chances = LabOptions_SlotChancesHMN;
3460    } else {
3461        data = rec_data.cpu_inputs;
3462        chances = LabOptions_SlotChancesCPU;
3463    }
3464
3465    chances[target_slot].disable = chances[copy_slot].disable;
3466    ReboundSlotChances(chances, target_slot);
3467    memcpy(data[target_slot], data[copy_slot], sizeof(RecInputData));
3468}
3469
3470void Record_DeleteSlot(GOBJ *menu_gobj) {
3471    int player = LabOptions_SlotManagement[OPTSLOT_PLAYER].val;
3472    int delete_slot = LabOptions_SlotManagement[OPTSLOT_SRC].val;
3473
3474    RecInputData **data;
3475    EventOption *chances;
3476    if (player == PLAYER_HMN) {
3477        data = rec_data.hmn_inputs;
3478        chances = LabOptions_SlotChancesHMN;
3479    } else {
3480        data = rec_data.cpu_inputs;
3481        chances = LabOptions_SlotChancesCPU;
3482    }
3483    chances[delete_slot].disable = 1;
3484    ReboundSlotChances(chances, delete_slot);
3485    data[delete_slot]->start_frame = -1;
3486    data[delete_slot]->num = 0;
3487}
3488
3489void InitInputSlot(RecInputData **data) {
3490    *data = calloc(sizeof(RecInputData));
3491    (*data)->start_frame = -1;
3492    (*data)->num = 0;
3493}
3494
3495// Recording Functions
3496GOBJ *Record_Init()
3497{
3498    // Create GOBJ
3499    GOBJ *rec_gobj = GObj_Create(0, 7, 0);
3500    // Add per frame process
3501    GObj_AddProc(rec_gobj, Record_Think, 3);
3502
3503    evMenu *menuAssets = event_vars->menu_assets;
3504    JOBJ *playback = JOBJ_LoadJoint(menuAssets->playback);
3505
3506    // save seek jobj
3507    JOBJ *seek;
3508    JOBJ_GetChild(playback, &seek, REC_SEEKJOINT, -1);
3509    rec_data.seek_jobj = seek;
3510
3511    rec_data.restore_timer = 0;
3512
3513    // save left and right seek bounds
3514    JOBJ *seek_bound[2];
3515    JOBJ_GetChild(playback, seek_bound, REC_LEFTBOUNDJOINT, REC_RIGHTBOUNDJOINT, -1);
3516    Vec3 seek_bound_pos;
3517    JOBJ_GetWorldPosition(seek_bound[0], 0, &seek_bound_pos);
3518    rec_data.seek_left = seek_bound_pos.X;
3519    JOBJ_GetWorldPosition(seek_bound[1], 0, &seek_bound_pos);
3520    rec_data.seek_right = seek_bound_pos.X;
3521
3522    // Add to gobj
3523    GObj_AddObject(rec_gobj, 3, playback);
3524    // Add gxlink
3525    GObj_AddGXLink(rec_gobj, Record_GX, REC_GXLINK, GXPRI_RECJOINT);
3526
3527    // Create text
3528    int canvas_index = Text_CreateCanvas(2, rec_gobj, 14, 15, 0, REC_GXLINK, GXPRI_RECTEXT, 19);
3529    Text *text = Text_CreateText(2, canvas_index);
3530    text->align = 1;
3531    text->kerning = 1;
3532    text->viewport_scale.X = REC_TEXTSCALE;
3533    text->viewport_scale.Y = REC_TEXTSCALE;
3534
3535    // Get text positions
3536    JOBJ *text_joint[2];
3537    JOBJ_GetChild(playback, text_joint, REC_LEFTTEXTJOINT, REC_RIGHTTEXTJOINT, -1);
3538    Vec3 text_left, text_right;
3539    JOBJ_GetWorldPosition(text_joint[0], 0, &text_left);
3540    JOBJ_GetWorldPosition(text_joint[1], 0, &text_right);
3541
3542    // Create subtexts for each side
3543    Text_AddSubtext(text, (text_left.X * 25), -(text_left.Y * 25), " ");
3544    Text_AddSubtext(text, (text_right.X * 25), -(text_right.Y) * 25, " ");
3545    rec_data.text = text;
3546
3547    // alloc rec_state
3548    rec_state = calloc(sizeof(Savestate_v1));
3549    // set as not exist
3550    rec_state->is_exist = 0;
3551
3552    // disable menu options
3553    for (u32 i = 0; i < countof(LabOptions_Record); i++)
3554    {
3555        if (i != OPTREC_SAVE_LOAD)
3556            LabOptions_Record[i].disable = 1;
3557    }
3558
3559    // allocate input arrays
3560    for (int i = 0; i < REC_SLOTS; i++)
3561    {
3562        InitInputSlot(&rec_data.hmn_inputs[i]);
3563        InitInputSlot(&rec_data.cpu_inputs[i]);
3564    }
3565    InitInputSlot(&rec_data.hmn_rerecord_inputs);
3566    InitInputSlot(&rec_data.cpu_rerecord_inputs);
3567
3568    // init memcard stuff
3569    Memcard_InitWorkArea();
3570    Memcard_InitSnapshotList(HSD_MemAlloc(2112), HSD_MemAlloc(256064));
3571
3572    // Create snapshot cam
3573    snap_image.img_ptr = 0;
3574    GOBJ *snap_gobj = GObj_Create(18, 18, 0);
3575    GOBJ_InitCamera(snap_gobj, Snap_CObjThink, 4);
3576    GX_AllocImageData(&snap_image, EXP_SCREENSHOT_WIDTH, EXP_SCREENSHOT_HEIGHT, 4, 2006);
3577    export_status = EXSTAT_NONE;
3578
3579    /*
3580    // init dev text
3581    int height = 18;
3582    int width = 28;
3583    int x = -50;
3584    int y = 410;
3585    DevText *dev_text = DevelopText_CreateDataTable(x, y, 0, width, height, HSD_MemAlloc(height * width * 2));
3586    stc_devtext = dev_text;
3587    DevelopText_Activate(0, dev_text);
3588    dev_text->cursorBlink = 0;
3589    GXColor color = {21, 20, 59, 135};
3590    DevelopText_StoreBGColor(dev_text, &color);
3591    DevelopText_StoreTextScale(dev_text, 7.5, 10);
3592    */
3593    return rec_gobj;
3594}
3595void Record_GX(GOBJ *gobj, int pass)
3596{
3597    bool hideHUD = *(u8*)(R13 + -0x4948);
3598    rec_data.text->hidden = hideHUD;
3599    if (hideHUD) return;
3600    
3601    // update UI position
3602    // the reason im doing this here is because i want it to update in the menu
3603    if (pass == 0)
3604    {
3605        JOBJ *seek = rec_data.seek_jobj;
3606        Text *text = rec_data.text;
3607
3608        // get curr frame (the current position in the recording)
3609        int curr_frame = Record_GetCurrFrame();
3610        int end_frame = Record_GetEndFrame();
3611
3612        int cpu_mode = LabOptions_Record[OPTREC_CPUMODE].val;
3613        int hmn_mode = LabOptions_Record[OPTREC_HMNMODE].val;
3614        
3615        // hide seek bar during recording
3616        if (cpu_mode == RECMODE_CPU_RECORD || hmn_mode == RECMODE_HMN_RECORD)
3617        {
3618            JOBJ_SetFlags(seek, JOBJ_HIDDEN);
3619
3620            // correct record frame
3621            if (curr_frame >= REC_LENGTH)
3622                curr_frame = REC_LENGTH;
3623
3624            // update seek bar frames
3625            Text_SetText(text, 0, "%d", curr_frame + 1);
3626            Text_SetText(text, 1, " ");
3627
3628            // update color
3629            GXColor text_color;
3630            if (curr_frame == REC_LENGTH)
3631            {
3632                text_color.r = 255;
3633                text_color.g = 57;
3634                text_color.b = 62;
3635            }
3636            else if (((float)curr_frame / (float)REC_LENGTH) >= 0.75)
3637            {
3638                text_color.r = 255;
3639                text_color.g = 124;
3640                text_color.b = 36;
3641            }
3642            else
3643            {
3644                text_color.r = 255;
3645                text_color.g = 255;
3646                text_color.b = 255;
3647            }
3648            Text_SetColor(text, 0, &text_color);
3649        }
3650        // during playback
3651        else
3652        {
3653            JOBJ_ClearFlags(seek, JOBJ_HIDDEN);
3654
3655            // if playing back with no recording, adjust both numbers
3656            int local_frame_seek = curr_frame + 1;
3657            if (curr_frame >= end_frame)
3658            {
3659                local_frame_seek = curr_frame + 1;
3660                end_frame = curr_frame + 1;
3661            }
3662
3663            // update seek bar position
3664            float range = rec_data.seek_right - rec_data.seek_left;
3665            float curr_pos;
3666            curr_pos = (float)local_frame_seek / (float)end_frame;
3667            seek->trans.X = rec_data.seek_left + (curr_pos * range);
3668            JOBJ_ClearFlagsAll(seek, JOBJ_HIDDEN);
3669            JOBJ_SetMtxDirtySub(seek);
3670
3671            // update seek bar frames
3672            Text_SetText(text, 0, "%d", local_frame_seek);
3673            Text_SetText(text, 1, "%d", end_frame);
3674
3675            // if random playback, hide frame count and bar
3676            if ((LabOptions_Record[OPTREC_CPUSLOT].val == 0) || (LabOptions_Record[OPTREC_HMNSLOT].val == 0))
3677            {
3678                Text_SetText(text, 1, "?");          // hide count
3679                JOBJ_SetFlagsAll(seek, JOBJ_HIDDEN); // hide bar
3680            }
3681
3682            // update color
3683            GXColor text_color;
3684            text_color.r = 255;
3685            text_color.g = 255;
3686            text_color.b = 255;
3687            Text_SetColor(text, 0, &text_color);
3688        }
3689    }
3690
3691    GXLink_Common(gobj, pass);
3692}
3693
3694void Record_Think(GOBJ *rec_gobj)
3695{
3696    if (rec_state->is_exist != 1) return;
3697
3698    GOBJ *cpu = Fighter_GetGObj(1);
3699    FighterData *cpu_data = cpu->userdata;
3700
3701    int hmn_slot = Record_GetSlot(0);
3702    int cpu_slot = Record_GetSlot(1);
3703
3704    RecInputData *hmn_inputs = rec_data.hmn_inputs[hmn_slot];
3705    RecInputData *cpu_inputs = rec_data.cpu_inputs[cpu_slot];
3706    int hmn_mode = LabOptions_Record[OPTREC_HMNMODE].val;
3707    int cpu_mode = LabOptions_Record[OPTREC_CPUMODE].val;
3708    
3709    // get longest recording
3710    int input_num = hmn_inputs->num;
3711    if (cpu_inputs->num > hmn_inputs->num)
3712        input_num = cpu_inputs->num;
3713
3714    // update inputs ---------------------------------------
3715
3716    int adjusted_hmn_mode = hmn_mode;
3717    if (adjusted_hmn_mode > 0) // adjust hmn_mode to match cpu_mode
3718        adjusted_hmn_mode++;
3719    Record_Update(0, hmn_inputs, rec_data.hmn_rerecord_inputs, adjusted_hmn_mode);
3720    Record_Update(1, cpu_inputs, rec_data.cpu_rerecord_inputs, cpu_mode);
3721
3722    // loop inputs check ------------------------------
3723
3724    int loop_mode = LabOptions_Record[OPTREC_LOOP].val;
3725    int modes_allow_loop = !Record_HMN_IsRecording()
3726        && !Record_CPU_IsRecording()
3727        && cpu_mode != RECMODE_CPU_CONTROL;
3728    int has_inputs = input_num != 0;
3729    int past_last_input = Record_GetCurrFrame() >= input_num;
3730    if (loop_mode & modes_allow_loop & has_inputs & past_last_input)
3731    {
3732        event_vars->game_timer = rec_state->frame;
3733
3734        // reroll
3735        if (LabOptions_Record[OPTREC_HMNSLOT].val == 0)
3736            rec_data.hmn_rndm_slot = Record_GetRandomSlot(rec_data.hmn_inputs, LabOptions_SlotChancesHMN);
3737        if (LabOptions_Record[OPTREC_CPUSLOT].val == 0)
3738            rec_data.cpu_rndm_slot = Record_GetRandomSlot(rec_data.cpu_inputs, LabOptions_SlotChancesCPU);
3739    }
3740
3741    // autorestore check -----------------------------------
3742
3743    if (modes_allow_loop) {
3744        int autorestore_mode = LabOptions_Record[OPTREC_AUTORESTORE].val;
3745        int restore = false;
3746        LabData *event_data = event_vars->event_gobj->userdata;
3747        switch (autorestore_mode)
3748        {
3749            case (AUTORESTORE_NONE):
3750                break;
3751            case (AUTORESTORE_PLAYBACK_END):
3752            {
3753                restore = past_last_input & has_inputs;
3754                break;
3755            }
3756            case (AUTORESTORE_COUNTER):
3757            {
3758                int state = cpu_data->state_id;
3759                restore = event_data->cpu_countering
3760                    || (ASID_DEADDOWN <= state && state <= ASID_DEADUPFALLHITCAMERAICE)
3761                    // Aitch: temporary hack to reset before we add Counter Action (Ledge) options.
3762                    || state == ASID_CLIFFWAIT;
3763                break;
3764            }
3765        }
3766
3767        // start restore timer on restore, and increment it if it has already started
3768        if (restore || rec_data.restore_timer > 0)
3769            rec_data.restore_timer++;
3770
3771        if (rec_data.restore_timer >= AUTORESTORE_DELAY)
3772            Record_LoadSavestate(rec_state);
3773    }
3774}
3775
3776int Record_RearrangeButtons(RecInputs *inputs) {
3777    int held = 0;
3778    held |= inputs->btn_a << 8;
3779    held |= inputs->btn_b << 9;
3780    held |= inputs->btn_x << 10;
3781    held |= inputs->btn_y << 11;
3782    held |= inputs->btn_L << 6;
3783    held |= inputs->btn_R << 5;
3784    held |= inputs->btn_Z << 4;
3785    held |= inputs->btn_dpadup << 3;
3786    return held;
3787}
3788
3789void Record_SetInputs(GOBJ *fighter, RecInputs *inputs, bool mirror) {
3790    FighterData *fighter_data = fighter->userdata;
3791    HSD_Pad *pad = PadGetEngine(fighter_data->pad_index);
3792
3793    // read inputs
3794    pad->held = Record_RearrangeButtons(inputs);
3795
3796    // stick signed bytes
3797    pad->stickX = inputs->stickX * (mirror ? -1 : 1);
3798    pad->stickY = inputs->stickY;
3799    pad->substickX = inputs->substickX * (mirror ? -1 : 1);
3800    pad->substickY = inputs->substickY;
3801
3802    // stick floats
3803    pad->fstickX = ((float)inputs->stickX / 80) * (mirror ? -1 : 1);
3804    pad->fstickY = ((float)inputs->stickY / 80);
3805    pad->fsubstickX = ((float)inputs->substickX / 80) * (mirror ? -1 : 1);
3806    pad->fsubstickY = ((float)inputs->substickY / 80);
3807
3808    // trigger byte
3809    pad->triggerRight = inputs->trigger;
3810    pad->triggerLeft = 0;
3811
3812    // trigger float
3813    pad->ftriggerRight = ((float)inputs->trigger / 140);
3814    pad->ftriggerLeft = 0;
3815    
3816    // Aitch: Set the raw pad inputs as well.
3817    // Some UCF corrections (e.g. SDI) are based on the raw pad data.
3818    // Since we overwrite the pad inputs, we also need to overwrite the raw inputs.
3819    // Otherwise, the UCF corrections will not be triggered.
3820    // It would be nice to simply overwrite the raw inputs with recording inputs,
3821    // and let the game copy it over to the pads we wrote above and internal UCF pads,
3822    // but alas TM has too much cruft for this to be feasible.
3823    PADStatus *stat = PadGetRaw(fighter_data->pad_index);
3824    stat->button = pad->held;
3825    stat->stickX = pad->stickX;
3826    stat->stickY = pad->stickY;
3827    stat->substickX = pad->substickX;
3828    stat->substickY = pad->substickY;
3829    stat->triggerRight = pad->triggerRight;
3830    stat->triggerLeft = 0;
3831    stat->analogA = 0;
3832    stat->analogB = 0;
3833}
3834
3835// assumes rec_mode_cpu
3836void Record_Update(int ply, RecInputData *input_data, RecInputData *rerecord_input_data, int rec_mode)
3837{
3838    GOBJ *fighter = Fighter_GetGObj(ply);
3839    FighterData *fighter_data = fighter->userdata;
3840
3841    // get curr frame (the time since saving positions)
3842    int curr_frame = (event_vars->game_timer - rec_state->frame);
3843
3844    // get the frame the recording starts on. i actually hate this code and need to change how this works
3845    int rec_start;
3846    if (input_data->start_frame == -1) // case 1: recording didnt start, use current frame
3847    {
3848        rec_start = curr_frame - 1;
3849    }
3850    else // case 2: recording has started, use the frame saved
3851    {
3852        rec_start = input_data->start_frame - rec_state->frame;
3853    }
3854
3855    // Get HSD Pad
3856    HSD_Pad *pad = PadGetEngine(fighter_data->pad_index);
3857
3858    // ensure we haven't taken over playback or set the cpu to counter
3859    bool cancelled = (ply == 0 && stc_playback_cancelled_hmn)
3860        || (ply == 1 && stc_playback_cancelled_cpu);
3861        
3862    // if the current frame before the recording ends
3863    if ((curr_frame) < (rec_start + REC_LENGTH))
3864    {
3865        switch (rec_mode)
3866        {
3867        case (RECMODE_CPU_OFF):
3868        case (RECMODE_CPU_CONTROL):
3869            break;
3870        case (RECMODE_CPU_RECORD):
3871        RECMODE_RECORD:
3872        {
3873            // recording has started BUT the player has jumped back behind it, move the start frame back
3874            if ((input_data->start_frame == -1) || (curr_frame < rec_start))
3875            {
3876                input_data->start_frame = (event_vars->game_timer - 1);
3877                rec_start = curr_frame - 1;
3878            }
3879
3880            // store inputs
3881            int held = pad->held;
3882            RecInputs *inputs = &input_data->inputs[curr_frame - 1];
3883            inputs->btn_a = !!((held)&HSD_BUTTON_A);
3884            inputs->btn_b = !!((held)&HSD_BUTTON_B);
3885            inputs->btn_x = !!((held)&HSD_BUTTON_X);
3886            inputs->btn_y = !!((held)&HSD_BUTTON_Y);
3887            inputs->btn_L = !!((held)&HSD_TRIGGER_L);
3888            inputs->btn_R = !!((held)&HSD_TRIGGER_R);
3889            inputs->btn_Z = !!((held)&HSD_TRIGGER_Z);
3890            inputs->btn_dpadup = !!((held)&HSD_BUTTON_DPAD_UP);
3891
3892            inputs->stickX = pad->stickX;
3893            inputs->stickY = pad->stickY;
3894            inputs->substickX = pad->substickX;
3895            inputs->substickY = pad->substickY;
3896
3897            // trigger - find the one pressed down more
3898            u8 trigger = pad->triggerLeft;
3899            if (pad->triggerRight > trigger)
3900                trigger = pad->triggerRight;
3901            inputs->trigger = trigger;
3902
3903            // update input_num
3904            input_data->num = (curr_frame - rec_start);
3905
3906            break;
3907        }
3908        case (RECMODE_CPU_PLAYBACK):
3909        RECMODE_PLAYBACK:
3910        {
3911            if (cancelled)
3912                return;
3913            // ensure we have an input for this frame
3914            if (curr_frame < rec_start || (curr_frame - rec_start) > (input_data->num))
3915                return;
3916
3917            RecInputs *inputs = &input_data->inputs[curr_frame - 1];
3918            Record_SetInputs(fighter, inputs, event_vars->loaded_mirrored);
3919            break;
3920        }
3921        case (RECMODE_CPU_RERECORD):
3922            // use rerecord inputs instead
3923            rerecord_input_data->inputs[curr_frame - 1] = input_data->inputs[curr_frame - 1];
3924            input_data = rerecord_input_data;
3925            
3926            if (cancelled)
3927                goto RECMODE_RECORD;
3928            else
3929                goto RECMODE_PLAYBACK;
3930        }
3931    }
3932}
3933
3934bool Record_HMN_IsRecording(void)
3935{
3936    int mode = LabOptions_Record[OPTREC_HMNMODE].val;
3937    return mode == RECMODE_HMN_RECORD || mode == RECMODE_HMN_RERECORD;
3938}
3939bool Record_CPU_IsRecording(void)
3940{
3941    int mode = LabOptions_Record[OPTREC_CPUMODE].val;
3942    return mode == RECMODE_CPU_RECORD || mode == RECMODE_CPU_RERECORD;
3943}
3944bool Record_HMN_IsPlayback(void)
3945{
3946    return LabOptions_Record[OPTREC_HMNMODE].val == RECMODE_HMN_PLAYBACK;
3947}
3948bool Record_CPU_IsPlayback(void)
3949{
3950    return LabOptions_Record[OPTREC_CPUMODE].val == RECMODE_CPU_PLAYBACK;
3951}
3952bool Record_HMN_IsRandomSlot(void)
3953{
3954    return LabOptions_Record[OPTREC_HMNSLOT].val == 0;
3955}
3956bool Record_CPU_IsRandomSlot(void)
3957{
3958    return LabOptions_Record[OPTREC_CPUSLOT].val == 0;
3959}
3960
3961void Record_InitState(GOBJ *menu_gobj)
3962{
3963    stc_playback_cancelled_hmn = false;
3964    stc_playback_cancelled_cpu = false;
3965    if (event_vars->Savestate_Save_v1(rec_state, 0))
3966        Record_OnSuccessfulSave(1);
3967}
3968
3969// returns time_diff
3970int Record_RemakeState(void)
3971{
3972    stc_playback_cancelled_hmn = false;
3973    stc_playback_cancelled_cpu = false;
3974    int prev_frame = rec_state->frame;
3975    if (event_vars->Savestate_Save_v1(rec_state, 0))
3976        Record_OnSuccessfulSave(0);
3977    int new_frame = rec_state->frame;
3978    int time_diff = new_frame - prev_frame;
3979    
3980    // If we re-save during mirroring, then we NEED to show the new savestate as unmirrored.
3981    // That's just how savestates work. So to use old, unmirrored inputs, we need to reverse them in place.
3982    if (event_vars->loaded_mirrored) {
3983        // need to disable mirroring, as the new savestate is inherently unmirrored.
3984        event_vars->loaded_mirrored = false;
3985        
3986        LabOptions_Record[OPTREC_MIRRORED_PLAYBACK].val = OPTMIRROR_OFF;
3987        LabOptions_Record[OPTREC_HMNMODE].disable = 0;
3988        LabOptions_Record[OPTREC_CPUMODE].disable = 0;
3989        
3990        for (int ply = 0; ply < 2; ++ply) {
3991            for (int slot = 0; slot < REC_SLOTS; ++slot) {
3992                RecInputData *input_data;
3993                if (ply == 0)
3994                    input_data = rec_data.hmn_inputs[slot];
3995                else
3996                    input_data = rec_data.cpu_inputs[slot];
3997
3998                int input_num = input_data->num;
3999                for (int input = 0; input <= input_num; ++input) {
4000                    RecInputs *inputs = &input_data->inputs[input];
4001                    inputs->stickX *= -1;
4002                    inputs->substickX *= -1;
4003                }
4004            }
4005        }
4006    }
4007    
4008    return time_diff;
4009}
4010
4011void Record_ResaveState(GOBJ *menu_gobj)
4012{
4013    int time_diff = Record_RemakeState();
4014    
4015    // change start frame
4016    for (int ply = 0; ply < 2; ++ply) {
4017        for (int slot = 0; slot < REC_SLOTS; ++slot) {
4018            RecInputData *input_data;
4019            if (ply == 0)
4020                input_data = rec_data.hmn_inputs[slot];
4021            else
4022                input_data = rec_data.cpu_inputs[slot];
4023
4024            if (input_data->start_frame != -1)
4025                input_data->start_frame += time_diff;
4026        }
4027    }
4028}
4029
4030void Record_PruneState(GOBJ *menu_gobj)
4031{
4032    int time_diff = Record_RemakeState();
4033    
4034    // change start frame
4035    for (int ply = 0; ply < 2; ++ply) {
4036        for (int slot = 0; slot < REC_SLOTS; ++slot) {
4037            RecInputData *input_data;
4038            if (ply == 0)
4039                input_data = rec_data.hmn_inputs[slot];
4040            else
4041                input_data = rec_data.cpu_inputs[slot];
4042
4043            if (input_data->start_frame != -1) {
4044                if (input_data->num > time_diff) {
4045                    input_data->num -= time_diff;
4046                    memmove(
4047                        &input_data->inputs[0],
4048                        &input_data->inputs[time_diff],
4049                        input_data->num * sizeof(RecInputs)
4050                    );
4051                    input_data->start_frame += time_diff;
4052                } else {
4053                    input_data->num = 0;
4054                }
4055            }
4056        }
4057    }
4058}
4059void Record_DeleteState(GOBJ *menu_gobj)
4060{
4061    stc_playback_cancelled_hmn = false;
4062    stc_playback_cancelled_cpu = false;
4063    for (u32 i = 0; i < countof(LabOptions_Record); i++)
4064    {
4065        if (i == OPTREC_SAVE_LOAD) {
4066            LabOptions_Record[i] = Record_Save;
4067            LabOptions_Record[i].disable = 0;
4068        } else {
4069            LabOptions_Record[i].val = (i == OPTREC_HMNSLOT || i == OPTREC_CPUSLOT) ? 1 : 0;
4070            LabOptions_Record[i].disable = 1;
4071        }
4072    }
4073
4074    for (int i = 0; i < REC_SLOTS; ++i) {
4075        LabOptions_SlotChancesHMN[i].val = 0;
4076        LabOptions_SlotChancesCPU[i].val = 0;
4077        LabOptions_SlotChancesHMN[i].disable = 1;
4078        LabOptions_SlotChancesCPU[i].disable = 1;
4079
4080        rec_data.hmn_inputs[i]->start_frame = -1;
4081        rec_data.hmn_inputs[i]->num = 0;
4082        rec_data.cpu_inputs[i]->start_frame = -1;
4083        rec_data.cpu_inputs[i]->num = 0;
4084    }
4085
4086    LabMenu_Record.scroll = 0;
4087    LabMenu_Record.cursor = 0;
4088}
4089void Record_RestoreState(GOBJ *menu_gobj)
4090{
4091    Record_LoadSavestate(rec_state);
4092}
4093void Record_ChangeHMNSlot(GOBJ *menu_gobj, int value)
4094{
4095    // upon changing to random
4096    if (value == 0)
4097    {
4098        if (Record_HMN_IsRecording())
4099            LabOptions_Record[OPTREC_HMNSLOT].val = 1;
4100        else
4101            rec_data.hmn_rndm_slot = Record_GetRandomSlot(rec_data.hmn_inputs, LabOptions_SlotChancesHMN);
4102    }
4103    
4104    // copy back rerecorded slot
4105    if (LabOptions_Record[OPTREC_HMNMODE].val == RECMODE_HMN_RERECORD)
4106    {
4107        int prev_slot = LabOptions_Record[OPTREC_HMNSLOT].val_prev;
4108        if (prev_slot != 0)
4109            memcpy(rec_data.hmn_inputs[prev_slot - 1], rec_data.hmn_rerecord_inputs, sizeof(RecInputData));
4110
4111        memcpy(rec_data.hmn_rerecord_inputs, rec_data.hmn_inputs[Record_GetSlot(0)], sizeof(RecInputData));
4112    }
4113
4114    // reload save
4115    Record_LoadSavestate(rec_state);
4116}
4117void Record_ChangeCPUSlot(GOBJ *menu_gobj, int value)
4118{
4119    // upon changing to random
4120    if (value == 0)
4121    {
4122        if (Record_CPU_IsRecording())
4123            LabOptions_Record[OPTREC_CPUSLOT].val = 1;
4124        else
4125            rec_data.cpu_rndm_slot = Record_GetRandomSlot(rec_data.cpu_inputs, LabOptions_SlotChancesCPU);
4126    }
4127    
4128    // copy back rerecorded slot
4129    if (LabOptions_Record[OPTREC_CPUMODE].val == RECMODE_CPU_RERECORD)
4130    {
4131        int prev_slot = LabOptions_Record[OPTREC_CPUSLOT].val_prev;
4132        if (prev_slot != 0)
4133            memcpy(rec_data.cpu_inputs[prev_slot - 1], rec_data.cpu_rerecord_inputs, sizeof(RecInputData));
4134
4135        memcpy(rec_data.cpu_rerecord_inputs, rec_data.cpu_inputs[Record_GetSlot(1)], sizeof(RecInputData));
4136    }
4137
4138    // reload save
4139    Record_LoadSavestate(rec_state);
4140}
4141
4142void Record_ChangeMode_Common(void)
4143{
4144    bool hmn_recording = Record_HMN_IsRecording();
4145    bool cpu_recording = Record_CPU_IsRecording();
4146
4147    // ensure not recording to random slot
4148    if (hmn_recording && Record_HMN_IsRandomSlot())
4149        LabOptions_Record[OPTREC_HMNSLOT].val = 1;
4150    if (cpu_recording && Record_CPU_IsRandomSlot())
4151        LabOptions_Record[OPTREC_CPUSLOT].val = 1;
4152
4153    // disable some options if recording
4154    if (hmn_recording || cpu_recording) {
4155        LabOptions_Record[OPTREC_LOOP].val = 0;
4156        LabOptions_Record[OPTREC_LOOP].disable = 1;
4157        LabOptions_Record[OPTREC_AUTORESTORE].val = AUTORESTORE_NONE;
4158        LabOptions_Record[OPTREC_AUTORESTORE].disable = 1;
4159    } else {
4160        LabOptions_Record[OPTREC_LOOP].disable = 0;
4161        LabOptions_Record[OPTREC_AUTORESTORE].disable = 0;
4162    }
4163
4164    // Mirrored Playback is only available in playback and not in recording
4165    bool can_mirror = (Record_CPU_IsPlayback() || Record_CPU_IsPlayback()) && !(hmn_recording || cpu_recording);
4166    LabOptions_Record[OPTREC_MIRRORED_PLAYBACK].disable = !can_mirror;
4167}
4168void Record_ChangeHMNMode(GOBJ *menu_gobj, int value)
4169{
4170    // copy rerecorded slot
4171    if (LabOptions_Record[OPTREC_HMNMODE].val == RECMODE_HMN_RERECORD)
4172        memcpy(rec_data.hmn_rerecord_inputs, rec_data.hmn_inputs[Record_GetSlot(0)], sizeof(RecInputData));
4173    
4174    // copy back rerecorded slot
4175    if (LabOptions_Record[OPTREC_HMNMODE].val_prev == RECMODE_HMN_RERECORD)
4176        memcpy(rec_data.hmn_inputs[Record_GetSlot(0)], rec_data.hmn_rerecord_inputs, sizeof(RecInputData));
4177    
4178    if (value == RECMODE_HMN_PLAYBACK || value == RECMODE_HMN_RERECORD)
4179        Record_LoadSavestate(rec_state);
4180    Record_ChangeMode_Common();
4181}
4182void Record_ChangeCPUMode(GOBJ *menu_gobj, int value)
4183{
4184    // copy rerecorded slot
4185    if (LabOptions_Record[OPTREC_CPUMODE].val == RECMODE_CPU_RERECORD)
4186        memcpy(rec_data.cpu_rerecord_inputs, rec_data.cpu_inputs[Record_GetSlot(1)], sizeof(RecInputData));
4187    
4188    // copy back rerecorded slot
4189    if (LabOptions_Record[OPTREC_CPUMODE].val_prev == RECMODE_CPU_RERECORD)
4190        memcpy(rec_data.cpu_inputs[Record_GetSlot(1)], rec_data.cpu_rerecord_inputs, sizeof(RecInputData));
4191    
4192    if (value == RECMODE_CPU_PLAYBACK || value == RECMODE_CPU_RERECORD)
4193        Record_LoadSavestate(rec_state);
4194    Record_ChangeMode_Common();
4195}
4196void Record_ChangeMirroredPlayback(GOBJ *menu_gobj, int value)
4197{
4198    // Cannot change HMN/CPU Mode while mirrored playback is on.
4199    if (value != OPTMIRROR_OFF)
4200    {
4201        LabOptions_Record[OPTREC_HMNMODE].disable = 1;
4202        LabOptions_Record[OPTREC_CPUMODE].disable = 1;
4203    }
4204    else
4205    {
4206        LabOptions_Record[OPTREC_HMNMODE].disable = 0;
4207        LabOptions_Record[OPTREC_CPUMODE].disable = 0;
4208    }
4209
4210    Record_LoadSavestate(rec_state);
4211}
4212int Record_GetRandomSlot(RecInputData **input_data, EventOption slot_menu[])
4213{
4214    s16 *chances[REC_SLOTS];
4215    int chance_count = EnabledSlotChances(slot_menu, chances);
4216    if (chance_count == 0) return 0;
4217
4218    int slots[REC_SLOTS];
4219    int slot_num = 0;
4220    for (int i = 0; i < REC_SLOTS; ++i) {
4221        if (!slot_menu[i].disable)
4222            slots[slot_num++] = i;
4223    }
4224
4225    int rand = HSD_Randi(100);
4226
4227    for (int i = 0; i < chance_count; ++i) {
4228        int chance = (int)*chances[i];
4229        if (rand < chance)
4230            return slots[i];
4231        rand -= chance;
4232    }
4233
4234    return 0;
4235}
4236int Record_GetSlot(int ply) {
4237    int slot;
4238    int random_slot;
4239
4240    if (ply == 0) {
4241        slot = LabOptions_Record[OPTREC_HMNSLOT].val;
4242        random_slot = rec_data.hmn_rndm_slot;
4243    } else {
4244        slot = LabOptions_Record[OPTREC_CPUSLOT].val;
4245        random_slot = rec_data.cpu_rndm_slot;
4246    }
4247
4248    if (slot == 0)
4249        slot = random_slot;
4250    else
4251        slot--;
4252
4253    return slot;
4254}
4255int Record_PastLastInput(int ply)
4256{
4257    int slot = Record_GetSlot(ply);
4258    int curr_frame = Record_GetCurrFrame();
4259    RecInputData *inputs;
4260    if (ply == 0)
4261        inputs = rec_data.hmn_inputs[slot];
4262    else
4263        inputs = rec_data.cpu_inputs[slot];
4264
4265    return curr_frame > inputs->num;
4266}
4267int Record_GetCurrFrame(void)
4268{
4269    return (event_vars->game_timer - 1) - rec_state->frame;
4270}
4271int Record_GetEndFrame(void)
4272{
4273    int hmn_slot = Record_GetSlot(0);
4274    int cpu_slot = Record_GetSlot(1);
4275    int curr_frame = Record_GetCurrFrame();
4276
4277    RecInputData *hmn_inputs = rec_data.hmn_inputs[hmn_slot];
4278    RecInputData *cpu_inputs = rec_data.cpu_inputs[cpu_slot];
4279
4280    // get what frame the longest recording ends on (savestate frame + recording start frame + recording time)
4281    int hmn_end_frame = 0;
4282    int cpu_end_frame = 0;
4283    if (hmn_inputs->start_frame != -1) // ensure a recording exists
4284        hmn_end_frame = (hmn_inputs->start_frame + hmn_inputs->num);
4285    if (cpu_inputs->start_frame != -1) // ensure a recording exists
4286        cpu_end_frame = (cpu_inputs->start_frame + cpu_inputs->num);
4287
4288    // find the larger recording
4289    RecInputData *input_data = hmn_inputs;
4290    if (cpu_end_frame > hmn_end_frame)
4291        input_data = cpu_inputs;
4292
4293    // get the frame the recording starts on. i actually hate this code and need to change how this works
4294    int rec_start;
4295    if (input_data->start_frame == -1) // case 1: recording didnt start, use current frame
4296        rec_start = curr_frame - 1;
4297    else // case 2: recording has started, use the frame saved
4298        rec_start = input_data->start_frame - rec_state->frame;
4299
4300    // get end frame
4301    int end_frame = rec_start + input_data->num;
4302
4303    return end_frame;
4304}
4305void Record_OnSuccessfulSave(int deleteRecordings)
4306{
4307    LabOptions_Record[OPTREC_SAVE_LOAD] = Record_Load;
4308
4309    // enable other options
4310    for (u32 i = 0; i < countof(LabOptions_Record); i++)
4311    {
4312        if (i == OPTREC_MIRRORED_PLAYBACK ||
4313            (i == OPTREC_HMNMODE && LabOptions_Record[OPTREC_MIRRORED_PLAYBACK].val == 1) ||
4314            (i == OPTREC_CPUMODE && LabOptions_Record[OPTREC_MIRRORED_PLAYBACK].val == 1))
4315          continue;
4316
4317        LabOptions_Record[i].disable = 0;
4318    }
4319
4320    if (deleteRecordings) {
4321        // clear slots
4322        for (int i = 0; i < REC_SLOTS; i++)
4323        {
4324            // clear data
4325            memset(rec_data.hmn_inputs[i], 0, sizeof(RecInputData));
4326            memset(rec_data.cpu_inputs[i], 0, sizeof(RecInputData));
4327
4328            // init frame this recording starts on
4329            rec_data.hmn_inputs[i]->start_frame = -1;
4330            rec_data.cpu_inputs[i]->start_frame = -1;
4331        }
4332
4333        // init settings
4334        LabOptions_Record[OPTREC_HMNMODE].val = RECMODE_HMN_OFF;
4335        LabOptions_Record[OPTREC_HMNSLOT].val = 1; // set hmn to slot 1
4336        LabOptions_Record[OPTREC_CPUMODE].val = RECMODE_CPU_OFF;
4337        LabOptions_Record[OPTREC_CPUSLOT].val = 1; // set cpu to slot 1
4338        LabOptions_Record[OPTREC_MIRRORED_PLAYBACK].val = OPTMIRROR_OFF;
4339        LabOptions_Record[OPTREC_MIRRORED_PLAYBACK].disable = 1;
4340    }
4341
4342    // also save to personal savestate
4343    event_vars->Savestate_Save_v1(event_vars->savestate, 0);
4344    event_vars->savestate_saved_while_mirrored = event_vars->loaded_mirrored;
4345
4346    // take screenshot
4347    snap_status = 1;
4348}
4349void Memcard_Wait()
4350{
4351
4352    while (stc_memcard_work->is_done == 0)
4353    {
4354        blr2();
4355    }
4356}
4357void Record_MemcardLoad(int slot, int file_no)
4358{
4359    // search card for this save file
4360    u8 file_found = 0;
4361    char filename[32];
4362    int file_size;
4363    s32 memSize, sectorSize;
4364    if (CARDProbeEx(slot, &memSize, &sectorSize) == CARD_RESULT_READY)
4365    {
4366        // mount card
4367        stc_memcard_work->is_done = 0;
4368        if (CARDMountAsync(slot, stc_memcard_work->work_area, 0, Memcard_RemovedCallback) == CARD_RESULT_READY)
4369        {
4370            // check card
4371            Memcard_Wait();
4372            stc_memcard_work->is_done = 0;
4373            if (CARDCheckAsync(slot, Memcard_RemovedCallback) == CARD_RESULT_READY)
4374            {
4375                Memcard_Wait();
4376
4377                CARDStat card_stat;
4378                if (CARDGetStatus(slot, file_no, &card_stat) == CARD_RESULT_READY)
4379                {
4380                    // check company code
4381                    if (strncmp(os_info->company, card_stat.company, sizeof(os_info->company)) == 0)
4382                    {
4383                        // check game name
4384                        if (strncmp(os_info->gameName, card_stat.gameName, sizeof(os_info->gameName)) == 0)
4385                        {
4386                            // check file name
4387                            if (strncmp("TMREC", card_stat.fileName, 5) == 0)
4388                            {
4389                                file_found = 1;
4390                                memcpy(filename, card_stat.fileName, sizeof(filename)); // copy filename to load after this
4391                                file_size = card_stat.length;
4392                            }
4393                        }
4394                    }
4395                }
4396            }
4397
4398            CARDUnmount(slot);
4399            stc_memcard_work->is_done = 0;
4400        }
4401    }
4402
4403    // if found, load it
4404    if (file_found == 1)
4405    {
4406
4407        // setup load
4408        MemcardSave memcard_save;
4409        memcard_save.data = HSD_MemAlloc(file_size);
4410        memcard_save.x4 = 3;
4411        memcard_save.size = file_size;
4412        memcard_save.xc = -1;
4413        Memcard_ReqSaveLoad(slot, filename, &memcard_save, stc_memcard_info->file_name, 0, 0, 0);
4414
4415        // wait to load
4416        int memcard_status = Memcard_CheckStatus();
4417        while (memcard_status == 11)
4418        {
4419            memcard_status = Memcard_CheckStatus();
4420        }
4421
4422        // if file loaded successfully
4423        if (memcard_status == 0)
4424        {
4425
4426            // enable other options
4427            for (u32 i = 1; i < countof(LabOptions_Record); i++)
4428            {
4429                LabOptions_Record[i].disable = 0;
4430            }
4431
4432            // take screenshot
4433            snap_status = 1;
4434
4435            // begin unpacking
4436            u8 *transfer_buf = memcard_save.data;
4437            ExportHeader *header = (ExportHeader *)transfer_buf;
4438            u8 *compressed_recording = transfer_buf + header->lookup.ofst_recording;
4439            ExportMenuSettings *menu_settings = (ExportMenuSettings *)(transfer_buf + header->lookup.ofst_menusettings);
4440
4441            // decompress
4442            RecordingSave *loaded_recsave = calloc(sizeof(RecordingSave) * 1.06);
4443            lz77Decompress(compressed_recording, (u8 *)loaded_recsave);
4444
4445            // copy buffer to savestate
4446            memcpy(rec_state, &loaded_recsave->savestate, sizeof(Savestate_v1));
4447            event_vars->savestate_saved_while_mirrored = false;
4448            event_vars->loaded_mirrored = false;
4449
4450            // restore controller indices
4451            rec_state->ft_state[0].player_block.controller = stc_hmn_controller;
4452            rec_state->ft_state[1].player_block.controller = stc_cpu_controller;
4453
4454            // load state
4455            Record_LoadSavestate(rec_state);
4456
4457            // copy recordings
4458            for (int i = 0; i < REC_SLOTS; i++)
4459            {
4460                memcpy(rec_data.hmn_inputs[i], &loaded_recsave->hmn_inputs[i], sizeof(RecInputData));
4461                memcpy(rec_data.cpu_inputs[i], &loaded_recsave->cpu_inputs[i], sizeof(RecInputData));
4462            }
4463
4464            HSD_Free(loaded_recsave);
4465
4466            // copy recording settings
4467            LabOptions_Record[OPTREC_HMNMODE].val = menu_settings->hmn_mode;
4468            LabOptions_Record[OPTREC_HMNSLOT].val = menu_settings->hmn_slot;
4469            LabOptions_Record[OPTREC_CPUMODE].val = menu_settings->cpu_mode;
4470            LabOptions_Record[OPTREC_CPUSLOT].val = menu_settings->cpu_slot;
4471            LabOptions_Record[OPTREC_LOOP].val = menu_settings->loop_inputs;
4472            LabOptions_Record[OPTREC_AUTORESTORE].val = menu_settings->auto_restore;
4473
4474            // save to personal savestate
4475            event_vars->Savestate_Save_v1(event_vars->savestate, 0);
4476            event_vars->savestate_saved_while_mirrored = event_vars->loaded_mirrored;
4477        }
4478
4479        HSD_Free(memcard_save.data);
4480    }
4481}
4482
4483void Record_LoadSavestate(Savestate_v1 *savestate) {
4484    int mirror = LabOptions_Record[OPTREC_MIRRORED_PLAYBACK].val;
4485    if (mirror == OPTMIRROR_RANDOM)
4486        mirror = HSD_Randi(2);
4487
4488    // if a non-major savestate is saved while mirrored, we need to unmirror again.
4489    if (savestate != rec_state)
4490        mirror = mirror != event_vars->savestate_saved_while_mirrored;
4491    event_vars->loaded_mirrored = mirror;
4492
4493    if (Record_HMN_IsPlayback() && Record_HMN_IsRandomSlot())
4494        rec_data.hmn_rndm_slot = Record_GetRandomSlot(rec_data.hmn_inputs, LabOptions_SlotChancesHMN);
4495
4496    if (Record_CPU_IsPlayback() && Record_CPU_IsRandomSlot())
4497        rec_data.cpu_rndm_slot = Record_GetRandomSlot(rec_data.cpu_inputs, LabOptions_SlotChancesCPU);
4498    
4499    event_vars->game_timer = rec_state->frame;
4500    rec_data.restore_timer = 0;
4501
4502    CPUResetVars();
4503
4504    stc_playback_cancelled_hmn = false;
4505    stc_playback_cancelled_cpu = false;
4506    
4507    int flags = 0;
4508    if (mirror) flags |= Savestate_Mirror;
4509    event_vars->Savestate_Load_v1(savestate, flags);
4510
4511    int plys[2] = {0, 1};
4512    int chances[2] = {
4513        LabOptions_SlotChancesHMN[OPTSLOTCHANCE_PERCENT].val,
4514        LabOptions_SlotChancesCPU[OPTSLOTCHANCE_PERCENT].val,
4515    };
4516
4517    for (int i = 0; i < 2; ++i) {
4518        int chance = chances[i];
4519        if (!chance) continue;
4520
4521        int ply = plys[i];
4522        GOBJ *fighter = Fighter_GetGObj(ply);
4523        FighterData *fighter_data = fighter->userdata;
4524        int percent = fighter_data->dmg.percent;
4525        
4526        int change = HSD_Randi(chance+1);
4527        percent += change;
4528        if (percent > 999) percent = 999;
4529        fighter_data->dmg.percent = percent;
4530
4531        Fighter_SetHUDDamage(ply, percent);
4532    }
4533}
4534
4535void Snap_CObjThink(GOBJ *gobj)
4536{
4537    if (snap_status == 1)
4538    {
4539        // take snap
4540        HSD_ImageDescCopyFromEFB(&snap_image, 0, 0, 0);
4541        snap_status = 0;
4542    }
4543}
4544void Savestates_Update()
4545{
4546
4547    /*
4548    So i have code to do this in events.c that runs based a variable in
4549    the EventDesc, but i need to execute code directly after loading state
4550    so im just gonna do this here...
4551    */
4552
4553    static int save_timer[4] = {0}; // Array to track save timer for each fighter
4554    const int SAVE_THRESHOLD = 10;
4555    // not when pause menu is showing
4556    if (Pause_CheckStatus(1) != 2)
4557    {
4558        if (lockout_timer > 0)
4559        {
4560            lockout_timer--;
4561        }
4562        else
4563        {
4564            // loop through all controller ports
4565            for (int port = 0; port < 4; port++)
4566            {
4567                HSD_Pad *pad = PadGetMaster(port);
4568                if (pad == NULL) continue; // Skip if no controller in this port
4569
4570                // Save state (D-pad right)
4571                if (pad->held & HSD_BUTTON_DPAD_RIGHT)
4572                {
4573                    save_timer[port]++;
4574                    if (save_timer[port] == SAVE_THRESHOLD)
4575                    {
4576                        // save state
4577                        event_vars->Savestate_Save_v1(event_vars->savestate, 0);
4578                        event_vars->savestate_saved_while_mirrored = event_vars->loaded_mirrored;
4579                        save_timer[port] = 0; // Reset timer after saving
4580                        lockout_timer = LOCKOUT_DURATION;
4581                    }
4582                }
4583                else
4584                {
4585                    save_timer[port] = 0; // Reset timer if button is released
4586                }
4587
4588                // Load state (D-pad left)
4589                if (pad->down & HSD_BUTTON_DPAD_LEFT)
4590                {
4591                    // load state
4592                    Record_LoadSavestate(event_vars->savestate);
4593                    stc_playback_cancelled_hmn = false;
4594                    stc_playback_cancelled_cpu = false;
4595
4596                    // re-roll random slot
4597                    if (LabOptions_Record[OPTREC_HMNSLOT].val == 0)
4598                    {
4599                        rec_data.hmn_rndm_slot = Record_GetRandomSlot(rec_data.hmn_inputs, LabOptions_SlotChancesHMN);
4600                    }
4601                    if (LabOptions_Record[OPTREC_CPUSLOT].val == 0)
4602                    {
4603                        rec_data.cpu_rndm_slot = Record_GetRandomSlot(rec_data.cpu_inputs, LabOptions_SlotChancesCPU);
4604                    }
4605                }
4606            }
4607        }
4608    }
4609}
4610
4611// Export functions
4612static char *keyboard_rows[2][4] = {
4613    {"1234567890", "qwertyuiop", "asdfghjkl-", "zxcvbnm,./"},
4614    {"!   %^  ()", "QWERTYUIOP", "ASDFGHJKL:", "ZXCVBNM<>?"}
4615};
4616int RowPixelToBlockPixel(int pixel_x, int pixel_y, int width, int height)
4617{
4618
4619    // get block width and height
4620    int block_width = divide_roundup(width, 4);
4621
4622    // get block num
4623    int block_num = ((pixel_y / 4) * block_width) + (pixel_x / 4);
4624
4625    // get pixels x and y within this block
4626    int block_pos_x = pixel_x % 4;
4627    int block_pos_y = pixel_y % 4;
4628
4629    // get block pixel index
4630    int block_pixel = (block_num * 16) + (block_pos_y * 4) + block_pos_x;
4631
4632    return block_pixel;
4633}
4634void ImageScale(RGB565 *out_img, RGB565 *in_img, int OutWidth, int OutHeight, int InWidth, int InHeight)
4635{
4636
4637    int x_ratio = (InWidth / OutWidth);
4638    int y_ratio = (InHeight / OutHeight);
4639    int px, py;
4640    int in_pixel, out_pixel;
4641
4642    for (int y = 0; y < (OutHeight); y++)
4643    {
4644        for (int x = 0; x < (OutWidth); x++)
4645        {
4646            px = x * x_ratio;
4647            py = y * y_ratio;
4648            in_pixel = RowPixelToBlockPixel(x, y, OutWidth, OutHeight);
4649            out_pixel = RowPixelToBlockPixel(px, py, InWidth, InHeight);
4650            out_img[in_pixel] = in_img[out_pixel];
4651        }
4652    }
4653}
4654void Export_Init(GOBJ *menu_gobj)
4655{
4656    MenuData *menu_data = menu_gobj->userdata;
4657
4658    // create gobj
4659    GOBJ *export_gobj = GObj_Create(0, 0, 0);
4660    ExportData *export_data = calloc(sizeof(ExportData));
4661    GObj_AddUserData(export_gobj, 4, HSD_Free, export_data);
4662
4663    // load menu joint
4664    JOBJ *export_joint = JOBJ_LoadJoint(stc_lab_data->export_menu);
4665    GObj_AddObject(export_gobj, 3, export_joint);                                  // add to gobj
4666    GObj_AddGXLink(export_gobj, GXLink_Common, GXLINK_MENUMODEL, GXPRI_MENUMODEL); // add gx link
4667    menu_data->custom_gobj_think = Export_Think;                                   // set callback
4668
4669    // save jobj pointers
4670    JOBJ_GetChild(export_joint, &export_data->memcard_jobj[0], EXP_MEMCARDAJOBJ, -1);
4671    JOBJ_GetChild(export_joint, &export_data->memcard_jobj[1], EXP_MEMCARDBJOBJ, -1);
4672    JOBJ_GetChild(export_joint, &export_data->screenshot_jobj, EXP_SCREENSHOTJOBJ, -1);
4673    JOBJ_GetChild(export_joint, &export_data->textbox_jobj, EXP_TEXTBOXJOBJ, -1);
4674
4675    // hide all
4676    JOBJ_SetFlags(export_data->memcard_jobj[0], JOBJ_HIDDEN);
4677    JOBJ_SetFlags(export_data->memcard_jobj[1], JOBJ_HIDDEN);
4678    JOBJ_SetFlags(export_data->screenshot_jobj, JOBJ_HIDDEN);
4679    JOBJ_SetFlags(export_data->textbox_jobj, JOBJ_HIDDEN);
4680
4681    // alloc a buffer for all of the recording data
4682    RecordingSave *temp_rec_save = calloc(sizeof(RecordingSave));
4683
4684    // copy match data to buffer
4685    memcpy(&temp_rec_save->match_data, &stc_match->match, sizeof(MatchInit));
4686    // copy savestate to buffer
4687    memcpy(&temp_rec_save->savestate, rec_state, sizeof(Savestate_v1));
4688    // copy recordings
4689    for (int i = 0; i < REC_SLOTS; i++)
4690    {
4691        memcpy(&temp_rec_save->hmn_inputs[i], rec_data.hmn_inputs[i], sizeof(RecInputData));
4692        memcpy(&temp_rec_save->cpu_inputs[i], rec_data.cpu_inputs[i], sizeof(RecInputData));
4693    }
4694
4695    // compress all recording data
4696    u8 *recording_buffer = calloc(sizeof(RecordingSave));
4697    int compress_size = Export_Compress(recording_buffer, (u8 *)temp_rec_save, sizeof(RecordingSave));
4698    HSD_Free(temp_rec_save); // free original data buffer
4699
4700    // resize screenshot
4701    int img_size = GXGetTexBufferSize(RESIZE_WIDTH, RESIZE_HEIGHT, 4, 0, 0);
4702    RGB565 *orig_img = snap_image.img_ptr;
4703    RGB565 *new_img = calloc(img_size);
4704    export_data->scaled_image = new_img;
4705    ImageScale(new_img, orig_img, RESIZE_WIDTH, RESIZE_HEIGHT, EXP_SCREENSHOT_WIDTH, EXP_SCREENSHOT_HEIGHT);
4706    resized_image.img_ptr = new_img;                                            // store pointer to resized image
4707    export_data->screenshot_jobj->dobj->mobj->tobj->imagedesc = &resized_image; // replace pointer to imagedesc
4708
4709    // get curr date
4710    OSCalendarTime td;
4711    OSTicksToCalendarTime(OSGetTime(), &td);
4712
4713    // alloc a buffer to transfer to memcard
4714    stc_transfer_buf_size = sizeof(ExportHeader) + img_size + sizeof(ExportMenuSettings) + compress_size;
4715    stc_transfer_buf = calloc(stc_transfer_buf_size);
4716
4717    // init header
4718    ExportHeader *header = (ExportHeader *)stc_transfer_buf;
4719    header->metadata.version = REC_VERS;
4720    header->metadata.image_width = RESIZE_WIDTH;
4721    header->metadata.image_height = RESIZE_HEIGHT;
4722    header->metadata.image_fmt = 4;
4723    header->metadata.hmn = Fighter_GetExternalID(0);
4724    header->metadata.hmn_costume = Fighter_GetCostumeID(0);
4725    header->metadata.cpu = Fighter_GetExternalID(1);
4726    header->metadata.cpu_costume = Fighter_GetCostumeID(1);
4727    header->metadata.stage_external = Stage_GetExternalID();
4728    header->metadata.stage_internal = Stage_ExternalToInternal(header->metadata.stage_external);
4729    header->metadata.month = td.mon + 1;
4730    header->metadata.day = td.mday;
4731    header->metadata.year = td.year;
4732    header->metadata.hour = td.hour;
4733    header->metadata.minute = td.min;
4734    header->metadata.second = td.sec;
4735    header->lookup.ofst_screenshot = sizeof(ExportHeader);
4736    header->lookup.ofst_recording = sizeof(ExportHeader) + img_size;
4737    header->lookup.ofst_menusettings = sizeof(ExportHeader) + img_size + compress_size;
4738
4739    // copy data to buffer
4740    // image
4741    memcpy(stc_transfer_buf + header->lookup.ofst_screenshot, new_img, img_size);
4742    // menu settings
4743    ExportMenuSettings *menu_settings = (ExportMenuSettings *)(stc_transfer_buf + header->lookup.ofst_menusettings);
4744    menu_settings->hmn_mode = LabOptions_Record[OPTREC_HMNMODE].val;
4745    menu_settings->hmn_slot = LabOptions_Record[OPTREC_HMNSLOT].val;
4746    menu_settings->cpu_mode = LabOptions_Record[OPTREC_CPUMODE].val;
4747    menu_settings->cpu_slot = LabOptions_Record[OPTREC_CPUSLOT].val;
4748    
4749    // Recording replay versions are forwards and backwards compatible.
4750    // Since we added the Re-Record option, we cannot export it because then it would crash with an invalid
4751    // menu setting when importing on a version without the Re-Record setting.
4752    if (menu_settings->hmn_mode > RECMODE_HMN_PLAYBACK)
4753        menu_settings->hmn_mode = RECMODE_HMN_PLAYBACK;
4754    if (menu_settings->cpu_mode > RECMODE_CPU_PLAYBACK)
4755        menu_settings->cpu_mode = RECMODE_CPU_PLAYBACK;
4756        
4757    menu_settings->loop_inputs = LabOptions_Record[OPTREC_LOOP].val;
4758    menu_settings->auto_restore = LabOptions_Record[OPTREC_AUTORESTORE].val;
4759    // recording data
4760    memcpy(stc_transfer_buf + header->lookup.ofst_recording, recording_buffer, compress_size); // compressed recording
4761
4762    // free compresed data buffer
4763    HSD_Free(recording_buffer);
4764
4765    // alloc filename buffer
4766    export_data->filename_buffer = calloc(32 + 2); // +2 for terminator and cursor
4767
4768    // initialize memcard menu
4769    Export_SelCardInit(export_gobj);
4770
4771    menu_data->custom_gobj = export_gobj;            // set custom gobj
4772    menu_data->custom_gobj_think = Export_Think;     // set think function
4773    menu_data->custom_gobj_destroy = Export_Destroy; // set destroy function
4774}
4775int Export_Think(GOBJ *export_gobj)
4776{
4777    ExportData *export_data = export_gobj->userdata;
4778    int can_unpause = 0;
4779
4780    switch (export_data->menu_index)
4781    {
4782    case (EXMENU_SELCARD):
4783    {
4784        can_unpause = Export_SelCardThink(export_gobj);
4785        break;
4786    }
4787    case (EXMENU_NAME):
4788    {
4789        can_unpause = Export_EnterNameThink(export_gobj);
4790        break;
4791    }
4792    case (EXMENU_CONFIRM):
4793    {
4794        can_unpause = Export_ConfirmThink(export_gobj);
4795        break;
4796    }
4797    }
4798
4799    return can_unpause;
4800}
4801void Export_Destroy(GOBJ *export_gobj)
4802{
4803    ExportData *export_data = export_gobj->userdata;
4804    MenuData *menu_data = event_vars->menu_gobj->userdata;
4805
4806    switch (export_data->menu_index)
4807    {
4808    case (EXMENU_SELCARD):
4809    {
4810        Export_SelCardExit(export_gobj);
4811        break;
4812    }
4813    case (EXMENU_NAME):
4814    {
4815        Export_EnterNameExit(export_gobj);
4816        break;
4817    }
4818    }
4819
4820    // free buffer allocs
4821    HSD_Free(stc_transfer_buf);
4822    HSD_Free(export_data->filename_buffer);
4823    HSD_Free(export_data->scaled_image);
4824
4825    // destroy gobj
4826    GObj_Destroy(export_gobj);
4827
4828    // show menu
4829    menu_data->custom_gobj = 0;
4830    menu_data->custom_gobj_think = 0;
4831    menu_data->custom_gobj_destroy = 0;
4832}
4833void Export_SelCardInit(GOBJ *export_gobj)
4834{
4835    ExportData *export_data = export_gobj->userdata;
4836    MenuData *menu_data = event_vars->menu_gobj->userdata;
4837
4838    // show menu jobjs
4839    JOBJ_ClearFlags(export_data->memcard_jobj[0], JOBJ_HIDDEN);
4840    JOBJ_ClearFlags(export_data->memcard_jobj[1], JOBJ_HIDDEN);
4841
4842    // create text
4843    Text *text_misc = Text_CreateText(2, menu_data->canvas_menu);
4844    export_data->text_misc = text_misc;
4845    text_misc->align = 1;
4846    text_misc->kerning = 1;
4847    // scale canvas
4848    text_misc->viewport_scale.X = MENU_CANVASSCALE;
4849    text_misc->viewport_scale.Y = MENU_CANVASSCALE;
4850
4851    // create title text
4852    Text *text_title = Text_CreateText(2, menu_data->canvas_menu);
4853    export_data->text_title = text_title;
4854    text_title->kerning = 1;
4855    // scale canvas
4856    text_title->trans.X = -23;
4857    text_title->trans.Y = -18;
4858    text_title->viewport_scale.X = MENU_CANVASSCALE * 2;
4859    text_title->viewport_scale.Y = MENU_CANVASSCALE * 2;
4860
4861    // create desc text
4862    Text *text_desc = Text_CreateText(2, menu_data->canvas_menu);
4863    export_data->text_desc = text_desc;
4864    text_desc->kerning = 1;
4865    // scale canvas
4866    text_desc->trans.X = -23;
4867    text_desc->trans.Y = 12;
4868    text_desc->viewport_scale.X = MENU_CANVASSCALE;
4869    text_desc->viewport_scale.Y = MENU_CANVASSCALE;
4870
4871    Text_AddSubtext(text_title, 0, 0, "Select a Memory Card"); // add title
4872    Text_AddSubtext(text_desc, 0, 0, "");                      // add description
4873
4874    // add dummy text
4875    Text_AddSubtext(text_misc, -165, 67, "Slot A");
4876    Text_AddSubtext(text_misc, 165, 67, "Slot B");
4877
4878    // init memcard inserted status
4879    for (int i = 0; i < 2; i++)
4880    {
4881        export_data->is_inserted[i] = 0;
4882    }
4883
4884    // init cursor
4885    export_data->menu_index = EXMENU_SELCARD;
4886    export_data->slot = 0;
4887}
4888int Export_SelCardThink(GOBJ *export_gobj)
4889{
4890
4891    ExportData *export_data = export_gobj->userdata;
4892
4893    int req_blocks = (divide_roundup(stc_transfer_buf_size, 8192) + 1);
4894
4895    // get pausing players inputs
4896    HSD_Pad *pad = PadGetMaster(stc_hmn_controller);
4897    int inputs = pad->down;
4898
4899    // update memcard info
4900    for (int i = 1; i >= 0; i--)
4901    {
4902        // probe slot
4903        u8 is_inserted;
4904
4905        s32 memSize, sectorSize;
4906        if (CARDProbeEx(i, &memSize, &sectorSize) == CARD_RESULT_READY)
4907        {
4908            // if it was just inserted, get info
4909            if (export_data->is_inserted[i] == 0)
4910            {
4911
4912                // mount card
4913                stc_memcard_work->is_done = 0;
4914                if (CARDMountAsync(i, stc_memcard_work->work_area, 0, Memcard_RemovedCallback) == CARD_RESULT_READY)
4915                {
4916                    // check card
4917                    Memcard_Wait();
4918                    stc_memcard_work->is_done = 0;
4919                    if (CARDCheckAsync(i, Memcard_RemovedCallback) == CARD_RESULT_READY)
4920                    {
4921                        Memcard_Wait();
4922
4923                        // if we get this far, a valid memcard is inserted
4924                        is_inserted = 1;
4925                        SFX_PlayCommon(2);
4926                        //export_data->slot = i;  // move cursor to this
4927
4928                        // get free blocks
4929                        s32 byteNotUsed, filesNotUsed;
4930                        if (CARDFreeBlocks(i, &byteNotUsed, &filesNotUsed) == CARD_RESULT_READY)
4931                        {
4932                            export_data->free_blocks[i] = (byteNotUsed / 8192);
4933                            export_data->free_files[i] = filesNotUsed;
4934                        }
4935                    }
4936                    else
4937                        is_inserted = 0;
4938
4939                    CARDUnmount(i);
4940                    stc_memcard_work->is_done = 0;
4941                }
4942                else
4943                    is_inserted = 0;
4944            }
4945            else
4946                is_inserted = 1;
4947        }
4948        else
4949            is_inserted = 0;
4950
4951        export_data->is_inserted[i] = is_inserted;
4952    }
4953
4954    if ((inputs & HSD_BUTTON_LEFT) || (inputs & HSD_BUTTON_DPAD_LEFT))
4955    {
4956        if (export_data->slot > 0)
4957        {
4958            export_data->slot--;
4959            SFX_PlayCommon(2);
4960        }
4961    }
4962
4963    if ((inputs & HSD_BUTTON_RIGHT) || (inputs & HSD_BUTTON_DPAD_RIGHT))
4964    {
4965        if (export_data->slot < 1)
4966        {
4967            export_data->slot++;
4968            SFX_PlayCommon(2);
4969        }
4970    }
4971
4972    int cursor = export_data->slot;
4973    if ((inputs & HSD_BUTTON_A) || (inputs & HSD_BUTTON_START))
4974    {
4975        // ensure it can be saved
4976        if ((export_data->is_inserted[cursor] == 1) && (export_data->free_files[cursor] >= 1) && (export_data->free_blocks[cursor] >= req_blocks))
4977        {
4978            // can save move to next screen
4979            Export_SelCardExit(export_gobj);
4980
4981            // init next menu
4982            Export_EnterNameInit(export_gobj);
4983
4984            SFX_PlayCommon(1);
4985
4986            return 0;
4987        }
4988
4989        else
4990            SFX_PlayCommon(3);
4991    }
4992    else if (inputs & HSD_BUTTON_B)
4993    {
4994        Export_Destroy(export_gobj);
4995
4996        // play sfx
4997        SFX_PlayCommon(0);
4998
4999        return 0;
5000    }
5001
5002    // update selection
5003    Text *text = export_data->text_misc;
5004    for (int i = 0; i < 2; i++)
5005    {
5006        static GXColor white = {255, 255, 255, 255};
5007        static GXColor yellow = {201, 178, 0, 255};
5008        GXColor *color;
5009
5010        // highlight cursor only
5011        if (export_data->slot == i)
5012            color = &yellow;
5013        else
5014            color = &white;
5015
5016        Text_SetColor(text, i, color);
5017    }
5018
5019    // update description
5020    Text *text_desc = export_data->text_desc;
5021    if (export_data->is_inserted[cursor] == 0)
5022    {
5023        Text_SetText(text_desc, 0, "No device is inserted in Slot %s.", slots_names[cursor]);
5024    }
5025    else if (export_data->free_files[cursor] < 1)
5026    {
5027        Text_SetText(text_desc, 0, "The memory card in Slot %s does not \nhave enough free files. 1 free file is \nrequired to save.", slots_names[cursor]);
5028    }
5029    else if (export_data->free_blocks[cursor] < req_blocks)
5030    {
5031        Text_SetText(text_desc, 0, "The memory card in Slot %s does not \nhave enough free blocks. %d blocks is \nrequired to save.", slots_names[cursor], req_blocks);
5032    }
5033    else
5034    {
5035        Text_SetText(text_desc, 0, "Slot %s: %d free blocks. %d blocks will be used.", slots_names[cursor], export_data->free_blocks[cursor], req_blocks);
5036    }
5037    return 1;
5038}
5039void Export_SelCardExit(GOBJ *export_gobj)
5040{
5041    ExportData *export_data = export_gobj->userdata;
5042
5043    // hide menu jobjs
5044    JOBJ_SetFlags(export_data->memcard_jobj[0], JOBJ_HIDDEN);
5045    JOBJ_SetFlags(export_data->memcard_jobj[1], JOBJ_HIDDEN);
5046
5047    Text_Destroy(export_data->text_title);
5048    Text_Destroy(export_data->text_desc);
5049    Text_Destroy(export_data->text_misc);
5050}
5051void Export_EnterNameInit(GOBJ *export_gobj)
5052{
5053    ExportData *export_data = export_gobj->userdata;
5054    MenuData *menu_data = event_vars->menu_gobj->userdata;
5055
5056    // show menu jobjs
5057    JOBJ_ClearFlags(export_data->screenshot_jobj, JOBJ_HIDDEN);
5058    JOBJ_ClearFlags(export_data->textbox_jobj, JOBJ_HIDDEN);
5059
5060    // create keyboard text
5061    Text *text_keyboard = Text_CreateText(2, menu_data->canvas_menu);
5062    export_data->text_keyboard = text_keyboard;
5063    text_keyboard->align = 1;
5064    text_keyboard->kerning = 1;
5065    // scale canvas
5066    text_keyboard->trans.X = EXP_KEYBOARD_X;
5067    text_keyboard->trans.Y = EXP_KEYBOARD_Y;
5068    text_keyboard->viewport_scale.X = MENU_CANVASSCALE * EXP_KEYBOARD_SIZE;
5069    text_keyboard->viewport_scale.Y = MENU_CANVASSCALE * EXP_KEYBOARD_SIZE;
5070    // init keyboard
5071    for (int i = 0; i < 4; i++)
5072    {
5073        // iterate through columns
5074        for (int j = 0; j < 10; j++)
5075        {
5076            Text_AddSubtext(text_keyboard, (-(9.0 / 2.0) * 60) + (j * 60), -80 + (i * 60), "");
5077        }
5078    }
5079    export_data->key_cursor[0] = 0;
5080    export_data->key_cursor[1] = 0;
5081    export_data->caps_lock = 0;
5082    Export_EnterNameUpdateKeyboard(export_gobj);
5083
5084    // create file details
5085    ExportHeader *header = (ExportHeader *)stc_transfer_buf;
5086    char *stage_name = stage_names[header->metadata.stage_internal];
5087    char *hmn_name = Fighter_GetName(header->metadata.hmn);
5088    char *cpu_name = Fighter_GetName(header->metadata.cpu);
5089    Text *text_filedetails = Text_CreateText(2, menu_data->canvas_menu);
5090    export_data->text_filedetails = text_filedetails;
5091    text_filedetails->kerning = 1;
5092    // scale canvas
5093    text_filedetails->trans.X = EXP_FILEDETAILS_X;
5094    text_filedetails->trans.Y = EXP_FILEDETAILS_Y;
5095    text_filedetails->viewport_scale.X = MENU_CANVASSCALE * EXP_FILEDETAILS_SIZE;
5096    text_filedetails->viewport_scale.Y = MENU_CANVASSCALE * EXP_FILEDETAILS_SIZE;
5097
5098    Text_AddSubtext(text_filedetails, 0, 0, "Stage: %s\nHMN: %s\nCPU: %s\n\nSlot %s", stage_name, hmn_name, cpu_name, slots_names[export_data->slot]); // add title
5099
5100    // create title text
5101    Text *text_title = Text_CreateText(2, menu_data->canvas_menu);
5102    export_data->text_title = text_title;
5103    text_title->kerning = 1;
5104    // scale canvas
5105    text_title->trans.X = -23;
5106    text_title->trans.Y = -18;
5107    text_title->viewport_scale.X = MENU_CANVASSCALE * 2;
5108    text_title->viewport_scale.Y = MENU_CANVASSCALE * 2;
5109    Text_AddSubtext(text_title, 0, 0, "Enter File Name");
5110
5111    // create desc text
5112    Text *text_desc = Text_CreateText(2, menu_data->canvas_menu);
5113    export_data->text_desc = text_desc;
5114    text_desc->kerning = 1;
5115    // scale canvas
5116    text_desc->trans.X = -23;
5117    text_desc->trans.Y = 12;
5118    text_desc->viewport_scale.X = MENU_CANVASSCALE;
5119    text_desc->viewport_scale.Y = MENU_CANVASSCALE;
5120    Text_AddSubtext(text_desc, 0, 0, "      A: Select  B: Backspace  Y: Caps");
5121    Text_AddSubtext(text_desc, 0, 40, "           X: Space  Start: Confirm");
5122
5123    // create filename
5124    Text *text_filename = Text_CreateText(2, menu_data->canvas_menu);
5125    export_data->text_filename = text_filename;
5126    text_filename->kerning = 1;
5127    text_filename->use_aspect = 1;
5128    GXColor filename_color = {225, 225, 225, 255};
5129    text_filename->color = filename_color;
5130    // scale canvas
5131    text_filename->trans.X = EXP_FILENAME_X;
5132    text_filename->trans.Y = EXP_FILENAME_Y;
5133    text_filename->aspect.X = EXP_FILENAME_ASPECTX;
5134    text_filename->aspect.Y = EXP_FILENAME_ASPECTY;
5135    text_filename->viewport_scale.X = MENU_CANVASSCALE * EXP_FILENAME_SIZE;
5136    text_filename->viewport_scale.Y = MENU_CANVASSCALE * EXP_FILENAME_SIZE;
5137    // init filename buffer
5138    export_data->filename_buffer[0] = '_';
5139    export_data->filename_buffer[1] = '\0';
5140    Text_AddSubtext(text_filename, 0, 0, export_data->filename_buffer); // add title
5141
5142    // init menu variables
5143    export_data->menu_index = EXMENU_NAME;
5144    export_data->filename_cursor = 0;
5145}
5146int Export_EnterNameThink(GOBJ *export_gobj)
5147{
5148
5149    ExportData *export_data = export_gobj->userdata;
5150
5151    // get pausing players inputs
5152    HSD_Pad *pad = PadGetMaster(stc_hmn_controller);
5153    int inputs = pad->repeat;
5154    int input_down = pad->down;
5155    u8 *cursor = export_data->key_cursor;
5156    int update_keyboard = 0;
5157    int update_filename = 0;
5158    char *filename_buffer = export_data->filename_buffer;
5159
5160    // first ensure memcard is still inserted
5161    s32 memSize, sectorSize;
5162    if (CARDProbeEx(export_data->slot, &memSize, &sectorSize) != CARD_RESULT_READY)
5163        goto EXIT;
5164
5165    // if left
5166    if ((inputs & HSD_BUTTON_LEFT) || (inputs & HSD_BUTTON_DPAD_LEFT))
5167    {
5168        if (cursor[0] > 0)
5169        {
5170            cursor[0]--;
5171        }
5172        else
5173        {
5174            cursor[0] = (10 - 1);
5175        }
5176        update_keyboard = 1;
5177    }
5178    // if right
5179    else if ((inputs & HSD_BUTTON_RIGHT) || (inputs & HSD_BUTTON_DPAD_RIGHT))
5180    {
5181        if (cursor[0] < (10 - 1))
5182        {
5183            cursor[0]++;
5184        }
5185        else
5186        {
5187            cursor[0] = 0;
5188        }
5189        update_keyboard = 1;
5190    }
5191    // if up
5192    else if ((inputs & HSD_BUTTON_UP) || (inputs & HSD_BUTTON_DPAD_UP))
5193    {
5194        if (cursor[1] > 0)
5195        {
5196            cursor[1]--;
5197        }
5198        else
5199        {
5200            cursor[1] = (4 - 1);
5201        }
5202        update_keyboard = 1;
5203    }
5204    // if down
5205    else if ((inputs & HSD_BUTTON_DOWN) || (inputs & HSD_BUTTON_DPAD_DOWN))
5206    {
5207        if (cursor[1] < 4 - 1)
5208        {
5209            cursor[1]++;
5210        }
5211        else
5212        {
5213            cursor[1] = 0;
5214        }
5215        update_keyboard = 1;
5216    }
5217    // if A
5218    else if ((inputs & HSD_BUTTON_A))
5219    {
5220
5221        // check if any remaining characters
5222        if (export_data->filename_cursor < 32)
5223        {
5224
5225            // get correct set of letters
5226            char **keyboard_letters = keyboard_rows[export_data->caps_lock];
5227
5228            // add character to buffer
5229            filename_buffer[export_data->filename_cursor] = keyboard_letters[cursor[1]][cursor[0]];
5230
5231            // add cursor and terminator
5232            filename_buffer[export_data->filename_cursor + 1] = '_';
5233            filename_buffer[export_data->filename_cursor + 2] = '\0';
5234
5235            // inc cursor
5236            export_data->filename_cursor++;
5237
5238            // update filename
5239            update_filename = 1;
5240
5241            // remove caps lock
5242            export_data->caps_lock = 0;
5243            update_keyboard = 1;
5244
5245            SFX_PlayCommon(1);
5246        }
5247        else
5248        {
5249            SFX_PlayCommon(3);
5250        }
5251    }
5252    else if (inputs & HSD_BUTTON_B)
5253    {
5254
5255        // check if can delete
5256        if (export_data->filename_cursor > 0)
5257        {
5258            // dec cursor
5259            export_data->filename_cursor--;
5260
5261            // add cursor and terminator
5262            filename_buffer[export_data->filename_cursor] = '_';
5263            filename_buffer[export_data->filename_cursor + 1] = '\0';
5264
5265            // update filename
5266            update_filename = 1;
5267
5268            SFX_PlayCommon(0);
5269        }
5270
5271        // exit here
5272        else if (input_down & HSD_BUTTON_B)
5273        {
5274        EXIT:
5275            Export_EnterNameExit(export_gobj);
5276            Export_SelCardInit(export_gobj);
5277            SFX_PlayCommon(0);
5278            return 0;
5279        }
5280    }
5281    if (inputs & HSD_BUTTON_Y)
5282    {
5283        export_data->caps_lock ^= 1;
5284        update_keyboard = 1;
5285
5286        SFX_PlayCommon(1);
5287    }
5288    if (inputs & HSD_BUTTON_X)
5289    {
5290
5291        // check if any remaining characters
5292        if (export_data->filename_cursor < 32)
5293        {
5294            // add character to buffer
5295            filename_buffer[export_data->filename_cursor] = ' ';
5296
5297            // add cursor and terminator
5298            filename_buffer[export_data->filename_cursor + 1] = '_';
5299            filename_buffer[export_data->filename_cursor + 2] = '\0';
5300
5301            // inc cursor
5302            export_data->filename_cursor++;
5303
5304            // update filename
5305            update_filename = 1;
5306
5307            SFX_PlayCommon(1);
5308        }
5309        else
5310        {
5311            TMLOG("max characters!\n");
5312        }
5313    }
5314    if (inputs & HSD_BUTTON_START)
5315    {
5316        // at least 1 character
5317        if (export_data->filename_cursor > 0)
5318        {
5319            Export_ConfirmInit(export_gobj);
5320
5321            // play sfx
5322            SFX_PlayCommon(1);
5323        }
5324        else
5325        {
5326            SFX_PlayCommon(3);
5327        }
5328
5329        return 0;
5330    }
5331
5332    // update keyboard
5333    if (update_keyboard == 1)
5334    {
5335        Export_EnterNameUpdateKeyboard(export_gobj);
5336        SFX_PlayCommon(2);
5337    }
5338
5339    // update filename if changed
5340    if (update_filename == 1)
5341    {
5342        Text_SetText(export_data->text_filename, 0, filename_buffer);
5343    }
5344
5345    return 0;
5346}
5347void Export_EnterNameExit(GOBJ *export_gobj)
5348{
5349    ExportData *export_data = export_gobj->userdata;
5350
5351    // hide menu jobjs
5352    JOBJ_SetFlags(export_data->screenshot_jobj, JOBJ_HIDDEN);
5353    JOBJ_SetFlags(export_data->textbox_jobj, JOBJ_HIDDEN);
5354
5355    Text_Destroy(export_data->text_title);
5356    Text_Destroy(export_data->text_desc);
5357    Text_Destroy(export_data->text_keyboard);
5358    Text_Destroy(export_data->text_filename);
5359    Text_Destroy(export_data->text_filedetails);
5360}
5361void Export_ConfirmInit(GOBJ *export_gobj)
5362{
5363    ExportData *export_data = export_gobj->userdata;
5364    MenuData *menu_data = event_vars->menu_gobj->userdata;
5365
5366    // create gobj
5367    GOBJ *confirm_gobj = GObj_Create(0, 0, 0);
5368    export_data->confirm_gobj = confirm_gobj;
5369
5370    // load menu joint
5371    JOBJ *confirm_jobj = JOBJ_LoadJoint(stc_lab_data->export_popup);
5372    GObj_AddObject(confirm_gobj, 3, confirm_jobj);                                   // add to gobj
5373    GObj_AddGXLink(confirm_gobj, GXLink_Common, GXLINK_MENUMODEL, GXPRI_POPUPMODEL); // add gx link
5374
5375    // create text
5376    Text *confirm_text = Text_CreateText(2, menu_data->canvas_popup);
5377    export_data->confirm_text = confirm_text;
5378    confirm_text->align = 1;
5379    confirm_text->kerning = 1;
5380    // scale canvas
5381    confirm_text->viewport_scale.X = MENU_CANVASSCALE;
5382    confirm_text->viewport_scale.Y = MENU_CANVASSCALE;
5383    Text_AddSubtext(confirm_text, 0, -40, "Save File to Slot %s?", slots_names[export_data->slot]);
5384    int yes_subtext = Text_AddSubtext(confirm_text, -60, 20, "Yes");
5385    GXColor yellow = {201, 178, 0, 255};
5386    Text_SetColor(confirm_text, yes_subtext, &yellow);
5387    Text_AddSubtext(confirm_text, 60, 20, "No");
5388
5389    export_data->menu_index = EXMENU_CONFIRM;
5390    export_data->confirm_state = EXPOP_CONFIRM;
5391    export_data->confirm_cursor = 0;
5392}
5393int Export_ConfirmThink(GOBJ *export_gobj)
5394{
5395    ExportData *export_data = export_gobj->userdata;
5396
5397    // get pausing players inputs
5398    HSD_Pad *pad = PadGetMaster(stc_hmn_controller);
5399    int inputs = pad->down;
5400
5401    // if unplugged exit
5402    s32 memSize, sectorSize;
5403    if (CARDProbeEx(export_data->slot, &memSize, &sectorSize) != CARD_RESULT_READY)
5404    {
5405        Export_ConfirmExit(export_gobj);
5406        Export_EnterNameExit(export_gobj);
5407
5408        // play sfx
5409        SFX_PlayCommon(0);
5410    }
5411
5412    switch (export_data->confirm_state)
5413    {
5414    case (EXPOP_CONFIRM):
5415    {
5416
5417        int update_cursor = 0;
5418
5419        if ((inputs & HSD_BUTTON_LEFT) || (inputs & HSD_BUTTON_DPAD_LEFT))
5420        {
5421            if (export_data->confirm_cursor > 0)
5422            {
5423                export_data->confirm_cursor--;
5424                update_cursor = 1;
5425            }
5426        }
5427        else if ((inputs & HSD_BUTTON_RIGHT) || (inputs & HSD_BUTTON_DPAD_RIGHT))
5428        {
5429            if (export_data->confirm_cursor < 1)
5430            {
5431                export_data->confirm_cursor++;
5432                update_cursor = 1;
5433            }
5434        }
5435        else if (inputs & HSD_BUTTON_B)
5436        {
5437            Export_ConfirmExit(export_gobj);
5438
5439            // play sfx
5440            SFX_PlayCommon(0);
5441
5442            return 0;
5443        }
5444        else if ((inputs & HSD_BUTTON_A) || (inputs & HSD_BUTTON_START))
5445        {
5446
5447            // begin save
5448            if (export_data->confirm_cursor == 0)
5449            {
5450
5451                MenuData *menu_data = event_vars->menu_gobj->userdata;
5452
5453                // free current text
5454                Text_Destroy(export_data->confirm_text);
5455
5456                // create text
5457                Text *confirm_text = Text_CreateText(2, menu_data->canvas_popup);
5458                export_data->confirm_text = confirm_text;
5459                confirm_text->align = 1;
5460                confirm_text->kerning = 1;
5461                // scale canvas
5462                confirm_text->viewport_scale.X = MENU_CANVASSCALE;
5463                confirm_text->viewport_scale.Y = MENU_CANVASSCALE;
5464                Text_AddSubtext(confirm_text, 0, -20, "");
5465
5466                export_data->confirm_state = EXPOP_SAVE;
5467
5468                export_status = EXSTAT_REQSAVE;
5469
5470                // play sfx
5471                SFX_PlayCommon(1);
5472
5473                return 0;
5474            }
5475            // go back to keyboard menu
5476            else
5477            {
5478                Export_ConfirmExit(export_gobj);
5479
5480                // play sfx
5481                SFX_PlayCommon(0);
5482
5483                return 0;
5484            }
5485        }
5486
5487        if (update_cursor == 1)
5488        {
5489            for (int i = 0; i < 2; i++)
5490            {
5491                static GXColor white = {255, 255, 255, 255};
5492                static GXColor yellow = {201, 178, 0, 255};
5493                GXColor *color;
5494
5495                // highlight cursor only
5496                if (export_data->confirm_cursor == i)
5497                    color = &yellow;
5498                else
5499                    color = &white;
5500
5501                Text_SetColor(export_data->confirm_text, i + 1, color);
5502            }
5503
5504            SFX_PlayCommon(2);
5505        }
5506        break;
5507    }
5508    case (EXPOP_SAVE):
5509    {
5510        // wait for save to finish
5511        if (Export_Process(export_gobj) == 1)
5512        {
5513            Export_ConfirmExit(export_gobj);
5514            Export_Destroy(export_gobj);
5515
5516            // play sfx
5517            SFX_PlayCommon(1);
5518
5519            return 0;
5520        }
5521        break;
5522    }
5523    }
5524    return 0;
5525}
5526void Export_ConfirmExit(GOBJ *export_gobj)
5527{
5528    ExportData *export_data = export_gobj->userdata;
5529
5530    GObj_Destroy(export_data->confirm_gobj);
5531    Text_Destroy(export_data->confirm_text);
5532
5533    export_data->menu_index = EXMENU_NAME;
5534}
5535void Export_EnterNameUpdateKeyboard(GOBJ *export_gobj)
5536{
5537    ExportData *export_data = export_gobj->userdata;
5538    Text *text_keyboard = export_data->text_keyboard;
5539    u8 *cursor = export_data->key_cursor;
5540
5541    // get correct set of letters
5542    char **keyboard_letters = keyboard_rows[export_data->caps_lock];
5543
5544    // iterate through rows
5545    for (int i = 0; i < 4; i++)
5546    {
5547        // iterate through columns
5548        for (int j = 0; j < 10; j++)
5549        {
5550
5551            int this_subtext = (i * 10) + j;
5552
5553            // update letter text
5554            char letter[2];
5555            letter[0] = keyboard_letters[i][j];
5556            letter[1] = '\0';
5557            Text_SetText(text_keyboard, this_subtext, letter);
5558
5559            // update letter color
5560            static GXColor white = {255, 255, 255, 255};
5561            static GXColor yellow = {201, 178, 0, 255};
5562            GXColor *color;
5563            // check for cursor
5564            if ((cursor[0] == j) && (cursor[1] == i))
5565                color = &yellow;
5566            else
5567                color = &white;
5568            Text_SetColor(text_keyboard, this_subtext, color);
5569        }
5570    }
5571}
5572int Export_Process(GOBJ *export_gobj)
5573{
5574
5575    ExportData *export_data = export_gobj->userdata;
5576    Text *text = export_data->confirm_text;
5577
5578    int finished = 0;
5579
5580    // if snapshot is processing, dont update
5581    switch (export_status)
5582    {
5583    case (EXSTAT_REQSAVE):
5584    {
5585
5586        int slot = export_data->slot;
5587
5588        save_pre_tick = OSGetTick();
5589
5590        // create filename string
5591        ExportHeader *header = (ExportHeader *)stc_transfer_buf;
5592        char filename[32];
5593        sprintf(filename, tm_filename, header->metadata.month, header->metadata.day, header->metadata.year, header->metadata.hour, header->metadata.minute, header->metadata.second); // generate filename based on date, time, fighters, and stage
5594
5595        // save file name to metadata
5596        memcpy(&header->metadata.filename, export_data->filename_buffer, export_data->filename_cursor);
5597
5598        // check if file exists and delete it
5599        s32 memSize, sectorSize;
5600        if (CARDProbeEx(slot, &memSize, &sectorSize) == CARD_RESULT_READY)
5601        {
5602            // mount card
5603            stc_memcard_work->is_done = 0;
5604            if (CARDMountAsync(slot, stc_memcard_work->work_area, 0, Memcard_RemovedCallback) == CARD_RESULT_READY)
5605            {
5606                // check card
5607                Memcard_Wait();
5608                stc_memcard_work->is_done = 0;
5609                if (CARDCheckAsync(slot, Memcard_RemovedCallback) == CARD_RESULT_READY)
5610                {
5611                    Memcard_Wait();
5612                    // get free blocks
5613                    s32 byteNotUsed, filesNotUsed;
5614                    if (CARDFreeBlocks(slot, &byteNotUsed, &filesNotUsed) == CARD_RESULT_READY)
5615                    {
5616                        // search for file with this name
5617                        for (int i = 0; i < CARD_MAX_FILE; i++)
5618                        {
5619                            CARDStat card_stat;
5620
5621                            if (CARDGetStatus(slot, i, &card_stat) == CARD_RESULT_READY)
5622                            {
5623                                // check company code
5624                                if (strncmp(os_info->company, card_stat.company, sizeof(os_info->company)) == 0)
5625                                {
5626                                    // check game name
5627                                    if (strncmp(os_info->gameName, card_stat.gameName, sizeof(os_info->gameName)) == 0)
5628                                    {
5629                                        // check file name
5630                                        if (strncmp(filename, card_stat.fileName, sizeof(filename)) == 0)
5631                                        {
5632                                            // delete
5633                                            CARDDeleteAsync(slot, filename, Memcard_RemovedCallback);
5634                                            stc_memcard_work->is_done = 0;
5635                                            Memcard_Wait();
5636                                        }
5637                                    }
5638                                }
5639                            }
5640                        }
5641                    }
5642                }
5643                CARDUnmount(slot);
5644                stc_memcard_work->is_done = 0;
5645            }
5646        }
5647
5648        // setup save
5649        memcpy(stc_memcard_info->file_name, &stc_save_name, sizeof(stc_save_name));
5650        memset(stc_memcard_info->file_desc, '\0', 32);                                                   // fill with spaces
5651        memcpy(stc_memcard_info->file_desc, export_data->filename_buffer, export_data->filename_cursor); // copy inputted name
5652        memcard_save.data = stc_transfer_buf;
5653        memcard_save.x4 = 3;
5654        memcard_save.size = stc_transfer_buf_size;
5655        memcard_save.xc = -1;
5656        Memcard_ReqSaveCreate(slot, filename, &memcard_save, stc_memcard_unk, stc_memcard_info->file_name, stc_lab_data->save_banner, stc_lab_data->save_icon, 0);
5657
5658        // change status
5659        export_status = EXSTAT_SAVEWAIT;
5660
5661        break;
5662    }
5663    case (EXSTAT_SAVEWAIT):
5664    {
5665
5666        // wait to finish writing
5667        if (Memcard_CheckStatus() != 11)
5668        {
5669            // change state
5670            export_status = EXSTAT_DONE;
5671        }
5672        else
5673        {
5674            if (*stc_memcard_write_status == 6)
5675            {
5676                Text_SetText(text, 0, "Writing Data...");
5677            }
5678            else
5679            {
5680                Text_SetText(text, 0, "Creating File");
5681            }
5682        }
5683
5684        break;
5685    }
5686    case (EXSTAT_DONE):
5687    {
5688
5689        export_status = EXSTAT_NONE;
5690        finished = 1;
5691
5692        Text_Destroy(text);
5693        break;
5694    }
5695    }
5696
5697    return finished;
5698}
5699int Export_Compress(u8 *dest, u8 *source, u32 size)
5700{
5701    int compress_size = lz77Compress(source, size, dest, 8);
5702    return compress_size;
5703}
5704
5705static void UpdateDataTracking(GOBJ *character) {
5706    FighterData *data = character->userdata;
5707
5708    if (data->flags.past_iasa)
5709        data->TM.iasa_frames++;
5710    else
5711        data->TM.iasa_frames = 0;
5712}
5713
5714static void UpdateOverlays(GOBJ *character, EventOption *overlays) {
5715    FighterData *data = character->userdata;
5716
5717    static int overlays_running[4] = { -1, -1, -1, -1 };
5718    int *overlay_running = &overlays_running[data->ply];
5719
5720    for (OverlayGroup i = 0; i < OVERLAY_COUNT; i++)
5721    {
5722        // overlays go from general to specific, so we iterate in reverse
5723        // to use the most specific overlay possibe.
5724        int j = OVERLAY_COUNT - i - 1;
5725
5726        int color_idx = overlays[j].val;
5727        if (color_idx == 0) continue;
5728
5729        if (CheckOverlay(character, j))
5730        {
5731            Overlay ov = LabValues_OverlayColours[color_idx];
5732
5733            if (ov.occur_once && *overlay_running == j)
5734                return;
5735
5736            memset(&data->color[1], 0, sizeof(ColorOverlay));
5737            memset(&data->color[0], 0, sizeof(ColorOverlay));
5738
5739            // Changes the alpha of the double jump overlay based on the number of jump used
5740            if (j == OVERLAY_JUMPS_USED){
5741                float max_jumps = (float)data->attr.max_jumps;
5742                float jumps_used = (float)data->jump.jumps_used;
5743                float alpha_factor = 1.0 - (max_jumps - jumps_used) / max_jumps;
5744                ov.color.a *= alpha_factor;
5745            }
5746
5747            *overlay_running = j;
5748            data->color[1].hex = ov.color;
5749            data->color[1].color_enable = 1;
5750            data->flags.invisible = ov.invisible;
5751
5752            if (ov.show_collision)
5753                data->show_hit = 1;
5754
5755            if (ov.play_sound)
5756                SFX_PlayCommon(2);
5757
5758            return;
5759        }
5760    }
5761
5762    if (*overlay_running != -1) {
5763        memset(&data->color[1], 0, sizeof(ColorOverlay));
5764        memset(&data->color[0], 0, sizeof(ColorOverlay));
5765        data->flags.invisible = 0;
5766        data->show_hit = LabOptions_General[OPTGEN_HIT].val;
5767        *overlay_running = -1;
5768    }
5769}
5770
5771static void Stage_SetFODPlatformHeight(int side) {
5772    int option_idx = side == 0 ? OPTSTAGE_FOD_PLAT_HEIGHT_LEFT : OPTSTAGE_FOD_PLAT_HEIGHT_RIGHT;
5773    int idx = LabOptions_Stage_FOD[option_idx].val;
5774    if (idx == 0) return; // random default
5775    float height = LabValues_FODPlatformHeights[idx];
5776
5777    GOBJ *platform_gobj = Stage_GetMapGObj(4);
5778    if (side == 0)
5779        platform_gobj = platform_gobj->previous;
5780
5781    GOBJ *stage_gobj = Stage_GetMapGObj(3);
5782    JOBJ *stage_jobj = stage_gobj->hsd_object;
5783    JOBJ *plat_jobj = stage_jobj->child->child;
5784    if (side != 0)
5785        plat_jobj = plat_jobj->sibling;
5786
5787    struct FODData { u16 mode, timer; } *data = (void*)((u8*)platform_gobj->userdata + 0xC4);
5788
5789    data->mode = 1;
5790    data->timer = 0xFF;
5791
5792    plat_jobj->trans.Y = height;
5793    JOBJ_SetMtxDirtySub(plat_jobj);
5794}
5795
5796static void Stage_Think(void) {
5797    GrExternal stage_kind = Stage_GetExternalID();
5798    if (stage_kind == GRKINDEXT_IZUMI) {
5799        Stage_SetFODPlatformHeight(0);
5800        Stage_SetFODPlatformHeight(1);
5801    }
5802}
5803
5804// Think Function that runs after the stage and character's think functions.
5805// Needed to prevent data from overwritten by the native think functions.
5806void Event_PostThink(GOBJ *gobj)
5807{
5808    GOBJ *hmn = Fighter_GetGObj(0);
5809    GOBJ *cpu = Fighter_GetGObj(1);
5810
5811    // we do this in post so that we can use the updated character data before rendering.
5812    UpdateDataTracking(hmn);
5813    UpdateDataTracking(cpu);
5814
5815    UpdateOverlays(hmn, LabOptions_OverlaysHMN);
5816    UpdateOverlays(cpu, LabOptions_OverlaysCPU);
5817
5818    Stage_Think();
5819}
5820
5821// Init Function
5822void Event_Init(GOBJ *gobj)
5823{
5824    GOBJ *hmn = Fighter_GetGObj(0);
5825    FighterData *hmn_data = hmn->userdata;
5826    GOBJ *cpu = Fighter_GetGObj(1);
5827    FighterData *cpu_data = cpu->userdata;
5828    GObj_AddProc(gobj, Event_PostThink, 20);
5829
5830    // Init runtime options...
5831    
5832    // recovery options
5833    EventMenu *recovery_menu = RecoveryMenus[cpu_data->kind];
5834    LabOptions_CPU[OPTCPU_RECOVERY].menu = recovery_menu;
5835    LabOptions_CPU[OPTCPU_RECOVERY].disable = recovery_menu == 0;
5836    
5837    // enable all recovery options
5838    if (recovery_menu) {
5839        for (int i = 0; i < recovery_menu->option_num; ++i)
5840            recovery_menu->options[i].val = 1;
5841    }
5842    
5843    // advanced counter options
5844    for (int i = 0; i < ADV_COUNTER_COUNT; ++i) {
5845        memcpy(
5846            LabOptions_AdvCounter[i],
5847            LabOptions_AdvCounter_Default,
5848            sizeof(LabOptions_AdvCounter_Default)
5849        );
5850    }
5851    
5852    // overlays
5853    memcpy(LabOptions_OverlaysHMN, LabOptions_OverlaysDefault, sizeof(LabOptions_OverlaysDefault));
5854    memcpy(LabOptions_OverlaysCPU, LabOptions_OverlaysDefault, sizeof(LabOptions_OverlaysDefault));
5855
5856    // info display
5857    memcpy(LabOptions_InfoDisplayHMN, LabOptions_InfoDisplayDefault, sizeof(LabOptions_InfoDisplayDefault));
5858    memcpy(LabOptions_InfoDisplayCPU, LabOptions_InfoDisplayDefault, sizeof(LabOptions_InfoDisplayDefault));
5859    LabOptions_InfoDisplayHMN[OPTINF_PRESET].OnChange = Lab_ChangeInfoPresetHMN;
5860    LabOptions_InfoDisplayCPU[OPTINF_PRESET].OnChange = Lab_ChangeInfoPresetCPU;
5861
5862    // saved options
5863    Memcard *memcard = stc_memcard;
5864
5865    // load input display option, resetting if invalid
5866    if (memcard->TM_LabFrameAdvanceButton < LabOptions_General[OPTGEN_FRAMEBTN].value_num)
5867        LabOptions_General[OPTGEN_FRAMEBTN].val = memcard->TM_LabFrameAdvanceButton;
5868    else
5869        memcard->TM_LabFrameAdvanceButton = LabOptions_General[OPTGEN_FRAMEBTN].val;
5870
5871    // load input display option, resetting if invalid
5872    if (memcard->TM_LabCPUInputDisplay < LabOptions_General[OPTGEN_INPUT].value_num)
5873        LabOptions_General[OPTGEN_INPUT].val = memcard->TM_LabCPUInputDisplay;
5874    else
5875        memcard->TM_LabCPUInputDisplay = LabOptions_General[OPTGEN_INPUT].val;
5876
5877    // load taunt option, resetting if invalid
5878    if (memcard->TM_LabTauntEnabled <= 1)
5879        LabOptions_General[OPTGEN_TAUNT].val = memcard->TM_LabTauntEnabled;
5880    else
5881        memcard->TM_LabTauntEnabled = LabOptions_General[OPTGEN_TAUNT].val;
5882
5883    // load overlays, resetting if invalid
5884    int overlay_save_count = sizeof(memcard->TM_LabSavedOverlays_HMN) / sizeof(OverlaySave);
5885    for (int i = 0; i < overlay_save_count; ++i) {
5886        OverlaySave save_hmn = memcard->TM_LabSavedOverlays_HMN[i];
5887        if (save_hmn.overlay != 0) {
5888            // ensure valid
5889            if (
5890                save_hmn.group < countof(LabOptions_OverlaysHMN)
5891                && save_hmn.overlay < countof(LabValues_OverlayColours)
5892            ) {
5893                LabOptions_OverlaysHMN[save_hmn.group].val = save_hmn.overlay;
5894            } else {
5895                memcard->TM_LabSavedOverlays_HMN[i] = (OverlaySave){0};
5896            }
5897        }
5898
5899        OverlaySave save_cpu = memcard->TM_LabSavedOverlays_CPU[i];
5900        if (save_cpu.overlay != 0) {
5901            // ensure valid
5902            if (
5903                save_cpu.group < countof(LabOptions_OverlaysCPU)
5904                && save_cpu.overlay < countof(LabValues_OverlayColours)
5905            ) {
5906                LabOptions_OverlaysCPU[save_cpu.group].val = save_cpu.overlay;
5907            } else {
5908                memcard->TM_LabSavedOverlays_CPU[i] = (OverlaySave){0};
5909            }
5910        }
5911    }
5912
5913    int enabled_osds = memcard->TM_OSDEnabled;
5914    for (int i = 0; i < LabMenu_OSDs.option_num; i++) {
5915        int osd_bit_position = osd_memory_bit_position[i];
5916        int is_osd_enabled = (enabled_osds & (1 << osd_bit_position)) != 0;
5917        LabOptions_OSDs[i].val = is_osd_enabled;
5918    }
5919
5920    // character rng options
5921    {
5922        CharacterRngOptions hmn_rng_data = character_rng_options[hmn_data->kind];
5923        CharacterRngOptions cpu_rng_data = character_rng_options[cpu_data->kind];
5924        if (hmn_rng_data.len != 0 || cpu_rng_data.len != 0) {
5925            LabOptions_Main[OPTLAB_CHAR_RNG].disable = 0;
5926            u8 current_option = 0;
5927            for (int i = 0; i < hmn_rng_data.len; ++i) {
5928                if (current_option == OPTCHARRNG_MAXCOUNT)
5929                    assert("too many character rng options");
5930                LabMenu_CharacterRng.options[current_option++] = hmn_rng_data.options[i];
5931            }
5932            // only if cpu is different from hmn
5933            if (hmn_rng_data.options != cpu_rng_data.options) {
5934                for (int i = 0; i < cpu_rng_data.len; ++i) {
5935                    if (current_option == OPTCHARRNG_MAXCOUNT)
5936                        assert("too many character rng options");
5937                    LabMenu_CharacterRng.options[current_option++] = cpu_rng_data.options[i];
5938                }
5939            }
5940            LabMenu_CharacterRng.option_num = current_option;
5941        }
5942    }
5943
5944    // stage options
5945    EventMenu *stage_menu = stage_menus[Stage_GetExternalID()];
5946    if (stage_menu != NULL) {
5947        LabOptions_Main[OPTLAB_STAGE].disable = 0;
5948        LabOptions_Main[OPTLAB_STAGE].menu = stage_menu;
5949    }
5950
5951    // Aitch: replace HSD_Randi call in stadium transformation code with lwz r3, TRANSFORMATION_ID_PTR
5952    // No way around this hack really, we can't fake the transformation well because loading is done immediately after
5953    // the randi call, so we would have to decompile the entire 50k asm line function and reverse engineer the state machine.
5954    // Directly overwriting the asm is the best call for now imo.
5955    // This needs to be done here in init, as dolphin will jit the function when it runs and overwriting won't do anything.
5956    *(u32*)(0x801d463c) = 0x806d3778;
5957
5958    event_vars->savestate_saved_while_mirrored = false;
5959    event_vars->loaded_mirrored = false;
5960
5961    // get this events assets
5962    stc_lab_data = Archive_GetPublicAddress(event_vars->event_archive, "lab");
5963
5964    // Init Info Display
5965    infodisp_gobj_hmn = InfoDisplay_Init(0);
5966    infodisp_gobj_cpu = InfoDisplay_Init(1);
5967
5968    // update to show/hide
5969    InfoDisplay_Update(infodisp_gobj_hmn, LabOptions_InfoDisplayHMN, Fighter_GetGObj(0), NULL);
5970    InfoDisplay_Update(infodisp_gobj_cpu, LabOptions_InfoDisplayCPU, Fighter_GetGObj(1), infodisp_gobj_hmn);
5971
5972    // Init DIDraw
5973    DIDraw_Init();
5974
5975    // Init Recording
5976    Record_Init();
5977
5978    // Init Input Display
5979    Inputs_Init();
5980
5981    // store hsd_update functions
5982    HSD_Update *hsd_update = stc_hsd_update;
5983    hsd_update->checkPause = Update_CheckPause;
5984    hsd_update->checkAdvance = Update_CheckAdvance;
5985
5986    // determine controllers
5987    stc_hmn_controller = Fighter_GetControllerPort(hmn_data->ply);
5988    stc_cpu_controller = (stc_hmn_controller+1) % 4;
5989    stc_null_controller = (stc_cpu_controller+1) % 4;
5990
5991    // set CPU AI to no_act 15
5992    cpu_data->cpu.ai = 15;
5993
5994    // change team - homing missiles don't move towards characters on same team
5995    hmn_data->team = 0;
5996    cpu_data->team = 1;
5997
5998    // check to immediately load recording
5999    if (*onload_fileno != -1)
6000    {
6001        Record_MemcardLoad(*onload_slot, *onload_fileno);
6002        LabOptions_Record[OPTREC_SAVE_LOAD] = Record_Load;
6003
6004        // When we load rwing savestates, we don't want infinite shields by default. This would cause desyncs galore.
6005        LabOptions_CPU[OPTCPU_SHIELD].val = CPUINFSHIELD_OFF;
6006    }
6007
6008    // Aitch: VERY nice for debugging. Please don't remove.
6009    TMLOG("HMN: %x\tCPU: %x\n", (u32)hmn_data, (u32)cpu_data);
6010}
6011
6012// Update Function
6013void Event_Update()
6014{
6015    if (Pause_CheckStatus(1) != 2) {
6016        float speed = LabOptions_GameSpeeds[LabOptions_General[OPTGEN_SPEED].val];
6017        HSD_SetSpeedEasy(speed);
6018    } else {
6019        HSD_SetSpeedEasy(1.0);
6020    }
6021
6022    // update DI draw
6023    DIDraw_Update();
6024
6025    // update info display
6026    InfoDisplay_Update(infodisp_gobj_hmn, LabOptions_InfoDisplayHMN, Fighter_GetGObj(0), NULL);
6027    InfoDisplay_Update(infodisp_gobj_cpu, LabOptions_InfoDisplayCPU, Fighter_GetGObj(1), infodisp_gobj_hmn);
6028
6029    // Check for savestates
6030    Savestates_Update();
6031    
6032    // hide UI if set to off
6033    bool hide = LabOptions_Record[OPTREC_CPUMODE].val == 0 && LabOptions_Record[OPTREC_HMNMODE].val == 0;
6034    HUDCamData *hud_cam = event_vars->hudcam_gobj->userdata;
6035    hud_cam->hide = hide;
6036}
6037
6038void Event_Think_LabState_Normal(GOBJ *event) {
6039    // Aitch: TODO - is there a good reason why we need both Record_Think and this function?
6040    // There could be a priority issue, where we need to call Record_Think after the cpu inputs are decided for whatever reason.
6041    // I think it makes sense to fold the two into a single function, if possible.
6042    // Or, call Record_Think from this function rather than it being a callback.
6043
6044    LabData *eventData = event->userdata;
6045    GOBJ *hmn = Fighter_GetGObj(0);
6046    FighterData *hmn_data = hmn->userdata;
6047    GOBJ *cpu = Fighter_GetGObj(1);
6048    FighterData *cpu_data = cpu->userdata;
6049    HSD_Pad *pad = PadGetEngine(hmn_data->pad_index);
6050
6051    static int move_timer = 0;
6052    const int MOVE_THRESHOLD = 10;
6053    // Move CPU
6054    if (lockout_timer > 0)
6055    {
6056        lockout_timer--;
6057    }
6058    else
6059    {
6060        if (pad->held & HSD_BUTTON_DPAD_DOWN)
6061        {
6062            move_timer++;
6063            if (move_timer == MOVE_THRESHOLD)
6064            {
6065                // handle timer logic
6066                move_timer = 0;
6067                lockout_timer = LOCKOUT_DURATION;
6068
6069                // ensure CPU is not dead
6070                if (cpu_data->flags.dead == 0)
6071                {
6072                    // ensure player is grounded
6073                    int isGround = 0;
6074                    if (hmn_data->phys.air_state == 0)
6075                    {
6076
6077                        // check for ground in front of player
6078                        Vec3 coll_pos;
6079                        int line_index;
6080                        int line_kind;
6081                        Vec3 line_unk;
6082                        float fromX = (hmn_data->phys.pos.X) + (hmn_data->facing_direction * 16);
6083                        float toX = fromX;
6084                        float fromY = (hmn_data->phys.pos.Y + 5);
6085                        float toY = fromY - 10;
6086                        isGround = GrColl_RaycastGround(&coll_pos, &line_index, &line_kind, &line_unk, -1, -1, -1, 0, fromX, fromY, toX, toY, 0);
6087                        if (isGround == 1)
6088                        {
6089
6090                            // do this for every subfighter (thanks for complicated code ice climbers)
6091                            int is_moved = 0;
6092                            for (int i = 0; i < 2; i++)
6093                            {
6094                                GOBJ *this_fighter = Fighter_GetSubcharGObj(cpu_data->ply, i);
6095
6096                                if (this_fighter != 0)
6097                                {
6098
6099                                    FighterData *this_fighter_data = this_fighter->userdata;
6100
6101                                    if ((this_fighter_data->flags.sleep == 0) && (this_fighter_data->flags.dead == 0))
6102                                    {
6103
6104                                        is_moved = 1;
6105
6106                                        // place CPU here
6107                                        this_fighter_data->phys.pos = coll_pos;
6108                                        this_fighter_data->coll_data.ground_index = line_index;
6109
6110                                        // facing player
6111                                        this_fighter_data->facing_direction = hmn_data->facing_direction * -1;
6112
6113                                        // set grounded
6114                                        this_fighter_data->phys.air_state = 0;
6115                                        //Fighter_SetGrounded(this_fighter);
6116
6117                                        // kill velocity
6118                                        Fighter_KillAllVelocity(this_fighter);
6119
6120                                        // enter wait
6121                                        Fighter_EnterWait(this_fighter);
6122
6123                                        // update ECB
6124                                        this_fighter_data->coll_data.topN_Curr = this_fighter_data->phys.pos; // move current ECB location to new position
6125                                        Coll_ECBCurrToPrev(&this_fighter_data->coll_data);
6126                                        this_fighter_data->cb.Coll(this_fighter);
6127
6128                                        // update camera box
6129                                        Fighter_UpdateCameraBox(this_fighter);
6130                                        this_fighter_data->camera_subject->boundleft_curr = this_fighter_data->camera_subject->boundleft_proj;
6131                                        this_fighter_data->camera_subject->boundright_curr = this_fighter_data->camera_subject->boundright_proj;
6132
6133                                        // init CPU logic (for nana's popo position history...)
6134                                        int cpu_kind = Fighter_GetCPUKind(this_fighter_data->ply);
6135                                        int cpu_level = Fighter_GetCPULevel(this_fighter_data->ply);
6136                                        Fighter_CPUInitialize(this_fighter_data, cpu_kind, cpu_level, 0);
6137
6138                                        // place subfighter in the Z axis
6139                                        if (this_fighter_data->flags.ms == 1)
6140                                        {
6141                                            ftCommonData *ft_common = *stc_ftcommon;
6142                                            this_fighter_data->phys.pos.Z = ft_common->ms_zjostle_max * -1;
6143                                        }
6144                                    }
6145                                }
6146                            }
6147
6148                            if (is_moved == 1)
6149                            {
6150                                CPUResetVars();
6151                            }
6152                        }
6153                    }
6154
6155                    // play SFX
6156                    if (isGround == 0)
6157                    {
6158                        SFX_PlayCommon(3);
6159                    }
6160                    else
6161                    {
6162                        SFX_Play(221);
6163                    }
6164                }
6165            }
6166        }
6167        else
6168        {
6169            move_timer = 0;
6170        }
6171    }
6172
6173    int hmn_mode = LabOptions_Record[OPTREC_HMNMODE].val;
6174    int cpu_mode = LabOptions_Record[OPTREC_CPUMODE].val;
6175
6176    int cpu_control = false;
6177    
6178    HSD_Pad *hmn_pad = PadGetMaster(stc_hmn_controller);
6179    int sticks = fabs(hmn_pad->fstickX) >= STICK_DEADZONE
6180        || fabs(hmn_pad->fstickY) >= STICK_DEADZONE
6181        || fabs(hmn_pad->fsubstickX) >= STICK_DEADZONE
6182        || fabs(hmn_pad->fsubstickY) >= STICK_DEADZONE;
6183    int triggers = hmn_pad->ftriggerLeft >= TRIGGER_DEADZONE
6184        || hmn_pad->ftriggerRight >= TRIGGER_DEADZONE;
6185    int buttons = hmn_pad->held & (HSD_BUTTON_A | HSD_BUTTON_B | HSD_BUTTON_X | HSD_BUTTON_Y | 
6186            HSD_BUTTON_DPAD_UP | HSD_TRIGGER_L | HSD_TRIGGER_R | HSD_TRIGGER_Z);
6187    bool takeover_input = (buttons | triggers | sticks) != 0;
6188    
6189    int takeover_target;
6190    if (hmn_mode == RECMODE_HMN_RERECORD)
6191        takeover_target = TAKEOVER_HMN;
6192    else if (cpu_mode == RECMODE_CPU_RERECORD)
6193        takeover_target = TAKEOVER_CPU;
6194    else
6195        takeover_target = LabOptions_Record[OPTREC_TAKEOVER].val;
6196
6197    switch (cpu_mode)
6198    {
6199    case (RECMODE_CPU_OFF):
6200    {
6201        Fighter_SetSlotType(cpu_data->ply, 1);
6202        cpu_data->pad_index = stc_cpu_controller;
6203        CPUThink(event, hmn, cpu);
6204
6205        break;
6206    }
6207    case (RECMODE_CPU_PLAYBACK):
6208    {
6209        if (takeover_input && takeover_target == TAKEOVER_CPU)
6210            stc_playback_cancelled_cpu = true;
6211        
6212        if (takeover_target != TAKEOVER_CPU && !stc_playback_cancelled_cpu) {
6213            switch (LabOptions_Record[OPTREC_PLAYBACK_COUNTER].val) {
6214            case PLAYBACKCOUNTER_OFF:
6215                break;
6216            case PLAYBACKCOUNTER_ENDS:
6217                stc_playback_cancelled_cpu |= Record_PastLastInput(1);
6218                break;
6219            case PLAYBACKCOUNTER_ON_HIT_CPU:
6220                if (
6221                    (IsHitlagVictim(cpu) && eventData->cpu_lasthit != cpu_data->dmg.atk_instance_hurtby)
6222                    || CPU_IsGrabbed(cpu, hmn)
6223                ) {
6224                    eventData->cpu_countertimer = 0;
6225                    eventData->cpu_hitnum++;
6226                    eventData->cpu_lasthit = cpu_data->dmg.atk_instance_hurtby;
6227                    eventData->cpu_hitkind = HITKIND_DAMAGE;
6228                }
6229                
6230                if (eventData->cpu_hitnum != 0) {
6231                    CounterInfo info = GetCounterInfo();
6232                    if (!info.disable) {
6233                        stc_playback_cancelled_cpu = true;
6234                        eventData->cpu_state = CPUSTATE_COUNTER;
6235                    } else if (!InHitstunAnim(cpu_data->state_id) || HitstunEnded(cpu)) {
6236                        eventData->cpu_countertimer++;
6237                    }
6238                }
6239                
6240                break;
6241            case PLAYBACKCOUNTER_ON_HIT_HMN:
6242                stc_playback_cancelled_cpu |= IsHitlagVictim(hmn);
6243                break;
6244            case PLAYBACKCOUNTER_ON_HIT_EITHER:
6245                stc_playback_cancelled_cpu |= IsHitlagVictim(cpu) || IsHitlagVictim(hmn);
6246                break;
6247            }
6248        }
6249
6250        if (!stc_playback_cancelled_cpu) {
6251            Fighter_SetSlotType(cpu_data->ply, 0);
6252            cpu_data->pad_index = stc_cpu_controller;
6253        } else if (takeover_target == TAKEOVER_CPU) {
6254            Fighter_SetSlotType(cpu_data->ply, 0);
6255            cpu_data->pad_index = stc_hmn_controller;
6256            cpu_control = true;
6257        } else {
6258            Fighter_SetSlotType(cpu_data->ply, 1);
6259            cpu_data->pad_index = stc_cpu_controller;
6260            CPUThink(event, hmn, cpu);
6261        }
6262
6263        break;
6264    }
6265    case (RECMODE_CPU_CONTROL):
6266    case (RECMODE_CPU_RECORD):
6267    {
6268        cpu_control = true;
6269
6270        Fighter_SetSlotType(cpu_data->ply, 0);
6271        cpu_data->pad_index = stc_hmn_controller;
6272
6273        break;
6274    }
6275    case (RECMODE_CPU_RERECORD):
6276    {
6277        cpu_control = true;
6278        
6279        Fighter_SetSlotType(cpu_data->ply, 0);
6280        cpu_data->pad_index = stc_hmn_controller;
6281
6282        if (takeover_input && takeover_target == TAKEOVER_CPU)
6283            stc_playback_cancelled_cpu = true;
6284        
6285        break;
6286    }
6287    }
6288
6289    if (!cpu_control) {
6290        if ((hmn_mode == RECMODE_HMN_PLAYBACK || hmn_mode == RECMODE_HMN_RERECORD)
6291            && (Record_PastLastInput(0) || (takeover_input && takeover_target == TAKEOVER_HMN))) {
6292            stc_playback_cancelled_hmn = true;
6293        }
6294
6295        if (stc_playback_cancelled_hmn || hmn_mode != RECMODE_HMN_PLAYBACK)
6296            hmn_data->pad_index = stc_hmn_controller;
6297        else
6298            hmn_data->pad_index = stc_null_controller;
6299    } else {
6300        hmn_data->pad_index = stc_null_controller;
6301    }
6302
6303    for (int i = 0; i < REC_SLOTS; i++) {
6304        int slot_menu_idx = OPTSLOTCHANCE_1 + i;
6305
6306        // if slot newly created
6307
6308        if (rec_data.hmn_inputs[i]->num != 0 && LabOptions_SlotChancesHMN[slot_menu_idx].disable) {
6309            s16 *chances[REC_SLOTS];
6310            int chance_count = EnabledSlotChances(LabOptions_SlotChancesHMN, chances);
6311
6312            LabOptions_SlotChancesHMN[slot_menu_idx].disable = 0;
6313            if (chance_count) {
6314                LabOptions_SlotChancesHMN[slot_menu_idx].val = 100 / chance_count;
6315                chances[chance_count++] = &LabOptions_SlotChancesHMN[slot_menu_idx].val;
6316                DistributeChances(chances, chance_count);
6317            } else {
6318                LabOptions_SlotChancesHMN[slot_menu_idx].val = 100;
6319            }
6320        }
6321
6322        if (rec_data.cpu_inputs[i]->num != 0 && LabOptions_SlotChancesCPU[slot_menu_idx].disable) {
6323            s16 *chances[REC_SLOTS];
6324            int chance_count = EnabledSlotChances(LabOptions_SlotChancesCPU, chances);
6325
6326            LabOptions_SlotChancesCPU[slot_menu_idx].disable = 0;
6327            if (chance_count) {
6328                LabOptions_SlotChancesCPU[slot_menu_idx].val = 100 / chance_count;
6329                chances[chance_count++] = &LabOptions_SlotChancesCPU[slot_menu_idx].val;
6330                DistributeChances(chances, chance_count);
6331            } else {
6332                LabOptions_SlotChancesCPU[slot_menu_idx].val = 100;
6333            }
6334        }
6335    }
6336}
6337
6338// Think Function
6339void Event_Think(GOBJ *event)
6340{
6341    // Save a minor state at event start, so people can reset if they SD.
6342    // This cannot be done in Event_Init, so we do it here.
6343    if (!event_vars->savestate->is_exist) {
6344        event_vars->Savestate_Save_v1(event_vars->savestate, Savestate_Silent);
6345        event_vars->savestate_saved_while_mirrored = event_vars->loaded_mirrored;
6346    }
6347    
6348    LabData *eventData = event->userdata;
6349
6350    Lab_CustomOSDsThink();
6351
6352    // get fighter data
6353    GOBJ *hmn = Fighter_GetGObj(0);
6354    FighterData *hmn_data = hmn->userdata;
6355    GOBJ *cpu = Fighter_GetGObj(1);
6356    FighterData *cpu_data = cpu->userdata;
6357    HSD_Pad *pad = PadGetEngine(hmn_data->pad_index);
6358    
6359    // We allow negative values to track how long we have not been in lockout for.
6360    // If the CPU is in hitlag, do not finish the lockout. This prevents insta techs
6361    // when the tech windows is the 1f between hitlag and knockdown.
6362    if (cpu_data->flags.hitlag == 0 || eventData->cpu_tech_lockout > 2)
6363        eventData->cpu_tech_lockout--;
6364
6365    // Disable the D-pad up button according to the OPTGEN_TAUNT value
6366    if (LabOptions_General[OPTGEN_TAUNT].val == 1)
6367    {
6368      pad->held &= ~PAD_BUTTON_DPAD_UP;
6369    }
6370
6371    // lock percent if enabled
6372    if (LabOptions_CPU[OPTCPU_LOCKPCNT].val)
6373    {
6374        cpu_data->dmg.percent = cpu_locked_percent;
6375        Fighter_SetHUDDamage(1, cpu_locked_percent);
6376    }
6377
6378    if (LabOptions_General[OPTGEN_HMNPCNTLOCK].val)
6379    {
6380        hmn_data->dmg.percent = hmn_locked_percent;
6381        Fighter_SetHUDDamage(0, hmn_locked_percent);
6382    }        
6383
6384    // update menu's percent
6385    LabOptions_General[OPTGEN_HMNPCNT].val = hmn_data->dmg.percent;
6386    LabOptions_CPU[OPTCPU_PCNT].val = cpu_data->dmg.percent;
6387    
6388    // reset stale moves
6389    if (LabOptions_General[OPTGEN_STALE].val == 0)
6390    {
6391        for (int i = 0; i < 6; i++)
6392        {
6393            // check if fighter exists
6394            GOBJ *fighter = Fighter_GetGObj(i);
6395            if (fighter != 0)
6396            {
6397                // reset stale move table
6398                int *staleMoveTable = Fighter_GetStaleMoveTable(i);
6399                memset(staleMoveTable, 0, 0x2C);
6400            }
6401        }
6402    }
6403
6404    // apply intangibility
6405    if (LabOptions_CPU[OPTCPU_INTANG].val == 1)
6406    {
6407        cpu_data->flags.no_reaction_always = 1;
6408        cpu_data->flags.nudge_disable = 1;
6409        cpu_data->grab.vuln = 0x1FF;
6410        cpu_data->dmg.percent = 0;
6411        Fighter_SetHUDDamage(cpu_data->ply, 0);
6412
6413        // if new state, apply colanim
6414        if (cpu_data->TM.state_frame <= 1)
6415        {
6416            Fighter_ColAnim_Apply(cpu_data, INTANG_COLANIM, 0);
6417        }
6418    }
6419    else
6420    {
6421        cpu_data->flags.no_reaction_always = 0;
6422        cpu_data->flags.nudge_disable = 0;
6423    }
6424
6425    // apply invisibility
6426    int invisible = LabOptions_Tech[OPTTECH_INVISIBLE].val;
6427    if (invisible) {
6428        if (IsTechAnim(cpu_data->state_id))
6429        {
6430            // get distinguishable frame from lookup table
6431            u32 char_id = cpu_data->kind;
6432            if (char_id >= countof(tech_frame_distinguishable))
6433                assert("invalid character kind causing read out of bounds");
6434
6435            int frame_distinguishable = tech_frame_distinguishable[char_id];
6436
6437            // apply if tech anim is after distinguishable frame and invulnerable
6438            if (frame_distinguishable != -1) {
6439                // state frame is 0-indexed but frame distinguishable is 1-indexed, so add 1
6440                int state_frame = cpu_data->TM.state_frame + 1;
6441                int delay = LabOptions_Tech[OPTTECH_INVISIBLE_DELAY].val;
6442                int after = state_frame > frame_distinguishable + delay;
6443                cpu_data->flags.invisible = after && state_frame < 20;
6444
6445                int sound = LabOptions_Tech[OPTTECH_SOUND].val;
6446                if (sound && state_frame == frame_distinguishable)
6447                    SFX_PlayCommon(1);
6448            }
6449        }
6450    }
6451
6452    // update shield deterioration
6453    int inf_shield = 0;
6454    switch (LabOptions_CPU[OPTCPU_SHIELD].val)
6455    {
6456        case CPUINFSHIELD_OFF:
6457            break;
6458        case CPUINFSHIELD_UNTIL_HIT:
6459            inf_shield = eventData->cpu_hitshield == 0;
6460            break;
6461        case CPUINFSHIELD_ON:
6462            inf_shield = 1;
6463            break;
6464    }
6465
6466    if (inf_shield)
6467    {
6468        int health = LabOptions_CPU[OPTCPU_SHIELDHEALTH].val;
6469        for (int i = 0; i < 6; i++)
6470        {
6471            for (int ch = 0; ch < 2; ++ch)
6472            {
6473                GOBJ *fighter = Fighter_GetSubcharGObj(i, ch);
6474                if (fighter == 0) continue;
6475                FighterData *data = fighter->userdata;
6476                data->shield.health = health;
6477            }
6478        }
6479    }
6480    
6481    if (LabOptions_General[OPTGEN_POWERSHIELD].val) {
6482        if (cpu_data->shield_bubble.bone) {
6483            memcpy((u8*)&cpu_data->reflect_bubble, (u8*)&cpu_data->shield_bubble, sizeof(cpu_data->shield_bubble));
6484            cpu_data->flags.reflect_enable = 1;
6485            
6486            cpu_data->reflect_hit = (struct reflect_hit) {
6487                .max_dmg = 10000000,
6488                .dmg_mult = 0.5f,
6489                .is_break = 0,
6490            };
6491        }
6492    }
6493
6494    if (LabOptions_CPU[OPTCPU_SET_POS].OnSelect == Lab_FinishMoveCPU) {
6495        // set CPU position
6496
6497        if (cpu_data->phys.air_state == 0) // if is grounded
6498            Fighter_EnterFall(cpu);
6499
6500        Fighter_KillAllVelocity(cpu);
6501        cpu_data->phys.pos.Y += cpu_data->attr.gravity; // remove small initial gravity delta
6502
6503        HSD_Pad *pad = PadGetMaster(stc_hmn_controller);
6504        cpu_data->phys.pos.X += pad->fstickX * 1.5;
6505        cpu_data->phys.pos.Y += pad->fstickY * 1.5;
6506    } else if (LabOptions_CPU[OPTCPU_CTRL_BY].val != CTRLBY_NONE) {
6507        // cpu controlled by another port
6508
6509        int port = LabOptions_CPU[OPTCPU_CTRL_BY].val - CTRLBY_PORT_1;
6510        Fighter_SetSlotType(cpu_data->ply, 0);
6511        cpu_data->pad_index = port;
6512    } else {
6513        // normal cpu
6514
6515        Event_Think_LabState_Normal(event);
6516    }
6517}
6518
6519CounterInfo GetCounterInfo(void) {
6520    LabData *eventData = event_vars->event_gobj->userdata;
6521    CounterInfo info = {0};
6522    
6523    // determine counter logic
6524    EventOption *adv_options = NULL;
6525    int logic = CTRLOGIC_DEFAULT;
6526    
6527    int hitidx = eventData->cpu_hitnum - 1;
6528    if (hitidx < 0) {
6529        hitidx = 0;
6530        OSReport("cpu_hitnum not incremented!");
6531    }
6532    
6533    if (hitidx < ADV_COUNTER_COUNT) {
6534        adv_options = LabOptions_AdvCounter[hitidx];
6535        logic = adv_options[OPTCTR_LOGIC].val;
6536    }
6537    
6538    // get default action
6539    info.counter_delay = LabOptions_CPU[OPTCPU_CTRFRAMES].val;
6540    if (eventData->cpu_hitkind == HITKIND_SHIELD) {
6541        int ctr = LabOptions_CPU[OPTCPU_CTRSHIELD].val;
6542        info.action_id = CPUCounterActionsShield[ctr];
6543    } else if (eventData->cpu_groundstate == 0) {
6544        int ctr = LabOptions_CPU[OPTCPU_CTRGRND].val;
6545        info.action_id = CPUCounterActionsGround[ctr];
6546    } else {
6547        int ctr = LabOptions_CPU[OPTCPU_CTRAIR].val;
6548        info.action_id = CPUCounterActionsAir[ctr];
6549    }
6550    
6551    // find action and delay for this hit
6552    if (info.action_id == CPUACT_RANDOMADV) {
6553        // ignore custom logic
6554    } else if (logic == CTRLOGIC_DEFAULT) {
6555        // do nothing, use default action
6556    } else if (logic == CTRLOGIC_DISABLED) {
6557        info.disable = 1;
6558    } else if (logic == CTRLOGIC_CUSTOM) {
6559        if (eventData->cpu_hitkind == HITKIND_SHIELD) {
6560            info.counter_delay = adv_options[OPTCTR_DELAYSHIELD].val;
6561            int ctr = adv_options[OPTCTR_CTRSHIELD].val;
6562            info.action_id = CPUCounterActionsShield[ctr];
6563        } else if (eventData->cpu_groundstate == 0) {
6564            info.counter_delay = adv_options[OPTCTR_DELAYGRND].val;
6565            int ctr = adv_options[OPTCTR_CTRGRND].val;
6566            info.action_id = CPUCounterActionsGround[ctr];
6567        } else {
6568            info.counter_delay = adv_options[OPTCTR_DELAYAIR].val;
6569            int ctr = adv_options[OPTCTR_CTRAIR].val;
6570            info.action_id = CPUCounterActionsAir[ctr];
6571        }
6572    } else {
6573        assert("invalid counter logic");
6574    }
6575    
6576    if (eventData->cpu_countertimer < info.counter_delay)
6577        info.disable = 1;
6578
6579    return info;
6580}
6581
6582// Initial Menu
6583EventMenu *Event_Menu = &LabMenu_Main;
6584
6585// helper fns ######################################################
6586
6587static int IsTechAnim(int state) {
6588    return state == ASID_PASSIVE || state == ASID_PASSIVESTANDF || state == ASID_PASSIVESTANDB;
6589}
6590
6591// Clean up percentages so the total is 100, evenly distributing the change.
6592static void DistributeChances(s16 *chances[], unsigned int chance_count) {
6593    if (chance_count == 0) return;
6594
6595    int sum = 0;
6596    for (u32 t = 0; t < chance_count; ++t)
6597        sum += *chances[t];
6598
6599    int delta = 100 - sum;
6600    int change;
6601    if (sum > 100) { change = -1; } else { change = 1; }
6602
6603    // Aitch: We could always start on the first chance, but when adding a new slot we should distribute starting
6604    // on the largest (if decreasing) or smallest (if increasing) option.
6605    // This fixes percents when rounding: for example, three options will have chances 33, 33, and 34.
6606    // When we add a new event to this, if we always start on the first option,
6607    // then the resulting percents will be 24, 25, 25, 26.
6608    // When we start on the largest/smallest option then they will all be 25 as expected.
6609    int option = 0;
6610    int min = 999;
6611    for (u32 t = 0; t < chance_count; ++t) {
6612        int check = (int)*chances[t] * change;
6613        if (check < min) {
6614            min = check;
6615            option = t;
6616        }
6617    }
6618
6619    // Keep adding/removing from next option until all needed change to revert to 100% is applied.
6620    // Algorithm is pretty garbage, but it should be quick enough.
6621    while (delta)
6622    {
6623        s16 *opt_val = chances[option];
6624        int prev_chance = (int)*opt_val;
6625        int new_chance = prev_chance + change;
6626
6627        if (0 <= new_chance && new_chance <= 100) {
6628            *opt_val = new_chance;
6629            delta -= change;
6630        }
6631
6632        option = (option + 1) % chance_count;
6633    }
6634}
6635
6636// Clean up percentages so the total is always 100.
6637// The next percentage is modified.
6638static void ReboundChances(s16 *chances[], unsigned int chance_count, int just_changed_option) {
6639    if (chance_count == 0) return;
6640
6641    int sum = 0;
6642    for (u32 t = 0; t < chance_count; ++t)
6643        sum += *chances[t];
6644
6645    int delta = 100 - sum;
6646    // keep adding/removing from next option chance until all needed change to revert to 100% is applied
6647    while (delta)
6648    {
6649        int rebound_option = (just_changed_option + 1) % chance_count;
6650
6651        s16 *opt_val = chances[rebound_option];
6652        int prev_chance = (int)*opt_val;
6653
6654        int new_chance = prev_chance + delta;
6655        if (new_chance < 0) {
6656            *opt_val = 0;
6657            delta = new_chance;
6658        } else if (new_chance > 100) {
6659            *opt_val = 100;
6660            delta = new_chance - 100;
6661        } else {
6662            *opt_val = (u16)new_chance;
6663            delta = 0;
6664        }
6665
6666        just_changed_option = rebound_option;
6667    }
6668}
6669
6670static float GetAngleOutOfDeadzone(float angle, int lastSDIWasCardinal)
6671{
6672    // get out of deadzone if last sdi was cardinal
6673    if (angle > M_1DEGREE * 73.5f || (angle < M_1DEGREE * 106.5f && lastSDIWasCardinal))
6674    {
6675        angle = M_1DEGREE * 73.f;
6676    }
6677    else if (angle > M_1DEGREE * 163.5f || (angle < M_1DEGREE * 196.5f && lastSDIWasCardinal))
6678    {
6679        angle = M_1DEGREE * 163.f;
6680    }
6681    else if (angle > M_1DEGREE * 253.5f || (angle < M_1DEGREE * 296.5f && lastSDIWasCardinal))
6682    {
6683        angle = M_1DEGREE * 253.f;
6684    }
6685    else if (angle > M_1DEGREE * 343.5f || (angle < M_1DEGREE * 16.5f && lastSDIWasCardinal))
6686    {
6687        angle = M_1DEGREE * 343.f;
6688    }
6689    return angle;
6690}
6691
6692static int pow_n(int x, int n)
6693{
6694    int res = 1;
6695    for (; n; n--)
6696        res *= x;
6697    return res;
6698}
6699
6700// lz77 functions credited to https://github.com/andyherbert/lz1
6701static u32 lz77Compress(u8 *uncompressed_text, u32 uncompressed_size, u8 *compressed_text, u8 pointer_length_width)
6702{
6703    u16 pointer_pos, temp_pointer_pos, output_pointer, pointer_length, temp_pointer_length;
6704    u32 compressed_pointer, output_size, coding_pos, output_lookahead_ref, look_behind, look_ahead;
6705    u16 pointer_pos_max, pointer_length_max;
6706    pointer_pos_max = pow_n(2, 16 - pointer_length_width);
6707    pointer_length_max = pow_n(2, pointer_length_width);
6708
6709    *((u32 *)compressed_text) = uncompressed_size;
6710    *(compressed_text + 4) = pointer_length_width;
6711    compressed_pointer = output_size = 5;
6712
6713    for (coding_pos = 0; coding_pos < uncompressed_size; ++coding_pos)
6714    {
6715        pointer_pos = 0;
6716        pointer_length = 0;
6717        for (temp_pointer_pos = 1; (temp_pointer_pos < pointer_pos_max) && (temp_pointer_pos <= coding_pos); ++temp_pointer_pos)
6718        {
6719            look_behind = coding_pos - temp_pointer_pos;
6720            look_ahead = coding_pos;
6721            for (temp_pointer_length = 0; uncompressed_text[look_ahead++] == uncompressed_text[look_behind++]; ++temp_pointer_length)
6722                if (temp_pointer_length == pointer_length_max)
6723                    break;
6724            if (temp_pointer_length > pointer_length)
6725            {
6726                pointer_pos = temp_pointer_pos;
6727                pointer_length = temp_pointer_length;
6728                if (pointer_length == pointer_length_max)
6729                    break;
6730            }
6731        }
6732        coding_pos += pointer_length;
6733        if ((coding_pos == uncompressed_size) && pointer_length)
6734        {
6735            output_pointer = (pointer_length == 1) ? 0 : ((pointer_pos << pointer_length_width) | (pointer_length - 2));
6736            output_lookahead_ref = coding_pos - 1;
6737        }
6738        else
6739        {
6740            output_pointer = (pointer_pos << pointer_length_width) | (pointer_length ? (pointer_length - 1) : 0);
6741            output_lookahead_ref = coding_pos;
6742        }
6743        *((u16 *)(compressed_text + compressed_pointer)) = output_pointer;
6744        compressed_pointer += 2;
6745        *(compressed_text + compressed_pointer++) = *(uncompressed_text + output_lookahead_ref);
6746        output_size += 3;
6747    }
6748
6749    return output_size;
6750}
6751
6752static u32 lz77Decompress(u8 *compressed_text, u8 *uncompressed_text)
6753{
6754    u8 pointer_length_width;
6755    u16 input_pointer, pointer_length, pointer_pos, pointer_length_mask;
6756    u32 compressed_pointer, coding_pos, pointer_offset, uncompressed_size;
6757
6758    uncompressed_size = *((u32 *)compressed_text);
6759    pointer_length_width = *(compressed_text + 4);
6760    compressed_pointer = 5;
6761
6762    pointer_length_mask = pow_n(2, pointer_length_width) - 1;
6763
6764    for (coding_pos = 0; coding_pos < uncompressed_size; ++coding_pos)
6765    {
6766        input_pointer = *((u16 *)(compressed_text + compressed_pointer));
6767        compressed_pointer += 2;
6768        pointer_pos = input_pointer >> pointer_length_width;
6769        pointer_length = pointer_pos ? ((input_pointer & pointer_length_mask) + 1) : 0;
6770        if (pointer_pos)
6771            for (pointer_offset = coding_pos - pointer_pos; pointer_length > 0; --pointer_length)
6772                uncompressed_text[coding_pos++] = uncompressed_text[pointer_offset++];
6773        *(uncompressed_text + coding_pos) = *(compressed_text + compressed_pointer++);
6774    }
6775
6776    return coding_pos;
6777}
6778
6779// adapted from decomp github.com/doldecomp/melee/blob/7f0e2ddb83fa974b64b05d0a7e5b374cf12c0541/src/melee/ft/ftwalljump.c
6780static bool CanWalljump(GOBJ* fighter) {
6781    FighterData *fighter_data = fighter->userdata;
6782    CollData* coll_data = &fighter_data->coll_data;
6783
6784    return fighter_data->flags.can_walljump && (coll_data->envFlags & ((1u << 11) | (1u << 5))) != 0;
6785}
6786
6787static bool CheckHasJump(GOBJ *g) {
6788    FighterData *data = g->userdata;
6789    int max_jumps = data->attr.max_jumps;
6790    int jumps_used = data->jump.jumps_used;
6791
6792    return jumps_used < max_jumps;
6793}