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