summaryrefslogtreecommitdiffstats
path: root/src/input_common/tas/tas_input.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/input_common/tas/tas_input.cpp')
-rw-r--r--src/input_common/tas/tas_input.cpp340
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