mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2025-08-24 19:27:27 +00:00
refactor: update and format SlippiGame
This commit is contained in:
Nikhil Narayana
parent
4d57b3b605
commit
9392df6991
2 changed files with 666 additions and 687 deletions
357
Externals/SlippiLib/SlippiGame.cpp
vendored
357
Externals/SlippiLib/SlippiGame.cpp
vendored
|
|
@ -4,28 +4,24 @@
|
|||
|
||||
#include "SlippiGame.h"
|
||||
|
||||
namespace Slippi
|
||||
{
|
||||
//**********************************************************************
|
||||
//* Event Handlers
|
||||
//**********************************************************************
|
||||
// The read operators will read a value and increment the index so the next read
|
||||
// will read in the correct location
|
||||
uint8_t readByte(uint8_t* a, int& idx, uint32_t maxSize, uint8_t defaultValue)
|
||||
{
|
||||
if (idx >= (int)maxSize)
|
||||
{
|
||||
namespace Slippi {
|
||||
//**********************************************************************
|
||||
//* Event Handlers
|
||||
//**********************************************************************
|
||||
// The read operators will read a value and increment the index so the next read
|
||||
// will read in the correct location
|
||||
uint8_t readByte(uint8_t *a, int &idx, uint32_t maxSize, uint8_t defaultValue) {
|
||||
if (idx >= (int)maxSize) {
|
||||
idx += 1;
|
||||
return defaultValue;
|
||||
}
|
||||
|
||||
return a[idx++];
|
||||
}
|
||||
}
|
||||
|
||||
uint16_t readHalf(uint8_t* a, int& idx, uint32_t maxSize, uint16_t defaultValue)
|
||||
{
|
||||
if (idx >= (int)maxSize)
|
||||
{
|
||||
uint16_t readHalf(uint8_t *a, int &idx, uint32_t maxSize,
|
||||
uint16_t defaultValue) {
|
||||
if (idx >= (int)maxSize) {
|
||||
idx += 2;
|
||||
return defaultValue;
|
||||
}
|
||||
|
|
@ -33,40 +29,36 @@ namespace Slippi
|
|||
uint16_t value = a[idx] << 8 | a[idx + 1];
|
||||
idx += 2;
|
||||
return value;
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t readWord(uint8_t* a, int& idx, uint32_t maxSize, uint32_t defaultValue)
|
||||
{
|
||||
if (idx >= (int)maxSize)
|
||||
{
|
||||
uint32_t readWord(uint8_t *a, int &idx, uint32_t maxSize,
|
||||
uint32_t defaultValue) {
|
||||
if (idx >= (int)maxSize) {
|
||||
idx += 4;
|
||||
return defaultValue;
|
||||
}
|
||||
|
||||
uint32_t value = a[idx] << 24 | a[idx + 1] << 16 | a[idx + 2] << 8 | a[idx + 3];
|
||||
uint32_t value =
|
||||
a[idx] << 24 | a[idx + 1] << 16 | a[idx + 2] << 8 | a[idx + 3];
|
||||
idx += 4;
|
||||
return value;
|
||||
}
|
||||
}
|
||||
|
||||
float readFloat(uint8_t* a, int& idx, uint32_t maxSize, float defaultValue)
|
||||
{
|
||||
uint32_t bytes = readWord(a, idx, maxSize, *(uint32_t*)(&defaultValue));
|
||||
return *(float*)(&bytes);
|
||||
}
|
||||
float readFloat(uint8_t *a, int &idx, uint32_t maxSize, float defaultValue) {
|
||||
uint32_t bytes = readWord(a, idx, maxSize, *(uint32_t *)(&defaultValue));
|
||||
return *(float *)(&bytes);
|
||||
}
|
||||
|
||||
void handleGameInit(Game* game, uint32_t maxSize)
|
||||
{
|
||||
void handleGameInit(Game *game, uint32_t maxSize) {
|
||||
int idx = 0;
|
||||
|
||||
// Read version number
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
for (int i = 0; i < 4; i++) {
|
||||
game->version[i] = readByte(data, idx, maxSize, 0);
|
||||
}
|
||||
|
||||
// Read entire game info header
|
||||
for (int i = 0; i < GAME_INFO_HEADER_SIZE; i++)
|
||||
{
|
||||
for (int i = 0; i < GAME_INFO_HEADER_SIZE; i++) {
|
||||
game->settings.header[i] = readWord(data, idx, maxSize, 0);
|
||||
}
|
||||
|
||||
|
|
@ -75,18 +67,15 @@ namespace Slippi
|
|||
|
||||
// Read UCF toggle bytes
|
||||
bool shouldRead = game->version[0] >= 1;
|
||||
for (int i = 0; i < UCF_TOGGLE_SIZE; i++)
|
||||
{
|
||||
for (int i = 0; i < UCF_TOGGLE_SIZE; i++) {
|
||||
uint32_t value = shouldRead ? readWord(data, idx, maxSize, 0) : 0;
|
||||
game->settings.ucfToggles[i] = value;
|
||||
}
|
||||
|
||||
// Read nametag for each player
|
||||
std::array<std::array<uint16_t, NAMETAG_SIZE>, 4> playerNametags;
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
for (int j = 0; j < NAMETAG_SIZE; j++)
|
||||
{
|
||||
for (int i = 0; i < 4; i++) {
|
||||
for (int j = 0; j < NAMETAG_SIZE; j++) {
|
||||
playerNametags[i][j] = readHalf(data, idx, maxSize, 0);
|
||||
}
|
||||
}
|
||||
|
|
@ -97,19 +86,40 @@ namespace Slippi
|
|||
// Read isFrozenPS byte
|
||||
game->settings.isFrozenPS = readByte(data, idx, maxSize, 0);
|
||||
|
||||
// Read minorScene byte
|
||||
game->settings.minorScene = readByte(data, idx, maxSize, 0);
|
||||
|
||||
// Read majorScene byte
|
||||
game->settings.majorScene = readByte(data, idx, maxSize, 0);
|
||||
|
||||
// Read display name for each player
|
||||
std::array<std::array<uint8_t, DISPLAY_NAME_SIZE>, 4> playerDisplayNames;
|
||||
for (int i = 0; i < 4; i++) {
|
||||
for (int j = 0; j < DISPLAY_NAME_SIZE; j++) {
|
||||
playerDisplayNames[i][j] = readByte(data, idx, maxSize, 0);
|
||||
}
|
||||
}
|
||||
|
||||
// Read connectCodes
|
||||
std::array<std::array<uint8_t, CONNECT_CODE_SIZE>, 4> playerConnectCodes;
|
||||
for (int i = 0; i < 4; i++) {
|
||||
for (int j = 0; j < CONNECT_CODE_SIZE; j++) {
|
||||
playerConnectCodes[i][j] = readByte(data, idx, maxSize, 0);
|
||||
}
|
||||
}
|
||||
|
||||
// Pull header data into struct
|
||||
int player1Pos = 24; // This is the index of the first players character info
|
||||
std::array<uint32_t, Slippi::GAME_INFO_HEADER_SIZE> gameInfoHeader = game->settings.header;
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
std::array<uint32_t, Slippi::GAME_INFO_HEADER_SIZE> gameInfoHeader =
|
||||
game->settings.header;
|
||||
for (int i = 0; i < 4; i++) {
|
||||
// this is the position in the array that this player's character info is
|
||||
// stored
|
||||
int pos = player1Pos + (9 * i);
|
||||
|
||||
uint32_t playerInfo = gameInfoHeader[pos];
|
||||
uint8_t playerType = (playerInfo & 0x00FF0000) >> 16;
|
||||
if (playerType == 0x3)
|
||||
{
|
||||
if (playerType == 0x3) {
|
||||
// Player type 3 is an empty slot
|
||||
continue;
|
||||
}
|
||||
|
|
@ -122,6 +132,8 @@ namespace Slippi
|
|||
p.playerType = playerType;
|
||||
p.characterColor = playerInfo & 0xFF;
|
||||
p.nametag = playerNametags[i];
|
||||
p.displayName = playerDisplayNames[i];
|
||||
p.connectCode = playerConnectCodes[i];
|
||||
|
||||
// Add player settings to result
|
||||
game->settings.players[i] = p;
|
||||
|
|
@ -131,33 +143,29 @@ namespace Slippi
|
|||
|
||||
auto majorVersion = game->version[0];
|
||||
auto minorVersion = game->version[1];
|
||||
if (majorVersion > 3 || (majorVersion == 3 && minorVersion >= 1))
|
||||
{
|
||||
if (majorVersion > 3 || (majorVersion == 3 && minorVersion >= 1)) {
|
||||
// After version 3.1.0 we added a dynamic gecko loading process. These
|
||||
// are needed before starting the game. areSettingsLoaded will be set
|
||||
// to true when they are received
|
||||
game->areSettingsLoaded = false;
|
||||
}
|
||||
else if (majorVersion > 1 || (majorVersion == 1 && minorVersion >= 6))
|
||||
{
|
||||
} else if (majorVersion > 1 || (majorVersion == 1 && minorVersion >= 6)) {
|
||||
// Indicate settings loaded immediately if after version 1.6.0
|
||||
// Sheik game info was added in this version and so we no longer
|
||||
// need to wait
|
||||
game->areSettingsLoaded = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void handleGeckoList(Game* game, uint32_t maxSize)
|
||||
{
|
||||
void handleGeckoList(Game *game, uint32_t maxSize) {
|
||||
game->settings.geckoCodes.clear();
|
||||
game->settings.geckoCodes.insert(game->settings.geckoCodes.end(), data, data + maxSize);
|
||||
game->settings.geckoCodes.insert(game->settings.geckoCodes.end(), data,
|
||||
data + maxSize);
|
||||
|
||||
// File is good to load
|
||||
game->areSettingsLoaded = true;
|
||||
}
|
||||
}
|
||||
|
||||
void handleFrameStart(Game* game, uint32_t maxSize)
|
||||
{
|
||||
void handleFrameStart(Game *game, uint32_t maxSize) {
|
||||
int idx = 0;
|
||||
|
||||
// Check frame count
|
||||
|
|
@ -165,7 +173,7 @@ namespace Slippi
|
|||
game->frameCount = frameCount;
|
||||
|
||||
auto frameUniquePtr = std::make_unique<FrameData>();
|
||||
FrameData* frame = frameUniquePtr.get();
|
||||
FrameData *frame = frameUniquePtr.get();
|
||||
|
||||
frame->frame = frameCount;
|
||||
frame->randomSeedExists = true;
|
||||
|
|
@ -176,10 +184,9 @@ namespace Slippi
|
|||
frame->numSinceStart = game->frames.size();
|
||||
game->frames.push_back(std::move(frameUniquePtr));
|
||||
game->framesByIndex[frameCount] = frame;
|
||||
}
|
||||
}
|
||||
|
||||
void handlePreFrameUpdate(Game* game, uint32_t maxSize)
|
||||
{
|
||||
void handlePreFrameUpdate(Game *game, uint32_t maxSize) {
|
||||
int idx = 0;
|
||||
|
||||
// Check frame count
|
||||
|
|
@ -187,11 +194,10 @@ namespace Slippi
|
|||
game->frameCount = frameCount;
|
||||
|
||||
auto frameUniquePtr = std::make_unique<FrameData>();
|
||||
FrameData* frame = frameUniquePtr.get();
|
||||
FrameData *frame = frameUniquePtr.get();
|
||||
bool isNewFrame = true;
|
||||
|
||||
if (game->framesByIndex.count(frameCount))
|
||||
{
|
||||
if (game->framesByIndex.count(frameCount)) {
|
||||
// If this frame already exists, get the current frame
|
||||
frame = game->frames.back().get();
|
||||
isNewFrame = false;
|
||||
|
|
@ -226,40 +232,36 @@ namespace Slippi
|
|||
p.lTrigger = readFloat(data, idx, maxSize, 0);
|
||||
p.rTrigger = readFloat(data, idx, maxSize, 0);
|
||||
|
||||
if (asmEvents[EVENT_PRE_FRAME_UPDATE] >= 59)
|
||||
{
|
||||
if (asmEvents[EVENT_PRE_FRAME_UPDATE] >= 59) {
|
||||
p.joystickXRaw = readByte(data, idx, maxSize, 0);
|
||||
}
|
||||
|
||||
uint32_t noPercent = 0xFFFFFFFF;
|
||||
p.percent = readFloat(data, idx, maxSize, *(float*)(&noPercent));
|
||||
p.percent = readFloat(data, idx, maxSize, *(float *)(&noPercent));
|
||||
|
||||
// Add player data to frame
|
||||
std::unordered_map<uint8_t, PlayerFrameData>* target;
|
||||
std::unordered_map<uint8_t, PlayerFrameData> *target;
|
||||
target = isFollower ? &frame->followers : &frame->players;
|
||||
|
||||
// Set the player data for the player or follower
|
||||
target->operator[](playerSlot) = p;
|
||||
|
||||
// Add frame to game
|
||||
if (isNewFrame)
|
||||
{
|
||||
if (isNewFrame) {
|
||||
frame->numSinceStart = game->frames.size();
|
||||
game->frames.push_back(std::move(frameUniquePtr));
|
||||
game->framesByIndex[frameCount] = frame;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void handlePostFrameUpdate(Game* game, uint32_t maxSize)
|
||||
{
|
||||
void handlePostFrameUpdate(Game *game, uint32_t maxSize) {
|
||||
int idx = 0;
|
||||
|
||||
// Check frame count
|
||||
int32_t frameCount = readWord(data, idx, maxSize, 0);
|
||||
|
||||
FrameData* frame;
|
||||
if (game->framesByIndex.count(frameCount))
|
||||
{
|
||||
FrameData *frame;
|
||||
if (game->framesByIndex.count(frameCount)) {
|
||||
// If this frame already exists, get the current frame
|
||||
frame = game->frames.back().get();
|
||||
}
|
||||
|
|
@ -272,62 +274,60 @@ namespace Slippi
|
|||
uint8_t playerSlot = readByte(data, idx, maxSize, 0);
|
||||
uint8_t isFollower = readByte(data, idx, maxSize, 0);
|
||||
|
||||
PlayerFrameData* p = isFollower ? &frame->followers[playerSlot] : &frame->players[playerSlot];
|
||||
PlayerFrameData *p =
|
||||
isFollower ? &frame->followers[playerSlot] : &frame->players[playerSlot];
|
||||
|
||||
p->internalCharacterId = readByte(data, idx, maxSize, 0);
|
||||
|
||||
// Check if a player started as sheik and update
|
||||
if (frameCount == GAME_FIRST_FRAME && p->internalCharacterId == GAME_SHEIK_INTERNAL_ID)
|
||||
{
|
||||
if (frameCount == GAME_FIRST_FRAME &&
|
||||
p->internalCharacterId == GAME_SHEIK_INTERNAL_ID) {
|
||||
game->settings.players[playerSlot].characterId = GAME_SHEIK_EXTERNAL_ID;
|
||||
}
|
||||
|
||||
// Set settings loaded if this is the last character
|
||||
if (frameCount == GAME_FIRST_FRAME)
|
||||
{
|
||||
if (frameCount == GAME_FIRST_FRAME) {
|
||||
uint8_t lastPlayerIndex = 0;
|
||||
for (auto it = frame->players.begin(); it != frame->players.end(); ++it)
|
||||
{
|
||||
if (it->first <= lastPlayerIndex)
|
||||
{
|
||||
for (auto it = frame->players.begin(); it != frame->players.end(); ++it) {
|
||||
if (it->first <= lastPlayerIndex) {
|
||||
continue;
|
||||
}
|
||||
|
||||
lastPlayerIndex = it->first;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void handleFrameEnd(Game* game, uint32_t maxSize) {
|
||||
if (playerSlot >= lastPlayerIndex) {
|
||||
game->areSettingsLoaded = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void handleFrameEnd(Game *game, uint32_t maxSize) {
|
||||
int idx = 0;
|
||||
|
||||
int32_t frameCount = readWord(data, idx, maxSize, 0);
|
||||
int32_t lastFinalizedFrame = readWord(data, idx, maxSize, frameCount);
|
||||
|
||||
game->lastFinalizedFrame = lastFinalizedFrame;
|
||||
}
|
||||
}
|
||||
|
||||
void handleGameEnd(Game* game, uint32_t maxSize)
|
||||
{
|
||||
void handleGameEnd(Game *game, uint32_t maxSize) {
|
||||
int idx = 0;
|
||||
|
||||
game->winCondition = readByte(data, idx, maxSize, 0);
|
||||
}
|
||||
}
|
||||
|
||||
// This function gets the position where the raw data starts
|
||||
int getRawDataPosition(std::ifstream* f)
|
||||
{
|
||||
// This function gets the position where the raw data starts
|
||||
int getRawDataPosition(std::ifstream *f) {
|
||||
char buffer[2];
|
||||
f->seekg(0, std::ios::beg);
|
||||
f->read(buffer, 2);
|
||||
|
||||
if (buffer[0] == 0x36)
|
||||
{
|
||||
if (buffer[0] == 0x36) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (buffer[0] != '{')
|
||||
{
|
||||
if (buffer[0] != '{') {
|
||||
// TODO: Do something here to cause an error
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -336,12 +336,10 @@ namespace Slippi
|
|||
// TODO: For now since raw is the first element the data will always start at
|
||||
// 15
|
||||
return 15;
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t getRawDataLength(std::ifstream* f, int position, int fileSize)
|
||||
{
|
||||
if (position == 0)
|
||||
{
|
||||
uint32_t getRawDataLength(std::ifstream *f, int position, int fileSize) {
|
||||
if (position == 0) {
|
||||
return fileSize;
|
||||
}
|
||||
|
||||
|
|
@ -349,28 +347,28 @@ namespace Slippi
|
|||
f->seekg(position - 4, std::ios::beg);
|
||||
f->read(buffer, 4);
|
||||
|
||||
uint8_t* byteBuf = (uint8_t*)&buffer[0];
|
||||
uint32_t length = byteBuf[0] << 24 | byteBuf[1] << 16 | byteBuf[2] << 8 | byteBuf[3];
|
||||
uint8_t *byteBuf = (uint8_t *)&buffer[0];
|
||||
uint32_t length =
|
||||
byteBuf[0] << 24 | byteBuf[1] << 16 | byteBuf[2] << 8 | byteBuf[3];
|
||||
return length;
|
||||
}
|
||||
}
|
||||
|
||||
std::unordered_map<uint8_t, uint32_t> getMessageSizes(std::ifstream* f, int position)
|
||||
{
|
||||
std::unordered_map<uint8_t, uint32_t> getMessageSizes(std::ifstream *f,
|
||||
int position) {
|
||||
char buffer[2];
|
||||
f->seekg(position, std::ios::beg);
|
||||
f->read(buffer, 2);
|
||||
if (buffer[0] != EVENT_PAYLOAD_SIZES)
|
||||
{
|
||||
if (buffer[0] != EVENT_PAYLOAD_SIZES) {
|
||||
return {};
|
||||
}
|
||||
|
||||
int payloadLength = buffer[1];
|
||||
std::unordered_map<uint8_t, uint32_t> messageSizes = { {EVENT_PAYLOAD_SIZES, payloadLength} };
|
||||
std::unordered_map<uint8_t, uint32_t> messageSizes = {
|
||||
{EVENT_PAYLOAD_SIZES, payloadLength}};
|
||||
|
||||
std::vector<char> messageSizesBuffer(payloadLength - 1);
|
||||
f->read(&messageSizesBuffer[0], payloadLength - 1);
|
||||
for (int i = 0; i < payloadLength - 1; i += 3)
|
||||
{
|
||||
for (int i = 0; i < payloadLength - 1; i += 3) {
|
||||
uint8_t command = messageSizesBuffer[i];
|
||||
|
||||
// Extract the bytes in u8s. Without this the chars don't or together well
|
||||
|
|
@ -382,12 +380,10 @@ namespace Slippi
|
|||
}
|
||||
|
||||
return messageSizes;
|
||||
}
|
||||
}
|
||||
|
||||
void SlippiGame::processData()
|
||||
{
|
||||
if (isProcessingComplete)
|
||||
{
|
||||
void SlippiGame::processData() {
|
||||
if (isProcessingComplete) {
|
||||
// If we have finished processing this file, return
|
||||
return;
|
||||
}
|
||||
|
|
@ -395,20 +391,17 @@ namespace Slippi
|
|||
// This function will process as much data as possible
|
||||
int startPos = (int)file->tellg();
|
||||
file->seekg(startPos);
|
||||
if (startPos == 0)
|
||||
{
|
||||
if (startPos == 0) {
|
||||
file->seekg(0, std::ios::end);
|
||||
int len = (int)file->tellg();
|
||||
if (len < 2)
|
||||
{
|
||||
if (len < 2) {
|
||||
// If we can't read message sizes payload size yet, return
|
||||
return;
|
||||
}
|
||||
|
||||
int rawDataPos = getRawDataPosition(file.get());
|
||||
int rawDataLen = len - rawDataPos;
|
||||
if (rawDataLen < 2)
|
||||
{
|
||||
if (rawDataLen < 2) {
|
||||
// If we don't have enough raw data yet to read the replay file, return
|
||||
// Reset to begining so that the startPos condition will be hit again
|
||||
file->seekg(0);
|
||||
|
|
@ -422,8 +415,7 @@ namespace Slippi
|
|||
file->read(buffer, 2);
|
||||
file->seekg(startPos);
|
||||
auto messageSizesSize = (int)buffer[1];
|
||||
if (rawDataLen < messageSizesSize)
|
||||
{
|
||||
if (rawDataLen < messageSizesSize) {
|
||||
// If we haven't received the full payload sizes message, return
|
||||
// Reset to begining so that the startPos condition will be hit again
|
||||
file->seekg(0);
|
||||
|
|
@ -441,8 +433,7 @@ namespace Slippi
|
|||
// log << "Size to read: " << sizeToRead << "\n";
|
||||
// log << "Start Pos: " << startPos << "\n";
|
||||
// log << "End Pos: " << endPos << "\n\n";
|
||||
if (sizeToRead <= 0)
|
||||
{
|
||||
if (sizeToRead <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -450,8 +441,7 @@ namespace Slippi
|
|||
file->read(&newData[0], sizeToRead);
|
||||
|
||||
int newDataPos = 0;
|
||||
while (newDataPos < sizeToRead)
|
||||
{
|
||||
while (newDataPos < sizeToRead) {
|
||||
auto command = newData[newDataPos];
|
||||
auto payloadSize = asmEvents[command];
|
||||
|
||||
|
|
@ -460,35 +450,32 @@ namespace Slippi
|
|||
// log << "Command: " << buff << " | Payload Size: " << payloadSize << "\n";
|
||||
|
||||
auto remainingLen = sizeToRead - newDataPos;
|
||||
if (remainingLen < ((int)payloadSize + 1))
|
||||
{
|
||||
if (remainingLen < ((int)payloadSize + 1)) {
|
||||
// Here we don't have enough data to read the whole payload
|
||||
// Will be processed after getting more data (hopefully)
|
||||
file->seekg(-remainingLen, std::ios::cur);
|
||||
return;
|
||||
}
|
||||
|
||||
data = (uint8_t*)&newData[newDataPos + 1];
|
||||
data = (uint8_t *)&newData[newDataPos + 1];
|
||||
|
||||
uint8_t isSplitComplete = false;
|
||||
uint32_t outerPayloadSize = payloadSize;
|
||||
|
||||
// Handle a split message, combining in until we possess the entire message
|
||||
if (command == EVENT_SPLIT_MESSAGE)
|
||||
{
|
||||
if (shouldResetSplitMessageBuf)
|
||||
{
|
||||
if (command == EVENT_SPLIT_MESSAGE) {
|
||||
if (shouldResetSplitMessageBuf) {
|
||||
splitMessageBuf.clear();
|
||||
shouldResetSplitMessageBuf = false;
|
||||
}
|
||||
|
||||
int _ = 0;
|
||||
uint16_t blockSize = readHalf(&data[SPLIT_MESSAGE_INTERNAL_DATA_LEN], _, payloadSize, 0);
|
||||
uint16_t blockSize =
|
||||
readHalf(&data[SPLIT_MESSAGE_INTERNAL_DATA_LEN], _, payloadSize, 0);
|
||||
splitMessageBuf.insert(splitMessageBuf.end(), data, data + blockSize);
|
||||
|
||||
isSplitComplete = data[SPLIT_MESSAGE_INTERNAL_DATA_LEN + 3];
|
||||
if (isSplitComplete)
|
||||
{
|
||||
if (isSplitComplete) {
|
||||
// Transform this message into a different message
|
||||
command = data[SPLIT_MESSAGE_INTERNAL_DATA_LEN + 2];
|
||||
data = &splitMessageBuf[0];
|
||||
|
|
@ -497,8 +484,7 @@ namespace Slippi
|
|||
}
|
||||
}
|
||||
|
||||
switch (command)
|
||||
{
|
||||
switch (command) {
|
||||
case EVENT_GAME_INIT:
|
||||
handleGameInit(game.get(), payloadSize);
|
||||
break;
|
||||
|
|
@ -514,6 +500,9 @@ namespace Slippi
|
|||
case EVENT_POST_FRAME_UPDATE:
|
||||
handlePostFrameUpdate(game.get(), payloadSize);
|
||||
break;
|
||||
case EVENT_FRAME_END:
|
||||
handleFrameEnd(game.get(), payloadSize);
|
||||
break;
|
||||
case EVENT_GAME_END:
|
||||
handleGameEnd(game.get(), payloadSize);
|
||||
isProcessingComplete = true;
|
||||
|
|
@ -532,25 +521,26 @@ namespace Slippi
|
|||
payloadSize = isSplitComplete ? outerPayloadSize : payloadSize;
|
||||
newDataPos += payloadSize + 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::unique_ptr<SlippiGame> SlippiGame::FromFile(std::string path)
|
||||
{
|
||||
std::unique_ptr<SlippiGame> SlippiGame::FromFile(std::string path) {
|
||||
auto result = std::make_unique<SlippiGame>();
|
||||
result->game = std::make_unique<Game>();
|
||||
result->path = path;
|
||||
|
||||
#ifdef _WIN32
|
||||
// On Windows, we need to convert paths to std::wstring to deal with UTF-8
|
||||
std::wstring convertedPath = std::wstring_convert<std::codecvt_utf8<wchar_t>>().from_bytes(path);
|
||||
result->file = std::make_unique<std::ifstream>(convertedPath, std::ios::in | std::ios::binary);
|
||||
std::wstring convertedPath =
|
||||
std::wstring_convert<std::codecvt_utf8<wchar_t>>().from_bytes(path);
|
||||
result->file = std::make_unique<std::ifstream>(
|
||||
convertedPath, std::ios::in | std::ios::binary);
|
||||
#else
|
||||
result->file = std::make_unique<std::ifstream>(path, std::ios::in | std::ios::binary);
|
||||
result->file =
|
||||
std::make_unique<std::ifstream>(path, std::ios::in | std::ios::binary);
|
||||
#endif
|
||||
|
||||
// result->log.open("log.txt");
|
||||
if (!result->file->is_open())
|
||||
{
|
||||
if (!result->file->is_open()) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
|
|
@ -566,74 +556,61 @@ namespace Slippi
|
|||
// SlippiGame* result = processFile((uint8_t*)&rawData[0], rawDataLength);
|
||||
|
||||
return std::move(result);
|
||||
}
|
||||
}
|
||||
|
||||
bool SlippiGame::IsProcessingComplete()
|
||||
{
|
||||
return isProcessingComplete;
|
||||
}
|
||||
bool SlippiGame::IsProcessingComplete() { return isProcessingComplete; }
|
||||
|
||||
bool SlippiGame::AreSettingsLoaded()
|
||||
{
|
||||
bool SlippiGame::AreSettingsLoaded() {
|
||||
processData();
|
||||
return game->areSettingsLoaded;
|
||||
}
|
||||
}
|
||||
|
||||
bool SlippiGame::DoesFrameExist(int32_t frame)
|
||||
{
|
||||
bool SlippiGame::DoesFrameExist(int32_t frame) {
|
||||
processData();
|
||||
return (bool)game->framesByIndex.count(frame);
|
||||
}
|
||||
return static_cast<bool>(game->framesByIndex.count(frame));
|
||||
}
|
||||
|
||||
std::array<uint8_t, 4> SlippiGame::GetVersion()
|
||||
{
|
||||
return game->version;
|
||||
}
|
||||
std::array<uint8_t, 4> SlippiGame::GetVersion() { return game->version; }
|
||||
|
||||
std::string SlippiGame::GetVersionString()
|
||||
{
|
||||
std::string SlippiGame::GetVersionString() {
|
||||
char version[30];
|
||||
sprintf(version, "%d.%d.%d", game->version[0], game->version[1], game->version[2]);
|
||||
sprintf(version, "%d.%d.%d", game->version[0], game->version[1],
|
||||
game->version[2]);
|
||||
|
||||
return std::string(version);
|
||||
}
|
||||
}
|
||||
|
||||
FrameData* SlippiGame::GetFrame(int32_t frame) {
|
||||
FrameData *SlippiGame::GetFrame(int32_t frame) {
|
||||
// Get the frame we want
|
||||
return game->framesByIndex.at(frame);
|
||||
}
|
||||
}
|
||||
|
||||
FrameData* SlippiGame::GetFrameAt(uint32_t pos)
|
||||
{
|
||||
if (pos >= game->frames.size())
|
||||
{
|
||||
FrameData *SlippiGame::GetFrameAt(uint32_t pos) {
|
||||
if (pos >= game->frames.size()) {
|
||||
return nullptr;
|
||||
}
|
||||
// Get the frame we want
|
||||
return game->frames[pos].get();
|
||||
}
|
||||
}
|
||||
|
||||
int32_t SlippiGame::GetLastFinalizedFrame() {
|
||||
int32_t SlippiGame::GetLastFinalizedFrame() {
|
||||
processData();
|
||||
return game->lastFinalizedFrame;
|
||||
}
|
||||
}
|
||||
|
||||
int32_t SlippiGame::GetLatestIndex() {
|
||||
int32_t SlippiGame::GetLatestIndex() {
|
||||
processData();
|
||||
return game->frameCount;
|
||||
}
|
||||
}
|
||||
|
||||
GameSettings* SlippiGame::GetSettings()
|
||||
{
|
||||
GameSettings *SlippiGame::GetSettings() {
|
||||
processData();
|
||||
return &game->settings;
|
||||
}
|
||||
}
|
||||
|
||||
bool SlippiGame::DoesPlayerExist(int8_t port) {
|
||||
bool SlippiGame::DoesPlayerExist(int8_t port) {
|
||||
return game->settings.players.find(port) != game->settings.players.end();
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t SlippiGame::GetGameEndMethod() {
|
||||
return game->winCondition;
|
||||
}
|
||||
uint8_t SlippiGame::GetGameEndMethod() { return game->winCondition; }
|
||||
} // namespace Slippi
|
||||
|
|
|
|||
116
Externals/SlippiLib/SlippiGame.h
vendored
116
Externals/SlippiLib/SlippiGame.h
vendored
|
|
@ -9,32 +9,33 @@
|
|||
#include <vector>
|
||||
|
||||
namespace Slippi {
|
||||
const uint8_t EVENT_SPLIT_MESSAGE = 0x10;
|
||||
const uint8_t EVENT_PAYLOAD_SIZES = 0x35;
|
||||
const uint8_t EVENT_GAME_INIT = 0x36;
|
||||
const uint8_t EVENT_PRE_FRAME_UPDATE = 0x37;
|
||||
const uint8_t EVENT_POST_FRAME_UPDATE = 0x38;
|
||||
const uint8_t EVENT_GAME_END = 0x39;
|
||||
const uint8_t EVENT_FRAME_START = 0x3A;
|
||||
const uint8_t EVENT_FRAME_END = 0x3C;
|
||||
const uint8_t EVENT_GECKO_LIST = 0x3D;
|
||||
const uint8_t EVENT_SPLIT_MESSAGE = 0x10;
|
||||
const uint8_t EVENT_PAYLOAD_SIZES = 0x35;
|
||||
const uint8_t EVENT_GAME_INIT = 0x36;
|
||||
const uint8_t EVENT_PRE_FRAME_UPDATE = 0x37;
|
||||
const uint8_t EVENT_POST_FRAME_UPDATE = 0x38;
|
||||
const uint8_t EVENT_GAME_END = 0x39;
|
||||
const uint8_t EVENT_FRAME_START = 0x3A;
|
||||
const uint8_t EVENT_FRAME_END = 0x3C;
|
||||
const uint8_t EVENT_GECKO_LIST = 0x3D;
|
||||
|
||||
const uint8_t GAME_INFO_HEADER_SIZE = 78;
|
||||
const uint8_t UCF_TOGGLE_SIZE = 8;
|
||||
const uint8_t NAMETAG_SIZE = 8;
|
||||
const uint8_t DISPLAY_NAME_SIZE = 31;
|
||||
const uint8_t CONNECT_CODE_SIZE = 10;
|
||||
const int32_t GAME_FIRST_FRAME = -123;
|
||||
const int32_t PLAYBACK_FIRST_SAVE = -122;
|
||||
const uint8_t GAME_SHEIK_INTERNAL_ID = 0x7;
|
||||
const uint8_t GAME_SHEIK_EXTERNAL_ID = 0x13;
|
||||
const uint8_t GAME_INFO_HEADER_SIZE = 78;
|
||||
const uint8_t UCF_TOGGLE_SIZE = 8;
|
||||
const uint8_t NAMETAG_SIZE = 8;
|
||||
const uint8_t DISPLAY_NAME_SIZE = 31;
|
||||
const uint8_t CONNECT_CODE_SIZE = 10;
|
||||
const int32_t GAME_FIRST_FRAME = -123;
|
||||
const int32_t PLAYBACK_FIRST_SAVE = -122;
|
||||
const uint8_t GAME_SHEIK_INTERNAL_ID = 0x7;
|
||||
const uint8_t GAME_SHEIK_EXTERNAL_ID = 0x13;
|
||||
|
||||
const uint32_t SPLIT_MESSAGE_INTERNAL_DATA_LEN = 512;
|
||||
const uint32_t SPLIT_MESSAGE_INTERNAL_DATA_LEN = 512;
|
||||
|
||||
static uint8_t* data;
|
||||
static uint8_t *data;
|
||||
|
||||
typedef struct {
|
||||
// Every player update has its own rng seed because it might change in between players
|
||||
typedef struct {
|
||||
// Every player update has its own rng seed because it might change in between
|
||||
// players
|
||||
uint32_t randomSeed;
|
||||
|
||||
uint8_t internalCharacterId;
|
||||
|
|
@ -49,23 +50,25 @@ namespace Slippi {
|
|||
uint8_t comboCount;
|
||||
uint8_t lastHitBy;
|
||||
|
||||
//Controller information
|
||||
// Controller information
|
||||
float joystickX;
|
||||
float joystickY;
|
||||
float cstickX;
|
||||
float cstickY;
|
||||
float trigger;
|
||||
uint32_t buttons; //This will include multiple "buttons" pressed on special buttons. For example I think pressing z sets 3 bits
|
||||
uint32_t buttons; // This will include multiple "buttons" pressed on special
|
||||
// buttons. For example I think pressing z sets 3 bits
|
||||
|
||||
//This is extra controller information
|
||||
uint16_t physicalButtons; //A better representation of what a player is actually pressing
|
||||
// This is extra controller information
|
||||
uint16_t physicalButtons; // A better representation of what a player is
|
||||
// actually pressing
|
||||
float lTrigger;
|
||||
float rTrigger;
|
||||
|
||||
uint8_t joystickXRaw;
|
||||
} PlayerFrameData;
|
||||
} PlayerFrameData;
|
||||
|
||||
typedef struct FrameData {
|
||||
typedef struct FrameData {
|
||||
int32_t frame;
|
||||
uint32_t numSinceStart;
|
||||
bool randomSeedExists = false;
|
||||
|
|
@ -73,10 +76,10 @@ namespace Slippi {
|
|||
bool inputsFullyFetched = false;
|
||||
std::unordered_map<uint8_t, PlayerFrameData> players;
|
||||
std::unordered_map<uint8_t, PlayerFrameData> followers;
|
||||
} FrameData;
|
||||
} FrameData;
|
||||
|
||||
typedef struct {
|
||||
//Static data
|
||||
typedef struct {
|
||||
// Static data
|
||||
uint8_t characterId;
|
||||
uint8_t characterColor;
|
||||
uint8_t playerType;
|
||||
|
|
@ -84,10 +87,10 @@ namespace Slippi {
|
|||
std::array<uint16_t, NAMETAG_SIZE> nametag;
|
||||
std::array<uint8_t, DISPLAY_NAME_SIZE> displayName;
|
||||
std::array<uint8_t, CONNECT_CODE_SIZE> connectCode;
|
||||
} PlayerSettings;
|
||||
} PlayerSettings;
|
||||
|
||||
typedef struct {
|
||||
uint16_t stage; //Stage ID
|
||||
typedef struct {
|
||||
uint16_t stage; // Stage ID
|
||||
uint32_t randomSeed;
|
||||
std::array<uint32_t, GAME_INFO_HEADER_SIZE> header;
|
||||
std::array<uint32_t, UCF_TOGGLE_SIZE> ucfToggles;
|
||||
|
|
@ -97,11 +100,11 @@ namespace Slippi {
|
|||
uint8_t minorScene;
|
||||
uint8_t majorScene;
|
||||
std::vector<uint8_t> geckoCodes;
|
||||
} GameSettings;
|
||||
} GameSettings;
|
||||
|
||||
typedef struct Game {
|
||||
typedef struct Game {
|
||||
std::array<uint8_t, 4> version;
|
||||
std::unordered_map<int32_t, FrameData*> framesByIndex;
|
||||
std::unordered_map<int32_t, FrameData *> framesByIndex;
|
||||
std::vector<std::unique_ptr<FrameData>> frames;
|
||||
GameSettings settings;
|
||||
bool areSettingsLoaded = false;
|
||||
|
|
@ -109,37 +112,36 @@ namespace Slippi {
|
|||
int32_t frameCount; // Current/last frame count
|
||||
int32_t lastFinalizedFrame = -124;
|
||||
|
||||
//From OnGameEnd event
|
||||
// From OnGameEnd event
|
||||
uint8_t winCondition;
|
||||
} Game;
|
||||
} Game;
|
||||
|
||||
// TODO: This shouldn't be static. Doesn't matter too much atm because we always
|
||||
// TODO: only read one file at a time
|
||||
static std::unordered_map<uint8_t, uint32_t> asmEvents = {
|
||||
{ EVENT_GAME_INIT, 320 },
|
||||
{ EVENT_PRE_FRAME_UPDATE, 58 },
|
||||
{ EVENT_POST_FRAME_UPDATE, 33 },
|
||||
{ EVENT_GAME_END, 1 },
|
||||
{ EVENT_FRAME_START, 8 }
|
||||
};
|
||||
// TODO: This shouldn't be static. Doesn't matter too much atm because we always
|
||||
// TODO: only read one file at a time
|
||||
static std::unordered_map<uint8_t, uint32_t> asmEvents = {
|
||||
{EVENT_GAME_INIT, 320},
|
||||
{EVENT_PRE_FRAME_UPDATE, 58},
|
||||
{EVENT_POST_FRAME_UPDATE, 33},
|
||||
{EVENT_GAME_END, 1},
|
||||
{EVENT_FRAME_START, 8}};
|
||||
|
||||
class SlippiGame
|
||||
{
|
||||
public:
|
||||
class SlippiGame {
|
||||
public:
|
||||
static std::unique_ptr<SlippiGame> FromFile(std::string path);
|
||||
bool AreSettingsLoaded();
|
||||
bool DoesFrameExist(int32_t frame);
|
||||
std::array<uint8_t, 4> GetVersion();
|
||||
std::string GetVersionString();
|
||||
FrameData* GetFrame(int32_t frame);
|
||||
FrameData* GetFrameAt(uint32_t pos);
|
||||
FrameData *GetFrame(int32_t frame);
|
||||
FrameData *GetFrameAt(uint32_t pos);
|
||||
int32_t GetLastFinalizedFrame();
|
||||
int32_t GetLatestIndex();
|
||||
GameSettings* GetSettings();
|
||||
GameSettings *GetSettings();
|
||||
uint8_t GetGameEndMethod();
|
||||
bool DoesPlayerExist(int8_t port);
|
||||
bool IsProcessingComplete();
|
||||
private:
|
||||
|
||||
private:
|
||||
std::unique_ptr<Game> game;
|
||||
std::unique_ptr<std::ifstream> file;
|
||||
std::vector<uint8_t> rawData;
|
||||
|
|
@ -150,5 +152,5 @@ namespace Slippi {
|
|||
|
||||
bool isProcessingComplete = false;
|
||||
void processData();
|
||||
};
|
||||
}
|
||||
};
|
||||
} // namespace Slippi
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue