fork/training-mode-ce

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

Alex Harrisonfix most characters not l-canceling initial bair in edgeguard training8a73b3f

master
11.4 KiB344 linesraw
1#include "edgeguard.h"
2#include "recovery.c"
3
4// how far inland the hmn will start
5#define DISTANCE_FROM_LEDGE 15
6
7// how many frames it takes to reset after the cpu dies or successfully recovers
8#define RESET_DELAY 30
9
10static int reset_timer = -1;
11static int edgeguard_timer = 0;
12EventMenu *Event_Menu = &Menu_Main;
13
14static void UpdatePosition(GOBJ *fighter) {
15    FighterData *data = fighter->userdata;
16
17    Vec3 pos = data->phys.pos;
18    data->coll_data.topN_Curr = pos;
19    data->coll_data.topN_CurrCorrect = pos;
20    data->coll_data.topN_Prev = pos;
21    data->coll_data.topN_Proj = pos;
22    data->coll_data.coll_test = *stc_colltest;
23}
24
25static void UpdateCameraBox(GOBJ *fighter) {
26    Fighter_UpdateCameraBox(fighter);
27
28    FighterData *data = fighter->userdata;
29    CmSubject *subject = data->camera_subject;
30    subject->boundleft_curr = subject->boundleft_proj;
31    subject->boundright_curr = subject->boundright_proj;
32
33    Match_CorrectCamera();
34}
35
36static bool IsGroundActionable(GOBJ *fighter) {
37    FighterData *data = fighter->userdata;
38
39    // ensure grounded
40    if (data->phys.air_state == 1)
41        return false;
42
43    int state = data->state_id;
44
45    if (InHitstunAnim(state) && HitstunEnded(fighter))
46        return true;
47
48    if (state == ASID_LANDING && data->state.frame >= data->attr.normal_landing_lag)
49        return true;
50        
51    return state == ASID_WAIT
52        || state == ASID_WALKSLOW
53        || state == ASID_WALKMIDDLE
54        || state == ASID_WALKFAST
55        || state == ASID_RUN
56        || state == ASID_SQUATWAIT
57        || state == ASID_OTTOTTOWAIT
58        || state == ASID_GUARD;
59}
60
61static void Exit(GOBJ *menu) {
62    stc_match->state = 3;
63    Match_EndVS();
64}
65
66static void Reset_Subchar(GOBJ *sub, GOBJ *main) {
67    // Every subchar has a force that attracts them to the main char's position a few frames ago.
68    // When the main character teleports during a reset,
69    // we need to reset the past position data of the subchar so that 
70    // they aren't attracted to the main char's previous position across the stage.
71
72    FighterData *main_data = main->userdata;
73    FighterData *sub_data = sub->userdata;
74    Vec3 pos = main_data->phys.pos;
75    float facing = main_data->facing_direction;
76    for (u32 i = 0; i < countof(sub_data->cpu.leader_log); ++i) {
77        CPULeaderLog *log = &sub_data->cpu.leader_log[i];
78        log->pos = pos;
79        log->facing_direction = facing;
80    }
81}
82
83static void Reset_HMN(GOBJ *hmn, int side_idx, int dmg) {
84    FighterData *hmn_data = hmn->userdata;
85    
86    int side = side_idx * 2 - 1;
87    hmn_data->facing_direction = -side; 
88    float ledge_x = ledge_positions[side_idx].X - DISTANCE_FROM_LEDGE * side;
89    
90    // set phys
91    hmn_data->phys.kb_vel.X = 0.f;
92    hmn_data->phys.kb_vel.Y = 0.f;
93    hmn_data->phys.self_vel.X = 0.f;
94    hmn_data->phys.self_vel.Y = 0.f;
95    hmn_data->phys.pos.X = ledge_x;
96    hmn_data->phys.pos.Y = 5.f;
97    UpdatePosition(hmn);
98    
99    hmn_data->jump.jumps_used = 1;
100    
101    // set hmn action state
102    Fighter_EnterAerial(hmn, ASID_ATTACKAIRB);
103    Fighter_ApplyAnimation(hmn, 7, 1, 0);
104    hmn_data->state.frame = 7;
105    hmn_data->script.script_event_timer = 0;
106    Fighter_SubactionFastForward(hmn);
107
108    Fighter_UpdateStateFrameInfo(hmn);
109    Fighter_HitboxDisableAll(hmn);
110    hmn_data->script.script_current = 0;
111    
112    // fix camera
113    UpdateCameraBox(hmn);
114
115    // give hitlag
116    hmn_data->dmg.hitlag_frames = 7;
117    hmn_data->flags.hitlag = 1;
118    hmn_data->flags.hitlag_unk = 1;
119    
120    // percent
121    hmn_data->dmg.percent = dmg;
122    Fighter_SetHUDDamage(hmn_data->ply, dmg);
123}
124
125static void Reset_CPU(GOBJ *cpu, int side_idx, int dmg, float kb_mag, float kb_angle) {
126    FighterData *cpu_data = cpu->userdata;
127    cpu_data->cpu.ai = 15;
128    
129    int side = side_idx * 2 - 1;
130    cpu_data->facing_direction = -side;
131    float ledge_x = ledge_positions[side_idx].X - DISTANCE_FROM_LEDGE * side;
132    
133    // set phys
134    cpu_data->phys.kb_vel.X = 0.f;
135    cpu_data->phys.kb_vel.Y = 0.f;
136    cpu_data->phys.self_vel.X = 0.f;
137    cpu_data->phys.self_vel.Y = 0.f;
138    cpu_data->phys.pos.X = ledge_x;
139    cpu_data->phys.pos.Y = 0.f;
140    UpdatePosition(cpu);
141    
142    cpu_data->jump.jumps_used = 1;
143    
144    // set cpu action state
145    int state = kb_mag > 130.f ? ASID_DAMAGEFLYHI : ASID_DAMAGEFLYN;
146    Fighter_EnterFall(cpu);
147    ActionStateChange(0, 1, 0, cpu, state, 0x40, 0);
148    Fighter_UpdateStateFrameInfo(cpu);
149    
150    // fix camera
151    UpdateCameraBox(cpu);
152    
153    // give cpu knockback
154    float angle_rad = kb_angle * M_1DEGREE;
155
156    float vel = kb_mag * (*stc_ftcommon)->force_applied_to_kb_mag_multiplier;
157    float vel_x = cos(angle_rad) * vel * (float)side;
158    float vel_y = sin(angle_rad) * vel;
159    cpu_data->phys.kb_vel.X = vel_x;
160    cpu_data->phys.kb_vel.Y = vel_y;
161
162    float kb_frames = (float)(int)((*stc_ftcommon)->x154 * kb_mag);
163    memcpy(&cpu_data->state_var.state_var1, &kb_frames, sizeof(float));
164    cpu_data->flags.hitstun = 1;
165    Fighter_EnableCollUpdate(cpu_data);
166
167    // give hitlag
168    cpu_data->dmg.hitlag_frames = 7;
169    cpu_data->flags.hitlag = 1;
170    cpu_data->flags.hitlag_unk = 1;
171    
172    // percent
173    cpu_data->dmg.percent = dmg;
174    Fighter_SetHUDDamage(cpu_data->ply, dmg);
175}
176
177static void Reset(void) {
178    event_vars->Savestate_Load_v1(event_vars->savestate, Savestate_Silent);
179    edgeguard_timer = 0;
180
181    for (int ply = 0; ply < 2; ++ply) {
182        MatchHUDElement *hud = &stc_matchhud->element_data[ply];
183        if (hud->is_removed == 1)
184            Match_CreateHUD(ply);
185    }
186
187    int side_idx = HSD_Randi(2);
188    KBValues vals = HitStrength_KBRange[Options_Main[OPT_MAIN_HITSTRENGTH].val];
189    float kb_mag = vals.mag_min + (vals.mag_max - vals.mag_min) * HSD_Randf();
190    float kb_angle = vals.ang_min + (vals.ang_max - vals.ang_min) * HSD_Randf();
191    int hmn_dmg = Options_Main[OPT_MAIN_PERCENT].val;
192    int cpu_dmg = vals.dmg_min + HSD_Randi(vals.dmg_max - vals.dmg_min);
193    
194    GOBJ *hmn = Fighter_GetSubcharGObj(0, 0);
195    GOBJ *cpu = Fighter_GetSubcharGObj(1, 0);
196    Reset_HMN(hmn, side_idx, hmn_dmg);
197    Reset_CPU(cpu, side_idx, cpu_dmg, kb_mag, kb_angle);
198    
199    GOBJ *hmn_sub = Fighter_GetSubcharGObj(0, 1);
200    GOBJ *cpu_sub = Fighter_GetSubcharGObj(1, 1);
201    FighterData *hmn_data = hmn->userdata;
202    FighterData *cpu_data = cpu->userdata;
203    if (hmn_sub && hmn_data->flags.has_follower) {
204        Reset_HMN(hmn_sub, side_idx, hmn_dmg);
205        Reset_Subchar(hmn_sub, hmn);
206    }
207    if (cpu_sub && cpu_data->flags.has_follower) {
208        Reset_CPU(cpu_sub, side_idx, cpu_dmg, kb_mag, kb_angle);
209        Reset_Subchar(cpu_sub, hmn);
210    }
211}
212
213static void ChangePlayerPercent(GOBJ *menu_gobj, int dmg) {
214    GOBJ *hmn = Fighter_GetGObj(0);
215    FighterData *hmn_data = hmn->userdata;
216
217    hmn_data->dmg.percent = dmg;
218    Fighter_SetHUDDamage(hmn_data->ply, dmg);
219}
220
221static void WriteCustomKBValues(void) {
222    HitStrength_KBRange[KBVALS_CUSTOM].mag_min = Options_CustomHitStrength[OPT_CUSTOMHIT_MAGMIN].val;
223    HitStrength_KBRange[KBVALS_CUSTOM].mag_max = Options_CustomHitStrength[OPT_CUSTOMHIT_MAGMAX].val;
224    HitStrength_KBRange[KBVALS_CUSTOM].ang_min = Options_CustomHitStrength[OPT_CUSTOMHIT_ANGMIN].val;
225    HitStrength_KBRange[KBVALS_CUSTOM].ang_max = Options_CustomHitStrength[OPT_CUSTOMHIT_ANGMAX].val;
226    HitStrength_KBRange[KBVALS_CUSTOM].dmg_min = Options_CustomHitStrength[OPT_CUSTOMHIT_DMGMIN].val;
227    HitStrength_KBRange[KBVALS_CUSTOM].dmg_max = Options_CustomHitStrength[OPT_CUSTOMHIT_DMGMAX].val;
228    Options_Main[OPT_MAIN_HITSTRENGTH].val = KBVALS_CUSTOM;
229}
230
231static void ChangeCustomKB_MagMin(GOBJ *menu_gobj, int value) {
232    s16 *min = &Options_CustomHitStrength[OPT_CUSTOMHIT_MAGMIN].val;
233    s16 *max = &Options_CustomHitStrength[OPT_CUSTOMHIT_MAGMAX].val;
234    if (*min > *max) *max = *min;
235    WriteCustomKBValues();
236}
237static void ChangeCustomKB_MagMax(GOBJ *menu_gobj, int value) {
238    s16 *min = &Options_CustomHitStrength[OPT_CUSTOMHIT_MAGMIN].val;
239    s16 *max = &Options_CustomHitStrength[OPT_CUSTOMHIT_MAGMAX].val;
240    if (*min > *max) *min = *max;
241    WriteCustomKBValues();
242}
243static void ChangeCustomKB_AngMin(GOBJ *menu_gobj, int value) {
244    s16 *min = &Options_CustomHitStrength[OPT_CUSTOMHIT_ANGMIN].val;
245    s16 *max = &Options_CustomHitStrength[OPT_CUSTOMHIT_ANGMAX].val;
246    if (*min > *max) *max = *min;
247    WriteCustomKBValues();
248}
249static void ChangeCustomKB_AngMax(GOBJ *menu_gobj, int value) {
250    s16 *min = &Options_CustomHitStrength[OPT_CUSTOMHIT_ANGMIN].val;
251    s16 *max = &Options_CustomHitStrength[OPT_CUSTOMHIT_ANGMAX].val;
252    if (*min > *max) *min = *max;
253    WriteCustomKBValues();
254}
255static void ChangeCustomKB_DmgMin(GOBJ *menu_gobj, int value) {
256    s16 *min = &Options_CustomHitStrength[OPT_CUSTOMHIT_DMGMIN].val;
257    s16 *max = &Options_CustomHitStrength[OPT_CUSTOMHIT_DMGMAX].val;
258    if (*min > *max) *max = *min;
259    WriteCustomKBValues();
260}
261static void ChangeCustomKB_DmgMax(GOBJ *menu_gobj, int value) {
262    s16 *min = &Options_CustomHitStrength[OPT_CUSTOMHIT_DMGMIN].val;
263    s16 *max = &Options_CustomHitStrength[OPT_CUSTOMHIT_DMGMAX].val;
264    if (*min > *max) *min = *max;
265    WriteCustomKBValues();
266}
267
268void Event_Init(GOBJ *gobj) {
269    GOBJ *hmn = Fighter_GetGObj(0);
270    GOBJ *cpu = Fighter_GetGObj(1);
271    FighterData *hmn_data = hmn->userdata;
272    FighterData *cpu_data = cpu->userdata;
273    
274    // change team - homing missiles don't move towards characters on same team
275    hmn_data->team = 0;
276    cpu_data->team = 1;
277
278    EventMenu *recovery_menu = RecoveryMenus[cpu_data->kind];
279    if (recovery_menu == 0)
280        assert("unimplemented character in edgeguard training");
281    Options_Main[OPT_MAIN_RECOVERY].menu = recovery_menu;
282    
283    GetLedgePositions(ledge_positions);
284}
285
286void Event_Think(GOBJ *menu) {
287    // For some reason, Savestate_Save crashes in Event_Init.
288    // So we need to init on first think frame.
289    if (event_vars->game_timer == 1) {
290        event_vars->Savestate_Save_v1(event_vars->savestate, Savestate_Silent);
291        Reset();
292    }
293    
294    GOBJ *hmn = Fighter_GetGObj(0);
295    GOBJ *cpu = Fighter_GetGObj(1);
296    FighterData *hmn_data = hmn->userdata;
297    FighterData *cpu_data = cpu->userdata;
298
299    if (reset_timer > 0) 
300        reset_timer--;
301
302    if (reset_timer == 0) {
303        reset_timer = -1;
304        Reset();
305    }
306    
307    if (edgeguard_timer < 10) {
308        // Ensure the player L-cancels the initial bair.
309        //
310        // We can't set this in reset because most characters need to L-Cancel later than the reset frame.
311        // Not really a good solution other than a timer.
312        hmn_data->flags.is_fastfall = 1;
313        hmn_data->input.timer_trigger_any_ignore_hitlag = 0;
314    }
315    edgeguard_timer++;
316    
317    Vec2 cpu_pos = { cpu_data->phys.pos.X, cpu_data->phys.pos.Y };
318    
319    if (
320        reset_timer == -1
321        && (
322            cpu_data->flags.dead
323            || hmn_data->flags.dead
324            || cpu_data->state_id == ASID_CLIFFCATCH
325            || cpu_data->state_id == ASID_DOWNWAITU
326            || cpu_data->state_id == ASID_DOWNWAITD
327            || IsGroundActionable(cpu)
328            
329            // if the CPU is actionable high above the stage, just reset early.
330            || (cpu_pos.Y > 100.f 
331                && fabs(cpu_pos.X) < ledge_positions[1].X 
332                && IsAirActionable(cpu))
333        )
334    ) {
335        reset_timer = RESET_DELAY;
336    }
337    
338    HSD_Pad *pad = PadGetMaster(hmn_data->pad_index);
339    if (pad->down & HSD_BUTTON_DPAD_LEFT)
340        reset_timer = 0;
341        
342    u32 opt_flags = RecoveryMenuOptFlags(cpu);
343    Recovery_Think(cpu, opt_flags);
344}