fork/slippc

git clone https://git.julia.blue/fork/slippc

Patrick CrainAdded ability to parse and analyzed .zlp compressed replays4df3a04

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