fork/training-mode-ce

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

AitchMerge pull request #307 from NickCondron/wd4578fd4

master
21.0 KiB676 linesraw
1#include "wavedash.h"
2#include "events.h"
3
4enum options {
5    OPT_TARGET,
6    OPT_SHORT_HOP,
7    OPT_HUD,
8    OPT_TIPS,
9    OPT_HELP,
10    OPT_EXIT,
11
12    OPT_COUNT
13};
14
15// Main Menu
16static EventOption WdOptions_Main[] = {
17    // Target
18    {
19        .kind = OPTKIND_TOGGLE,
20        .name = "Target",
21        .desc = {"Highlight an area of the stage to wavedash towards."},
22    },
23    // Short Hop
24    {
25        .kind = OPTKIND_TOGGLE,
26        .name = "Short Hop Indicator",
27        .val = 1,
28        .desc = {"A sparkling indicator for when you short hop.",
29                 "Short hops can avoid excess frames spent",
30                 "in airdodge in case you are late, especially",
31                 "at long/sharp wavedash angles"},
32    },
33    // HUD
34    {
35        .kind = OPTKIND_TOGGLE,
36        .name = "HUD",
37        .desc = {"Toggle visibility of the HUD."},
38        .val = 1,
39        .OnChange = Wavedash_ChangeShowHUD,
40    },
41    // Tips
42    {
43        .kind = OPTKIND_TOGGLE,
44        .name = "Tips",
45        .desc = {"Toggle the onscreen display of tips."},
46        .val = 1,
47    },
48    // Help
49    {
50        .kind = OPTKIND_INFO,
51        .name = "Help",
52        .desc =
53            {"A wavedash is performed by air-dodging diagonally down",
54             "as soon you leave the ground from a jump, causing the fighter",
55             "to slide a short distance. This technique will allow you to quickly",
56             "adjust your position and even attack while sliding."},
57    },
58    // Exit
59    {
60        .kind = OPTKIND_FUNC,
61        .name = "Exit",
62        .desc = {"Return to the Event Selection Screen."},
63        .OnSelect = Event_Exit,
64    },
65};
66static EventMenu WdMenu_Main = {
67    .name = "Wavedash Training",
68    .option_num = sizeof(WdOptions_Main) / sizeof(EventOption),
69    .options = WdOptions_Main,
70};
71
72// Init Function
73void Event_Init(GOBJ *gobj)
74{
75    WavedashData *event_data = gobj->userdata;
76    GOBJ *hmn = Fighter_GetGObj(0);
77    FighterData *hmn_data = hmn->userdata;
78
79    // get wavedash assets
80    event_data->assets = Archive_GetPublicAddress(event_vars->event_archive, "wavedash");
81
82    // create HUD
83    Wavedash_Init(event_data);
84
85    // init target
86    Target_Init(event_data, hmn_data);
87}
88// Think Function
89void Event_Think(GOBJ *event)
90{
91    WavedashData *event_data = event->userdata;
92    GOBJ *hmn = Fighter_GetGObj(0);
93    FighterData *hmn_data = hmn->userdata;
94    JOBJ *hud_jobj = event_data->hud.gobj->hsd_object;
95
96    // infinite shields
97    hmn_data->shield.health = 60;
98
99    Wavedash_Think(event_data, hmn_data);
100
101    // update target
102    Target_Manager(event_data, hmn_data);
103
104    // run tip logic
105    Tips_Think(event_data, hmn_data);
106
107    // update HUD anim
108    JOBJ_AnimAll(hud_jobj);
109
110    // update arrow animation
111    if (event_data->hud.arrow_timer > 0)
112    {
113        event_data->hud.arrow_timer--;
114
115        // get this frames position
116        float time = 1 - ((float)event_data->hud.arrow_timer / (float)WDARROW_ANIMFRAMES);
117        float xpos = smooth_lerp(time, event_data->hud.arrow_prevpos, event_data->hud.arrow_nextpos);
118
119        // update position
120        JOBJ *arrow_jobj;
121        JOBJ_GetChild(hud_jobj, &arrow_jobj, WDJOBJ_ARROW, -1); // get timing bar jobj
122        arrow_jobj->trans.X = xpos;
123        JOBJ_SetMtxDirtySub(arrow_jobj);
124    }
125}
126void Event_Exit(GOBJ *menu)
127{
128    // end game
129    stc_match->state = 3;
130
131    // cleanup
132    Match_EndVS();
133}
134
135// Event functions
136void Wavedash_Init(WavedashData *event_data)
137{
138    GOBJ *hud_gobj = GObj_Create(0, 0, 0);
139    event_data->hud.gobj = hud_gobj;
140    // Load jobj
141    JOBJ *hud_jobj = JOBJ_LoadJoint(event_data->assets->hud);
142    GObj_AddObject(hud_gobj, 3, hud_jobj);
143    GObj_AddGXLink(hud_gobj, GXLink_Common, GXLINK_HUD, 80);
144
145    // create text canvas
146    int canvas = Text_CreateCanvas(2, hud_gobj, 14, 15, 0, GXLINK_HUD, 81, 19);
147    event_data->hud.canvas = canvas;
148
149    // init text
150    Text **text_arr = &event_data->hud.text_timing;
151    for (int i = 0; i < 3; i++)
152    {
153
154        // Create text object
155        Text *hud_text = Text_CreateText(2, canvas);
156        text_arr[i] = hud_text;
157        hud_text->kerning = 1;
158        hud_text->align = 1;
159        hud_text->use_aspect = 1;
160
161        // Get position
162        Vec3 text_pos;
163        JOBJ *text_jobj;
164        JOBJ_GetChild(hud_jobj, &text_jobj, WDJOBJ_TEXT + i, -1);
165        JOBJ_GetWorldPosition(text_jobj, 0, &text_pos);
166
167        // adjust scale
168        Vec3 *scale = &hud_jobj->scale;
169        // text scale
170        hud_text->viewport_scale.X = (scale->X * 0.01) * TEXT_SCALE;
171        hud_text->viewport_scale.Y = (scale->Y * 0.01) * TEXT_SCALE;
172        hud_text->aspect.X = 165;
173
174        // text position
175        hud_text->trans.X = text_pos.X + (scale->X / 4.0);
176        hud_text->trans.Y = (text_pos.Y * -1) + (scale->Y / 4.0);
177
178        // dummy text
179        Text_AddSubtext(hud_text, 0, 0, "-");
180    }
181
182    // init timer
183    event_data->timer = -1;
184}
185void Wavedash_Think(WavedashData *event_data, FighterData *hmn_data)
186{
187    // start sequence on jump squat
188    if (hmn_data->state_id == ASID_KNEEBEND && hmn_data->TM.state_frame == 0)
189    {
190        event_data->timer = 0;
191        event_data->airdodge_frame = -1;
192    }
193
194    // Do nothing if sequence hasn't started
195    if (event_data->timer < 0)
196        return;
197
198    // run sequence logic
199    event_data->timer++;
200
201    // The game tracks whether the current jump is going to be a short hop in
202    // `state_var1`. The value at the end of kneebend is what we want.
203    if (hmn_data->state_id == ASID_KNEEBEND)
204        event_data->short_hop = hmn_data->state_var.state_var1;
205    if (WdOptions_Main[OPT_SHORT_HOP].val && event_data->short_hop)
206        Fighter_ColAnim_Apply(hmn_data, 107, 0); // make sparkles
207
208    // Record early airdodge timings. May be overwritten by a later successful
209    // timing in case player uses multiple presses.
210    if (hmn_data->input.down & (PAD_TRIGGER_L | PAD_TRIGGER_R) &&
211            hmn_data->state_id == ASID_KNEEBEND)
212        event_data->airdodge_frame = event_data->timer;
213
214    // Real airdodge
215    if (hmn_data->TM.state_frame == 0 &&
216            (hmn_data->state_id == ASID_ESCAPEAIR ||
217            (hmn_data->state_id == ASID_LANDINGFALLSPECIAL &&
218             hmn_data->TM.state_prev[0] == ASID_ESCAPEAIR &&
219             hmn_data->TM.state_prev_frames[0] == 0)))
220    {
221        event_data->airdodge_frame = event_data->timer;
222        Vec2 lstick = hmn_data->input.lstick;
223        event_data->angle_real = -atan2(lstick.Y, fabs(lstick.X)) / M_1DEGREE;
224
225        PADStatus *stat = PadGetRaw(0);
226        event_data->angle_raw = -atan2(stat->stickY, fabs(stat->stickX)) / M_1DEGREE;
227    }
228
229    void *mat_anim = 0;
230    if (hmn_data->state_id == ASID_LANDINGFALLSPECIAL
231        && hmn_data->TM.state_frame == 0
232        && hmn_data->TM.state_prev[0] == ASID_ESCAPEAIR
233        && hmn_data->TM.state_prev[2] == ASID_KNEEBEND)
234    {
235        // success
236        mat_anim = event_data->assets->hudmatanim[0];
237        event_data->wd_attempted++;
238        event_data->wd_succeeded++;
239
240        // check for perfect
241        if (event_data->airdodge_frame == ((int)hmn_data->attr.jump_startup_time + 1))
242            SFX_Play(303);
243    }
244    else if (hmn_data->TM.state_frame >= FAILFRAMES &&
245             event_data->airdodge_frame > 0 &&
246            (hmn_data->state_id == ASID_JUMPF ||
247             hmn_data->state_id == ASID_JUMPB ||
248             hmn_data->state_id == ASID_ESCAPEAIR)) {
249        // failure
250        mat_anim = event_data->assets->hudmatanim[1];
251        event_data->wd_attempted++;
252        SFX_PlayCommon(3);
253    } else if (hmn_data->state_id == ASID_KNEEBEND ||
254              (hmn_data->TM.state_frame < FAILFRAMES &&
255              (hmn_data->state_id == ASID_JUMPF ||
256               hmn_data->state_id == ASID_JUMPB ||
257               hmn_data->state_id == ASID_ESCAPEAIR))) {
258        // in progress
259        return;
260    }
261
262    // Reset
263    event_data->timer = -1;
264    Fighter_ColAnim_Remove(hmn_data, 107); // remove sparkles
265
266    // Wavedash not attempted
267    if (event_data->airdodge_frame < 0)
268        return;
269
270    // update bar frame colors
271    JOBJ *hud_jobj = event_data->hud.gobj->hsd_object;
272    JOBJ *arrow_jobj;
273    JOBJ_GetChild(hud_jobj, &arrow_jobj, WDJOBJ_ARROW, -1); // get timing bar jobj
274    int timing = event_data->airdodge_frame - (int)hmn_data->attr.jump_startup_time - 1;
275
276    // update arrow position
277    if (timing + WDFRAMES / 2 < WDFRAMES)
278    {
279        event_data->hud.arrow_prevpos = arrow_jobj->trans.X;
280        event_data->hud.arrow_nextpos = timing * WDARROW_OFFSET;
281        event_data->hud.arrow_timer = WDARROW_ANIMFRAMES;
282        JOBJ_ClearFlags(arrow_jobj, JOBJ_HIDDEN);
283    }
284    else
285    {
286        // hide arrow for this wd attempt
287        event_data->hud.arrow_timer = 0;
288        arrow_jobj->trans.X = 0;
289        JOBJ_SetFlags(arrow_jobj, JOBJ_HIDDEN);
290    }
291
292    // updating timing text
293    if (timing < 0) // is early
294        Text_SetText(event_data->hud.text_timing, 0, "%df Early", -timing);
295    else if (timing > 0)
296        Text_SetText(event_data->hud.text_timing, 0, "%df Late", timing);
297    else
298        Text_SetText(event_data->hud.text_timing, 0, "Perfect");
299
300    // Update airdodge angle text
301    // We show both the raw and real angles in case they differ
302    if (fabs(event_data->angle_real - event_data->angle_raw) < 1.0)
303        Text_SetText(event_data->hud.text_angle, 0, "%.1f",
304                event_data->angle_real);
305    else
306        Text_SetText(event_data->hud.text_angle, 0, "%.1f (%.1f)",
307                event_data->angle_real, event_data->angle_raw);
308
309    // update succession
310    int successful = event_data->wd_succeeded;
311    float succession = 100.0 * event_data->wd_succeeded / event_data->wd_attempted;
312    Text_SetText(event_data->hud.text_succession, 0, "%d (%.2f%)", successful, succession);
313
314    // apply HUD animation
315    JOBJ_RemoveAnimAll(hud_jobj);
316    JOBJ_AddAnimAll(hud_jobj, 0, mat_anim, 0);
317    JOBJ_ReqAnimAll(hud_jobj, 0);
318}
319
320// Target functions
321void Target_Init(WavedashData *event_data, FighterData *hmn_data)
322{
323
324    ftCommonData *ftcommon = *stc_ftcommon;
325    float mag;
326
327    // determine best wavedash distance (not taking into account friction doubling)
328    mag = ftcommon->escapeair_vel * cos(atan2(-0.2875, 0.9500));
329    float wd_maxdstn = Target_GetWdashDistance(hmn_data, mag);
330    event_data->wd_maxdstn = wd_maxdstn;
331
332    // determine scale based on wd distance
333    float dist = event_data->wd_maxdstn;
334    if (dist < TRGTSCL_DISTMIN)
335        dist = TRGTSCL_DISTMIN;
336    else if (dist > TRGTSCL_DISTMAX)
337        dist = TRGTSCL_DISTMAX;
338    event_data->target.scale = (((dist - TRGTSCL_DISTMIN) / (TRGTSCL_DISTMAX - TRGTSCL_DISTMIN)) * (TRGTSCL_SCALEMAX - TRGTSCL_SCALEMIN)) + TRGTSCL_SCALEMIN;
339
340    // get width of the target
341    JOBJ *target = JOBJ_LoadJoint(event_data->assets->target_jobj); // create dummy
342    float scale = event_data->target.scale;                         // scale
343    target->scale.X *= scale;
344    target->scale.Z *= scale;
345
346    // get children
347    JOBJ *left_jobj, *right_jobj;
348    JOBJ_GetChild(target, &left_jobj, TRGTJOBJ_LBOUND, -1);
349    JOBJ_GetChild(target, &right_jobj, TRGTJOBJ_RBOUND, -1);
350    // get offsets
351    JOBJ_GetWorldPosition(left_jobj, 0, &event_data->target.left_offset);
352    JOBJ_GetWorldPosition(right_jobj, 0, &event_data->target.right_offset);
353
354    // free jobj
355    JOBJ_RemoveAll(target);
356}
357void Target_Manager(WavedashData *event_data, FighterData *hmn_data)
358{
359    GOBJ *target_gobj = event_data->target.gobj;
360
361    if (WdOptions_Main[OPT_TARGET].val)
362    { // on
363        // if not spawned, spawn
364        if (target_gobj == 0)
365        {
366            if (hmn_data->phys.air_state == 0)
367            {
368                // spawn target
369                target_gobj = Target_Spawn(event_data, hmn_data);
370                event_data->target.gobj = target_gobj;
371            }
372        }
373
374        // update target logic
375        if (target_gobj != 0)
376        {
377            TargetData *target_data = target_gobj->userdata;
378
379            // check current target state
380            if (target_data->state == TRGSTATE_DESPAWN)
381            {
382                // create new one
383                target_gobj = Target_Spawn(event_data, hmn_data);
384                event_data->target.gobj = target_gobj;
385            }
386        }
387    }
388    else
389    { // off
390        // if spawned, remove
391        if (target_gobj != 0)
392        {
393            Target_ChangeState(target_gobj, TRGSTATE_DESPAWN);
394            event_data->target.gobj = 0;
395        }
396    }
397}
398GOBJ *Target_Spawn(WavedashData *event_data, FighterData *hmn_data)
399{
400
401    Vec3 ray_angle;
402    Vec3 ray_pos;
403    int ray_index;
404    float max = (event_data->wd_maxdstn * TRGT_RANGEMAX);
405    float min = (event_data->wd_maxdstn * TRGT_RANGEMIN);
406
407    // ensure min exists
408    int min_exists = 0;
409    min_exists += Target_CheckArea(event_data, hmn_data->coll_data.ground_index, &hmn_data->phys.pos, max, 0, 0, 0);
410    min_exists += Target_CheckArea(event_data, hmn_data->coll_data.ground_index, &hmn_data->phys.pos, max * -1, 0, 0, 0);
411    if (min_exists)
412    {
413
414        // begin looking for valid ground at a random distance
415        int is_ground = 0;
416        while (!is_ground)
417        {
418
419            // select random direction
420            float direction;
421            int temp = HSD_Randi(2);
422            if (temp == 0)
423                direction = -1;
424            else
425                direction = 1;
426
427            // random distance
428            float distance = (HSD_Randf() * (max - min)) + min;
429
430            // check if valid
431            is_ground = Target_CheckArea(event_data, hmn_data->coll_data.ground_index, &hmn_data->phys.pos, distance * direction, &ray_index, &ray_pos, &ray_angle);
432        }
433
434        // create target gobj
435        GOBJ *target_gobj = GObj_Create(10, 11, 0);
436
437        // target data
438        TargetData *target_data = calloc(sizeof(TargetData));
439        GObj_AddUserData(target_gobj, 4, HSD_Free, target_data);
440
441        // add proc
442        GObj_AddProc(target_gobj, Target_Think, 16);
443
444        // create jobj
445        JOBJ *target_jobj = JOBJ_LoadJoint(event_data->assets->target_jobj);
446        GObj_AddObject(target_gobj, 3, target_jobj);
447        GObj_AddGXLink(target_gobj, GXLink_Common, 5, 0);
448
449        // scale target
450        float scale = event_data->target.scale;
451        target_jobj->scale.X *= scale;
452        target_jobj->scale.Z *= scale;
453
454        // move target
455        target_jobj->trans.X = ray_pos.X;
456        target_jobj->trans.Y = ray_pos.Y;
457        target_jobj->trans.Z = ray_pos.Z;
458
459        // adjust rotation based on line slope
460        JOBJ *aura_jobj;
461        JOBJ_GetChild(target_jobj, &aura_jobj, TRGTJOBJ_AURA, -1);
462        aura_jobj->rot.Z = -1 * atan2(ray_angle.X, ray_angle.Y);
463
464        // create camera box
465        CmSubject *cam = CameraSubject_Alloc();
466        cam->boundleft_proj = -10;
467        cam->boundright_proj = 10;
468        cam->boundtop_proj = 10;
469        cam->boundbottom_proj = -10;
470
471        // update camerabox position
472        cam->cam_pos.X = target_jobj->trans.X;
473        cam->cam_pos.Y = target_jobj->trans.Y + 15;
474        cam->cam_pos.Z = target_jobj->trans.Z;
475
476        // init target data
477        Target_ChangeState(target_gobj, TRGSTATE_SPAWN); // enter spawn state
478        target_data->cam = cam;                          // save camera
479        target_data->line_index = ray_index;             // save line index
480        target_data->pos = ray_pos;                      // save position
481        target_data->left = event_data->target.left_offset.X;
482        target_data->right = event_data->target.right_offset.X;
483
484        return target_gobj;
485    }
486    else
487    {
488        return 0;
489    }
490}
491void Target_Think(GOBJ *target_gobj)
492{
493    JOBJ *target_jobj = target_gobj->hsd_object;
494    TargetData *target_data = target_gobj->userdata;
495
496    // update anim
497    JOBJ_AnimAll(target_jobj);
498
499    // ensure line still exists
500    if (GrColl_CheckIfLineEnabled(target_data->line_index) == 0)
501    {
502        // enter exit state
503        Target_ChangeState(target_gobj, TRGSTATE_DESPAWN);
504    }
505
506    // update target position (look into how fighters are rooted on ground)
507    Vec3 pos_diff;
508    GrColl_GetPosDifference(target_data->line_index, &target_data->pos, &pos_diff);
509    VECAdd(&target_data->pos, &pos_diff, &target_data->pos);
510
511    // update target orientation
512    Vec3 slope;
513    GrColl_GetLineSlope(target_data->line_index, &slope);
514    JOBJ *aura_jobj;
515    JOBJ_GetChild(target_jobj, &aura_jobj, TRGTJOBJ_AURA, -1);
516    aura_jobj->rot.Z = -1 * atan2(slope.X, slope.Y);
517
518    // update camerabox position
519    CmSubject *cam = target_data->cam;
520    cam->cam_pos.X = target_data->pos.X;
521    cam->cam_pos.Y = target_data->pos.Y + 15;
522    cam->cam_pos.Z = target_data->pos.Z;
523
524    // update position
525    target_jobj->trans = target_data->pos;
526    JOBJ_SetMtxDirtySub(target_jobj);
527
528    // state based logic
529    switch (target_data->state)
530    {
531    case (TRGSTATE_SPAWN):
532    {
533        // check if ended
534        if (JOBJ_CheckAObjEnd(target_jobj) == 0)
535            Target_ChangeState(target_gobj, TRGSTATE_WAIT);
536
537        break;
538    }
539    case (TRGSTATE_WAIT):
540    {
541        // get position
542        Vec3 pos;
543        JOBJ_GetWorldPosition(target_jobj, 0, &pos);
544
545        // check for collision
546        FighterData *hmn_data = Fighter_GetGObj(0)->userdata;
547
548        Vec3 *ft_pos = &hmn_data->phys.pos;
549        if (hmn_data->phys.air_state == 0 &&
550            fabs(hmn_data->phys.self_vel.X) < 0.5 && // check if a wavedash
551            (ft_pos->X > (pos.X + target_data->left)) &&
552            (ft_pos->X < (pos.X + target_data->right)) &&
553            (ft_pos->Y > (pos.Y - 1)) &&
554            (ft_pos->Y < (pos.Y + 1)))
555        {
556            SFX_Play(173);
557
558            Target_ChangeState(target_gobj, TRGSTATE_DESPAWN);
559        }
560
561        break;
562    }
563    case (TRGSTATE_DESPAWN):
564    {
565        // check if ended
566        if (JOBJ_CheckAObjEnd(target_jobj) == 0)
567        {
568            CameraSubject_Destroy(target_data->cam);
569            GObj_Destroy(target_gobj);
570        }
571
572        break;
573    }
574    }
575}
576void Target_ChangeState(GOBJ *target_gobj, int state)
577{
578    WavedashData *event_data = event_vars->event_gobj->userdata;
579    TargetData *target_data = target_gobj->userdata;
580    JOBJ *target_jobj = target_gobj->hsd_object;
581
582    // update state
583    target_data->state = state;
584
585    // add anim
586    JOBJ_AddAnimAll(target_jobj, event_data->assets->target_jointanim[state], event_data->assets->target_matanim[state], 0);
587    JOBJ_ReqAnimAll(target_jobj, 0); // req anim
588}
589
590void Wavedash_ChangeShowHUD(GOBJ *menu_gobj, int show)
591{
592    HUDCamData *cam = event_vars->hudcam_gobj->userdata;
593    cam->hide = !show;
594}
595
596float Target_GetWdashDistance(FighterData *hmn_data, float mag)
597{
598
599    float distance = 0;
600    ftCommonData *ftcommon = *stc_ftcommon;
601
602    // now simulate
603    mag *= ftcommon->escapeair_veldecaymult; // first frame multiply by 0.9 ( in airdodge still)
604    distance += mag;
605
606    // subsequent, apply friction until at 0
607    while (mag > 0)
608    {
609
610        // get friction
611        float friction = hmn_data->attr.ground_friction;
612        if (mag > hmn_data->attr.walk_maximum_velocity) // double friction if speed > walk max speed
613            friction *= ftcommon->friction_mult;
614
615        // apply it
616        mag -= friction;
617
618        // ensure not under 0
619        if (mag < 0)
620            mag = 0;
621
622        distance += mag;
623    }
624
625    return distance;
626}
627int Target_CheckArea(WavedashData *event_data, int line, Vec3 *pos, float x_offset, int *ret_line, Vec3 *ret_pos, Vec3 *ret_slope)
628{
629
630    int status = 0;
631
632    // init
633    int is_ground = 0;
634    // check left
635    is_ground += GrColl_CrawlGround(line, pos, ret_line, ret_pos, 0, ret_slope, x_offset + event_data->target.left_offset.X, 0);
636    // check right
637    is_ground += GrColl_CrawlGround(line, pos, ret_line, ret_pos, 0, ret_slope, x_offset + event_data->target.right_offset.X, 0);
638    // check center
639    is_ground += GrColl_CrawlGround(line, pos, ret_line, ret_pos, 0, ret_slope, x_offset + event_data->target.center_offset.X, 0);
640
641    if (is_ground == 3)
642        status = 1;
643
644    return status;
645}
646
647// Tips
648void Tips_Think(WavedashData *event_data, FighterData *hmn_data)
649{
650    if (!WdOptions_Main[OPT_TIPS].val)
651        return;
652
653    // Check for player holding shield too after the wavedash landing lag
654    if (hmn_data->state_id == ASID_GUARDOFF && hmn_data->TM.state_frame == 0 &&
655        hmn_data->TM.state_prev[3] == ASID_LANDINGFALLSPECIAL)
656    {
657        if (event_data->tip.shield_num++ % 5 == 2)
658            event_vars->Tip_Display(5 * 60, "Tip:\nDon't hold the trigger! Quickly \npress and release to prevent \nshielding after wavedashing.");
659    }
660
661    // Check for slow airdodge landing after full hop
662    if (hmn_data->state_id == ASID_LANDINGFALLSPECIAL
663            && hmn_data->TM.state_frame == 0
664            && hmn_data->TM.state_prev[0] == ASID_ESCAPEAIR
665            && hmn_data->TM.state_prev_frames[0] > 3 // slow to hit ground from airdodge
666            && hmn_data->TM.state_prev_frames[1] < 5 // slightly late airdodge timing
667            && event_data->angle_real > 0            // ignore horizontal airdodge
668            && !event_data->short_hop)               // full hop
669    {
670        if (event_data->tip.short_hop++ % 8 == 2)
671            event_vars->Tip_Display(5 * 60, "Tip:\nUse short hop for wavedash!\nit can help you land faster\nwhen you airdodge late.");
672    }
673}
674
675// Initial Menu
676EventMenu *Event_Menu = &WdMenu_Main;