alterware/iw6-mod
1
0
Fork 4
Code Issues Pull Requests 13 Packages Projects Releases Wiki Activity

Resolved merge conflicts. #17

Open
anomaly wants to merge 15 commits from anomaly/iw6-mod:master into master
pull from: anomaly/iw6-mod:master
merge into: alterware:master
Conversation 0 Commits 15 Files Changed 44 +4263
9 changed files with 4263 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit c3a7f63336 - Show all commits

946
src/client/component/demo_playback.cpp Normal file
View File

@ -0,0 +1,946 @@
#include "std_include.hpp"
#include "loader/component_loader.hpp"
#include "demo_playback.hpp"
#include "demo_utils.hpp"
#include "command.hpp"
#include "console.hpp"
#include "scheduler.hpp"
#include "utils/command_line.hpp"
#include "utils/hook.hpp"
using namespace demo_utils;
namespace // demo class
{
class demo_playback_t
{
public:
demo_playback_t();
[[nodiscard]] bool is_demo_playing() const;
[[nodiscard]] bool is_demo_repeating() const;
[[nodiscard]] const std::optional<gamestate_t>& get_gamestate() const;
[[nodiscard]] bool rewind_demo(std::optional<std::uint32_t> msec);
[[nodiscard]] bool start(std::filesystem::path& path, bool repeat);
[[nodiscard]] std::optional<std::reference_wrapper<std::filesystem::path>> restart();
template <typename Func, typename... Args> auto use_predicted_data(Func func, Args&&... args);
template <typename Func, typename... Args> auto handle_fast_forward(Func func, Args&&... args);
void parse_demo_wrapper();
void stop();
private:
void repeat();
bool repeat_{};
bool skip_timeout_{};
bool retain_timescale_{};
std::size_t post_map_header_file_offset_{};
std::size_t pred_data_index_{};
std::array<predicted_data_t, 256> pred_data_{};
std::optional<std::int32_t> rewind_snap_svr_time_;
std::optional<gamestate_t> gs_;
std::vector<std::uint8_t> buffer_;
std::filesystem::path path_;
std::ifstream file_;
} demo;
demo_playback_t::demo_playback_t()
{
buffer_.reserve(MAX_SIZE);
}
bool demo_playback_t::is_demo_playing() const
{
return file_.good() && file_.is_open();
}
bool demo_playback_t::is_demo_repeating() const
{
return repeat_;
}
const std::optional<gamestate_t>& demo_playback_t::get_gamestate() const
{
return gs_;
}
template <typename Func, typename ...Args>
auto demo_playback_t::use_predicted_data(Func func, Args&& ...args)
{
return func(pred_data_, pred_data_index_, std::forward<Args>(args)...);
}
template <typename Func, typename ...Args>
auto demo_playback_t::handle_fast_forward(Func func, Args&& ...args)
{
return func(rewind_snap_svr_time_, skip_timeout_, std::forward<Args>(args)...);
}
bool demo_playback_t::rewind_demo(std::optional<std::uint32_t> msec)
{
if (!is_demo_playing())
{
return false;
}
// trigger demo end-of-file which will repeat the demo
repeat_ = true;
file_.seekg(0, std::ios::end);
if (msec)
{
retain_timescale_ = true;
const auto snap_svr_time = game::mp::cl->snap.serverTime;
if (const auto delta_time = snap_svr_time - static_cast<std::int32_t>(*msec) - 50; delta_time > 0)
{
rewind_snap_svr_time_ = delta_time;
}
}
// workaround to get rewinding working without delay at low timescales
fast_forward_demo(1000);
return true;
}
bool demo_playback_t::start(std::filesystem::path& path, bool repeat)
{
// check if the file can be opened before taking any action with the demo file stream
std::ifstream file(path, std::ios::binary);
const auto can_open = file.good() && file.is_open();
if (!can_open)
{
return false;
}
stop();
file_ = std::move(file);
assert(file_.good() && file_.is_open());
// (re)set data
repeat_ = repeat;
gs_.reset();
path_ = std::move(path);
get_persistent_data() = {};
if (auto* demo_timescale = game::Dvar_FindVar("demotimescale"); demo_timescale)
{
demo_timescale->current.value = 1.0f;
}
if (game::Live_SyncOnlineDataFlags(0))
{
console::info("the demo should start to load in a few seconds\n");
}
return true;
}
std::optional<std::reference_wrapper<std::filesystem::path>> demo_playback_t::restart()
{
if (!start(path_, repeat_))
{
return path_;
}
return std::nullopt;
}
void demo_playback_t::parse_demo_wrapper()
{
if (!parse_demo(file_, buffer_, post_map_header_file_offset_, pred_data_, pred_data_index_, gs_))
{
if (is_demo_repeating() && *game::mp::connstate != game::CA_DISCONNECTED)
{ // don't repeat demo if it was stopped manually
repeat();
}
else
{
stop();
}
}
assert(*game::mp::connstate != game::CA_DISCONNECTED || !is_demo_playing());
}
void demo_playback_t::stop()
{
skip_timeout_ = {};
retain_timescale_ = {};
post_map_header_file_offset_ = {};
pred_data_index_ = {};
pred_data_.fill({});
rewind_snap_svr_time_ = {};
gs_.reset();
buffer_.clear();
file_.clear();
file_.close();
// ensure that sv_cheats is always disabled after demo playback
if (auto* sv_cheats = game::Dvar_FindVar("sv_cheats"); sv_cheats)
{
sv_cheats->current.enabled = false;
}
}
void demo_playback_t::repeat()
{
assert(post_map_header_file_offset_ < 256);
if (auto& connstate = *game::mp::connstate; connstate == game::CA_ACTIVE)
{
// prevent old snapshots from being processed; would mess up the server command sequences
connstate = game::CA_PRIMED;
}
// reset game data
game::mp::clc->serverCommandSequence = {};
game::mp::clc->lastExecutedServerCommand = {};
game::mp::cgs->serverCommandSequence = {};
get_persistent_data() = {};
if (auto* demo_timescale = game::Dvar_FindVar("demotimescale"); demo_timescale)
{
if (!retain_timescale_)
{
demo_timescale->current.value = 1.0f;
}
}
// reset class data
skip_timeout_ = {};
retain_timescale_ = {};
pred_data_index_ = {};
file_.clear();
file_.seekg(post_map_header_file_offset_, std::ios::beg);
}
}
namespace // hooks
{
utils::hook::detour CG_UpdateOmnvars_hook;
utils::hook::detour CG_VisionSetStartLerp_To_hook;
utils::hook::detour CL_GetPredictedPlayerInformationForServerTime_hook;
utils::hook::detour CL_GetPredictedVehicleForServerTime_hook;
utils::hook::detour CL_SetCGameTime_hook;
utils::hook::detour CL_WritePacket_hook;
utils::hook::detour GetRemoteEyeValues_hook;
utils::hook::detour LUI_IntermissionBegan_hook;
utils::hook::detour VehicleCam_UpdatePlayerControlCam_hook;
game::dvar_t* demo_vision;
static constexpr std::array VISION_SETS{
"disabled", "no vision", "default",
"ac130", "ac130_enhanced_mp", "ac130_inverted", "aftermath", "aftermath_glow", "aftermath_post", "black_bw",
"cheat_bw", "coup_sunblind", "default_night", "default_night_mp", "end_game", "missilecam", "mpintro",
"mpnuke", "mpnuke_aftermath", "mpoutro", "near_death", "near_death_mp", "nuke_global_flash", "thermal_mp", "thermal_snowlevel_mp",
"aftermath_map", static_cast<const char*>(nullptr)
};
static_assert(
std::string_view(VISION_SETS[0]) == "disabled" &&
std::string_view(VISION_SETS[1]) == "no vision" &&
std::string_view(VISION_SETS[2]) == "default" &&
std::string_view(VISION_SETS[VISION_SETS.size() - 2]) == "aftermath_map" &&
VISION_SETS.back() == nullptr // enum dvars require a nullptr as last value
);
bool handle_vision_override(game::mp::ClientVisionSetData& cvs_data, std::int32_t index, const char* vision_name, std::int32_t duration, std::int32_t time)
{
if (demo.is_demo_playing())
{
const auto vision_set = static_cast<std::size_t>((demo_vision) ? demo_vision->current.integer : 0);
if (vision_set == 1)
{
// enable 'post apply' vision
cvs_data.visionSetLerpData[index].style = 1;
cvs_data.postApplyLerpDest = 1.0f;
return true;
}
else if (vision_set >= 2 && vision_set + 2 <= VISION_SETS.size())
{
// enable 'post apply' vision
cvs_data.visionSetLerpData[index].style = 0;
cvs_data.postApplyLerpDest = 1.0f;
if (vision_set + 2 == VISION_SETS.size())
{
if (const auto mapname = get_mapname(false); mapname.empty())
{
return CG_VisionSetStartLerp_To_hook.invoke<bool>(&cvs_data, index, "aftermath_post", duration, time);
}
else
{
// a small number of maps have a vision called 'aftermath_mp_mapname'
return CG_VisionSetStartLerp_To_hook.invoke<bool>(&cvs_data, index, std::format("aftermath_{}", mapname).c_str(), duration, time);
}
}
else
{
return CG_VisionSetStartLerp_To_hook.invoke<bool>(&cvs_data, index, VISION_SETS[vision_set], duration, time);
}
}
}
return CG_VisionSetStartLerp_To_hook.invoke<bool>(&cvs_data, index, vision_name, duration, time);
}
void handle_vision()
{
if (demo_vision && demo_vision->modified)
{
const auto vision_set = demo_vision->current.integer;
for (auto i = 0; i < game::CS_VISIONSET_COUNT; ++i)
{
const std::string_view vision_name = (!vision_set)
? game::mp::cg->cvsData.visionName[i]
: "";
handle_vision_override(game::mp::cg->cvsData, i, vision_name.data(), 1, game::mp::cl->serverTime);
}
if (!vision_set)
{
// disable 'post apply' vision if the game hasn't used it yet
if (game::mp::cg->cvsData.visionName[5][0] == '\0')
{
game::mp::cg->cvsData.postApplyLerpDest = 0.0f;
}
}
else if (vision_set == 1)
{
std::memset(&game::mp::cg->cvsData.visionSetCurrent, 0, sizeof(game::mp::cg->cvsData.visionSetCurrent));
}
// reset modified flag to avoid doing the same work each frame
demo_vision->modified = false;
}
}
void handle_fast_forward(auto old_connstate)
{
if (const auto new_connstate = *game::mp::connstate; new_connstate == game::CA_ACTIVE)
{
const auto server_time = game::mp::cl->serverTime;
const auto snap_svr_time = game::mp::cl->snap.serverTime;
demo.handle_fast_forward([old_connstate, server_time, snap_svr_time](
std::optional<std::int32_t>& rewind_snap_svr_time, bool& skip_timeout)
{
if (old_connstate == game::CA_PRIMED)
{
if (rewind_snap_svr_time)
{
// handle fast forward after rewinding
if (*rewind_snap_svr_time > snap_svr_time)
{
fast_forward_demo(*rewind_snap_svr_time - snap_svr_time);
}
rewind_snap_svr_time = {};
}
}
else if (old_connstate == game::CA_ACTIVE && !skip_timeout)
{
if (const auto delta_time = snap_svr_time - server_time; delta_time >= 1000)
{
// skip timeout between first and second snapshots (for user demos)
fast_forward_demo(delta_time);
skip_timeout = true;
}
}
});
}
}
void handle_demo_patches()
{
// set cg_t->demoType to DEMO_TYPE_CLIENT to disable mouse input and avoid frame interpolation issues
game::mp::cg->demoType = game::mp::DEMO_TYPE_CLIENT;
// ensure that sv_cheats is always enabled during demo playback
if (auto* sv_cheats = game::Dvar_FindVar("sv_cheats"); sv_cheats)
{
sv_cheats->current.enabled = true;
}
// sometimes the hud isn't updated after a weapon change; force update the weapon name and ammo (clip) when changing weapons
// various other Call of Duty games are also affected by this bug
if (game::mp::cg->weaponSelect.data != static_cast<std::size_t>(game::mp::cg->ps.weapon))
{
game::CG_SelectWeapon(0, game::mp::cg->ps.weapon, 0);
}
}
void handle_demo_reading(const std::int32_t client_num)
{
if (game::Live_SyncOnlineDataFlags(0) || !demo.is_demo_playing())
{
// set demoType to default value
// normally the game does this unconditionally, but that code has been removed
game::mp::cg->demoType = game::mp::DEMO_TYPE_NONE;
CL_SetCGameTime_hook.invoke<void>(client_num);
}
else
{
const auto old_connstate = *game::mp::connstate;
if (old_connstate == game::CA_ACTIVE)
{
// reset cl->newSnapshots to prevent CL_SetCGameTime from making a call to CL_AdjustTimeDelta,
// which interferes with the timescale
game::mp::cl->newSnapshots = 0;
}
CL_SetCGameTime_hook.invoke<void>(client_num);
handle_fast_forward(old_connstate);
handle_vision();
handle_demo_patches();
demo.parse_demo_wrapper();
}
}
void write_packet(const std::int32_t client_num)
{
if (!demo.is_demo_playing())
{
CL_WritePacket_hook.invoke<void>(client_num);
}
}
bool get_predicted_player_data(const game::mp::clientActive_t& cl, std::int32_t ps_time, game::mp::playerState_t& ps)
{
if (!demo.is_demo_playing())
{
return CL_GetPredictedPlayerInformationForServerTime_hook.invoke<bool>(&cl, ps_time, &ps);
}
// hide regular hud when showing special hud for killstreak reward
// must not unset this 15th bit when dead to avoid a crash in CG_SimulateBulletFire
ps.otherFlags = (ps.pm_type == 7 || ps.remoteControlEnt != 2047 || ps.vehicleState.entity != 2047)
? ps.otherFlags | 0x4000
: ps.otherFlags & ~0x4000;
demo.use_predicted_data([&ps, ps_time](const std::array<predicted_data_t, 256>& pred_data, std::size_t pred_data_index)
{
static constexpr auto pred_data_size = std::tuple_size_v<std::remove_reference_t<decltype(pred_data)>>;
// find most recent predicted player data
for (std::size_t count = 0, index = pred_data_index - 1; count < pred_data_size; ++count, --index)
{
const auto& p_data = pred_data[index % pred_data_size];
if (p_data.cad.serverTime <= ps_time && ps_time - p_data.cad.serverTime < 500)
{
std::memcpy(&ps.origin[0], &p_data.cad.origin[0], sizeof(ps.origin));
std::memcpy(&ps.velocity[0], &p_data.cad.velocity[0], sizeof(ps.velocity));
std::memcpy(&ps.viewangles[0], &p_data.viewangles[0], sizeof(ps.viewangles));
ps.bobCycle = p_data.cad.bobCycle;
ps.movementDir = p_data.cad.movementDir;
break;
}
}
});
// must return true otherwise branch is taken that undoes the work of this function
return true;
}
bool get_predicted_vehicle_data(const game::mp::clientActive_t& cl, std::int32_t ps_time, game::PlayerVehicleState& ps_vehicle)
{
if (!demo.is_demo_playing())
{
return CL_GetPredictedVehicleForServerTime_hook.invoke<bool>(&cl, ps_time, &ps_vehicle);
}
demo.use_predicted_data([&ps_vehicle, ps_time](const std::array<predicted_data_t, 256>& pred_data, std::size_t pred_data_index)
{
static constexpr auto pred_data_size = std::tuple_size_v<std::remove_reference_t<decltype(pred_data)>>;
// find most recent predicted vehicle data
for (std::size_t count = 0, index = pred_data_index - 1; count < pred_data_size; ++count, --index)
{
const auto& p_data = pred_data[index % pred_data_size];
if (p_data.cad.serverTime <= ps_time && ps_time - p_data.cad.serverTime < 500)
{
const auto org_entity = ps_vehicle.entity;
ps_vehicle = p_data.cad.playerVehStateClientArchive;
ps_vehicle.entity = org_entity;
break;
}
}
});
// must return true otherwise branch is taken that undoes the work of this function
return true;
}
bool show_intermission_menu(const std::int32_t client_num, void* lua_vm)
{
// it appeared easier to prevent the intermission menu from being shown instead of closing or hiding it
if (!demo.is_demo_playing() || !demo.is_demo_repeating())
{
return LUI_IntermissionBegan_hook.invoke<bool>(client_num, lua_vm);
}
// rewind demo and don't display intermission menu for repeated demos
static_cast<void>(demo.rewind_demo(std::nullopt));
return false;
}
void control_ui_element(const std::int32_t client_num, const game::mp::snapshot_t& old_snap, game::mp::snapshot_t& new_snap)
{
// it appeared easier to prevent these menus from being shown instead of closing or hiding them
if (demo.is_demo_playing())
{
// skip team selection menu (and loadout selection menu)
assert(std::string_view(*reinterpret_cast<const char**>(game::Omnvar_GetDef(103))) == "ui_options_menu");
new_snap.omnvars[103] = {};
if (demo.is_demo_repeating())
{
// skip extinction mode end-of-game score / stats menu
assert(std::string_view(*reinterpret_cast<const char**>(game::Omnvar_GetDef(194))) == "ui_alien_show_eog_score");
new_snap.omnvars[194] = {};
}
}
CG_UpdateOmnvars_hook.invoke<void>(client_num, &old_snap, &new_snap);
}
std::int32_t update_gamestate_config_strings(game::msg_t& msg)
{
if (demo.is_demo_playing())
{
// update command sequences and overwrite config strings if that data is available
if (const auto& gs = demo.get_gamestate(); gs)
{
game::mp::cls->gameState = gs->data;
game::mp::clc->serverCommandSequence = gs->svr_cmd_seq;
game::mp::clc->lastExecutedServerCommand = gs->svr_cmd_seq;
game::mp::cgs->serverCommandSequence = gs->svr_cmd_seq;
}
else
{
assert(is_gamestate_valid(game::mp::cls->gameState, false));
game::mp::clc->lastExecutedServerCommand = game::mp::clc->serverCommandSequence;
game::mp::cgs->serverCommandSequence = game::mp::clc->serverCommandSequence;
}
}
// call MSG_ReadLong that this hook replaces
return game::MSG_ReadLong(&msg);
}
void ignore_mouse_input_killstreak_reward_1(const std::int32_t client_num, game::mp::cg_t& cg, game::vec3_t& out_view_origin, game::vec3_t& out_view_angles)
{
auto& in_killcam = cg.inKillCam;
if (!demo.is_demo_playing() || in_killcam)
{
VehicleCam_UpdatePlayerControlCam_hook.invoke<void>(client_num, &cg, &out_view_origin, &out_view_angles);
}
else
{
// required for e.g. the Gryphon killstreak reward
in_killcam = 1;
VehicleCam_UpdatePlayerControlCam_hook.invoke<void>(client_num, &cg, &out_view_origin, &out_view_angles);
in_killcam = 0;
}
}
bool ignore_mouse_input_killstreak_reward_2(const std::int32_t client_num)
{
auto& other_flags = game::mp::cg->ps.otherFlags;
if (!demo.is_demo_playing() || !(other_flags & 0x4000))
{
return GetRemoteEyeValues_hook.invoke<bool>(client_num);
}
else
{
// required for e.g. the Trinity Rocket killstreak reward
other_flags &= ~0x4000;
const auto result = GetRemoteEyeValues_hook.invoke<bool>(client_num);
other_flags |= 0x4000;
return result;
}
}
}
namespace // command execution
{
bool execute_playback_command_internal(std::filesystem::path& file_path, bool repeat, bool print_error)
{
if (demo.start(file_path, repeat))
{
return true;
}
if (print_error)
{
console::error("could not play demo %s\n", file_path.string().c_str());
}
return false;
}
bool execute_playback_command_internal(std::string_view file_name, bool repeat)
{
const auto fs_basepath = get_base_path(false);
if (fs_basepath.empty())
{
console::error("could not find fs_basepath\n");
return false;
}
const auto mod = get_mod_directory();
auto file_path1 = std::filesystem::path(fs_basepath) / std::format("demos/client/{2}/user/{0}{1}", file_name, DEMO_EXTENSION, mod);
if (execute_playback_command_internal(file_path1, repeat, false))
{
return true;
}
auto file_path2 = std::filesystem::path(fs_basepath) / std::format("demos/client/{2}/auto/{0}{1}", file_name, DEMO_EXTENSION, mod);
if (execute_playback_command_internal(file_path2, repeat, false))
{
return true;
}
auto file_path3 = std::filesystem::path(fs_basepath) / std::format("demos/client/{0}{1}", file_name, DEMO_EXTENSION);
if (execute_playback_command_internal(file_path3, repeat, false))
{
return true;
}
auto file_path4 = std::filesystem::path(fs_basepath) / std::format("demos/server/{2}/{0}{1}", file_name, DEMO_EXTENSION, mod);
if (execute_playback_command_internal(file_path4, repeat, false))
{
return true;
}
auto file_path5 = std::filesystem::path(fs_basepath) / std::format("demos/server/{0}{1}", file_name, DEMO_EXTENSION);
if (execute_playback_command_internal(file_path5, repeat, false))
{
return true;
}
auto file_path6 = std::filesystem::path(fs_basepath) / std::format("demos/{0}{1}", file_name, DEMO_EXTENSION);
if (execute_playback_command_internal(file_path6, repeat, false))
{
return true;
}
console::error("could not play demo %s\n", file_path1.string().c_str());
console::error("could not play demo %s\n", file_path2.string().c_str());
console::error("could not play demo %s\n", file_path3.string().c_str());
console::error("could not play demo %s\n", file_path4.string().c_str());
console::error("could not play demo %s\n", file_path5.string().c_str());
console::error("could not play demo %s\n", file_path6.string().c_str());
return false;
}
template <bool force_playback>
bool execute_playback_command(const command::params& params)
{
struct args_t
{
bool fullpath{};
bool repeat{};
};
auto parsed_arguments = [&params]() -> std::optional<args_t>
{
if (params.size() == 3)
{
if (std::string_view(params.get(2)) == "fullpath")
{
return args_t{ true, false };
}
else if (std::string_view(params.get(2)) == "repeat")
{
return args_t{ false, true };
}
else
{
return {};
}
}
else if (params.size() == 4)
{
if (std::string_view(params.get(2)) == "fullpath" && std::string_view(params.get(3)) == "repeat")
{
return args_t{ true, true };
}
else
{
return {};
}
}
else
{
return args_t{ false, false };
}
}();
if (params.size() < 2 || params.size() > 4 || !parsed_arguments)
{
console::info("usage: demoplay <file_name>, fullpath(optional), repeat(optional)\n");
return false;
}
if constexpr (!force_playback)
{
if (!demo.is_demo_playing() && game::CL_IsCgameInitialized())
{
console::warn("could not play demo; please disconnect first\n");
return false;
}
}
if (!parsed_arguments->fullpath)
{
return execute_playback_command_internal(params.get(1), parsed_arguments->repeat);
}
else
{
auto file_path = std::filesystem::path(params.get(1));
return execute_playback_command_internal(file_path, parsed_arguments->repeat, true);
}
}
void execute_playback_instant_play_command(const command::params& params)
{
// the demo recording code (demo_recording_t::shutdown_watcher) should take care of properly closing any recording demo files!
const auto demo_playing = demo.is_demo_playing();
if (execute_playback_command<true>(params))
{
if (auto* sv_running = game::Dvar_FindVar("sv_running"); sv_running && sv_running->current.enabled)
{
// demo cannot play if local server is still considered to be running
sv_running->current.enabled = false;
}
if (!demo_playing)
{
if (auto& connstate = *game::mp::connstate; connstate == game::CA_ACTIVE)
{
// prevent old snapshots from being processed,
// would mess up the server command sequences and server times
connstate = game::CA_PRIMED;
}
}
}
}
void execute_playback_replay_command(const command::params& params)
{
if (params.size() != 1)
{
console::info("usage: demoreplay\n");
return;
}
if (const auto path = demo.restart(); path)
{
console::error("could not play demo %s\n", path->get().string().c_str());
}
}
void execute_playback_rewind_command(const command::params& params)
{
if (params.size() < 1 || params.size() > 2)
{
console::info("usage: demorewind <milliseconds>(optional)\n");
return;
}
if (params.size() == 2)
{
const auto msec = std::atoi(params.get(1));
if (msec <= 0)
{
console::error("demorewind invalid value %s\n", params.get(1));
return;
}
if (!demo.rewind_demo(msec))
{
console::error("demo must be playing to rewind\n");
}
}
else if (!demo.rewind_demo(std::nullopt))
{
console::error("demo must be playing to rewind\n");
}
}
void execute_playback_fast_forward_command(const command::params& params)
{
if (params.size() != 2)
{
console::info("usage: demoforward <milliseconds>\n");
return;
}
const auto msec = std::atoi(params.get(1));
if (msec <= 0)
{
console::error("demoforward invalid value %s\n", params.get(1));
return;
}
if (demo.is_demo_playing())
{
fast_forward_demo(static_cast<std::uint32_t>(msec));
}
else
{
console::error("demo must be playing to fast forward\n");
}
}
}
namespace demo_playback
{
bool playing()
{
return demo.is_demo_playing();
}
bool startplay(std::string_view file_name, bool repeat)
{
return execute_playback_command_internal(file_name, repeat);
}
bool startplay(std::filesystem::path& file_name, bool repeat)
{
return execute_playback_command_internal(file_name, repeat, true);
}
void stopplay()
{
demo.stop();
}
class component final : public component_interface
{
public:
void post_unpack() override
{
if (!game::environment::is_mp())
{
return;
}
// check run-time address assertions
check_address_assertions();
// primary hook for demo playback; read demo data after server time has been updated
CL_SetCGameTime_hook.create(game::CL_SetCGameTime, handle_demo_reading);
// don't write packets when playing a demo
CL_WritePacket_hook.create(game::CL_WritePacket, write_packet);
// replace functions to get predicted data, because they skip the viewangles
CL_GetPredictedPlayerInformationForServerTime_hook.create(
game::CL_GetPredictedPlayerInformationForServerTime, get_predicted_player_data);
CL_GetPredictedVehicleForServerTime_hook.create(
game::CL_GetPredictedVehicleForServerTime, get_predicted_vehicle_data);
// ignore mouse input when updating the camera for certain killstreak rewards
VehicleCam_UpdatePlayerControlCam_hook.create(
game::VehicleCam_UpdatePlayerControlCam, ignore_mouse_input_killstreak_reward_1);
GetRemoteEyeValues_hook.create(
game::GetRemoteEyeValues, ignore_mouse_input_killstreak_reward_2);
// optional skip of intermission menu
LUI_IntermissionBegan_hook.create(game::LUI_IntermissionBegan, show_intermission_menu);
// don't open any menu when demo playback has started
CG_UpdateOmnvars_hook.create(game::CG_UpdateOmnvars, control_ui_element);
// allow user to override visual settings
CG_VisionSetStartLerp_To_hook.create(0x1402A3200, handle_vision_override);
demo_vision = game::Dvar_RegisterEnum(
"demovision", const_cast<const char**>(VISION_SETS.data()), 0, game::DVAR_FLAG_NONE, "Override vision set for demos");
// update the gamestate configs strings with 'live' data from the demo (in CL_ParseGamestate)
utils::hook::call(0x1402CCD56, update_gamestate_config_strings);
// don't let the game set cg_t->demoType in CG_DrawActiveFrame,
// otherwise demo playback will have mouse input and suffer from frame interpolation issues
utils::hook::nop(0x14029981C, 6);
// replace thread local storage lookup for cg.bgs in function CG_EmissiveBlendCommand with hardcoded address
// when CG_ExecuteNewServerCommands is called manually (e.g. from demo_utils::process_server_commands),
// this address in tls may be a nullptr and the game could crash here (in extinction mode at least)
static constexpr auto patch_address = 0x14028844B;
static constexpr std::array<std::uint8_t, 7> patch{ 0x48, 0x8D, 0x1D, 0x68, 0xBC, 0x59, 0x01 };
utils::hook::nop(patch_address, 0xE);
utils::hook::nop(patch_address + 0x1C, 4);
utils::hook::nop(patch_address + 0x22, 4);
utils::hook::copy(patch_address + 0xE, patch.data(), patch.size()); // lea rbx, [0x1418240C8] (point RBX to cg.bgs)
assert(std::bit_cast<std::size_t>(&game::mp::cg->bgs) ==
patch_address + 0xE + patch.size() + *reinterpret_cast<const std::uint32_t*>(patch_address + 0x11));
// add console command support to play demos
command::add("demoplay", execute_playback_command<false>);
// add experimental command console support to play demos,
// skip disconnecting from local or online server and skip map (re)loading
command::add("demoinstantplay", execute_playback_instant_play_command);
// replay most recent demo (if any)
command::add("demoreplay", execute_playback_replay_command);
// rewind demo (by N msec)
command::add("demorewind", execute_playback_rewind_command);
// fast forward demo by N msec
command::add("demoforward", execute_playback_fast_forward_command);
// add command line support to play demos; this makes it possible to double click on a demo file to play it
const auto& args = utils::command_line::get_args();
for (const auto& arg : args)
{
if (arg.extension() == DEMO_EXTENSION)
{
scheduler::on_game_initialized([cmd = std::format(R"(demoplay "{}" fullpath repeat)", arg.string())]() mutable
{
command::execute(std::move(cmd), true);
}, scheduler::main);
console::info("the demo should start to load in a few seconds\n");
break;
}
}
}
};
}
REGISTER_COMPONENT(demo_playback::component)

9
src/client/component/demo_playback.hpp Normal file
View File

@ -0,0 +1,9 @@
#pragma once
namespace demo_playback
{
[[nodiscard]] bool playing();
[[nodiscard]] bool startplay(std::string_view file_name, bool repeat = true);
[[nodiscard]] bool startplay(std::filesystem::path& file_path, bool repeat = true);
[[nodiscard]] void stopplay();
}

746
src/client/component/demo_recording.cpp Normal file
View File

@ -0,0 +1,746 @@
#include "std_include.hpp"
#include "loader/component_loader.hpp"
#include "demo_playback.hpp"
#include "demo_recording.hpp"
#include "demo_utils.hpp"
#include "command.hpp"
#include "console.hpp"
#include "game/game.hpp"
#include "scheduler.hpp"
#include "utils/hook.hpp"
using namespace demo_utils;
namespace // demo class
{
game::dvar_t* demo_autorecord;
class demo_recording_t
{
static constexpr auto NON_DELTA_SNAPSHOT_COUNT = 4;
struct stored_times_t
{
std::int32_t flush_time{};
std::int32_t predicted_data_time{};
std::int32_t cur_svr_time{};
std::int32_t first_svr_time_user_file{};
std::int32_t first_svr_time_auto_file{};
};
public:
demo_recording_t() = default;
~demo_recording_t();
demo_recording_t(const demo_recording_t&) = delete;
demo_recording_t(demo_recording_t&&) noexcept = delete;
demo_recording_t& operator=(const demo_recording_t&) = delete;
demo_recording_t& operator=(demo_recording_t&&) noexcept = delete;
[[nodiscard]] std::uint32_t get_demo_count() const;
[[nodiscard]] std::int32_t get_demo_length() const;
[[nodiscard]] bool is_recording() const;
[[nodiscard]] bool non_delta_data_requested() const;
[[nodiscard]] bool start(const std::filesystem::path& user_path, const std::filesystem::path& auto_path);
[[nodiscard]] bool stop();
void shutdown_watcher();
void process_network_data(auto old_connstate, auto new_connstate, std::span<const std::uint8_t> network_data);
void process_predicted_data();
private:
[[nodiscard]] bool is_auto_recording() const;
[[nodiscard]] bool non_delta_data_request_acknowledged();
[[nodiscard]] bool start_user_file(const std::filesystem::path& path);
[[nodiscard]] bool start_auto_file(const std::filesystem::path& path);
[[nodiscard]] static bool stop_internal(std::ofstream& file, std::int32_t first_svr_time, std::int32_t last_svr_time);
void flush_filestreams();
void check_auto_recording();
void process_old_data();
void process_new_gamestate(std::span<const std::uint8_t> network_data);
void process_first_snapshot(std::span<const std::uint8_t> network_data);
void process_special_network_data(auto old_connstate, auto new_connstate, std::span<const std::uint8_t> network_data);
void process_helo_pilot_turret_fire();
std::uint32_t demo_count_{};
std::uint32_t non_delta_count_{};
stored_times_t times_;
buffer_t crit_data_;
std::ofstream user_file_;
buffer_t auto_buffer_;
std::ofstream auto_file_;
} demo;
demo_recording_t::~demo_recording_t()
{
process_old_data();
}
std::uint32_t demo_recording_t::get_demo_count() const
{
return demo_count_;
}
std::int32_t demo_recording_t::get_demo_length() const
{
return (times_.cur_svr_time - times_.first_svr_time_user_file) / 1000;
}
bool demo_recording_t::is_recording() const
{
return user_file_.good() && user_file_.is_open();
}
bool demo_recording_t::is_auto_recording() const
{
return auto_file_.good() && auto_file_.is_open();
}
bool demo_recording_t::non_delta_data_requested() const
{
return non_delta_count_ > 0;
}
bool demo_recording_t::non_delta_data_request_acknowledged()
{
if (non_delta_data_requested())
{
const auto delta_num = game::mp::cl->snap.deltaNum;
if (static constexpr auto no_delta = -1; delta_num == no_delta)
{
--non_delta_count_;
return true;
}
}
return false;
}
bool demo_recording_t::start_user_file(const std::filesystem::path& path)
{
const auto crit_data = crit_data_.get();
if (!crit_data.size())
{
return false;
}
std::ofstream file(path, std::ios::binary);
if (!file.good() || !file.is_open())
{
return false;
}
write_general_header(file);
// store mod name so if there's mod support the mod can be loaded
write_mod_header(file);
// store map name and game type so that the map can be preloaded
if (!write_map_header(file))
{
return false;
}
// store the current gamestate config strings so that the original strings are overwritten if they were modified
if (!write_gamestate_data(file))
{
return false;
}
// required for demos (and live matches) to function at all
file.write(reinterpret_cast<const char*>(crit_data.data()), crit_data.size());
// set the non-delta snapshot count, the demo won't be valid otherwise
non_delta_count_ = NON_DELTA_SNAPSHOT_COUNT;
// store first server time so that demo length can be tracked
times_.first_svr_time_user_file = game::mp::cl->snap.serverTime;
// increase demo count for the text render function to work properly
++demo_count_;
user_file_ = std::move(file);
return true;
}
bool demo_recording_t::start_auto_file(const std::filesystem::path& path)
{
std::ofstream file(path, std::ios::binary);
if (!file.good() || !file.is_open())
{
return false;
}
const auto buffer = auto_buffer_.get();
file.write(reinterpret_cast<const char*>(buffer.data()), buffer.size());
auto_file_ = std::move(file);
auto_buffer_.clear();
return true;
}
bool demo_recording_t::start(const std::filesystem::path& user_path, const std::filesystem::path& auto_path)
{
if (!is_recording())
{
if (!is_auto_recording() && !start_auto_file(auto_path))
{
return false;
}
if (!start_user_file(user_path))
{
return false;
}
return true;
}
return false;
}
bool demo_recording_t::stop_internal(std::ofstream& file, std::int32_t first_svr_time, std::int32_t last_svr_time)
{
write_general_footer(file, first_svr_time, last_svr_time);
write_end_of_file(file);
file.flush();
file.close();
return file.good() && !file.is_open();
}
bool demo_recording_t::stop()
{
return is_recording() && stop_internal(user_file_, times_.first_svr_time_user_file, times_.cur_svr_time);
}
void demo_recording_t::process_old_data()
{
if (is_recording() && !stop())
{
console::error("could not stop user demo\n");
}
if (is_auto_recording() && !stop_internal(auto_file_, times_.first_svr_time_auto_file, times_.cur_svr_time))
{
console::error("could not close auto demo\n");
}
demo_count_ = {};
non_delta_count_ = {};
times_ = {};
crit_data_.clear();
auto_buffer_.clear();
assert(!is_recording());
assert(!is_auto_recording());
}
void demo_recording_t::shutdown_watcher()
{
auto execute_on_disconnect = [this, cgame_init = false]() mutable
{
if (demo_playback::playing())
{
if (is_recording() || is_auto_recording())
{
// this is only relevant when playing back demos without disconnecting from the server (instant play)
cgame_init = false;
process_old_data();
}
return;
}
if (!cgame_init && game::CL_IsCgameInitialized())
{
cgame_init = true;
}
if (cgame_init && !game::CL_IsCgameInitialized())
{
cgame_init = false;
process_old_data();
}
};
scheduler::loop(execute_on_disconnect, scheduler::main);
}
void demo_recording_t::flush_filestreams()
{
const auto real_time = game::mp::cls->realtime;
if (real_time >= times_.flush_time + 15'000)
{
times_.flush_time = real_time;
if (is_recording())
{
user_file_.flush();
}
if (is_auto_recording())
{
auto_file_.flush();
}
}
}
void demo_recording_t::check_auto_recording()
{
if (!is_auto_recording() && times_.first_svr_time_auto_file && demo_autorecord && demo_autorecord->current.enabled)
{
assert(!game::Live_SyncOnlineDataFlags(0) && game::CL_IsCgameInitialized());
const auto opt_auto_dir = create_directory_auto_demo();
if (!opt_auto_dir)
{
console::error("could not create demo auto directory\n");
return;
}
const auto opt_auto_path = create_path_auto_demo(*opt_auto_dir);
if (!opt_auto_path)
{
console::error("could not create demo auto file\n");
return;
}
if (!start_auto_file(*opt_auto_path))
{
// turn auto recording off to prevent spamming the console with errors
demo_autorecord->current.enabled = false;
console::error("could not create demo auto file %s\n", opt_auto_path->string().c_str());
return;
}
}
}
void demo_recording_t::process_new_gamestate(std::span<const std::uint8_t> network_data)
{
process_old_data();
// store gamestate for user file
write_network_data(crit_data_, network_data);
// reserve memory (low size if auto recording is enabled, because then the demo writes almost directly to disk)
const auto reserve_size = (demo_autorecord && demo_autorecord->current.enabled) ? 8192 : 1024 * 1024;
auto_buffer_.reserve_memory(reserve_size);
// write headers to auto buffer (ahead of the gamestate itself)
write_general_header(auto_buffer_);
write_mod_header(auto_buffer_);
write_map_header(auto_buffer_);
}
void demo_recording_t::process_first_snapshot(std::span<const std::uint8_t> network_data)
{
assert(!is_recording() && crit_data_.size()
&& !times_.cur_svr_time && !times_.first_svr_time_user_file && !times_.first_svr_time_auto_file);
// store first snapshot for user file
write_network_data(crit_data_, network_data);
times_.first_svr_time_auto_file = game::mp::cl->snap.serverTime;
}
void demo_recording_t::process_special_network_data(auto old_connstate, auto new_connstate, std::span<const std::uint8_t> network_data)
{
assert(new_connstate >= game::CA_PRIMED);
if (old_connstate < game::CA_LOADING)
{
assert(!game::mp::cl->snap.valid && !game::mp::cl->snap.serverTime);
process_new_gamestate(network_data);
}
else if (old_connstate >= game::CA_PRIMED)
{
if (game::mp::cl->snap.valid && game::mp::cl->snap.serverTime && !times_.cur_svr_time)
{
process_first_snapshot(network_data);
}
times_.cur_svr_time = game::mp::cl->snap.serverTime;
}
}
void demo_recording_t::process_network_data(auto old_connstate, auto new_connstate, std::span<const std::uint8_t> network_data)
{
if (new_connstate < game::CA_PRIMED)
{
return;
}
process_special_network_data(old_connstate, new_connstate, network_data);
check_auto_recording();
if (is_recording())
{
if (!non_delta_data_requested() || non_delta_data_request_acknowledged())
{
write_network_data(user_file_, network_data);
}
}
if (is_auto_recording())
{
write_network_data(auto_file_, network_data);
}
else
{
write_network_data(auto_buffer_, network_data);
}
flush_filestreams();
}
void demo_recording_t::process_helo_pilot_turret_fire()
{
const auto turret_fire = cpy_cast<std::uint8_t>(reinterpret_cast<const std::uint8_t*>(0x1419A9394));
if (turret_fire > 0)
{
if (is_recording())
{
write_helo_pilot_turret_fire(user_file_, turret_fire);
}
if (is_auto_recording())
{
write_helo_pilot_turret_fire(auto_file_, turret_fire);
}
else
{
write_helo_pilot_turret_fire(auto_buffer_, turret_fire);
}
}
}
void demo_recording_t::process_predicted_data()
{
process_helo_pilot_turret_fire();
if (is_recording())
{
// only one predicted data packet is needed per (1000 / sv_fps) msec
// the best way to limit the amount of predicted data is to attempt to predict the next playerState_t::commandTime
// because during demo playback the playerState_t::commandTime determines which predicted data is used
const auto& cl = *game::mp::cl;
const auto cmd_number = static_cast<std::size_t>(cl.cmdNumber);
const auto pred_svr_time_delta = cl.cmds[cmd_number % std::size(cl.cmds)].serverTime
- cl.cmds[(cmd_number - 1) % std::size(cl.cmds)].serverTime;
const auto pred_svr_time = cl.cgamePredictedDataServerTime;
const auto svr_time_delta = std::clamp(cl.snap.serverTime - cl.oldSnapServerTime, 50, 100);
const auto cur_cmd_time = cl.snap.ps.commandTime;
const auto next_cmd_time = cur_cmd_time + svr_time_delta;
const auto threshold = (3 * pred_svr_time_delta) / 2;
if (pred_svr_time + threshold >= next_cmd_time && next_cmd_time + threshold >= pred_svr_time)
{
times_.predicted_data_time = cl.serverTime;
write_predicted_data(user_file_);
}
else if (cl.serverTime >= times_.predicted_data_time + svr_time_delta - 5)
{
times_.predicted_data_time = cl.serverTime;
write_predicted_data(user_file_);
}
}
if (is_auto_recording())
{
write_predicted_data(auto_file_);
}
else
{
write_predicted_data(auto_buffer_);
}
}
}
namespace // hooks
{
utils::hook::detour CL_ParseServerMessage_hook;
void capture_data(const std::int32_t client_num, game::msg_t& msg)
{
const auto old_connstate = *game::mp::connstate;
CL_ParseServerMessage_hook.invoke(client_num, &msg);
const auto new_connstate = *game::mp::connstate;
if (demo_playback::playing())
{
return;
}
if (new_connstate < game::CA_DISCONNECTED || new_connstate > game::CA_ACTIVE)
{
console::warn("invalid connection state after processing data in CL_PacketEvent\n");
return;
}
if (!msg.data || msg.overflowed || static_cast<std::size_t>(msg.cursize) > MAX_SIZE)
{
if (demo.is_recording())
{
console::warn("invalid data in CL_PacketEvent\n");
}
return;
}
demo.process_network_data(old_connstate, new_connstate,
std::span<const std::uint8_t>(reinterpret_cast<const std::uint8_t*>(msg.data), msg.cursize));
}
void capture_predicted_data(game::msg_t& msg, std::int32_t value, std::uint32_t bits)
{
if (!demo_playback::playing())
{
demo.process_predicted_data();
}
// call MSG_WriteBits that this hook replaces
game::MSG_WriteBits(&msg, value, bits);
}
void request_non_delta_data(game::msg_t& msg, std::int32_t value, std::uint32_t bits)
{
if (!demo_playback::playing() && demo.non_delta_data_requested())
{
// request a non-delta snapshot from the server
// to have a valid start for a new (user) demo
value = 1;
}
// call MSG_WriteBits that this hook replaces
game::MSG_WriteBits(&msg, value, bits);
}
}
namespace // command execution
{
void add_recording_text_to_hud(const std::filesystem::path& path)
{
const auto* font = game::R_RegisterFont("fonts/normalfont");
if (!font)
{
console::error("could not register font\n");
return;
}
const auto* view_placement = game::ScrPlace_GetViewPlacement();
if (!view_placement)
{
console::error("could not find view placement\n");
return;
}
auto create_resources = [&path, font, view_placement]()
{
struct resources_t
{
const game::Font_t* font{};
float y{};
std::int32_t demo_length{};
std::uint32_t demo_count{};
std::uint32_t org_text_size{};
std::string text;
};
resources_t res{
.font = font,
.y = view_placement->realViewportSize[1],
.demo_length = demo.get_demo_length(),
.demo_count = demo.get_demo_count(),
.text = "recording: " + path.stem().string()
};
res.org_text_size = static_cast<std::uint32_t>(res.text.size());
res.text.reserve(res.text.size() + 12);
return res;
};
scheduler::schedule([res = create_resources()]() mutable
{
if (!demo.is_recording() || res.demo_count != demo.get_demo_count() || !game::CL_IsCgameInitialized())
{
return scheduler::cond_end;
}
if (res.demo_length != demo.get_demo_length())
{
res.demo_length = demo.get_demo_length();
// resize to original size and append demo length in seconds
res.text.resize(res.org_text_size);
res.text += std::format(" ({} sec)", res.demo_length);
}
static constexpr std::array<float, 4> color_red{ 178.0f / 255.0f, 34.0f / 255.0f, 34.0f / 255.0f, 1.0f };
// draw in bottom left corner
game::R_AddCmdDrawText(res.text.c_str(), std::numeric_limits<std::int32_t>::max(),
res.font, 10.0f, res.y - 5.0f, 0.75f, 0.75f, 0.0f, color_red.data(), 0);
return scheduler::cond_continue;
}, scheduler::renderer);
}
bool execute_demo_start_command_internal(std::string_view file_name, bool overwrite)
{
if (game::Live_SyncOnlineDataFlags(0) || !game::CL_IsCgameInitialized() || *game::mp::connstate != game::CA_ACTIVE)
{
console::warn("must be in a match to record a demo\n");
return false;
}
if (demo.is_recording())
{
console::warn("must stop demo recording before starting to record\n");
return false;
}
if (demo_playback::playing())
{
console::warn("cannot record a demo during demo playback\n");
return false;
}
const auto opt_user_dir = create_directory_user_demo();
if (!opt_user_dir)
{
console::error("could not create demo user directory\n");
return false;
}
const auto opt_auto_dir = create_directory_auto_demo();
if (!opt_auto_dir)
{
console::error("could not create demo auto directory\n");
return false;
}
const auto opt_user_path = (file_name.empty())
? create_path_user_demo(*opt_user_dir)
: create_path_user_demo(*opt_user_dir, file_name, overwrite);
if (!opt_user_path)
{
console::error("could not create demo user file\n");
return false;
}
const auto opt_auto_path = create_path_auto_demo(*opt_auto_dir);
if (!opt_auto_path)
{
console::error("could not create demo auto file\n");
return false;
}
if (!demo.start(*opt_user_path, *opt_auto_path))
{
console::error("could not create demo user file %s\n", opt_user_path->string().c_str());
console::error("could not create demo auto file %s\n", opt_auto_path->string().c_str());
return false;
}
add_recording_text_to_hud(*opt_user_path);
return true;
}
void execute_demo_start_command(const command::params& params)
{
if (params.size() < 1 || params.size() > 3 || (params.size() == 3 && std::string_view(params.get(2)) != "overwrite"))
{
console::info("usage: demostart <file_name>(optional), overwrite(optional)\n");
return;
}
assert(params.size() != 3 || (params.size() == 3 && std::string_view(params.get(2)) == "overwrite"));
execute_demo_start_command_internal((params.size() >= 2) ? params.get(1) : std::string_view{}, (params.size() == 3));
}
void execute_demo_stop_command(const command::params& params)
{
if (params.size() != 1)
{
console::info("usage: demostop\n");
return;
}
if (demo.is_recording() && !demo.stop())
{
console::error("could not stop demo\n");
}
}
}
namespace demo_recording
{
bool recording()
{
return demo.is_recording();
}
bool startrecord(std::string_view file_name, bool overwrite)
{
return execute_demo_start_command_internal(file_name, overwrite);
}
bool demo_recording::stoprecord()
{
return demo.stop();
}
class component final : public component_interface
{
public:
void post_unpack() override
{
if (!game::environment::is_mp())
{
return;
}
// check run-time address assertions
check_address_assertions();
// capture incoming packets
CL_ParseServerMessage_hook.create(game::CL_ParseServerMessage, capture_data);
// capture client predicted data (in CL_WritePacket)
utils::hook::call(0x1402C21B9, capture_predicted_data);
// request the server for no delta data (in CL_WritePacket)
utils::hook::call(0x1402C2026, request_non_delta_data);
// add support to auto record
demo_autorecord = game::Dvar_RegisterBool(
"demoautorecord", false, game::DVAR_FLAG_NONE, "Automatically start recording a demo.");
// add console command support to record demos
command::add("demostart", execute_demo_start_command);
command::add("demostop", execute_demo_stop_command);
scheduler::on_game_initialized([]()
{
demo.shutdown_watcher();
// check if demo directories exist / could be created
if (!can_create_demo_directories())
{
console::error("could not create demo directories\n");
}
}, scheduler::main);
}
};
}
REGISTER_COMPONENT(demo_recording::component)

8
src/client/component/demo_recording.hpp Normal file
View File

@ -0,0 +1,8 @@
#pragma once
namespace demo_recording
{
[[nodiscard]] bool recording();
[[nodiscard]] bool startrecord(std::string_view file_name = {}, bool overwrite = {});
[[nodiscard]] bool stoprecord();
}

664
src/client/component/demo_sv_recording.cpp Normal file
View File

@ -0,0 +1,664 @@
#include "std_include.hpp"
#include "loader/component_loader.hpp"
#include "demo_sv_recording.hpp"
#include "demo_utils.hpp"
#include "command.hpp"
#include "console.hpp"
#include "scheduler.hpp"
#include "utils/hook.hpp"
#include "utils/string.hpp"
using namespace demo_utils;
namespace // checked client num class
{
inline constexpr std::size_t SV_MAX_CLIENTS =
sizeof(game::mp::serverStatic_t::clients) / sizeof(game::mp::serverStatic_t::clients[0]);
class sv_client_num_t
{
public:
explicit sv_client_num_t(std::size_t client_num);
explicit sv_client_num_t(std::string_view client_id);
[[nodiscard]] bool valid() const;
[[nodiscard]] std::uint8_t value() const;
private:
[[nodiscard]] static std::optional<std::uint8_t> check_client_num(std::size_t client_num);
[[nodiscard]] static std::optional<std::uint8_t> parse_client_id(std::string_view str);
const std::optional<std::uint8_t> client_num_;
};
sv_client_num_t::sv_client_num_t(std::size_t client_num)
: client_num_(check_client_num(client_num))
{
assert(valid());
}
sv_client_num_t::sv_client_num_t(std::string_view client_id)
: client_num_(parse_client_id(client_id))
{}
bool sv_client_num_t::valid() const
{
return client_num_.has_value();
}
std::uint8_t sv_client_num_t::value() const
{
assert(valid());
return client_num_.value();
}
std::optional<std::uint8_t> sv_client_num_t::check_client_num(std::size_t client_num)
{
if (client_num >= SV_MAX_CLIENTS)
{
return {};
}
if (client_num >= static_cast<std::size_t>(game::mp::svs->clientCount))
{
return {};
}
assert(game::mp::svs->clientCount == game::Dvar_FindVar("sv_maxclients")->current.integer);
assert(client_num == static_cast<std::size_t>(game::mp::svs->clients[client_num].gentity->s.number));
return static_cast<std::uint8_t>(client_num);
}
std::optional<std::uint8_t> sv_client_num_t::parse_client_id(std::string_view str)
{
if (str.starts_with("pid"))
{
const auto pid = std::string_view(str.begin() + 3, str.end());
const auto all_digits = std::all_of(pid.begin(), pid.end(), [](unsigned char c)
{
return std::isdigit(c);
});
auto value = std::numeric_limits<std::size_t>::max();
const auto ec = std::from_chars(pid.data(), pid.data() + pid.size(), value).ec;
if (all_digits && ec == std::errc{})
{
const auto client_num = check_client_num(value);
if (client_num)
{
return client_num;
}
}
}
for (const auto& cl : game::mp::svs->clients)
{
if (cl.header.state != game::CS_ACTIVE || str != utils::string::strip(cl.name, true))
{
continue;
}
const auto client_num = check_client_num(cl.gentity->s.number);
if (client_num)
{
return client_num;
}
}
return {};
}
}
namespace // server demos class
{
game::dvar_t* sv_demos;
game::dvar_t* sv_demo_autorecord;
bool sv_execute_demo_start_command_internal(sv_client_num_t client_num, std::string_view file_name, bool overwrite);
class server_rotation_t
{
struct data_t
{
bool svr_restart_bit{};
std::size_t map_hash{};
std::size_t gametype_hash{};
};
public:
[[nodiscard]] bool has_changed()
{
const auto svr_restart_bit = static_cast<bool>(game::mp::svs->snapFlagServerBit & 4);
const auto has_value = data_.has_value();
if (!has_value || data_->svr_restart_bit != svr_restart_bit)
{
const auto dvar_mapname = get_mapname(false);
const auto dvar_gametype = get_gametype(false);
if (dvar_mapname.empty() || dvar_gametype.empty())
{
console::error("the server demo recording code may not function properly if dvars mapname or g_gametype are not available\n");
}
const auto map_hash = std::hash<std::string_view>()(dvar_mapname);
const auto gametype_hash = std::hash<std::string_view>()(dvar_gametype);
if (!has_value || (data_->map_hash != map_hash || data_->gametype_hash != gametype_hash))
{
data_.emplace(data_t{
.svr_restart_bit = svr_restart_bit,
.map_hash = map_hash,
.gametype_hash = gametype_hash
});
return has_value;
}
// server has not rotated despite restart bit change
data_->svr_restart_bit = svr_restart_bit;
}
return false;
}
private:
std::optional<data_t> data_;
};
struct client_data_t
{
private:
struct stored_times_t
{
std::int32_t first_svr_time{};
std::int32_t cur_svr_time{};
std::optional<std::int32_t> last_conn_time;
};
public:
[[nodiscard]] bool is_buffer_active() const
{
return buffer_active;
}
[[nodiscard]] bool is_recording() const
{
return file_active;
}
bool buffer_active{};
bool file_active{};
stored_times_t times;
buffer_t buffer;
std::ofstream file;
};
struct sv_demo_recordings_t
{
public:
sv_demo_recordings_t() = default;
~sv_demo_recordings_t();
sv_demo_recordings_t(const sv_demo_recordings_t&) = delete;
sv_demo_recordings_t(sv_demo_recordings_t&&) noexcept = delete;
sv_demo_recordings_t& operator=(const sv_demo_recordings_t&) = delete;
sv_demo_recordings_t& operator=(sv_demo_recordings_t&&) noexcept = delete;
[[nodiscard]] bool is_recording(sv_client_num_t client_num) const;
[[nodiscard]] bool start(sv_client_num_t client_num, const std::filesystem::path& path);
[[nodiscard]] bool stop(sv_client_num_t client_num);
void write_data(sv_client_num_t client_num, const game::mp::client_t& cl,
std::span<const std::uint8_t> network_data, bool client_loading);
void shutdown_watcher();
private:
[[nodiscard]] const client_data_t& get_client(sv_client_num_t client_num) const;
[[nodiscard]] client_data_t& get_client(sv_client_num_t client_num);
bool stop_internal(client_data_t& client, bool reset_client);
bool update_state(sv_client_num_t client_num, std::int32_t last_conn_time, bool client_loading);
void process_old_data();
server_rotation_t svr_rotation_data_;
std::array<client_data_t, SV_MAX_CLIENTS> client_data_{};
} demos;
sv_demo_recordings_t::~sv_demo_recordings_t()
{
process_old_data();
}
const client_data_t& sv_demo_recordings_t::get_client(sv_client_num_t client_num) const
{
assert(client_num.valid());
return client_data_[client_num.value()];
}
client_data_t& sv_demo_recordings_t::get_client(sv_client_num_t client_num)
{
assert(client_num.valid());
return client_data_[client_num.value()];
}
bool sv_demo_recordings_t::is_recording(sv_client_num_t client_num) const
{
return client_num.valid() && get_client(client_num).is_recording();
}
bool sv_demo_recordings_t::start(sv_client_num_t client_num, const std::filesystem::path& path)
{
if (!client_num.valid())
{
return false;
}
auto& client = get_client(client_num);
if (client.is_buffer_active())
{
if (!client.is_recording())
{
std::ofstream file(path, std::ios::binary);
if (file.good() && file.is_open())
{
const auto buffer = client.buffer.get();
client.file = std::move(file);
client.file.write(reinterpret_cast<const char*>(buffer.data()), buffer.size());
client.file.flush();
client.file_active = true;
return true;
}
}
}
else
{
console::error("client pid %d cannot be recorded at this time; sv_demos was possibly enabled too late!\n", client_num.value());
}
return false;
}
bool sv_demo_recordings_t::stop_internal(client_data_t& client, bool reset_client)
{
if (client.is_recording())
{
write_general_footer(client.file, client.times.first_svr_time, client.times.cur_svr_time);
write_end_of_file(client.file);
client.file.flush();
client.file.close();
client.file_active = {};
}
if (reset_client)
{
client.buffer_active = {};
client.times = {};
client.buffer.clear();
}
return client.file.good() && !client.file.is_open();
}
bool sv_demo_recordings_t::stop(sv_client_num_t client_num)
{
return client_num.valid() && stop_internal(get_client(client_num), false);
}
void sv_demo_recordings_t::process_old_data()
{
for (auto& client : client_data_)
{
stop_internal(client, true);
}
svr_rotation_data_ = {};
}
void sv_demo_recordings_t::shutdown_watcher()
{
auto execute_on_shutdown = [this, sv_loaded = false]() mutable
{
if (!sv_loaded && game::SV_Loaded())
{
sv_loaded = true;
}
if (sv_loaded && !game::SV_Loaded())
{
sv_loaded = false;
process_old_data();
}
};
scheduler::loop(execute_on_shutdown, scheduler::main);
}
bool sv_demo_recordings_t::update_state(sv_client_num_t client_num, std::int32_t last_conn_time, bool client_loading)
{
// handle server map change: close files and reset data for all clients; should ignore fast restarts
if (svr_rotation_data_.has_changed())
{
process_old_data();
}
auto& client = get_client(client_num);
if (!client_loading && !client.is_buffer_active())
{
// sv_demos was possibly enabled too late for this player for this match!
return false;
}
// handle client last connect time change: close file and reset data
if (!client.times.last_conn_time || *client.times.last_conn_time != last_conn_time)
{
if (client.times.last_conn_time)
{
stop_internal(client, true);
}
client.times.last_conn_time = last_conn_time;
}
// write general, mod and map headers to the buffer once
if (!client.is_buffer_active())
{
// reserve memory (low size if auto recording is enabled, because then the demo writes almost directly to disk)
const auto reserve_size = (sv_demo_autorecord && sv_demo_autorecord->current.enabled) ? 8192 : 512 * 1024;
client.buffer.reserve_memory(reserve_size);
sv_write_general_header(client.buffer, game::mp::svs->clients[client_num.value()].name);
write_mod_header(client.buffer);
if (write_map_header(client.buffer))
{
client.buffer_active = true;
}
}
// store first and current server times to keep track of demo length
client.times.cur_svr_time = game::mp::svs->time;
if (!client_loading && !client.times.first_svr_time && client.times.cur_svr_time)
{
client.times.first_svr_time = client.times.cur_svr_time;
}
// if not already recording, start demo for client when auto recording is enabled
if (!client.is_recording() && sv_demo_autorecord && sv_demo_autorecord->current.enabled)
{
if (!sv_execute_demo_start_command_internal(client_num, std::string_view{}, false))
{
console::error("failed to start demo automatically for client num %d\n", client_num.value());
}
}
return true;
}
void sv_demo_recordings_t::write_data(sv_client_num_t client_num,
const game::mp::client_t& cl, std::span<const std::uint8_t> network_data, bool client_loading)
{
if (!client_num.valid() || !update_state(client_num, cl.lastConnectTime, client_loading))
{
return;
}
auto write_data_internal = [&cl, network_data, client_loading](auto& output)
{
const auto send_msg_count = static_cast<std::size_t>(cl.header.sendMessageCount);
const auto svr_msg_sequence = static_cast<std::size_t>(cl.header.netchan.outgoingSequence);
if (!client_loading)
{
sv_write_predicted_data(output, cl.gentity->client->ps, send_msg_count);
}
write_id_and_size(output, 4 + network_data.size(), demo_data_id::network_data);
output.write(reinterpret_cast<const char*>(&svr_msg_sequence), 4);
output.write(reinterpret_cast<const char*>(network_data.data()), network_data.size());
};
auto& client = get_client(client_num);
if (client.is_buffer_active())
{
write_data_internal(client.buffer);
}
if (client.is_recording())
{
write_data_internal(client.file);
if (static_cast<std::size_t>(cl.header.sendMessageCount) % 512 == 0)
{
client.file.flush();
}
}
}
}
namespace // hooks
{
utils::hook::detour SV_Netchan_Transmit_hook;
bool sv_capture_data(game::mp::client_t& cl, const char* data, std::int32_t length)
{
const auto valid_player = cl.gentity && cl.gentity->client && cl.testClient == game::TC_NONE
&& (cl.header.state == game::CS_CLIENTLOADING || cl.header.state == game::CS_ACTIVE);
if (sv_demos && sv_demos->current.enabled && valid_player)
{
const auto client_num = sv_client_num_t(static_cast<std::size_t>(cl.gentity->s.number));
if (!client_num.valid())
{
console::error("invalid client num %d\n", cl.gentity->s.number);
}
else
{
const auto client_loading = (cl.header.state == game::CS_CLIENTLOADING);
const auto size = static_cast<std::size_t>(length);
if ((!client_loading || cl.gamestateMessageNum == cl.header.netchan.outgoingSequence) && size < MAX_SIZE)
{
const std::span<const std::uint8_t> network_data(reinterpret_cast<const std::uint8_t*>(data), size);
demos.write_data(client_num, cl, network_data, client_loading);
}
else
{
console::warn("invalid data for client num %d, message count %d, message size %zu\n",
client_num.value(), cl.header.sendMessageCount, size);
}
}
}
return SV_Netchan_Transmit_hook.invoke<bool>(&cl, data, length);
}
}
namespace // command execution
{
bool sv_execute_demo_start_command_internal(sv_client_num_t client_num, std::string_view file_name, bool overwrite)
{
if (game::Live_SyncOnlineDataFlags(0))
{
console::error("server must be initialized to record a demo\n");
return false;
}
if (const auto* sv_running = game::Dvar_FindVar("sv_running"); !sv_running || !sv_running->current.enabled)
{
console::error("server must be online to record a demo\n");
return false;
}
if (!sv_demos || !sv_demos->current.enabled)
{
console::error("cannot record a demo with sv_demos disabled\n");
return false;
}
if (!client_num.valid())
{
console::error("invalid client num\n");
return false;
}
const auto state = game::mp::svs->clients[client_num.value()].header.state;
if (state != game::CS_CLIENTLOADING && state != game::CS_ACTIVE)
{
console::error("client needs to be fully connected\n");
return false;
}
const auto client_type = game::mp::svs->clients[client_num.value()].testClient;
if (client_type != game::TC_NONE)
{
console::error("can only record actual players\n");
return false;
}
if (demos.is_recording(client_num))
{
console::error("already recording client\n");
return false;
}
const auto opt_dir_path = sv_create_demo_directory();
if (!opt_dir_path)
{
console::error("could not create demo directory\n");
return false;
}
const auto& cl = game::mp::svs->clients[client_num.value()];
const auto empty_guid = (cl.playerGuid[0] == '\0');
if (empty_guid)
{
console::warn("player guid appears empty\n");
}
const auto opt_server_path = (file_name.empty())
? sv_create_path_server_demo(*opt_dir_path, (!empty_guid) ? cl.playerGuid : utils::string::strip(cl.name, true))
: sv_create_path_server_demo(*opt_dir_path, file_name, overwrite);
if (!opt_server_path)
{
console::error("could not create demo file\n");
return false;
}
if (!demos.start(client_num, *opt_server_path))
{
console::error("could not create demo file %s\n", opt_server_path->string().c_str());
return false;
}
return true;
}
void sv_execute_demo_start_command(const command::params& params)
{
if (params.size() < 2 || params.size() > 4 || (params.size() == 4 && std::string_view(params.get(3)) != "overwrite"))
{
console::info("usage: sv_demostart <client_num | player_name>, <file_name>(optional), overwrite(optional)\n");
return;
}
assert(params.size() != 4 || (params.size() == 4 && std::string_view(params.get(3)) == "overwrite"));
sv_execute_demo_start_command_internal(
sv_client_num_t(params.get(1)), (params.size() >= 3) ? params.get(2) : std::string_view{}, (params.size() == 4));
}
void sv_execute_demo_stop_command(const command::params& params)
{
if (params.size() != 2)
{
console::info("usage: sv_demostop <client_num | player_name>\n");
return;
}
const sv_client_num_t client_num(params.get(1));
if (!client_num.valid())
{
console::error("invalid client num %s\n", params.get(1));
}
else if (!demos.stop(client_num))
{
console::error("could not stop demo\n");
}
}
}
namespace demo_sv_recording
{
bool sv_recording(std::size_t client_num)
{
return demos.is_recording(sv_client_num_t(client_num));
}
bool sv_startrecord(std::size_t client_num, std::string_view file_name, bool overwrite)
{
return sv_execute_demo_start_command_internal(sv_client_num_t(client_num), file_name, overwrite);
}
bool sv_stoprecord(std::size_t client_num)
{
return demos.stop(sv_client_num_t(client_num));
}
class component final : public component_interface
{
public:
void post_unpack() override
{
if (!game::environment::is_dedi())
{
return;
}
// check run-time address assertions
check_address_assertions();
// capture outgoing packets to client
SV_Netchan_Transmit_hook.create(game::SV_Netchan_Transmit, sv_capture_data);
// execute server demo code based on this value; if it's is enabled mid-match,
// then the demos recorded during that match (if any) are likely corrupt!
sv_demos = game::Dvar_RegisterBool(
"sv_demos", false, game::DVAR_FLAG_NONE, "Enable server demos");
// add support to auto record all players
sv_demo_autorecord = game::Dvar_RegisterBool(
"sv_demoautorecord", false, game::DVAR_FLAG_NONE,
"Automatically start recording a demo for each connected client.");
// add console command support to record server demos
command::add("sv_demostart", sv_execute_demo_start_command);
command::add("sv_demostop", sv_execute_demo_stop_command);
scheduler::on_game_initialized([]()
{
demos.shutdown_watcher();
// check if demo directory exists / could be created
if (!sv_can_create_demo_directory())
{
console::error("could not create demo directory\n");
}
}, scheduler::main);
}
};
}
REGISTER_COMPONENT(demo_sv_recording::component)

8
src/client/component/demo_sv_recording.hpp Normal file
View File

@ -0,0 +1,8 @@
#pragma once
namespace demo_sv_recording
{
[[nodiscard]] bool sv_recording(std::size_t client_num);
[[nodiscard]] bool sv_startrecord(std::size_t client_num, std::string_view file_name = {}, bool overwrite = {});
[[nodiscard]] bool sv_stoprecord(std::size_t client_num);
}

139
src/client/component/demo_timescale.cpp Normal file
View File

@ -0,0 +1,139 @@
#include "std_include.hpp"
#include "loader/component_loader.hpp"
#include "demo_playback.hpp"
#include "fps.hpp"
#include "game/game.hpp"
#include "utils/hook.hpp"
#include "utils/string.hpp"
namespace demo_timescale
{
namespace
{
utils::hook::detour Com_TimeScaleMsec_hook;
game::dvar_t* demo_timescale;
void generate_pattern(std::array<std::uint8_t, 1000>& pattern, std::size_t ones_count, std::size_t zeros_count)
{
assert(ones_count + zeros_count == pattern.size());
for (std::size_t i = 0, zeros = 1, ones = 1; i < pattern.size(); ++i)
{
if (ones * zeros_count < zeros * ones_count)
{
++ones;
pattern[i] = 1;
}
else
{
++zeros;
pattern[i] = 0;
}
}
assert(std::accumulate(pattern.begin(), pattern.end(), 0) > 0);
}
void calculate_pattern(std::array<std::uint8_t, 1000>& pattern, float fps, float timescale)
{
// Com_TimeScaleMsec is called once per frame, so the number of calls it takes to advance 1000 ms
// can be calculated by using the following formula: fps / timescale
// example: 500 fps and 0.01 timescale -> 500 / 0.01 = 50'000
// a pattern needs to be generated where 1000 * 1ms and 49'000 * 0ms are interleaved,
// and fit in an array of size 1000
const auto call_count_per_sec = static_cast<std::size_t>(std::clamp(fps / timescale, 1000.0f, 1'000'000.0f));
const auto ones_count = static_cast<std::size_t>(pattern.size() / (call_count_per_sec / static_cast<float>(pattern.size())));
const auto zeros_count = pattern.size() - ones_count;
generate_pattern(pattern, ones_count, zeros_count);
}
std::int32_t Com_TimeScaleMsec_stub(std::int32_t msec)
{
if (!demo_playback::playing() || !demo_timescale || demo_timescale->current.value == 1.0f)
{
return Com_TimeScaleMsec_hook.invoke<std::int32_t>(msec);
}
if (demo_timescale->current.value == 0.0f)
{
return 0; // pause game
}
// the code below generates a pattern of interleaved 0s and 1s based on calculated avg fps
// a new pattern is generated every 1000 frames, or after timescale or maxfps changes
// the pattern determines the speed at which the game advances
const auto timescale = demo_timescale->current.value;
const auto avg_fps = fps::get_avg_fps();
const auto frame_time = timescale * 1000.0f / avg_fps;
const auto* com_maxfps = game::Dvar_FindVar("com_maxfps");
const auto maxfps = (com_maxfps) ? com_maxfps->current.integer : static_cast<std::int32_t>(avg_fps);
static auto last_timescale = timescale;
static auto last_maxfps = maxfps;
static std::size_t pattern_index;
static std::array<std::uint8_t, 1000> pattern;
if (last_timescale != timescale || last_maxfps != maxfps)
{
last_timescale = timescale;
last_maxfps = maxfps;
// update pattern using the maxfps instead of avg fps for now
calculate_pattern(pattern, static_cast<float>(maxfps), timescale);
// update the pattern again in the near future when the average fps is more accurate
pattern_index = 95 * pattern.size() / 100;
}
if (frame_time > 1.0f)
{
const auto i_frame_time = static_cast<std::int32_t>(frame_time);
const auto ones_count = static_cast<std::size_t>(frame_time * 1000 - i_frame_time * 1000);
if (ones_count <= 1)
{
return i_frame_time;
}
if (pattern_index % pattern.size() == 0)
{
const auto zeros_count = pattern.size() - ones_count;
generate_pattern(pattern, ones_count, zeros_count);
}
return i_frame_time + pattern[pattern_index++ % pattern.size()];
}
else if (pattern_index % pattern.size() == 0)
{
calculate_pattern(pattern, avg_fps, timescale);
}
// advance (1ms) or pause (0ms) based on the pattern
return pattern[pattern_index++ % pattern.size()];
}
}
class component final : public component_interface
{
public:
void post_unpack() override
{
if (!game::environment::is_mp())
{
return;
}
// add timescale support for demo playback
Com_TimeScaleMsec_hook.create(game::Com_TimeScaleMsec, Com_TimeScaleMsec_stub);
demo_timescale = game::Dvar_RegisterFloat(
"demotimescale", 1.0f, 0.0f, 1000.0f, game::DVAR_FLAG_NONE, "Set playback speed for demos");
}
};
}
REGISTER_COMPONENT(demo_timescale::component)

1526
src/client/component/demo_utils.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

217
src/client/component/demo_utils.hpp Normal file
View File

@ -0,0 +1,217 @@
#pragma once
#include "game/game.hpp"
namespace demo_utils
{
namespace globals
{
inline constexpr std::string_view DEMO_CODE_VERSION = "v0.0.1";
inline constexpr std::string_view DEMO_EXTENSION = ".dm_iw6";
inline constexpr std::size_t MAX_SIZE = 131'072;
}
using namespace globals;
namespace types
{
enum struct demo_data_id : std::uint8_t
{
mod_header = 0,
map_header = 1,
network_data = 2,
predicted_data = 3,
update_gamestate_data = 4,
gen_header = 5,
gen_footer = 6,
eof = 31,
unused_flag_1 = 0b0010'0000,
unused_flag_2 = 0b0100'0000,
one_byte_flag = 0b1000'0000,
flags = (unused_flag_1 | unused_flag_2 | one_byte_flag)
};
demo_data_id operator|(demo_data_id lhs, demo_data_id rhs);
demo_data_id operator&(demo_data_id lhs, demo_data_id rhs);
demo_data_id operator~(demo_data_id value);
enum struct predicted_data_id : std::uint8_t
{
player = 0,
vehicle_gryphon = 1,
vehicle_helo_pilot = 2,
vehicle_odin = 3,
vehicle_unknown = 4,
vehicle_helo_pilot_turret_fire = 5
};
struct persistent_data_t
{
// ksr -> killstreak reward
std::int32_t cur_kill_count{};
std::int32_t req_kill_count_next_ksr{};
std::int32_t unknown1{ 1 };
std::int32_t active_ksr_count{};
std::int32_t unknown2{ -1 };
std::int32_t active_ksr_flags{};
std::int32_t unknown3{};
std::int32_t first_ksr_icon{};
std::int32_t second_ksr_icon{};
std::int32_t third_ksr_icon{};
};
struct packed_gamestate_sizes
{
std::uint64_t string_data : 20{};
std::uint64_t string_offsets : 16{};
std::uint64_t unused : 27{};
std::uint64_t compressed : 1{};
};
static_assert(sizeof(packed_gamestate_sizes) == 8);
struct predicted_data_t
{
game::vec3_t viewangles{};
game::ClientArchiveData cad{};
};
struct gamestate_t
{
std::uint32_t svr_cmd_seq{};
game::gameState_t data{};
};
class buffer_t
{
public:
[[nodiscard]] std::size_t size() const;
[[nodiscard]] std::span<const std::uint8_t> get() const;
void reserve_memory(std::size_t size);
void write(const char* src, std::size_t size);
void clear();
private:
std::vector<std::uint8_t> buffer_;
};
}
using namespace types;
namespace gen_utilities
{
std::string_view get_dvar_string(std::string_view dvar_name, bool valid_string);
std::string_view get_mod_directory();
std::string_view get_base_path(bool default_string);
std::string_view get_mapname(bool default_string);
std::string get_shortened_mapname_lowercase(bool default_string);
std::string get_mapname_lowercase(bool default_string);
std::string_view get_gametype(bool default_string);
std::string get_gametype_lowercase(bool default_string);
//std::string get_datetime();
}
using namespace gen_utilities;
namespace file_directory
{
std::optional<std::filesystem::path> create_directory_user_demo();
std::optional<std::filesystem::path> create_directory_auto_demo();
bool can_create_demo_directories();
std::optional<std::filesystem::path> create_path_user_demo(const std::filesystem::path& dir_path);
std::optional<std::filesystem::path> create_path_user_demo(
const std::filesystem::path& dir_path, std::string_view demo_name, bool overwrite);
std::optional<std::filesystem::path> create_path_auto_demo(const std::filesystem::path& dir_path);
}
using namespace file_directory;
namespace file_directory_server
{
std::optional<std::filesystem::path> sv_create_demo_directory();
bool sv_can_create_demo_directory();
std::optional<std::filesystem::path> sv_create_path_server_demo(
const std::filesystem::path& dir_path, std::string_view client_id);
std::optional<std::filesystem::path> sv_create_path_server_demo(
const std::filesystem::path& dir_path, std::string_view demo_name, bool overwrite);
}
using namespace file_directory_server;
namespace serialization
{
void write_id_and_size(buffer_t& output, std::size_t size, demo_data_id id);
void write_id_and_size(std::ofstream& output, std::size_t size, demo_data_id id);
void write_network_data(buffer_t& output, std::span<const std::uint8_t> network_data);
void write_network_data(std::ofstream& output, std::span<const std::uint8_t> network_data);
//void write_predicted_player_data(buffer_t& output, const game::ClientArchiveData& cad,
//const game::vec3_t& viewangles, std::uint8_t cad_index, predicted_data_id id);
//void write_predicted_player_data(std::ofstream& output, const game::ClientArchiveData& cad,
//const game::vec3_t& viewangles, std::uint8_t cad_index, predicted_data_id id);
//void write_predicted_vehicle_data(buffer_t& output, const game::ClientArchiveData& cad,
//const game::vec3_t& viewangles, std::uint8_t cad_index, predicted_data_id id);
//void write_predicted_vehicle_data(std::ofstream& output, const game::ClientArchiveData& cad,
//const game::vec3_t& viewangles, std::uint8_t cad_index, predicted_data_id id);
void write_helo_pilot_turret_fire(buffer_t& output, std::uint8_t fire_count);
void write_helo_pilot_turret_fire(std::ofstream& output, std::uint8_t fire_count);
void write_mod_header(buffer_t& output);
void write_mod_header(std::ofstream& output);
bool write_map_header(buffer_t& output);
bool write_map_header(std::ofstream& output);
bool write_gamestate_data(buffer_t& output);
bool write_gamestate_data(std::ofstream& output);
void write_predicted_data(buffer_t& output);
void write_predicted_data(std::ofstream& output);
void write_general_header(buffer_t& output);
void write_general_header(std::ofstream& output);
//void write_general_footer(buffer_t& output, std::int32_t first_svr_time, std::int32_t last_svr_time);
void write_general_footer(std::ofstream& output, std::int32_t first_svr_time, std::int32_t last_svr_time);
//void write_end_of_file(buffer_t& output);
void write_end_of_file(std::ofstream& output);
}
using namespace serialization;
namespace serialization_server
{
void sv_write_predicted_data(buffer_t& output, const game::mp::playerState_t& ps, std::size_t send_msg_count);
void sv_write_predicted_data(std::ofstream& output, const game::mp::playerState_t& ps, std::size_t send_msg_count);
void sv_write_general_header(buffer_t& output, std::string_view player_name);
void sv_write_general_header(std::ofstream& output, std::string_view player_name);
}
using namespace serialization_server;
namespace deserialization
{
bool is_gamestate_valid(game::gameState_t& gs, bool sanitize);
bool parse_demo(std::ifstream& file, std::vector<std::uint8_t>& buffer,
std::size_t& post_map_header_file_offset, std::array<predicted_data_t, 256>& pred_data,
std::size_t& pred_data_index, std::optional<gamestate_t>& gs);
}
using namespace deserialization;
namespace misc
{
template <typename To, typename From>
requires (std::is_trivially_copyable_v<From>&& std::is_trivially_copyable_v<To>)
[[nodiscard]] To cpy_cast(const From* src)
{
To dst;
std::memcpy(&dst, src, sizeof(To));
return dst;
}
persistent_data_t& get_persistent_data();
void fast_forward_demo(std::uint32_t msec);
void check_address_assertions();
}
using namespace misc;
}