feat: allow pre-processing of some tools

this resolves issues where some basic tools (like use or cmd) would not be processed correctly due to being executed late into user cmd processing (which is required for other tools because of altticks handling)

Author: Krzyhau

src/Features/Tas/TasController.cpp

@@ -110,9 +110,8 @@ void TasController::SetButtonState(TasControllerInput i, bool state) {
 std::chrono::time_point<std::chrono::high_resolution_clock> g_lastControllerMove;
 
 void TasController::ControllerMove(int nSlot, float flFrametime, CUserCmd *cmd) {
-	// ControllerMove is executed several times for one tick, idk why,
-	// but only once with tick_count bigger than 0. Working only
-	// on these seems to work fine, so I assume these are correct.
+	// ControllerMove is executed several times for one tick. Most of them
+	// are called from ExtraMouseSamples with 0 tick count. We want to filter them out.
 	if (cmd->tick_count == 0) return;
 
 	// doing some debugs to test the behaviour of the real controller
@@ -141,7 +140,7 @@ void TasController::ControllerMove(int nSlot, float flFrametime, CUserCmd *cmd)
 
 	//console->Print("TasController::ControllerMove (%d, ", cmd->tick_count);
 
-	tasPlayer->FetchInputs(nSlot, this);
+	tasPlayer->FetchInputs(nSlot, this, cmd);
 
 	//TAS is now controlling inputs. Reset everything we can.
 	cmd->forwardmove = 0;

src/Features/Tas/TasParser.hpp

@@ -1,7 +1,7 @@
 #pragma once
 #include "TasScript.hpp"
 
-#define MAX_SCRIPT_VERSION 8
+#define MAX_SCRIPT_VERSION 9
 
 #include <iostream>
 #include <string>

src/Features/Tas/TasPlayer.cpp

@@ -154,8 +154,8 @@ void TasPlayer::Activate(TasPlaybackInfo info) {
 	for (int slot = 0; slot < 2; ++slot) {
 		playbackInfo.slots[slot].ClearGeneratedContent();
 
-		currentInputFramebulkIndex[slot] = 0;
-		currentToolsFramebulkIndex[slot] = 0;
+		currentRequestRawFramebulkIndex[slot] = 0;
+	
 	}
 
 	active = true;
@@ -350,6 +350,28 @@ TasFramebulk TasPlayer::GetRawFramebulkAt(int slot, int tick, unsigned& cachedIn
 	return playbackInfo.slots[slot].framebulks[cachedIndex];
 }
 
+TasFramebulk &TasPlayer::RequestProcessedFramebulkAt(int slot, int tick) {
+	auto &processed = playbackInfo.slots[slot].processedFramebulks;
+	auto processedCount = processed.size();
+
+	if (processedCount == 0 || processed.back().tick < tick) {
+		TasFramebulk fb = GetRawFramebulkAt(slot, tick, currentRequestRawFramebulkIndex[slot]);
+		processed.push_back(fb);
+		return processed.back();
+	}
+
+	// if it already exists, it should be near the end, as we usually request the newest ones
+	for (int index = processedCount - 1; index >= 0; --index) {
+		if (processed[index].tick == tick) {
+			return processed[index];
+		} else if (processed[index].tick < tick) {
+			break;
+		}
+	}
+
+	console->Warning("TAS processed framebulk for tick %d not found! This should not happen!\n", tick);
+}
+
 TasPlayerInfo TasPlayer::GetPlayerInfo(int slot, void *player, CUserCmd *cmd, bool clientside) {
 	TasPlayerInfo pi;
 
@@ -540,7 +562,7 @@ void TasPlayer::SaveProcessedFramebulks() {
     we assume the response time for our "virtual controller" to be
     non-existing and just let it parse inputs corresponding to given tick.
 */
-void TasPlayer::FetchInputs(int slot, TasController *controller) {
+void TasPlayer::FetchInputs(int slot, TasController *controller, CUserCmd* cmd) {
 	// Slight hack! Input fetching (including SteamControllerMove) is
 	// called through _Host_RunFrame_Input, which is called *before*
 	// GameFrame (that being called via _Host_RunFrame_Server). Therefore,
@@ -549,36 +571,23 @@ void TasPlayer::FetchInputs(int slot, TasController *controller) {
 	// said than done since the input fetching code is only run when the
 	// client is connected, so to match the behaviour we'd probably need
 	// to actually hook at _Host_RunFrame_Input or CL_Move.
-	int tick = currentTick + 1;
-
-	TasFramebulk fb = GetRawFramebulkAt(slot, tick, currentInputFramebulkIndex[slot]);
+	int tasTick = currentTick + 1;
 
-	int fbTick = fb.tick;
+	auto player = server->GetPlayer(slot + 1);
 
-	if (sar_tas_debug.GetInt() > 0 && fbTick == tick) {
-		console->Print("%s\n", fb.ToString().c_str());
+	if (tasTick == 1) {
+		SamplePreProcessedFramebulk(slot, 0, player, cmd);
 	}
 
+	TasFramebulk fb = SamplePreProcessedFramebulk(slot, tasTick, player, cmd);
+
 	controller->SetViewAnalog(fb.viewAnalog.x, fb.viewAnalog.y);
 	controller->SetMoveAnalog(fb.moveAnalog.x, fb.moveAnalog.y);
 	for (int i = 0; i < TAS_CONTROLLER_INPUT_COUNT; i++) {
 		controller->SetButtonState((TasControllerInput)i, fb.buttonStates[i]);
 	}
-
-	if (tick == 1) {
-		// on tick 1, we'll run the commands from the bulk at tick 0 because
-		// of the annoying off-by-one thing explained above
-		TasFramebulk fb0 = GetRawFramebulkAt(slot, 0);
-		for (std::string cmd : fb0.commands) {
-			controller->AddCommandToQueue(cmd);
-		}
-	}
-
-	// add commands only for tick when framebulk is placed. Don't preserve it to other ticks.
-	if (tick == fbTick) {
-		for (std::string cmd : fb.commands) {
-			controller->AddCommandToQueue(cmd);
-		}
+	for (std::string cmd : fb.commands) {
+		controller->AddCommandToQueue(cmd);
 	}
 }
 
@@ -591,6 +600,52 @@ static bool IsTaunting(ClientEnt *player) {
 	return false;
 }
 
+TasFramebulk TasPlayer::SamplePreProcessedFramebulk(int slot, int tasTick, void *player, CUserCmd *cmd) {
+
+	auto pInfo = GetPlayerInfo(slot, server->GetPlayer(slot + 1), cmd);
+	TasFramebulk& fb = RequestProcessedFramebulkAt(slot, tasTick);
+
+	auto fbTick = fb.tick;
+	fb.tick = tasTick;
+	bool framebulkUpdated = (fbTick == tasTick);
+
+	if (sar_tas_debug.GetInt() > 0 && framebulkUpdated) {
+		console->Print("(TAS:  rawtick) %s\n", fb.ToString().c_str());
+	}
+
+	if (tasTick == 0 || !framebulkUpdated) {
+		std::vector<std::string> emptyCommands;
+		fb.commands = emptyCommands;
+	}
+
+	if (!framebulkUpdated) {
+		std::vector<TasToolCommand> emptyToolCmds;
+		fb.toolCmds = emptyToolCmds;
+	}
+
+	if (tasTick == 1) {
+		// on tick 1, we'll run the commands from the bulk at tick 0 because
+		// of the annoying off-by-one thing explained in FetchInputs
+		TasFramebulk fb0 = GetRawFramebulkAt(slot, 0);
+
+		if (fb0.tick == 0) {
+			for (std::string cmd : fb0.commands) {
+				fb.commands.push_back(cmd);
+			}
+		}
+	}
+
+	if (IsUsingTools()) {
+		ApplyTools(fb, pInfo, PRE_PROCESSING);
+
+		if (sar_tas_debug.GetInt() > 0) {
+			console->Print("(TAS:  pretick) %s\n", fb.ToString().c_str());
+		}
+	}
+
+	return fb;
+}
+
 // special tools have to be parsed in input processing part.
 // because of alternateticks, a pair of inputs are created and then executed at the same time,
 // meaning that second tick in pair reads outdated info.
@@ -603,18 +658,7 @@ void TasPlayer::PostProcess(int slot, void *player, CUserCmd *cmd) {
 	// every other way of getting time is incorrect due to alternateticks
 	int tasTick = FetchCurrentPlayerTickBase(player) - startTick;
 
-	TasFramebulk fb = GetRawFramebulkAt(slot, tasTick, currentToolsFramebulkIndex[slot]);
-
-	// update all tools that needs to be updated
-	auto fbTick = fb.tick;
-	fb.tick = tasTick;
-	if (fbTick == tasTick) {
-		for (TasToolCommand cmd : fb.toolCmds) {
-			auto tool = TasTool::GetInstanceByName(slot, cmd.tool->GetName());
-			if (tool == nullptr) continue;
-			tool->SetParams(cmd.params);
-		}
-	}
+	TasFramebulk& fb = RequestProcessedFramebulkAt(slot, tasTick);
 
 	auto playerInfo = GetPlayerInfo(slot, player, cmd);
 
@@ -634,21 +678,7 @@ void TasPlayer::PostProcess(int slot, void *player, CUserCmd *cmd) {
 		return;
 	}
 
-	// applying tools
-	if (playbackInfo.slots[slot].header.version >= 3) {
-		// use priority list for newer versions. technically all tools should be in the list
-		for (std::string toolName : TasTool::priorityList) {
-			auto tool = TasTool::GetInstanceByName(slot, toolName);
-			if (tool == nullptr) continue;
-			tool->Apply(fb, playerInfo);
-		}
-	} else {
-		// use old "earliest first" ordering system (partially also present in TasTool::SetParams)
-		for (TasTool *tool : TasTool::GetList(slot)) {
-			tool->Apply(fb, playerInfo);
-		}
-	}
-
+	ApplyTools(fb, playerInfo, POST_PROCESSING);
 
 	// make sure none of the framebulk is NaN
 	if (std::isnan(fb.moveAnalog.x)) fb.moveAnalog.x = 0;
@@ -717,13 +747,9 @@ void TasPlayer::PostProcess(int slot, void *player, CUserCmd *cmd) {
 		SE(player)->fieldOff<CUserCmd>("m_hViewModel", 8) /* m_LastCmd */ = *cmd;
 	}
 
-	// put processed framebulk in the list
-	if (fbTick != tasTick) {
-		std::vector<std::string> empty;
-		fb.commands = empty;
+	if (sar_tas_debug.GetInt() > 0) {
+		console->Print("(TAS: posttick) %s\n", fb.ToString().c_str());
 	}
-	playbackInfo.slots[slot].processedFramebulks.push_back(fb);
-
 	tasPlayer->DumpUsercmd(slot, cmd, tasTick, "processed");
 }
 
@@ -756,6 +782,46 @@ void TasPlayer::ApplyMoveAnalog(Vector moveAnalog, CUserCmd *cmd) {
 	}
 }
 
+void TasPlayer::ApplyTools(TasFramebulk &fb, const TasPlayerInfo &pInfo, TasToolProcessingType processType) {
+	int slot = pInfo.slot;
+	
+	for (TasToolCommand cmd : fb.toolCmds) {
+		auto tool = TasTool::GetInstanceByName(slot, cmd.tool->GetName());
+		if (!CanProcessTool(tool, processType)) continue;
+		tool->SetParams(cmd.params);
+	}
+
+	FOR_TAS_SCRIPT_VERSIONS_UNTIL(2) {
+		// use old "earliest first" ordering system (partially also present in TasTool::SetParams)
+		for (TasTool *tool : TasTool::GetList(slot)) {
+			if (!CanProcessTool(tool, processType)) continue;
+			tool->Apply(fb, pInfo);
+		}
+		return;
+	}
+
+	// use priority list for newer versions. technically all tools should be in the list
+	for (std::string toolName : TasTool::priorityList) {
+		auto tool = TasTool::GetInstanceByName(slot, toolName);
+		if (!CanProcessTool(tool, processType)) continue;
+		tool->Apply(fb, pInfo);
+	}
+}
+
+bool TasPlayer::CanProcessTool(TasTool *tool, TasToolProcessingType processType) {
+	if (tool == nullptr) {
+		return false;
+	}
+
+	int slot = tool->GetSlot();
+	FOR_TAS_SCRIPT_VERSIONS_UNTIL(8) {
+		// old scripts process all tools in post processing
+		return processType == POST_PROCESSING;
+	}
+
+	return tool->CanProcess(processType);
+}
+
 void TasPlayer::DumpUsercmd(int slot, const CUserCmd *cmd, int tick, const char *source) {
 	if (!sar_tas_dump_usercmd.GetBool()) return;
 	std::string str = Utils::ssprintf("%s,%d,%.6f,%.6f,%08X,%.6f,%.6f,%.6f", source, tick, cmd->forwardmove, cmd->sidemove, cmd->buttons, cmd->viewangles.x, cmd->viewangles.y, cmd->viewangles.z);

src/Features/Tas/TasPlayer.hpp

@@ -1,15 +1,15 @@
 #pragma once
 
-#include "TasScript.hpp"
 #include "Command.hpp"
 #include "Features/Feature.hpp"
 #include "Features/Tas/TasController.hpp"
 #include "Features/Tas/TasTool.hpp"
-#include "Utils/SDK.hpp"
-#include "Variable.hpp"
-#include "Modules/Engine.hpp"
 #include "Modules/Client.hpp"
+#include "Modules/Engine.hpp"
 #include "Modules/Server.hpp"
+#include "TasScript.hpp"
+#include "Utils/SDK.hpp"
+#include "Variable.hpp"
 
 #define TAS_SCRIPTS_DIR "tas"
 #define TAS_SCRIPT_EXT "p2tas"
@@ -38,7 +38,7 @@ struct TasPlaybackInfo {
 		if (coopControlSlot >= 0 && slots[1 - coopControlSlot].IsActive()) {
 			return slots[1 - coopControlSlot];
 		}
-		return slots[0].IsActive() ? slots[0] : slots[1]; 
+		return slots[0].IsActive() ? slots[0] : slots[1];
 	}
 	inline TasScriptHeader GetMainHeader() const { return GetMainScript().header; }
 };
@@ -72,11 +72,11 @@ class TasPlayer : public Feature {
 	int currentTick = 0;  // tick position of script player, relative to its starting point.
 	int lastTick = 0;     // last tick of script, relative to its starting point
 
-	int wasEnginePaused = false; // Used to check if we need to revert incrementing a tick
+	int wasEnginePaused = false;  // Used to check if we need to revert incrementing a tick
 
 	// used to cache last used framebulk to quickly access it for playback
-	unsigned currentInputFramebulkIndex[2];
-	unsigned currentToolsFramebulkIndex[2];
+	unsigned currentRequestRawFramebulkIndex[2];
+
 public:
 	void Update();
 	void UpdateServer();
@@ -89,9 +89,8 @@ class TasPlayer : public Feature {
 	inline bool IsReady() const { return ready; };
 	inline bool IsRunning() const { return active && startTick != -1; }
 	inline bool IsPaused() const { return paused; }
-	inline bool IsUsingTools() const { 
-		return (playbackInfo.slots[0].IsActive() && !playbackInfo.slots[0].IsRaw()) 
-			|| (playbackInfo.slots[1].IsActive() && !playbackInfo.slots[1].IsRaw());
+	inline bool IsUsingTools() const {
+		return (playbackInfo.slots[0].IsActive() && !playbackInfo.slots[0].IsRaw()) || (playbackInfo.slots[1].IsActive() && !playbackInfo.slots[1].IsRaw());
 	}
 	inline int GetScriptVersion(int slot) const { return playbackInfo.slots[slot].header.version; }
 
@@ -102,15 +101,16 @@ class TasPlayer : public Feature {
 	void Activate(TasPlaybackInfo info);
 	void Start();
 	void PostStart();
-	void Stop(bool interrupted=false);
-	void Replay(bool automatic=false);
+	void Stop(bool interrupted = false);
+	void Replay(bool automatic = false);
 
 	void Pause();
 	void Resume();
 	void AdvanceFrame();
 
 	TasFramebulk GetRawFramebulkAt(int slot, int tick);
 	TasFramebulk GetRawFramebulkAt(int slot, int tick, unsigned &cachedIndex);
+	TasFramebulk &RequestProcessedFramebulkAt(int slot, int tick);
 
 	TasPlayerInfo GetPlayerInfo(int slot, void *player, CUserCmd *cmd, bool clientside = false);
 	int FetchCurrentPlayerTickBase(void *player, bool clientside = false);
@@ -119,9 +119,12 @@ class TasPlayer : public Feature {
 	void SaveUsercmdDebugs(int slot);
 	void SavePlayerInfoDebugs(int slot);
 
-	void FetchInputs(int slot, TasController *controller);
+	void FetchInputs(int slot, TasController *controller, CUserCmd *cmd);
+	TasFramebulk SamplePreProcessedFramebulk(int slot, int tasTick, void *player, CUserCmd *cmd);
 	void PostProcess(int slot, void *player, CUserCmd *cmd);
 	void ApplyMoveAnalog(Vector moveAnalog, CUserCmd *cmd);
+	void ApplyTools(TasFramebulk &fb, const TasPlayerInfo &pInfo, TasToolProcessingType processType);
+	bool CanProcessTool(TasTool *tool, TasToolProcessingType processType);
 	void DumpUsercmd(int slot, const CUserCmd *cmd, int tick, const char *source);
 	void DumpPlayerInfo(int slot, int tick, Vector pos, Vector eye_pos, QAngle ang);