fork/training-mode-ce
git clone https://git.julia.blue/fork/training-mode-ce
edda55f
nix
1#include "ledgedash.h" 2 3static GXColor tmgbar_black = {40 ,40 ,40 ,255 }; 4static GXColor tmgbar_grey = {120 ,120 ,120 ,255 }; 5static GXColor tmgbar_blue = {128 ,128 ,255 ,255 }; 6static GXColor tmgbar_green = {128 ,255 ,128 ,255 }; 7static GXColor tmgbar_cyan = {52 ,202 ,228 ,255 }; 8static GXColor tmgbar_red = {255 ,128 ,128 ,255 }; 9static GXColor tmgbar_magenta = {230 ,22 ,198 ,255 }; 10static GXColor tmgbar_white = {255 ,255 ,255 ,255 }; 11static GXColor * tmgbar_colors []= { 12& tmgbar_black , 13& tmgbar_grey , 14& tmgbar_green , 15& tmgbar_cyan , 16& tmgbar_magenta , 17& tmgbar_white , 18& tmgbar_red , 19& tmgbar_blue , 20}; 21 22enum menu_options 23{ 24OPT_POS , 25OPT_RESET , 26OPT_HUD , 27OPT_TIPS , 28OPT_CAM , 29OPT_INV , 30OPT_SPEED , 31OPT_OVERLAYS , 32OPT_RESETDELAY , 33OPT_ABOUT , 34OPT_EXIT , 35}; 36 37enum reset_mode 38{ 39OPTRESET_NONE , 40OPTRESET_SAME_SIDE , 41OPTRESET_SWAP , 42OPTRESET_SWAP_ON_SUCCESS , 43OPTRESET_RANDOM , 44}; 45 46enum reset_pos 47{ 48OPTPOS_LEDGE , 49OPTPOS_FALLING , 50OPTPOS_STAGE , 51OPTPOS_RESPAWNPLAT , 52OPTPOS_RANDOM ,// Must be last 53}; 54 55// Main Menu 56static const char * LdshOptions_CamMode []= {"Normal" ,"Zoom" ,"Fixed" ,"Advanced" }; 57static const char * LdshOptions_Start []= {"Ledge" ,"Falling" ,"Stage" ,"Respawn Platform" ,"Random" }; 58static float LdshOptions_GameSpeeds []= {1.f ,5.f /6.f ,2.f /3.f ,1.f /2.f ,1.f /4.f }; 59static const char * LdshOptions_GameSpeedText []= {"1" ,"5/6" ,"2/3" ,"1/2" ,"1/4" }; 60static const char * LdshOptions_Reset []= {"None" ,"Same Side" ,"Swap" ,"Swap on Success" ,"Random" }; 61static const char * LdshOptions_ResetDelay []= {"Slow" ,"Normal" ,"Fast" ,"Instant" }; 62static int LdshOptions_ResetDelaySuccess []= {120 ,60 ,30 ,1 }; 63static int LdshOptions_ResetDelayFailure []= {60 ,20 ,1 ,1 }; 64 65static EventOption LdshOptions_Main []= { 66 { 67 .kind = OPTKIND_STRING , 68 .value_num = sizeof (LdshOptions_Start ) /4 , 69 .name = "Starting Position" , 70 .desc = {"Choose where the fighter is placed " , 71"after resetting positions." }, 72 .values = LdshOptions_Start , 73 .OnChange = Ledgedash_ToggleStartPosition , 74 }, 75 { 76 .kind = OPTKIND_STRING , 77 .value_num = sizeof (LdshOptions_Reset ) /4 , 78 .val = OPTRESET_SAME_SIDE , 79 .name = "Reset" , 80 .desc = {"Change where the fighter gets placed" , 81"after a ledgedash attempt." }, 82 .values = LdshOptions_Reset , 83 }, 84 { 85 .kind = OPTKIND_TOGGLE , 86 .name = "HUD" , 87 .desc = {"Toggle visibility of the HUD." }, 88 .val = 1 , 89 .OnChange = Ledgedash_ChangeShowHUD , 90 }, 91 { 92 .kind = OPTKIND_TOGGLE , 93 .name = "Tips" , 94 .desc = {"Toggle the onscreen display of tips." }, 95 .val = 1 , 96 .OnChange = Tips_Toggle , 97 }, 98 { 99 .kind = OPTKIND_STRING , 100 .value_num = sizeof (LdshOptions_CamMode ) /4 , 101 .name = "Camera Mode" , 102 .desc = {"Adjust the camera's behavior." , 103"In advanced mode, use C-Stick while holding" , 104"A/B/Y to pan, rotate and zoom, respectively." }, 105 .values = LdshOptions_CamMode , 106 .OnChange = Ledgedash_ChangeCamMode , 107 }, 108 { 109 .kind = OPTKIND_TOGGLE , 110 .name = "Keep Ledge Invincibility" , 111 .desc = {"Keep maximum invincibility while on the ledge" , 112"to practice the ledgedash inputs." }, 113 }, 114 { 115 .kind = OPTKIND_STRING , 116 .value_num = sizeof (LdshOptions_GameSpeedText ) / 117sizeof (* LdshOptions_GameSpeedText ), 118 .name = "Game Speed" , 119 .desc = {"Change how fast the game engine runs." }, 120 .values = LdshOptions_GameSpeedText , 121 }, 122 { 123 .kind = OPTKIND_TOGGLE , 124 .name = "Color Overlays" , 125 .desc = {"Show which state you are in with a color overlay." }, 126 }, 127 { 128 .kind = OPTKIND_STRING , 129 .value_num = 130sizeof (LdshOptions_ResetDelay ) /sizeof (* LdshOptions_ResetDelay ), 131 .val = 1 , 132 .name = "Reset Delay" , 133 .desc = {"Change how quickly you can start a new ledgedash." }, 134 .values = LdshOptions_ResetDelay , 135 }, 136 { 137 .kind = OPTKIND_INFO , 138 .name = "HELP" , 139 .desc = 140 {"Ledgedashing is the act of wavedashing onto stage from ledge." , 141"This is most commonly done by dropping off ledge, double jumping " , 142"immediately, and quickly airdodging onto stage. Each input" , 143"is performed quickly after the last, making it difficult and risky." }, 144 }, 145 { 146 .kind = OPTKIND_FUNC , 147 .name = "Exit" , 148 .desc = {"Return to the Event Selection Screen." }, 149 .OnSelect = Event_Exit , 150 }, 151}; 152 153static EventOption Ldsh_FrameAdvance = { 154 .kind = OPTKIND_TOGGLE , 155 .name = "Frame Advance" , 156 .desc = {"Enable frame advance. Press to advance one" , 157"frame. Hold to advance at normal speed." }, 158}; 159 160static Shortcut Ldsh_Shortcuts []= { 161 { 162 .button_mask = HSD_BUTTON_A , 163 .option = & Ldsh_FrameAdvance , 164 } 165}; 166 167static ShortcutList Ldsh_ShortcutList = { 168 .count = countof (Ldsh_Shortcuts ), 169 .list = Ldsh_Shortcuts , 170}; 171 172static EventMenu LdshMenu_Main = { 173 .name = "Ledgedash Training" , 174 .option_num = sizeof (LdshOptions_Main ) /sizeof (EventOption ), 175 .options = LdshOptions_Main , 176 .shortcuts = & Ldsh_ShortcutList , 177}; 178 179// Init Function 180void Event_Init (GOBJ * gobj ) 181{ 182LedgedashData * event_data = gobj -> userdata ; 183 184// get assets 185event_data -> assets = Archive_GetPublicAddress (event_vars -> event_archive ,"ledgedash" ); 186 187HSD_Update * hsd_update = stc_hsd_update ; 188hsd_update -> checkPause = Update_CheckPause ; 189hsd_update -> checkAdvance = Update_CheckAdvance ; 190 191// standardize camera 192float * unk_cam = (void * )0x803bcca0 ; 193stc_stage -> fov_r = 0 ;// no camera rotation 194stc_stage -> x28 = 1 ;// pan value? 195stc_stage -> x2c = 1 ;// pan value? 196stc_stage -> x30 = 1 ;// pan value? 197stc_stage -> x34 = 130 ;// zoom out 198unk_cam [0x40 /4 ]= 30 ; 199 200// Init hitlog 201event_data -> hitlog_gobj = Ledgedash_HitLogInit (); 202 203// Init HUD 204Ledgedash_HUDInit (event_data ); 205 206// Init Fighter 207Ledgedash_FtInit (event_data ); 208 209Fighter_PlaceOnLedge (); 210} 211// Think Function 212void Event_Think (GOBJ * event ) 213{ 214LedgedashData * event_data = event -> userdata ; 215 216// get fighter data 217GOBJ * hmn = Fighter_GetGObj (0 ); 218FighterData * hmn_data = hmn -> userdata ; 219 220// no ledgefall 221FtCliffCatch * ft_state = (void * )& hmn_data -> state_var ; 222if (hmn_data -> state_id == ASID_CLIFFWAIT ) 223ft_state -> fall_timer = 2 ; 224 225if (LdshOptions_Main [OPT_INV ].val == 1 ) { 226if (hmn_data -> state_id == ASID_CLIFFWAIT ) { 227hmn_data -> hurt .intang_frames .ledge = 30 ; 228hmn_data -> TM .state_frame = 1 ; 229 } 230 } 231 232if (hmn_data -> input .down & HSD_BUTTON_DPAD_LEFT ) { 233event_data -> ledge = -1 ; 234Fighter_PlaceOnLedge (); 235 }else if (hmn_data -> input .down & HSD_BUTTON_DPAD_RIGHT ) { 236event_data -> ledge = 1 ; 237Fighter_PlaceOnLedge (); 238 } 239 240Ledgedash_ResetThink (event_data ,hmn ); 241Ledgedash_HUDThink (event_data ,hmn_data ); 242Ledgedash_HitLogThink (event_data ,hmn ); 243 244if (LdshOptions_Main [OPT_OVERLAYS ].val == 1 ) { 245memset (& hmn_data -> color [1 ],0 ,sizeof (ColorOverlay )); 246memset (& hmn_data -> color [0 ],0 ,sizeof (ColorOverlay )); 247 248u32 curr_frame = event_data -> action_state .timer - 1 ; 249if (curr_frame < 30 ) { 250int action = event_data -> action_state .action_log [curr_frame ]; 251 252GXColor color ; 253if (action == LDACT_NONE ) { 254if (hmn_data -> hurt .intang_frames .ledge != 0 ) { 255color = tmgbar_blue ; 256color .a = 180 ; 257 }else { 258color = (GXColor ) {0 ,0 ,0 ,0 }; 259 } 260 }else { 261color = * tmgbar_colors [action ]; 262color .a = 180 ; 263 } 264 265hmn_data -> color [1 ].hex = color ; 266hmn_data -> color [1 ].color_enable = 1 ; 267 } 268 } 269} 270void Event_Exit (GOBJ * menu ) 271{ 272// end game 273stc_match -> state = 3 ; 274 275// cleanup 276Match_EndVS (); 277} 278 279// Ledgedash functions 280void Ledgedash_HUDInit (LedgedashData * event_data ) 281{ 282GOBJ * hud_gobj = GObj_Create (0 ,0 ,0 ); 283event_data -> hud .gobj = hud_gobj ; 284// Load jobj 285JOBJ * hud_jobj = JOBJ_LoadJoint (event_data -> assets -> hud ); 286GObj_AddObject (hud_gobj ,3 ,hud_jobj ); 287GObj_AddGXLink (hud_gobj ,GXLink_Common ,GXLINK_HUD ,80 ); 288 289// create text canvas 290int canvas = Text_CreateCanvas (2 ,hud_gobj ,14 ,15 ,0 ,GXLINK_HUD ,81 ,19 ); 291event_data -> hud .canvas = canvas ; 292 293// init text 294Text ** text_arr = & event_data -> hud .text_angle ; 295for (int i = 0 ;i < 3 ;i ++ ) 296 { 297// Create text object 298Text * hud_text = Text_CreateText (2 ,canvas ); 299text_arr [i ]= hud_text ; 300hud_text -> kerning = 1 ; 301hud_text -> align = 1 ; 302hud_text -> use_aspect = 1 ; 303 304// Get position 305Vec3 text_pos ; 306JOBJ * text_jobj ; 307JOBJ_GetChild (hud_jobj ,& text_jobj ,2 + i ,-1 ); 308JOBJ_GetWorldPosition (text_jobj ,0 ,& text_pos ); 309 310// adjust scale 311Vec3 * scale = & hud_jobj -> scale ; 312// text scale 313hud_text -> viewport_scale .X = (scale -> X * 0.01 )* LCLTEXT_SCALE ; 314hud_text -> viewport_scale .Y = (scale -> Y * 0.01 )* LCLTEXT_SCALE ; 315hud_text -> aspect .X = 165 ; 316 317// text position 318hud_text -> trans .X = text_pos .X + (scale -> X /4.0 ); 319hud_text -> trans .Y = (text_pos .Y * -1 )+ (scale -> Y /4.0 ); 320 321// dummy text 322Text_AddSubtext (hud_text ,0 ,0 ,"-" ); 323 } 324} 325void Ledgedash_HUDThink (LedgedashData * event_data ,FighterData * hmn_data ) 326{ 327// run tip logic 328Tips_Think (event_data ,hmn_data ); 329 330JOBJ * hud_jobj = event_data -> hud .gobj -> hsd_object ; 331 332// check to initialize timer 333if ((hmn_data -> state_id == ASID_CLIFFWAIT )&& (hmn_data -> TM .state_frame == 1 )) 334 { 335Ledgedash_InitVariables (event_data ); 336 337event_data -> tip .refresh_num ++ ; 338 } 339 340u32 curr_frame = event_data -> action_state .timer ++ ; 341int hud_updating = 342curr_frame < countof (event_data -> action_state .action_log ) 343&& hmn_data -> hurt .intang_frames .ledge != 0 ; 344 345if (hud_updating ) { 346int state_id = hmn_data -> state_id ; 347int action = LDACT_GALINT ; 348 349// look for cliffwait 350if (state_id == ASID_CLIFFWAIT ) 351action = LDACT_CLIFFWAIT ; 352 353// look for release 354else if (state_id == ASID_FALL ) 355action = LDACT_FALL ; 356 357// look for jump 358else if ( 359state_id == ASID_JUMPAERIALF 360|| state_id == ASID_JUMPAERIALB 361// check for kirby and jiggs jump 362|| ((hmn_data -> kind == 4 || hmn_data -> kind == 15 )&& (state_id >=341 && state_id <=345 ))) 363action = LDACT_JUMP ; 364 365// look for airdodge 366else if (state_id == ASID_ESCAPEAIR ) 367action = LDACT_AIRDODGE ; 368 369// look for attack 370else if (hmn_data -> atk_kind != 1 || state_id == ASID_CATCH || state_id == ASID_CATCHDASH ) 371action = LDACT_ATTACK ; 372 373// look for landing 374else if ( 375 (state_id == ASID_LANDING && hmn_data -> TM .state_frame < hmn_data -> attr .normal_landing_lag ) 376|| state_id == ASID_LANDINGFALLSPECIAL 377 ) 378action = LDACT_LANDING ; 379 380// look for ledge options 381else if (ASID_CLIFFCLIMBSLOW <=state_id && state_id <=ASID_CLIFFJUMPQUICK2 ) 382action = LDACT_NONE ; 383 384event_data -> action_state .action_log [curr_frame ]= action ; 385 } 386 387// grab airdodge angle 388if (event_data -> action_state .is_airdodge == 0 ) 389 { 390if ((hmn_data -> state_id == ASID_ESCAPEAIR )|| (hmn_data -> TM .state_prev [0 ]== ASID_ESCAPEAIR )) 391 { 392// determine airdodge angle 393float angle = atan2 (fabs (hmn_data -> input .lstick .Y ),fabs (hmn_data -> input .lstick .X )); 394 395// save airdodge angle 396event_data -> hud .airdodge_angle = angle ; 397event_data -> action_state .is_airdodge = 1 ; 398 } 399 } 400 401if (hmn_data -> state_id == ASID_CLIFFWAIT ) 402event_data -> action_state .is_ledgegrab = 1 ; 403if (event_data -> action_state .is_ledgegrab && hmn_data -> state_id == ASID_FALL ) 404event_data -> action_state .is_release = 1 ; 405 406int released_ledge = event_data -> action_state .is_release == 1 ; 407int not_finished = event_data -> action_state .is_finished == 0 ; 408int just_finished = false; 409if (not_finished && released_ledge ) { 410// if actionable after normal landing 411just_finished |=hmn_data -> state_id == ASID_LANDING 412&& hmn_data -> TM .state_frame >=hmn_data -> attr .normal_landing_lag ; 413 414// if actionable after normal landing, but performed an action immediately after 415just_finished |=hmn_data -> TM .state_prev [0 ]== ASID_LANDING 416|| hmn_data -> TM .state_prev [1 ]== ASID_LANDING ; 417 418// if actionable after airdodge landing 419just_finished |=hmn_data -> TM .state_prev [0 ]== ASID_LANDINGFALLSPECIAL 420|| hmn_data -> TM .state_prev [1 ]== ASID_LANDINGFALLSPECIAL ; 421 422// if entered wait without entering landing - probably from NIL 423just_finished |=hmn_data -> state_id == ASID_WAIT ; 424 425event_data -> action_state .is_finished |=just_finished ; 426 } 427 428if (just_finished ) { 429// destroy any tips 430event_vars -> Tip_Destroy (); 431 432// output remaining airdodge angle 433if (event_data -> action_state .is_airdodge == 1 ) 434Text_SetText (event_data -> hud .text_angle ,0 ,"%.2f" ,fabs (event_data -> hud .airdodge_angle /M_1DEGREE )); 435else 436Text_SetText (event_data -> hud .text_angle ,0 ,"-" ); 437 438// output remaining GALINT 439void * matanim ; 440Text * text_galint = event_data -> hud .text_galint ; 441if (hmn_data -> hurt .intang_frames .ledge > 0 ) 442 { 443event_data -> hud .successful_count ++ ; 444event_data -> was_successful = true; 445matanim = event_data -> assets -> hudmatanim [0 ]; 446Text_SetText (text_galint ,0 ,"%df" ,hmn_data -> hurt .intang_frames .ledge ); 447 } 448else if (hmn_data -> TM .vuln_frames < 25 ) 449 { 450event_data -> was_successful = false; 451matanim = event_data -> assets -> hudmatanim [1 ]; 452Text_SetText (text_galint ,0 ,"-%df" ,hmn_data -> TM .vuln_frames ); 453 } 454else 455 { 456event_data -> was_successful = false; 457matanim = event_data -> assets -> hudmatanim [1 ]; 458Text_SetText (text_galint ,0 ,"-" ); 459 } 460event_data -> hud .total_count ++ ; 461int success_count = event_data -> hud .successful_count ; 462int total_count = event_data -> hud .total_count ; 463float success_percent = (float )success_count /total_count ; 464Text_SetText (event_data -> hud .text_count ,0 ,"%d/%d (%.1f%%)" ,success_count ,total_count ,success_percent * 100 ); 465 466// init hitbox num 467LdshHitlogData * hitlog_data = event_data -> hitlog_gobj -> userdata ; 468hitlog_data -> num = 0 ; 469 470// apply HUD animation 471JOBJ_RemoveAnimAll (hud_jobj ); 472JOBJ_AddAnimAll (hud_jobj ,0 ,matanim ,0 ); 473JOBJ_ReqAnimAll (hud_jobj ,0 ); 474 } 475} 476 477void Ledgedash_ResetThink (LedgedashData * event_data ,GOBJ * hmn ) 478{ 479FighterData * hmn_data = hmn -> userdata ; 480 481int reset_mode = LdshOptions_Main [OPT_RESET ].val ; 482 483if (reset_mode == OPTRESET_NONE ) 484return ; 485 486if (event_data -> reset_timer > 0 ) { 487event_data -> reset_timer -- ; 488 489if (event_data -> reset_timer > 0 ) 490return ; 491 492int swap = false; 493switch (reset_mode ) { 494case OPTRESET_SAME_SIDE : 495break ; 496case OPTRESET_SWAP : 497swap = true; 498break ; 499case OPTRESET_SWAP_ON_SUCCESS : 500swap = event_data -> was_successful ; 501break ; 502case OPTRESET_RANDOM : 503swap = HSD_Randi (2 ); 504break ; 505 } 506 507if (swap ) 508event_data -> ledge = - event_data -> ledge ; 509 510Fighter_PlaceOnLedge (); 511 }else if (event_data -> action_state .is_finished ) { 512 513int reset_idx = LdshOptions_Main [OPT_RESETDELAY ].val ; 514event_data -> reset_timer = LdshOptions_ResetDelaySuccess [reset_idx ]; 515if (event_data -> was_successful ) 516SFX_Play (303 ); 517else 518SFX_PlayCommon (3 ); 519 }else { 520int state = hmn_data -> state_id ; 521 522bool dead = hmn_data -> flags .dead ; 523bool missed_airdodge = hmn_data -> state_id == ASID_ESCAPEAIR && hmn_data -> TM .state_frame >=9 ; 524bool ledge_action = ASID_CLIFFCLIMBSLOW <=state && state <=ASID_CLIFFJUMPQUICK2 ; 525bool non_landing_grounded = hmn_data -> phys .air_state == 0 526&& event_data -> action_state .is_release 527&& state != ASID_LANDING 528&& state != ASID_LANDINGFALLSPECIAL 529&& state != ASID_REBIRTHWAIT 530&& hmn_data -> TM .state_frame >=12 ; 531 532if (dead || missed_airdodge || ledge_action || non_landing_grounded ) { 533int reset_idx = LdshOptions_Main [OPT_RESETDELAY ].val ; 534event_data -> reset_timer = LdshOptions_ResetDelayFailure [reset_idx ]; 535event_data -> was_successful = false; 536SFX_PlayCommon (3 ); 537 538// update counter hud 539event_data -> hud .total_count ++ ; 540int success_count = event_data -> hud .successful_count ; 541int total_count = event_data -> hud .total_count ; 542float success_percent = (float )success_count /total_count ; 543Text_SetText (event_data -> hud .text_count ,0 ,"%d/%d (%.1f%%)" ,success_count ,total_count ,success_percent * 100 ); 544 } 545 } 546} 547void Ledgedash_InitVariables (LedgedashData * event_data ) 548{ 549event_data -> action_state .timer = 0 ; 550event_data -> action_state .is_ledgegrab = 0 ; 551event_data -> action_state .is_release = 0 ; 552event_data -> action_state .is_airdodge = 0 ; 553event_data -> action_state .is_finished = 0 ; 554 555// init action log 556for (u32 i = 0 ;i < countof (event_data -> action_state .action_log );i ++ ) 557 { 558event_data -> action_state .action_log [i ]= 0 ; 559 } 560} 561 562// Menu Toggle functions 563void Ledgedash_ToggleStartPosition (GOBJ * menu_gobj ,int value ) 564{ 565Fighter_PlaceOnLedge (); 566} 567 568// Hitlog functions 569GOBJ * Ledgedash_HitLogInit (void ) 570{ 571 572GOBJ * hit_gobj = GObj_Create (0 ,0 ,0 ); 573LdshHitlogData * hit_data = calloc (sizeof (LdshHitlogData )); 574GObj_AddUserData (hit_gobj ,4 ,HSD_Free ,hit_data ); 575GObj_AddGXLink (hit_gobj ,Ledgedash_HitLogGX ,5 ,0 ); 576 577// init array 578hit_data -> num = 0 ; 579 580return hit_gobj ; 581} 582void Ledgedash_HitLogThink (LedgedashData * event_data ,GOBJ * hmn ) 583{ 584FighterData * hmn_data = hmn -> userdata ; 585LdshHitlogData * hitlog_data = event_data -> hitlog_gobj -> userdata ; 586 587// log hitboxes 588if (event_data -> action_state .is_finished && hmn_data -> hurt .intang_frames .ledge > 0 ) 589 { 590 591// iterate through fighter hitboxes 592for (u32 i = 0 ;i < countof (hmn_data -> hitbox );i ++ ) 593 { 594 595ftHit * this_hit = & hmn_data -> hitbox [i ]; 596 597if ((this_hit -> active != 0 )&& // if hitbox is active 598 (hitlog_data -> num < LDSH_HITBOXNUM ))// if not over max 599 { 600 601// log info 602LdshHitboxData * this_ldsh_hit = & hitlog_data -> hitlog [hitlog_data -> num ]; 603this_ldsh_hit -> size = this_hit -> size ; 604this_ldsh_hit -> pos_curr = this_hit -> pos ; 605this_ldsh_hit -> pos_prev = this_hit -> pos_prev ; 606this_ldsh_hit -> kind = this_hit -> attribute ; 607 608// increment hitboxes 609hitlog_data -> num ++ ; 610 } 611 } 612 613// iterate through items belonging to fighter 614GOBJ * this_item = (* stc_gobj_lookup )[MATCHPLINK_ITEM ]; 615while (this_item != 0 ) 616 { 617ItemData * this_itemdata = this_item -> userdata ; 618 619// ensure belongs to the fighter 620if (this_itemdata -> fighter_gobj == hmn ) 621 { 622// iterate through item hitboxes 623for (u32 i = 0 ;i < countof (hmn_data -> hitbox );i ++ ) 624 { 625 626itHit * this_hit = & this_itemdata -> hitbox [i ]; 627 628if ((this_hit -> active != 0 )&& // if hitbox is active 629 (hitlog_data -> num < LDSH_HITBOXNUM ))// if not over max 630 { 631 632// log info 633LdshHitboxData * this_ldsh_hit = & hitlog_data -> hitlog [hitlog_data -> num ]; 634this_ldsh_hit -> size = this_hit -> size ; 635this_ldsh_hit -> pos_curr = this_hit -> pos ; 636this_ldsh_hit -> pos_prev = this_hit -> pos_prev ; 637this_ldsh_hit -> kind = this_hit -> attribute ; 638 639// increment hitboxes 640hitlog_data -> num ++ ; 641 } 642 } 643 } 644 645this_item = this_item -> next ; 646 } 647 } 648} 649 650void Ledgedash_HitLogGX (GOBJ * gobj ,int pass ) 651{ 652static GXColor hitlog_ambient = {128 ,0 ,0 ,50 }; 653static GXColor hit_diffuse = {255 ,99 ,99 ,50 }; 654static GXColor grab_diffuse = {255 ,0 ,255 ,50 }; 655static GXColor detect_diffuse = {255 ,255 ,255 ,50 }; 656 657LdshHitlogData * hitlog_data = gobj -> userdata ; 658 659if (pass == 2 ) { 660LedgedashData * event_data = event_vars -> event_gobj -> userdata ; 661static GXColor colors []= { 662 {40 ,40 ,40 ,180 }, 663 {120 ,120 ,120 ,180 }, 664 {128 ,255 ,128 ,180 }, 665 {52 ,202 ,228 ,180 }, 666 {230 ,22 ,198 ,180 }, 667 {255 ,255 ,255 ,180 }, 668 {255 ,128 ,128 ,180 }, 669 {128 ,128 ,255 ,180 }, 670 }; 671static char * names []= { 672"Cliffwait" , 673"Fall" , 674"Jump" , 675"Airdodge" , 676"Attack" , 677"Landing" , 678"GALINT" , 679 }; 680event_vars -> HUD_DrawActionLogBar ( 681event_data -> action_state .action_log , 682colors , 683countof (event_data -> action_state .action_log ) 684 ); 685event_vars -> HUD_DrawActionLogKey ( 686names , 687& colors [1 ], 688countof (names ) 689 ); 690 } 691 692for (int i = 0 ;i < hitlog_data -> num ;i ++ ) 693 { 694LdshHitboxData * this_ldsh_hit = & hitlog_data -> hitlog [i ]; 695 696// determine color 697GXColor * diffuse ; 698if (this_ldsh_hit -> kind == 0 ) 699diffuse = & hit_diffuse ; 700else if (this_ldsh_hit -> kind == 8 ) 701diffuse = & grab_diffuse ; 702else if (this_ldsh_hit -> kind == 11 ) 703diffuse = & detect_diffuse ; 704else 705diffuse = & hit_diffuse ; 706 707Develop_DrawSphere (this_ldsh_hit -> size ,& this_ldsh_hit -> pos_curr ,& this_ldsh_hit -> pos_prev ,diffuse ,& hitlog_ambient ); 708 } 709} 710 711// Fighter fuctions 712void Ledgedash_FtInit (LedgedashData * event_data ) 713{ 714// create camera box 715CmSubject * cam = CameraSubject_Alloc (); 716cam -> boundleft_proj = -10 ; 717cam -> boundright_proj = 10 ; 718cam -> boundtop_proj = 10 ; 719cam -> boundbottom_proj = -10 ; 720cam -> boundleft_curr = cam -> boundleft_proj ; 721cam -> boundright_curr = cam -> boundright_proj ; 722cam -> boundtop_curr = cam -> boundtop_proj ; 723cam -> boundbottom_curr = cam -> boundbottom_proj ; 724event_data -> cam = cam ; 725event_data -> was_successful = false; 726event_data -> reset_timer = 0 ; 727event_data -> ledge = -1 ;// start on left ledge 728 729//if (event_vars->ledge_l == -1 || event_vars->ledge_r == -1) { 730// event_data->cam->is_disable = 0; 731// event_vars->Tip_Display(500 * 60, "Error:\nIt appears there are no\ngood ledges on this stage..."); 732//} 733} 734 735void Ledgedash_ChangeShowHUD (GOBJ * menu_gobj ,int show ) { 736HUDCamData * cam = event_vars -> hudcam_gobj -> userdata ; 737cam -> hide = !show ; 738} 739 740void Ledgedash_ChangeCamMode (GOBJ * menu_gobj ,int value ) 741{ 742MatchCamera * cam = stc_matchcam ; 743 744// normal cam 745if (value == 0 ) 746 { 747Match_SetNormalCamera (); 748 } 749// zoom cam 750else if (value == 1 ) 751 { 752Match_SetFreeCamera (0 ,3 ); 753cam -> freecam_fov .X = 140 ; 754cam -> freecam_rotate .Y = 10 ; 755 } 756// fixed 757else if (value == 2 ) 758 { 759Match_SetFixedCamera (); 760 } 761else if (value == 3 ) 762 { 763Match_SetDevelopCamera (); 764 } 765Match_CorrectCamera (); 766} 767 768void Event_Update (void ) 769{ 770if (Pause_CheckStatus (1 )!= 2 ) { 771float speed = LdshOptions_GameSpeeds [LdshOptions_Main [OPT_SPEED ].val ]; 772HSD_SetSpeedEasy (speed ); 773 }else { 774HSD_SetSpeedEasy (1.0 ); 775 } 776} 777 778int Ledge_Find (int search_dir ,float xpos_start ,float * ledge_dir ) 779{ 780// get line and vert pointers 781CollLine * collline = * stc_collline ; 782 783// get initial closest 784float xpos_closest ; 785if (search_dir == -1 )// search left 786xpos_closest = -5000 ; 787else if (search_dir == 1 )// search right 788xpos_closest = 5000 ; 789else // search both 790xpos_closest = 5000 ; 791 792// look for the closest ledge 793int index_closest = -1 ; 794CollGroup * this_group = * stc_firstcollgroup ; 795while (this_group != 0 )// loop through ground links 796 { 797 798// 2 passes, one for ground and one for dynamic lines 799int line_index ,line_num ; 800for (int i = 0 ;i < 2 ;i ++ ) 801 { 802// first pass, use floors 803if (i == 0 ) 804 { 805line_index = this_group -> desc -> floor_start ;// first ground link 806line_num = line_index + this_group -> desc -> floor_num ;// ground link num 807 } 808// second pass, use dynamics 809else if (i == 1 ) 810 { 811line_index = this_group -> desc -> dyn_start ;// first ground link 812line_num = line_index + this_group -> desc -> dyn_num ;// ground link num 813 } 814 815// loop through lines 816while (line_index < line_num ) 817 { 818// get all data for this line 819CollLine * this_line = & collline [line_index ];// ??? i actually dont know why i cant access this directly 820CollLineDesc * this_linedesc = this_line -> desc ; 821 822// check if this link is a ledge 823if (this_linedesc -> is_ledge ) 824 { 825 826// check both sides of this ledge 827Vec3 ledge_pos ; 828for (int j = 0 ;j < 2 ;j ++ ) 829 { 830// first pass, check left 831if (j == 0 ) 832 { 833GrColl_GetGroundLineEndLeft (line_index ,& ledge_pos ); 834 } 835else if (j == 1 ) 836 { 837GrColl_GetGroundLineEndRight (line_index ,& ledge_pos ); 838 } 839 840// is within the camera range 841if ((ledge_pos .X > Stage_GetCameraLeft ())&& (ledge_pos .X < Stage_GetCameraRight ())&& (ledge_pos .Y > Stage_GetCameraBottom ())&& (ledge_pos .Y < Stage_GetCameraTop ())) 842 { 843 844// check for any obstructions 845float dir_mult ; 846if (j == 0 )// left ledge 847dir_mult = -1 ; 848else if (j == 1 )// right ledge 849dir_mult = 1 ; 850int ray_index ; 851int ray_kind ; 852Vec3 ray_angle ; 853Vec3 ray_pos ; 854float from_x = ledge_pos .X + (2 * dir_mult ); 855float to_x = from_x ; 856float from_y = ledge_pos .Y + 5 ; 857float to_y = from_y - 10 ; 858int is_ground = GrColl_RaycastGround (& ray_pos ,& ray_index ,& ray_kind ,& ray_angle ,-1 ,-1 ,-1 ,0 ,from_x ,from_y ,to_x ,to_y ,0 ); 859if (is_ground == 0 ) 860 { 861int is_closer = 0 ; 862 863if (search_dir == -1 )// check if to the left 864 { 865if ((ledge_pos .X > xpos_closest )&& (ledge_pos .X < xpos_start )) 866is_closer = 1 ; 867 } 868else if (search_dir == 1 )// check if to the right 869 { 870if ((ledge_pos .X < xpos_closest )&& (ledge_pos .X > xpos_start )) 871is_closer = 1 ; 872 } 873else // check if any direction 874 { 875float dist_old = fabs (xpos_start - xpos_closest ); 876float dist_new = fabs (xpos_start - ledge_pos .X ); 877if (dist_new < dist_old ) 878is_closer = 1 ; 879 } 880 881// determine direction 882if (is_closer ) 883 { 884 885// now determine if this line is a ledge in this direction 886if (j == 0 )// left ledge 887 { 888CollLine * prev_line = & collline [this_linedesc -> line_prev ];// ??? i actually dont know why i cant access this directly 889if ((this_linedesc -> line_prev == -1 )|| (prev_line -> is_rwall == 1 ))// if prev line is a right wall / if prev line doesnt exist 890 { 891 892// save info on this line 893xpos_closest = ledge_pos .X ;// save left vert's X position 894index_closest = line_index ; 895* ledge_dir = 1 ; 896 } 897 } 898else if (j == 1 )// right ledge 899 { 900CollLine * next_line = & collline [this_linedesc -> line_next ];// ??? i actually dont know why i cant access this directly 901if ((this_linedesc -> line_prev == -1 )|| (next_line -> is_lwall == 1 ))// if prev line is a right wall / if prev line doesnt exist 902 { 903 904// save info on this line 905xpos_closest = ledge_pos .X ;// save left vert's X position 906index_closest = line_index ; 907* ledge_dir = -1 ; 908 } 909 } 910 } 911 } 912 } 913 } 914 } 915 916line_index ++ ; 917 } 918 } 919 920// get next 921this_group = this_group -> next ; 922 } 923 924return index_closest ; 925} 926void Fighter_PlaceOnLedge (void ) 927{ 928LedgedashData * event_data = event_vars -> event_gobj -> userdata ; 929GOBJ * hmn = Fighter_GetGObj (0 ); 930FighterData * hmn_data = hmn -> userdata ; 931 932float ledge_dir ; 933int line_index = Ledge_Find (event_data -> ledge ,0.f ,& ledge_dir ); 934 935if (line_index == -1 ) { 936event_vars -> Tip_Display (500 * 60 ,"Error:\nIt appears there are no \nledges on this stage.." ); 937return ; 938 } 939 940Ledgedash_InitVariables (event_data ); 941event_data -> tip .refresh_displayed = 0 ; 942event_data -> tip .is_input_release = 0 ; 943event_data -> tip .refresh_num = 0 ; 944 945// get ledge position 946Vec3 ledge_pos ; 947if (ledge_dir > 0 ) 948GrColl_GetGroundLineEndLeft (line_index ,& ledge_pos ); 949else 950GrColl_GetGroundLineEndRight (line_index ,& ledge_pos ); 951 952// remove velocity 953hmn_data -> phys .self_vel .X = 0 ; 954hmn_data -> phys .self_vel .Y = 0 ; 955 956// restore tether 957hmn_data -> flags .used_tether = 0 ; 958 959 960// Sleep first 961Fighter_EnterSleep (hmn ,0 ); 962Fighter_EnterRebirth (hmn ); 963 964// face the ledge 965hmn_data -> facing_direction = ledge_dir ; 966 967// check starting position 968int start_pos = LdshOptions_Main [OPT_POS ].val ; 969 970SWITCH_START_POS : 971switch (start_pos ) 972 { 973case OPTPOS_RANDOM : 974 { 975start_pos = HSD_Randi (OPTPOS_RANDOM ); 976 gotoSWITCH_START_POS ; 977 } 978case OPTPOS_LEDGE : 979 { 980// place player on this ledge 981event_data -> tip .refresh_num = -1 ;// setting this to -1 because the per frame code will add 1 and make it 0 982FtCliffCatch * ft_state = (void * )& hmn_data -> state_var ; 983ft_state -> ledge_index = line_index ;// store line index 984Fighter_EnterCliffWait (hmn ); 985ft_state -> timer = 0 ;// spoof as on ledge for a frame already 986Fighter_SetAirborne (hmn_data ); 987Fighter_EnableCollUpdate (hmn_data ); 988Coll_CheckLedge (& hmn_data -> coll_data ); 989Fighter_MoveToCliff (hmn ); 990Fighter_UpdatePosition (hmn ); 991ftCommonData * ftcommon = * stc_ftcommon ; 992 993// This needs to be +1 for some reason, otherwise we get an off-by-one in galint calculations 994Fighter_ApplyIntang (hmn ,ftcommon -> cliff_invuln_time + 1 ); 995break ; 996 } 997case OPTPOS_FALLING : 998 { 999// place player falling above the ledge 1000hmn_data -> phys .pos .X = ledge_pos .X + -5 * ledge_dir ;// slight nudge to prevent accidentally landing on stage 1001hmn_data -> phys .pos .Y = ledge_pos .Y + 20 ; 1002Fighter_UpdatePosition (hmn ); 1003Fighter_EnterFall (hmn ); 1004break ; 1005 } 1006case OPTPOS_STAGE : 1007 { 1008// place player on stage next to ledge 1009Vec3 coll_pos ,line_unk ; 1010int line_index ,line_kind ; 1011float x = ledge_pos .X + 12 * ledge_dir ; 1012float from_y = ledge_pos .Y + 5 ; 1013float to_y = from_y - 10 ; 1014int is_ground = GrColl_RaycastGround (& coll_pos ,& line_index ,& line_kind ,& line_unk ,-1 ,-1 ,-1 ,0 ,x ,from_y ,x ,to_y ,0 ); 1015if (is_ground == 1 ) 1016 { 1017hmn_data -> phys .pos = coll_pos ; 1018Fighter_UpdatePosition (hmn ); 1019Fighter_EnterWait (hmn ); 1020 } 1021break ; 1022 } 1023case OPTPOS_RESPAWNPLAT : 1024 { 1025// place player in a random position in respawn wait 1026float xpos_min = 40 ; 1027float xpos_max = 65 ; 1028float ypos_min = -30 ; 1029float ypos_max = 30 ; 1030hmn_data -> phys .pos .X = ((ledge_dir * -1 )* (xpos_min + HSD_Randi (xpos_max - xpos_min )+ HSD_Randf ()))+ (ledge_pos .X ); 1031hmn_data -> phys .pos .Y = ((ledge_dir * -1 )* (ypos_min + HSD_Randi (ypos_max - ypos_min )+ HSD_Randf ()))+ (ledge_pos .Y ); 1032 1033// enter rebirth 1034Fighter_EnterRebirthWait (hmn ); 1035hmn_data -> cb .Phys = RebirthWait_Phys ; 1036hmn_data -> cb .IASA = RebirthWait_IASA ; 1037 1038Fighter_UpdateRebirthPlatformPos (hmn ); 1039 1040break ; 1041 } 1042 } 1043 1044// avoid double reset in case user manually resets 1045event_data -> reset_timer = 0 ; 1046 1047// update camera box 1048CmSubject * cam = event_data -> cam ; 1049cam -> cam_pos .X = ledge_pos .X + (ledge_dir * 20 ); 1050cam -> cam_pos .Y = ledge_pos .Y + 15 ; 1051 1052Fighter_UpdateCamera (hmn ); 1053 1054// Prevent double reset caused by normal getup -> ledge jump combo with an instant reset delay. 1055hmn_data -> input .timer_lstick_tilt_y = 10 ; 1056 1057// remove all particles 1058for (int i = 0 ;i < PTCL_LINKMAX ;i ++ ) 1059 { 1060Particle ** ptcls = & stc_ptcl [i ]; 1061Particle * ptcl = * ptcls ; 1062while (ptcl != 0 ) 1063 { 1064 1065Particle * ptcl_next = ptcl -> next ; 1066 1067// begin destroying this particle 1068 1069// subtract some value, 8039c9f0 1070if (ptcl -> gen != 0 ) 1071 { 1072ptcl -> gen -> particle_num -- ; 1073 } 1074// remove from generator? 8039ca14 1075if (ptcl -> gen != 0 ) 1076psRemoveParticleAppSRT (ptcl ); 1077 1078// delete parent jobj, 8039ca48 1079psDeletePntJObjwithParticle (ptcl ); 1080 1081// update most recent ptcl pointer 1082* ptcls = ptcl -> next ; 1083 1084// free alloc, 8039ca54 1085HSD_ObjFree ((void * )0x804d0f60 ,ptcl ); 1086 1087// decrement ptcl total 1088u16 ptclnum = * stc_ptclnum ; 1089ptclnum -- ; 1090* stc_ptclnum = ptclnum ; 1091 1092// get next 1093ptcl = ptcl_next ; 1094 } 1095 } 1096 1097// remove all camera shake gobjs (p_link 18, entity_class 3) 1098GOBJ * gobj = (* stc_gobj_lookup )[MATCHPLINK_MATCHCAM ]; 1099while (gobj != 0 ) 1100 { 1101 1102GOBJ * gobj_next = gobj -> next ; 1103 1104// if entity class 3 (quake) 1105if (gobj -> entity_class == 3 ) 1106 { 1107GObj_Destroy (gobj ); 1108 } 1109 1110gobj = gobj_next ; 1111 } 1112} 1113void Fighter_UpdatePosition (GOBJ * fighter ) 1114{ 1115 1116FighterData * fighter_data = fighter -> userdata ; 1117 1118// Update Position (Copy Physics XYZ into all ECB XYZ) 1119fighter_data -> coll_data .topN_Curr .X = fighter_data -> phys .pos .X ; 1120fighter_data -> coll_data .topN_Curr .Y = fighter_data -> phys .pos .Y ; 1121fighter_data -> coll_data .topN_Prev .X = fighter_data -> phys .pos .X ; 1122fighter_data -> coll_data .topN_Prev .Y = fighter_data -> phys .pos .Y ; 1123fighter_data -> coll_data .topN_CurrCorrect .X = fighter_data -> phys .pos .X ; 1124fighter_data -> coll_data .topN_CurrCorrect .Y = fighter_data -> phys .pos .Y ; 1125fighter_data -> coll_data .topN_Proj .X = fighter_data -> phys .pos .X ; 1126fighter_data -> coll_data .topN_Proj .Y = fighter_data -> phys .pos .Y ; 1127 1128// Update Collision Frame ID 1129fighter_data -> coll_data .coll_test = * stc_colltest ; 1130 1131// Adjust JObj position (code copied from 8006c324) 1132JOBJ * fighter_jobj = fighter -> hsd_object ; 1133fighter_jobj -> trans .X = fighter_data -> phys .pos .X ; 1134fighter_jobj -> trans .Y = fighter_data -> phys .pos .Y ; 1135fighter_jobj -> trans .Z = fighter_data -> phys .pos .Z ; 1136JOBJ_SetMtxDirtySub (fighter_jobj ); 1137 1138// Update Static Player Block Coords 1139Fighter_SetPosition (fighter_data -> ply ,fighter_data -> flags .ms ,& fighter_data -> phys .pos ); 1140} 1141void Fighter_UpdateCamera (GOBJ * fighter ) 1142{ 1143FighterData * fighter_data = fighter -> userdata ; 1144 1145// Update camerabox pos 1146Fighter_UpdateCameraBox (fighter ); 1147 1148// Update tween 1149fighter_data -> camera_subject -> boundleft_curr = fighter_data -> camera_subject -> boundleft_proj ; 1150fighter_data -> camera_subject -> boundright_curr = fighter_data -> camera_subject -> boundright_proj ; 1151 1152// update camera position 1153Match_CorrectCamera (); 1154 1155// reset onscreen bool 1156//Fighter_UpdateOnscreenBool(fighter); 1157fighter_data -> flags .is_offscreen = 0 ; 1158} 1159void RebirthWait_Phys (GOBJ * fighter ) 1160{ 1161 1162FighterData * fighter_data = fighter -> userdata ; 1163 1164// infinite time 1165fighter_data -> state_var .state_var1 = 2 ; 1166} 1167int RebirthWait_IASA (GOBJ * fighter ) 1168{ 1169 1170FighterData * fighter_data = fighter -> userdata ; 1171if (!Fighter_IASACheck_JumpAerial (fighter )) 1172 { 1173ftCommonData * ftcommon = * stc_ftcommon ; 1174 1175// check for lstick movement 1176float stick_x = fabs (fighter_data -> input .lstick .X ); 1177float stick_y = fighter_data -> input .lstick .Y ; 1178if ( 1179 (stick_x > 0.2875f && fighter_data -> input .timer_lstick_tilt_x < 2 ) 1180|| (stick_y < - ftcommon -> lstick_rebirthfall && fighter_data -> input .timer_lstick_tilt_y < 4 ) 1181 ) { 1182Fighter_EnterFall (fighter ); 1183return 1 ; 1184 } 1185 } 1186 1187return 0 ; 1188} 1189int Fighter_IsFallInput (FighterData * hmn_data ) 1190{ 1191float thresh = (* stc_ftcommon )-> ledge_drop_thresh ;// 0.2875 1192float drop_angle = (* stc_ftcommon )-> lstick_tilt ;// 0.872665 (50 deg) 1193float lx = hmn_data -> input .lstick .X ; 1194float ly = hmn_data -> input .lstick .Y ; 1195float angle = atan2 (ly ,fabs (lx )); 1196float cx = hmn_data -> input .cstick .X ; 1197float cy = hmn_data -> input .cstick .Y ; 1198 1199// Technically there are some false positives here that result in a ledgejump. 1200// However, this shouldn't affect the tip displays. 1201int lstick_drop = (fabs (lx ) >=thresh || fabs (ly ) >=thresh )&& 1202 !(angle > drop_angle || (angle > - drop_angle && lx * hmn_data -> facing_direction >=0 )); 1203int cstick_drop = (fabs (cx ) >=thresh || fabs (cy ) >=thresh ); 1204return (lstick_drop || cstick_drop )&& !Fighter_IsFallBlocked (hmn_data ); 1205} 1206int Fighter_IsFallBlocked (FighterData * hmn_data ) 1207{ 1208float thresh = (* stc_ftcommon )-> ledge_drop_thresh ;// 0.2875 1209float lx = hmn_data -> input .lstick_prev .X ; 1210float ly = hmn_data -> input .lstick_prev .Y ; 1211float cx = hmn_data -> input .cstick_prev .X ; 1212float cy = hmn_data -> input .cstick_prev .Y ; 1213 1214return fabs (lx ) >=thresh || fabs (ly ) >=thresh || 1215fabs (cx ) >=thresh || fabs (cy ) >=thresh ; 1216} 1217// Tips Functions 1218void Tips_Toggle (GOBJ * menu_gobj ,int value ) 1219{ 1220// destroy existing tips when disabling 1221if (value == 1 ) 1222event_vars -> Tip_Destroy (); 1223} 1224void Tips_Think (LedgedashData * event_data ,FighterData * hmn_data ) 1225{ 1226// skip if tips turned off 1227if (LdshOptions_Main [OPT_TIPS ].val == 1 ) 1228return ; 1229 1230// check for early fall input in cliffcatch 1231if (!event_data -> tip .is_input_release && hmn_data -> state_id == ASID_CLIFFCATCH && Fighter_IsFallInput (hmn_data )) 1232 { 1233event_data -> tip .is_input_release = 1 ; 1234event_vars -> Tip_Destroy (); 1235 1236// determine how many frames early 1237Figatree * anim = Fighter_GetAnimData (hmn_data ,hmn_data -> action_id ); 1238float frame_num = anim -> frame_num ; 1239float frames_early = frame_num - hmn_data -> state .frame ; 1240event_vars -> Tip_Display (3 * 60 ,"Misinput:\nFell %d frames early." , (int )frames_early + 1 ); 1241 } 1242 1243// check for early fall input on cliffwait frame 0 1244if (!event_data -> tip .is_input_release && hmn_data -> state_id == ASID_CLIFFWAIT && hmn_data -> TM .state_frame == 1 && Fighter_IsFallInput (hmn_data )) 1245 { 1246event_data -> tip .is_input_release = 1 ; 1247event_vars -> Tip_Destroy (); 1248event_vars -> Tip_Display (LSDH_TIPDURATION ,"Misinput:\nFell 1 frame early." ); 1249 } 1250 1251if (!event_data -> tip .is_input_release && hmn_data -> state_id == ASID_CLIFFJUMPQUICK1 ) 1252 { 1253if (Fighter_IsFallInput (hmn_data )) 1254 { 1255event_data -> tip .is_input_release = 1 ; 1256event_vars -> Tip_Destroy (); 1257 1258// jumped before fall 1259event_vars -> Tip_Display (LSDH_TIPDURATION ,"Misinput:\nJumped %d frame(s) early." ,hmn_data -> TM .state_frame + 1 ); 1260 } 1261else if (Fighter_IsFallBlocked (hmn_data )) 1262 { 1263event_data -> tip .is_input_release = 1 ; 1264event_vars -> Tip_Destroy (); 1265 1266// failed to release sticks to neutral 1267event_vars -> Tip_Display (LSDH_TIPDURATION ,"Misinput:\nDid not reset sticks \nto neutral before dropping." ,hmn_data -> TM .state_frame ); 1268 } 1269 } 1270 1271// check for ledgedash without refreshing 1272if (!event_data -> tip .refresh_displayed && event_data -> action_state .is_finished && event_data -> tip .refresh_num == 0 ) 1273 { 1274 1275event_data -> tip .refresh_displayed = 1 ; 1276 1277// increment condition count 1278event_data -> tip .refresh_cond_num ++ ; 1279 1280// after 3 conditions, display tip 1281if (event_data -> tip .refresh_cond_num >=3 ) 1282 { 1283// if tip is displayed, reset cond num 1284if (event_vars -> Tip_Display (5 * 60 ,"Warning:\nIt is higly recommended to\nre-grab ledge after \nbeing reset to simulate \na realistic scenario!" )) 1285event_data -> tip .refresh_cond_num = 0 ; 1286 } 1287 } 1288} 1289 1290int Update_CheckPause (void ) 1291{ 1292HSD_Update * update = stc_hsd_update ; 1293int isChange = 0 ; 1294 1295// menu paused 1296if (Ldsh_FrameAdvance .val == 1 ) 1297 { 1298// check if unpaused 1299if (update -> pause_kind != PAUSEKIND_SYS ) 1300isChange = 1 ; 1301 } 1302// menu unpaused 1303else 1304 { 1305// check if paused 1306if (update -> pause_kind == PAUSEKIND_SYS ) 1307isChange = 1 ; 1308 } 1309 1310return isChange ; 1311} 1312int Update_CheckAdvance (void ) 1313{ 1314static int timer = 0 ; 1315 1316HSD_Update * update = stc_hsd_update ; 1317int isAdvance = 0 ; 1318 1319GOBJ * hmn = Fighter_GetGObj (0 ); 1320FighterData * hmn_data = hmn -> userdata ; 1321int controller = hmn_data -> pad_index ; 1322 1323// get their pad 1324HSD_Pad * pad = PadGetMaster (controller ); 1325HSD_Pad * engine_pad = PadGetEngine (controller ); 1326 1327// get their advance input 1328static int stc_advance_btns []= {HSD_TRIGGER_L ,HSD_TRIGGER_Z ,HSD_BUTTON_X ,HSD_BUTTON_Y ,HSD_TRIGGER_R }; 1329Memcard * memcard = stc_memcard ; 1330u32 btn_idx = memcard -> TM_LabFrameAdvanceButton ; 1331if (btn_idx >=countof (stc_advance_btns )) 1332btn_idx = 0 ; 1333int advance_btn = stc_advance_btns [btn_idx ]; 1334 1335// check if holding L 1336if (Ldsh_FrameAdvance .val == 1 && (pad -> held & advance_btn )) 1337 { 1338timer ++ ; 1339 1340// advance if first press or holding more than 10 frames 1341if (timer == 1 || timer > 30 ) 1342 { 1343isAdvance = 1 ; 1344 1345// remove button input 1346pad -> down &= ~advance_btn ; 1347pad -> held &= ~advance_btn ; 1348engine_pad -> down &= ~advance_btn ; 1349engine_pad -> held &= ~advance_btn ; 1350 1351// if using L, remove analog press too 1352if (advance_btn == HSD_TRIGGER_L ) 1353 { 1354pad -> triggerLeft = 0 ; 1355pad -> ftriggerLeft = 0 ; 1356engine_pad -> triggerLeft = 0 ; 1357engine_pad -> ftriggerLeft = 0 ; 1358 } 1359else if (advance_btn == HSD_TRIGGER_R ) 1360 { 1361pad -> triggerRight = 0 ; 1362pad -> ftriggerRight = 0 ; 1363engine_pad -> triggerRight = 0 ; 1364engine_pad -> ftriggerRight = 0 ; 1365 } 1366 } 1367 } 1368else 1369 { 1370update -> advance = 0 ; 1371timer = 0 ; 1372 } 1373 1374return isAdvance ; 1375} 1376 1377// Initial Menu 1378EventMenu * Event_Menu = & LdshMenu_Main ;