fork/training-mode-ce

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

AitchAdd warnings and fix them (#297)4f5d26e

nix
31.4 KiB671 linesraw
1#include "events.h"
2
3// use enum savestate_flags for flags
4int Savestate_Save_v1(Savestate_v1 *savestate, int flags)
5{
6    typedef struct BackupQueue
7    {
8        GOBJ *fighter;
9        FighterData *fighter_data;
10    } BackupQueue;
11
12    // ensure no players are in problematic states
13    int canSave = 1;
14    
15    if (flags & Savestate_Checks) {
16        GOBJ **gobj_list = R13_PTR(-0x3E74);
17        GOBJ *fighter = gobj_list[8];
18        while (fighter != 0)
19        {
20           FighterData *fighter_data = fighter->userdata;
21    
22           if ((fighter_data->cb.OnDeath_Persist != 0) ||
23              (fighter_data->cb.OnDeath_State != 0) ||
24              (fighter_data->cb.OnDeath3 != 0) ||
25              (fighter_data->item_held != 0) ||
26              (fighter_data->x1978 != 0) ||
27              (fighter_data->accessory != 0) ||
28              ((fighter_data->kind == FTKIND_NESS) && ((fighter_data->state_id >= 342) && (fighter_data->state_id <= 344)))) // hardcode ness' usmash because it doesnt destroy the yoyo via onhit callback...
29           {
30              // cannot save
31              canSave = 0;
32              break;
33           }
34    
35           fighter = fighter->next;
36        }
37    }
38
39    // loop through all players
40    int isSaved = 0;
41    if (canSave == 1)
42    {
43
44        savestate->is_exist = 1;
45
46        // save frame
47        savestate->frame = event_vars->game_timer;
48
49        // save event data
50        memcpy(&savestate->event_data, event_vars->event_gobj->userdata, sizeof(savestate->event_data));
51
52        // backup all players
53        for (int i = 0; i < 6; i++)
54        {
55            // get fighter gobjs
56            BackupQueue queue[2];
57            for (int j = 0; j < 2; j++)
58            {
59                GOBJ *fighter = 0;
60                FighterData *fighter_data = 0;
61
62                // get fighter gobj and data if they exist
63                fighter = Fighter_GetSubcharGObj(i, j);
64                if (fighter != 0)
65                    fighter_data = fighter->userdata;
66
67                // store fighter pointers
68                queue[j].fighter = fighter;
69                queue[j].fighter_data = fighter_data;
70            }
71
72            // if the main fighter exists
73            if (queue[0].fighter != 0)
74            {
75
76                FtSaveState_v1 *ft_state = &savestate->ft_state[i];
77
78                isSaved = 1;
79
80                // We use the Savestate's Playerblock size because it's smaller
81                // than the Playerblock defined in fighter.h
82                Playerblock *playerblock = Fighter_GetPlayerblock(queue[0].fighter_data->ply);
83                memcpy(&ft_state->player_block, playerblock, sizeof(ft_state->player_block));
84
85                int *stale_queue = Fighter_GetStaleMoveTable(queue[0].fighter_data->ply);
86                memcpy(&ft_state->stale_queue, stale_queue, sizeof(ft_state->stale_queue));
87
88                // backup each subfighters data
89                for (int j = 0; j < 2; j++)
90                {
91                    // if exists
92                    if (queue[j].fighter != 0)
93                    {
94
95                        FtSaveStateData_v1 *ft_data = &ft_state->data[j];
96                        FighterData *fighter_data = queue[j].fighter_data;
97
98                        // backup to ft_state
99                        ft_data->is_exist = 1;
100                        ft_data->state_id = fighter_data->state_id;
101                        ft_data->facing_direction = fighter_data->facing_direction;
102                        ft_data->state_frame = fighter_data->state.frame;
103                        ft_data->state_rate = fighter_data->state.rate;
104                        ft_data->state_blend = fighter_data->state.blend;
105                        memcpy(&ft_data->phys, &fighter_data->phys, sizeof(fighter_data->phys));                               // copy physics
106                        memcpy(&ft_data->color, &fighter_data->color, sizeof(fighter_data->color));                            // copy color overlay
107                        memcpy(&ft_data->input, &fighter_data->input, sizeof(fighter_data->input));                            // copy inputs
108                        memcpy(&ft_data->coll_data, &fighter_data->coll_data, sizeof(fighter_data->coll_data));                // copy collision
109                        memcpy(&ft_data->camera_subject, fighter_data->camera_subject, sizeof(ft_data->camera_subject));       // copy camerabox
110                        memcpy(&ft_data->hitbox, &fighter_data->hitbox, sizeof(fighter_data->hitbox));                         // copy hitbox
111                        memcpy(&ft_data->throw_hitbox, &fighter_data->throw_hitbox, sizeof(fighter_data->throw_hitbox));       // copy hitbox
112                        memcpy(&ft_data->thrown_hitbox, &fighter_data->thrown_hitbox, sizeof(fighter_data->thrown_hitbox));    // copy hitbox
113                        memcpy(&ft_data->flags, &fighter_data->flags, sizeof(fighter_data->flags));                            // copy flags
114                        memcpy(&ft_data->fighter_var, &fighter_data->fighter_var, sizeof(fighter_data->fighter_var));          // copy var
115                        memcpy(&ft_data->state_var, &fighter_data->state_var, sizeof(fighter_data->state_var));                // copy var
116                        memcpy(&ft_data->ftcmd_var, &fighter_data->ftcmd_var, sizeof(fighter_data->ftcmd_var));                // copy var
117                        memcpy(&ft_data->jump, &fighter_data->jump, sizeof(fighter_data->jump));                               // copy var
118                        memcpy(&ft_data->smash, &fighter_data->smash, sizeof(fighter_data->smash));                            // copy var
119                        memcpy(&ft_data->hurt, &fighter_data->hurt, sizeof(fighter_data->hurt));                               // copy var
120                        memcpy(&ft_data->shield, &fighter_data->shield, sizeof(fighter_data->shield));                         // copy hitbox
121                        memcpy(&ft_data->shield_bubble, &fighter_data->shield_bubble, sizeof(fighter_data->shield_bubble));    // copy hitbox
122                        memcpy(&ft_data->reflect_bubble, &fighter_data->reflect_bubble, sizeof(fighter_data->reflect_bubble)); // copy hitbox
123                        memcpy(&ft_data->absorb_bubble, &fighter_data->absorb_bubble, sizeof(fighter_data->absorb_bubble));    // copy hitbox
124                        memcpy(&ft_data->reflect_hit, &fighter_data->reflect_hit, sizeof(fighter_data->reflect_hit));          // copy hitbox
125                        memcpy(&ft_data->absorb_hit, &fighter_data->absorb_hit, sizeof(fighter_data->absorb_hit));             // copy hitbox
126
127                        // copy dmg
128                        // latest MexTK and savestate have different sizes for dmg struct, so we use savestates's size
129                        memcpy(&ft_data->dmg, &fighter_data->dmg, sizeof(ft_data->dmg));
130                        ft_data->dmg.hit_log.source = GOBJToID(ft_data->dmg.hit_log.source);
131
132                        // copy grab
133                        memcpy(&ft_data->grab, &fighter_data->grab, sizeof(fighter_data->grab));
134                        ft_data->grab.attacker = GOBJToID(ft_data->grab.attacker);
135                        ft_data->grab.victim = GOBJToID(ft_data->grab.victim);
136
137                        // copy callbacks
138                        memcpy(&ft_data->cb, &fighter_data->cb, sizeof(fighter_data->cb)); // copy hitbox
139
140                        // convert hitbox pointers
141                        for (u32 k = 0; k < countof(fighter_data->hitbox); k++)
142                        {
143                            ft_data->hitbox[k].bone = BoneToID(fighter_data, ft_data->hitbox[k].bone);
144                            for (u32 l = 0; l < countof(fighter_data->hitbox->victims); l++) // pointers to hitbox victims
145                            {
146                                ft_data->hitbox[k].victims[l].data = FtDataToID(ft_data->hitbox[k].victims[l].data);
147                            }
148                        }
149                        for (u32 k = 0; k < countof(fighter_data->throw_hitbox); k++)
150                        {
151                            ft_data->throw_hitbox[k].bone = BoneToID(fighter_data, ft_data->throw_hitbox[k].bone);
152                            for (u32 l = 0; l < countof(fighter_data->throw_hitbox->victims); l++) // pointers to hitbox victims
153                            {
154                                ft_data->throw_hitbox[k].victims[l].data = FtDataToID(ft_data->throw_hitbox[k].victims[l].data);
155                            }
156                        }
157
158                        ft_data->thrown_hitbox.bone = BoneToID(fighter_data, ft_data->thrown_hitbox.bone);
159                        for (u32 k = 0; k < countof(fighter_data->thrown_hitbox.victims); k++) // pointers to hitbox victims
160                        {
161
162                            ft_data->thrown_hitbox.victims[k].data = FtDataToID(ft_data->thrown_hitbox.victims[k].data);
163                        }
164
165                        // copy XRotN rotation
166                        s8 XRotN_id = Fighter_BoneLookup(fighter_data, XRotN);
167                        if (XRotN_id != -1)
168                        {
169                            ft_data->XRotN_rot = fighter_data->bones[XRotN_id].joint->rot;
170                        }
171                    }
172                }
173            }
174        }
175    }
176
177    if ((flags & Savestate_Silent) == 0) {
178        // Play SFX
179        if (isSaved == 0)
180        {
181            SFX_PlayCommon(3);
182        }
183        if (isSaved == 1)
184        {
185            // play sfx
186            SFX_PlayCommon(1);
187    
188            // if not in frame advance, flash screen. I wrote it like this because the second condition kept getting optimized out
189            if ((Pause_CheckStatus(0) != 1))
190            {
191                if ((Pause_CheckStatus(1) != 2))
192                {
193                    ScreenFlash_Create(2, 0);
194                }
195            }
196        }
197    }
198
199    return isSaved;
200}
201// use enum savestate_flags for flags
202int Savestate_Load_v1(Savestate_v1 *savestate, int flags)
203{
204    typedef struct BackupQueue
205    {
206        GOBJ *fighter;
207        FighterData *fighter_data;
208    } BackupQueue;
209
210    // loop through all players
211    int isLoaded = 0;
212    for (int i = 0; i < 6; i++)
213    {
214        // get fighter gobjs
215        BackupQueue queue[2];
216        for (int j = 0; j < 2; j++)
217        {
218            GOBJ *fighter = 0;
219            FighterData *fighter_data = 0;
220
221            // get fighter gobj and data if they exist
222            fighter = Fighter_GetSubcharGObj(i, j);
223            if (fighter != 0)
224                fighter_data = fighter->userdata;
225
226            // store fighter pointers
227            queue[j].fighter = fighter;
228            queue[j].fighter_data = fighter_data;
229        }
230
231        // if the main fighter and backup exists
232        if ((queue[0].fighter != 0) && (savestate->ft_state[i].data[0].is_exist == 1))
233        {
234
235            FtSaveState_v1 *ft_state = &savestate->ft_state[i];
236
237            isLoaded = 1;
238
239            // restore playerblock
240            Playerblock *playerblock = Fighter_GetPlayerblock(queue[0].fighter_data->ply);
241            GOBJ *fighter_gobj[2];
242            fighter_gobj[0] = playerblock->gobj[0];
243            fighter_gobj[1] = playerblock->gobj[1];
244            memcpy(playerblock, &ft_state->player_block, sizeof(ft_state->player_block));
245            playerblock->gobj[0] = fighter_gobj[0];
246            playerblock->gobj[1] = fighter_gobj[1];
247
248            // restore stale moves
249            int *stale_queue = Fighter_GetStaleMoveTable(queue[0].fighter_data->ply);
250            memcpy(stale_queue, &ft_state->stale_queue, sizeof(ft_state->stale_queue));
251
252            // restore fighter data
253            for (int j = 0; j < 2; j++)
254            {
255
256                GOBJ *fighter = queue[j].fighter;
257
258                if (fighter != 0)
259                {
260
261                    // get state
262                    FtSaveStateData_v1 *ft_data = &ft_state->data[j];
263                    FighterData *fighter_data = queue[j].fighter_data;
264
265                    // sleep
266                    Fighter_EnterSleep(fighter, 0);
267
268                    fighter_data->state_id = ft_data->state_id;
269                    fighter_data->facing_direction = ft_data->facing_direction;
270                    if (flags & Savestate_Mirror)
271                    {
272                        fighter_data->facing_direction *= -1;
273                    }
274                    fighter_data->state.frame = ft_data->state_frame;
275                    fighter_data->state.rate = ft_data->state_rate;
276                    fighter_data->state.blend = ft_data->state_blend;
277
278                    // restore phys struct
279                    memcpy(&fighter_data->phys, &ft_data->phys, sizeof(fighter_data->phys)); // copy physics
280                    if (flags & Savestate_Mirror)
281                    {
282                        fighter_data->phys.anim_vel.X *= -1;
283                        fighter_data->phys.self_vel.X *= -1;
284                        fighter_data->phys.kb_vel.X *= -1;
285                        fighter_data->phys.atk_shield_kb_vel.X *= -1;
286                        fighter_data->phys.pos.X *= -1;
287                        fighter_data->phys.pos_prev.X *= -1;
288                        fighter_data->phys.pos_delta.X *= -1;
289                        fighter_data->phys.horzitonal_velocity_queue_will_be_added_to_0xec *= -1;
290                        fighter_data->phys.self_vel_ground.X *= -1;
291                        fighter_data->phys.nudge_vel.X *= -1;
292                    }
293
294                    // restore inputs
295                    memcpy(&fighter_data->input, &ft_data->input, sizeof(fighter_data->input)); // copy inputs
296                    if (flags & Savestate_Mirror)
297                    {
298                        fighter_data->input.lstick.X *= -1;
299                        fighter_data->input.lstick_prev.X *= -1;
300                        fighter_data->input.cstick.X *= -1;
301                        fighter_data->input.cstick_prev.X *= -1;
302                    }
303
304                    // restore coll data
305                    CollData *thiscoll = &fighter_data->coll_data;
306                    GOBJ *gobj = thiscoll->gobj;                                                            // 0x0
307                    JOBJ *joint_1 = thiscoll->joint_1;                                                      // 0x108
308                    JOBJ *joint_2 = thiscoll->joint_2;                                                      // 0x10c
309                    JOBJ *joint_3 = thiscoll->joint_3;                                                      // 0x110
310                    JOBJ *joint_4 = thiscoll->joint_4;                                                      // 0x114
311                    JOBJ *joint_5 = thiscoll->joint_5;                                                      // 0x118
312                    JOBJ *joint_6 = thiscoll->joint_6;                                                      // 0x11c
313                    JOBJ *joint_7 = thiscoll->joint_7;                                                      // 0x120
314                    memcpy(&fighter_data->coll_data, &ft_data->coll_data, sizeof(fighter_data->coll_data)); // copy collision
315                    thiscoll->gobj = gobj;
316                    thiscoll->joint_1 = joint_1;
317                    thiscoll->joint_2 = joint_2;
318                    thiscoll->joint_3 = joint_3;
319                    thiscoll->joint_4 = joint_4;
320                    thiscoll->joint_5 = joint_5;
321                    thiscoll->joint_6 = joint_6;
322                    thiscoll->joint_7 = joint_7;
323                    if (flags & Savestate_Mirror)
324                    {
325                        thiscoll->topN_Curr.X *= -1;
326                        thiscoll->topN_CurrCorrect.X *= -1;
327                        thiscoll->topN_Prev.X *= -1;
328                        thiscoll->topN_Proj.X *= -1;
329
330                        // if the fighter is on a left/right platform, it needs to set the opposite platform's ground_index to prevent it from stucking at edge of the platform
331                        int stage_internal_id = Stage_ExternalToInternal(Stage_GetExternalID());
332                        struct {
333                            int stage_internal_id;
334                            int left_index;
335                            int right_index;
336                        } platform_ground_indices[] = {
337                            {GRKIND_STORY, 1, 5}, // platforms
338                            {GRKIND_STORY, 2, 6}, // slants
339                            {GRKIND_IZUMI, 0, 1}, // platforms
340                            {GRKIND_IZUMI, 3, 7}, // edges
341                            {GRKIND_IZUMI, 4, 6}, // transition
342                            {GRKIND_PSTAD, 35, 36}, // platforms
343                            {GRKIND_PSTAD, 51, 54}, // edges
344                            {GRKIND_PSTAD, 52, 53}, // transition
345                            {GRKIND_OLDPU, 0, 1}, // platforms
346                            {GRKIND_OLDPU, 3, 5}, // edges
347                            {GRKIND_BATTLE, 2, 4}, // platforms
348                            {GRKIND_BATTLE, 0, 5}, // edges
349                            {GRKIND_FD, 0, 2}, // edges
350                        };
351                        for (u32 i = 0; i < countof(platform_ground_indices); i++)
352                        {
353                            if (platform_ground_indices[i].stage_internal_id == stage_internal_id)
354                            {
355                                if (thiscoll->ground_index == platform_ground_indices[i].left_index)
356                                    thiscoll->ground_index = platform_ground_indices[i].right_index;
357                                else if (thiscoll->ground_index == platform_ground_indices[i].right_index)
358                                    thiscoll->ground_index = platform_ground_indices[i].left_index;
359                            }
360                        }
361                    }
362
363                    // restore hitboxes
364                    memcpy(&fighter_data->hitbox, &ft_data->hitbox, sizeof(fighter_data->hitbox));                   // copy hitbox
365                    memcpy(&fighter_data->throw_hitbox, &ft_data->throw_hitbox, sizeof(fighter_data->throw_hitbox)); // copy hitbox
366                    memcpy(&fighter_data->thrown_hitbox, &ft_data->thrown_hitbox, sizeof(fighter_data->thrown_hitbox));       // copy hitbox
367
368                    // copy grab
369                    memcpy(&fighter_data->grab, &ft_data->grab, sizeof(fighter_data->grab));
370                    fighter_data->grab.attacker = IDToGOBJ(fighter_data->grab.attacker);
371                    fighter_data->grab.victim = IDToGOBJ(fighter_data->grab.victim);
372
373                    // convert pointers
374
375                    for (u32 k = 0; k < countof(fighter_data->hitbox); k++)
376                    {
377                        fighter_data->hitbox[k].bone = IDToBone(fighter_data, ft_data->hitbox[k].bone);
378                        for (u32 l = 0; l < countof(fighter_data->hitbox->victims); l++) // pointers to hitbox victims
379                        {
380                            fighter_data->hitbox[k].victims[l].data = IDToFtData(ft_data->hitbox[k].victims[l].data);
381                        }
382                    }
383                    for (u32 k = 0; k < countof(fighter_data->throw_hitbox); k++)
384                    {
385                        fighter_data->throw_hitbox[k].bone = IDToBone(fighter_data, ft_data->throw_hitbox[k].bone);
386                        for (u32 l = 0; l < countof(fighter_data->throw_hitbox->victims); l++) // pointers to hitbox victims
387                        {
388                            fighter_data->throw_hitbox[k].victims[l].data = IDToFtData(ft_data->throw_hitbox[k].victims[l].data);
389                        }
390                    }
391                    fighter_data->thrown_hitbox.bone = IDToBone(fighter_data, ft_data->thrown_hitbox.bone);
392                    for (u32 k = 0; k < countof(fighter_data->thrown_hitbox.victims); k++) // pointers to hitbox victims
393                    {
394                        fighter_data->thrown_hitbox.victims[k].data = IDToFtData(ft_data->thrown_hitbox.victims[k].data);
395                    }
396
397                    // restore fighter variables
398                    memcpy(&fighter_data->fighter_var, &ft_data->fighter_var, sizeof(fighter_data->fighter_var)); // copy hitbox
399
400                    // zero pointer to cached animations to force anim load (fixes fall crash)
401                    fighter_data->anim_curr_ARAM = 0;
402                    fighter_data->anim_persist_ARAM = 0;
403
404                    // enter backed up state
405                    GOBJ *anim_source = 0;
406                    if (fighter_data->flags.is_robj_child == 1)
407                        anim_source = fighter_data->grab.attacker;
408                    Fighter_SetAllHurtboxesNotUpdated(fighter);
409                    ActionStateChange(ft_data->state_frame, ft_data->state_rate, -1, fighter, ft_data->state_id, 0, anim_source);
410                    fighter_data->state.blend = 0;
411
412                    // copy physics again to work around some bugs. Notably, this fixes savestates during dash.
413                    memcpy(&fighter_data->phys, &ft_data->phys, sizeof(fighter_data->phys));
414                    if (flags & Savestate_Mirror)
415                    {
416                        fighter_data->phys.anim_vel.X *= -1;
417                        fighter_data->phys.self_vel.X *= -1;
418                        fighter_data->phys.kb_vel.X *= -1;
419                        fighter_data->phys.atk_shield_kb_vel.X *= -1;
420                        fighter_data->phys.pos.X *= -1;
421                        fighter_data->phys.pos_prev.X *= -1;
422                        fighter_data->phys.pos_delta.X *= -1;
423                        fighter_data->phys.horzitonal_velocity_queue_will_be_added_to_0xec *= -1;
424                        fighter_data->phys.self_vel_ground.X *= -1;
425                        fighter_data->phys.nudge_vel.X *= -1;
426                    }
427
428                    // restore state variables
429                    memcpy(&fighter_data->state_var, &ft_data->state_var, sizeof(fighter_data->state_var)); // copy hitbox
430
431                    // restore ftcmd variables
432                    memcpy(&fighter_data->ftcmd_var, &ft_data->ftcmd_var, sizeof(fighter_data->ftcmd_var)); // copy hitbox
433
434                    // restore damage variables
435                    memcpy(&fighter_data->dmg, &ft_data->dmg, sizeof(ft_data->dmg)); // copy hitbox
436                    fighter_data->dmg.hit_log.source = IDToGOBJ(fighter_data->dmg.hit_log.source);
437
438                    // restore jump variables
439                    memcpy(&fighter_data->jump, &ft_data->jump, sizeof(fighter_data->jump)); // copy hitbox
440
441                    // restore flags
442                    memcpy(&fighter_data->flags, &ft_data->flags, sizeof(fighter_data->flags)); // copy hitbox
443
444                    // restore hurt variables
445                    memcpy(&fighter_data->hurt, &ft_data->hurt, sizeof(fighter_data->hurt)); // copy hurtbox
446
447                    // update jobj position
448                    JOBJ *fighter_jobj = fighter->hsd_object;
449                    fighter_jobj->trans = fighter_data->phys.pos;
450                    // dirtysub their jobj
451                    JOBJ_SetMtxDirtySub(fighter_jobj);
452
453                    // update hurtbox position
454                    Fighter_UpdateHurtboxes(fighter_data);
455
456                    // remove color overlay
457                    Fighter_ColAnim_Remove(fighter_data, 9);
458
459                    // restore color
460                    memcpy(fighter_data->color, ft_data->color, sizeof(fighter_data->color));
461
462                    // restore smash variables
463                    memcpy(&fighter_data->smash, &ft_data->smash, sizeof(fighter_data->smash)); // copy hitbox
464
465                    // restore shield/reflect/absorb variables
466                    memcpy(&fighter_data->shield, &ft_data->shield, sizeof(fighter_data->shield));                         // copy hitbox
467                    memcpy(&fighter_data->shield_bubble, &ft_data->shield_bubble, sizeof(fighter_data->shield_bubble));    // copy hitbox
468                    memcpy(&fighter_data->reflect_bubble, &ft_data->reflect_bubble, sizeof(fighter_data->reflect_bubble)); // copy hitbox
469                    memcpy(&fighter_data->absorb_bubble, &ft_data->absorb_bubble, sizeof(fighter_data->absorb_bubble));    // copy hitbox
470                    memcpy(&fighter_data->reflect_hit, &ft_data->reflect_hit, sizeof(fighter_data->reflect_hit));          // copy hitbox
471                    memcpy(&fighter_data->absorb_hit, &ft_data->absorb_hit, sizeof(fighter_data->absorb_hit));             // copy hitbox
472
473                    // restore callback functions
474                    memcpy(&fighter_data->cb, &ft_data->cb, sizeof(fighter_data->cb)); // copy hitbox
475
476                    // stop player SFX
477                    SFX_StopAllFighterSFX(fighter_data);
478
479                    // update colltest frame
480                    fighter_data->coll_data.coll_test = *stc_colltest;
481
482                    // restore camera subject
483                    CmSubject *thiscam = fighter_data->camera_subject;
484                    CmSubject *savedcam = (CmSubject *)&ft_data->camera_subject;
485                    void *alloc = thiscam->alloc;
486                    CmSubject *next = thiscam->next;
487                    memcpy(thiscam, savedcam, sizeof(ft_data->camera_subject));
488                    if (flags & Savestate_Mirror)
489                    {
490                        // These adjustments of mirroring camera are not perfect for now. Please fix this if you know suitable adjustments
491                        thiscam->cam_pos.X *= -1;
492                        thiscam->bone_pos.X *= -1;
493                        thiscam->direction *= -1;
494                    }
495                    thiscam->alloc = alloc;
496                    thiscam->next = next;
497
498                    // update their IK
499                    Fighter_UpdateIK(fighter);
500
501                    // if shield is up, update shield
502                    if ((fighter_data->state_id >= ASID_GUARDON) && (fighter_data->state_id <= ASID_GUARDREFLECT))
503                    {
504                        fighter_data->shield_bubble.bone = 0;
505                        fighter_data->reflect_bubble.bone = 0;
506                        fighter_data->absorb_bubble.bone = 0;
507
508                        GuardOnInitIDK(fighter);
509                        Animation_GuardAgain(fighter);
510                    }
511
512                    // process dynamics
513
514                    int dyn_proc_num = 45;
515
516                    // simulate dynamics a bunch to fall in place
517                    for (int d = 0; d < dyn_proc_num; d++)
518                    {
519                        Fighter_ProcDynamics(fighter);
520                    }
521
522                    // remove all items belonging to this fighter
523                    GOBJ *item = (*stc_gobj_lookup)[MATCHPLINK_ITEM];
524                    while (item != 0)
525                    {
526                        // get next
527                        GOBJ *next_item = item->next;
528
529                        // check to delete
530                        ItemData *item_data = item->userdata;
531                        if (fighter == item_data->fighter_gobj)
532                        {
533                            // destroy it
534                            Item_Destroy(item);
535                        }
536
537                        item = next_item;
538                    }
539                }
540            }
541
542            // If subchar exists, reset its leader log, tracked position, and facing direction. 
543            // This is to fix a bug where the last 30 frames before save state reset would get carried into the subcharacter's
544            // queue after loading a savestate. A more ideal fix would be to save and restore the cpu leader log, but implementing
545            // that will have to wait until the upcomming save state refactor is done. For now this solves most problems by clearing
546            // out the queue on reset so the subcharacter starts with a blank cpu log, which is what you want in most situations. 
547            if (queue[1].fighter != 0 && savestate->ft_state[i].data[1].is_exist == 1){
548
549                FtSaveStateData_v1 *primarychar_data = &ft_state->data[0];
550                FighterData *subchar_fighter_data = queue[1].fighter_data;
551
552                for (u32 j = 0; j < countof(subchar_fighter_data->cpu.leader_log); j++) 
553                {
554                    // set the pos target to the primary character's position to avoid a force target at 0,0,0
555                    // set the facing direction to the primary character's facing direction to avoid the facing direction being incorrect on the first frame
556                    subchar_fighter_data->cpu.leader_log[j] = (struct CPULeaderLog){
557                        .pos = primarychar_data->phys.pos,
558                        .facing_direction = primarychar_data->facing_direction
559                    };
560                }
561            }
562
563            // check to recreate HUD
564            MatchHUDElement *hud = &stc_matchhud->element_data[i];
565
566            // check if fighter is perm dead
567            if (Match_CheckIfStock() == 1)
568            {
569                // remove HUD if no stocks left
570                if (Fighter_GetStocks(i) <= 0)
571                {
572                    hud->is_removed = 0;
573                }
574            }
575
576            // check to create it
577            if (hud->is_removed == 1)
578            {
579                Match_CreateHUD(i);
580            }
581
582            // snap camera to the new positions
583            Match_CorrectCamera();
584
585            // stop crowd cheer
586            SFX_StopCrowd();
587        }
588    }
589    
590    if (isLoaded == 1) {
591        // restore frame
592        Match *match = stc_match;
593        match->time_frames = savestate->frame;
594        event_vars->game_timer = savestate->frame;
595
596        // update timer
597        int frames = match->time_frames - 1; // this is because the scenethink function runs once before the gobj procs do
598        match->time_seconds = frames / 60;
599        match->time_ms = frames % 60;
600
601        // restore event data
602        memcpy(event_vars->event_gobj->userdata, &savestate->event_data, sizeof(savestate->event_data));
603
604        // remove all particles
605        for (int i = 0; i < PTCL_LINKMAX; i++)
606        {
607            Particle **ptcls = &stc_ptcl[i];
608            Particle *ptcl = *ptcls;
609            while (ptcl != 0)
610            {
611
612                Particle *ptcl_next = ptcl->next;
613
614                // begin destroying this particle
615
616                // subtract some value, 8039c9f0
617                if (ptcl->gen != 0)
618                {
619                    ptcl->gen->particle_num--;
620                }
621                // remove from generator? 8039ca14
622                if (ptcl->gen != 0)
623                    psRemoveParticleAppSRT(ptcl);
624
625                // delete parent jobj, 8039ca48
626                psDeletePntJObjwithParticle(ptcl);
627
628                // update most recent ptcl pointer
629                *ptcls = ptcl->next;
630
631                // free alloc, 8039ca54
632                HSD_ObjFree((void *)0x804d0f60, ptcl);
633
634                // decrement ptcl total
635                u16 ptclnum = *stc_ptclnum;
636                ptclnum--;
637                *stc_ptclnum = ptclnum;
638
639                // get next
640                ptcl = ptcl_next;
641            }
642        }
643
644        // remove all camera shake gobjs (p_link 18, entity_class 3)
645        GOBJ *gobj = (*stc_gobj_lookup)[MATCHPLINK_MATCHCAM];
646        while (gobj != 0)
647        {
648
649            GOBJ *gobj_next = gobj->next;
650
651            // if entity class 3 (quake)
652            if (gobj->entity_class == 3)
653            {
654                GObj_Destroy(gobj);
655            }
656
657            gobj = gobj_next;
658        }
659    }
660    
661    // sfx
662    if ((flags & Savestate_Silent) == 0) {
663        if (isLoaded == 0) {
664            SFX_PlayCommon(3);
665        } else {
666            SFX_PlayCommon(0);
667        }
668    }
669
670    return isLoaded;
671}