aboutsummaryrefslogtreecommitdiff
path: root/src/input_common/tas/tas_input.cpp
diff options
context:
space:
mode:
authorMonsterDruide1 <5958456@gmail.com>2021-06-18 16:15:42 +0200
committerMonsterDruide1 <5958456@gmail.com>2021-09-18 23:22:00 +0200
commitb42c3ce21db249d5e3bc04b4f73202e757da317c (patch)
treec5ccf9e311d2a675b0e2afff3d85ed4654047b5e /src/input_common/tas/tas_input.cpp
parent35f46fc079d9534df7850eca3ce29e89e04d8914 (diff)
input_common/tas: Base playback & recording system
The base playback system supports up to 8 controllers (specified by `PLAYER_NUMBER` in `tas_input.h`), which all change their inputs simulataneously when `TAS::UpdateThread` is called. The recording system uses the controller debugger to read the state of the first controller and forwards that data to the TASing system for recording. Currently, this process sadly is not frame-perfect and pixel-accurate. Co-authored-by: Naii-the-Baf <sfabian200@gmail.com> Co-authored-by: Narr-the-Reg <juangerman-13@hotmail.com>
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 0000000000..343641945d
--- /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
generated by cgit v1.2.3-70-g09d2 (git 2.49.0) at 2025-04-02 12:55:48 +0000