summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorgerman77 <juangerman-13@hotmail.com>2021-09-21 00:26:08 +0200
committerNarr the Reg <juangerman-13@hotmail.com>2021-11-25 03:30:22 +0100
commitdc3ab9e11068998ffd419f65f00fb336585b8e8c (patch)
treeb4330f227bfa90f3c8440f33bf3b987240646c44
parentinput_common: Rewrite gc_adapter (diff)
downloadyuzu-dc3ab9e11068998ffd419f65f00fb336585b8e8c.tar
yuzu-dc3ab9e11068998ffd419f65f00fb336585b8e8c.tar.gz
yuzu-dc3ab9e11068998ffd419f65f00fb336585b8e8c.tar.bz2
yuzu-dc3ab9e11068998ffd419f65f00fb336585b8e8c.tar.lz
yuzu-dc3ab9e11068998ffd419f65f00fb336585b8e8c.tar.xz
yuzu-dc3ab9e11068998ffd419f65f00fb336585b8e8c.tar.zst
yuzu-dc3ab9e11068998ffd419f65f00fb336585b8e8c.zip
Diffstat (limited to '')
-rw-r--r--src/input_common/CMakeLists.txt6
-rw-r--r--src/input_common/tas/tas_input.cpp455
-rw-r--r--src/input_common/tas/tas_input.h237
-rw-r--r--src/input_common/tas/tas_poller.cpp101
-rw-r--r--src/input_common/tas/tas_poller.h43
5 files changed, 2 insertions, 840 deletions
diff --git a/src/input_common/CMakeLists.txt b/src/input_common/CMakeLists.txt
index c8871513c..19270dc84 100644
--- a/src/input_common/CMakeLists.txt
+++ b/src/input_common/CMakeLists.txt
@@ -5,6 +5,8 @@ add_library(input_common STATIC
drivers/keyboard.h
drivers/mouse.cpp
drivers/mouse.h
+ drivers/tas_input.cpp
+ drivers/tas_input.h
drivers/touch_screen.cpp
drivers/touch_screen.h
helpers/stick_from_buttons.cpp
@@ -27,10 +29,6 @@ add_library(input_common STATIC
motion_input.h
sdl/sdl.cpp
sdl/sdl.h
- tas/tas_input.cpp
- tas/tas_input.h
- tas/tas_poller.cpp
- tas/tas_poller.h
udp/client.cpp
udp/client.h
udp/udp.cpp
diff --git a/src/input_common/tas/tas_input.cpp b/src/input_common/tas/tas_input.cpp
deleted file mode 100644
index 1598092b6..000000000
--- a/src/input_common/tas/tas_input.cpp
+++ /dev/null
@@ -1,455 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2+
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include <regex>
-
-#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 {
-
-// Supported keywords and buttons from a TAS file
-constexpr std::array<std::pair<std::string_view, TasButton>, 20> text_to_tas_button = {
- std::pair{"KEY_A", TasButton::BUTTON_A},
- {"KEY_B", TasButton::BUTTON_B},
- {"KEY_X", TasButton::BUTTON_X},
- {"KEY_Y", TasButton::BUTTON_Y},
- {"KEY_LSTICK", TasButton::STICK_L},
- {"KEY_RSTICK", TasButton::STICK_R},
- {"KEY_L", TasButton::TRIGGER_L},
- {"KEY_R", TasButton::TRIGGER_R},
- {"KEY_PLUS", TasButton::BUTTON_PLUS},
- {"KEY_MINUS", TasButton::BUTTON_MINUS},
- {"KEY_DLEFT", TasButton::BUTTON_LEFT},
- {"KEY_DUP", TasButton::BUTTON_UP},
- {"KEY_DRIGHT", TasButton::BUTTON_RIGHT},
- {"KEY_DDOWN", TasButton::BUTTON_DOWN},
- {"KEY_SL", TasButton::BUTTON_SL},
- {"KEY_SR", TasButton::BUTTON_SR},
- {"KEY_CAPTURE", TasButton::BUTTON_CAPTURE},
- {"KEY_HOME", TasButton::BUTTON_HOME},
- {"KEY_ZL", TasButton::TRIGGER_ZL},
- {"KEY_ZR", TasButton::TRIGGER_ZR},
-};
-
-Tas::Tas() {
- if (!Settings::values.tas_enable) {
- needs_reset = true;
- return;
- }
- LoadTasFiles();
-}
-
-Tas::~Tas() {
- Stop();
-};
-
-void Tas::LoadTasFiles() {
- script_length = 0;
- for (size_t i = 0; i < commands.size(); i++) {
- LoadTasFile(i);
- if (commands[i].size() > script_length) {
- script_length = commands[i].size();
- }
- }
-}
-
-void Tas::LoadTasFile(size_t player_index) {
- if (!commands[player_index].empty()) {
- commands[player_index].clear();
- }
- std::string file =
- Common::FS::ReadStringFromFile(Common::FS::GetYuzuPath(Common::FS::YuzuPath::TASDir) /
- fmt::format("script0-{}.txt", player_index + 1),
- Common::FS::FileType::BinaryFile);
- std::stringstream command_line(file);
- std::string line;
- int frame_no = 0;
- 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 (frame_no < std::stoi(seglist.at(0))) {
- commands[player_index].push_back({});
- frame_no++;
- }
-
- TASCommand command = {
- .buttons = ReadCommandButtons(seglist.at(1)),
- .l_axis = ReadCommandAxis(seglist.at(2)),
- .r_axis = ReadCommandAxis(seglist.at(3)),
- };
- commands[player_index].push_back(command);
- frame_no++;
- }
- LOG_INFO(Input, "TAS file loaded! {} frames", frame_no);
-}
-
-void Tas::WriteTasFile(std::u8string file_name) {
- std::string output_text;
- for (size_t frame = 0; frame < record_commands.size(); frame++) {
- if (!output_text.empty()) {
- output_text += "\n";
- }
- const TASCommand& line = record_commands[frame];
- output_text += std::to_string(frame) + " " + WriteCommandButtons(line.buttons) + " " +
- WriteCommandAxis(line.l_axis) + " " + WriteCommandAxis(line.r_axis);
- }
- const auto bytes_written = Common::FS::WriteStringToFile(
- Common::FS::GetYuzuPath(Common::FS::YuzuPath::TASDir) / file_name,
- Common::FS::FileType::TextFile, output_text);
- if (bytes_written == output_text.size()) {
- LOG_INFO(Input, "TAS file written to file!");
- } else {
- LOG_ERROR(Input, "Writing the TAS-file has failed! {} / {} bytes written", bytes_written,
- output_text.size());
- }
-}
-
-std::pair<float, float> Tas::FlipAxisY(std::pair<float, float> old) {
- auto [x, y] = old;
- return {x, -y};
-}
-
-void Tas::RecordInput(u32 buttons, const std::array<std::pair<float, float>, 2>& axes) {
- last_input = {buttons, FlipAxisY(axes[0]), FlipAxisY(axes[1])};
-}
-
-std::tuple<TasState, size_t, size_t> Tas::GetStatus() const {
- TasState state;
- if (is_recording) {
- return {TasState::Recording, 0, record_commands.size()};
- }
-
- if (is_running) {
- state = TasState::Running;
- } else {
- state = TasState::Stopped;
- }
-
- return {state, current_command, script_length};
-}
-
-std::string Tas::DebugButtons(u32 buttons) const {
- return fmt::format("{{ {} }}", TasInput::Tas::ButtonsToString(buttons));
-}
-
-std::string Tas::DebugJoystick(float x, float y) const {
- return fmt::format("[ {} , {} ]", std::to_string(x), std::to_string(y));
-}
-
-std::string Tas::DebugInput(const TasData& data) const {
- return fmt::format("{{ {} , {} , {} }}", DebugButtons(data.buttons),
- DebugJoystick(data.axis[0], data.axis[1]),
- DebugJoystick(data.axis[2], data.axis[3]));
-}
-
-std::string Tas::DebugInputs(const std::array<TasData, PLAYER_NUMBER>& arr) const {
- std::string returns = "[ ";
- for (size_t i = 0; i < arr.size(); i++) {
- returns += DebugInput(arr[i]);
- if (i != arr.size() - 1) {
- returns += " , ";
- }
- }
- return returns + "]";
-}
-
-std::string Tas::ButtonsToString(u32 button) const {
- std::string returns;
- for (auto [text_button, tas_button] : text_to_tas_button) {
- if ((button & static_cast<u32>(tas_button)) != 0)
- returns += fmt::format(", {}", text_button.substr(4));
- }
- return returns.empty() ? "" : returns.substr(2);
-}
-
-void Tas::UpdateThread() {
- if (!Settings::values.tas_enable) {
- if (is_running) {
- Stop();
- }
- return;
- }
-
- if (is_recording) {
- record_commands.push_back(last_input);
- }
- if (needs_reset) {
- current_command = 0;
- needs_reset = false;
- LoadTasFiles();
- LOG_DEBUG(Input, "tas_reset done");
- }
-
- if (!is_running) {
- tas_data.fill({});
- return;
- }
- if (current_command < script_length) {
- LOG_DEBUG(Input, "Playing TAS {}/{}", current_command, script_length);
- size_t frame = current_command++;
- for (size_t i = 0; i < commands.size(); i++) {
- if (frame < commands[i].size()) {
- TASCommand command = commands[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] = {};
- }
- }
- } else {
- is_running = Settings::values.tas_loop.GetValue();
- current_command = 0;
- tas_data.fill({});
- if (!is_running) {
- SwapToStoredController();
- }
- }
- 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.0f;
- const float y = std::stof(seglist.at(1)) / 32767.0f;
-
- 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;
-}
-
-void Tas::StartStop() {
- if (!Settings::values.tas_enable) {
- return;
- }
- if (is_running) {
- Stop();
- } else {
- is_running = true;
- SwapToTasController();
- }
-}
-
-void Tas::Stop() {
- is_running = false;
- SwapToStoredController();
-}
-
-void Tas::SwapToTasController() {
- if (!Settings::values.tas_swap_controllers) {
- return;
- }
- auto& players = Settings::values.players.GetValue();
- for (std::size_t index = 0; index < players.size(); index++) {
- auto& player = players[index];
- player_mappings[index] = player;
-
- // Only swap active controllers
- if (!player.connected) {
- continue;
- }
-
- Common::ParamPackage tas_param;
- tas_param.Set("pad", static_cast<u8>(index));
- auto button_mapping = GetButtonMappingForDevice(tas_param);
- auto analog_mapping = GetAnalogMappingForDevice(tas_param);
- auto& buttons = player.buttons;
- auto& analogs = player.analogs;
-
- for (std::size_t i = 0; i < buttons.size(); ++i) {
- buttons[i] = button_mapping[static_cast<Settings::NativeButton::Values>(i)].Serialize();
- }
- for (std::size_t i = 0; i < analogs.size(); ++i) {
- analogs[i] = analog_mapping[static_cast<Settings::NativeAnalog::Values>(i)].Serialize();
- }
- }
- is_old_input_saved = true;
- Settings::values.is_device_reload_pending.store(true);
-}
-
-void Tas::SwapToStoredController() {
- if (!is_old_input_saved) {
- return;
- }
- auto& players = Settings::values.players.GetValue();
- for (std::size_t index = 0; index < players.size(); index++) {
- players[index] = player_mappings[index];
- }
- is_old_input_saved = false;
- Settings::values.is_device_reload_pending.store(true);
-}
-
-void Tas::Reset() {
- if (!Settings::values.tas_enable) {
- return;
- }
- needs_reset = true;
-}
-
-bool Tas::Record() {
- if (!Settings::values.tas_enable) {
- return true;
- }
- is_recording = !is_recording;
- return is_recording;
-}
-
-void Tas::SaveRecording(bool overwrite_file) {
- if (is_recording) {
- return;
- }
- if (record_commands.empty()) {
- return;
- }
- WriteTasFile(u8"record.txt");
- if (overwrite_file) {
- WriteTasFile(u8"script0-1.txt");
- }
- needs_reset = true;
- record_commands.clear();
-}
-
-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
diff --git a/src/input_common/tas/tas_input.h b/src/input_common/tas/tas_input.h
deleted file mode 100644
index 3e2db8f00..000000000
--- a/src/input_common/tas/tas_input.h
+++ /dev/null
@@ -1,237 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-
-#include "common/common_types.h"
-#include "common/settings_input.h"
-#include "core/frontend/input.h"
-#include "input_common/main.h"
-
-/*
-To play back TAS scripts on Yuzu, select the folder with scripts in the configuration menu below
-Tools -> Configure TAS. The file itself has normal text format and has to be called script0-1.txt
-for controller 1, script0-2.txt for controller 2 and so forth (with max. 8 players).
-
-A script file has the same format as TAS-nx uses, so final files will look like this:
-
-1 KEY_B 0;0 0;0
-6 KEY_ZL 0;0 0;0
-41 KEY_ZL;KEY_Y 0;0 0;0
-43 KEY_X;KEY_A 32767;0 0;0
-44 KEY_A 32767;0 0;0
-45 KEY_A 32767;0 0;0
-46 KEY_A 32767;0 0;0
-47 KEY_A 32767;0 0;0
-
-After placing the file at the correct location, it can be read into Yuzu with the (default) hotkey
-CTRL+F6 (refresh). In the bottom left corner, it will display the amount of frames the script file
-has. Playback can be started or stopped using CTRL+F5.
-
-However, for playback to actually work, the correct input device has to be selected: In the Controls
-menu, select TAS from the device list for the controller that the script should be played on.
-
-Recording a new script file is really simple: Just make sure that the proper device (not TAS) is
-connected on P1, and press CTRL+F7 to start recording. When done, just press the same keystroke
-again (CTRL+F7). The new script will be saved at the location previously selected, as the filename
-record.txt.
-
-For debugging purposes, the common controller debugger can be used (View -> Debugging -> Controller
-P1).
-*/
-
-namespace TasInput {
-
-constexpr size_t PLAYER_NUMBER = 8;
-
-using TasAnalog = std::pair<float, float>;
-
-enum class TasState {
- Running,
- Recording,
- Stopped,
-};
-
-enum class TasButton : u32 {
- BUTTON_A = 1U << 0,
- BUTTON_B = 1U << 1,
- BUTTON_X = 1U << 2,
- BUTTON_Y = 1U << 3,
- STICK_L = 1U << 4,
- STICK_R = 1U << 5,
- TRIGGER_L = 1U << 6,
- TRIGGER_R = 1U << 7,
- TRIGGER_ZL = 1U << 8,
- TRIGGER_ZR = 1U << 9,
- BUTTON_PLUS = 1U << 10,
- BUTTON_MINUS = 1U << 11,
- BUTTON_LEFT = 1U << 12,
- BUTTON_UP = 1U << 13,
- BUTTON_RIGHT = 1U << 14,
- BUTTON_DOWN = 1U << 15,
- BUTTON_SL = 1U << 16,
- BUTTON_SR = 1U << 17,
- BUTTON_HOME = 1U << 18,
- BUTTON_CAPTURE = 1U << 19,
-};
-
-enum class TasAxes : u8 {
- StickX,
- StickY,
- SubstickX,
- SubstickY,
- Undefined,
-};
-
-struct TasData {
- u32 buttons{};
- std::array<float, 4> axis{};
-};
-
-class Tas {
-public:
- Tas();
- ~Tas();
-
- // Changes the input status that will be stored in each frame
- void RecordInput(u32 buttons, const std::array<std::pair<float, float>, 2>& axes);
-
- // Main loop that records or executes input
- void UpdateThread();
-
- // Sets the flag to start or stop the TAS command excecution and swaps controllers profiles
- void StartStop();
-
- // Stop the TAS and reverts any controller profile
- void Stop();
-
- // Sets the flag to reload the file and start from the begining in the next update
- void Reset();
-
- /**
- * Sets the flag to enable or disable recording of inputs
- * @return Returns true if the current recording status is enabled
- */
- bool Record();
-
- // Saves contents of record_commands on a file if overwrite is enabled player 1 will be
- // overwritten with the recorded commands
- void SaveRecording(bool overwrite_file);
-
- /**
- * Returns the current status values of TAS playback/recording
- * @return Tuple of
- * TasState indicating the current state out of Running, Recording or Stopped ;
- * Current playback progress or amount of frames (so far) for Recording ;
- * Total length of script file currently loaded or amount of frames (so far) for Recording
- */
- std::tuple<TasState, size_t, size_t> GetStatus() const;
-
- // Retuns an array of the default button mappings
- InputCommon::ButtonMapping GetButtonMappingForDevice(const Common::ParamPackage& params) const;
-
- // Retuns an array of the default analog mappings
- InputCommon::AnalogMapping GetAnalogMappingForDevice(const Common::ParamPackage& params) const;
- [[nodiscard]] const TasData& GetTasState(std::size_t pad) const;
-
-private:
- struct TASCommand {
- u32 buttons{};
- TasAnalog l_axis{};
- TasAnalog r_axis{};
- };
-
- // Loads TAS files from all players
- void LoadTasFiles();
-
- // Loads TAS file from the specified player
- void LoadTasFile(size_t player_index);
-
- // Writes a TAS file from the recorded commands
- void WriteTasFile(std::u8string file_name);
-
- /**
- * Parses a string containing the axis values with the following format "x;y"
- * X and Y have a range from -32767 to 32767
- * @return Returns a TAS analog object with axis values with range from -1.0 to 1.0
- */
- TasAnalog ReadCommandAxis(const std::string& line) const;
-
- /**
- * Parses a string containing the button values with the following format "a;b;c;d..."
- * Each button is represented by it's text format specified in text_to_tas_button array
- * @return Returns a u32 with each bit representing the status of a button
- */
- u32 ReadCommandButtons(const std::string& line) const;
-
- /**
- * Converts an u32 containing the button status into the text equivalent
- * @return Returns a string with the name of the buttons to be written to the file
- */
- std::string WriteCommandButtons(u32 data) const;
-
- /**
- * Converts an TAS analog object containing the axis status into the text equivalent
- * @return Returns a string with the value of the axis to be written to the file
- */
- std::string WriteCommandAxis(TasAnalog data) const;
-
- // Inverts the Y axis polarity
- std::pair<float, float> FlipAxisY(std::pair<float, float> old);
-
- /**
- * Converts an u32 containing the button status into the text equivalent
- * @return Returns a string with the name of the buttons to be printed on console
- */
- std::string DebugButtons(u32 buttons) const;
-
- /**
- * Converts an TAS analog object containing the axis status into the text equivalent
- * @return Returns a string with the value of the axis to be printed on console
- */
- std::string DebugJoystick(float x, float y) const;
-
- /**
- * Converts the given TAS status into the text equivalent
- * @return Returns a string with the value of the TAS status to be printed on console
- */
- std::string DebugInput(const TasData& data) const;
-
- /**
- * Converts the given TAS status of multiple players into the text equivalent
- * @return Returns a string with the value of the status of all TAS players to be printed on
- * console
- */
- std::string DebugInputs(const std::array<TasData, PLAYER_NUMBER>& arr) const;
-
- /**
- * Converts an u32 containing the button status into the text equivalent
- * @return Returns a string with the name of the buttons
- */
- std::string ButtonsToString(u32 button) const;
-
- // Stores current controller configuration and sets a TAS controller for every active controller
- // to the current config
- void SwapToTasController();
-
- // Sets the stored controller configuration to the current config
- void SwapToStoredController();
-
- size_t script_length{0};
- std::array<TasData, PLAYER_NUMBER> tas_data;
- bool is_old_input_saved{false};
- bool is_recording{false};
- bool is_running{false};
- bool needs_reset{false};
- std::array<std::vector<TASCommand>, PLAYER_NUMBER> commands{};
- std::vector<TASCommand> record_commands{};
- size_t current_command{0};
- TASCommand last_input{}; // only used for recording
-
- // Old settings for swapping controllers
- std::array<Settings::PlayerInput, 10> player_mappings;
-};
-} // namespace TasInput
diff --git a/src/input_common/tas/tas_poller.cpp b/src/input_common/tas/tas_poller.cpp
deleted file mode 100644
index 15810d6b0..000000000
--- a/src/input_common/tas/tas_poller.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <mutex>
-#include <utility>
-
-#include "common/settings.h"
-#include "common/threadsafe_queue.h"
-#include "input_common/tas/tas_input.h"
-#include "input_common/tas/tas_poller.h"
-
-namespace InputCommon {
-
-class TasButton final : public Input::ButtonDevice {
-public:
- explicit TasButton(u32 button_, u32 pad_, const TasInput::Tas* tas_input_)
- : button(button_), pad(pad_), tas_input(tas_input_) {}
-
- bool GetStatus() const override {
- return (tas_input->GetTasState(pad).buttons & button) != 0;
- }
-
-private:
- const u32 button;
- const u32 pad;
- const TasInput::Tas* tas_input;
-};
-
-TasButtonFactory::TasButtonFactory(std::shared_ptr<TasInput::Tas> tas_input_)
- : tas_input(std::move(tas_input_)) {}
-
-std::unique_ptr<Input::ButtonDevice> TasButtonFactory::Create(const Common::ParamPackage& params) {
- const auto button_id = params.Get("button", 0);
- const auto pad = params.Get("pad", 0);
-
- return std::make_unique<TasButton>(button_id, pad, tas_input.get());
-}
-
-class TasAnalog final : public Input::AnalogDevice {
-public:
- explicit TasAnalog(u32 pad_, u32 axis_x_, u32 axis_y_, const TasInput::Tas* tas_input_)
- : pad(pad_), axis_x(axis_x_), axis_y(axis_y_), tas_input(tas_input_) {}
-
- float GetAxis(u32 axis) const {
- std::lock_guard lock{mutex};
- return tas_input->GetTasState(pad).axis.at(axis);
- }
-
- std::pair<float, float> GetAnalog(u32 analog_axis_x, u32 analog_axis_y) const {
- float x = GetAxis(analog_axis_x);
- float y = GetAxis(analog_axis_y);
-
- // Make sure the coordinates are in the unit circle,
- // otherwise normalize it.
- float r = x * x + y * y;
- if (r > 1.0f) {
- r = std::sqrt(r);
- x /= r;
- y /= r;
- }
-
- return {x, y};
- }
-
- std::tuple<float, float> GetStatus() const override {
- return GetAnalog(axis_x, axis_y);
- }
-
- Input::AnalogProperties GetAnalogProperties() const override {
- return {0.0f, 1.0f, 0.5f};
- }
-
-private:
- const u32 pad;
- const u32 axis_x;
- const u32 axis_y;
- const TasInput::Tas* tas_input;
- mutable std::mutex mutex;
-};
-
-/// An analog device factory that creates analog devices from GC Adapter
-TasAnalogFactory::TasAnalogFactory(std::shared_ptr<TasInput::Tas> tas_input_)
- : tas_input(std::move(tas_input_)) {}
-
-/**
- * Creates analog device from joystick axes
- * @param params contains parameters for creating the device:
- * - "port": the nth gcpad on the adapter
- * - "axis_x": the index of the axis to be bind as x-axis
- * - "axis_y": the index of the axis to be bind as y-axis
- */
-std::unique_ptr<Input::AnalogDevice> TasAnalogFactory::Create(const Common::ParamPackage& params) {
- const auto pad = static_cast<u32>(params.Get("pad", 0));
- const auto axis_x = static_cast<u32>(params.Get("axis_x", 0));
- const auto axis_y = static_cast<u32>(params.Get("axis_y", 1));
-
- return std::make_unique<TasAnalog>(pad, axis_x, axis_y, tas_input.get());
-}
-
-} // namespace InputCommon
diff --git a/src/input_common/tas/tas_poller.h b/src/input_common/tas/tas_poller.h
deleted file mode 100644
index 09e426cef..000000000
--- a/src/input_common/tas/tas_poller.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include "core/frontend/input.h"
-#include "input_common/tas/tas_input.h"
-
-namespace InputCommon {
-
-/**
- * A button device factory representing a tas bot. It receives tas events and forward them
- * to all button devices it created.
- */
-class TasButtonFactory final : public Input::Factory<Input::ButtonDevice> {
-public:
- explicit TasButtonFactory(std::shared_ptr<TasInput::Tas> tas_input_);
-
- /**
- * Creates a button device from a button press
- * @param params contains parameters for creating the device:
- * - "code": the code of the key to bind with the button
- */
- std::unique_ptr<Input::ButtonDevice> Create(const Common::ParamPackage& params) override;
-
-private:
- std::shared_ptr<TasInput::Tas> tas_input;
-};
-
-/// An analog device factory that creates analog devices from tas
-class TasAnalogFactory final : public Input::Factory<Input::AnalogDevice> {
-public:
- explicit TasAnalogFactory(std::shared_ptr<TasInput::Tas> tas_input_);
-
- std::unique_ptr<Input::AnalogDevice> Create(const Common::ParamPackage& params) override;
-
-private:
- std::shared_ptr<TasInput::Tas> tas_input;
-};
-
-} // namespace InputCommon