fork/training-mode-ce
git clone https://git.julia.blue/fork/training-mode-ce
1617686
master
1// Include this file in your event source and call Recovery_Think. Easy! 2// 3// You can set opt_flags manually, or use RecoveryMenuOptFlags with the given menus. 4 5#include "../MexTK/mex.h" 6#include "events.h" 7 8static void Think_Spacies (GOBJ * cpu ,u32 opt_flags ); 9static void Think_Sheik (GOBJ * cpu ,u32 opt_flags ); 10static void Think_Falcon (GOBJ * cpu ,u32 opt_flags ); 11static void Think_Marth (GOBJ * cpu ,u32 opt_flags ); 12 13typedef void (* ThinkFn )(GOBJ * ,u32 ); 14static ThinkFn ThinkFnLookup []= { 150 ,// MARIO 16Think_Spacies ,// FOX 17Think_Falcon ,// FALCON 180 ,// DK 190 ,// KIRBY 200 ,// BOWSER 210 ,// LINK 22Think_Sheik ,// SHEIK 230 ,// NESS 240 ,// PEACH 250 ,// POPO 260 ,// NANA 270 ,// PIKACHU 280 ,// SAMUS 290 ,// YOSHI 300 ,// JIGGLYPUFF 310 ,// MEWTWO 320 ,// LUIGI 33Think_Marth ,// MARTH 340 ,// ZELDA 350 ,// YOUNGLINK 360 ,// DRMARIO 37Think_Spacies ,// FALCO 380 ,// PICHU 390 ,// GAW, 400 ,// GANONDORF 410 ,// ROY 42}; 43 44static Vec2 ledge_positions [2 ]; 45 46static void GetLedgePositions (Vec2 coords_out [2 ]) { 47static char ledge_ids [34 ][2 ]= { 48 {0xFF ,0xFF }, {0xFF ,0xFF }, {0x03 ,0x07 }, {0x33 ,0x36 }, 49 {0x03 ,0x0D }, {0x29 ,0x45 }, {0x05 ,0x11 }, {0x09 ,0x1A }, 50 {0x02 ,0x06 }, {0x15 ,0x17 }, {0x00 ,0x00 }, {0x43 ,0x4C }, 51 {0x00 ,0x00 }, {0x00 ,0x00 }, {0x0E ,0x0D }, {0x00 ,0x00 }, 52 {0x00 ,0x05 }, {0x1E ,0x2E }, {0x0C ,0x0E }, {0x02 ,0x04 }, 53 {0x03 ,0x05 }, {0x00 ,0x00 }, {0x06 ,0x12 }, {0x00 ,0x00 }, 54 {0xD7 ,0xE2 }, {0x00 ,0x00 }, {0x00 ,0x00 }, {0x00 ,0x00 }, 55 {0x03 ,0x05 }, {0x03 ,0x0B }, {0x06 ,0x10 }, {0x00 ,0x05 }, 56 {0x00 ,0x02 }, {0x01 ,0x01 }, 57 }; 58 59int stage_id = Stage_GetExternalID (); 60char left_id = ledge_ids [stage_id ][0 ]; 61char right_id = ledge_ids [stage_id ][1 ]; 62 63Vec3 pos ; 64Stage_GetLeftOfLineCoordinates (left_id ,& pos ); 65coords_out [0 ]= (Vec2 ) {pos .X ,pos .Y }; 66Stage_GetRightOfLineCoordinates (right_id ,& pos ); 67coords_out [1 ]= (Vec2 ) {pos .X ,pos .Y }; 68} 69 70static void DIIn (FighterData * cpu_data ) { 71bool right = cpu_data -> phys .pos .X > 0.f ; 72 73cpu_data -> cpu .lstickX = right ?-90 :90 ; 74cpu_data -> cpu .lstickY = 90 ; 75 76// Spoof last input as current input to prevent SDI 77cpu_data -> input .lstick .X = right ?-0.7f :0.7f ; 78cpu_data -> input .lstick .Y = 0.7f ; 79} 80 81#define OptEnabled (opt ) (((opt_flags) & (1u << (opt))) != 0) 82 83#define CMN_FALL_MIN_DISTANCE 20.0f 84 85void Recovery_Think (GOBJ * cpu ,u32 opt_flags ) { 86if (ledge_positions [0 ].X == 0.0f ) 87GetLedgePositions (ledge_positions ); 88 89FighterData * cpu_data = cpu -> userdata ; 90cpu_data -> cpu .ai = 15 ;// noact 91 92// Common thinking ----------------------- 93 94float x = cpu_data -> phys .pos .X ; 95int state = cpu_data -> state_id ; 96 97// wall tech 98cpu_data -> input .timer_LR = 0 ; 99 100// if falling on stage, don't do anything 101if ( 102 (ASID_FALL <=state && state <=ASID_FALLAERIALB ) 103|| (ASID_JUMPF <=state && state <=ASID_JUMPAERIALB ) 104 ) { 105float lx = ledge_positions [0 ].X ; 106float rx = ledge_positions [1 ].X ; 107 108// if withing stage, at greater than CMN_FALL_MIN_DISTANCE units from ledge, just drop down. 109if (lx + CMN_FALL_MIN_DISTANCE <=x && x <=rx - CMN_FALL_MIN_DISTANCE ) { 110cpu_data -> cpu .lstickX = 0 ; 111cpu_data -> cpu .lstickY = 0 ; 112return ; 113 114// if within stage, but not greater than CMN_FALL_MIN_DISTANCE units from ledge, drift inwards. 115 }else if (lx <=x && x <=rx ) { 116cpu_data -> cpu .lstickX = -127 * sign (x ); 117cpu_data -> cpu .lstickY = 0 ; 118return ; 119 } 120 } 121 122// normal getup 123if (state == ASID_CLIFFWAIT && cpu_data -> TM .state_frame == 2 ) { 124cpu_data -> cpu .lstickX = -127 * sign (x ); 125cpu_data -> cpu .lstickY = 0 ; 126return ; 127 } 128 129// angel platform 130if (state == ASID_REBIRTHWAIT ) { 131cpu_data -> cpu .lstickX = 0 ; 132cpu_data -> cpu .lstickY = -127 ; 133return ; 134 } 135 136// Character specific thinking ------------ 137 138ThinkFn think_fn = ThinkFnLookup [cpu_data -> kind ]; 139if (think_fn ) { 140think_fn (cpu ,opt_flags ); 141 }else { 142cpu_data -> cpu .ai = 0 ; 143 } 144} 145 146enum options_spacies { 147OPT_SPACIES_FF_LOW , 148OPT_SPACIES_FF_MID , 149OPT_SPACIES_FF_HIGH , 150OPT_SPACIES_JUMP , 151OPT_SPACIES_ILLUSION , 152OPT_SPACIES_FASTFALL , 153 154OPT_SPACIES_COUNT 155}; 156 157enum options_sheik { 158OPT_SHEIK_UPB_LEDGE , 159OPT_SHEIK_UPB_STAGE , 160OPT_SHEIK_UPB_HIGH , 161OPT_SHEIK_JUMP , 162OPT_SHEIK_FAIR , 163OPT_SHEIK_AMSAH_TECH , 164 165OPT_SHEIK_COUNT 166}; 167 168enum options_falcon { 169OPT_FALCON_UPB , 170OPT_FALCON_DRIFT_BACK , 171OPT_FALCON_JUMP , 172OPT_FALCON_FASTFALL , 173OPT_FALCON_DOWNB , 174 175OPT_FALCON_COUNT 176}; 177 178enum options_marth { 179OPT_MARTH_UPB_EARLY , 180OPT_MARTH_JUMP , 181OPT_MARTH_SIDEB , 182OPT_MARTH_FAIR , 183 184OPT_MARTH_COUNT 185}; 186 187// Fox ------------------------------------------------- 188 189static EventOption RecOptions_Fox []= { 190 { 191 .kind = OPTKIND_TOGGLE , 192 .name = "Firefox Low" , 193 .desc = {"Allow Fox to aim his up special to the ledge." }, 194 .val = 1 , 195 }, 196 { 197 .kind = OPTKIND_TOGGLE , 198 .name = "Firefox Mid" , 199 .desc = {"Allow Fox to aim his up special to the stage." }, 200 }, 201 { 202 .kind = OPTKIND_TOGGLE , 203 .name = "Firefox High" , 204 .desc = {"Allow Fox to aim his up special high." }, 205 }, 206 { 207 .kind = OPTKIND_TOGGLE , 208 .name = "Double Jump" , 209 .desc = {"Allow Fox to double jump." }, 210 }, 211 { 212 .kind = OPTKIND_TOGGLE , 213 .name = "Illusion" , 214 .desc = {"Allow Fox to side special." }, 215 }, 216 { 217 .kind = OPTKIND_TOGGLE , 218 .name = "Fast Fall" , 219 .desc = {"Allow Fox to fast fall." }, 220 }, 221}; 222static EventMenu RecMenu_Fox = { 223 .name = "Fox Recovery" , 224 .option_num = sizeof (RecOptions_Fox ) /sizeof (EventOption ), 225 .options = RecOptions_Fox , 226}; 227 228// Falco ------------------------------------------------- 229 230static EventOption RecOptions_Falco []= { 231 { 232 .kind = OPTKIND_TOGGLE , 233 .name = "Firebird Low" , 234 .desc = {"Allow Falco to aim his up special to the ledge." }, 235 .val = 1 , 236 }, 237 { 238 .kind = OPTKIND_TOGGLE , 239 .name = "Firebird Mid" , 240 .desc = {"Allow Falco to aim his up special to the stage." }, 241 }, 242 { 243 .kind = OPTKIND_TOGGLE , 244 .name = "Firebird High" , 245 .desc = {"Allow Falco to aim his up special high." }, 246 }, 247 { 248 .kind = OPTKIND_TOGGLE , 249 .name = "Double Jump" , 250 .desc = {"Allow Falco to double jump." }, 251 }, 252 { 253 .kind = OPTKIND_TOGGLE , 254 .name = "Phantasm" , 255 .desc = {"Allow Falco to side special." }, 256 }, 257 { 258 .kind = OPTKIND_TOGGLE , 259 .name = "Fast Fall" , 260 .desc = {"Allow Falco to fast fall." }, 261 }, 262}; 263static EventMenu RecMenu_Falco = { 264 .name = "Falco Recovery" , 265 .option_num = sizeof (RecOptions_Falco ) /sizeof (EventOption ), 266 .options = RecOptions_Falco , 267}; 268 269// Sheik ------------------------------------------------- 270 271static EventOption RecOptions_Sheik []= { 272 { 273 .kind = OPTKIND_TOGGLE , 274 .name = "Vanish to Ledge" , 275 .desc = {"Allow Sheik to vanish to ledge and the" , 276"tip of the stage." }, 277 .val = 1 , 278 }, 279 { 280 .kind = OPTKIND_TOGGLE , 281 .name = "Vanish to Stage" , 282 .desc = {"Allow Sheik to vanish deep into stage." }, 283 .val = 1 , 284 }, 285 { 286 .kind = OPTKIND_TOGGLE , 287 .name = "Vanish High" , 288 .desc = {"Allow Sheik to vanish above the ledge" , 289"and to platforms." }, 290 .val = 1 , 291 }, 292 { 293 .kind = OPTKIND_TOGGLE , 294 .name = "Double Jump" , 295 .desc = {"Allow Sheik to double jump." }, 296 }, 297 { 298 .kind = OPTKIND_TOGGLE , 299 .name = "Fair" , 300 .desc = {"Allow Sheik to fair the player." }, 301 }, 302 { 303 .kind = OPTKIND_TOGGLE , 304 .name = "Amsah Tech" , 305 .desc = {"Allow Sheik to Amsah Tech." }, 306 }, 307}; 308 309static EventMenu RecMenu_Sheik = { 310 .name = "Sheik Recovery" , 311 .option_num = sizeof (RecOptions_Sheik ) /sizeof (EventOption ), 312 .options = RecOptions_Sheik , 313}; 314 315// Captain Falcon -------------------------------------- 316 317static EventOption RecOptions_Falcon []= { 318 { 319 .kind = OPTKIND_TOGGLE , 320 .name = "Falcon Dive" , 321 .desc = {"Allow Falcon to Up B." }, 322 .val = 1 , 323 }, 324 { 325 .kind = OPTKIND_TOGGLE , 326 .name = "Drift Back" , 327 .desc = {"Allow Falcon to drift backwards." }, 328 .val = 1 , 329 }, 330 { 331 .kind = OPTKIND_TOGGLE , 332 .name = "Double Jump" , 333 .desc = {"Allow Falcon to double jump." }, 334 }, 335 { 336 .kind = OPTKIND_TOGGLE , 337 .name = "Fast Fall" , 338 .desc = {"Allow Falcon to fast fall." }, 339 }, 340 { 341 .kind = OPTKIND_TOGGLE , 342 .name = "Falcon Kick" , 343 .desc = {"Allow Falcon to Down B." }, 344 }, 345}; 346 347static EventMenu RecMenu_Falcon = { 348 .name = "Falcon Recovery" , 349 .option_num = sizeof (RecOptions_Falcon ) /sizeof (EventOption ), 350 .options = RecOptions_Falcon , 351}; 352 353// Marth -------------------------------------- 354 355static EventOption RecOptions_Marth []= { 356 { 357 .kind = OPTKIND_TOGGLE , 358 .name = "Dolphin Slash Early" , 359 .desc = {"Allow Marth to Up B above the ledge." }, 360 .val = 1 , 361 }, 362 { 363 .kind = OPTKIND_TOGGLE , 364 .name = "Double Jump" , 365 .desc = {"Allow Marth to double jump." }, 366 .val = 1 , 367 }, 368 { 369 .kind = OPTKIND_TOGGLE , 370 .name = "Dancing Blade" , 371 .desc = {"Allow Marth to use SideB to recover and" , 372"delay his timing." }, 373 }, 374 { 375 .kind = OPTKIND_TOGGLE , 376 .name = "Fair" , 377 .desc = {"Allow Marth to fair the player." }, 378 }, 379}; 380 381static EventMenu RecMenu_Marth = { 382 .name = "Marth Recovery" , 383 .option_num = sizeof (RecOptions_Marth ) /sizeof (EventOption ), 384 .options = RecOptions_Marth , 385}; 386 387EventMenu * RecoveryMenus []= { 3880 ,// MARIO 389& RecMenu_Fox , 390& RecMenu_Falcon , 3910 ,// DK 3920 ,// KIRBY 3930 ,// BOWSER 3940 ,// LINK 395& RecMenu_Sheik , 3960 ,// NESS 3970 ,// PEACH 3980 ,// POPO 3990 ,// NANA 4000 ,// PIKACHU 4010 ,// SAMUS 4020 ,// YOSHI 4030 ,// JIGGLYPUFF 4040 ,// MEWTWO 4050 ,// LUIGI 406& RecMenu_Marth , 4070 ,// ZELDA 4080 ,// YOUNGLINK 4090 ,// DRMARIO 410& RecMenu_Falco , 4110 ,// PICHU 4120 ,// GAW, 4130 ,// GANONDORF 4140 ,// ROY 415}; 416 417// Helper FNs --------------------------------------------- 418 419u32 RecoveryMenuOptFlags (GOBJ * cpu ) { 420FighterData * cpu_data = cpu -> userdata ; 421EventMenu * menu = RecoveryMenus [cpu_data -> kind ]; 422if (menu == 0 ) 423return 0 ; 424 425u32 opt_flags = 0 ; 426for (u32 opt = 0 ;opt < (u32 )menu -> option_num ;++ opt ) 427opt_flags |= (u32 )menu -> options [opt ].val <<opt ; 428return opt_flags ; 429} 430 431static inline float Progress (float n ,float a ,float b ) {return (n - a ) / (b - a ); } 432static inline bool Within (float a ,float b ,float tolerance ) {return fabs (b - a )< tolerance ; } 433 434static int HitstunEnded (GOBJ * fighter ) { 435FighterData * data = fighter -> userdata ; 436float hitstun ; 437memcpy (& hitstun ,& data -> state_var .state_var1 ,sizeof (float )); 438return hitstun == 0.0 ; 439} 440 441static int InHitstunAnim (int state ) { 442return ASID_DAMAGEHI1 <=state && state <=ASID_DAMAGEFLYROLL ; 443} 444 445static bool IsAirActionable (GOBJ * fighter ) { 446FighterData * data = fighter -> userdata ; 447 448// ensure airborne 449if (data -> phys .air_state == 0 ) 450return false; 451 452int state = data -> state_id ; 453 454if (InHitstunAnim (state )) { 455if (HitstunEnded (fighter )) 456return true; 457 458FtDamage * dmg = (FtDamage * )& data -> state_var ; 459if (dmg -> is_meteor && dmg -> meteor_lockout == 0 ) 460return true; 461 } 462 463if (state == ASID_PASSIVEWALL && data -> TM .state_frame > 5 ) 464return true; 465 466if (state == ASID_PASSIVEWALLJUMP ) 467return true; 468 469if (ASID_ATTACKAIRN <=state && state <=ASID_ATTACKAIRLW && data -> flags .past_iasa ) 470return true; 471 472return (ASID_JUMPF <=state && state <=ASID_FALLAERIALB ) 473|| state == ASID_DAMAGEFALL ; 474} 475 476static float Vec2_Distance (Vec2 * a ,Vec2 * b ) { 477float dx = a -> X - b -> X ; 478float dy = a -> Y - b -> Y ; 479return sqrtf (dx * dx + dy * dy ); 480} 481 482static float Vec2_Length (Vec2 * a ) { 483float x = a -> X ; 484float y = a -> Y ; 485return sqrtf (x * x + y * y ); 486} 487 488static void PhysStep (FighterData * data ,Vec2 * pos ,Vec2 * vel ) { 489float gravity = data -> phys .air_state == 0 ?0.f :data -> attr .gravity ; 490float min_y_vel = data -> flags .is_fastfall ? 491- data -> attr .fastfall_velocity 492 :- data -> attr .terminal_velocity ; 493 494pos -> X += vel -> X ; 495pos -> Y += vel -> Y ; 496vel -> Y -= gravity ; 497vel -> Y = fmax (vel -> Y ,min_y_vel ); 498} 499 500static Vec2 SimulatePhys (FighterData * data ,int future ) { 501Vec2 pos = {data -> phys .pos .X ,data -> phys .pos .Y }; 502Vec2 vel = {data -> phys .self_vel .X ,data -> phys .self_vel .Y }; 503for (int i = 0 ;i < future ;++ i ) 504PhysStep (data ,& pos ,& vel ); 505 506return pos ; 507} 508 509static bool SimulatePhys_CanReachPoint (FighterData * data ,Vec2 target ) { 510if (data -> phys .air_state == 0 )return false; 511 512Vec2 pos = {data -> phys .pos .X ,data -> phys .pos .Y }; 513Vec2 vel = {data -> phys .self_vel .X ,data -> phys .self_vel .Y }; 514 515float dir = sign (target .X - pos .X ); 516if (sign (vel .X )!= dir ) 517return false; 518 519while (target .Y < pos .Y || vel .Y >=0.f ) 520PhysStep (data ,& pos ,& vel ); 521 522return dir != sign (target .X - pos .X ); 523} 524 525static float ProjectedDistance (FighterData * a ,FighterData * b ,int future ) { 526Vec2 a_future = SimulatePhys (a ,future ); 527Vec2 b_future = SimulatePhys (b ,future ); 528return Vec2_Distance (& a_future ,& b_future ); 529} 530 531// Spacies ------------------------------------------------ 532 533#define SP_UPB_CHANCE 12 534#define SP_JUMP_CHANCE_BELOW_LEDGE 4 535#define SP_JUMP_CHANCE_ABOVE_LEDGE 30 536#define SP_ILLUSION_CHANCE_ABOVE_LEDGE 30 537#define SP_ILLUSION_CHANCE_TO_LEDGE 12 538#define SP_FASTFALL_CHANCE 8 539 540#define SP_MAX_ILLUSION_HEIGHT 30.f 541#define SP_MIN_ILLUSION_HEIGHT -15.f 542#define SP_ILLUSION_DISTANCE 75.f 543#define SP_FIREFOX_DISTANCE 80.f 544#define SP_FIREBIRD_DISTANCE 70.f 545 546#define SP_SWEETSPOT_OFFSET_X 16 547#define SP_SWEETSPOT_OFFSET_Y 5 548 549static void Think_Spacies (GOBJ * cpu ,u32 opt_flags ) { 550FighterData * cpu_data = cpu -> userdata ; 551 552Vec2 pos = {cpu_data -> phys .pos .X ,cpu_data -> phys .pos .Y }; 553Vec2 vel = {cpu_data -> phys .self_vel .X ,cpu_data -> phys .self_vel .Y }; 554int state = cpu_data -> state_id ; 555float dir = pos .X > 0.f ?-1.f :1.f ; 556bool can_jump = cpu_data -> jump .jumps_used < 2 && OptEnabled (OPT_SPACIES_JUMP ); 557 558Vec2 target_ledge = ledge_positions [pos .X > 0.f ]; 559Vec2 target_ledgegrab = { 560 .X = target_ledge .X - SP_SWEETSPOT_OFFSET_X * dir , 561 .Y = target_ledge .Y - SP_SWEETSPOT_OFFSET_Y , 562 }; 563 564Vec2 vec_to_ledgegrab = { 565 .X = target_ledgegrab .X - pos .X , 566 .Y = target_ledgegrab .Y - pos .Y , 567 }; 568float distance_to_ledgegrab = Vec2_Length (& vec_to_ledgegrab ); 569 570int dj_chance ,illusion_chance ; 571if (cpu_data -> phys .pos .Y > target_ledge .Y ) { 572dj_chance = SP_JUMP_CHANCE_ABOVE_LEDGE ; 573illusion_chance = SP_ILLUSION_CHANCE_ABOVE_LEDGE ; 574 }else { 575dj_chance = SP_JUMP_CHANCE_BELOW_LEDGE ; 576illusion_chance = SP_ILLUSION_CHANCE_TO_LEDGE ; 577 } 578 579bool is_past_ledge = fabs (target_ledgegrab .X )> fabs (pos .X ); 580bool can_fall_to_ledge = is_past_ledge 581 |SimulatePhys_CanReachPoint (cpu_data ,target_ledgegrab ); 582 583bool can_upb = OptEnabled (OPT_SPACIES_FF_LOW ) 584 |OptEnabled (OPT_SPACIES_FF_MID ) 585 |OptEnabled (OPT_SPACIES_FF_HIGH ); 586 587float upb_distance = cpu_data -> kind == FTKIND_FOX ? 588SP_FIREFOX_DISTANCE :SP_FIREBIRD_DISTANCE ; 589 590// HITSTUN 591if (cpu_data -> flags .hitlag ) { 592DIIn (cpu_data ); 593 594// ACTIONABLE 595 }else if (IsAirActionable (cpu )) { 596 597// JUMP 598if ( 599OptEnabled (OPT_SPACIES_JUMP ) 600&& can_jump 601&& ( 602// force jump if at end of range 603distance_to_ledgegrab > upb_distance 604 605// otherwise, random chance to jump 606|| HSD_Randi (dj_chance )== 0 607 ) 608 ) { 609cpu_data -> cpu .held |=PAD_BUTTON_Y ; 610if (distance_to_ledgegrab > upb_distance ) 611cpu_data -> cpu .lstickX = 127 * dir ; 612else 613cpu_data -> cpu .lstickX = 127 * (HSD_Randi (3 )- 1 ); 614 615// ILLUSION 616 }else if ( 617OptEnabled (OPT_SPACIES_ILLUSION )&& ( 618// force illusion to ledge if no jump and cannot upb 619 ( 620 !can_upb && !can_jump 621&& SP_MIN_ILLUSION_HEIGHT < pos .Y 622&& pos .Y < SP_MIN_ILLUSION_HEIGHT + 5.f 623 ) 624 625// random chance to illusion 626|| ( 627pos .Y > SP_MIN_ILLUSION_HEIGHT 628&& pos .Y < SP_MAX_ILLUSION_HEIGHT 629&& fabs (vec_to_ledgegrab .X )< SP_ILLUSION_DISTANCE 630&& HSD_Randi (illusion_chance )== 0 631 ) 632 ) 633 ) { 634cpu_data -> cpu .lstickX = 127 * dir ; 635cpu_data -> cpu .held |=PAD_BUTTON_B ; 636 637// FIREFOX 638 }else if ( 639vel .Y <=1.5f 640&& can_upb 641&& !can_fall_to_ledge 642&& ( 643// force upb if at end of range 644 (pos .Y < 0.f && distance_to_ledgegrab > upb_distance ) 645 646// otherwise, random chance to upb 647|| ( 648distance_to_ledgegrab < upb_distance 649&& HSD_Randi (SP_UPB_CHANCE )== 0 650 ) 651 ) 652 ) { 653cpu_data -> cpu .lstickY = 127 ; 654cpu_data -> cpu .held |=PAD_BUTTON_B ; 655 656// FASTFALL 657 }else if ( 658OptEnabled (OPT_SPACIES_FASTFALL ) 659&& !cpu_data -> flags .is_fastfall 660&& vel .Y < 0.f 661&& HSD_Randi (SP_FASTFALL_CHANCE )== 0 662 ) { 663cpu_data -> cpu .lstickY = -127 ; 664 665// WAIT 666 }else { 667// drift towards stage 668cpu_data -> cpu .lstickX = 127 * dir ; 669 } 670 671// FIREFOX STARTUP 672 }else if (0x161 <=state && state <=0x162 ) { 673// compute firefox angle 674 675int low = OptEnabled (OPT_SPACIES_FF_LOW ); 676int mid = OptEnabled (OPT_SPACIES_FF_MID ); 677int high = OptEnabled (OPT_SPACIES_FF_HIGH ); 678int option_count = low + mid + high ; 679int choice = HSD_Randi (option_count ); 680 681float high_y ; 682if (vec_to_ledgegrab .X < upb_distance ) { 683high_y = pos .Y + sqrtf ( 684upb_distance * upb_distance 685- vec_to_ledgegrab .X * vec_to_ledgegrab .X 686 ); 687 }else { 688high_y = vec_to_ledgegrab .Y ; 689 } 690 691Vec2 target = { .X = target_ledgegrab .X }; 692if (low && choice -- == 0 ) { 693target .Y = target_ledgegrab .Y ; 694 }else if (mid && choice -- == 0 ) { 695target .Y = (target_ledgegrab .Y + high_y ) /2.f ; 696 }else if (high && choice -- == 0 ) { 697target .Y = high_y ; 698 } 699 700Vec2 vec_to_target = { 701 .X = target .X - pos .X , 702 .Y = target .Y - pos .Y , 703 }; 704Vec2_Normalize (& vec_to_target ); 705 706// place angles barely inside deadzone outside of deadzone 707if (-0.2875f < vec_to_target .X && vec_to_target .X <=-0.1375f ) 708vec_to_target .X = -0.2875f ; 709else if (0.2875f > vec_to_target .X && vec_to_target .X >=0.1375f ) 710vec_to_target .X = 0.2875f ; 711 712cpu_data -> cpu .lstickX = (s8 )(vec_to_target .X * 127.f ); 713cpu_data -> cpu .lstickY = (s8 )(vec_to_target .Y * 127.f ); 714 715// INACTIONABLE WITH DRIFT 716 }else if ( 717// if in firefox ending states 718 (0x162 <=state && state <=0x167 ) 719 720// or special fall 721|| (ASID_FALLSPECIAL <=state && state <=ASID_FALLSPECIALB ) 722 ) { 723// drift towards stage 724cpu_data -> cpu .lstickX = 127 * dir ; 725 } 726} 727 728// Sheik ------------------------------------------------ 729 730#define SK_UPB_POOF_NOT_ON_LEDGE_CHANCE 10 731#define SK_UPB_POOF_ON_LEDGE_CHANCE 5 732#define SK_UPB_JUMP_HEIGHT 48.f 733#define SK_UPB_JUMP_MAX_X 50.f 734#define SK_UPB_POOF_DISTANCE 40.f 735#define SK_FAIR_SIZE 18 736 737#define SK_JUMP_CHANCE_FAR_BELOW_LEDGE 4 738#define SK_JUMP_CHANCE_BELOW_LEDGE 30 739#define SK_JUMP_CHANCE_ABOVE_LEDGE 120 740#define SK_FAIR_CHANCE 5 741#define SK_AMSAH_TECH_CHANCE 1 742 743#define SK_SWEETSPOT_OFFSET_X 15 744#define SK_SWEETSPOT_OFFSET_Y 5 745 746// There is a frame between inputting the DI for the amsah tech 747// and inputting the tech direction. We need to make sure that 748// we tech the same as we DI, so we set this flag to prevent the CPU 749// from DIing in as usual in that frame. 750static bool amsah_teching = false; 751 752static void Think_Sheik (GOBJ * cpu ,u32 opt_flags ) { 753GOBJ * hmn = Fighter_GetGObj (0 ); 754FighterData * hmn_data = hmn -> userdata ; 755FighterData * cpu_data = cpu -> userdata ; 756 757Vec2 pos = {cpu_data -> phys .pos .X ,cpu_data -> phys .pos .Y }; 758Vec2 vel = {cpu_data -> phys .self_vel .X ,cpu_data -> phys .self_vel .Y }; 759int state = cpu_data -> state_id ; 760float dir = pos .X > 0.f ?-1.f :1.f ; 761bool can_jump = cpu_data -> jump .jumps_used < 2 && OptEnabled (OPT_SHEIK_JUMP ); 762bool hmn_on_ledge = hmn_data -> state_id == ASID_CLIFFWAIT ; 763 764Vec2 target_ledge = ledge_positions [pos .X > 0.f ]; 765Vec2 target_ledgegrab = { 766 .X = target_ledge .X - SK_SWEETSPOT_OFFSET_X * dir , 767 .Y = target_ledge .Y - SK_SWEETSPOT_OFFSET_Y , 768 }; 769 770Vec2 vec_to_ledgegrab = { 771 .X = target_ledgegrab .X - pos .X , 772 .Y = target_ledgegrab .Y - pos .Y , 773 }; 774Vec2 vec_to_ledge = { 775 .X = target_ledge .X - pos .X , 776 .Y = target_ledge .Y - pos .Y , 777 }; 778 779// how close sheik will be to the ledge after the jump 780Vec2 post_jump_vec_to_ledge = { 781 .X = fmax (fabs (vec_to_ledge .X )- SK_UPB_JUMP_MAX_X ,0.f )* dir , 782 .Y = vec_to_ledge .Y - SK_UPB_JUMP_HEIGHT , 783 }; 784float post_jump_dist_to_ledge = Vec2_Length (& post_jump_vec_to_ledge ); 785bool can_upb = post_jump_dist_to_ledge < SK_UPB_POOF_DISTANCE 786&& vel .Y < 1.f 787&& (!can_jump || post_jump_dist_to_ledge < 1.f ) 788&& ( 789OptEnabled (OPT_SHEIK_UPB_LEDGE ) 790|| OptEnabled (OPT_SHEIK_UPB_STAGE ) 791|| OptEnabled (OPT_SHEIK_UPB_HIGH ) 792 ); 793 794int dj_chance ; 795if (cpu_data -> phys .pos .Y > target_ledge .Y - 10.f ) { 796dj_chance = SK_JUMP_CHANCE_ABOVE_LEDGE ; 797 }else if (cpu_data -> phys .pos .Y > target_ledge .Y - 50.f ) { 798dj_chance = SK_JUMP_CHANCE_BELOW_LEDGE ; 799 }else { 800dj_chance = SK_JUMP_CHANCE_FAR_BELOW_LEDGE ; 801 } 802 803if (!cpu_data -> flags .hitstun ) 804amsah_teching = false; 805 806// AMSAH TECH 807if ( 808OptEnabled (OPT_SHEIK_AMSAH_TECH ) 809&& InHitstunAnim (state ) 810&& cpu_data -> TM .state_prev [0 ]== ASID_LANDINGFALLSPECIAL 811&& cpu_data -> flags .hitlag 812&& cpu_data -> dmg .hitlag_frames == 1.f 813&& HSD_Randi (SK_AMSAH_TECH_CHANCE )== 0 814 ) { 815cpu_data -> cpu .held |=PAD_TRIGGER_R ; 816cpu_data -> cpu .lstickX = 80 * - (int )cpu_data -> dmg .hit_log .direction ; 817cpu_data -> cpu .lstickY = -80 ; 818cpu_data -> cpu .cstickY = -127 ; 819amsah_teching = true; 820 821// HITSTUN 822 }else if (cpu_data -> flags .hitlag && !amsah_teching ) { 823DIIn (cpu_data ); 824 }else if (cpu_data -> flags .hitstun && amsah_teching ) { 825cpu_data -> cpu .lstickX = pos .X < hmn_data -> phys .pos .X ?-80 :80 ; 826cpu_data -> cpu .lstickY = -80 ; 827 828// ACTIONABLE 829 }else if (IsAirActionable (cpu )) { 830// JUMP 831if ( 832can_jump 833&& ( 834// force jump if at end of range 835 ( 836post_jump_dist_to_ledge > SK_UPB_POOF_DISTANCE 837&& vec_to_ledgegrab .Y > 10.f 838 ) 839 840// otherwise, random chance to jump 841|| HSD_Randi (dj_chance )== 0 842 ) 843 ) { 844cpu_data -> cpu .held |=PAD_BUTTON_Y ; 845cpu_data -> cpu .lstickX = 127 * dir ; 846 847// FAIR 848 }else if ( 849OptEnabled (OPT_SHEIK_FAIR ) 850&& !cpu_data -> flags .is_fastfall 851&& pos .X * dir < hmn_data -> phys .pos .X * dir 852&& hmn_data -> hurt .intang_frames .ledge < 5 853&& ProjectedDistance (hmn_data ,cpu_data ,6 )< SK_FAIR_SIZE 854 ) { 855cpu_data -> cpu .held |=PAD_BUTTON_A ; 856cpu_data -> cpu .lstickX = 127 * dir ; 857 858// UP B 859 }else if ( 860// random chance to upb 861 ( 862vec_to_ledgegrab .Y > 10.f 863&& can_upb 864&& !can_jump 865&& !hmn_on_ledge 866&& HSD_Randi (SK_UPB_POOF_NOT_ON_LEDGE_CHANCE )== 0 867 ) 868 869|| ( 870can_upb 871&& !can_jump 872&& hmn_on_ledge 873&& HSD_Randi (SK_UPB_POOF_ON_LEDGE_CHANCE )== 0 874 ) 875 876// force upb if at end of range 877|| ( 878vec_to_ledgegrab .Y > SK_UPB_JUMP_HEIGHT 879&& can_upb 880&& !can_jump 881&& post_jump_dist_to_ledge < SK_UPB_POOF_DISTANCE 882 ) 883 ) { 884cpu_data -> cpu .lstickY = 127 ; 885cpu_data -> cpu .held |=PAD_BUTTON_B ; 886 887// WAIT 888 }else { 889if (pos .X * dir < target_ledgegrab .X * dir ) 890cpu_data -> cpu .lstickX = 127 * dir ; 891else 892cpu_data -> cpu .lstickX = -127 * dir ; 893 } 894// VANISH STARTUP 895 }else if (state == 0x166 ) { 896// choose poof direction 897if (cpu_data -> TM .state_frame == 34 ) { 898int ledge = OptEnabled (OPT_SHEIK_UPB_LEDGE ); 899int stage_tip = OptEnabled (OPT_SHEIK_UPB_LEDGE ); 900int above_ledge = OptEnabled (OPT_SHEIK_UPB_HIGH )&& vec_to_ledgegrab .X < SK_UPB_POOF_DISTANCE ; 901int high = OptEnabled (OPT_SHEIK_UPB_HIGH ); 902int stage_inland = OptEnabled (OPT_SHEIK_UPB_STAGE )&& pos .Y > 0.f ; 903 904// double stage_inland chance 905int option_count = ledge + above_ledge + stage_tip + stage_inland + stage_inland + high ; 906int choice = HSD_Randi (option_count ); 907 908Vec2 target = {0 }; 909 910// upb to ledge 911if ((ledge && choice -- == 0 )|| option_count == 0 ) { 912target = target_ledge ; 913target .Y -= 13.f ; 914 915// upb to stage tip 916 }else if (stage_tip && choice -- == 0 ) { 917target = target_ledge ; 918target .Y -= 2.f ; 919if (pos .Y < target_ledge .Y ) 920target .Y -= 2.f ; 921if (pos .Y < target_ledge .Y - 10.f ) 922target .Y += 1.f ; 923if (pos .Y < target_ledge .Y - 28.f ) 924target .Y += 0.5f ; 925 926// upb above ledge 927 }else if (above_ledge && choice -- == 0 ) { 928float high_y = pos .Y + sqrtf ( 929SK_UPB_POOF_DISTANCE * SK_UPB_POOF_DISTANCE 930- vec_to_ledgegrab .X * vec_to_ledgegrab .X 931 ); 932target = (Vec2 ) {target_ledge .X ,high_y }; 933 934// upb high to platform 935 }else if (high && choice -- == 0 ) { 936target = (Vec2 ) {pos .X + dir ,pos .Y + 1.f };// TODO BETTER TARGETING 937 938// upb inwards to stage (doubled chance) 939 }else if (stage_inland && choice -- <=1 ) { 940target = (Vec2 ) {0.f ,0.f };// TODO BETTER TARGETING 941 } 942 943Vec2 poof_dir = { 944target .X - pos .X , 945target .Y - pos .Y , 946 }; 947Vec2_Normalize (& poof_dir ); 948 949cpu_data -> cpu .lstickX = (s8 )(poof_dir .X * 127.f ); 950cpu_data -> cpu .lstickY = (s8 )(poof_dir .Y * 127.f ); 951 952 }else { 953if (pos .Y > target_ledge .Y ) { 954cpu_data -> cpu .lstickX = dir * 127.f ; 955 }else { 956cpu_data -> cpu .lstickX = sign (vec_to_ledgegrab .X )* 127.f ; 957 } 958 } 959 960// SPECIAL FALL 961 }else if (ASID_FALLSPECIAL <=state && state <=ASID_FALLSPECIALB ) { 962// drift towards stage 963cpu_data -> cpu .lstickX = 127 * dir ; 964 } 965} 966 967// Falcon ------------------------------------------------ 968 969#define CF_SWEETSPOT_OFFSET_X 13 970#define CF_SWEETSPOT_OFFSET_Y 8 971#define CF_UPB_HEIGHT 48 972#define CF_JUMP_HEIGHT 40 973 974#define CF_UPB_CHANCE_FAR 5 975#define CF_UPB_CHANCE_WITH_JUMP 50 976#define CF_UPB_CHANCE_CLOSE 100 977#define CF_UPB_DRIFT_CHANGE_CHANCE 20 978#define CF_FALL_DRIFT_CHANGE_CHANCE 40 979#define CF_DOWNB_CHANCE 3 980#define CF_JUMP_CHANCE_BELOW_LEDGE 20 981#define CF_JUMP_CHANCE_ABOVE_LEDGE 40 982#define CF_JUMP_CHANCE_TO_LEDGE 8 983#define CF_FASTFALL_CHANCE 15 984 985#define CF_DRIFT_DURATION_LENGTH_CONST 5 986#define CF_DRIFT_DURATION_LENGTH_RNG 30 987 988static int drift_back_timer = 0 ; 989 990static void Think_Falcon (GOBJ * cpu ,u32 opt_flags ) { 991FighterData * cpu_data = cpu -> userdata ; 992 993Vec2 pos = {cpu_data -> phys .pos .X ,cpu_data -> phys .pos .Y }; 994Vec2 vel = {cpu_data -> phys .self_vel .X ,cpu_data -> phys .self_vel .Y }; 995int state = cpu_data -> state_id ; 996float dir = pos .X > 0.f ?-1.f :1.f ; 997 998Vec2 target_ledge = ledge_positions [pos .X > 0.f ]; 999Vec2 target_ledgegrab = { 1000 .X = target_ledge .X - CF_SWEETSPOT_OFFSET_X * dir , 1001 .Y = target_ledge .Y - CF_SWEETSPOT_OFFSET_Y , 1002 }; 1003 1004Vec2 vec_to_ledgegrab = { 1005 .X = target_ledgegrab .X - pos .X , 1006 .Y = target_ledgegrab .Y - pos .Y , 1007 }; 1008Vec2 vec_to_ledge = { 1009 .X = target_ledge .X - pos .X , 1010 .Y = target_ledge .Y - pos .Y , 1011 }; 1012bool past_ledge = fabs (pos .X )< fabs (target_ledgegrab .X ); 1013bool can_jump = cpu_data -> jump .jumps_used < 2 && OptEnabled (OPT_FALCON_JUMP ); 1014 1015int dj_chance ; 1016if (Within (vec_to_ledge .Y ,CF_JUMP_HEIGHT - 5.f ,10.f )&& vec_to_ledge .X * dir < 50.f ) { 1017dj_chance = CF_JUMP_CHANCE_TO_LEDGE ; 1018 }else if (cpu_data -> phys .pos .Y > target_ledge .Y - 10.f ) { 1019dj_chance = CF_JUMP_CHANCE_ABOVE_LEDGE ; 1020 }else { 1021dj_chance = CF_JUMP_CHANCE_BELOW_LEDGE ; 1022 } 1023 1024bool can_fall_to_ledge = SimulatePhys_CanReachPoint (cpu_data ,target_ledgegrab ); 1025int upb_chance ; 1026if (can_fall_to_ledge ) { 1027upb_chance = CF_UPB_CHANCE_CLOSE ; 1028 }else if (can_jump ) { 1029upb_chance = CF_UPB_CHANCE_WITH_JUMP ; 1030 }else { 1031upb_chance = CF_UPB_CHANCE_FAR ; 1032 } 1033 1034bool in_drift_back_zone = past_ledge 1035|| ( 1036vec_to_ledgegrab .Y < -30.f 1037&& ( 1038// rising drift 1039 (vel .Y > 1.f && - vec_to_ledgegrab .Y /1.5f > fabs (vec_to_ledgegrab .X )) 1040 1041// falling drift 1042|| (vel .Y <=1.f && - vec_to_ledgegrab .Y /3.f > fabs (vec_to_ledgegrab .X )) 1043 ) 1044 ); 1045 1046// HITSTUN 1047if (cpu_data -> flags .hitlag ) { 1048DIIn (cpu_data ); 1049 1050// STOP DRIFT BACK 1051 }else if (!in_drift_back_zone && drift_back_timer ) { 1052drift_back_timer = 0 ; 1053cpu_data -> cpu .lstickX = 0 ; 1054 1055// DRIFT BACK 1056 }else if (drift_back_timer ) { 1057drift_back_timer -- ; 1058if (drift_back_timer ) 1059cpu_data -> cpu .lstickX = -127 * dir ; 1060else 1061// frame with no drift - this allows faster drift change 1062cpu_data -> cpu .lstickX = 0 ; 1063 1064 }else if (IsAirActionable (cpu )) { 1065// JUMP 1066if ( 1067OptEnabled (OPT_FALCON_JUMP ) 1068&& can_jump 1069&& ( 1070// force jump if at end of range 1071vec_to_ledgegrab .Y > CF_UPB_HEIGHT 1072 1073// otherwise, random chance to jump 1074|| HSD_Randi (dj_chance )== 0 1075 ) 1076 ) { 1077cpu_data -> cpu .held |=PAD_BUTTON_Y ; 1078float jump_dir ; 1079if (Within (vec_to_ledge .Y ,CF_JUMP_HEIGHT - 5.f ,10.f )&& vec_to_ledge .X * dir < 50.f ) 1080jump_dir = sign (vec_to_ledgegrab .X ); 1081else 1082jump_dir = HSD_Randf ()* 2.f - 1.f ; 1083cpu_data -> cpu .lstickX = 127 * jump_dir ; 1084 1085// UPB 1086 }else if ( 1087OptEnabled (OPT_FALCON_UPB ) 1088&& ( 1089// random change to upb 1090 ( 1091vel .Y <=1.f 1092&& !past_ledge 1093&& vec_to_ledgegrab .Y < CF_UPB_HEIGHT 1094&& HSD_Randi (upb_chance )== 0 1095 ) 1096// force upb if at end of range 1097|| ( 1098vel .Y <=0.f 1099&& !can_jump 1100&& vec_to_ledgegrab .Y > CF_UPB_HEIGHT 1101 ) 1102 ) 1103 ) { 1104cpu_data -> cpu .lstickY = 127 ; 1105cpu_data -> cpu .held |=PAD_BUTTON_B ; 1106 1107// FALCON KICK 1108 }else if ( 1109OptEnabled (OPT_FALCON_DOWNB ) 1110&& pos .Y > 60.f 1111&& vel .Y < 0.f 1112&& fabs (vec_to_ledge .X )> 50.f 1113&& cpu_data -> jump .jumps_used == 2 1114&& HSD_Randi (CF_DOWNB_CHANCE )== 0 1115 ) { 1116cpu_data -> cpu .lstickY = -127 ; 1117cpu_data -> cpu .held |=PAD_BUTTON_B ; 1118 1119// DRIFT BACK 1120 }else if ( 1121OptEnabled (OPT_FALCON_DRIFT_BACK ) 1122&& in_drift_back_zone 1123&& vec_to_ledgegrab .Y < 0.f 1124&& HSD_Randi (CF_FALL_DRIFT_CHANGE_CHANCE )== 0 1125 ) { 1126drift_back_timer = HSD_Randi (CF_DRIFT_DURATION_LENGTH_RNG )+ CF_DRIFT_DURATION_LENGTH_CONST ; 1127// frame with no drift - this allows faster drift change 1128cpu_data -> cpu .lstickX = 0 ; 1129 }else { 1130cpu_data -> cpu .lstickX = 127 * dir ; 1131 } 1132 1133// UPB DRIFT 1134 }else if (state == 0x162 ) { 1135if ( 1136OptEnabled (OPT_FALCON_DRIFT_BACK ) 1137&& vec_to_ledgegrab .Y < 0.f 1138&& cpu_data -> TM .state_frame > 14 1139&& in_drift_back_zone 1140&& HSD_Randi (CF_UPB_DRIFT_CHANGE_CHANCE )== 0 1141 ) { 1142drift_back_timer = HSD_Randi (20 )+ 5 ; 1143// frame with no drift - this allows faster drift change 1144cpu_data -> cpu .lstickX = 0 ; 1145 }else { 1146cpu_data -> cpu .lstickX = 127 * dir ; 1147 } 1148 }else if (ASID_FALLSPECIAL <=state && state <=ASID_FALLSPECIALB ) { 1149// FASTFALL 1150if ( 1151OptEnabled (OPT_FALCON_FASTFALL ) 1152&& !cpu_data -> flags .is_fastfall 1153&& vel .Y < 0.f 1154&& (past_ledge || 1155- vec_to_ledgegrab .Y /3.f > fabs (vec_to_ledgegrab .X ) 1156 ) 1157&& HSD_Randi (CF_FASTFALL_CHANCE )== 0 1158 ) { 1159cpu_data -> cpu .lstickY = -127 ; 1160 }else { 1161cpu_data -> cpu .lstickX = 127 * dir ; 1162 } 1163 } 1164} 1165 1166// Marth ------------------------------------------------ 1167 1168#define MT_SWEETSPOT_OFFSET_X 12 1169#define MT_SWEETSPOT_OFFSET_Y 8 1170#define MT_JUMP_HEIGHT 36 1171#define MT_JUMP_DISTANCE 30 1172#define MT_UPB_STRAIGHT_HEIGHT 60 1173#define MT_UPB_STRAIGHT_DISTANCE 10 1174#define MT_UPB_CURLED_HEIGHT 55 1175#define MT_UPB_CURLED_DISTANCE 25 1176#define MT_FAIR_SIZE 25 1177 1178#define MT_JUMP_CHANCE 5 1179#define MT_UPB_EARLY_CHANCE 30 1180#define MT_SIDEB_DELAY_CHANCE 10 1181#define MT_FAIR_CHANCE 3 1182 1183static void Think_Marth (GOBJ * cpu ,u32 opt_flags ) { 1184GOBJ * hmn = Fighter_GetGObj (0 ); 1185FighterData * hmn_data = hmn -> userdata ; 1186FighterData * cpu_data = cpu -> userdata ; 1187 1188Vec2 pos = {cpu_data -> phys .pos .X ,cpu_data -> phys .pos .Y }; 1189Vec2 vel = {cpu_data -> phys .self_vel .X ,cpu_data -> phys .self_vel .Y }; 1190float dir = pos .X > 0.f ?-1.f :1.f ; 1191int state = cpu_data -> state_id ; 1192 1193Vec2 target_ledge = ledge_positions [pos .X > 0.f ]; 1194Vec2 target_ledgegrab = { 1195 .X = target_ledge .X - MT_SWEETSPOT_OFFSET_X * dir , 1196 .Y = target_ledge .Y - MT_SWEETSPOT_OFFSET_Y , 1197 }; 1198 1199Vec2 vec_to_ledgegrab = { 1200 .X = target_ledgegrab .X - pos .X , 1201 .Y = target_ledgegrab .Y - pos .Y , 1202 }; 1203 1204bool past_ledgegrab = fabs (pos .X )< fabs (target_ledgegrab .X ); 1205bool can_jump = cpu_data -> jump .jumps_used < 2 ; 1206bool can_upb = vec_to_ledgegrab .Y < MT_UPB_STRAIGHT_HEIGHT 1207&& vec_to_ledgegrab .X * dir < MT_UPB_CURLED_DISTANCE 1208&& (stc_stage -> kind != GRKIND_BATTLE || vec_to_ledgegrab .X * dir > 3.f ); 1209 1210if (cpu_data -> flags .hitlag ) { 1211DIIn (cpu_data ); 1212 }else if (IsAirActionable (cpu )) { 1213// SIDE B FAR 1214if ( 1215OptEnabled (OPT_MARTH_SIDEB ) 1216&& fabs (vec_to_ledgegrab .X )> 60.f 1217&& !past_ledgegrab 1218&& vel .Y < -0.5f 1219&& fabs (vel .X )> 0.8f 1220 ) { 1221cpu_data -> cpu .held |=PAD_BUTTON_B ; 1222cpu_data -> cpu .lstickX = 127 * dir ; 1223 1224// SIDE B WAIT 1225 }else if ( 1226OptEnabled (OPT_MARTH_SIDEB ) 1227&& vel .Y < 0.0f 1228&& vec_to_ledgegrab .Y > 10.f 1229&& vec_to_ledgegrab .Y < 35.f 1230&& ( 1231stc_stage -> kind != GRKIND_BATTLE || 1232fabs (SimulatePhys (cpu_data ,25 ).X )> fabs (target_ledgegrab .X ) 1233 ) 1234&& HSD_Randi (MT_SIDEB_DELAY_CHANCE )== 0 1235 ) { 1236cpu_data -> cpu .held |=PAD_BUTTON_B ; 1237cpu_data -> cpu .lstickX = 127 * dir ; 1238 1239// JUMP 1240 }else if ( 1241// random chance 1242 ( 1243OptEnabled (OPT_MARTH_JUMP ) 1244&& MT_JUMP_HEIGHT - 5.f < vec_to_ledgegrab .Y 1245&& vec_to_ledgegrab .Y < MT_JUMP_HEIGHT 1246&& can_jump 1247&& fabs (vec_to_ledgegrab .X )< MT_JUMP_DISTANCE 1248&& HSD_Randi (MT_JUMP_CHANCE )== 0 1249 ) 1250 1251// force jump if can't upb 1252|| ( 1253OptEnabled (OPT_MARTH_JUMP ) 1254&& vec_to_ledgegrab .Y > MT_UPB_STRAIGHT_HEIGHT 1255&& can_jump 1256 ) 1257 ) { 1258cpu_data -> cpu .held |=PAD_BUTTON_Y ; 1259if (past_ledgegrab ) 1260cpu_data -> cpu .lstickX = -127 * dir ; 1261else if (vec_to_ledgegrab .X * dir < MT_UPB_CURLED_DISTANCE ) 1262cpu_data -> cpu .lstickX = 0 ; 1263else 1264cpu_data -> cpu .lstickX = 127 * dir ; 1265 1266// FAIR 1267 }else if ( 1268OptEnabled (OPT_MARTH_FAIR ) 1269&& !cpu_data -> flags .is_fastfall 1270&& pos .X * dir < hmn_data -> phys .pos .X * dir 1271&& hmn_data -> hurt .intang_frames .ledge < 4 1272&& ProjectedDistance (hmn_data ,cpu_data ,5 )< MT_FAIR_SIZE 1273&& target_ledge .Y - SimulatePhys (cpu_data ,30 ).Y < MT_UPB_STRAIGHT_HEIGHT 1274&& HSD_Randi (MT_FAIR_CHANCE )== 0 1275 ) { 1276cpu_data -> cpu .held |=PAD_BUTTON_A ; 1277cpu_data -> cpu .lstickX = 127 * dir ; 1278 1279// UP B 1280 }else if ( 1281// random chance 1282 ( 1283OptEnabled (OPT_MARTH_UPB_EARLY ) 1284&& vec_to_ledgegrab .Y > 35.f 1285&& vec_to_ledgegrab .Y < MT_UPB_STRAIGHT_HEIGHT 1286&& can_upb 1287&& !can_jump 1288&& vel .Y < 1.f 1289&& HSD_Randi (MT_UPB_EARLY_CHANCE )== 0 1290 ) 1291 1292// force upb 1293|| ( 1294 ( 1295vec_to_ledgegrab .Y > MT_UPB_STRAIGHT_HEIGHT 1296|| ( 1297vec_to_ledgegrab .X * dir < MT_UPB_CURLED_DISTANCE 1298&& vec_to_ledgegrab .Y > MT_UPB_CURLED_HEIGHT 1299 ) 1300 ) 1301&& (!can_jump || !OptEnabled (OPT_MARTH_JUMP )) 1302&& vel .Y < 0.f 1303 ) 1304 ) { 1305cpu_data -> cpu .held |=PAD_BUTTON_B ; 1306cpu_data -> cpu .lstickY = 127 ; 1307 1308// WAIT 1309 }else { 1310if (pos .X * dir + 10.f < target_ledgegrab .X * dir ) 1311cpu_data -> cpu .lstickX = 127 * dir ; 1312else 1313cpu_data -> cpu .lstickX = -127 * dir ; 1314 } 1315 1316// DOLPHIN SLASH 1317 }else if (state == 0x170 ) { 1318// choose curl 1319if (cpu_data -> TM .state_frame == 3 ) { 1320float curl ;// -1 = full curl backwards, 1 = full curl forwards 1321 1322if (stc_stage -> kind == GRKIND_BATTLE && vec_to_ledgegrab .X * dir < 5.f ) { 1323curl = -1.f ; 1324 }else if (vec_to_ledgegrab .X * dir < MT_UPB_CURLED_DISTANCE && vec_to_ledgegrab .Y < MT_UPB_CURLED_HEIGHT ) { 1325curl = HSD_Randf ()* 0.3f + 0.7f ; 1326 }else if (vec_to_ledgegrab .X * dir > MT_UPB_CURLED_DISTANCE ) { 1327curl = 1.f ; 1328 }else if (vec_to_ledgegrab .Y > MT_UPB_STRAIGHT_HEIGHT ) { 1329curl = -1.f ; 1330 }else { 1331curl = Progress (vec_to_ledgegrab .X * dir ,MT_UPB_STRAIGHT_DISTANCE ,MT_UPB_CURLED_DISTANCE ); 1332curl = fclamp (curl ,-1.f ,1.f ); 1333 1334// similar function to sqrt but easier to compute 1335curl = (- (curl * curl )+ 2.f * fabs (curl ))* sign (curl ); 1336 } 1337 1338// curl starts from the opposite diagonal notch 1339if (curl < 0.f ) 1340curl /=2.f ; 1341 1342float ang = curl * M_PI /2.f ; 1343cpu_data -> cpu .lstickX = (127.f * sin (ang ))* dir ; 1344cpu_data -> cpu .lstickY = 127.f * cos (ang ); 1345 } 1346 1347else if (cpu_data -> TM .state_frame == 5 ) { 1348cpu_data -> cpu .lstickX = 127.f * dir ; 1349 } 1350 1351 }else if (ASID_ATTACKAIRN <=state && state <=ASID_ATTACKAIRLW ) { 1352cpu_data -> cpu .lstickX = 127 * sign (vec_to_ledgegrab .X ); 1353 1354 }else if (ASID_FALLSPECIAL <=state && state <=ASID_FALLSPECIALB ) { 1355cpu_data -> cpu .lstickX = 127 * sign (vec_to_ledgegrab .X ); 1356 } 1357} 1358 1359