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