fork/slippc
git clone https://git.julia.blue/fork/slippc
46ef8c0
testing
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 = SLIPPC_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 382if (MIN_VERSION (3 ,14 ,0 )) { 383_replay .match_id = std::string (_rb + _bp + O_MATCH_ID ); 384_replay .game_number = readBE4U (& _rb [_bp + O_GAME_NUMBER ]); 385_replay .tiebreaker_number = readBE4U (& _rb [_bp + O_TIEBREAKER_NUMBER ]); 386 } 387 388_max_frames = getMaxNumFrames (); 389_replay .setFrames (_max_frames ); 390DOUT1 (" Estimated " <<_max_frames <<" gameplay frames (" << (_replay .frame_count ) <<" total frames)" ); 391return true; 392 } 393 394bool Parser ::_parsePreFrame () { 395DOUT2 (" Parsing pre frame event at byte " <<+ _bp ); 396int32_t fnum = readBE4S (& _rb [_bp + O_FRAME ]); 397int32_t f = fnum - LOAD_FRAME ; 398 399if (fnum < LOAD_FRAME ) { 400FAIL_CORRUPT (" Frame index " <<fnum <<" less than " <<+ LOAD_FRAME ); 401return false; 402 } 403if (fnum >=_max_frames ) { 404FAIL_CORRUPT (" Frame index " <<fnum 405 <<" greater than max frames computed from reported raw size (" <<_max_frames <<")" ); 406return false; 407 } 408 409uint8_t p = uint8_t (_rb [_bp + O_PLAYER ])+ 4 * uint8_t (_rb [_bp + O_FOLLOWER ]);//Includes follower 410if (p > 7 || _replay .player [p ].frame == nullptr ) { 411FAIL_CORRUPT (" Invalid player index " <<+ p ); 412return false; 413 } 414 415_replay .last_frame = fnum ; 416_replay .frame_count = f + 1 ;//Update the last frame we actually read 417_replay .player [p ].frame [f ].frame = fnum ; 418_replay .player [p ].frame [f ].player = p %4 ; 419_replay .player [p ].frame [f ].follower = (p > 3 ); 420_replay .player [p ].frame [f ].alive = 1 ; 421_replay .player [p ].frame [f ].seed = readBE4U (& _rb [_bp + O_RNG_PRE ]); 422_replay .player [p ].frame [f ].action_pre = readBE2U (& _rb [_bp + O_ACTION_PRE ]); 423_replay .player [p ].frame [f ].pos_x_pre = readBE4F (& _rb [_bp + O_XPOS_PRE ]); 424_replay .player [p ].frame [f ].pos_y_pre = readBE4F (& _rb [_bp + O_YPOS_PRE ]); 425_replay .player [p ].frame [f ].face_dir_pre = readBE4F (& _rb [_bp + O_FACING_PRE ]); 426_replay .player [p ].frame [f ].joy_x = readBE4F (& _rb [_bp + O_JOY_X ]); 427_replay .player [p ].frame [f ].joy_y = readBE4F (& _rb [_bp + O_JOY_Y ]); 428_replay .player [p ].frame [f ].c_x = readBE4F (& _rb [_bp + O_CX ]); 429_replay .player [p ].frame [f ].c_y = readBE4F (& _rb [_bp + O_CY ]); 430_replay .player [p ].frame [f ].trigger = readBE4F (& _rb [_bp + O_TRIGGER ]); 431_replay .player [p ].frame [f ].buttons = readBE2U (& _rb [_bp + O_BUTTONS ]); 432_replay .player [p ].frame [f ].phys_l = readBE4F (& _rb [_bp + O_PHYS_L ]); 433_replay .player [p ].frame [f ].phys_r = readBE4F (& _rb [_bp + O_PHYS_R ]); 434 435if (MIN_VERSION (1 ,2 ,0 )) { 436_replay .player [p ].frame [f ].ucf_x = uint8_t (_rb [_bp + O_UCF_ANALOG ]); 437 } 438 439if (MIN_VERSION (1 ,4 ,0 )) { 440_replay .player [p ].frame [f ].percent_pre = readBE4F (& _rb [_bp + O_DAMAGE_PRE ]); 441 } 442 443return true; 444 } 445 446bool Parser ::_parsePostFrame () { 447DOUT2 (" Parsing post frame event at byte " <<+ _bp ); 448int32_t fnum = readBE4S (& _rb [_bp + O_FRAME ]); 449int32_t f = fnum - LOAD_FRAME ; 450 451if (fnum < LOAD_FRAME ) { 452FAIL_CORRUPT (" Frame index " <<fnum <<" less than " <<+ LOAD_FRAME ); 453return false; 454 } 455if (fnum >=_max_frames ) { 456FAIL_CORRUPT (" Frame index " <<fnum <<" greater than max frames computed from reported raw size (" 457 <<_max_frames <<")" ); 458return false; 459 } 460 461uint8_t p = uint8_t (_rb [_bp + O_PLAYER ])+ 4 * uint8_t (_rb [_bp + O_FOLLOWER ]);//Includes follower 462if (p > 7 || _replay .player [p ].frame == nullptr ) { 463FAIL_CORRUPT (" Invalid player index " <<+ p ); 464return false; 465 } 466 467_replay .player [p ].frame [f ].char_id = uint8_t (_rb [_bp + O_INT_CHAR_ID ]); 468if (_replay .player [p ].frame [f ].char_id >=CharInt ::__LAST ) { 469WARN_CORRUPT (" Internal character ID " <<+ _replay .player [p ].frame [f ].char_id <<" is invalid" ); 470++ _replay .errors ; 471 } 472 473_replay .player [p ].frame [f ].action_post = readBE2U (& _rb [_bp + O_ACTION_POST ]); 474_replay .player [p ].frame [f ].pos_x_post = readBE4F (& _rb [_bp + O_XPOS_POST ]); 475_replay .player [p ].frame [f ].pos_y_post = readBE4F (& _rb [_bp + O_YPOS_POST ]); 476_replay .player [p ].frame [f ].face_dir_post = readBE4F (& _rb [_bp + O_FACING_POST ]); 477_replay .player [p ].frame [f ].percent_post = readBE4F (& _rb [_bp + O_DAMAGE_POST ]); 478_replay .player [p ].frame [f ].shield = readBE4F (& _rb [_bp + O_SHIELD ]); 479_replay .player [p ].frame [f ].hit_with = uint8_t (_rb [_bp + O_LAST_HIT_ID ]); 480_replay .player [p ].frame [f ].combo = uint8_t (_rb [_bp + O_COMBO ]); 481_replay .player [p ].frame [f ].hurt_by = uint8_t (_rb [_bp + O_LAST_HIT_BY ]); 482_replay .player [p ].frame [f ].stocks = uint8_t (_rb [_bp + O_STOCKS ]); 483 484if (MIN_VERSION (0 ,2 ,0 )) { 485_replay .player [p ].frame [f ].action_fc = readBE4F (& _rb [_bp + O_ACTION_FRAMES ]); 486 } 487 488if (MIN_VERSION (2 ,0 ,0 )) { 489_replay .player [p ].frame [f ].flags_1 = uint8_t (_rb [_bp + O_STATE_BITS_1 ]); 490_replay .player [p ].frame [f ].flags_2 = uint8_t (_rb [_bp + O_STATE_BITS_2 ]); 491_replay .player [p ].frame [f ].flags_3 = uint8_t (_rb [_bp + O_STATE_BITS_3 ]); 492_replay .player [p ].frame [f ].flags_4 = uint8_t (_rb [_bp + O_STATE_BITS_4 ]); 493_replay .player [p ].frame [f ].flags_5 = uint8_t (_rb [_bp + O_STATE_BITS_5 ]); 494_replay .player [p ].frame [f ].hitstun = readBE4F (& _rb [_bp + O_HITSTUN ]); 495_replay .player [p ].frame [f ].airborne = bool (_rb [_bp + O_AIRBORNE ]); 496_replay .player [p ].frame [f ].ground_id = readBE2U (& _rb [_bp + O_GROUND_ID ]); 497_replay .player [p ].frame [f ].jumps = uint8_t (_rb [_bp + O_JUMPS ]); 498_replay .player [p ].frame [f ].l_cancel = uint8_t (_rb [_bp + O_LCANCEL ]); 499 } 500 501if (MIN_VERSION (2 ,1 ,0 )) { 502_replay .player [p ].frame [f ].hurtbox = uint8_t (_rb [_bp + O_HURTBOX ]); 503 } 504 505if (MIN_VERSION (3 ,5 ,0 )) { 506_replay .player [p ].frame [f ].self_air_x = readBE4F (& _rb [_bp + O_SELF_AIR_X ]); 507_replay .player [p ].frame [f ].self_air_y = readBE4F (& _rb [_bp + O_SELF_AIR_Y ]); 508_replay .player [p ].frame [f ].attack_x = readBE4F (& _rb [_bp + O_ATTACK_X ]); 509_replay .player [p ].frame [f ].attack_y = readBE4F (& _rb [_bp + O_ATTACK_Y ]); 510_replay .player [p ].frame [f ].self_grd_x = readBE4F (& _rb [_bp + O_SELF_GROUND_X ]); 511 } 512 513if (MIN_VERSION (3 ,8 ,0 )) { 514_replay .player [p ].frame [f ].hitlag = readBE4F (& _rb [_bp + O_HITLAG ]); 515 } 516 517if (MIN_VERSION (3 ,11 ,0 )) { 518_replay .player [p ].frame [f ].anim_index = readBE4U (& _rb [_bp + O_ANIM_INDEX ]); 519 } 520 521return true; 522 } 523 524bool Parser ::_parseItemUpdate () { 525DOUT2 (" Parsing item frame event at byte " <<+ _bp ); 526int32_t fnum = readBE4S (& _rb [_bp + O_FRAME ]); 527 528if (fnum < LOAD_FRAME ) { 529FAIL_CORRUPT (" Frame index " <<fnum <<" less than " <<+ LOAD_FRAME ); 530return false; 531 } 532if (fnum >=_max_frames ) { 533FAIL_CORRUPT (" Frame index " <<fnum <<" greater than max frames computed from reported raw size (" 534 <<_max_frames <<")" ); 535return false; 536 } 537 538uint32_t id = readBE4U (& _rb [_bp + O_ITEM_ID ]); 539 540if (id >=MAX_ITEMS ) { 541return true;//We can't output this many items (TODO: what's with item ID 3039053192???) 542 } 543 544int32_t f = _replay .item [id ].num_frames ; 545_replay .item [id ].spawn_id = id ; 546if (_replay .item [id ].frame == nullptr ) { 547_replay .item [id ].frame = new SlippiItemFrame [MAX_ITEM_LIFE ]; 548 } 549if (id >=_replay .num_items ) { 550_replay .num_items = id + 1 ; 551 } 552 553if (f < MAX_ITEM_LIFE ) { 554_replay .item [id ].num_frames += 1 ; 555_replay .item [id ].type = readBE2U (& _rb [_bp + O_ITEM_TYPE ]); 556_replay .item [id ].frame [f ].frame = fnum ; 557_replay .item [id ].frame [f ].state = uint8_t (_rb [_bp + O_ITEM_STATE ]); 558_replay .item [id ].frame [f ].face_dir = readBE4F (& _rb [_bp + O_ITEM_FACING ]); 559_replay .item [id ].frame [f ].xvel = readBE4F (& _rb [_bp + O_ITEM_XVEL ]); 560_replay .item [id ].frame [f ].yvel = readBE4F (& _rb [_bp + O_ITEM_YVEL ]); 561_replay .item [id ].frame [f ].xpos = readBE4F (& _rb [_bp + O_ITEM_XPOS ]); 562_replay .item [id ].frame [f ].ypos = readBE4F (& _rb [_bp + O_ITEM_YPOS ]); 563_replay .item [id ].frame [f ].damage = readBE2U (& _rb [_bp + O_ITEM_DAMAGE ]); 564_replay .item [id ].frame [f ].expire = readBE4F (& _rb [_bp + O_ITEM_EXPIRE ]); 565if (MIN_VERSION (3 ,2 ,0 )) { 566_replay .item [id ].frame [f ].flags_1 = uint8_t (_rb [_bp + O_ITEM_MISC ]); 567_replay .item [id ].frame [f ].flags_2 = uint8_t (_rb [_bp + O_ITEM_MISC + 1 ]); 568_replay .item [id ].frame [f ].flags_3 = uint8_t (_rb [_bp + O_ITEM_MISC + 2 ]); 569_replay .item [id ].frame [f ].flags_4 = uint8_t (_rb [_bp + O_ITEM_MISC + 3 ]); 570 } 571if (MIN_VERSION (3 ,6 ,0 )) { 572_replay .item [id ].frame [f ].owner = int8_t (_rb [_bp + O_ITEM_OWNER ]); 573 } 574 }else { 575DOUT2 (" Item " <<+ id <<" was alive longer than expected " ); 576 } 577 578return true; 579 } 580 581bool Parser ::_parseGameEnd () { 582DOUT1 (" Parsing game end event at byte " <<+ _bp ); 583_game_end_found = true; 584_replay .end_type = uint8_t (_rb [_bp + O_END_METHOD ]); 585 586if (MIN_VERSION (2 ,0 ,0 )) { 587_replay .lras = int8_t (_rb [_bp + O_LRAS ]); 588 } 589 590// Determine game winner 591// TODO: should account for LRAS 592int winner_stocks = 0 ; 593float winner_damage = 0 ; 594for (unsigned p = 0 ;p < 4 ;++ p ) { 595if (_replay .player [p ].player_type == 3 ) { 596continue ;//If we're not playing, we probably didn't win 597 } 598int end_stocks = _replay .player [p ].frame [_replay .frame_count - 1 ].stocks ; 599_replay .player [p ].end_stocks = end_stocks ; 600float end_damage = _replay .player [p ].frame [_replay .frame_count - 1 ].percent_post ; 601if ((end_stocks > winner_stocks )|| (end_stocks == winner_stocks && end_damage < winner_damage )) { 602winner_stocks = end_stocks ; 603winner_damage = end_damage ; 604_replay .winner_id = p ;//Tentatively set this person as the winner 605 } 606 } 607return true; 608 } 609 610bool Parser ::_parseMetadata () { 611DOUT1 (" Parsing metadata" ); 612 613//Parse metadata from UBJSON as regular JSON 614 std::stringstream ss ; 615 616 std::string indent = " " ; 617 std::string key = "" ; 618 std::string val = "" ; 619 std::string keypath = "" ;//Flattened representation of current JSON key 620bool done = false; 621bool fail = false; 622int32_t n = 0 ; 623 624 std::regex comma_killer ("(,)(\\s*\\})" ); 625 626uint8_t strlen = 0 ; 627for (unsigned i = 0 ;_bp + i < _file_size ;) { 628//Get next key 629switch (_rb [_bp + i ]) { 630case 0x55 ://U -> Length upcoming 631if (_bp + i + 1 >=_file_size ) { 632fail = true;break ; 633 } 634strlen = _rb [_bp + i + 1 ]; 635if (strlen > 0 ) { 636if (_bp + i + 1 + strlen >=_file_size ) { 637fail = true;break ; 638 } 639key .assign (& _rb [_bp + i + 2 ],strlen ); 640// std::cout << keypath << std::endl; 641 }else { 642key = "" ;//Not sure if empty strings are actually valid, but just in case 643 } 644keypath += "," + key ; 645if (key .compare ("metadata" )!= 0 ) { 646ss <<indent <<"\"" <<key <<"\" : " ; 647 } 648i = i + 2 + strlen ; 649break ; 650case 0x7d ://} -> Object ending 651keypath = keypath .substr (0 ,keypath .find_last_of ("," )); 652indent = indent .substr (1 ); 653if (indent .length ()== 0 ) { 654done = true; 655break ; 656 } 657ss <<indent <<"}," << std::endl ; 658i = i + 1 ; 659continue ; 660default : 661WARN (" Don't know what's happening; expected key" ); 662++ _replay .errors ; 663return false; 664 } 665if (done ) { 666break ; 667 }else if (fail || _bp + i >=_file_size ) { 668WARN (" Metadata shorter than expected" ); 669++ _replay .errors ; 670return false; 671 } 672//Get next value 673switch (_rb [_bp + i ]) { 674case 0x7b ://{ -> Object upcoming 675ss <<"{" << std::endl ; 676if (key .compare ("metadata" )!= 0 ) { 677indent = indent + " " ; 678 } 679i = i + 1 ; 680break ; 681case 0x53 ://S -> string upcoming 682if (_bp + i + 2 >=_file_size ) { 683fail = true;break ; 684 } 685ss <<"\"" ; 686if (_rb [_bp + i + 1 ]!= 0x55 ) {//If the string is not of length U 687WARN (" Found a long string we can't parse yet:" 688 << std::endl 689 <<" " <<ss .str () << std::endl ); 690++ _replay .errors ; 691return false; 692 } 693strlen = _rb [_bp + i + 2 ]; 694if (_bp + i + 2 + strlen >=_file_size ) { 695fail = true;break ; 696 } 697val .assign (& _rb [_bp + i + 3 ],strlen ); 698ss <<val <<"\"," << std::endl ; 699if (key .compare ("startAt" )== 0 ) { 700_replay .start_time = val ; 701 }else if (key .compare ("playedOn" )== 0 ) { 702_replay .played_on = val ; 703 }else if (key .compare ("netplay" )== 0 ) { 704size_t portpos = keypath .find ("players," ); 705if (portpos != std::string::npos ) { 706int port = keypath .substr (portpos + 8 ,1 ).c_str ()[0 ]- '0' ; 707_replay .player [port ].tag = val ; 708 } 709 }else if (key .compare ("code" )== 0 ) { 710size_t portpos = keypath .find ("players," ); 711if (portpos != std::string::npos ) { 712int port = keypath .substr (portpos + 8 ,1 ).c_str ()[0 ]- '0' ; 713// check if connect code was already set in game start block 714if (_replay .player [port ].tag_code .compare ("" )== 0 ) { 715_replay .player [port ].tag_code = val ; 716 } 717 } 718 } 719i = i + 3 + strlen ; 720keypath = keypath .substr (0 ,keypath .find_last_of ("," )); 721break ; 722case 0x6c ://l -> 32-bit signed int upcoming 723if (_bp + i + 4 >=_file_size ) { 724fail = true;break ; 725 } 726n = readBE4S (& _rb [_bp + i + 1 ]); 727ss << std::dec <<n <<"," << std::endl ; 728i = i + 5 ; 729keypath = keypath .substr (0 ,keypath .find_last_of ("," )); 730break ; 731default : 732WARN (" Don't know what's happening; expected value" ); 733return false; 734 } 735if (fail ) { 736WARN (" Metadata shorter than expected" ); 737return false; 738 } 739continue ; 740 } 741 742 std::string metadata = ss .str (); 743metadata = metadata .substr (0 ,metadata .length ()- 2 );//Remove trailing comma 744 std::string mjson ; 745 std::regex_replace (//Get rid of extraneous commas in our otherwise valid JSON 746 std::back_inserter (mjson ), 747metadata .begin (), 748metadata .end (), 749comma_killer , 750"$2" 751 ); 752 753_replay .metadata = mjson ; 754 755return true; 756 } 757 758Analysis * Parser ::analyze () { 759Analyzer a (_debug ); 760return a .analyze (_replay ); 761 } 762 763void Parser ::_cleanup () { 764_replay .cleanup (); 765 } 766 767 std::string Parser ::asJson (bool delta ) { 768return _replay .replayAsJson (delta ); 769 } 770 771void Parser ::save (const char * outfilename ,bool delta ) { 772DOUT1 (" Saving JSON" ); 773 std::ofstream ofile2 ; 774ofile2 .open (outfilename ); 775ofile2 <<asJson (delta ) << std::endl ; 776ofile2 .close (); 777DOUT1 (" Saved to " <<outfilename ); 778 } 779 780}