fork/training-mode-ce

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

Alex Harrisonfix rerecord bug and prevent recovery AI from SDIing1617686

nix
41.4 KiB1359 linesraw
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[] = {
15    0, // MARIO
16    Think_Spacies, // FOX
17    Think_Falcon, // FALCON
18    0, // DK
19    0, // KIRBY
20    0, // BOWSER
21    0, // LINK
22    Think_Sheik, // SHEIK
23    0, // NESS
24    0, // PEACH
25    0, // POPO
26    0, // NANA
27    0, // PIKACHU
28    0, // SAMUS
29    0, // YOSHI
30    0, // JIGGLYPUFF
31    0, // MEWTWO
32    0, // LUIGI
33    Think_Marth, // MARTH
34    0, // ZELDA
35    0, // YOUNGLINK
36    0, // DRMARIO
37    Think_Spacies, // FALCO
38    0, // PICHU
39    0, // GAW,
40    0, // GANONDORF
41    0, // ROY
42};
43
44static Vec2 ledge_positions[2];
45
46static void GetLedgePositions(Vec2 coords_out[2]) {
47    static 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
59    int stage_id = Stage_GetExternalID();
60    char left_id = ledge_ids[stage_id][0];
61    char right_id = ledge_ids[stage_id][1];
62
63    Vec3 pos;
64    Stage_GetLeftOfLineCoordinates(left_id, &pos);
65    coords_out[0] = (Vec2) { pos.X, pos.Y };
66    Stage_GetRightOfLineCoordinates(right_id, &pos);
67    coords_out[1] = (Vec2) { pos.X, pos.Y };
68}
69
70static void DIIn(FighterData *cpu_data) {
71    bool right = cpu_data->phys.pos.X > 0.f;
72
73    cpu_data->cpu.lstickX = right ? -90 : 90;
74    cpu_data->cpu.lstickY = 90;
75
76    // Spoof last input as current input to prevent SDI
77    cpu_data->input.lstick.X = right ? -0.7f : 0.7f;
78    cpu_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) {
86    if (ledge_positions[0].X == 0.0f)
87        GetLedgePositions(ledge_positions);
88        
89    FighterData *cpu_data = cpu->userdata;
90    cpu_data->cpu.ai = 15; // noact
91    
92    // Common thinking -----------------------
93    
94    float x = cpu_data->phys.pos.X;
95    int state = cpu_data->state_id;
96    
97    // wall tech
98    cpu_data->input.timer_LR = 0;
99    
100    // if falling on stage, don't do anything
101    if (
102        (ASID_FALL <= state && state <= ASID_FALLAERIALB)
103        || (ASID_JUMPF <= state && state <= ASID_JUMPAERIALB)
104    ) {
105        float lx = ledge_positions[0].X;
106        float rx = ledge_positions[1].X;
107        
108        // if withing stage, at greater than CMN_FALL_MIN_DISTANCE units from ledge, just drop down.
109        if (lx + CMN_FALL_MIN_DISTANCE <= x && x <= rx - CMN_FALL_MIN_DISTANCE) {
110            cpu_data->cpu.lstickX = 0;
111            cpu_data->cpu.lstickY = 0;
112            return;
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) {
116            cpu_data->cpu.lstickX = -127 * sign(x);
117            cpu_data->cpu.lstickY = 0;
118            return;
119        } 
120    }
121    
122    // normal getup
123    if (state == ASID_CLIFFWAIT && cpu_data->TM.state_frame == 2) {
124        cpu_data->cpu.lstickX = -127 * sign(x);
125        cpu_data->cpu.lstickY = 0;
126        return;
127    }
128    
129    // angel platform
130    if (state == ASID_REBIRTHWAIT) {
131        cpu_data->cpu.lstickX = 0;
132        cpu_data->cpu.lstickY = -127;
133        return;
134    }
135    
136    // Character specific thinking ------------
137    
138    ThinkFn think_fn = ThinkFnLookup[cpu_data->kind];
139    if (think_fn) {
140        think_fn(cpu, opt_flags);
141    } else {
142        cpu_data->cpu.ai = 0;
143    }
144}
145
146enum options_spacies {
147    OPT_SPACIES_FF_LOW,
148    OPT_SPACIES_FF_MID,
149    OPT_SPACIES_FF_HIGH,
150    OPT_SPACIES_JUMP,
151    OPT_SPACIES_ILLUSION,
152    OPT_SPACIES_FASTFALL,
153    
154    OPT_SPACIES_COUNT
155};
156
157enum options_sheik {
158    OPT_SHEIK_UPB_LEDGE,
159    OPT_SHEIK_UPB_STAGE,
160    OPT_SHEIK_UPB_HIGH,
161    OPT_SHEIK_JUMP,
162    OPT_SHEIK_FAIR,
163    OPT_SHEIK_AMSAH_TECH,
164    
165    OPT_SHEIK_COUNT
166};
167
168enum options_falcon {
169    OPT_FALCON_UPB,
170    OPT_FALCON_DRIFT_BACK,
171    OPT_FALCON_JUMP,
172    OPT_FALCON_FASTFALL,
173    OPT_FALCON_DOWNB,
174
175    OPT_FALCON_COUNT
176};
177
178enum options_marth {
179    OPT_MARTH_UPB_EARLY,
180    OPT_MARTH_JUMP,
181    OPT_MARTH_SIDEB,
182    OPT_MARTH_FAIR,
183
184    OPT_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[] = {
388    0, // MARIO
389    &RecMenu_Fox,
390    &RecMenu_Falcon,
391    0, // DK
392    0, // KIRBY
393    0, // BOWSER
394    0, // LINK
395    &RecMenu_Sheik,
396    0, // NESS
397    0, // PEACH
398    0, // POPO
399    0, // NANA
400    0, // PIKACHU
401    0, // SAMUS
402    0, // YOSHI
403    0, // JIGGLYPUFF
404    0, // MEWTWO
405    0, // LUIGI
406    &RecMenu_Marth,
407    0, // ZELDA
408    0, // YOUNGLINK
409    0, // DRMARIO
410    &RecMenu_Falco,
411    0, // PICHU
412    0, // GAW,
413    0, // GANONDORF
414    0, // ROY
415};
416
417// Helper FNs ---------------------------------------------
418
419u32 RecoveryMenuOptFlags(GOBJ *cpu) {
420    FighterData *cpu_data = cpu->userdata;
421    EventMenu *menu = RecoveryMenus[cpu_data->kind];
422    if (menu == 0)
423        return 0;
424
425    u32 opt_flags = 0;
426    for (u32 opt = 0; opt < (u32)menu->option_num; ++opt)
427        opt_flags |= (u32)menu->options[opt].val << opt;
428    return 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) {
435    FighterData *data = fighter->userdata;
436    float hitstun;
437    memcpy(&hitstun, &data->state_var.state_var1, sizeof(float));
438    return hitstun == 0.0;
439}
440
441static int InHitstunAnim(int state) {
442    return ASID_DAMAGEHI1 <= state && state <= ASID_DAMAGEFLYROLL;
443}
444
445static bool IsAirActionable(GOBJ *fighter) {
446    FighterData *data = fighter->userdata;
447    
448    // ensure airborne
449    if (data->phys.air_state == 0)
450        return false;
451
452    int state = data->state_id;
453
454    if (InHitstunAnim(state)) {
455        if (HitstunEnded(fighter))
456            return true;
457        
458        FtDamage *dmg = (FtDamage *)&data->state_var;
459        if (dmg->is_meteor && dmg->meteor_lockout == 0)
460            return true;
461    }
462    
463    if (state == ASID_PASSIVEWALL && data->TM.state_frame > 5)
464        return true;
465        
466    if (state == ASID_PASSIVEWALLJUMP)
467        return true;
468        
469    if (ASID_ATTACKAIRN <= state && state <= ASID_ATTACKAIRLW && data->flags.past_iasa)
470        return true;
471
472    return (ASID_JUMPF <= state && state <= ASID_FALLAERIALB)
473        || state == ASID_DAMAGEFALL;
474}
475
476static float Vec2_Distance(Vec2 *a, Vec2 *b) {
477    float dx = a->X - b->X;
478    float dy = a->Y - b->Y;
479    return sqrtf(dx*dx + dy*dy);
480}
481
482static float Vec2_Length(Vec2 *a) {
483    float x = a->X;
484    float y = a->Y;
485    return sqrtf(x*x + y*y);
486}
487
488static void PhysStep(FighterData *data, Vec2 *pos, Vec2 *vel) {
489    float gravity = data->phys.air_state == 0 ? 0.f : data->attr.gravity;
490    float min_y_vel = data->flags.is_fastfall ?
491        -data->attr.fastfall_velocity
492        : -data->attr.terminal_velocity;
493        
494    pos->X += vel->X;
495    pos->Y += vel->Y;
496    vel->Y -= gravity;
497    vel->Y = fmax(vel->Y, min_y_vel);
498}
499
500static Vec2 SimulatePhys(FighterData *data, int future) {
501    Vec2 pos = { data->phys.pos.X, data->phys.pos.Y };
502    Vec2 vel = { data->phys.self_vel.X, data->phys.self_vel.Y };
503    for (int i = 0; i < future; ++i)
504        PhysStep(data, &pos, &vel);
505    
506    return pos;
507}
508
509static bool SimulatePhys_CanReachPoint(FighterData *data, Vec2 target) {
510    if (data->phys.air_state == 0) return false; 
511
512    Vec2 pos = { data->phys.pos.X, data->phys.pos.Y };
513    Vec2 vel = { data->phys.self_vel.X, data->phys.self_vel.Y };
514    
515    float dir = sign(target.X - pos.X);
516    if (sign(vel.X) != dir)
517        return false;
518    
519    while (target.Y < pos.Y || vel.Y >= 0.f)
520        PhysStep(data, &pos, &vel);
521        
522    return dir != sign(target.X - pos.X);
523}
524
525static float ProjectedDistance(FighterData *a, FighterData *b, int future) {
526    Vec2 a_future = SimulatePhys(a, future);
527    Vec2 b_future = SimulatePhys(b, future);
528    return 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) {
550    FighterData *cpu_data = cpu->userdata;
551
552    Vec2 pos = { cpu_data->phys.pos.X, cpu_data->phys.pos.Y };
553    Vec2 vel = { cpu_data->phys.self_vel.X, cpu_data->phys.self_vel.Y };
554    int state = cpu_data->state_id;
555    float dir = pos.X > 0.f ? -1.f : 1.f;
556    bool can_jump = cpu_data->jump.jumps_used < 2 && OptEnabled(OPT_SPACIES_JUMP);
557    
558    Vec2 target_ledge = ledge_positions[pos.X > 0.f];
559    Vec2 target_ledgegrab = {
560        .X = target_ledge.X - SP_SWEETSPOT_OFFSET_X*dir,
561        .Y = target_ledge.Y - SP_SWEETSPOT_OFFSET_Y,
562    };
563    
564    Vec2 vec_to_ledgegrab = {
565        .X = target_ledgegrab.X - pos.X,
566        .Y = target_ledgegrab.Y - pos.Y,
567    };
568    float distance_to_ledgegrab = Vec2_Length(&vec_to_ledgegrab);
569    
570    int dj_chance, illusion_chance;
571    if (cpu_data->phys.pos.Y > target_ledge.Y) {
572        dj_chance = SP_JUMP_CHANCE_ABOVE_LEDGE;
573        illusion_chance = SP_ILLUSION_CHANCE_ABOVE_LEDGE;
574    } else {
575        dj_chance = SP_JUMP_CHANCE_BELOW_LEDGE;
576        illusion_chance = SP_ILLUSION_CHANCE_TO_LEDGE;
577    }
578    
579    bool is_past_ledge = fabs(target_ledgegrab.X) > fabs(pos.X);
580    bool can_fall_to_ledge = is_past_ledge
581        | SimulatePhys_CanReachPoint(cpu_data, target_ledgegrab);
582    
583    bool can_upb = OptEnabled(OPT_SPACIES_FF_LOW)
584        | OptEnabled(OPT_SPACIES_FF_MID)
585        | OptEnabled(OPT_SPACIES_FF_HIGH);
586    
587    float upb_distance = cpu_data->kind == FTKIND_FOX ?
588        SP_FIREFOX_DISTANCE : SP_FIREBIRD_DISTANCE;
589    
590    // HITSTUN
591    if (cpu_data->flags.hitlag) {
592        DIIn(cpu_data);
593        
594    // ACTIONABLE
595    } else if (IsAirActionable(cpu)) {
596
597        // JUMP
598        if (
599            OptEnabled(OPT_SPACIES_JUMP)
600            && can_jump
601            && (
602                // force jump if at end of range
603                distance_to_ledgegrab > upb_distance
604                
605                // otherwise, random chance to jump
606                || HSD_Randi(dj_chance) == 0
607            )
608        ) {
609            cpu_data->cpu.held |= PAD_BUTTON_Y;
610            if (distance_to_ledgegrab > upb_distance)
611                cpu_data->cpu.lstickX = 127 * dir;
612            else 
613                cpu_data->cpu.lstickX = 127 * (HSD_Randi(3) - 1);
614            
615        // ILLUSION
616        } else if (
617            OptEnabled(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                || (
627                    pos.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        ) {
634            cpu_data->cpu.lstickX = 127 * dir;
635            cpu_data->cpu.held |= PAD_BUTTON_B;
636            
637        // FIREFOX
638        } else if (
639            vel.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                || (
648                    distance_to_ledgegrab < upb_distance
649                    && HSD_Randi(SP_UPB_CHANCE) == 0
650                )
651            )
652        ) {
653            cpu_data->cpu.lstickY = 127;
654            cpu_data->cpu.held |= PAD_BUTTON_B;
655            
656        // FASTFALL
657        } else if (
658            OptEnabled(OPT_SPACIES_FASTFALL)
659            && !cpu_data->flags.is_fastfall
660            && vel.Y < 0.f
661            && HSD_Randi(SP_FASTFALL_CHANCE) == 0
662        ) {
663            cpu_data->cpu.lstickY = -127;
664            
665        // WAIT
666        } else {
667            // drift towards stage
668            cpu_data->cpu.lstickX = 127 * dir;
669        }
670        
671    // FIREFOX STARTUP
672    } else if (0x161 <= state && state <= 0x162) {
673        // compute firefox angle
674        
675        int low = OptEnabled(OPT_SPACIES_FF_LOW);
676        int mid = OptEnabled(OPT_SPACIES_FF_MID);
677        int high = OptEnabled(OPT_SPACIES_FF_HIGH);
678        int option_count = low + mid + high;
679        int choice = HSD_Randi(option_count);
680        
681        float high_y;
682        if (vec_to_ledgegrab.X < upb_distance) {
683            high_y = pos.Y + sqrtf(
684                upb_distance*upb_distance
685                - vec_to_ledgegrab.X*vec_to_ledgegrab.X
686            );
687        } else {
688            high_y = vec_to_ledgegrab.Y;
689        }
690        
691        Vec2 target = { .X = target_ledgegrab.X };
692        if (low && choice-- == 0) {
693            target.Y = target_ledgegrab.Y;
694        } else if (mid && choice-- == 0) {
695            target.Y = (target_ledgegrab.Y + high_y) / 2.f;
696        } else if (high && choice-- == 0) {
697            target.Y = high_y;
698        }
699        
700        Vec2 vec_to_target = {
701            .X = target.X - pos.X,
702            .Y = target.Y - pos.Y,
703        };
704        Vec2_Normalize(&vec_to_target);
705        
706        // place angles barely inside deadzone outside of deadzone
707        if (-0.2875f < vec_to_target.X && vec_to_target.X <= -0.1375f)
708            vec_to_target.X = -0.2875f;
709        else if (0.2875f > vec_to_target.X && vec_to_target.X >= 0.1375f)
710            vec_to_target.X = 0.2875f;
711
712        cpu_data->cpu.lstickX = (s8)(vec_to_target.X * 127.f);
713        cpu_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
724        cpu_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) {
753    GOBJ *hmn = Fighter_GetGObj(0);
754    FighterData *hmn_data = hmn->userdata;
755    FighterData *cpu_data = cpu->userdata;
756
757    Vec2 pos = { cpu_data->phys.pos.X, cpu_data->phys.pos.Y };
758    Vec2 vel = { cpu_data->phys.self_vel.X, cpu_data->phys.self_vel.Y };
759    int state = cpu_data->state_id;
760    float dir = pos.X > 0.f ? -1.f : 1.f;
761    bool can_jump = cpu_data->jump.jumps_used < 2 && OptEnabled(OPT_SHEIK_JUMP);
762    bool hmn_on_ledge = hmn_data->state_id == ASID_CLIFFWAIT;
763    
764    Vec2 target_ledge = ledge_positions[pos.X > 0.f];
765    Vec2 target_ledgegrab = {
766        .X = target_ledge.X - SK_SWEETSPOT_OFFSET_X*dir,
767        .Y = target_ledge.Y - SK_SWEETSPOT_OFFSET_Y,
768    };
769    
770    Vec2 vec_to_ledgegrab = {
771        .X = target_ledgegrab.X - pos.X,
772        .Y = target_ledgegrab.Y - pos.Y,
773    };
774    Vec2 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
780    Vec2 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    };
784    float post_jump_dist_to_ledge = Vec2_Length(&post_jump_vec_to_ledge);
785    bool 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        && (
789            OptEnabled(OPT_SHEIK_UPB_LEDGE)
790            || OptEnabled(OPT_SHEIK_UPB_STAGE)
791            || OptEnabled(OPT_SHEIK_UPB_HIGH)
792        );
793    
794    int dj_chance;
795    if (cpu_data->phys.pos.Y > target_ledge.Y - 10.f) {
796        dj_chance = SK_JUMP_CHANCE_ABOVE_LEDGE;
797    } else if (cpu_data->phys.pos.Y > target_ledge.Y - 50.f) {
798        dj_chance = SK_JUMP_CHANCE_BELOW_LEDGE;
799    } else {
800        dj_chance = SK_JUMP_CHANCE_FAR_BELOW_LEDGE;
801    }
802    
803    if (!cpu_data->flags.hitstun)
804        amsah_teching = false;
805    
806    // AMSAH TECH
807    if (
808        OptEnabled(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    ) {
815        cpu_data->cpu.held |= PAD_TRIGGER_R;
816        cpu_data->cpu.lstickX = 80 * -(int)cpu_data->dmg.hit_log.direction;
817        cpu_data->cpu.lstickY = -80;
818        cpu_data->cpu.cstickY = -127;
819        amsah_teching = true;
820
821    // HITSTUN
822    } else if (cpu_data->flags.hitlag && !amsah_teching) {
823        DIIn(cpu_data);
824    } else if (cpu_data->flags.hitstun && amsah_teching) {
825        cpu_data->cpu.lstickX = pos.X < hmn_data->phys.pos.X ? -80 : 80;
826        cpu_data->cpu.lstickY = -80;
827        
828    // ACTIONABLE
829    } else if (IsAirActionable(cpu)) {
830        // JUMP
831        if (
832            can_jump
833            && (
834                // force jump if at end of range
835                (
836                    post_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        ) {
844            cpu_data->cpu.held |= PAD_BUTTON_Y;
845            cpu_data->cpu.lstickX = 127 * dir;
846            
847        // FAIR
848        } else if (
849            OptEnabled(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        ) {
855            cpu_data->cpu.held |= PAD_BUTTON_A;
856            cpu_data->cpu.lstickX = 127 * dir;
857            
858        // UP B
859        } else if (
860            // random chance to upb
861            (
862                vec_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            || (
870                can_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            || (
878                vec_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        ) {
884            cpu_data->cpu.lstickY = 127;
885            cpu_data->cpu.held |= PAD_BUTTON_B;
886        
887        // WAIT 
888        } else {
889            if (pos.X * dir < target_ledgegrab.X * dir)
890                cpu_data->cpu.lstickX = 127 * dir;
891            else
892                cpu_data->cpu.lstickX = -127 * dir;
893        }
894    // VANISH STARTUP
895    } else if (state == 0x166) {
896        // choose poof direction
897        if (cpu_data->TM.state_frame == 34) {
898            int ledge = OptEnabled(OPT_SHEIK_UPB_LEDGE);
899            int stage_tip = OptEnabled(OPT_SHEIK_UPB_LEDGE);
900            int above_ledge = OptEnabled(OPT_SHEIK_UPB_HIGH) && vec_to_ledgegrab.X < SK_UPB_POOF_DISTANCE;
901            int high = OptEnabled(OPT_SHEIK_UPB_HIGH);
902            int stage_inland = OptEnabled(OPT_SHEIK_UPB_STAGE) && pos.Y > 0.f;
903            
904            // double stage_inland chance
905            int option_count = ledge + above_ledge + stage_tip + stage_inland + stage_inland + high;
906            int choice = HSD_Randi(option_count);
907            
908            Vec2 target = {0};
909            
910            // upb to ledge
911            if ((ledge && choice-- == 0) || option_count == 0) {
912                target = target_ledge;
913                target.Y -= 13.f;
914                    
915            // upb to stage tip
916            } else if (stage_tip && choice-- == 0) {
917                target = target_ledge;
918                target.Y -= 2.f;
919                if (pos.Y < target_ledge.Y)
920                    target.Y -= 2.f;
921                if (pos.Y < target_ledge.Y-10.f)
922                    target.Y += 1.f;
923                if (pos.Y < target_ledge.Y-28.f)
924                    target.Y += 0.5f;
925                
926            // upb above ledge
927            } else if (above_ledge && choice-- == 0) {
928                float high_y = pos.Y + sqrtf(
929                    SK_UPB_POOF_DISTANCE*SK_UPB_POOF_DISTANCE
930                    - vec_to_ledgegrab.X*vec_to_ledgegrab.X
931                );
932                target = (Vec2) { target_ledge.X, high_y };
933                
934            // upb high to platform
935            } else if (high && choice-- == 0) {
936                target = (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) {
940                target = (Vec2) { 0.f, 0.f }; // TODO BETTER TARGETING
941            }
942            
943            Vec2 poof_dir = {
944                target.X - pos.X,
945                target.Y - pos.Y,
946            };
947            Vec2_Normalize(&poof_dir);
948            
949            cpu_data->cpu.lstickX = (s8)(poof_dir.X * 127.f);
950            cpu_data->cpu.lstickY = (s8)(poof_dir.Y * 127.f);
951            
952        } else {
953            if (pos.Y > target_ledge.Y) {
954                cpu_data->cpu.lstickX = dir * 127.f;
955            } else {
956                cpu_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
963        cpu_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) {
991    FighterData *cpu_data = cpu->userdata;
992
993    Vec2 pos = { cpu_data->phys.pos.X, cpu_data->phys.pos.Y };
994    Vec2 vel = { cpu_data->phys.self_vel.X, cpu_data->phys.self_vel.Y };
995    int state = cpu_data->state_id;
996    float dir = pos.X > 0.f ? -1.f : 1.f;
997    
998    Vec2 target_ledge = ledge_positions[pos.X > 0.f];
999    Vec2 target_ledgegrab = {
1000        .X = target_ledge.X - CF_SWEETSPOT_OFFSET_X*dir,
1001        .Y = target_ledge.Y - CF_SWEETSPOT_OFFSET_Y,
1002    };
1003    
1004    Vec2 vec_to_ledgegrab = {
1005        .X = target_ledgegrab.X - pos.X,
1006        .Y = target_ledgegrab.Y - pos.Y,
1007    };
1008    Vec2 vec_to_ledge = {
1009        .X = target_ledge.X - pos.X,
1010        .Y = target_ledge.Y - pos.Y,
1011    };
1012    bool past_ledge = fabs(pos.X) < fabs(target_ledgegrab.X);
1013    bool can_jump = cpu_data->jump.jumps_used < 2 && OptEnabled(OPT_FALCON_JUMP);
1014    
1015    int dj_chance;
1016    if (Within(vec_to_ledge.Y, CF_JUMP_HEIGHT - 5.f, 10.f) && vec_to_ledge.X * dir < 50.f) {
1017        dj_chance = CF_JUMP_CHANCE_TO_LEDGE;
1018    } else if (cpu_data->phys.pos.Y > target_ledge.Y - 10.f) {
1019        dj_chance = CF_JUMP_CHANCE_ABOVE_LEDGE;
1020    } else {
1021        dj_chance = CF_JUMP_CHANCE_BELOW_LEDGE;
1022    }
1023    
1024    bool can_fall_to_ledge = SimulatePhys_CanReachPoint(cpu_data, target_ledgegrab);
1025    int upb_chance;
1026    if (can_fall_to_ledge) {
1027        upb_chance = CF_UPB_CHANCE_CLOSE;
1028    } else if (can_jump) {
1029        upb_chance = CF_UPB_CHANCE_WITH_JUMP;
1030    } else {
1031        upb_chance = CF_UPB_CHANCE_FAR;
1032    }
1033    
1034    bool in_drift_back_zone = past_ledge
1035        || (
1036            vec_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
1047    if (cpu_data->flags.hitlag) {
1048        DIIn(cpu_data);
1049        
1050    // STOP DRIFT BACK
1051    } else if (!in_drift_back_zone && drift_back_timer) {
1052        drift_back_timer = 0;
1053        cpu_data->cpu.lstickX = 0;
1054    
1055    // DRIFT BACK
1056    } else if (drift_back_timer) {
1057        drift_back_timer--;
1058        if (drift_back_timer)
1059            cpu_data->cpu.lstickX = -127 * dir;
1060        else
1061            // frame with no drift - this allows faster drift change
1062            cpu_data->cpu.lstickX = 0;
1063            
1064    } else if (IsAirActionable(cpu)) {
1065        // JUMP
1066        if (
1067            OptEnabled(OPT_FALCON_JUMP)
1068            && can_jump
1069            && (
1070                // force jump if at end of range
1071                vec_to_ledgegrab.Y > CF_UPB_HEIGHT
1072                
1073                // otherwise, random chance to jump
1074                || HSD_Randi(dj_chance) == 0
1075            )
1076        ) {
1077            cpu_data->cpu.held |= PAD_BUTTON_Y;
1078            float jump_dir;
1079            if (Within(vec_to_ledge.Y, CF_JUMP_HEIGHT - 5.f, 10.f) && vec_to_ledge.X * dir < 50.f)
1080                jump_dir = sign(vec_to_ledgegrab.X);
1081            else
1082                jump_dir = HSD_Randf() * 2.f - 1.f;
1083            cpu_data->cpu.lstickX = 127 * jump_dir;
1084            
1085        // UPB
1086        } else if (
1087            OptEnabled(OPT_FALCON_UPB) 
1088            && (
1089                // random change to upb
1090                (
1091                    vel.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                || (
1098                    vel.Y <= 0.f
1099                    && !can_jump
1100                    && vec_to_ledgegrab.Y > CF_UPB_HEIGHT
1101                )
1102            )
1103        ) {
1104            cpu_data->cpu.lstickY = 127;
1105            cpu_data->cpu.held |= PAD_BUTTON_B;
1106            
1107        // FALCON KICK
1108        } else if (
1109            OptEnabled(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        ) {
1116            cpu_data->cpu.lstickY = -127;
1117            cpu_data->cpu.held |= PAD_BUTTON_B;
1118            
1119        // DRIFT BACK
1120        } else if (
1121            OptEnabled(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        ) {
1126            drift_back_timer = HSD_Randi(CF_DRIFT_DURATION_LENGTH_RNG) + CF_DRIFT_DURATION_LENGTH_CONST;
1127            // frame with no drift - this allows faster drift change
1128            cpu_data->cpu.lstickX = 0;
1129        } else {
1130            cpu_data->cpu.lstickX = 127 * dir;
1131        }
1132        
1133    // UPB DRIFT
1134    } else if (state == 0x162) {
1135        if (
1136            OptEnabled(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        ) {
1142            drift_back_timer = HSD_Randi(20) + 5;
1143            // frame with no drift - this allows faster drift change
1144            cpu_data->cpu.lstickX = 0;
1145        } else {
1146            cpu_data->cpu.lstickX = 127 * dir;
1147        }
1148    } else if (ASID_FALLSPECIAL <= state && state <= ASID_FALLSPECIALB) {
1149        // FASTFALL
1150        if (
1151            OptEnabled(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        ) {
1159            cpu_data->cpu.lstickY = -127;
1160        } else {
1161            cpu_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) {
1184    GOBJ *hmn = Fighter_GetGObj(0);
1185    FighterData *hmn_data = hmn->userdata;
1186    FighterData *cpu_data = cpu->userdata;
1187    
1188    Vec2 pos = { cpu_data->phys.pos.X, cpu_data->phys.pos.Y };
1189    Vec2 vel = { cpu_data->phys.self_vel.X, cpu_data->phys.self_vel.Y };
1190    float dir = pos.X > 0.f ? -1.f : 1.f;
1191    int state = cpu_data->state_id;
1192    
1193    Vec2 target_ledge = ledge_positions[pos.X > 0.f];
1194    Vec2 target_ledgegrab = {
1195        .X = target_ledge.X - MT_SWEETSPOT_OFFSET_X*dir,
1196        .Y = target_ledge.Y - MT_SWEETSPOT_OFFSET_Y,
1197    };
1198    
1199    Vec2 vec_to_ledgegrab = {
1200        .X = target_ledgegrab.X - pos.X,
1201        .Y = target_ledgegrab.Y - pos.Y,
1202    };
1203    
1204    bool past_ledgegrab = fabs(pos.X) < fabs(target_ledgegrab.X);
1205    bool can_jump = cpu_data->jump.jumps_used < 2;
1206    bool 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
1210    if (cpu_data->flags.hitlag) {
1211        DIIn(cpu_data);
1212    } else if (IsAirActionable(cpu)) {
1213        // SIDE B FAR
1214        if (
1215            OptEnabled(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        ) {
1221            cpu_data->cpu.held |= PAD_BUTTON_B;
1222            cpu_data->cpu.lstickX = 127 * dir;
1223            
1224        // SIDE B WAIT
1225        } else if (
1226            OptEnabled(OPT_MARTH_SIDEB)
1227            && vel.Y < 0.0f
1228            && vec_to_ledgegrab.Y > 10.f 
1229            && vec_to_ledgegrab.Y < 35.f 
1230            && (
1231                stc_stage->kind != GRKIND_BATTLE ||
1232                fabs(SimulatePhys(cpu_data, 25).X) > fabs(target_ledgegrab.X)
1233            )
1234            && HSD_Randi(MT_SIDEB_DELAY_CHANCE) == 0
1235        ) {
1236            cpu_data->cpu.held |= PAD_BUTTON_B;
1237            cpu_data->cpu.lstickX = 127 * dir;
1238            
1239        // JUMP
1240        } else if (
1241            // random chance
1242            (
1243                OptEnabled(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            || (
1253                OptEnabled(OPT_MARTH_JUMP)
1254                && vec_to_ledgegrab.Y > MT_UPB_STRAIGHT_HEIGHT
1255                && can_jump
1256            )
1257        ) {
1258            cpu_data->cpu.held |= PAD_BUTTON_Y;
1259            if (past_ledgegrab)
1260                cpu_data->cpu.lstickX = -127 * dir;
1261            else if (vec_to_ledgegrab.X * dir < MT_UPB_CURLED_DISTANCE)
1262                cpu_data->cpu.lstickX = 0;
1263            else
1264                cpu_data->cpu.lstickX = 127 * dir;
1265        
1266        // FAIR
1267        } else if (
1268            OptEnabled(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        ) {
1276            cpu_data->cpu.held |= PAD_BUTTON_A;
1277            cpu_data->cpu.lstickX = 127 * dir;
1278            
1279        // UP B
1280        } else if (
1281            // random chance
1282            (
1283                OptEnabled(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                (
1295                    vec_to_ledgegrab.Y > MT_UPB_STRAIGHT_HEIGHT
1296                    || (
1297                        vec_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        ) {
1305            cpu_data->cpu.held |= PAD_BUTTON_B;
1306            cpu_data->cpu.lstickY = 127;
1307            
1308        // WAIT
1309        } else {
1310            if (pos.X * dir + 10.f < target_ledgegrab.X * dir)
1311                cpu_data->cpu.lstickX = 127 * dir;
1312            else
1313                cpu_data->cpu.lstickX = -127 * dir;
1314        }
1315    
1316    // DOLPHIN SLASH
1317    } else if (state == 0x170) {
1318        // choose curl
1319        if (cpu_data->TM.state_frame == 3) {
1320            float curl; // -1 = full curl backwards, 1 = full curl forwards
1321            
1322            if (stc_stage->kind == GRKIND_BATTLE && vec_to_ledgegrab.X * dir < 5.f) {
1323                curl = -1.f;
1324            } else if (vec_to_ledgegrab.X * dir < MT_UPB_CURLED_DISTANCE && vec_to_ledgegrab.Y < MT_UPB_CURLED_HEIGHT) {
1325                curl = HSD_Randf() * 0.3f + 0.7f;
1326            } else if (vec_to_ledgegrab.X * dir > MT_UPB_CURLED_DISTANCE) {
1327                curl = 1.f;
1328            } else if (vec_to_ledgegrab.Y > MT_UPB_STRAIGHT_HEIGHT) {
1329                curl = -1.f;
1330            } else {
1331                curl = Progress(vec_to_ledgegrab.X * dir, MT_UPB_STRAIGHT_DISTANCE, MT_UPB_CURLED_DISTANCE);
1332                curl = fclamp(curl, -1.f, 1.f);
1333                
1334                // similar function to sqrt but easier to compute
1335                curl = (-(curl*curl) + 2.f * fabs(curl)) * sign(curl);
1336            }
1337            
1338            // curl starts from the opposite diagonal notch
1339            if (curl < 0.f)
1340                curl /= 2.f;
1341            
1342            float ang = curl * M_PI / 2.f;
1343            cpu_data->cpu.lstickX = (127.f * sin(ang)) * dir;
1344            cpu_data->cpu.lstickY = 127.f * cos(ang);
1345        }
1346        
1347        else if (cpu_data->TM.state_frame == 5) {
1348            cpu_data->cpu.lstickX = 127.f * dir;
1349        }
1350
1351    } else if (ASID_ATTACKAIRN <= state && state <= ASID_ATTACKAIRLW) {
1352        cpu_data->cpu.lstickX = 127 * sign(vec_to_ledgegrab.X);
1353        
1354    } else if (ASID_FALLSPECIAL <= state && state <= ASID_FALLSPECIALB) {
1355        cpu_data->cpu.lstickX = 127 * sign(vec_to_ledgegrab.X);
1356    }
1357}
1358
1359