fork/slippc
git clone https://git.julia.blue/fork/slippc
b79f91c
0.8.1
1#include "compressor.h" 2 3namespace slip { 4 5Compressor ::Compressor (int debug_level ) { 6_debug = debug_level ; 7_bp = 0 ; 8 } 9 10Compressor ::~Compressor () { 11if (_rb != nullptr ) {delete []_rb ; } 12if (_wb != nullptr ) {delete []_wb ; } 13if (_outfilename != nullptr ) {delete _outfilename ; } 14if (_outgeckofilename != nullptr ) {delete _outgeckofilename ; } 15 } 16 17bool Compressor ::loadFromFile (const char * replayfilename ) { 18DOUT1 (" Loading " <<replayfilename ); 19 std::ifstream myfile ; 20myfile .open (replayfilename ,std::ios::binary | std::ios::in ); 21if (myfile .fail ()) { 22FAIL (" File " <<replayfilename <<" could not be opened or does not exist" ); 23return false; 24 } 25 26myfile .seekg (0 ,myfile .end ); 27_file_size = myfile .tellg (); 28if (_file_size < MIN_REPLAY_LENGTH ) { 29FAIL (" File " <<replayfilename <<" is too short to be a valid Slippi replay" ); 30return false; 31 } 32myfile .seekg (0 ,myfile .beg ); 33 34_rb = new char [_file_size ]; 35myfile .read (_rb ,_file_size ); 36myfile .close (); 37 38// Check if we have a compressed stream 39bool is_compressed = same4 (& _rb [0 ],LZMA_HEADER ); 40if (is_compressed ) { 41DOUT1 (" File Size: " <<+ _file_size <<", compressed" ); 42// Decompress the read buffer 43 std::string decomp = decompressWithLzma (_rb ,_file_size ); 44// Get the new file size 45_file_size = decomp .size (); 46// Delete the old read buffer 47delete []_rb ; 48// Reallocate it with more spce 49_rb = new char [_file_size ]; 50// Copy buffer from the decompressed string 51memcpy (_rb ,decomp .c_str (),_file_size ); 52 }else { 53DOUT1 (" File Size: " <<+ _file_size ); 54 } 55 56_infilename = replayfilename ; 57 58_wb = new char [_file_size ]; 59memcpy (_wb ,_rb ,sizeof (char )* _file_size ); 60 61return this -> _parse (); 62 } 63 64void Compressor ::saveToFile (bool rawencode ) { 65if (fileExists (* _outfilename )) { 66FAIL (" File " <<* _outfilename <<" exists, refusing to overwrite" ); 67return ; 68 } 69 70 std::ofstream ofile ; 71ofile .open (* _outfilename , std::ios::binary | std::ios::out ); 72// If this is the unencoded version, compress it first 73if (!(_encode_ver || rawencode )) { 74// Compress the write buffer 75 std::string comp = compressWithLzma (_wb ,_file_size ); 76DOUT1 (" Compression Ratio = " <<float (_file_size - comp .size ())/_file_size ); 77// Write compressed buffer to file 78ofile .write (comp .c_str (),sizeof (char )* comp .size ()); 79 }else { 80// Write normal buffer to file 81ofile .write (_wb ,sizeof (char )* _file_size ); 82 } 83 84ofile .close (); 85 86 } 87 88bool Compressor ::setOutputFilename (const char * fname ) { 89if (fileExists (fname )) { 90return false; 91 } 92if (_outfilename != nullptr ) { 93delete _outfilename ; 94 } 95_outfilename = new std::string (fname ); 96return true; 97 } 98 99bool Compressor ::setGeckoOutputFilename (const char * fname ) { 100if (_outgeckofilename != nullptr ) { 101delete _outgeckofilename ; 102 } 103_outgeckofilename = new std::string (fname ); 104_outgeckofilename -> append (".dat" ); 105if (fileExists (* _outgeckofilename )) { 106return false; 107 } 108return true; 109 } 110 111unsigned Compressor ::saveToBuff (char ** buffer ) { 112// buffer = new char[_file_size]; 113* buffer = new char [_file_size ]; 114memcpy (* buffer ,_wb ,sizeof (char )* _file_size ); 115return _file_size ; 116 } 117 118bool Compressor ::loadFromBuff (char ** buffer ,unsigned size ) { 119_file_size = size ; 120_wb = new char [_file_size ]; 121_rb = new char [_file_size ]; 122memcpy (_wb ,* buffer ,sizeof (char )* _file_size ); 123memcpy (_rb ,* buffer ,sizeof (char )* _file_size ); 124return this -> _parse (); 125 } 126 127bool Compressor ::validate () { 128if (_encode_ver ) { 129return true; 130 } 131 132char * enc_buff = nullptr ,* dec_buff = nullptr ; 133unsigned size = this -> saveToBuff (& enc_buff ); 134Compressor * d = new slip::Compressor (_debug ); 135d -> loadFromBuff (& enc_buff ,size ); 136d -> saveToBuff (& dec_buff ); 137 138bool success = (memcmp (_rb ,dec_buff ,size )== 0 ); 139if (!success ) { 140unsigned diff = 0 ; 141for (unsigned i = 0 ;i < size ;++ i ) { 142if (_rb [i ]!= dec_buff [i ]) { 143if ((++ diff ) <=500 ) { 144DOUT2 (" Byte " <<i <<" differs! orig " 145 <<int (_rb [i ]) <<" != " <<int (dec_buff [i ]) <<" new" ); 146 } 147 } 148 } 149DOUT1 ("Differs in " <<diff <<"/" <<size <<" bytes" ); 150 } 151 152delete []dec_buff ; 153delete []enc_buff ; 154delete d ; 155 156return success ; 157 } 158 159bool Compressor ::_parse () { 160_bp = 0 ;//Start reading from byte 0 161if (notthis -> _parseHeader ()) { 162FAIL (" Failed to parse header" ); 163return false; 164 } 165if (notthis -> _parseEventDescriptions ()) { 166FAIL (" Failed to parse event descriptions" ); 167return false; 168 } 169if (notthis -> _parseEvents ()) { 170FAIL (" Failed to parse events proper" ); 171return false; 172 } 173DOUT1 (" Successfully parsed replay!" ); 174return true; 175 } 176 177bool Compressor ::_parseHeader () { 178DOUT1 (" Parsing header" ); 179 180//First 15 bytes contain header information 181if (same8 (& _rb [_bp ],SLP_HEADER )) { 182DOUT1 (" Slippi Header Matched" ); 183 }else { 184FAIL_CORRUPT (" Header did not match expected Slippi file header" ); 185return false; 186 } 187_length_raw_start = readBE4U (& _rb [_bp + 11 ]); 188if (_length_raw_start == 0 ) {//TODO: this is /technically/ recoverable 189FAIL_CORRUPT (" 0-byte raw data detected" ); 190return false; 191 } 192DOUT1 (" Raw portion = " <<_length_raw_start <<" bytes" ); 193if (_length_raw_start > _file_size ) { 194FAIL_CORRUPT (" Raw data size exceeds file size of " <<_file_size <<" bytes" ); 195return false; 196 } 197_length_raw = _length_raw_start ; 198_bp += 15 ; 199return true; 200 } 201 202bool Compressor ::_parseEventDescriptions () { 203DOUT1 (" Parsing event descriptions" ); 204 205//Next 2 bytes should be 0x35 206if (_rb [_bp ]!= Event ::EV_PAYLOADS ) { 207FAIL_CORRUPT (" Expected Event 0x" << std::hex 208 <<Event ::EV_PAYLOADS << std::dec <<" (Event Payloads)" ); 209return false; 210 } 211uint8_t ev_bytes = _rb [_bp + 1 ]- 1 ;//Subtract 1 because the last byte we read counted as part of the payload 212_payload_sizes [Event ::EV_PAYLOADS ]= int32_t (ev_bytes + 1 ); 213DOUT1 (" Event description length = " <<int32_t (ev_bytes + 1 ) <<" bytes" ); 214_bp += 2 ; 215 216//Next ev_bytes bytes describe events 217for (unsigned i = 0 ;i < ev_bytes ;i += 3 ) { 218unsigned ev_code = uint8_t (_rb [_bp + i ]); 219if (_payload_sizes [ev_code ]> 0 ) { 220if (ev_code >=Event ::EV_PAYLOADS && ev_code <=Event ::GAME_END ) { 221FAIL_CORRUPT (" Event " <<Event ::name [ev_code - Event ::EV_PAYLOADS ] <<" payload size set multiple times" ); 222 }else { 223FAIL_CORRUPT (" Event " <<hex (ev_code ) << std::dec <<" payload size set multiple times" ); 224 } 225return false; 226 } 227_payload_sizes [ev_code ]= readBE2U (& _rb [_bp + i + 1 ])+ 1 ;//Add one because of the event code itself 228DOUT1 (" Payload size for event " 229 <<hex (ev_code ) << std::dec <<": " <<_payload_sizes [ev_code ] 230 <<" bytes" ); 231 } 232 233//Sanity checks to verify we at least have Payload Sizes, Game Start, Pre Frame, Post Frame, and Game End Events 234for (unsigned i = Event ::EV_PAYLOADS ;i <=Event ::GAME_END ;++ i ) { 235if (_payload_sizes [i ]== 0 ) { 236FAIL_CORRUPT (" Event " <<Event ::name [i - Event ::EV_PAYLOADS ] <<" payload size not set" ); 237return false; 238 } 239 } 240 241//Update the remaining length of the raw data to sift through 242_bp += ev_bytes ; 243_length_raw -= (2 + ev_bytes ); 244return true; 245 } 246 247bool Compressor ::_parseEvents () { 248DOUT1 (" Parsing events proper" ); 249 250bool success = true; 251for ( ;_length_raw > 0 ; ) { 252unsigned ev_code = uint8_t (_rb [_bp ]); 253 254unsigned shift = _payload_sizes [ev_code ]; 255if (shift > _length_raw ) { 256FAIL_CORRUPT (" Event byte offset exceeds raw data length" ); 257return false; 258 } 259DOUT2 (" EV code " <<hex (ev_code ) <<" encountered" ); 260switch (ev_code ) {//Determine the event code 261case Event ::GAME_START :success = _parseGameStart ();break ; 262case Event ::SPLIT_MSG :success = _parseGeckoCodes ();break ; 263case Event ::FRAME_START :success = _parseFrameStart ();break ; 264case Event ::PRE_FRAME :success = _parsePreFrame ();break ; 265case Event ::ITEM_UPDATE :success = _parseItemUpdate ();break ; 266case Event ::POST_FRAME :success = _parsePostFrame ();break ; 267case Event ::BOOKEND :success = _parseBookend ();break ; 268case Event ::GAME_END : 269_game_end_found = true; 270_game_loop_end = _bp ; 271if (!_encode_ver ) { 272_shuffleEvents (); 273 } 274success = true; 275break ; 276default : 277DOUT1 (" Warning: unknown event code " <<hex (ev_code ) <<" encountered; skipping" ); 278break ; 279 } 280if (notsuccess ) { 281return false; 282 } 283if (_payload_sizes [ev_code ]== 0 ) { 284FAIL_CORRUPT (" Uninitialized event " <<hex (ev_code ) <<" encountered" ); 285return false; 286 } 287_length_raw -= shift ; 288_bp += shift ; 289DOUT2 (" Raw bytes remaining: " <<+ _length_raw ); 290 } 291if (!_game_end_found ) { 292FAIL_CORRUPT (" No game end event found" ); 293return false; 294 } 295return true; 296 } 297 298bool Compressor ::_parseGameStart () { 299DOUT1 (" Parsing game start event at byte " <<+ _bp ); 300 301//Get Slippi version 302_slippi_maj = uint8_t (_rb [_bp + O_SLP_MAJ ]);//Major version 303_slippi_min = uint8_t (_rb [_bp + O_SLP_MIN ]);//Minor version 304_slippi_rev = uint8_t (_rb [_bp + O_SLP_REV ]);//Build version (4th char unused) 305_encode_ver = uint8_t (_rb [_bp + O_SLP_ENC ]);//Whether the file is encoded 306if (MIN_VERSION (3 ,13 ,0 )) { 307FAIL (" Version is " <<GET_VERSION () <<". Replays from Slippi 3.13.0 and higher are not supported" ); 308return false; 309 } 310 311//Set encoding status for output buffer 312if (_wb [_bp + O_SLP_ENC ]) { 313_wb [_bp + O_SLP_ENC ]= 0 ;//Input is encoded, so we will decode 314 }else { 315_wb [_bp + O_SLP_ENC ]= COMPRETZ_VERSION ;//Input is not encoded, use current version 316 } 317 318// ensure we have a good output filename based on encode status 319if (!ensureAppropriateFilename ()) { 320return false; 321 } 322 323//Print slippi version 324 std::stringstream ss ; 325ss <<+ _slippi_maj <<"." <<+ _slippi_min <<"." <<+ _slippi_rev ; 326DOUT1 (" Slippi Version: " <<ss .str () <<", " << (_encode_ver ?"encoded" :"raw" )); 327if (_encode_ver ) { 328DOUT1 (" Compressed with: slippc compression ver. " <<int (_encode_ver )); 329 } 330 331//Get starting RNG state 332_rng = readBE4U (& _rb [_bp + O_RNG_GAME_START ]); 333_rng_start = _rng ; 334DOUT1 (" Starting RNG: " <<_rng ); 335 336return true; 337 } 338 339bool Compressor ::_parseGeckoCodes () { 340if (ENCODE_VERSION_MIN (2 )) { 341// Debug output for actually dumping the gecko code messages to a file 342if (_outgeckofilename ) { 343char * main_buf = (_encode_ver ?_wb :_rb ); 344 std::fstream fin ; 345if (_message_count ) { 346fin .open (* _outgeckofilename , std::ios::out | std::ios::app | std::ios::binary ); 347 }else { 348fin .open (* _outgeckofilename , std::ios::out | std::ios::trunc | std::ios::binary ); 349 } 350fin .write (& (main_buf [_bp ]),MESSAGE_SIZE ); 351fin .close (); 352++ _message_count ; 353 } 354//Assuming everyone has the same default Gecko codes doesn't work, so V2 doesn't do anything fancy 355return true; 356 } 357 358// V1 tried to XOR gecko codes but implemented it wrong anyway 359// because it used a function-local variable to count messages, 360// so it ended up XORing the same 512 bytes over and over again 361// Must keep this here as a reminder of my shame ): 362 363// Load default Gecko codes 364const char * codes = readLegacyGeckoCodes (); 365 366// XOR encode everything but the command byte 367for (unsigned i = 1 ;i < MESSAGE_SIZE ;++ i ) { 368_wb [_bp + i ]= _rb [_bp + i ] ^codes [i ]; 369 } 370 371return true; 372 } 373 374bool Compressor ::_parseItemUpdate () { 375//Encodings so far 376//0x00 - 0x00 | Command Byte | No encoding 377//0x01 - 0x04 | Frame Number | Predictive encoding (last frame + 1) 378//0x05 - 0x06 | Type ID | XORed with last item-slot value 379//0x07 - 0x07 | State | XORed with last item-slot value 380//0x08 - 0x0B | Facing Direction | XORed with last item-slot value 381//0x0C - 0x0F | X Velocity | Predicted from X position on this / last frame 382//0x10 - 0x13 | Y Velocity | Predicted from Y position on this / last frame 383//0x14 - 0x17 | X Position | Predictive encoding (2-frame delta) 384//0x18 - 0x1B | Y Position | Predictive encoding (2-frame delta) 385//0x1C - 0x1D | Damage Taken | XORed with last item-slot value 386//0x1E - 0x21 | Expiration Timer | Predictive encoding (2-frame delta) 387//0x22 - 0x25 | Spawn ID | No encoding 388//0x26 - 0x29 | Misc Values | XORed with last item-slot value 389//0x2A - 0x2A | Owner | XORed with last item-slot value 390 391DOUT2 (" Compressing item event at byte " <<+ _bp ); 392char * main_buf = (_encode_ver ?_wb :_rb ); 393 394//Encode frame number, predicting the last frame number +1 395int cur_item_frame = readBE4S (& _rb [_bp + O_FRAME ]); 396int pred_item_frame = predictFrame (cur_item_frame ,lastitemstartframe ,& _wb [_bp + O_FRAME ]); 397lastitemstartframe = _encode_ver ?pred_item_frame :cur_item_frame ; 398DOUT2 (" Item frame is " <<+ lastitemstartframe ); 399 400if (_debug >=3 ) { 401int fnum = readBE4S (& _rb [_bp + O_FRAME ]); 402int inum = readBE4U (& _rb [_bp + O_ITEM_ID ]); 403DOUT3 (" EVID " <<+ fnum <<".3" <<+ inum ); 404 } 405 406//Get a storage slot for the item 407uint8_t slot = readBE4U (& _rb [_bp + O_ITEM_ID ]) %ITEM_SLOTS ; 408 409//XOR all of the remaining data for the item 410uint16_t itype ; 411// TODO: not sure if I even need this split 412if (ENCODE_VERSION_MIN (2 )) { 413// we use ITEM_TYPE for other purposes, so don't XOR it 414xorEncodeRange (O_ITEM_STATE ,O_ITEM_XVEL ,_x_item [slot ]); 415// Ignore the bits used for storing defer information 416itype = decodeDeferInfo (readBE2U (& main_buf [_bp + O_ITEM_TYPE ])); 417 }else { 418xorEncodeRange (O_ITEM_TYPE ,O_ITEM_XVEL ,_x_item [slot ]); 419itype = readBE2U (& main_buf [_bp + O_ITEM_TYPE ]); 420 } 421xorEncodeRange (O_ITEM_DAMAGE ,O_ITEM_EXPIRE ,_x_item [slot ]); 422 423//Predict item positions based on velocity 424predictVelocItem (slot ,O_ITEM_XPOS ); 425 426//V2 and up of compressor predicts velocities y position based on item type 427if (ENCODE_VERSION_MIN (2 )) { 428switch (itype ) { 429case 0xd2 ://Shy Guy 430// Shy guys are jerks (yay puns) 431predictJoltItem (slot ,O_ITEM_YPOS );break ; 432default ://Everything else just uses V1 behavior 433predictAccelItem (slot ,O_ITEM_YPOS );break ; 434 } 435 }else {// V1 of compressor always used predictAccelItem() 436predictAccelItem (slot ,O_ITEM_YPOS ); 437 } 438 439// Use item positions to determine their velocties 440predictAsDifference (O_ITEM_XVEL ,O_ITEM_XPOS ,_x_item_p [slot ]); 441predictAsDifference (O_ITEM_YVEL ,O_ITEM_YPOS ,_x_item_p [slot ]); 442 443//Predict item expiration based on velocity 444predictVelocItem (slot ,O_ITEM_EXPIRE ); 445 446if (MIN_VERSION (3 ,2 ,0 )) { 447xorEncodeRange (O_ITEM_MISC ,O_ITEM_OWNER ,_x_item [slot ]); 448if (MIN_VERSION (3 ,6 ,0 )) { 449xorEncodeRange (O_ITEM_OWNER ,O_ITEM_END ,_x_item [slot ]); 450 } 451 } 452 453if (_debug == 0 ) {return true; } 454 455return true; 456 } 457 458bool Compressor ::_parseFrameStart () { 459//Encodings so far 460//0x00 - 0x00 | Command Byte | No encoding 461//0x01 - 0x04 | Frame Number | Predictive encoding (last frame + 1), second bit flipped if raw RNG 462//0x05 - 0x08 | RNG Seed | Predictive encoding (# of RNG rolls, or raw) 463 464if (_game_loop_start == 0 ) { 465_game_loop_start = _bp ; 466if (_encode_ver ) { 467_unshuffleEvents (); 468 } 469 } 470 471if (_debug >=3 ) { 472int fnum = readBE4S (& _rb [_bp + O_FRAME ]); 473DOUT3 (" EVID " <<+ fnum <<".10" ); 474 } 475 476//Encode frame number, predicting the last frame number +1 477int cur_frame = readBE4S (& _rb [_bp + O_FRAME ]); 478int pred_frame = predictFrame (cur_frame ,laststartframe ,& _wb [_bp + O_FRAME ]); 479 480//Update laststartframe since we just crossed a new frame boundary 481laststartframe = _encode_ver ?pred_frame :cur_frame ; 482 483//Predict RNG value from real (not delta encoded) frame number 484predictRNG (O_FRAME ,O_RNG_FS ); 485 486return true; 487 } 488 489bool Compressor ::_parseBookend () { 490//Encodings so far 491//0x00 - 0x00 | Command Byte | No encoding 492//0x01 - 0x04 | Frame Number | Predictive encoding (last frame + 1) 493//0x05 - 0x08 | Rollback Frame | Predictive encoding (last frame + 1) 494 495if (_debug >=3 ) { 496if (MIN_VERSION (3 ,7 ,0 )) { 497int fnum = readBE4S (& _rb [_bp + O_FRAME ]); 498int ffin = readBE4S (& _rb [_bp + O_ROLLBACK_FRAME ]); 499DOUT3 (" EVID " <<+ fnum <<".50 (" <<ffin <<")" ); 500 } 501 } 502 503//Encode actual frame number, predicting and updating laststartframe 504predictFrame (readBE4S (& _rb [_bp + O_FRAME ]),laststartframe ,& _wb [_bp + O_FRAME ]); 505if (MIN_VERSION (3 ,7 ,0 )) { 506//Encode rollback frame number, predicting laststartframe without update 507predictFrame (readBE4S (& _rb [_bp + O_ROLLBACK_FRAME ]),laststartframe ,& _wb [_bp + O_ROLLBACK_FRAME ]); 508 } 509 510return true; 511 } 512 513bool Compressor ::_parsePreFrame () { 514//Encodings so far 515//0x00 - 0x00 | Command Byte | No encoding 516//0x01 - 0x04 | Frame Number | Predictive encoding (last frame + 1), second bit flipped if raw RNG 517//0x05 - 0x05 | Player Index | No encoding (never changes) 518//0x06 - 0x06 | Is Follower | No encoding (never changes) 519//0x07 - 0x0A | RNG Seed | Predictive encoding (# of RNG rolls, or raw) 520//0x0B - 0x0C | Action State | XORed with last post-frame value 521//0x0D - 0x10 | X Position | XORed with last post-frame value 522//0x11 - 0x14 | Y Position | XORed with last post-frame value 523//0x15 - 0x18 | Facing Direction | XORed with last post-frame value 524//0x19 - 0x1C | Joystick X | Value retrieved from float map 525//0x1D - 0x20 | Joystick Y | Value retrieved from float map 526//0x21 - 0x24 | C-Stick X | Value retrieved from float map 527//0x25 - 0x28 | C-Stick Y | Value retrieved from float map 528//0x29 - 0x2C | Trigger | Value retrieved from float map 529//0x2D - 0x30 | Processed Buttons | No encoding (already sparse) 530//0x31 - 0x32 | Physical Buttons | XORed with lower bits of Processed Buttons 531//0x33 - 0x36 | Physical L | Value retrieved from float map 532//0x37 - 0x3A | Physical R | Value retrieved from float map 533//0x3B - 0x3B | UCF X analog | No encoding 534//0x3C - 0x3F | Damage | No encoding (already sparse) 535 536// Old code for trying to predict Joy X from Joy Y and UCF X 537// if (!_encode_ver) { 538// float joyx = readBE4F(&_rb[_bp+O_JOY_X]); 539// float joyy = readBE4F(&_rb[_bp+O_JOY_Y]); 540// int8_t ucfx = _rb[_bp+O_UCF_ANALOG]; 541// int8_t intx = float(joyx*80.0f); 542// int8_t inty = float(joyy*80.0f); 543 544// int8_t predx; 545// if (inty > 27 || inty < -58) { 546// predx = 0; 547// } else if (ucfx < -22) { 548// predx = ucfx; 549// } else if (ucfx > 22) { 550// predx = ucfx; 551// } else { 552// predx = 0; 553// } 554 555// if (predx > 79) { 556// predx = 79; 557// } else if (predx < -79) { 558// predx = -79; 559// } 560 561// std::cout 562// << " PRED " << padString(predx,4) 563// << " INT X " << padString(intx,4) 564// << " UCF X " << padString(ucfx,4) 565// << " INT Y " << padString(inty,4) 566// << (((predx != 0) && (predx != intx)) ? " MISS" : "") 567// << std::endl; 568// } 569 570DOUT2 (" Compressing pre frame event at byte " <<+ _bp ); 571char * main_buf = (_encode_ver ?_wb :_rb ); 572 573//Get player index 574uint8_t p = uint8_t (_rb [_bp + O_PLAYER ])+ 4 * uint8_t (_rb [_bp + O_FOLLOWER ]);//Includes follower 575if (p > 7 ) { 576FAIL_CORRUPT (" Invalid player index " <<+ p ); 577return false; 578 } 579 580if (_debug >=3 ) { 581int fnum = readBE4S (& _rb [_bp + O_FRAME ]); 582DOUT3 (" EVID " <<+ fnum <<".2" <<+ p ); 583 } 584 585//Encode frame number, predicting the last frame number +1 586int cur_frame = readBE4S (& _rb [_bp + O_FRAME ]); 587int pred_frame = predictFrame (cur_frame ,lastpreframe [p ],& _wb [_bp + O_FRAME ]); 588//Update lastpreframe[p] since we just crossed a new frame boundary 589lastpreframe [p ]= _encode_ver ?pred_frame :cur_frame ; 590 591DOUT2 (" Pre frame is " <<+ lastpreframe [p ]); 592 593//Predict RNG value from real (not delta encoded) frame number 594predictRNG (O_FRAME ,O_RNG_PRE ); 595 596//Carry over action state from last post-frame 597writeBE2U (readBE2U (& _rb [_bp + O_ACTION_PRE ]) ^readBE2U (& _x_post_frame [p ][O_ACTION_POST ]),& _wb [_bp + O_ACTION_PRE ]); 598memcpy (& _x_pre_frame [p ][O_ACTION_PRE ],& main_buf [_bp + O_ACTION_PRE ],2 ); 599 600//Carry over x position from last post-frame 601writeBE4U (readBE4U (& _rb [_bp + O_XPOS_PRE ]) ^readBE4U (& _x_post_frame [p ][O_XPOS_POST ]),& _wb [_bp + O_XPOS_PRE ]); 602memcpy (& _x_pre_frame [p ][O_XPOS_PRE ],& main_buf [_bp + O_XPOS_PRE ],4 ); 603 604//Carry over y position from last post-frame 605writeBE4U (readBE4U (& _rb [_bp + O_YPOS_PRE ]) ^readBE4U (& _x_post_frame [p ][O_YPOS_POST ]),& _wb [_bp + O_YPOS_PRE ]); 606memcpy (& _x_pre_frame [p ][O_YPOS_PRE ],& main_buf [_bp + O_YPOS_PRE ],4 ); 607 608//Carry over facing direction from last post-frame 609writeBE4U (readBE4U (& _rb [_bp + O_FACING_PRE ]) ^readBE4U (& _x_post_frame [p ][O_FACING_POST ]),& _wb [_bp + O_FACING_PRE ]); 610memcpy (& _x_pre_frame [p ][O_FACING_PRE ],& main_buf [_bp + O_FACING_PRE ],4 ); 611 612// Encode analog stick and trigger values as integers 613encodeAnalog (O_JOY_X ,80.0f ); 614encodeAnalog (O_JOY_Y ,80.0f ); 615encodeAnalog (O_CX ,80.0f ); 616encodeAnalog (O_CY ,80.0f ); 617encodeAnalog (O_TRIGGER ,140.0f ); 618encodeAnalog (O_PHYS_L ,140.0f ); 619encodeAnalog (O_PHYS_R ,140.0f ); 620 621// Encode physical buttons from lower bits of processed buttons 622uint16_t phys_buttons = readBE2U (& main_buf [_bp + O_BUTTONS ]); 623uint16_t proc_buttons = readBE2U (& main_buf [_bp + O_PROCESSED + 2 ]); 624writeBE2U (proc_buttons ^phys_buttons ,& _wb [_bp + O_BUTTONS ]); 625 626return true; 627 } 628 629bool Compressor ::_parsePostFrame () { 630//Encodings so far 631//0x00 - 0x00 | Command Byte | No encoding 632//0x01 - 0x04 | Frame Number | Predictive encoding (last frame + 1) 633//0x05 - 0x05 | Player Index | No encoding (never changes) 634//0x06 - 0x06 | Is Follower | No encoding (never changes) 635//0x07 - 0x07 | Char ID | No encoding (already sparse) 636//0x08 - 0x09 | Action State | No encoding, but used to predict pre-frame 637//0x0A - 0x0D | X Position | Predictive encoding (3-frame accel) 638//0x0E - 0x11 | Y Position | Predictive encoding (3-frame accel) 639//0x12 - 0x15 | Facing Direction | No encoding, but used to predict pre-frame 640//0x16 - 0x19 | Damage | No encoding, but used to predict pre-frame 641//0x1A - 0x1D | Shield | Predictive encoding (2-frame delta) 642//0x1E - 0x1E | Last Hitting Attack | XOR encoding 643//0x1F - 0x1F | Combo Count | XOR encoding 644//0x20 - 0x20 | Last Hit By | XOR encoding 645//0x21 - 0x21 | Stocks Remaining | XOR encoding 646//0x22 - 0x25 | AS Frame Counter | Predictive encoding (2-frame delta) 647//0x26 - 0x2A | State Bit Flags | XOR encoding 648//0x2B - 0x2E | Hitstun Counter | Predictive encoding (2-frame delta) 649//0x2F - 0x2F | Ground / Air State | No encoding (already sparse) 650//0x30 - 0x31 | Ground ID | No encoding (already sparse) 651//0x32 - 0x32 | Jumps Remaining | No encoding (already sparse) 652//0x33 - 0x33 | L Cancel Status | No encoding (already sparse) 653//0x34 - 0x34 | Hurtbox Status | No encoding (already sparse) 654//0x35 - 0x38 | Self Air X-velocity | Predictive encoding (2-frame delta) 655//0x39 - 0x3C | Self Y-velocity | Predictive encoding (2-frame delta) 656//0x3D - 0x40 | Attack X-velocity | Predictive encoding (2-frame delta) 657//0x41 - 0x44 | Attack Y-velocity | Predictive encoding (2-frame delta) 658//0x45 - 0x48 | Self Ground X-vel. | Predictive encoding (2-frame delta) 659 660DOUT2 (" Compressing post frame event at byte " <<+ _bp ); 661char * main_buf = (_encode_ver ?_wb :_rb ); 662 663union {float f ;uint32_t u ; }float_true ,float_pred ,float_temp ; 664int32_t fnum = readBE4S (& _rb [_bp + O_FRAME ]); 665int32_t f = fnum - LOAD_FRAME ; 666 667//Get player index 668uint8_t p = uint8_t (_rb [_bp + O_PLAYER ])+ 4 * uint8_t (_rb [_bp + O_FOLLOWER ]);//Includes follower 669if (p > 7 ) { 670FAIL_CORRUPT (" Invalid player index " <<+ p ); 671return false; 672 } 673 674if (_debug >=3 ) { 675int fnum = readBE4S (& _rb [_bp + O_FRAME ]); 676DOUT3 (" EVID " <<+ fnum <<".4" <<+ p ); 677 } 678 679//Encode frame number, predicting the last frame number +1 680int cur_frame = readBE4S (& _rb [_bp + O_FRAME ]); 681int pred_frame = predictFrame (cur_frame ,lastpostframe [p ],& _wb [_bp + O_FRAME ]); 682//Update lastpreframe[p] since we just crossed a new frame boundary 683lastpostframe [p ]= _encode_ver ?pred_frame :cur_frame ; 684 685DOUT2 (" Post frame is " <<+ lastpostframe [p ]); 686 687//Predict x position based on velocity and acceleration 688predictAccelPost (p ,O_XPOS_POST ); 689//Predict y position based on velocity and acceleration 690predictAccelPost (p ,O_YPOS_POST ); 691 692//Copy action state to post-frame 693memcpy (& _x_post_frame [p ][O_ACTION_POST ],& main_buf [_bp + O_ACTION_POST ],2 ); 694//Copy x position to post-frame 695memcpy (& _x_post_frame [p ][O_XPOS_POST ],& main_buf [_bp + O_XPOS_POST ],4 ); 696//Copy y position to post-frame 697memcpy (& _x_post_frame [p ][O_YPOS_POST ],& main_buf [_bp + O_YPOS_POST ],4 ); 698//Copy facing direction to post-frame 699memcpy (& _x_post_frame [p ][O_FACING_POST ],& main_buf [_bp + O_FACING_POST ],4 ); 700//Copy damage to post-frame 701memcpy (& _x_post_frame [p ][O_DAMAGE_POST ],& main_buf [_bp + O_DAMAGE_POST ],4 ); 702 703//Predict shield decay as velocity 704predictVelocPost (p ,O_SHIELD ); 705 706//Compress single byte values with XOR encoding 707xorEncodeRange (O_LAST_HIT_ID ,O_ACTION_FRAMES ,_x_post_frame [p ]); 708 709//Predict this frame's action state counter from the last 2 frames' counters 710if (MIN_VERSION (0 ,2 ,0 )) { 711predictVelocPost (p ,O_ACTION_FRAMES ); 712 } 713 714if (MIN_VERSION (2 ,0 ,0 )) { 715//XOR encode state bit flags 716xorEncodeRange (O_STATE_BITS_1 ,O_HITSTUN ,_x_post_frame [p ]); 717 718//Predict this frame's hitstun counter from the last 2 frames' counters 719predictVelocPost (p ,O_HITSTUN ); 720 721if (MIN_VERSION (3 ,5 ,0 )) { 722//Predict delta of various speeds based on previous frames' velocities 723predictVelocPost (p ,O_SELF_AIR_Y ); 724predictVelocPost (p ,O_ATTACK_X ); 725predictVelocPost (p ,O_ATTACK_Y ); 726predictVelocPost (p ,O_SELF_GROUND_X ); 727predictVelocPost (p ,O_SELF_AIR_X ); 728 729if (MIN_VERSION (3 ,8 ,0 )) { 730//Predict this frame's hitlag counter from the last 2 frames' counters 731predictVelocPost (p ,O_HITLAG ); 732 } 733 } 734 } 735 736if (_debug == 0 ) {return true; } 737//Below here is still in testing mode 738 739return true; 740 } 741 742bool Compressor ::_unshuffleEvents () { 743if (MAX_VERSION (3 ,0 ,0 )) { 744return true; 745 } 746bool success = _shuffleEvents (true); 747if (success ) { 748// Copy the relevant portion of _rb to _wb 749memcpy ( 750& _wb [_game_loop_start ], 751& _rb [_game_loop_start ], 752sizeof (char )* (_game_loop_end - _game_loop_start ) 753 ); 754 }else { 755FAIL ("BIG PROBLEM UNSHUFFLING" ); 756 } 757return success ; 758 } 759 760#define DOUNSHUFFLE (index ,event ) \ 761 off = _payload_sizes[event]; \ 762 memcpy(&main_buf[b],&ev_buf[index][cpos[index]],off); \ 763 cpos[index] += off; \ 764 b += off; 765 766#define DECODEFRAMEMATCHES (index ,last ) \ 767 (decodeFrame(readBE4S(&ev_buf[index][cpos[index]+O_FRAME]), last) == fnum) 768 769 770bool Compressor ::_shuffleEvents (bool unshuffle ) { 771const unsigned ETYPES = 64 ;//Number of types of events 772const unsigned EMAX = 30 ;//Max event to include as part of the game loop 773 774// Can't do this for replays without frame start events yet 775if (MAX_VERSION (3 ,0 ,0 )) { 776return true; 777 } 778 779// Flag for if we fail anywhere 780bool success = true; 781 782// Determine if we're using the input or output buffer 783char * main_buf = unshuffle ?_rb :_wb ; 784if (unshuffle ) { 785// We don't actually know where _game_loop_end is yet 786_game_loop_end = _file_size ; 787// We also need to unshuffle columns 788_unshuffleColumns (main_buf ); 789 } 790 791//Allocate space for storing shuffled events 792int max_events = ALLOC_EVENTS ;//initial number of events to allocate space for 793unsigned offset [ETYPES ]= {0 };//Size of individual event arrays 794unsigned * ev_counts = new unsigned [ETYPES ]; 795unsigned * ev_max = new unsigned [ETYPES ]; 796unsigned * ev_size = new unsigned [ETYPES ]; 797ev_size [0 ]= _payload_sizes [Event ::FRAME_START ]; 798ev_size [9 ]= _payload_sizes [Event ::ITEM_UPDATE ]; 799ev_size [18 ]= _payload_sizes [Event ::BOOKEND ]; 800ev_size [19 ]= _payload_sizes [Event ::SPLIT_MSG ]; 801for (unsigned i = 0 ;i < 8 ;++ i ) { 802ev_size [1 + i ]= _payload_sizes [Event ::PRE_FRAME ]; 803ev_size [10 + i ]= _payload_sizes [Event ::POST_FRAME ]; 804 } 805char ** ev_buf = new char * [ETYPES ]; 806for (unsigned i = 0 ;i < 20 ;++ i ) { 807ev_counts [i ]= 0 ;//set event counter to 0 808ev_max [i ]= max_events ;//initially allocate space for arrays 809ev_buf [i ]= new char [ev_max [i ]* ev_size [i ]]; 810 } 811int * frame_counter = new int [max_events ]{0 }; 812unsigned * finalized_counter = new unsigned [max_events ]{0 }; 813unsigned start_fp = 0 ;//Frame pointer to next start frame 814unsigned end_fp = 0 ;//Frame pointer to next end frame 815 816//Initialize data for frame deferral counting 817char * defer_pre [8 ]; 818char * defer_post [8 ]; 819for (unsigned i = 0 ;i < 8 ;++ i ) { 820defer_pre [i ]= new char [RB_SIZE ]{0 }; 821defer_post [i ]= new char [RB_SIZE ]{0 }; 822 } 823char * dupe_frames = new char [RB_SIZE ]{0 }; 824int max_frame = -125 ; 825unsigned max_item_seen = 0 ; 826int modframe = 0 ; 827uint8_t defer = 0 ; 828 829//Rearrange memory 830uint8_t pid ;//Temporary variable for player id 831uint8_t oid ;//Index into the offset array we're currently working with 832int cur_frame = -125 ; 833unsigned oldshuffleframe = lastshuffleframe ; 834for (unsigned b = _game_loop_start ;b < _game_loop_end ; ) { 835unsigned ev_code = uint8_t (main_buf [b ]); 836unsigned shift = _payload_sizes [ev_code ]; 837// std::cout << "ev code" << hex(ev_code) << " at byte " << b << "/" << _game_loop_end << std::endl; 838switch (ev_code ) { 839case Event ::FRAME_START : 840oid = 0 ; 841if (unshuffle ) { 842cur_frame = decodeFrame (readBE4S (& main_buf [b + O_FRAME ]),lastshuffleframe ); 843lastshuffleframe = cur_frame ; 844 }else { 845cur_frame = readBE4S (& _rb [b + O_FRAME ]); 846 } 847 848// If we're shuffling, we need to keep track of deferred frames 849// once we unshuffle events back into order 850if (!unshuffle ) { 851// Determine the number of times each recent frame has been duplicated 852modframe = ((cur_frame + 256 )%RB_SIZE ); 853if (cur_frame > max_frame ) { 854max_frame = cur_frame ; 855dupe_frames [modframe ]= 0 ; 856// reset the defer counters for each player 857for (unsigned i = 0 ;i < 8 ;++ i ) { 858defer_pre [i ][modframe ]= 0 ; 859defer_post [i ][modframe ]= 0 ; 860 } 861 }else { 862dupe_frames [modframe ]+= 1 ; 863 } 864 } 865 866frame_counter [start_fp ]= cur_frame ; 867++ start_fp ; 868 869// check if we've reached the event limit, and reallocate memory for more 870// events if so 871if ((int )start_fp == max_events ) { 872DOUT1 (" Maxed out frame count, resizing to " <<max_events * 2 <<" events" ); 873// double the size of the buffer for storing frame count information 874int * newstartbuf = new int [max_events * 2 ]; 875// copy data from the old buffer to the new one 876memcpy (& newstartbuf [0 ],& frame_counter [0 ],max_events ); 877// free the old frame counter buffer 878delete []frame_counter ; 879// set the buffer pointer to the new buffer 880frame_counter = newstartbuf ; 881 882// double the size of the buffer for storing finalized frame information 883unsigned * newendbuf = new unsigned [max_events * 2 ]; 884// copy data from the old buffer to the new one 885memcpy (& newendbuf [0 ],& finalized_counter [0 ],max_events ); 886// free the old finalized counter buffer 887delete []finalized_counter ; 888// set the buffer pointer to the new buffer 889finalized_counter = newendbuf ; 890 891// actually properly double the size of the event buffer 892max_events *=2 ; 893 } 894// std::cout << "Started frame " << cur_frame << std::endl; 895break ; 896case Event ::PRE_FRAME ://Includes follower 897pid = uint8_t (main_buf [b + O_PLAYER ])+ 4 * uint8_t (main_buf [b + O_FOLLOWER ]); 898oid = 1 + pid ; 899if (!unshuffle ) { 900// check if we got rollback'd into existence 901defer = (dupe_frames [modframe ]- defer_pre [pid ][modframe ]); 902if (defer > 0 ) { 903// encode the number of frames we need to defer writing 904// this rollback'd preframe into the stream when decoding 905unsigned asid = readBE2U (& main_buf [b + O_ACTION_PRE ]); 906asid = encodeDeferInfo (asid ,defer ); 907writeBE2U (asid ,& main_buf [b + O_ACTION_PRE ]); 908 } 909// std::cout << " set defer to " << +(dupe_frames[modframe]) << " - " << +(defer_pre[pid][modframe]) << "+ 1 = " << +(defer_pre[pid][modframe]) << std::endl; 910defer_pre [pid ][modframe ]= dupe_frames [modframe ]+ 1 ; 911 } 912break ; 913case Event ::ITEM_UPDATE : 914oid = 9 ; 915// XOR first byte of item id with last finalized frame 916if (!unshuffle ) { 917unsigned item_id = readBE4U (& main_buf [b + O_ITEM_ID ]); 918 919int ff = 0 ; 920if (MIN_VERSION (3 ,7 ,0 )) { 921ff = lookAheadToFinalizedFrame (& _rb [b ]); 922 923// if we've seen a new item, check if it was rollbacked into existence 924if (item_id >=max_item_seen ) { 925max_item_seen = item_id + 1 ; 926if (dupe_frames [modframe ]> 0 ) { 927// encode the number of frames we need to defer writing 928// this rollback'd item into the stream when decoding 929unsigned item_type = readBE2U (& main_buf [b + O_ITEM_TYPE ]); 930item_type = encodeDeferInfo (item_type ,dupe_frames [modframe ]); 931writeBE2U (item_type ,& main_buf [b + O_ITEM_TYPE ]); 932 } 933 } 934 935item_id = encodeFrameIntoItemId (item_id ,ff ); 936unsigned dec_id = encodeFrameIntoItemId (item_id ,ff ); 937if (encodeFrameIntoItemId (encodeFrameIntoItemId (dec_id ,ff ),ff )!= dec_id ) { 938return false; 939 } 940writeBE4U (item_id ,& main_buf [b + O_ITEM_ID ]); 941 }else { 942ff = start_fp ; 943int before = 0 ; 944// check last 128 frames for duplicates 945// start at 2 because frame_ptr is incremented 946for (unsigned fi = 2 ;fi < MAX_ROLLBACK ;++ fi ) { 947if (frame_counter [start_fp - fi ]== cur_frame ) { 948before += 1 ; 949 } 950 } 951if (before > 0 ) { 952// std::cout << "Item " << item_id << " has " << +before << " duplicate frames before frame " << cur_frame << std::endl; 953 } 954item_id = encodeFrameIntoItemId (item_id ,before ); 955unsigned dec_id = encodeFrameIntoItemId (item_id ,before ); 956if (encodeFrameIntoItemId (encodeFrameIntoItemId (dec_id ,ff ),ff )!= dec_id ) { 957return false; 958 } 959writeBE4U (item_id ,& main_buf [b + O_ITEM_ID ]); 960 } 961// std::cout << "ITEM ID = " << item_id << " (" << dec_id << ") FINAL " << ff << std::endl; 962 } 963break ; 964case Event ::POST_FRAME ://Includes follower 965pid = uint8_t (main_buf [b + O_PLAYER ])+ 4 * uint8_t (main_buf [b + O_FOLLOWER ]); 966oid = 10 + pid ; 967if (!unshuffle ) { 968// check if we got rollback'd into existence 969defer = (dupe_frames [modframe ]- defer_post [pid ][modframe ]); 970if (defer > 0 ) { 971// encode the number of frames we need to defer writing 972// this rollback'd preframe into the stream when decoding 973unsigned asid = readBE2U (& main_buf [b + O_ACTION_POST ]); 974asid = encodeDeferInfo (asid ,defer ); 975writeBE2U (asid ,& main_buf [b + O_ACTION_POST ]); 976 } 977// std::cout << " set defer to " << +(dupe_frames[modframe]) << " - " << +(defer_pre[pid][modframe]) << "+ 1 = " << +(defer_pre[pid][modframe]) << std::endl; 978defer_post [pid ][modframe ]= dupe_frames [modframe ]+ 1 ; 979 } 980break ; 981case Event ::BOOKEND : 982oid = 18 ; 983// Frame bookend rollback frames aren't defined before 3.7.0 984if (MIN_VERSION (3 ,7 ,0 )) { 985int final_frame ; 986if (unshuffle ) { 987lastshuffleframe = frame_counter [end_fp ]; 988final_frame = decodeFrame (readBE4S (& main_buf [b + O_ROLLBACK_FRAME ]),lastshuffleframe ); 989 }else { 990final_frame = readBE4S (& _rb [b + O_ROLLBACK_FRAME ]); 991 } 992finalized_counter [end_fp ]= (final_frame + 256 ) %256 ; 993++ end_fp ; 994 }else { 995// TODO: MANUALLY COMPUTE FINALIZED FRAME 996 } 997// std::cout << "Finalized frame " << cur_frame << std::endl; 998break ; 999case Event ::SPLIT_MSG ://Includes follower 1000oid = EMAX + 1 ;break ; 1001case Event ::GAME_END : 1002oid = EMAX ; 1003_game_loop_end = b ; 1004// std::cout << "GAME LOOP END 0x" 1005// << std::hex << ev_code << std::dec 1006// << " at byte " << +b << std::endl; 1007break ; 1008default : 1009oid = ETYPES - 1 ; 1010// std::cout << "NOT GOOD 0x" 1011// << std::hex << ev_code << std::dec 1012// << " at byte " << +b << std::endl; 1013break ; 1014 } 1015if (oid < EMAX ) { 1016// std::cout << "FINE 0x" 1017// << std::hex << ev_code << std::dec 1018// << " at byte " << +b << std::endl; 1019memcpy (& ev_buf [oid ][offset [oid ]],& main_buf [b ],sizeof (char )* shift ); 1020++ (ev_counts [oid ]); 1021if (ev_counts [oid ]== ev_max [oid ]) { 1022DOUT1 (" Maxed out events for " <<+ oid <<", resizing to " <<ev_max [oid ]* 2 <<" events" ); 1023// double the size of the buffer for storing event information 1024char * newbuf = new char [ev_max [oid ]* ev_size [oid ]* 2 ]; 1025// copy data from the old buffer to the new one 1026memcpy (& newbuf [0 ],& ev_buf [oid ][0 ],ev_max [oid ]* ev_size [oid ]); 1027// actually properly double the size of the event buffer 1028ev_max [oid ] *=2 ; 1029// free the old buffer 1030delete []ev_buf [oid ]; 1031// set the buffer pointer to the new buffer 1032ev_buf [oid ]= newbuf ; 1033 } 1034 } 1035offset [oid ]+= shift ; 1036b += shift ; 1037 } 1038lastshuffleframe = oldshuffleframe ; 1039 1040//Sanity checks to make sure the number of individual event bytes 1041// sums to the total number of bytes in the main game loop 1042unsigned tsize = 0 ; 1043for (unsigned i = 0 ;i < EMAX ;++ i ) {//Skip game end event 1044tsize += offset [i ]; 1045// std::cout << "SIZE of " << i << " is " << offset[i] << std::endl; 1046 } 1047if (tsize != (_game_loop_end - _game_loop_start )) { 1048FAIL (" SOMETHING WENT HORRENDOUSLY WRONG D:" ); 1049FAIL (" tsize=" <<tsize ); 1050FAIL (" _game_loop_end=" <<_game_loop_end ); 1051FAIL (" _game_loop_start=" <<_game_loop_start ); 1052success = false; 1053 } 1054 1055// Copy memory over if we haven't failed horrendously yet 1056if (success ) { 1057unsigned off = 0 ; 1058unsigned b = _game_loop_start ; 1059if (!unshuffle ) {//Shuffle into main memory, excluding message event 1060// Copy all events (except 19 == messages, makes things worse) 1061for (unsigned i = 0 ;i <=18 ;++ i ) { 1062memcpy (& main_buf [b ],& ev_buf [i ][0 ],offset [i ]); 1063b += offset [i ]; 1064 } 1065// Shuffle columns 1066_shuffleColumns (offset ); 1067 }else {//Unshuffle into main memory, excluding message event 1068unsigned cpos [EMAX ]= {0 };//Buffer positions we're copying out of 1069int * dec_frames = new int [_game_loop_end ]; 1070for (unsigned frame_ptr = 0 ;b < _game_loop_end ;++ frame_ptr ) { 1071// Sanity checks to make sure this is an actual frame start event 1072if (cpos [0 ] >=offset [0 ]) { 1073FAIL (" THAT SUCKS D: at frame" <<frame_ptr ); 1074FAIL (" " <<cpos [0 ] <<" >= " <<offset [0 ]); 1075success = false; 1076break ; 1077 } 1078if (ev_buf [0 ][cpos [0 ]]!= Event ::FRAME_START ) { 1079FAIL (" OH SNAP D:" ); 1080success = false; 1081break ; 1082 } 1083 1084// Get the current frame from the next frame start event 1085int enc_frame = readBE4S (& ev_buf [0 ][cpos [0 ]+ O_FRAME ]); 1086int fnum = decodeFrame (enc_frame ,lastshuffleframe ); 1087lastshuffleframe = fnum ; 1088dec_frames [frame_ptr ]= fnum ; 1089 1090// Determine the number of times each recent frame has been duplicated 1091modframe = ((fnum + 256 )%RB_SIZE ); 1092if (fnum > max_frame ) { 1093max_frame = fnum ; 1094dupe_frames [modframe ]= 0 ; 1095 }else { 1096dupe_frames [modframe ]+= 1 ; 1097 } 1098 1099// std::cout << "Decoded frame at " << frame_ptr << " as " << fnum << std::endl; 1100DOUT3 (" " << (b ) <<" bytes read, " << (_game_loop_end - b ) <<" bytes left at frame " <<fnum ); 1101 1102// TODO: this isn't working for Game_20210207T004448.slp 1103if (fnum < -123 || fnum > (1 <<30 )) { 1104FAIL (" SOMETHING WENT HORRENDOUSLY WRONG D:" ); 1105success = false; 1106break ; 1107 } 1108 1109// Copy the frame start event over to the main buffer 1110DOUNSHUFFLE (0 ,Event ::FRAME_START ); 1111 1112// Check if each player has a pre-frame this frame 1113for (unsigned p = 0 ;p < 8 ;++ p ) { 1114// True player order: 0,4,1,5,2,6,3,7 1115unsigned i = 1 + (4 * (p %2 ))+ unsigned (p /2 ); 1116// If the player has no more pre-frame data, move on 1117if (cpos [i ] >=offset [i ]) { 1118continue ; 1119 } 1120// If the next frame isn't the one we're expecting, move on 1121if (!DECODEFRAMEMATCHES (i ,lastshufflepreframe [p ])) { 1122// std::cout << fnum << " NO MATCH pre-frame " << i+1 << " @ " << decodeFrame(readBE4S(&ev_buf[1+i][cpos[1+i]+O_FRAME]), lastshuffleframe) << std::endl; 1123continue ; 1124 } 1125// Verify we don't need to defer writing this preframe event 1126// to the output stream due to rollback shenanigans 1127unsigned asid = readBE2U (& ev_buf [i ][cpos [i ]+ O_ACTION_PRE ]); 1128unsigned defer = getDeferInfo (asid ); 1129if (defer > 0 ) { 1130if ((int )defer != dupe_frames [modframe ]) { 1131continue ; 1132 } 1133// zero out the first two bits of action state id holding defer information 1134writeBE2U (decodeDeferInfo (asid ),& ev_buf [i ][cpos [i ]+ O_ACTION_PRE ]); 1135 } 1136// Copy the pre frame event over to the main buffer 1137DOUNSHUFFLE (i ,Event ::PRE_FRAME ); 1138lastshufflepreframe [p ]= fnum ; 1139// std::cout << fnum << " pre-frame " << i+1 << std::endl; 1140 } 1141 1142// Copy over any items with matching frames 1143int last_id = -1 ; 1144for (;;) { 1145// If there are no more items, move on 1146if (cpos [9 ] >=offset [9 ]) {break ; } 1147 1148// If the next item frame isn't the current frame, move on 1149if (!DECODEFRAMEMATCHES (9 ,lastitemshuffleframe )) { 1150break ; 1151 } 1152 1153// Double check we're on the correctly finalized frame 1154unsigned item_id = readBE4U (& ev_buf [9 ][cpos [9 ]+ O_ITEM_ID ]); 1155 1156if (MIN_VERSION (3 ,7 ,0 )) { 1157unsigned ff = finalized_counter [frame_ptr ]; 1158// Decode item_id encoded with frame number 1159if (getFrameModFromItemId (item_id )!= ff ) { 1160break ; 1161 } 1162item_id = encodeFrameIntoItemId (item_id ,ff ); 1163 }else {// 3.6.x does not have a frame bookend rollback frame 1164unsigned dupes = 0 ; 1165// check last 128 frames for duplicates 1166// start at 1 because frame_ptr is not incremented 1167for (unsigned fi = 1 ;fi < MAX_ROLLBACK ;++ fi ) { 1168if (frame_ptr < fi ) { 1169break ; 1170 } 1171if (dec_frames [frame_ptr - fi ]== fnum ) { 1172dupes += 1 ; 1173 } 1174 } 1175 1176// verify item appeared on this duplicate frame 1177if (getFrameModFromItemId (item_id )!= dupes ) { 1178break ; 1179 } 1180 1181item_id = encodeFrameIntoItemId (item_id ,dupes ); 1182 } 1183 1184// Verify we aren't repeating items this frame 1185if (int (item_id ) <=last_id ) {break ; } 1186 1187// Verify we don't need to defer writing this item event 1188// to the output stream due to rollback shenanigans 1189unsigned item_type = readBE2U (& ev_buf [9 ][cpos [9 ]+ O_ITEM_TYPE ]); 1190unsigned defer = getDeferInfo (item_type ); 1191if (defer > 0 ) { 1192if ((int )defer != dupe_frames [modframe ]) { 1193break ; 1194 } 1195// zero out the first two bits of item type holding defer information 1196writeBE2U (decodeDeferInfo (item_type ),& ev_buf [9 ][cpos [9 ]+ O_ITEM_TYPE ]); 1197 } 1198 1199// Restore the actual item ID to the buffer 1200writeBE4U (item_id ,& ev_buf [9 ][cpos [9 ]+ O_ITEM_ID ]); 1201 1202// Update the last seen item id 1203last_id = item_id ; 1204 1205// Update lastitemshuffleframe 1206lastitemshuffleframe = fnum ; 1207 1208// Copy the item event over to the main buffer 1209DOUNSHUFFLE (9 ,Event ::ITEM_UPDATE ); 1210 } 1211 1212// Check if each player has a post-frame this frame 1213for (unsigned p = 0 ;p < 8 ;++ p ) { 1214// True player order: 0,4,1,5,2,6,3,7 1215unsigned i = 10 + (4 * (p %2 ))+ unsigned (p /2 ); 1216//If the player has no more post-frame data, move on 1217if (cpos [i ] >=offset [i ]) { 1218continue ; 1219 } 1220// If the next frame isn't the one we're expecting, move on 1221if (!DECODEFRAMEMATCHES (i ,lastshufflepostframe [p ])) { 1222continue ; 1223 } 1224// Verify we don't need to defer writing this postframe event 1225// to the output stream due to rollback shenanigans 1226unsigned asid = readBE2U (& ev_buf [i ][cpos [i ]+ O_ACTION_POST ]); 1227unsigned defer = getDeferInfo (asid ); 1228if (defer > 0 ) { 1229if ((int )defer != dupe_frames [modframe ]) { 1230continue ; 1231 } 1232// zero out the first two bits of action state id holding defer information 1233writeBE2U (decodeDeferInfo (asid ),& ev_buf [i ][cpos [i ]+ O_ACTION_POST ]); 1234 } 1235// Copy the post frame event over to the main buffer 1236DOUNSHUFFLE (i ,Event ::POST_FRAME ); 1237lastshufflepostframe [p ]= fnum ; 1238// std::cout << fnum << " post-frame " << i+1 << std::endl; 1239 } 1240 1241// Copy the frame end event over to the main buffer 1242if (DECODEFRAMEMATCHES (18 ,lastshuffleframe )) { 1243DOUNSHUFFLE (18 ,Event ::BOOKEND ); 1244 } 1245 } 1246delete []dec_frames ; 1247 } 1248 } 1249 1250//Free memory 1251 1252delete []ev_counts ; 1253delete []ev_max ; 1254delete []ev_size ; 1255 1256for (unsigned i = 0 ;i < 8 ;++ i ) { 1257delete []defer_pre [i ]; 1258delete []defer_post [i ]; 1259 } 1260delete []dupe_frames ; 1261 1262for (unsigned i = 0 ;i < 20 ;++ i ) { 1263delete []ev_buf [i ]; 1264 } 1265delete []ev_buf ; 1266delete []frame_counter ; 1267delete []finalized_counter ; 1268 1269return success ; 1270 } 1271 1272}