diff options
Diffstat (limited to '')
-rw-r--r-- | src/input_common/tas/tas_input.cpp | 340 |
1 files changed, 340 insertions, 0 deletions
diff --git a/src/input_common/tas/tas_input.cpp b/src/input_common/tas/tas_input.cpp new file mode 100644 index 000000000..343641945 --- /dev/null +++ b/src/input_common/tas/tas_input.cpp @@ -0,0 +1,340 @@ +// Copyright 2021 yuzu Emulator Project +// Licensed under GPLv2+ +// Refer to the license.txt file included. + +#include <chrono> +#include <cstring> +#include <functional> +#include <random> +#include <regex> +#include <thread> +#include <boost/asio.hpp> + +#include "common/fs/file.h" +#include "common/fs/fs_types.h" +#include "common/fs/path_util.h" +#include "common/logging/log.h" +#include "common/settings.h" +#include "input_common/tas/tas_input.h" + +namespace TasInput { + +Tas::Tas() { + LoadTasFiles(); +} + +Tas::~Tas() { + update_thread_running = false; +} + +void Tas::RefreshTasFile() { + refresh_tas_fle = true; +} +void Tas::LoadTasFiles() { + scriptLength = 0; + for (int i = 0; i < PLAYER_NUMBER; i++) { + LoadTasFile(i); + if (newCommands[i].size() > scriptLength) + scriptLength = newCommands[i].size(); + } +} +void Tas::LoadTasFile(int playerIndex) { + LOG_DEBUG(Input, "LoadTasFile()"); + if (!newCommands[playerIndex].empty()) { + newCommands[playerIndex].clear(); + } + std::string file = Common::FS::ReadStringFromFile( + Common::FS::GetYuzuPathString(Common::FS::YuzuPath::TASFile) + "script0-" + + std::to_string(playerIndex + 1) + ".txt", + Common::FS::FileType::BinaryFile); + std::stringstream command_line(file); + std::string line; + int frameNo = 0; + TASCommand empty = {.buttons = 0, .l_axis = {0.f, 0.f}, .r_axis = {0.f, 0.f}}; + while (std::getline(command_line, line, '\n')) { + if (line.empty()) + continue; + LOG_DEBUG(Input, "Loading line: {}", line); + std::smatch m; + + std::stringstream linestream(line); + std::string segment; + std::vector<std::string> seglist; + + while (std::getline(linestream, segment, ' ')) { + seglist.push_back(segment); + } + + if (seglist.size() < 4) + continue; + + while (frameNo < std::stoi(seglist.at(0))) { + newCommands[playerIndex].push_back(empty); + frameNo++; + } + + TASCommand command = { + .buttons = ReadCommandButtons(seglist.at(1)), + .l_axis = ReadCommandAxis(seglist.at(2)), + .r_axis = ReadCommandAxis(seglist.at(3)), + }; + newCommands[playerIndex].push_back(command); + frameNo++; + } + LOG_INFO(Input, "TAS file loaded! {} frames", frameNo); +} + +void Tas::WriteTasFile() { + LOG_DEBUG(Input, "WriteTasFile()"); + std::string output_text = ""; + for (int frame = 0; frame < (signed)recordCommands.size(); frame++) { + if (!output_text.empty()) + output_text += "\n"; + TASCommand line = recordCommands.at(frame); + output_text += std::to_string(frame) + " " + WriteCommandButtons(line.buttons) + " " + + WriteCommandAxis(line.l_axis) + " " + WriteCommandAxis(line.r_axis); + } + size_t bytesWritten = Common::FS::WriteStringToFile( + Common::FS::GetYuzuPathString(Common::FS::YuzuPath::TASFile) + "record.txt", + Common::FS::FileType::TextFile, output_text); + if (bytesWritten == output_text.size()) + LOG_INFO(Input, "TAS file written to file!"); + else + LOG_ERROR(Input, "Writing the TAS-file has failed! {} / {} bytes written", bytesWritten, + output_text.size()); +} + +void Tas::RecordInput(u32 buttons, std::array<std::pair<float, float>, 2> axes) { + lastInput = {buttons, flipY(axes[0]), flipY(axes[1])}; +} + +std::pair<float, float> Tas::flipY(std::pair<float, float> old) const { + auto [x, y] = old; + return {x, -y}; +} + +std::string Tas::GetStatusDescription() { + if (Settings::values.tas_record) { + return "Recording TAS: " + std::to_string(recordCommands.size()); + } + if (Settings::values.tas_enable) { + return "Playing TAS: " + std::to_string(current_command) + "/" + + std::to_string(scriptLength); + } + return "TAS not running: " + std::to_string(current_command) + "/" + + std::to_string(scriptLength); +} + +std::string debugButtons(u32 buttons) { + return "{ " + TasInput::Tas::buttonsToString(buttons) + " }"; +} + +std::string debugJoystick(float x, float y) { + return "[ " + std::to_string(x) + "," + std::to_string(y) + " ]"; +} + +std::string debugInput(TasData data) { + return "{ " + debugButtons(data.buttons) + " , " + debugJoystick(data.axis[0], data.axis[1]) + + " , " + debugJoystick(data.axis[2], data.axis[3]) + " }"; +} + +std::string debugInputs(std::array<TasData, PLAYER_NUMBER> arr) { + std::string returns = "[ "; + for (size_t i = 0; i < arr.size(); i++) { + returns += debugInput(arr[i]); + if (i != arr.size() - 1) + returns += " , "; + } + return returns + "]"; +} + +void Tas::UpdateThread() { + if (update_thread_running) { + if (Settings::values.pauseTasOnLoad && Settings::values.cpuBoosted) { + for (int i = 0; i < PLAYER_NUMBER; i++) { + tas_data[i].buttons = 0; + tas_data[i].axis = {}; + } + } + + if (Settings::values.tas_record) { + recordCommands.push_back(lastInput); + } + if (!Settings::values.tas_record && !recordCommands.empty()) { + WriteTasFile(); + Settings::values.tas_reset = true; + refresh_tas_fle = true; + recordCommands.clear(); + } + if (Settings::values.tas_reset) { + current_command = 0; + if (refresh_tas_fle) { + LoadTasFiles(); + refresh_tas_fle = false; + } + Settings::values.tas_reset = false; + LoadTasFiles(); + LOG_DEBUG(Input, "tas_reset done"); + } + if (Settings::values.tas_enable) { + if ((signed)current_command < scriptLength) { + LOG_INFO(Input, "Playing TAS {}/{}", current_command, scriptLength); + size_t frame = current_command++; + for (int i = 0; i < PLAYER_NUMBER; i++) { + if (frame < newCommands[i].size()) { + TASCommand command = newCommands[i][frame]; + tas_data[i].buttons = command.buttons; + auto [l_axis_x, l_axis_y] = command.l_axis; + tas_data[i].axis[0] = l_axis_x; + tas_data[i].axis[1] = l_axis_y; + auto [r_axis_x, r_axis_y] = command.r_axis; + tas_data[i].axis[2] = r_axis_x; + tas_data[i].axis[3] = r_axis_y; + } else { + tas_data[i].buttons = 0; + tas_data[i].axis = {}; + } + } + } else { + Settings::values.tas_enable = false; + current_command = 0; + for (int i = 0; i < PLAYER_NUMBER; i++) { + tas_data[i].buttons = 0; + tas_data[i].axis = {}; + } + } + } else { + for (int i = 0; i < PLAYER_NUMBER; i++) { + tas_data[i].buttons = 0; + tas_data[i].axis = {}; + } + } + } + LOG_DEBUG(Input, "TAS inputs: {}", debugInputs(tas_data)); +} + +TasAnalog Tas::ReadCommandAxis(const std::string line) const { + std::stringstream linestream(line); + std::string segment; + std::vector<std::string> seglist; + + while (std::getline(linestream, segment, ';')) { + seglist.push_back(segment); + } + + const float x = std::stof(seglist.at(0)) / 32767.f; + const float y = std::stof(seglist.at(1)) / 32767.f; + + return {x, y}; +} + +u32 Tas::ReadCommandButtons(const std::string data) const { + std::stringstream button_text(data); + std::string line; + u32 buttons = 0; + while (std::getline(button_text, line, ';')) { + for (auto [text, tas_button] : text_to_tas_button) { + if (text == line) { + buttons |= static_cast<u32>(tas_button); + break; + } + } + } + return buttons; +} + +std::string Tas::WriteCommandAxis(TasAnalog data) const { + auto [x, y] = data; + std::string line; + line += std::to_string(static_cast<int>(x * 32767)); + line += ";"; + line += std::to_string(static_cast<int>(y * 32767)); + return line; +} + +std::string Tas::WriteCommandButtons(u32 data) const { + if (data == 0) + return "NONE"; + + std::string line; + u32 index = 0; + while (data > 0) { + if ((data & 1) == 1) { + for (auto [text, tas_button] : text_to_tas_button) { + if (tas_button == static_cast<TasButton>(1 << index)) { + if (line.size() > 0) + line += ";"; + line += text; + break; + } + } + } + index++; + data >>= 1; + } + return line; +} + +InputCommon::ButtonMapping Tas::GetButtonMappingForDevice( + const Common::ParamPackage& params) const { + // This list is missing ZL/ZR since those are not considered buttons. + // We will add those afterwards + // This list also excludes any button that can't be really mapped + static constexpr std::array<std::pair<Settings::NativeButton::Values, TasButton>, 20> + switch_to_tas_button = { + std::pair{Settings::NativeButton::A, TasButton::BUTTON_A}, + {Settings::NativeButton::B, TasButton::BUTTON_B}, + {Settings::NativeButton::X, TasButton::BUTTON_X}, + {Settings::NativeButton::Y, TasButton::BUTTON_Y}, + {Settings::NativeButton::LStick, TasButton::STICK_L}, + {Settings::NativeButton::RStick, TasButton::STICK_R}, + {Settings::NativeButton::L, TasButton::TRIGGER_L}, + {Settings::NativeButton::R, TasButton::TRIGGER_R}, + {Settings::NativeButton::Plus, TasButton::BUTTON_PLUS}, + {Settings::NativeButton::Minus, TasButton::BUTTON_MINUS}, + {Settings::NativeButton::DLeft, TasButton::BUTTON_LEFT}, + {Settings::NativeButton::DUp, TasButton::BUTTON_UP}, + {Settings::NativeButton::DRight, TasButton::BUTTON_RIGHT}, + {Settings::NativeButton::DDown, TasButton::BUTTON_DOWN}, + {Settings::NativeButton::SL, TasButton::BUTTON_SL}, + {Settings::NativeButton::SR, TasButton::BUTTON_SR}, + {Settings::NativeButton::Screenshot, TasButton::BUTTON_CAPTURE}, + {Settings::NativeButton::Home, TasButton::BUTTON_HOME}, + {Settings::NativeButton::ZL, TasButton::TRIGGER_ZL}, + {Settings::NativeButton::ZR, TasButton::TRIGGER_ZR}, + }; + + InputCommon::ButtonMapping mapping{}; + for (const auto& [switch_button, tas_button] : switch_to_tas_button) { + Common::ParamPackage button_params({{"engine", "tas"}}); + button_params.Set("pad", params.Get("pad", 0)); + button_params.Set("button", static_cast<int>(tas_button)); + mapping.insert_or_assign(switch_button, std::move(button_params)); + } + + return mapping; +} + +InputCommon::AnalogMapping Tas::GetAnalogMappingForDevice( + const Common::ParamPackage& params) const { + + InputCommon::AnalogMapping mapping = {}; + Common::ParamPackage left_analog_params; + left_analog_params.Set("engine", "tas"); + left_analog_params.Set("pad", params.Get("pad", 0)); + left_analog_params.Set("axis_x", static_cast<int>(TasAxes::StickX)); + left_analog_params.Set("axis_y", static_cast<int>(TasAxes::StickY)); + mapping.insert_or_assign(Settings::NativeAnalog::LStick, std::move(left_analog_params)); + Common::ParamPackage right_analog_params; + right_analog_params.Set("engine", "tas"); + right_analog_params.Set("pad", params.Get("pad", 0)); + right_analog_params.Set("axis_x", static_cast<int>(TasAxes::SubstickX)); + right_analog_params.Set("axis_y", static_cast<int>(TasAxes::SubstickY)); + mapping.insert_or_assign(Settings::NativeAnalog::RStick, std::move(right_analog_params)); + return mapping; +} + +const TasData& Tas::GetTasState(std::size_t pad) const { + return tas_data[pad]; +} +} // namespace TasInput |