mirrors/dolphin
0
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-08-26 12:16:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

needs_more_snake_case

Browse source
This commit is contained in:
Nikhil Narayana 2023-08-20 13:50:43 -07:00
commit 2757adcbc7
No known key found for this signature in database
GPG key ID: 1B34839FA8D6245E
11 changed files with 359 additions and 353 deletions
Download patch file Download diff file Expand all files Collapse all files

133
Source/Core/Core/HW/EXI/EXI_DeviceSlippi.cpp
View file

@ -314,9 +314,9 @@ void CEXISlippi::configureCommands(u8* payload, u8 length)
for (int i = 1; i < length; i += 3) for (int i = 1; i < length; i += 3)
{ {
// Go through the receive commands payload and set up other commands // Go through the receive commands payload and set up other commands
u8 commandByte = payload[i]; u8 command_byte = payload[i];
u32 commandPayloadSize = payload[i + 1] << 8 | payload[i + 2]; u32 command_payload_size = payload[i + 1] << 8 | payload[i + 2];
payloadSizes[commandByte] = commandPayloadSize; payloadSizes[command_byte] = command_payload_size;
} }
} }
@ -474,6 +474,7 @@ void CEXISlippi::writeToFileAsync(u8* payload, u32 length, std::string file_opti
void CEXISlippi::FileWriteThread(void) void CEXISlippi::FileWriteThread(void)
{ {
Common::SetCurrentThreadName("Slippi File Write");
while (write_thread_running || !file_write_queue.empty()) while (write_thread_running || !file_write_queue.empty())
{ {
// Process all messages // Process all messages
@ -703,14 +704,14 @@ void CEXISlippi::prepareGameInfo(u8* payload)
Slippi::GameSettings* settings = m_current_game->GetSettings(); Slippi::GameSettings* settings = m_current_game->GetSettings();
// Unlikely but reset the overclocking in case we quit during a hard ffw in a previous play // Unlikely but reset the overclocking in case we quit during a hard ffw in a previous play
SConfig::GetSlippiConfig().oc_enable = g_playback_status->origOCEnable; SConfig::GetSlippiConfig().oc_enable = g_playback_status->orig_OC_enable;
SConfig::GetSlippiConfig().oc_factor = g_playback_status->origOCFactor; SConfig::GetSlippiConfig().oc_factor = g_playback_status->orig_OC_factor;
// Start in Fast Forward if this is mirrored // Start in Fast Forward if this is mirrored
auto replay_comm_settings = g_replay_comm->getSettings(); auto replay_comm_settings = g_replay_comm->getSettings();
if (!g_playback_status->isHardFFW) if (!g_playback_status->is_hard_FFW)
g_playback_status->isHardFFW = replay_comm_settings.mode == "mirror"; g_playback_status->is_hard_FFW = replay_comm_settings.mode == "mirror";
g_playback_status->lastFFWFrame = INT_MIN; g_playback_status->last_FFW_frame = INT_MIN;
// Build a word containing the stage and the presence of the characters // Build a word containing the stage and the presence of the characters
u32 random_seed = settings->randomSeed; u32 random_seed = settings->randomSeed;
@ -786,7 +787,7 @@ void CEXISlippi::prepareGameInfo(u8* payload)
m_read_queue.push_back(settings->isFrozenPS); m_read_queue.push_back(settings->isFrozenPS);
// Write should resync setting // Write should resync setting
m_read_queue.push_back(replay_comm_settings.shouldResync ? 1 : 0); m_read_queue.push_back(replay_comm_settings.should_resync ? 1 : 0);
// Write display names // Write display names
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
@ -802,7 +803,7 @@ void CEXISlippi::prepareGameInfo(u8* payload)
// Initialize frame sequence index value for reading rollbacks // Initialize frame sequence index value for reading rollbacks
frame_seq_idx = 0; frame_seq_idx = 0;
if (replay_comm_settings.rollbackDisplayMethod != "off") if (replay_comm_settings.rollback_display_method != "off")
{ {
// Prepare savestates // Prepare savestates
available_savestates.clear(); available_savestates.clear();
@ -825,10 +826,10 @@ void CEXISlippi::prepareGameInfo(u8* payload)
} }
// Reset playback frame to begining // Reset playback frame to begining
g_playback_status->currentPlaybackFrame = Slippi::GAME_FIRST_FRAME; g_playback_status->current_playback_frame = Slippi::GAME_FIRST_FRAME;
// Initialize replay related threads if not viewing rollback versions of relays // Initialize replay related threads if not viewing rollback versions of relays
if (replay_comm_settings.rollbackDisplayMethod == "off" && if (replay_comm_settings.rollback_display_method == "off" &&
(replay_comm_settings.mode == "normal" || replay_comm_settings.mode == "queue")) (replay_comm_settings.mode == "normal" || replay_comm_settings.mode == "queue"))
{ {
// g_playback_status->startThreads(); // g_playback_status->startThreads();
@ -845,7 +846,7 @@ void CEXISlippi::prepareGeckoList()
// Some codes should only be denylisted when not displaying rollbacks, these are codes // Some codes should only be denylisted when not displaying rollbacks, these are codes
// that are required for things to not break when using Slippi savestates. Perhaps this // that are required for things to not break when using Slippi savestates. Perhaps this
// should be handled by actually applying these codes in the playback ASM instead? not sure // should be handled by actually applying these codes in the playback ASM instead? not sure
auto should_deny = replay_comm_settings.rollbackDisplayMethod == "off"; auto should_deny = replay_comm_settings.rollback_display_method == "off";
deny_list[0x8038add0] = should_deny; // Online/Core/PreventFileAlarms/PreventMusicAlarm.asm deny_list[0x8038add0] = should_deny; // Online/Core/PreventFileAlarms/PreventMusicAlarm.asm
deny_list[0x80023FFC] = should_deny; // Online/Core/PreventFileAlarms/MuteMusic.asm deny_list[0x80023FFC] = should_deny; // Online/Core/PreventFileAlarms/MuteMusic.asm
@ -938,19 +939,19 @@ void CEXISlippi::prepareCharacterFrameData(Slippi::FrameData* frame, u8 port, u8
// Add all of the inputs in order // Add all of the inputs in order
appendWordToBuffer(&m_read_queue, data.randomSeed); appendWordToBuffer(&m_read_queue, data.randomSeed);
appendWordToBuffer(&m_read_queue, *(u32*)&data.joystickX); appendWordToBuffer(&m_read_queue, static_cast<u32>(data.joystickX));
appendWordToBuffer(&m_read_queue, *(u32*)&data.joystickY); appendWordToBuffer(&m_read_queue, static_cast<u32>(data.joystickY));
appendWordToBuffer(&m_read_queue, *(u32*)&data.cstickX); appendWordToBuffer(&m_read_queue, static_cast<u32>(data.cstickX));
appendWordToBuffer(&m_read_queue, *(u32*)&data.cstickY); appendWordToBuffer(&m_read_queue, static_cast<u32>(data.cstickY));
appendWordToBuffer(&m_read_queue, *(u32*)&data.trigger); appendWordToBuffer(&m_read_queue, static_cast<u32>(data.trigger));
appendWordToBuffer(&m_read_queue, data.buttons); appendWordToBuffer(&m_read_queue, data.buttons);
appendWordToBuffer(&m_read_queue, *(u32*)&data.locationX); appendWordToBuffer(&m_read_queue, static_cast<u32>(data.locationX));
appendWordToBuffer(&m_read_queue, *(u32*)&data.locationY); appendWordToBuffer(&m_read_queue, static_cast<u32>(data.locationY));
appendWordToBuffer(&m_read_queue, *(u32*)&data.facingDirection); appendWordToBuffer(&m_read_queue, static_cast<u32>(data.facingDirection));
appendWordToBuffer(&m_read_queue, static_cast<u32>(data.animation)); appendWordToBuffer(&m_read_queue, static_cast<u32>(data.animation));
m_read_queue.push_back(data.joystickXRaw); m_read_queue.push_back(data.joystickXRaw);
m_read_queue.push_back(data.joystickYRaw); m_read_queue.push_back(data.joystickYRaw);
appendWordToBuffer(&m_read_queue, *(u32*)&data.percent); appendWordToBuffer(&m_read_queue, static_cast<u32>(data.percent));
// NOTE TO DEV: If you add data here, make sure to increase the size above // NOTE TO DEV: If you add data here, make sure to increase the size above
} }
@ -992,11 +993,11 @@ void CEXISlippi::prepareFrameData(u8* payload)
// Parse input // Parse input
s32 frame_idx = payload[0] << 24 | payload[1] << 16 | payload[2] << 8 | payload[3]; s32 frame_idx = payload[0] << 24 | payload[1] << 16 | payload[2] << 8 | payload[3];
// If loading from queue, move on to the next replay if we have past endFrame // If loading from queue, move on to the next replay if we have past end_frame
auto watch_settings = g_replay_comm->current; auto watch_settings = g_replay_comm->current;
if (frame_idx > watch_settings.endFrame) if (frame_idx > watch_settings.end_frame)
{ {
INFO_LOG_FMT(SLIPPI, "Killing game because we are past endFrame"); INFO_LOG_FMT(SLIPPI, "Killing game because we are past end_frame");
m_read_queue.push_back(FRAME_RESP_TERMINATE); m_read_queue.push_back(FRAME_RESP_TERMINATE);
return; return;
} }
@ -1018,18 +1019,18 @@ void CEXISlippi::prepareFrameData(u8* payload)
// data from this frame. Don't wait until next frame is processing is complete // data from this frame. Don't wait until next frame is processing is complete
// (this is the last frame, in that case) // (this is the last frame, in that case)
auto is_frame_found = m_current_game->DoesFrameExist(frame_idx); auto is_frame_found = m_current_game->DoesFrameExist(frame_idx);
g_playback_status->lastFrame = m_current_game->GetLatestIndex(); g_playback_status->last_frame = m_current_game->GetLatestIndex();
auto is_frame_complete = checkFrameFullyFetched(frame_idx); auto is_frame_complete = checkFrameFullyFetched(frame_idx);
auto is_frame_ready = is_frame_found && (is_processing_complete || is_frame_complete); auto is_frame_ready = is_frame_found && (is_processing_complete || is_frame_complete);
// If there is a startFrame configured, manage the fast-forward flag // If there is a start_frame configured, manage the fast-forward flag
if (watch_settings.startFrame > Slippi::GAME_FIRST_FRAME) if (watch_settings.start_frame > Slippi::GAME_FIRST_FRAME)
{ {
if (frame_idx < watch_settings.startFrame) if (frame_idx < watch_settings.start_frame)
{ {
g_playback_status->setHardFFW(true); g_playback_status->setHardFFW(true);
} }
else if (frame_idx == watch_settings.startFrame) else if (frame_idx == watch_settings.start_frame)
{ {
// TODO: This might disable fast forward on first frame when we dont want to? // TODO: This might disable fast forward on first frame when we dont want to?
g_playback_status->setHardFFW(false); g_playback_status->setHardFFW(false);
@ -1037,11 +1038,11 @@ void CEXISlippi::prepareFrameData(u8* payload)
} }
auto comm_settings = g_replay_comm->getSettings(); auto comm_settings = g_replay_comm->getSettings();
if (comm_settings.rollbackDisplayMethod == "normal") if (comm_settings.rollback_display_method == "normal")
{ {
auto next_frame = m_current_game->GetFrameAt(frame_seq_idx); auto next_frame = m_current_game->GetFrameAt(frame_seq_idx);
bool should_hard_FFW = bool should_hard_FFW =
next_frame && next_frame->frame <= g_playback_status->currentPlaybackFrame; next_frame && next_frame->frame <= g_playback_status->current_playback_frame;
g_playback_status->setHardFFW(should_hard_FFW); g_playback_status->setHardFFW(should_hard_FFW);
if (next_frame) if (next_frame)
@ -1053,26 +1054,26 @@ void CEXISlippi::prepareFrameData(u8* payload)
} }
// If RealTimeMode is enabled, let's trigger fast forwarding under certain conditions // If RealTimeMode is enabled, let's trigger fast forwarding under certain conditions
auto is_far_behind = g_playback_status->lastFrame - frame_idx > 2; auto is_far_behind = g_playback_status->last_frame - frame_idx > 2;
auto is_very_far_behind = g_playback_status->lastFrame - frame_idx > 25; auto is_very_far_behind = g_playback_status->last_frame - frame_idx > 25;
if (is_far_behind && comm_settings.mode == "mirror" && comm_settings.isRealTimeMode) if (is_far_behind && comm_settings.mode == "mirror" && comm_settings.is_real_time_mode)
{ {
g_playback_status->isSoftFFW = true; g_playback_status->is_soft_FFW = true;
// Once isHardFFW has been turned on, do not turn it off with this condition, should // Once is_hard_FFW has been turned on, do not turn it off with this condition, should
// hard FFW to the latest point // hard FFW to the latest point
if (!g_playback_status->isHardFFW) if (!g_playback_status->is_hard_FFW)
g_playback_status->isHardFFW = is_very_far_behind; g_playback_status->is_hard_FFW = is_very_far_behind;
} }
if (g_playback_status->lastFrame == frame_idx) if (g_playback_status->last_frame == frame_idx)
{ {
// The reason to disable fast forwarding here is in hopes // The reason to disable fast forwarding here is in hopes
// of disabling it on the last frame that we have actually received. // of disabling it on the last frame that we have actually received.
// Doing this will allow the rendering logic to run to display the // Doing this will allow the rendering logic to run to display the
// last frame instead of the frame previous to fast forwarding. // last frame instead of the frame previous to fast forwarding.
// Not sure if this fully works with partial frames // Not sure if this fully works with partial frames
g_playback_status->isSoftFFW = false; g_playback_status->is_soft_FFW = false;
g_playback_status->setHardFFW(false); g_playback_status->setHardFFW(false);
} }
@ -1088,7 +1089,7 @@ void CEXISlippi::prepareFrameData(u8* payload)
// Disable fast forward here too... this shouldn't be necessary but better // Disable fast forward here too... this shouldn't be necessary but better
// safe than sorry I guess // safe than sorry I guess
g_playback_status->isSoftFFW = false; g_playback_status->is_soft_FFW = false;
g_playback_status->setHardFFW(false); g_playback_status->setHardFFW(false);
if (request_result_code == FRAME_RESP_TERMINATE) if (request_result_code == FRAME_RESP_TERMINATE)
@ -1103,11 +1104,11 @@ void CEXISlippi::prepareFrameData(u8* payload)
u8 rollback_code = 0; // 0 = not rollback, 1 = rollback, perhaps other options in the future? u8 rollback_code = 0; // 0 = not rollback, 1 = rollback, perhaps other options in the future?
// Increment frame index if greater // Increment frame index if greater
if (frame_idx > g_playback_status->currentPlaybackFrame) if (frame_idx > g_playback_status->current_playback_frame)
{ {
g_playback_status->currentPlaybackFrame = frame_idx; g_playback_status->current_playback_frame = frame_idx;
} }
else if (comm_settings.rollbackDisplayMethod != "off") else if (comm_settings.rollback_display_method != "off")
{ {
rollback_code = 1; rollback_code = 1;
} }
@ -1116,8 +1117,8 @@ void CEXISlippi::prepareFrameData(u8* payload)
if (should_FFW) if (should_FFW)
{ {
WARN_LOG_FMT(SLIPPI, "[Frame {}] FFW frame, behind by: {} frames.", frame_idx, WARN_LOG_FMT(SLIPPI, "[Frame {}] FFW frame, behind by: {} frames.", frame_idx,
g_playback_status->lastFrame - frame_idx); g_playback_status->last_frame - frame_idx);
g_playback_status->lastFFWFrame = frame_idx; g_playback_status->last_FFW_frame = frame_idx;
} }
// Return success code // Return success code
@ -1125,11 +1126,12 @@ void CEXISlippi::prepareFrameData(u8* payload)
// Get frame // Get frame
Slippi::FrameData* frame = m_current_game->GetFrame(frame_idx); Slippi::FrameData* frame = m_current_game->GetFrame(frame_idx);
if (comm_settings.rollbackDisplayMethod != "off") if (comm_settings.rollback_display_method != "off")
{ {
auto previous_frame = m_current_game->GetFrameAt(frame_seq_idx - 1); auto previous_frame = m_current_game->GetFrameAt(frame_seq_idx - 1);
frame = m_current_game->GetFrameAt(frame_seq_idx); frame = m_current_game->GetFrameAt(frame_seq_idx);
// SLIPPITODO: document what is going on here
*(s32*)(&playback_savestate_payload[0]) = Common::swap32(frame->frame); *(s32*)(&playback_savestate_payload[0]) = Common::swap32(frame->frame);
if (previous_frame && frame->frame <= previous_frame->frame) if (previous_frame && frame->frame <= previous_frame->frame)
@ -1157,7 +1159,7 @@ void CEXISlippi::prepareFrameData(u8* payload)
// Add frame rng seed to be restored at priority 0 // Add frame rng seed to be restored at priority 0
u8 rng_result = frame->randomSeedExists ? 1 : 0; u8 rng_result = frame->randomSeedExists ? 1 : 0;
m_read_queue.push_back(rng_result); m_read_queue.push_back(rng_result);
appendWordToBuffer(&m_read_queue, *(u32*)&frame->randomSeed); appendWordToBuffer(&m_read_queue, static_cast<u32>(frame->randomSeed));
// Add frame data for every character // Add frame data for every character
for (u8 port = 0; port < 4; port++) for (u8 port = 0; port < 4; port++)
@ -2034,7 +2036,7 @@ void CEXISlippi::prepareOnlineMatchState()
if (mm_state == SlippiMatchmaking::ProcessState::CONNECTION_SUCCESS) if (mm_state == SlippiMatchmaking::ProcessState::CONNECTION_SUCCESS)
{ {
m_local_player_index = matchmaking->LocalPlayerIndex(); m_local_player_idx = matchmaking->LocalPlayerIndex();
if (!slippi_netplay) if (!slippi_netplay)
{ {
@ -2083,14 +2085,14 @@ void CEXISlippi::prepareOnlineMatchState()
if (remote_player_count == 1) if (remote_player_count == 1)
{ {
auto is_decider = slippi_netplay->IsDecider(); auto is_decider = slippi_netplay->IsDecider();
m_local_player_index = is_decider ? 0 : 1; m_local_player_idx = is_decider ? 0 : 1;
m_remote_player_index = is_decider ? 1 : 0; m_remote_player_idx = is_decider ? 1 : 0;
} }
#endif #endif
auto is_decider = slippi_netplay->IsDecider(); auto is_decider = slippi_netplay->IsDecider();
m_local_player_index = is_decider ? 0 : 1; m_local_player_idx = is_decider ? 0 : 1;
m_remote_player_index = is_decider ? 1 : 0; m_remote_player_idx = is_decider ? 1 : 0;
} }
else else
{ {
@ -2134,8 +2136,8 @@ void CEXISlippi::prepareOnlineMatchState()
m_read_queue.push_back(local_player_ready); // Local player ready m_read_queue.push_back(local_player_ready); // Local player ready
m_read_queue.push_back(remote_players_ready); // Remote players ready m_read_queue.push_back(remote_players_ready); // Remote players ready
m_read_queue.push_back(m_local_player_index); // Local player index m_read_queue.push_back(m_local_player_idx); // Local player index
m_read_queue.push_back(m_remote_player_index); // Remote player index m_read_queue.push_back(m_remote_player_idx); // Remote player index
// Set chat message if any // Set chat message if any
if (slippi_netplay) if (slippi_netplay)
@ -2159,13 +2161,12 @@ void CEXISlippi::prepareOnlineMatchState()
} }
else else
{ {
chat_message_player_idx = m_local_player_index; chat_message_player_idx = m_local_player_idx;
} }
if (is_single_mode || !matchmaking) if (is_single_mode || !matchmaking)
{ {
chat_message_player_idx = chat_message_player_idx = sent_chat_message_id > 0 ? m_local_player_idx : m_remote_player_idx;
sent_chat_message_id > 0 ? m_local_player_index : m_remote_player_index;
} }
// in CSS p1 is always current player and p2 is opponent // in CSS p1 is always current player and p2 is opponent
local_player_name = p1_ame = user_info.display_name; local_player_name = p1_ame = user_info.display_name;
@ -2437,14 +2438,14 @@ void CEXISlippi::prepareOnlineMatchState()
std::vector<std::string> opponent_names = {}; std::vector<std::string> opponent_names = {};
if (matchmaking->RemotePlayerCount() == 1) if (matchmaking->RemotePlayerCount() == 1)
{ {
opponent_names.push_back(matchmaking->GetPlayerName(m_remote_player_index)); opponent_names.push_back(matchmaking->GetPlayerName(m_remote_player_idx));
} }
else else
{ {
int team_idx = online_match_block[0x69 + m_local_player_index * 0x24]; int team_idx = online_match_block[0x69 + m_local_player_idx * 0x24];
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
{ {
if (m_local_player_index == i || online_match_block[0x69 + i * 0x24] == team_idx) if (m_local_player_idx == i || online_match_block[0x69 + i * 0x24] == team_idx)
continue; continue;
opponent_names.push_back(matchmaking->GetPlayerName(i)); opponent_names.push_back(matchmaking->GetPlayerName(i));
@ -2847,8 +2848,8 @@ void CEXISlippi::handleReportGame(const SlippiExiTypes::ReportGameQuery& query)
SlippiMatchmakingOnlinePlayMode online_mode = SlippiMatchmakingOnlinePlayMode online_mode =
static_cast<SlippiMatchmakingOnlinePlayMode>(query.mode); static_cast<SlippiMatchmakingOnlinePlayMode>(query.mode);
u32 duration_frames = query.frame_length; u32 duration_frames = query.frame_length;
u32 game_idx = query.game_index; u32 game_idx = query.game_idx;
u32 tiebreak_idx = query.tiebreak_index; u32 tiebreak_idx = query.tiebreak_idx;
s8 winner_idx = query.winner_idx; s8 winner_idx = query.winner_idx;
int stage_id = Common::FromBigEndian(*(u16*)&query.game_info_block[0xE]); int stage_id = Common::FromBigEndian(*(u16*)&query.game_info_block[0xE]);
u8 game_end_method = query.game_end_method; u8 game_end_method = query.game_end_method;
@ -2904,8 +2905,8 @@ void CEXISlippi::handleReportGame(const SlippiExiTypes::ReportGameQuery& query)
{ {
SlippiSyncedGameState s; SlippiSyncedGameState s;
s.match_id = match_id; s.match_id = match_id;
s.game_index = game_idx; s.game_idx = game_idx;
s.tiebreak_index = tiebreak_idx; s.tiebreak_idx = tiebreak_idx;
s.seconds_remaining = query.synced_timer; s.seconds_remaining = query.synced_timer;
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
{ {

4
Source/Core/Core/HW/EXI/EXI_DeviceSlippi.h
View file

@ -283,8 +283,8 @@ private:
// We put these at the class level to preserve values in the case of a disconnect // We put these at the class level to preserve values in the case of a disconnect
// while loading. Without this, someone could load into a game playing the wrong char // while loading. Without this, someone could load into a game playing the wrong char
u8 m_local_player_index = 0; u8 m_local_player_idx = 0;
u8 m_remote_player_index = 1; u8 m_remote_player_idx = 1;
// Frame skipping variables // Frame skipping variables
int frames_to_skip = 0; int frames_to_skip = 0;

8
Source/Core/Core/Slippi/SlippiExiTypes.h
View file

@ -27,8 +27,8 @@ struct ReportGameQuery
u8 command; u8 command;
u8 mode; u8 mode;
u32 frame_length; u32 frame_length;
u32 game_index; u32 game_idx;
u32 tiebreak_index; u32 tiebreak_idx;
s8 winner_idx; s8 winner_idx;
u8 game_end_method; u8 game_end_method;
s8 lras_initiator; s8 lras_initiator;
@ -119,8 +119,8 @@ inline ReportGameQuery Convert(u8* payload)
{ {
auto q = *reinterpret_cast<ReportGameQuery*>(payload); auto q = *reinterpret_cast<ReportGameQuery*>(payload);
q.frame_length = Common::FromBigEndian(q.frame_length); q.frame_length = Common::FromBigEndian(q.frame_length);
q.game_index = Common::FromBigEndian(q.game_index); q.game_idx = Common::FromBigEndian(q.game_idx);
q.tiebreak_index = Common::FromBigEndian(q.tiebreak_index); q.tiebreak_idx = Common::FromBigEndian(q.tiebreak_idx);
q.synced_timer = Common::FromBigEndian(q.synced_timer); q.synced_timer = Common::FromBigEndian(q.synced_timer);
for (int i = 0; i < REPORT_PLAYER_COUNT; i++) for (int i = 0; i < REPORT_PLAYER_COUNT; i++)
{ {

14
Source/Core/Core/Slippi/SlippiNetplay.cpp
View file

@ -504,8 +504,8 @@ unsigned int SlippiNetplayClient::OnData(sf::Packet& packet, ENetPeer* peer)
SlippiSyncedGameState results; SlippiSyncedGameState results;
packet >> results.match_id; packet >> results.match_id;
packet >> results.game_index; packet >> results.game_idx;
packet >> results.tiebreak_index; packet >> results.tiebreak_idx;
packet >> results.seconds_remaining; packet >> results.seconds_remaining;
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
{ {
@ -515,7 +515,7 @@ unsigned int SlippiNetplayClient::OnData(sf::Packet& packet, ENetPeer* peer)
// ERROR_LOG_FMT(SLIPPI_ONLINE, "Received synced state from opponent. {}, {}, {}, {}. F1: {} // ERROR_LOG_FMT(SLIPPI_ONLINE, "Received synced state from opponent. {}, {}, {}, {}. F1: {}
// ({}%%), F2: {} ({}%%)", // ({}%%), F2: {} ({}%%)",
// results.match_id, results.game_index, results.tiebreak_index, // results.match_id, results.game_idx, results.tiebreak_idx,
// results.seconds_remaining, results.fighters[0].stocks_remaining, // results.seconds_remaining, results.fighters[0].stocks_remaining,
// results.fighters[0].current_health, results.fighters[1].stocks_remaining, // results.fighters[0].current_health, results.fighters[1].stocks_remaining,
// results.fighters[1].current_health); // results.fighters[1].current_health);
@ -1193,8 +1193,8 @@ void SlippiNetplayClient::SendSyncedGameState(SlippiSyncedGameState& s)
*spac << static_cast<u8>(NetPlay::MessageID::SLIPPI_SYNCED_STATE); *spac << static_cast<u8>(NetPlay::MessageID::SLIPPI_SYNCED_STATE);
*spac << this->m_player_idx; *spac << this->m_player_idx;
*spac << s.match_id; *spac << s.match_id;
*spac << s.game_index; *spac << s.game_idx;
*spac << s.tiebreak_index; *spac << s.tiebreak_idx;
*spac << s.seconds_remaining; *spac << s.seconds_remaining;
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
{ {
@ -1454,10 +1454,10 @@ bool SlippiNetplayClient::IsWaitingForDesyncRecovery()
for (int i = 0; i < m_remotePlayerCount; i++) for (int i = 0; i < m_remotePlayerCount; i++)
{ {
if (local_sync_state.game_index != remote_sync_states[i].game_index) if (local_sync_state.game_idx != remote_sync_states[i].game_idx)
return true; return true;
if (local_sync_state.tiebreak_index != remote_sync_states[i].tiebreak_index) if (local_sync_state.tiebreak_idx != remote_sync_states[i].tiebreak_idx)
return true; return true;
} }

4
Source/Core/Core/Slippi/SlippiNetplay.h
View file

@ -58,8 +58,8 @@ struct SlippiSyncedFighterState
struct SlippiSyncedGameState struct SlippiSyncedGameState
{ {
std::string match_id = ""; std::string match_id = "";
u32 game_index = 0; u32 game_idx = 0;
u32 tiebreak_index = 0; u32 tiebreak_idx = 0;
u32 seconds_remaining = 480; u32 seconds_remaining = 480;
SlippiSyncedFighterState fighters[4]; SlippiSyncedFighterState fighters[4];
}; };

294
Source/Core/Core/Slippi/SlippiPlayback.cpp
View file

@ -23,14 +23,14 @@ std::unique_ptr<SlippiPlaybackStatus> g_playback_status;
extern std::unique_ptr<SlippiReplayComm> g_replay_comm; extern std::unique_ptr<SlippiReplayComm> g_replay_comm;
static std::mutex mtx; static std::mutex mtx;
static std::mutex seekMtx; static std::mutex seek_mtx;
static std::mutex ffwMtx; static std::mutex ffw_mtx;
static std::mutex diffMtx; static std::mutex diff_mtx;
static std::unique_lock<std::mutex> processingLock(diffMtx); static std::unique_lock<std::mutex> processing_lock(diff_mtx);
static std::condition_variable condVar; static std::condition_variable cond_var;
static std::condition_variable cv_waitingForTargetFrame; static std::condition_variable cv_waiting_for_target_frame;
static std::condition_variable cv_processingDiff; static std::condition_variable cv_processing_diff;
static std::atomic<int> numDiffsProcessing(0); static std::atomic<int> num_diffs_processing(0);
s32 emod(s32 a, s32 b) s32 emod(s32 a, s32 b)
{ {
@ -39,33 +39,33 @@ s32 emod(s32 a, s32 b)
return r >= 0 ? r : r + std::abs(b); return r >= 0 ? r : r + std::abs(b);
} }
std::string processDiff(std::vector<u8> iState, std::vector<u8> cState) std::string processDiff(std::vector<u8> initial_state, std::vector<u8> curr_state)
{ {
INFO_LOG_FMT(SLIPPI, "Processing diff"); INFO_LOG_FMT(SLIPPI, "Processing diff");
numDiffsProcessing += 1; num_diffs_processing += 1;
cv_processingDiff.notify_one(); cv_processing_diff.notify_one();
std::string diff = std::string(); std::string diff = std::string();
open_vcdiff::VCDiffEncoder encoder((char*)iState.data(), iState.size()); open_vcdiff::VCDiffEncoder encoder((char*)initial_state.data(), initial_state.size());
encoder.Encode((char*)cState.data(), cState.size(), &diff); encoder.Encode((char*)curr_state.data(), curr_state.size(), &diff);
INFO_LOG_FMT(SLIPPI, "done processing"); INFO_LOG_FMT(SLIPPI, "done processing");
numDiffsProcessing -= 1; num_diffs_processing -= 1;
cv_processingDiff.notify_one(); cv_processing_diff.notify_one();
return diff; return diff;
} }
SlippiPlaybackStatus::SlippiPlaybackStatus() SlippiPlaybackStatus::SlippiPlaybackStatus()
{ {
shouldJumpBack = false; should_jump_back = false;
shouldJumpForward = false; should_jump_forward = false;
inSlippiPlayback = false; in_slippi_playback = false;
shouldRunThreads = false; should_run_threads = false;
isHardFFW = false; is_hard_FFW = false;
isSoftFFW = false; is_soft_FFW = false;
lastFFWFrame = INT_MIN; last_FFW_frame = INT_MIN;
currentPlaybackFrame = INT_MIN; current_playback_frame = INT_MIN;
targetFrameNum = INT_MAX; target_frame_num = INT_MAX;
lastFrame = Slippi::PLAYBACK_FIRST_SAVE; last_frame = Slippi::PLAYBACK_FIRST_SAVE;
#ifdef IS_PLAYBACK #ifdef IS_PLAYBACK
// Only generate these if this is a playback configuration. Should this class get initialized at // Only generate these if this is a playback configuration. Should this class get initialized at
// all? // all?
@ -76,61 +76,62 @@ SlippiPlaybackStatus::SlippiPlaybackStatus()
void SlippiPlaybackStatus::startThreads() void SlippiPlaybackStatus::startThreads()
{ {
shouldRunThreads = true; should_run_threads = true;
m_savestateThread = std::thread(&SlippiPlaybackStatus::SavestateThread, this); m_savestate_thread = std::thread(&SlippiPlaybackStatus::SavestateThread, this);
} }
void SlippiPlaybackStatus::prepareSlippiPlayback(s32& frameIndex) void SlippiPlaybackStatus::prepareSlippiPlayback(s32& frame_idx)
{ {
// block if there's too many diffs being processed // block if there's too many diffs being processed
while (shouldRunThreads && numDiffsProcessing > 2) while (should_run_threads && num_diffs_processing > 2)
{ {
INFO_LOG_FMT(SLIPPI, "Processing too many diffs, blocking main process"); INFO_LOG_FMT(SLIPPI, "Processing too many diffs, blocking main process");
cv_processingDiff.wait(processingLock); cv_processing_diff.wait(processing_lock);
} }
// Unblock thread to save a state every interval // Unblock thread to save a state every interval
if (shouldRunThreads && ((currentPlaybackFrame + 122) % FRAME_INTERVAL == 0)) if (should_run_threads && ((current_playback_frame + 122) % FRAME_INTERVAL == 0))
condVar.notify_one(); cond_var.notify_one();
// TODO: figure out why sometimes playback frame increments past targetFrameNum // TODO: figure out why sometimes playback frame increments past target_frame_num
if (inSlippiPlayback && frameIndex >= targetFrameNum) if (in_slippi_playback && frame_idx >= target_frame_num)
{ {
INFO_LOG_FMT(SLIPPI, "Reached frame {}. Target was {}. Unblocking", frameIndex, targetFrameNum); INFO_LOG_FMT(SLIPPI, "Reached frame {}. Target was {}. Unblocking", frame_idx,
cv_waitingForTargetFrame.notify_one(); target_frame_num);
cv_waiting_for_target_frame.notify_one();
} }
} }
void SlippiPlaybackStatus::resetPlayback() void SlippiPlaybackStatus::resetPlayback()
{ {
if (shouldRunThreads) if (should_run_threads)
{ {
shouldRunThreads = false; should_run_threads = false;
if (m_savestateThread.joinable()) if (m_savestate_thread.joinable())
m_savestateThread.detach(); m_savestate_thread.detach();
condVar.notify_one(); // Will allow thread to kill itself cond_var.notify_one(); // Will allow thread to kill itself
futureDiffs.clear(); future_diffs.clear();
futureDiffs.rehash(0); future_diffs.rehash(0);
} }
shouldJumpBack = false; should_jump_back = false;
shouldJumpForward = false; should_jump_forward = false;
isHardFFW = false; is_hard_FFW = false;
isSoftFFW = false; is_soft_FFW = false;
targetFrameNum = INT_MAX; target_frame_num = INT_MAX;
inSlippiPlayback = false; in_slippi_playback = false;
} }
void SlippiPlaybackStatus::processInitialState() void SlippiPlaybackStatus::processInitialState()
{ {
INFO_LOG_FMT(SLIPPI, "saving iState"); INFO_LOG_FMT(SLIPPI, "saving initial_state");
State::SaveToBuffer(iState); State::SaveToBuffer(initial_state);
// The initial save to cState causes a stutter of about 5-10 frames // The initial save to curr_state causes a stutter of about 5-10 frames
// Doing it here to get it out of the way and prevent stutters later // Doing it here to get it out of the way and prevent stutters later
// Subsequent calls to SaveToBuffer for cState take ~1 frame // Subsequent calls to SaveToBuffer for curr_state take ~1 frame
State::SaveToBuffer(cState); State::SaveToBuffer(curr_state);
if (Config::Get(Config::SLIPPI_ENABLE_SEEK)) if (Config::Get(Config::SLIPPI_ENABLE_SEEK))
{ {
Config::SetCurrent(Config::MAIN_SHOW_CURSOR, Config::ShowCursor::Constantly); Config::SetCurrent(Config::MAIN_SHOW_CURSOR, Config::ShowCursor::Constantly);
@ -140,39 +141,40 @@ void SlippiPlaybackStatus::processInitialState()
void SlippiPlaybackStatus::SavestateThread() void SlippiPlaybackStatus::SavestateThread()
{ {
Common::SetCurrentThreadName("Savestate thread"); Common::SetCurrentThreadName("Savestate thread");
std::unique_lock<std::mutex> intervalLock(mtx); std::unique_lock<std::mutex> interval_lock(mtx);
INFO_LOG_FMT(SLIPPI, "Entering savestate thread"); INFO_LOG_FMT(SLIPPI, "Entering savestate thread");
while (shouldRunThreads) while (should_run_threads)
{ {
// Wait to hit one of the intervals // Wait to hit one of the intervals
// Possible while rewinding that we hit this wait again. // Possible while rewinding that we hit this wait again.
while (shouldRunThreads && while (should_run_threads &&
(currentPlaybackFrame - Slippi::PLAYBACK_FIRST_SAVE) % FRAME_INTERVAL != 0) (current_playback_frame - Slippi::PLAYBACK_FIRST_SAVE) % FRAME_INTERVAL != 0)
condVar.wait(intervalLock); cond_var.wait(interval_lock);
if (!shouldRunThreads) if (!should_run_threads)
break; break;
s32 fixedFrameNumber = currentPlaybackFrame; s32 fixed_frame_num = current_playback_frame;
if (fixedFrameNumber == INT_MAX) if (fixed_frame_num == INT_MAX)
continue; continue;
bool isStartFrame = fixedFrameNumber == Slippi::PLAYBACK_FIRST_SAVE; bool is_start_frame = fixed_frame_num == Slippi::PLAYBACK_FIRST_SAVE;
bool hasStateBeenProcessed = futureDiffs.count(fixedFrameNumber) > 0; bool has_state_been_processed = future_diffs.count(fixed_frame_num) > 0;
if (!inSlippiPlayback && isStartFrame) if (!in_slippi_playback && is_start_frame)
{ {
processInitialState(); processInitialState();
inSlippiPlayback = true; in_slippi_playback = true;
} }
else if (Config::Get(Config::SLIPPI_ENABLE_SEEK) && !hasStateBeenProcessed && !isStartFrame) else if (Config::Get(Config::SLIPPI_ENABLE_SEEK) && !has_state_been_processed &&
!is_start_frame)
{ {
INFO_LOG_FMT(SLIPPI, "saving diff at frame: {}", fixedFrameNumber); INFO_LOG_FMT(SLIPPI, "saving diff at frame: {}", fixed_frame_num);
State::SaveToBuffer(cState); State::SaveToBuffer(curr_state);
futureDiffs[fixedFrameNumber] = std::async(processDiff, iState, cState); future_diffs[fixed_frame_num] = std::async(processDiff, initial_state, curr_state);
} }
Common::SleepCurrentThread(SLEEP_TIME_MS); Common::SleepCurrentThread(SLEEP_TIME_MS);
} }
@ -182,82 +184,82 @@ void SlippiPlaybackStatus::SavestateThread()
void SlippiPlaybackStatus::seekToFrame() void SlippiPlaybackStatus::seekToFrame()
{ {
if (seekMtx.try_lock()) if (seek_mtx.try_lock())
{ {
if (targetFrameNum < Slippi::PLAYBACK_FIRST_SAVE) if (target_frame_num < Slippi::PLAYBACK_FIRST_SAVE)
targetFrameNum = Slippi::PLAYBACK_FIRST_SAVE; target_frame_num = Slippi::PLAYBACK_FIRST_SAVE;
if (targetFrameNum > lastFrame) if (target_frame_num > last_frame)
{ {
targetFrameNum = lastFrame; target_frame_num = last_frame;
} }
std::unique_lock<std::mutex> ffwLock(ffwMtx); std::unique_lock<std::mutex> ffw_lock(ffw_mtx);
auto replayCommSettings = g_replay_comm->getSettings(); auto replay_comm_settings = g_replay_comm->getSettings();
if (replayCommSettings.mode == "queue") if (replay_comm_settings.mode == "queue")
updateWatchSettingsStartEnd(); updateWatchSettingsStartEnd();
auto prevState = Core::GetState(); auto prev_state = Core::GetState();
if (prevState != Core::State::Paused) if (prev_state != Core::State::Paused)
Core::SetState(Core::State::Paused); Core::SetState(Core::State::Paused);
s32 closestStateFrame = s32 closest_state_frame =
targetFrameNum - emod(targetFrameNum - Slippi::PLAYBACK_FIRST_SAVE, FRAME_INTERVAL); target_frame_num - emod(target_frame_num - Slippi::PLAYBACK_FIRST_SAVE, FRAME_INTERVAL);
bool isLoadingStateOptimal = bool is_loading_state_optimal =
targetFrameNum < currentPlaybackFrame || closestStateFrame > currentPlaybackFrame; target_frame_num < current_playback_frame || closest_state_frame > current_playback_frame;
if (isLoadingStateOptimal) if (is_loading_state_optimal)
{ {
if (closestStateFrame <= Slippi::PLAYBACK_FIRST_SAVE) if (closest_state_frame <= Slippi::PLAYBACK_FIRST_SAVE)
{ {
State::LoadFromBuffer(iState); State::LoadFromBuffer(initial_state);
} }
else else
{ {
// If this diff exists, load it // If this diff exists, load it
if (futureDiffs.count(closestStateFrame) > 0) if (future_diffs.count(closest_state_frame) > 0)
{ {
loadState(closestStateFrame); loadState(closest_state_frame);
} }
else if (targetFrameNum < currentPlaybackFrame) else if (target_frame_num < current_playback_frame)
{ {
s32 closestActualStateFrame = closestStateFrame - FRAME_INTERVAL; s32 closest_actual_state_frame = closest_state_frame - FRAME_INTERVAL;
while (closestActualStateFrame > Slippi::PLAYBACK_FIRST_SAVE && while (closest_actual_state_frame > Slippi::PLAYBACK_FIRST_SAVE &&
futureDiffs.count(closestActualStateFrame) == 0) future_diffs.count(closest_actual_state_frame) == 0)
closestActualStateFrame -= FRAME_INTERVAL; closest_actual_state_frame -= FRAME_INTERVAL;
loadState(closestActualStateFrame); loadState(closest_actual_state_frame);
} }
else if (targetFrameNum > currentPlaybackFrame) else if (target_frame_num > current_playback_frame)
{ {
s32 closestActualStateFrame = closestStateFrame - FRAME_INTERVAL; s32 closest_actual_state_frame = closest_state_frame - FRAME_INTERVAL;
while (closestActualStateFrame > currentPlaybackFrame && while (closest_actual_state_frame > current_playback_frame &&
futureDiffs.count(closestActualStateFrame) == 0) future_diffs.count(closest_actual_state_frame) == 0)
closestActualStateFrame -= FRAME_INTERVAL; closest_actual_state_frame -= FRAME_INTERVAL;
// only load a savestate if we find one past our current frame since we are seeking // only load a savestate if we find one past our current frame since we are seeking
// forwards // forwards
if (closestActualStateFrame > currentPlaybackFrame) if (closest_actual_state_frame > current_playback_frame)
loadState(closestActualStateFrame); loadState(closest_actual_state_frame);
} }
} }
} }
// Fastforward until we get to the frame we want // Fastforward until we get to the frame we want
if (targetFrameNum != closestStateFrame && targetFrameNum != lastFrame) if (target_frame_num != closest_state_frame && target_frame_num != last_frame)
{ {
setHardFFW(true); setHardFFW(true);
Core::SetState(Core::State::Running); Core::SetState(Core::State::Running);
cv_waitingForTargetFrame.wait(ffwLock); cv_waiting_for_target_frame.wait(ffw_lock);
Core::SetState(Core::State::Paused); Core::SetState(Core::State::Paused);
setHardFFW(false); setHardFFW(false);
} }
// We've reached the frame we want. Reset targetFrameNum and release mutex so another seek can // We've reached the frame we want. Reset target_frame_num and release mutex so another seek can
// be performed // be performed
g_playback_status->currentPlaybackFrame = targetFrameNum; g_playback_status->current_playback_frame = target_frame_num;
targetFrameNum = INT_MAX; target_frame_num = INT_MAX;
Core::SetState(prevState); Core::SetState(prev_state);
seekMtx.unlock(); seek_mtx.unlock();
} }
else else
{ {
@ -265,7 +267,7 @@ void SlippiPlaybackStatus::seekToFrame()
} }
} }
// Set isHardFFW and update OC settings to speed up the FFW // Set is_hard_FFW and update OC settings to speed up the FFW
void SlippiPlaybackStatus::setHardFFW(bool enable) void SlippiPlaybackStatus::setHardFFW(bool enable)
{ {
if (enable) if (enable)
@ -275,36 +277,36 @@ void SlippiPlaybackStatus::setHardFFW(bool enable)
} }
else else
{ {
SConfig::GetSlippiConfig().oc_factor = origOCFactor; SConfig::GetSlippiConfig().oc_factor = orig_OC_factor;
SConfig::GetSlippiConfig().oc_enable = origOCEnable; SConfig::GetSlippiConfig().oc_enable = orig_OC_enable;
} }
isHardFFW = enable; is_hard_FFW = enable;
} }
void SlippiPlaybackStatus::loadState(s32 closestStateFrame) void SlippiPlaybackStatus::loadState(s32 closest_state_frame)
{ {
if (closestStateFrame == Slippi::PLAYBACK_FIRST_SAVE) if (closest_state_frame == Slippi::PLAYBACK_FIRST_SAVE)
State::LoadFromBuffer(iState); State::LoadFromBuffer(initial_state);
else else
{ {
std::string stateString; std::string state_string;
decoder.Decode((char*)iState.data(), iState.size(), futureDiffs[closestStateFrame].get(), decoder.Decode((char*)initial_state.data(), initial_state.size(),
&stateString); future_diffs[closest_state_frame].get(), &state_string);
std::vector<u8> stateToLoad(stateString.begin(), stateString.end()); std::vector<u8> state_to_load(state_string.begin(), state_string.end());
State::LoadFromBuffer(stateToLoad); State::LoadFromBuffer(state_to_load);
} }
} }
bool SlippiPlaybackStatus::shouldFFWFrame(s32 frameIndex) const bool SlippiPlaybackStatus::shouldFFWFrame(s32 frame_idx) const
{ {
if (!isSoftFFW && !isHardFFW) if (!is_soft_FFW && !is_hard_FFW)
{ {
// If no FFW at all, don't FFW this frame // If no FFW at all, don't FFW this frame
return false; return false;
} }
if (isHardFFW) if (is_hard_FFW)
{ {
// For a hard FFW, always FFW until it's turned off // For a hard FFW, always FFW until it's turned off
return true; return true;
@ -312,30 +314,30 @@ bool SlippiPlaybackStatus::shouldFFWFrame(s32 frameIndex) const
// Here we have a soft FFW, we only want to turn on FFW for single frames once // Here we have a soft FFW, we only want to turn on FFW for single frames once
// every X frames to FFW in a more smooth manner // every X frames to FFW in a more smooth manner
return (frameIndex - lastFFWFrame) >= 15; return (frame_idx - last_FFW_frame) >= 15;
} }
void SlippiPlaybackStatus::updateWatchSettingsStartEnd() void SlippiPlaybackStatus::updateWatchSettingsStartEnd()
{ {
int startFrame = g_replay_comm->current.startFrame; int start_frame = g_replay_comm->current.start_frame;
int endFrame = g_replay_comm->current.endFrame; int end_frame = g_replay_comm->current.end_frame;
if (startFrame != Slippi::GAME_FIRST_FRAME || endFrame != INT_MAX) if (start_frame != Slippi::GAME_FIRST_FRAME || end_frame != INT_MAX)
{ {
if (g_playback_status->targetFrameNum < startFrame) if (g_playback_status->target_frame_num < start_frame)
g_replay_comm->current.startFrame = g_playback_status->targetFrameNum; g_replay_comm->current.start_frame = g_playback_status->target_frame_num;
if (g_playback_status->targetFrameNum > endFrame) if (g_playback_status->target_frame_num > end_frame)
g_replay_comm->current.endFrame = INT_MAX; g_replay_comm->current.end_frame = INT_MAX;
} }
} }
std::unordered_map<u32, bool> SlippiPlaybackStatus::getDenylist() std::unordered_map<u32, bool> SlippiPlaybackStatus::getDenylist()
{ {
return denylist; return deny_list;
} }
std::vector<u8> SlippiPlaybackStatus::getLegacyCodelist() std::vector<u8> SlippiPlaybackStatus::getLegacyCodelist()
{ {
return legacyCodelist; return legacy_code_list;
} }
inline std::string readString(json obj, std::string key) inline std::string readString(json obj, std::string key)
@ -378,10 +380,10 @@ bool compareInjectionList(File::FSTEntry i1, File::FSTEntry i2)
void SlippiPlaybackStatus::generateDenylist() void SlippiPlaybackStatus::generateDenylist()
{ {
// We start by populating the denylist with old injections that are not longer used but need // We start by populating the deny_list with old injections that are not longer used but need
// to be included for backward compatibility reasons. // to be included for backward compatibility reasons.
// It also includes some common codes that are not in our codebase // It also includes some common codes that are not in our codebase
denylist = { deny_list = {
// Backward compatibility // Backward compatibility
// Post 3.4.0: Recording/FlushFrameBuffer.asm // Post 3.4.0: Recording/FlushFrameBuffer.asm
{0x802fef88, true}, {0x802fef88, true},
@ -450,30 +452,30 @@ void SlippiPlaybackStatus::generateDenylist()
} }
// Check if tags indicate that this code affects gameplay, if so, do not put it on the // Check if tags indicate that this code affects gameplay, if so, do not put it on the
// denylist // deny_list
auto tags = readString(injection, "Tags"); auto tags = readString(injection, "Tags");
bool shouldDeny = tags.find("[affects-gameplay]") == std::string::npos; bool should_deny = tags.find("[affects-gameplay]") == std::string::npos;
// Add injection to denylist // Add injection to deny_list
u32 address; u32 address;
auto addressStr = readString(injection, "InjectionAddress"); auto address_str = readString(injection, "InjectionAddress");
if (Common::FromChars(addressStr, address, 16).ec != std::errc{}) if (Common::FromChars(address_str, address, 16).ec != std::errc{})
{ {
ERROR_LOG_FMT(SLIPPI, "Injection list file {}: Could not parse address: {}", ERROR_LOG_FMT(SLIPPI, "Injection list file {}: Could not parse address: {}",
entry.physicalName, addressStr); entry.physicalName, address_str);
continue; continue;
} }
denylist[address] = shouldDeny; deny_list[address] = should_deny;
// INFO_LOG(SLIPPI, "New denylist entry: %08X", address); // INFO_LOG(SLIPPI, "New deny_list entry: %08X", address);
} }
} }
NOTICE_LOG_FMT(SLIPPI, "Denylist populated with length: {}", denylist.size()); NOTICE_LOG_FMT(SLIPPI, "Denylist populated with length: {}", deny_list.size());
} }
void SlippiPlaybackStatus::generateLegacyCodelist() void SlippiPlaybackStatus::generateLegacyCodelist()
{ {
legacyCodelist = { legacy_code_list = {
0xC2, 0x0C, 0x9A, 0x44, 0x00, 0x00, 0x00, 0xC2, 0x0C, 0x9A, 0x44, 0x00, 0x00, 0x00,
0x2F, // #External/UCF + Arduino Toggle UI/UCF/UCF 0.74 0x2F, // #External/UCF + Arduino Toggle UI/UCF/UCF 0.74
// Dashback - Check for Toggle.asm // Dashback - Check for Toggle.asm

42
Source/Core/Core/Slippi/SlippiPlayback.h
View file

@ -18,26 +18,26 @@ public:
SlippiPlaybackStatus(); SlippiPlaybackStatus();
~SlippiPlaybackStatus(); ~SlippiPlaybackStatus();
bool shouldJumpBack = false; bool should_jump_back = false;
bool shouldJumpForward = false; bool should_jump_forward = false;
bool inSlippiPlayback = false; bool in_slippi_playback = false;
volatile bool shouldRunThreads = false; volatile bool should_run_threads = false;
bool isHardFFW = false; bool is_hard_FFW = false;
bool isSoftFFW = false; bool is_soft_FFW = false;
bool origOCEnable = SConfig::GetSlippiConfig().oc_enable; bool orig_OC_enable = SConfig::GetSlippiConfig().oc_enable;
float origOCFactor = SConfig::GetSlippiConfig().oc_factor; float orig_OC_factor = SConfig::GetSlippiConfig().oc_factor;
s32 lastFFWFrame = INT_MIN; s32 last_FFW_frame = INT_MIN;
s32 currentPlaybackFrame = INT_MIN; s32 current_playback_frame = INT_MIN;
s32 targetFrameNum = INT_MAX; s32 target_frame_num = INT_MAX;
s32 lastFrame = Slippi::PLAYBACK_FIRST_SAVE; s32 last_frame = Slippi::PLAYBACK_FIRST_SAVE;
std::thread m_savestateThread; std::thread m_savestate_thread;
void startThreads(void); void startThreads(void);
void resetPlayback(void); void resetPlayback(void);
bool shouldFFWFrame(s32 frameIndex) const; bool shouldFFWFrame(s32 frame_idx) const;
void prepareSlippiPlayback(s32& frameIndex); void prepareSlippiPlayback(s32& frame_idx);
void setHardFFW(bool enable); void setHardFFW(bool enable);
std::unordered_map<u32, bool> getDenylist(); std::unordered_map<u32, bool> getDenylist();
std::vector<u8> getLegacyCodelist(); std::vector<u8> getLegacyCodelist();
@ -45,19 +45,19 @@ public:
private: private:
void SavestateThread(void); void SavestateThread(void);
void loadState(s32 closestStateFrame); void loadState(s32 closest_state_frame);
void processInitialState(); void processInitialState();
void updateWatchSettingsStartEnd(); void updateWatchSettingsStartEnd();
void generateDenylist(); void generateDenylist();
void generateLegacyCodelist(); void generateLegacyCodelist();
std::unordered_map<int32_t, std::shared_future<std::string>> std::unordered_map<int32_t, std::shared_future<std::string>>
futureDiffs; // State diffs keyed by frameIndex, processed async future_diffs; // State diffs keyed by frame_idx, processed async
std::vector<u8> iState; // The initial state std::vector<u8> initial_state; // The initial state
std::vector<u8> cState; // The current (latest) state std::vector<u8> curr_state; // The current (latest) state
std::unordered_map<u32, bool> denylist; std::unordered_map<u32, bool> deny_list;
std::vector<u8> legacyCodelist; std::vector<u8> legacy_code_list;
open_vcdiff::VCDiffDecoder decoder; open_vcdiff::VCDiffDecoder decoder;
open_vcdiff::VCDiffEncoder* encoder = NULL; open_vcdiff::VCDiffEncoder* encoder = NULL;

121
Source/Core/Core/Slippi/SlippiReplayComm.cpp
View file

@ -1,11 +1,17 @@
#include "SlippiReplayComm.h" #include "SlippiReplayComm.h"
#include <cctype> #include <cctype>
#include <memory> #include <memory>
#include "Common/CommonPaths.h" #include "Common/CommonPaths.h"
#include "Common/FileUtil.h" #include "Common/FileUtil.h"
#include "Common/Logging/LogManager.h" #include "Common/Logging/LogManager.h"
#include "Core/ConfigManager.h" #include "Core/ConfigManager.h"
#include <nlohmann/json.hpp>
using json = nlohmann::json;
std::unique_ptr<SlippiReplayComm> g_replay_comm; std::unique_ptr<SlippiReplayComm> g_replay_comm;
// https://stackoverflow.com/questions/216823/whats-the-best-way-to-trim-stdstring // https://stackoverflow.com/questions/216823/whats-the-best-way-to-trim-stdstring
@ -33,7 +39,7 @@ SlippiReplayComm::SlippiReplayComm()
{ {
INFO_LOG_FMT(EXPANSIONINTERFACE, "SlippiReplayComm: Using playback config path: {}", INFO_LOG_FMT(EXPANSIONINTERFACE, "SlippiReplayComm: Using playback config path: {}",
SConfig::GetSlippiConfig().slippi_input); SConfig::GetSlippiConfig().slippi_input);
configFilePath = SConfig::GetSlippiConfig().slippi_input; config_file_path = SConfig::GetSlippiConfig().slippi_input;
} }
SlippiReplayComm::~SlippiReplayComm() SlippiReplayComm::~SlippiReplayComm()
@ -42,16 +48,16 @@ SlippiReplayComm::~SlippiReplayComm()
SlippiReplayComm::CommSettings SlippiReplayComm::getSettings() SlippiReplayComm::CommSettings SlippiReplayComm::getSettings()
{ {
return commFileSettings; return comm_file_settings;
} }
std::string SlippiReplayComm::getReplayPath() std::string SlippiReplayComm::getReplayPath()
{ {
std::string replayFilePath = commFileSettings.replayPath; std::string replayFilePath = comm_file_settings.replay_path;
if (commFileSettings.mode == "queue") if (comm_file_settings.mode == "queue")
{ {
// If we are in queue mode, let's grab the replay from the queue instead // If we are in queue mode, let's grab the replay from the queue instead
replayFilePath = commFileSettings.queue.empty() ? "" : commFileSettings.queue.front().path; replayFilePath = comm_file_settings.queue.empty() ? "" : comm_file_settings.queue.front().path;
} }
return replayFilePath; return replayFilePath;
@ -62,21 +68,21 @@ bool SlippiReplayComm::isNewReplay()
loadFile(); loadFile();
std::string replayFilePath = getReplayPath(); std::string replayFilePath = getReplayPath();
bool hasPathChanged = replayFilePath != previousReplayLoaded; bool hasPathChanged = replayFilePath != previous_replay_loaded;
bool isReplay = !!replayFilePath.length(); bool isReplay = !!replayFilePath.length();
// The previous check is mostly good enough but it does not // The previous check is mostly good enough but it does not
// work if someone tries to load the same replay twice in a row // work if someone tries to load the same replay twice in a row
// the commandId was added to deal with this // the command_id was added to deal with this
bool hasCommandChanged = commFileSettings.commandId != previousCommandId; bool hasCommandChanged = comm_file_settings.command_id != previous_command_id;
// This checks if the queue index has changed, this is to fix the // This checks if the queue index has changed, this is to fix the
// issue where the same replay showing up twice in a row in a // issue where the same replay showing up twice in a row in a
// queue would never cause this function to return true // queue would never cause this function to return true
bool hasQueueIdxChanged = false; bool hasQueueIdxChanged = false;
if (commFileSettings.mode == "queue" && !commFileSettings.queue.empty()) if (comm_file_settings.mode == "queue" && !comm_file_settings.queue.empty())
{ {
hasQueueIdxChanged = commFileSettings.queue.front().index != previousIndex; hasQueueIdxChanged = comm_file_settings.queue.front().index != previous_idx;
} }
bool isNewReplay = hasPathChanged || hasCommandChanged || hasQueueIdxChanged; bool isNewReplay = hasPathChanged || hasCommandChanged || hasQueueIdxChanged;
@ -86,11 +92,11 @@ bool SlippiReplayComm::isNewReplay()
void SlippiReplayComm::nextReplay() void SlippiReplayComm::nextReplay()
{ {
if (commFileSettings.queue.empty()) if (comm_file_settings.queue.empty())
return; return;
// Increment queue position // Increment queue position
commFileSettings.queue.pop(); comm_file_settings.queue.pop();
} }
std::unique_ptr<Slippi::SlippiGame> SlippiReplayComm::loadGame() std::unique_ptr<Slippi::SlippiGame> SlippiReplayComm::loadGame()
@ -105,27 +111,27 @@ std::unique_ptr<Slippi::SlippiGame> SlippiReplayComm::loadGame()
// file did not exist yet, result will be falsy, which will keep // file did not exist yet, result will be falsy, which will keep
// the replay considered new so that the file will attempt to be // the replay considered new so that the file will attempt to be
// loaded again // loaded again
previousReplayLoaded = replayFilePath; previous_replay_loaded = replayFilePath;
previousCommandId = commFileSettings.commandId; previous_command_id = comm_file_settings.command_id;
if (commFileSettings.mode == "queue" && !commFileSettings.queue.empty()) if (comm_file_settings.mode == "queue" && !comm_file_settings.queue.empty())
{ {
previousIndex = commFileSettings.queue.front().index; previous_idx = comm_file_settings.queue.front().index;
} }
WatchSettings ws; WatchSettings ws;
ws.path = replayFilePath; ws.path = replayFilePath;
ws.startFrame = commFileSettings.startFrame; ws.start_frame = comm_file_settings.start_frame;
ws.endFrame = commFileSettings.endFrame; ws.end_frame = comm_file_settings.end_frame;
if (commFileSettings.mode == "queue") if (comm_file_settings.mode == "queue")
{ {
ws = commFileSettings.queue.front(); ws = comm_file_settings.queue.front();
} }
if (commFileSettings.outputOverlayFiles) if (comm_file_settings.output_overlay_files)
{ {
std::string dirpath = File::GetExeDirectory(); std::string dirpath = File::GetExeDirectory();
File::WriteStringToFile(dirpath + DIR_SEP + "Slippi/out-station.txt", ws.gameStation); File::WriteStringToFile(dirpath + DIR_SEP + "Slippi/out-station.txt", ws.game_station);
File::WriteStringToFile(dirpath + DIR_SEP + "Slippi/out-time.txt", ws.gameStartAt); File::WriteStringToFile(dirpath + DIR_SEP + "Slippi/out-time.txt", ws.game_start_at);
} }
current = ws; current = ws;
@ -139,43 +145,44 @@ void SlippiReplayComm::loadFile()
// TODO: Consider even only checking file mod time every 250 ms or something? Not sure // TODO: Consider even only checking file mod time every 250 ms or something? Not sure
// TODO: what the perf impact is atm // TODO: what the perf impact is atm
u64 modTime = File::GetFileModTime(configFilePath); u64 modTime = File::GetFileModTime(config_file_path);
if (modTime != 0 && modTime == configLastLoadModTime) if (modTime != 0 && modTime == config_last_load_mod_time)
{ {
// TODO: Maybe be smarter than just using mod time? Look for other things that would // TODO: Maybe be smarter than just using mod time? Look for other things that would
// TODO: indicate that file has changed and needs to be reloaded? // TODO: indicate that file has changed and needs to be reloaded?
return; return;
} }
WARN_LOG_FMT(EXPANSIONINTERFACE, "File change detected in comm file: {}", configFilePath.c_str()); WARN_LOG_FMT(EXPANSIONINTERFACE, "File change detected in comm file: {}",
configLastLoadModTime = modTime; config_file_path.c_str());
config_last_load_mod_time = modTime;
// TODO: Maybe load file in a more intelligent way to save // TODO: Maybe load file in a more intelligent way to save
// TODO: file operations // TODO: file operations
std::string commFileContents; std::string commFileContents;
File::ReadFileToString(configFilePath, commFileContents); File::ReadFileToString(config_file_path, commFileContents);
auto res = json::parse(commFileContents, nullptr, false); auto res = json::parse(commFileContents, nullptr, false);
if (res.is_discarded() || !res.is_object()) if (res.is_discarded() || !res.is_object())
{ {
// Happens if there is a parse error, I think? // Happens if there is a parse error, I think?
commFileSettings.mode = "normal"; comm_file_settings.mode = "normal";
commFileSettings.replayPath = ""; comm_file_settings.replay_path = "";
commFileSettings.startFrame = Slippi::GAME_FIRST_FRAME; comm_file_settings.start_frame = Slippi::GAME_FIRST_FRAME;
commFileSettings.endFrame = INT_MAX; comm_file_settings.end_frame = INT_MAX;
commFileSettings.commandId = ""; comm_file_settings.command_id = "";
commFileSettings.outputOverlayFiles = false; comm_file_settings.output_overlay_files = false;
commFileSettings.isRealTimeMode = false; comm_file_settings.is_real_time_mode = false;
commFileSettings.shouldResync = true; comm_file_settings.should_resync = true;
commFileSettings.rollbackDisplayMethod = "off"; comm_file_settings.rollback_display_method = "off";
if (res.is_string()) if (res.is_string())
{ {
// If we have a string, let's use that as the replayPath // If we have a string, let's use that as the replay_path
// This is really only here because when developing it might be easier // This is really only here because when developing it might be easier
// to just throw in a string instead of an object // to just throw in a string instead of an object
commFileSettings.replayPath = res.get<std::string>(); comm_file_settings.replay_path = res.get<std::string>();
} }
else else
{ {
@ -183,44 +190,44 @@ void SlippiReplayComm::loadFile()
// Reset in the case of read error. this fixes a race condition where file mod time changes // Reset in the case of read error. this fixes a race condition where file mod time changes
// but the file is not readable yet? // but the file is not readable yet?
configLastLoadModTime = 0; config_last_load_mod_time = 0;
} }
return; return;
} }
// TODO: Support file with only path string // TODO: Support file with only path string
commFileSettings.mode = res.value("mode", "normal"); comm_file_settings.mode = res.value("mode", "normal");
commFileSettings.replayPath = res.value("replay", ""); comm_file_settings.replay_path = res.value("replay", "");
commFileSettings.startFrame = res.value("startFrame", Slippi::GAME_FIRST_FRAME); comm_file_settings.start_frame = res.value("startFrame", Slippi::GAME_FIRST_FRAME);
commFileSettings.endFrame = res.value("endFrame", INT_MAX); comm_file_settings.end_frame = res.value("endFrame", INT_MAX);
commFileSettings.commandId = res.value("commandId", ""); comm_file_settings.command_id = res.value("commandId", "");
commFileSettings.outputOverlayFiles = res.value("outputOverlayFiles", false); comm_file_settings.output_overlay_files = res.value("outputOverlayFiles", false);
commFileSettings.isRealTimeMode = res.value("isRealTimeMode", false); comm_file_settings.is_real_time_mode = res.value("isRealTimeMode", false);
commFileSettings.shouldResync = res.value("shouldResync", true); comm_file_settings.should_resync = res.value("shouldResync", true);
commFileSettings.rollbackDisplayMethod = res.value("rollbackDisplayMethod", "off"); comm_file_settings.rollback_display_method = res.value("rollbackDisplayMethod", "off");
if (commFileSettings.mode == "queue") if (comm_file_settings.mode == "queue")
{ {
auto queue = res["queue"]; auto queue = res["queue"];
if (queue.is_array()) if (queue.is_array())
{ {
std::queue<WatchSettings>().swap(commFileSettings.queue); std::queue<WatchSettings>().swap(comm_file_settings.queue);
int index = 0; int index = 0;
for (json::iterator it = queue.begin(); it != queue.end(); ++it) for (json::iterator it = queue.begin(); it != queue.end(); ++it)
{ {
json el = *it; json el = *it;
WatchSettings w = {}; WatchSettings w = {};
w.path = el.value("path", ""); w.path = el.value("path", "");
w.startFrame = el.value("startFrame", Slippi::GAME_FIRST_FRAME); w.start_frame = el.value("startFrame", Slippi::GAME_FIRST_FRAME);
w.endFrame = el.value("endFrame", INT_MAX); w.end_frame = el.value("endFrame", INT_MAX);
w.gameStartAt = el.value("gameStartAt", ""); w.game_start_at = el.value("gameStartAt", "");
w.gameStation = el.value("gameStation", ""); w.game_station = el.value("gameStation", "");
w.index = index++; w.index = index++;
commFileSettings.queue.push(w); comm_file_settings.queue.push(w);
}; };
queueWasEmpty = false; queue_was_empty = false;
} }
} }
} }

42
Source/Core/Core/Slippi/SlippiReplayComm.h
View file

@ -1,7 +1,6 @@
#pragma once #pragma once
#include <limits.h> #include <limits.h>
#include <nlohmann/json.hpp>
#include <queue> #include <queue>
#include <string> #include <string>
@ -9,18 +8,16 @@
#include "SlippiGame.h" #include "SlippiGame.h"
using json = nlohmann::json;
class SlippiReplayComm class SlippiReplayComm
{ {
public: public:
typedef struct WatchSettings typedef struct WatchSettings
{ {
std::string path; std::string path;
int startFrame = Slippi::GAME_FIRST_FRAME; int start_frame = Slippi::GAME_FIRST_FRAME;
int endFrame = INT_MAX; int end_frame = INT_MAX;
std::string gameStartAt = ""; std::string game_start_at = "";
std::string gameStation = ""; std::string game_station = "";
int index = 0; int index = 0;
} WatchSettings; } WatchSettings;
@ -28,14 +25,14 @@ public:
typedef struct CommSettings typedef struct CommSettings
{ {
std::string mode; std::string mode;
std::string replayPath; std::string replay_path;
int startFrame = Slippi::GAME_FIRST_FRAME; int start_frame = Slippi::GAME_FIRST_FRAME;
int endFrame = INT_MAX; int end_frame = INT_MAX;
bool outputOverlayFiles; bool output_overlay_files;
bool isRealTimeMode; bool is_real_time_mode;
bool shouldResync; // If true, logic will attempt to resync games bool should_resync; // If true, logic will attempt to resync games
std::string rollbackDisplayMethod; // off, normal, visible std::string rollback_display_method; // off, normal, visible
std::string commandId; std::string command_id;
std::queue<WatchSettings> queue; std::queue<WatchSettings> queue;
} CommSettings; } CommSettings;
@ -53,16 +50,15 @@ private:
void loadFile(); void loadFile();
std::string getReplayPath(); std::string getReplayPath();
std::string configFilePath; std::string config_file_path;
json fileData; std::string previous_replay_loaded;
std::string previousReplayLoaded; std::string previous_command_id;
std::string previousCommandId; int previous_idx;
int previousIndex;
u64 configLastLoadModTime; u64 config_last_load_mod_time;
// Queue stuff // Queue stuff
bool queueWasEmpty = true; bool queue_was_empty = true;
CommSettings commFileSettings; CommSettings comm_file_settings;
}; };

16
Source/Core/DolphinQt/HotkeyScheduler.cpp
View file

@ -561,9 +561,9 @@ void HotkeyScheduler::Run()
if (IsHotkey(HK_SLIPPI_JUMP_BACK)) if (IsHotkey(HK_SLIPPI_JUMP_BACK))
{ {
INFO_LOG_FMT(SLIPPI, "jump back"); INFO_LOG_FMT(SLIPPI, "jump back");
if (g_playback_status->targetFrameNum == INT_MAX) if (g_playback_status->target_frame_num == INT_MAX)
{ {
g_playback_status->targetFrameNum = g_playback_status->currentPlaybackFrame - 1200; g_playback_status->target_frame_num = g_playback_status->current_playback_frame - 1200;
Host_PlaybackSeek(); Host_PlaybackSeek();
} }
} }
@ -571,9 +571,9 @@ void HotkeyScheduler::Run()
if (IsHotkey(HK_SLIPPI_STEP_BACK)) if (IsHotkey(HK_SLIPPI_STEP_BACK))
{ {
INFO_LOG_FMT(SLIPPI, "step back"); INFO_LOG_FMT(SLIPPI, "step back");
if (g_playback_status->targetFrameNum == INT_MAX) if (g_playback_status->target_frame_num == INT_MAX)
{ {
g_playback_status->targetFrameNum = g_playback_status->currentPlaybackFrame - 300; g_playback_status->target_frame_num = g_playback_status->current_playback_frame - 300;
Host_PlaybackSeek(); Host_PlaybackSeek();
} }
} }
@ -581,9 +581,9 @@ void HotkeyScheduler::Run()
if (IsHotkey(HK_SLIPPI_STEP_FORWARD)) if (IsHotkey(HK_SLIPPI_STEP_FORWARD))
{ {
INFO_LOG_FMT(SLIPPI, "step forward"); INFO_LOG_FMT(SLIPPI, "step forward");
if (g_playback_status->targetFrameNum == INT_MAX) if (g_playback_status->target_frame_num == INT_MAX)
{ {
g_playback_status->targetFrameNum = g_playback_status->currentPlaybackFrame + 300; g_playback_status->target_frame_num = g_playback_status->current_playback_frame + 300;
Host_PlaybackSeek(); Host_PlaybackSeek();
} }
} }
@ -591,9 +591,9 @@ void HotkeyScheduler::Run()
if (IsHotkey(HK_SLIPPI_JUMP_FORWARD)) if (IsHotkey(HK_SLIPPI_JUMP_FORWARD))
{ {
INFO_LOG_FMT(SLIPPI, "jump forward"); INFO_LOG_FMT(SLIPPI, "jump forward");
if (g_playback_status->targetFrameNum == INT_MAX) if (g_playback_status->target_frame_num == INT_MAX)
{ {
g_playback_status->targetFrameNum = g_playback_status->currentPlaybackFrame + 1200; g_playback_status->target_frame_num = g_playback_status->current_playback_frame + 1200;
Host_PlaybackSeek(); Host_PlaybackSeek();
} }
} }

30
Source/Core/VideoCommon/OnScreenDisplay.cpp
View file

@ -350,7 +350,7 @@ bool SeekBarBehavior(const ImRect& bb, ImGuiID id, int* v, int v_min, int v_max,
if (!isHeld) if (!isHeld)
{ {
value_changed = true; value_changed = true;
g_playback_status->targetFrameNum = *v; g_playback_status->target_frame_num = *v;
} }
} }
else else
@ -415,9 +415,9 @@ bool SeekBarBehavior(const ImRect& bb, ImGuiID id, int* v, int v_min, int v_max,
// Progress bar // Progress bar
if (!isHeld) if (!isHeld)
{ {
frame = (g_playback_status->targetFrameNum == INT_MAX) ? frame = (g_playback_status->target_frame_num == INT_MAX) ?
g_playback_status->currentPlaybackFrame : g_playback_status->current_playback_frame :
g_playback_status->targetFrameNum; g_playback_status->target_frame_num;
window->DrawList->AddLine(ImVec2(bb.Min.x, bb.Min.y - scaled_height * 0.002f), window->DrawList->AddLine(ImVec2(bb.Min.x, bb.Min.y - scaled_height * 0.002f),
ImVec2(curr_grab_pos, bb.Min.y - scaled_height * 0.002f), ImVec2(curr_grab_pos, bb.Min.y - scaled_height * 0.002f),
ImGui::ColorConvertFloat4ToU32(ImVec4(0.0f, 1.0f, 0.0f, style.Alpha)), ImGui::ColorConvertFloat4ToU32(ImVec4(0.0f, 1.0f, 0.0f, style.Alpha)),
@ -629,7 +629,7 @@ void DrawSlippiPlaybackControls()
ImGui::SetWindowFontScale(scaled_height / 2000.0f); ImGui::SetWindowFontScale(scaled_height / 2000.0f);
if (SeekBar("SlippiSeek", ImVec4(1.0f, 0.0f, 0.0f, 1.0f), &frame, Slippi::PLAYBACK_FIRST_SAVE, if (SeekBar("SlippiSeek", ImVec4(1.0f, 0.0f, 0.0f, 1.0f), &frame, Slippi::PLAYBACK_FIRST_SAVE,
g_playback_status->lastFrame, 1.0, "%d")) g_playback_status->last_frame, 1.0, "%d"))
{ {
Host_PlaybackSeek(); Host_PlaybackSeek();
} }
@ -645,9 +645,9 @@ void DrawSlippiPlaybackControls()
// ImGui::SameLine(0.0f, 5.0f); // ImGui::SameLine(0.0f, 5.0f);
if (ButtonCustom(ICON_MD_FAST_REWIND, ImVec2(BUTTON_WIDTH, BUTTON_WIDTH))) if (ButtonCustom(ICON_MD_FAST_REWIND, ImVec2(BUTTON_WIDTH, BUTTON_WIDTH)))
{ {
if (g_playback_status->targetFrameNum == INT_MAX) if (g_playback_status->target_frame_num == INT_MAX)
{ {
g_playback_status->targetFrameNum = g_playback_status->currentPlaybackFrame - 1200; g_playback_status->target_frame_num = g_playback_status->current_playback_frame - 1200;
Host_PlaybackSeek(); Host_PlaybackSeek();
} }
} }
@ -665,9 +665,9 @@ void DrawSlippiPlaybackControls()
ImGui::SetCursorPos(ImVec2(BUTTON_WIDTH, height - scaled_height * 0.0265f)); ImGui::SetCursorPos(ImVec2(BUTTON_WIDTH, height - scaled_height * 0.0265f));
if (ButtonCustom(ICON_MD_FIRST_PAGE, ImVec2(BUTTON_WIDTH, BUTTON_WIDTH))) if (ButtonCustom(ICON_MD_FIRST_PAGE, ImVec2(BUTTON_WIDTH, BUTTON_WIDTH)))
{ {
if (g_playback_status->targetFrameNum == INT_MAX) if (g_playback_status->target_frame_num == INT_MAX)
{ {
g_playback_status->targetFrameNum = g_playback_status->currentPlaybackFrame - 300; g_playback_status->target_frame_num = g_playback_status->current_playback_frame - 300;
Host_PlaybackSeek(); Host_PlaybackSeek();
} }
} }
@ -685,9 +685,9 @@ void DrawSlippiPlaybackControls()
ImGui::SetCursorPos(ImVec2(BUTTON_WIDTH * 2, height - scaled_height * 0.0265f)); ImGui::SetCursorPos(ImVec2(BUTTON_WIDTH * 2, height - scaled_height * 0.0265f));
if (ButtonCustom(ICON_MD_LAST_PAGE, ImVec2(BUTTON_WIDTH, BUTTON_WIDTH))) if (ButtonCustom(ICON_MD_LAST_PAGE, ImVec2(BUTTON_WIDTH, BUTTON_WIDTH)))
{ {
if (g_playback_status->targetFrameNum == INT_MAX) if (g_playback_status->target_frame_num == INT_MAX)
{ {
g_playback_status->targetFrameNum = g_playback_status->currentPlaybackFrame + 300; g_playback_status->target_frame_num = g_playback_status->current_playback_frame + 300;
Host_PlaybackSeek(); Host_PlaybackSeek();
} }
} }
@ -705,9 +705,9 @@ void DrawSlippiPlaybackControls()
ImGui::SetCursorPos(ImVec2(BUTTON_WIDTH * 3, height - scaled_height * 0.0265f)); ImGui::SetCursorPos(ImVec2(BUTTON_WIDTH * 3, height - scaled_height * 0.0265f));
if (ButtonCustom(ICON_MD_FAST_FORWARD, ImVec2(BUTTON_WIDTH, BUTTON_WIDTH))) if (ButtonCustom(ICON_MD_FAST_FORWARD, ImVec2(BUTTON_WIDTH, BUTTON_WIDTH)))
{ {
if (g_playback_status->targetFrameNum == INT_MAX) if (g_playback_status->target_frame_num == INT_MAX)
{ {
g_playback_status->targetFrameNum = g_playback_status->currentPlaybackFrame + 1200; g_playback_status->target_frame_num = g_playback_status->current_playback_frame + 1200;
Host_PlaybackSeek(); Host_PlaybackSeek();
} }
} }
@ -887,8 +887,8 @@ void DrawSlippiPlaybackControls()
// Time text // Time text
ImGui::SetCursorPos(ImVec2(BUTTON_WIDTH * 8, height - scaled_height * 0.024f)); ImGui::SetCursorPos(ImVec2(BUTTON_WIDTH * 8, height - scaled_height * 0.024f));
auto playbackTime = GetTimeForFrame(g_playback_status->currentPlaybackFrame); auto playbackTime = GetTimeForFrame(g_playback_status->current_playback_frame);
auto endTime = GetTimeForFrame(g_playback_status->lastFrame); auto endTime = GetTimeForFrame(g_playback_status->last_frame);
auto timeString = playbackTime + " / " + endTime; auto timeString = playbackTime + " / " + endTime;
ImGui::Text("%s", timeString.c_str()); ImGui::Text("%s", timeString.c_str());
} }