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