fork/slippc
git clone https://git.julia.blue/fork/slippc
ef70321
bench
1#include "parser.h" 2 3namespace slip { 4 5Parser ::Parser (int debug_level ) { 6_debug = debug_level ; 7_bp = 0 ; 8 } 9 10Parser ::~Parser () { 11if (_rb != nullptr ) { 12delete []_rb ; 13 } 14_cleanup (); 15 } 16 17bool Parser ::load (const char * replayfilename ) { 18DOUT1 (" Loading " <<replayfilename ); 19_replay .original_file = std::string (replayfilename ); 20 std::ifstream myfile ; 21myfile .open (replayfilename ,std::ios::binary | std::ios::in ); 22if (myfile .fail ()) { 23FAIL (" File " <<replayfilename <<" could not be opened or does not exist" ); 24return false; 25 } 26 27myfile .seekg (0 ,myfile .end ); 28_file_size = myfile .tellg (); 29if (_file_size < MIN_REPLAY_LENGTH ) { 30FAIL (" File " <<replayfilename <<" is too short to be a valid Slippi replay" ); 31return false; 32 } 33DOUT1 (" File Size: " <<+ _file_size ); 34myfile .seekg (0 ,myfile .beg ); 35 36_rb = new char [_file_size ]; 37myfile .read (_rb ,_file_size ); 38myfile .close (); 39 40// Check if we have a compressed .zlp file 41bool is_compressed = same4 (& _rb [0 ],LZMA_HEADER ); 42if (is_compressed ) { 43DOUT1 (" Decompressing file" ); 44// Decompress the read buffer 45 std::string decomp = decompressWithLzma (_rb ,_file_size ); 46// Get the new file size 47_file_size = decomp .size (); 48// Delete the old read buffer 49delete []_rb ; 50// Reallocate it with more spce 51_rb = new char [_file_size ]; 52// Copy buffer from the decompressed string 53memcpy (_rb ,decomp .c_str (),_file_size ); 54DOUT1 (" Decompressed File Size: " <<+ _file_size ); 55 } 56 57bool status = this -> _parse (); 58// if we attempted to parse an encoded replay 59if (_is_encoded ) { 60DOUT1 (" File was encoded, decoding" <<+ _file_size ); 61// Create a Compressor object 62Compressor * d = new slip::Compressor (0 ); 63// Decompress the buffer 64d -> loadFromBuff (& _rb ,_file_size ); 65// Save it back to the original buffer 66d -> saveToBuff (& _rb ); 67// Unset encoded state 68_is_encoded = false; 69// restart the parsing process 70status = this -> _parse (); 71 } 72return status ; 73 } 74 75bool Parser ::_parse () { 76_bp = 0 ;//Start reading from byte 0 77if (notthis -> _parseHeader ()) { 78WARN (" Failed to parse header" ); 79return false; 80 } 81if (notthis -> _parseEventDescriptions ()) { 82WARN (" Failed to parse event descriptions" ); 83return false; 84 } 85if (notthis -> _parseEvents ()) { 86WARN (" Failed to parse events proper" ); 87return false; 88 } 89if (_is_encoded ) { 90return true;//back out and restart the parsing process 91 } 92if (notthis -> _parseMetadata ()) { 93WARN (" Failed to parse metadata" ); 94//Non-fatal if we can't parse metadata, so don't need to return false 95 } 96if (!_game_end_found ) { 97WARN_CORRUPT (" No game end event found" ); 98++ _replay .errors ; 99 } 100if (_replay .errors == 0 ) { 101DOUT1 (" Successfully parsed replay!" ); 102return true; 103 }else { 104WARN (" Replay parsed with " <<_replay .errors <<" errors" ); 105return false; 106 } 107 } 108 109bool Parser ::_parseHeader () { 110DOUT1 (" Parsing header" ); 111 112//First 15 bytes contain header information 113if (same8 (& _rb [_bp ],SLP_HEADER )) { 114DOUT1 (" Slippi Header Matched" ); 115 }else { 116FAIL_CORRUPT (" Header did not match expected Slippi file header" ); 117return false; 118 } 119_length_raw_start = readBE4U (& _rb [_bp + 11 ]); 120if (_length_raw_start == 0 ) {//TODO: this is /technically/ recoverable 121WARN_CORRUPT (" 0-byte raw data detected" ); 122++ _replay .errors ; 123 } 124DOUT1 (" Raw portion = " <<_length_raw_start <<" bytes" ); 125if (_length_raw_start > _file_size ) { 126WARN_CORRUPT (" Raw data size " <<+ _length_raw_start <<" exceeds file size of " <<_file_size <<" bytes" ); 127++ _replay .errors ; 128_length_raw_start = 0 ; 129 } 130_length_raw = _length_raw_start ; 131_bp += 15 ; 132return true; 133 } 134 135bool Parser ::_parseEventDescriptions () { 136DOUT1 (" Parsing event descriptions" ); 137 138//Next 2 bytes should be 0x35 139if (_rb [_bp ]!= Event ::EV_PAYLOADS ) { 140FAIL_CORRUPT (" Expected event 0x" << std::hex 141 <<Event ::EV_PAYLOADS << std::dec <<" (Event Payloads)" ); 142return false; 143 } 144uint8_t ev_bytes = _rb [_bp + 1 ]- 1 ;//Subtract 1 because the last byte we read counted as part of the payload 145_payload_sizes [Event ::EV_PAYLOADS ]= int32_t (ev_bytes + 1 ); 146DOUT1 (" Event description length = " <<int32_t (ev_bytes + 1 ) <<" bytes" ); 147_bp += 2 ; 148 149//Next ev_bytes bytes describe events 150for (unsigned i = 0 ;i < ev_bytes ;i += 3 ) { 151unsigned ev_code = uint8_t (_rb [_bp + i ]); 152if (_payload_sizes [ev_code ]> 0 ) { 153if (ev_code >=Event ::EV_PAYLOADS && ev_code <=Event ::GAME_END ) { 154WARN_CORRUPT (" Event " <<Event ::name [ev_code - Event ::EV_PAYLOADS ] <<" payload size set multiple times" ); 155++ _replay .errors ; 156 }else { 157WARN_CORRUPT (" Event " <<hex (ev_code ) << std::dec <<" payload size set multiple times" ); 158++ _replay .errors ; 159 } 160return false; 161 } 162_payload_sizes [ev_code ]= readBE2U (& _rb [_bp + i + 1 ])+ 1 ;//Add one for the event code itself 163DOUT1 (" Payload size for event " 164 <<hex (ev_code ) << std::dec <<": " <<_payload_sizes [ev_code ] 165 <<" bytes" ); 166 } 167 168//Sanity checks to verify we at least have Payload Sizes, Game Start, Pre Frame, Post Frame, and Game End Events 169for (unsigned i = Event ::EV_PAYLOADS ;i <=Event ::GAME_END ;++ i ) { 170if (_payload_sizes [i ]== 0 ) { 171FAIL_CORRUPT (" Event " <<Event ::name [i - Event ::EV_PAYLOADS ] <<" payload size not set" ); 172return false; 173 } 174 } 175 176//Update the remaining length of the raw data to sift through 177_bp += ev_bytes ; 178_length_raw -= (2 + ev_bytes ); 179return true; 180 } 181 182bool Parser ::_parseEvents () { 183DOUT1 (" Parsing events proper" ); 184 185if (_length_raw_start == 0 ) {//TODO: this is /technically/ recoverable 186_length_raw_start = _file_size - _bp ; 187_length_raw = _length_raw_start ; 188DOUT1 (" Using remaining file size " <<+ _length_raw <<" as raw bytes" ); 189 } 190 191bool success = true; 192for ( ;_length_raw > 0 ; ) { 193unsigned ev_code = uint8_t (_rb [_bp ]); 194unsigned shift = _payload_sizes [ev_code ]; 195if (shift > _length_raw ) { 196WARN_CORRUPT (" Event byte offset exceeds raw data length" ); 197++ _replay .errors ; 198return true; 199 } 200switch (ev_code ) {//Determine the event code 201case Event ::GAME_START : 202success = _parseGameStart (); 203if (_is_encoded ) { 204return true;//immediately restart if the file is encoded 205 } 206break ; 207case Event ::PRE_FRAME :success = _parsePreFrame ();break ; 208case Event ::POST_FRAME :success = _parsePostFrame ();break ; 209case Event ::GAME_END :success = _parseGameEnd ();break ; 210case Event ::ITEM_UPDATE :success = _parseItemUpdate ();break ; 211 212case Event ::SPLIT_MSG :success = true;break ; 213case Event ::FRAME_START :success = true;break ; 214case Event ::BOOKEND :success = true;break ; 215 216default : 217DOUT1 (" Warning: unknown event code " <<hex (ev_code ) <<" encountered; skipping" ); 218break ; 219 } 220if (notsuccess ) { 221return false; 222 } 223if (_payload_sizes [ev_code ]== 0 ) { 224WARN_CORRUPT (" Uninitialized event " <<hex (ev_code ) <<" encountered" ); 225++ _replay .errors ; 226return true; 227 } 228_length_raw -= shift ; 229_bp += shift ; 230DOUT2 (" Raw bytes remaining: " <<+ _length_raw ); 231 } 232 233return true; 234 } 235 236bool Parser ::_parseGameStart () { 237DOUT1 (" Parsing game start event at byte " <<+ _bp ); 238 239// if this is encoded, we need to decompress our entire read 240// buffer and retry parsing 241if (_rb [_bp + O_SLP_ENC ]) { 242_is_encoded = true; 243DOUT1 (" File is encoded, decoding and retrying" ); 244return true; 245 } 246 247if (_slippi_maj > 0 ) { 248WARN_CORRUPT (" Duplicate game start event" ); 249++ _replay .errors ; 250 } 251 252//Get Slippi version 253_slippi_maj = uint8_t (_rb [_bp + O_SLP_MAJ ]);//Major version 254_slippi_min = uint8_t (_rb [_bp + O_SLP_MIN ]);//Minor version 255_slippi_rev = uint8_t (_rb [_bp + O_SLP_REV ]);//Build version (4th char unused) 256_replay .slippi_version_raw = readBE4U (& _rb [_bp + O_SLP_MAJ ]); 257 258 std::stringstream ss ; 259ss <<+ _slippi_maj <<"." <<+ _slippi_min <<"." <<+ _slippi_rev ; 260_slippi_version = ss .str (); 261DOUT1 (" Slippi Version: " <<_slippi_version ); 262 263//Get player info 264for (unsigned p = 0 ;p < 4 ;++ p ) { 265unsigned i = O_PLAYERDATA + 0x24 * p ;//Beginning of player info block 266 std::string ps = std::to_string (p + 1 ); 267 268_replay .player [p ].ext_char_id = uint8_t (_rb [_bp + i + O_PLAYER_ID ]); 269if (_replay .player [p ].ext_char_id >=CharExt ::__LAST ) { 270WARN_CORRUPT (" External character ID " <<+ _replay .player [p ].ext_char_id <<" is invalid" ); 271++ _replay .errors ; 272 } 273_replay .player [p ].player_type = uint8_t (_rb [_bp + i + O_PLAYER_TYPE ]); 274_replay .player [p ].start_stocks = uint8_t (_rb [_bp + i + O_START_STOCKS ]); 275_replay .player [p ].color = uint8_t (_rb [_bp + i + O_COLOR ]); 276_replay .player [p ].shade = uint8_t (_rb [_bp + i + O_SHADE ]); 277_replay .player [p ].handicap = uint8_t (_rb [_bp + i + O_HANDICAP ]); 278_replay .player [p ].team_id = uint8_t (_rb [_bp + i + O_TEAM_ID ]); 279_replay .player [p ].cpu_level = uint8_t (_rb [_bp + i + O_CPU_LEVEL ]); 280_replay .player [p ].offense = readBE4F (& _rb [_bp + i + O_OFFENSE ]); 281_replay .player [p ].defense = readBE4F (& _rb [_bp + i + O_DEFENSE ]); 282_replay .player [p ].scale = readBE4F (& _rb [_bp + i + O_SCALE ]); 283_replay .player [p ].stamina = uint8_t (_rb [_bp + i + O_PLAYER_BITS ])& 0x01 ; 284_replay .player [p ].silent = uint8_t (_rb [_bp + i + O_PLAYER_BITS ])& 0x02 ; 285_replay .player [p ].low_gravity = uint8_t (_rb [_bp + i + O_PLAYER_BITS ])& 0x04 ; 286_replay .player [p ].invisible = uint8_t (_rb [_bp + i + O_PLAYER_BITS ])& 0x08 ; 287_replay .player [p ].black_stock = uint8_t (_rb [_bp + i + O_PLAYER_BITS ])& 0x10 ; 288_replay .player [p ].metal = uint8_t (_rb [_bp + i + O_PLAYER_BITS ])& 0x20 ; 289_replay .player [p ].warp_in = uint8_t (_rb [_bp + i + O_PLAYER_BITS ])& 0x40 ; 290_replay .player [p ].rumble = uint8_t (_rb [_bp + i + O_PLAYER_BITS ])& 0x80 ; 291 292if (MIN_VERSION (1 ,0 ,0 )) { 293unsigned m = O_DASHBACK + 0x8 * p ; 294_replay .player [p ].dash_back = readBE4U (& _rb [_bp + m ]); 295_replay .player [p ].shield_drop = readBE4U (& _rb [_bp + m + 0x4 ]); 296 } 297 298//Decode Melee's internal tag as a proper UTF-8 string 299if (MIN_VERSION (1 ,3 ,0 )) { 300unsigned k = O_NAMETAG + 0x10 * p ; 301_replay .player [p ].tag_css = decode_shift_jis (_rb + _bp + k ); 302// std::cout << "CSS = " << _replay.player[p].tag_css << std::endl; 303 } 304 305//Decode display name as a proper UTF-8 string 306if (MIN_VERSION (3 ,9 ,0 )) { 307unsigned k = O_DISP_NAME + 0x1F * p ; 308_replay .player [p ].disp_name = sj2utf8 (std::string (_rb + _bp + k )); 309// std::cout << "Name = " << _replay.player[p].disp_name << std::endl; 310unsigned c = O_CONN_CODE + 0x0A * p ; 311_replay .player [p ].tag_code = parseConnCode (std::string (_rb + _bp + c )); 312// std::cout << "Code = " << _replay.player[p].tag_code << std::endl; 313 } 314 315//Decode Slippi UID 316if (MIN_VERSION (3 ,11 ,0 )) { 317unsigned k = O_SLIPPI_UID + 0x1D * p ; 318_replay .player [p ].slippi_uid = std::string (_rb + _bp + k ); 319// std::cout << "UID = " << _replay.player[p].slippi_uid << std::endl; 320 } 321 } 322 323//Write to replay data structure 324_replay .parser_version = SLIPPC_VERSION ; 325_replay .slippi_version = std::string (_slippi_version ); 326_replay .game_start_raw = std::string (base64_encode (reinterpret_cast < const unsigned char *> (& _rb [_bp + O_GAMEBITS_1 ]),312 )); 327_replay .metadata = "" ; 328 329_replay .sudden_death = bool (_rb [_bp + O_SUDDEN_DEATH ]); 330_replay .teams = bool (_rb [_bp + O_IS_TEAMS ]); 331_replay .items_on = int8_t (_rb [_bp + O_ITEM_SPAWN ]); 332_replay .sd_score = int8_t (_rb [_bp + O_SD_SCORE ]); 333_replay .stage = readBE2U (& _rb [_bp + O_STAGE ]); 334_replay .timer = readBE4U (& _rb [_bp + O_TIMER ])/60 ; 335 336_replay .timer_behav = uint8_t (_rb [_bp + O_GAMEBITS_1 ])& 0x03 ; 337_replay .ui_chars = (uint8_t (_rb [_bp + O_GAMEBITS_1 ])& 0x1C ) >>2 ; 338_replay .game_mode = (uint8_t (_rb [_bp + O_GAMEBITS_1 ])& 0xE0 ) >>5 ; 339_replay .friendly_fire = uint8_t (_rb [_bp + O_GAMEBITS_2 ])& 0x01 ; 340_replay .demo_mode = uint8_t (_rb [_bp + O_GAMEBITS_2 ])& 0x02 ; 341_replay .classic_adv = uint8_t (_rb [_bp + O_GAMEBITS_2 ])& 0x04 ; 342_replay .hrc_event = uint8_t (_rb [_bp + O_GAMEBITS_2 ])& 0x08 ; 343_replay .allstar_wait1 = uint8_t (_rb [_bp + O_GAMEBITS_2 ])& 0x10 ; 344_replay .allstar_wait2 = uint8_t (_rb [_bp + O_GAMEBITS_2 ])& 0x20 ; 345_replay .allstar_game1 = uint8_t (_rb [_bp + O_GAMEBITS_2 ])& 0x40 ; 346_replay .allstar_game2 = uint8_t (_rb [_bp + O_GAMEBITS_2 ])& 0x80 ; 347_replay .single_button = uint8_t (_rb [_bp + O_GAMEBITS_3 ])& 0x10 ; 348_replay .pause_timer = uint8_t (_rb [_bp + O_GAMEBITS_4 ])& 0x01 ; 349_replay .pause_nohud = uint8_t (_rb [_bp + O_GAMEBITS_4 ])& 0x02 ; 350_replay .pause_lras = uint8_t (_rb [_bp + O_GAMEBITS_4 ])& 0x04 ; 351_replay .pause_off = uint8_t (_rb [_bp + O_GAMEBITS_4 ])& 0x08 ; 352_replay .pause_zretry = uint8_t (_rb [_bp + O_GAMEBITS_4 ])& 0x10 ; 353_replay .pause_analog = uint8_t (_rb [_bp + O_GAMEBITS_4 ])& 0x40 ; 354_replay .pause_score = uint8_t (_rb [_bp + O_GAMEBITS_4 ])& 0x80 ; 355_replay .items1 = uint8_t (_rb [_bp + O_ITEMBITS_1 ]); 356_replay .items2 = uint8_t (_rb [_bp + O_ITEMBITS_2 ]); 357_replay .items3 = uint8_t (_rb [_bp + O_ITEMBITS_3 ]); 358_replay .items4 = uint8_t (_rb [_bp + O_ITEMBITS_4 ]); 359_replay .items5 = uint8_t (_rb [_bp + O_ITEMBITS_5 ]); 360if (_replay .stage >=Stage ::__LAST ) { 361WARN_CORRUPT (" Stage ID " <<+ _replay .stage <<" is invalid" ); 362++ _replay .errors ; 363 } 364_replay .seed = readBE4U (& _rb [_bp + O_RNG_GAME_START ]); 365 366if (MIN_VERSION (1 ,5 ,0 )) { 367_replay .pal = bool (_rb [_bp + O_IS_PAL ]); 368 } 369 370if (MIN_VERSION (2 ,0 ,0 )) { 371_replay .frozen_stadium = bool (_rb [_bp + O_PS_FROZEN ]); 372 } 373 374if (MIN_VERSION (3 ,7 ,0 )) { 375_replay .scene_min = uint8_t (_rb [_bp + O_SCENE_MIN ]); 376_replay .scene_maj = uint8_t (_rb [_bp + O_SCENE_MAJ ]); 377 } 378 379if (MIN_VERSION (3 ,12 ,0 )) { 380_replay .language = uint8_t (_rb [_bp + O_LANGUAGE ]); 381 } 382 383if (MIN_VERSION (3 ,14 ,0 )) { 384_replay .match_id = std::string (_rb + _bp + O_MATCH_ID ); 385_replay .game_number = readBE4U (& _rb [_bp + O_GAME_NUMBER ]); 386_replay .tiebreaker_number = readBE4U (& _rb [_bp + O_TIEBREAKER_NUMBER ]); 387 } 388 389_max_frames = getMaxNumFrames (); 390_replay .setFrames (_max_frames ); 391DOUT1 (" Estimated " <<_max_frames <<" gameplay frames (" << (_replay .frame_count ) <<" total frames)" ); 392return true; 393 } 394 395bool Parser ::_parsePreFrame () { 396DOUT2 (" Parsing pre frame event at byte " <<+ _bp ); 397int32_t fnum = readBE4S (& _rb [_bp + O_FRAME ]); 398int32_t f = fnum - LOAD_FRAME ; 399 400if (fnum < LOAD_FRAME ) { 401FAIL_CORRUPT (" Frame index " <<fnum <<" less than " <<+ LOAD_FRAME ); 402return false; 403 } 404if (fnum >=_max_frames ) { 405FAIL_CORRUPT (" Frame index " <<fnum 406 <<" greater than max frames computed from reported raw size (" <<_max_frames <<")" ); 407return false; 408 } 409 410uint8_t p = uint8_t (_rb [_bp + O_PLAYER ])+ 4 * uint8_t (_rb [_bp + O_FOLLOWER ]);//Includes follower 411if (p > 7 || _replay .player [p ].frame == nullptr ) { 412FAIL_CORRUPT (" Invalid player index " <<+ p ); 413return false; 414 } 415 416_replay .last_frame = fnum ; 417_replay .frame_count = f + 1 ;//Update the last frame we actually read 418_replay .player [p ].frame [f ].frame = fnum ; 419_replay .player [p ].frame [f ].player = p %4 ; 420_replay .player [p ].frame [f ].follower = (p > 3 ); 421_replay .player [p ].frame [f ].alive = 1 ; 422_replay .player [p ].frame [f ].seed = readBE4U (& _rb [_bp + O_RNG_PRE ]); 423_replay .player [p ].frame [f ].action_pre = readBE2U (& _rb [_bp + O_ACTION_PRE ]); 424_replay .player [p ].frame [f ].pos_x_pre = readBE4F (& _rb [_bp + O_XPOS_PRE ]); 425_replay .player [p ].frame [f ].pos_y_pre = readBE4F (& _rb [_bp + O_YPOS_PRE ]); 426_replay .player [p ].frame [f ].face_dir_pre = readBE4F (& _rb [_bp + O_FACING_PRE ]); 427_replay .player [p ].frame [f ].joy_x = readBE4F (& _rb [_bp + O_JOY_X ]); 428_replay .player [p ].frame [f ].joy_y = readBE4F (& _rb [_bp + O_JOY_Y ]); 429_replay .player [p ].frame [f ].c_x = readBE4F (& _rb [_bp + O_CX ]); 430_replay .player [p ].frame [f ].c_y = readBE4F (& _rb [_bp + O_CY ]); 431_replay .player [p ].frame [f ].trigger = readBE4F (& _rb [_bp + O_TRIGGER ]); 432_replay .player [p ].frame [f ].buttons = readBE2U (& _rb [_bp + O_BUTTONS ]); 433_replay .player [p ].frame [f ].phys_l = readBE4F (& _rb [_bp + O_PHYS_L ]); 434_replay .player [p ].frame [f ].phys_r = readBE4F (& _rb [_bp + O_PHYS_R ]); 435 436if (MIN_VERSION (1 ,2 ,0 )) { 437_replay .player [p ].frame [f ].ucf_x = uint8_t (_rb [_bp + O_UCF_ANALOG ]); 438 } 439 440if (MIN_VERSION (1 ,4 ,0 )) { 441_replay .player [p ].frame [f ].percent_pre = readBE4F (& _rb [_bp + O_DAMAGE_PRE ]); 442 } 443 444return true; 445 } 446 447bool Parser ::_parsePostFrame () { 448DOUT2 (" Parsing post frame event at byte " <<+ _bp ); 449int32_t fnum = readBE4S (& _rb [_bp + O_FRAME ]); 450int32_t f = fnum - LOAD_FRAME ; 451 452if (fnum < LOAD_FRAME ) { 453FAIL_CORRUPT (" Frame index " <<fnum <<" less than " <<+ LOAD_FRAME ); 454return false; 455 } 456if (fnum >=_max_frames ) { 457FAIL_CORRUPT (" Frame index " <<fnum <<" greater than max frames computed from reported raw size (" 458 <<_max_frames <<")" ); 459return false; 460 } 461 462uint8_t p = uint8_t (_rb [_bp + O_PLAYER ])+ 4 * uint8_t (_rb [_bp + O_FOLLOWER ]);//Includes follower 463if (p > 7 || _replay .player [p ].frame == nullptr ) { 464FAIL_CORRUPT (" Invalid player index " <<+ p ); 465return false; 466 } 467 468_replay .player [p ].frame [f ].char_id = uint8_t (_rb [_bp + O_INT_CHAR_ID ]); 469if (_replay .player [p ].frame [f ].char_id >=CharInt ::__LAST ) { 470WARN_CORRUPT (" Internal character ID " <<+ _replay .player [p ].frame [f ].char_id <<" is invalid" ); 471++ _replay .errors ; 472 } 473 474_replay .player [p ].frame [f ].action_post = readBE2U (& _rb [_bp + O_ACTION_POST ]); 475_replay .player [p ].frame [f ].pos_x_post = readBE4F (& _rb [_bp + O_XPOS_POST ]); 476_replay .player [p ].frame [f ].pos_y_post = readBE4F (& _rb [_bp + O_YPOS_POST ]); 477_replay .player [p ].frame [f ].face_dir_post = readBE4F (& _rb [_bp + O_FACING_POST ]); 478_replay .player [p ].frame [f ].percent_post = readBE4F (& _rb [_bp + O_DAMAGE_POST ]); 479_replay .player [p ].frame [f ].shield = readBE4F (& _rb [_bp + O_SHIELD ]); 480_replay .player [p ].frame [f ].hit_with = uint8_t (_rb [_bp + O_LAST_HIT_ID ]); 481_replay .player [p ].frame [f ].combo = uint8_t (_rb [_bp + O_COMBO ]); 482_replay .player [p ].frame [f ].hurt_by = uint8_t (_rb [_bp + O_LAST_HIT_BY ]); 483_replay .player [p ].frame [f ].stocks = uint8_t (_rb [_bp + O_STOCKS ]); 484 485if (MIN_VERSION (0 ,2 ,0 )) { 486_replay .player [p ].frame [f ].action_fc = readBE4F (& _rb [_bp + O_ACTION_FRAMES ]); 487 } 488 489if (MIN_VERSION (2 ,0 ,0 )) { 490_replay .player [p ].frame [f ].flags_1 = uint8_t (_rb [_bp + O_STATE_BITS_1 ]); 491_replay .player [p ].frame [f ].flags_2 = uint8_t (_rb [_bp + O_STATE_BITS_2 ]); 492_replay .player [p ].frame [f ].flags_3 = uint8_t (_rb [_bp + O_STATE_BITS_3 ]); 493_replay .player [p ].frame [f ].flags_4 = uint8_t (_rb [_bp + O_STATE_BITS_4 ]); 494_replay .player [p ].frame [f ].flags_5 = uint8_t (_rb [_bp + O_STATE_BITS_5 ]); 495_replay .player [p ].frame [f ].hitstun = readBE4F (& _rb [_bp + O_HITSTUN ]); 496_replay .player [p ].frame [f ].airborne = bool (_rb [_bp + O_AIRBORNE ]); 497_replay .player [p ].frame [f ].ground_id = readBE2U (& _rb [_bp + O_GROUND_ID ]); 498_replay .player [p ].frame [f ].jumps = uint8_t (_rb [_bp + O_JUMPS ]); 499_replay .player [p ].frame [f ].l_cancel = uint8_t (_rb [_bp + O_LCANCEL ]); 500 } 501 502if (MIN_VERSION (2 ,1 ,0 )) { 503_replay .player [p ].frame [f ].hurtbox = uint8_t (_rb [_bp + O_HURTBOX ]); 504 } 505 506if (MIN_VERSION (3 ,5 ,0 )) { 507_replay .player [p ].frame [f ].self_air_x = readBE4F (& _rb [_bp + O_SELF_AIR_X ]); 508_replay .player [p ].frame [f ].self_air_y = readBE4F (& _rb [_bp + O_SELF_AIR_Y ]); 509_replay .player [p ].frame [f ].attack_x = readBE4F (& _rb [_bp + O_ATTACK_X ]); 510_replay .player [p ].frame [f ].attack_y = readBE4F (& _rb [_bp + O_ATTACK_Y ]); 511_replay .player [p ].frame [f ].self_grd_x = readBE4F (& _rb [_bp + O_SELF_GROUND_X ]); 512 } 513 514if (MIN_VERSION (3 ,8 ,0 )) { 515_replay .player [p ].frame [f ].hitlag = readBE4F (& _rb [_bp + O_HITLAG ]); 516 } 517 518if (MIN_VERSION (3 ,11 ,0 )) { 519_replay .player [p ].frame [f ].anim_index = readBE4U (& _rb [_bp + O_ANIM_INDEX ]); 520 } 521 522return true; 523 } 524 525bool Parser ::_parseItemUpdate () { 526DOUT2 (" Parsing item frame event at byte " <<+ _bp ); 527int32_t fnum = readBE4S (& _rb [_bp + O_FRAME ]); 528 529if (fnum < LOAD_FRAME ) { 530FAIL_CORRUPT (" Frame index " <<fnum <<" less than " <<+ LOAD_FRAME ); 531return false; 532 } 533if (fnum >=_max_frames ) { 534FAIL_CORRUPT (" Frame index " <<fnum <<" greater than max frames computed from reported raw size (" 535 <<_max_frames <<")" ); 536return false; 537 } 538 539uint32_t id = readBE4U (& _rb [_bp + O_ITEM_ID ]); 540 541if (id >=MAX_ITEMS ) { 542return true;//We can't output this many items (TODO: what's with item ID 3039053192???) 543 } 544 545int32_t f = _replay .item [id ].num_frames ; 546_replay .item [id ].spawn_id = id ; 547if (_replay .item [id ].frame == nullptr ) { 548_replay .item [id ].frame = new SlippiItemFrame [MAX_ITEM_LIFE ]; 549 } 550if (id >=_replay .num_items ) { 551_replay .num_items = id + 1 ; 552 } 553 554if (f < MAX_ITEM_LIFE ) { 555_replay .item [id ].num_frames += 1 ; 556_replay .item [id ].type = readBE2U (& _rb [_bp + O_ITEM_TYPE ]); 557_replay .item [id ].frame [f ].frame = fnum ; 558_replay .item [id ].frame [f ].state = uint8_t (_rb [_bp + O_ITEM_STATE ]); 559_replay .item [id ].frame [f ].face_dir = readBE4F (& _rb [_bp + O_ITEM_FACING ]); 560_replay .item [id ].frame [f ].xvel = readBE4F (& _rb [_bp + O_ITEM_XVEL ]); 561_replay .item [id ].frame [f ].yvel = readBE4F (& _rb [_bp + O_ITEM_YVEL ]); 562_replay .item [id ].frame [f ].xpos = readBE4F (& _rb [_bp + O_ITEM_XPOS ]); 563_replay .item [id ].frame [f ].ypos = readBE4F (& _rb [_bp + O_ITEM_YPOS ]); 564_replay .item [id ].frame [f ].damage = readBE2U (& _rb [_bp + O_ITEM_DAMAGE ]); 565_replay .item [id ].frame [f ].expire = readBE4F (& _rb [_bp + O_ITEM_EXPIRE ]); 566if (MIN_VERSION (3 ,2 ,0 )) { 567_replay .item [id ].frame [f ].flags_1 = uint8_t (_rb [_bp + O_ITEM_MISC ]); 568_replay .item [id ].frame [f ].flags_2 = uint8_t (_rb [_bp + O_ITEM_MISC + 1 ]); 569_replay .item [id ].frame [f ].flags_3 = uint8_t (_rb [_bp + O_ITEM_MISC + 2 ]); 570_replay .item [id ].frame [f ].flags_4 = uint8_t (_rb [_bp + O_ITEM_MISC + 3 ]); 571 } 572if (MIN_VERSION (3 ,6 ,0 )) { 573_replay .item [id ].frame [f ].owner = int8_t (_rb [_bp + O_ITEM_OWNER ]); 574 } 575 }else { 576DOUT2 (" Item " <<+ id <<" was alive longer than expected " ); 577 } 578 579return true; 580 } 581 582bool Parser ::_parseGameEnd () { 583DOUT1 (" Parsing game end event at byte " <<+ _bp ); 584_game_end_found = true; 585_replay .end_type = uint8_t (_rb [_bp + O_END_METHOD ]); 586 587if (MIN_VERSION (2 ,0 ,0 )) { 588_replay .lras = int8_t (_rb [_bp + O_LRAS ]); 589 } 590 591// Determine game winner 592// TODO: should account for LRAS 593int winner_stocks = 0 ; 594float winner_damage = 0 ; 595for (unsigned p = 0 ;p < 4 ;++ p ) { 596if (_replay .player [p ].player_type == 3 ) { 597continue ;//If we're not playing, we probably didn't win 598 } 599int end_stocks = _replay .player [p ].frame [_replay .frame_count - 1 ].stocks ; 600_replay .player [p ].end_stocks = end_stocks ; 601float end_damage = _replay .player [p ].frame [_replay .frame_count - 1 ].percent_post ; 602if ((end_stocks > winner_stocks )|| (end_stocks == winner_stocks && end_damage < winner_damage )) { 603winner_stocks = end_stocks ; 604winner_damage = end_damage ; 605_replay .winner_id = p ;//Tentatively set this person as the winner 606 } 607 } 608return true; 609 } 610 611bool Parser ::_parseMetadata () { 612DOUT1 (" Parsing metadata" ); 613 614//Parse metadata from UBJSON as regular JSON 615 std::stringstream ss ; 616 617 std::string indent = " " ; 618 std::string key = "" ; 619 std::string val = "" ; 620 std::string keypath = "" ;//Flattened representation of current JSON key 621bool done = false; 622bool fail = false; 623int32_t n = 0 ; 624 625 std::regex comma_killer ("(,)(\\s*\\})" ); 626 627uint8_t strlen = 0 ; 628for (unsigned i = 0 ;_bp + i < _file_size ;) { 629//Get next key 630switch (_rb [_bp + i ]) { 631case 0x55 ://U -> Length upcoming 632if (_bp + i + 1 >=_file_size ) { 633fail = true;break ; 634 } 635strlen = _rb [_bp + i + 1 ]; 636if (strlen > 0 ) { 637if (_bp + i + 1 + strlen >=_file_size ) { 638fail = true;break ; 639 } 640key .assign (& _rb [_bp + i + 2 ],strlen ); 641// std::cout << keypath << std::endl; 642 }else { 643key = "" ;//Not sure if empty strings are actually valid, but just in case 644 } 645keypath += "," + key ; 646if (key .compare ("metadata" )!= 0 ) { 647ss <<indent <<"\"" <<key <<"\" : " ; 648 } 649i = i + 2 + strlen ; 650break ; 651case 0x7d ://} -> Object ending 652keypath = keypath .substr (0 ,keypath .find_last_of ("," )); 653indent = indent .substr (1 ); 654if (indent .length ()== 0 ) { 655done = true; 656break ; 657 } 658ss <<indent <<"}," << std::endl ; 659i = i + 1 ; 660continue ; 661default : 662WARN (" Don't know what's happening; expected key" ); 663++ _replay .errors ; 664return false; 665 } 666if (done ) { 667break ; 668 }else if (fail || _bp + i >=_file_size ) { 669WARN (" Metadata shorter than expected" ); 670++ _replay .errors ; 671return false; 672 } 673//Get next value 674switch (_rb [_bp + i ]) { 675case 0x7b ://{ -> Object upcoming 676ss <<"{" << std::endl ; 677if (key .compare ("metadata" )!= 0 ) { 678indent = indent + " " ; 679 } 680i = i + 1 ; 681break ; 682case 0x53 ://S -> string upcoming 683if (_bp + i + 2 >=_file_size ) { 684fail = true;break ; 685 } 686ss <<"\"" ; 687if (_rb [_bp + i + 1 ]!= 0x55 ) {//If the string is not of length U 688WARN (" Found a long string we can't parse yet:" 689 << std::endl 690 <<" " <<ss .str () << std::endl ); 691++ _replay .errors ; 692return false; 693 } 694strlen = _rb [_bp + i + 2 ]; 695if (_bp + i + 2 + strlen >=_file_size ) { 696fail = true;break ; 697 } 698val .assign (& _rb [_bp + i + 3 ],strlen ); 699ss <<val <<"\"," << std::endl ; 700if (key .compare ("startAt" )== 0 ) { 701_replay .start_time = val ; 702 }else if (key .compare ("playedOn" )== 0 ) { 703_replay .played_on = val ; 704 }else if (key .compare ("netplay" )== 0 ) { 705size_t portpos = keypath .find ("players," ); 706if (portpos != std::string::npos ) { 707int port = keypath .substr (portpos + 8 ,1 ).c_str ()[0 ]- '0' ; 708_replay .player [port ].tag = val ; 709 } 710 }else if (key .compare ("code" )== 0 ) { 711size_t portpos = keypath .find ("players," ); 712if (portpos != std::string::npos ) { 713int port = keypath .substr (portpos + 8 ,1 ).c_str ()[0 ]- '0' ; 714// check if connect code was already set in game start block 715if (_replay .player [port ].tag_code .compare ("" )== 0 ) { 716_replay .player [port ].tag_code = val ; 717 } 718 } 719 } 720i = i + 3 + strlen ; 721keypath = keypath .substr (0 ,keypath .find_last_of ("," )); 722break ; 723case 0x6c ://l -> 32-bit signed int upcoming 724if (_bp + i + 4 >=_file_size ) { 725fail = true;break ; 726 } 727n = readBE4S (& _rb [_bp + i + 1 ]); 728ss << std::dec <<n <<"," << std::endl ; 729i = i + 5 ; 730keypath = keypath .substr (0 ,keypath .find_last_of ("," )); 731break ; 732default : 733WARN (" Don't know what's happening; expected value" ); 734return false; 735 } 736if (fail ) { 737WARN (" Metadata shorter than expected" ); 738return false; 739 } 740continue ; 741 } 742 743 std::string metadata = ss .str (); 744metadata = metadata .substr (0 ,metadata .length ()- 2 );//Remove trailing comma 745 std::string mjson ; 746 std::regex_replace (//Get rid of extraneous commas in our otherwise valid JSON 747 std::back_inserter (mjson ), 748metadata .begin (), 749metadata .end (), 750comma_killer , 751"$2" 752 ); 753 754_replay .metadata = mjson ; 755 756return true; 757 } 758 759Analysis * Parser ::analyze () { 760Analyzer a (_debug ); 761return a .analyze (_replay ); 762 } 763 764void Parser ::_cleanup () { 765_replay .cleanup (); 766 } 767 768 std::string Parser ::asJson (bool delta ) { 769return _replay .replayAsJson (delta ); 770 } 771 772void Parser ::save (const char * outfilename ,bool delta ) { 773DOUT1 (" Saving JSON" ); 774 std::ofstream ofile2 ; 775ofile2 .open (outfilename ); 776ofile2 <<asJson (delta ) << std::endl ; 777ofile2 .close (); 778DOUT1 (" Saved to " <<outfilename ); 779 } 780 781}