Rim/iw4x-client
Rim/iw4x-client
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

Merge branch 'develop' of https://github.com/iw4x/iw4x-client into develop

Browse Source
This commit is contained in:
Rim 2024-06-17 18:29:57 -04:00
commit d6d8b078d9
24 changed files with 827 additions and 296 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
deps/iw4-open-formats/include/api.hpp vendored
View File

@ -4,6 +4,7 @@
#include "iw4_native_asset.hpp"
#include <functional>
#include <filesystem>
#include <unordered_set>
namespace iw4of
{

10
deps/iw4-open-formats/src/iw4-of/assets/asset_interface.hpp vendored
View File

@ -39,6 +39,11 @@ namespace iw4of
this->assets = assets;
}
bool writes_single_file()
{
return writes_single_file_internal();
}
std::filesystem::path get_work_path(const native::XAssetHeader& header) const;
virtual ~asset_interface() {}
@ -58,6 +63,11 @@ namespace iw4of
return {};
};
virtual bool writes_single_file_internal()
{
return false;
}
std::filesystem::path get_work_path(const std::string& asset_name) const;
std::filesystem::path get_work_path(const std::filesystem::path& file_path) const;

2
deps/iw4-open-formats/src/iw4-of/assets/asset_interfaces/iclipmap.cpp vendored
View File

@ -1114,7 +1114,7 @@ namespace iw4of::interfaces
/*typename SourceEncoding*/ rapidjson::UTF8<>,
/*typename TargetEncoding*/ rapidjson::UTF8<>,
/*typename StackAllocator*/ rapidjson::CrtAllocator,
/*unsigned writeFlags*/ rapidjson::kWriteNanAndInfFlag>
/*unsigned writeFlags*/ rapidjson::kWriteNanAndInfNullFlag | rapidjson::kWriteNanAndInfFlag>
writer(buff);
writer.SetFormatOptions(rapidjson::PrettyFormatOptions::kFormatSingleLineArray);
output.Accept(writer);

8
deps/iw4-open-formats/src/iw4-of/assets/asset_interfaces/ifx.cpp vendored
View File

@ -306,7 +306,13 @@ namespace iw4of::interfaces
output.AddMember("elemDefs", elemTable, allocator);
rapidjson::StringBuffer buff;
rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buff);
rapidjson::PrettyWriter<
/*typename OutputStream */ rapidjson::StringBuffer,
/*typename SourceEncoding*/ rapidjson::UTF8<>,
/*typename TargetEncoding*/ rapidjson::UTF8<>,
/*typename StackAllocator*/ rapidjson::CrtAllocator,
/*unsigned writeFlags*/ rapidjson::kWriteNanAndInfNullFlag | rapidjson::kWriteNanAndInfFlag>
writer(buff);
output.Accept(writer);
return utils::io::write_file(get_work_path(header).string(), buff.GetString());

10
deps/iw4-open-formats/src/iw4-of/assets/asset_interfaces/igfxworld.cpp vendored
View File

@ -636,11 +636,11 @@ namespace iw4of::interfaces
if (clip)
{
assert(clip->planeCount == asset->planeCount);
for (size_t i = 0; i < clip->planeCount; i++)
{
assert(0 ==
memcmp(&clip->planes[i], &asset->dpvsPlanes.planes[i], sizeof(native::cplane_s) - sizeof(native::cplane_s::pad)));
}
//for (size_t i = 0; i < clip->planeCount; i++)
//{
// assert(0 ==
// memcmp(&clip->planes[i], &asset->dpvsPlanes.planes[i], sizeof(native::cplane_s) - sizeof(native::cplane_s::pad)));
//}
asset->dpvsPlanes.planes = clip->planes;
}

11
deps/iw4-open-formats/src/iw4-of/assets/asset_interfaces/imaterial.cpp vendored
View File

@ -209,8 +209,17 @@ namespace iw4of::interfaces
output.AddMember("stateBitsTable", statebits_to_json_array(asset->stateBitsTable, asset->stateBitsCount, allocator), allocator);
}
// Write to disk
rapidjson::StringBuffer buff;
rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buff);
rapidjson::PrettyWriter<
/*typename OutputStream */ rapidjson::StringBuffer,
/*typename SourceEncoding*/ rapidjson::UTF8<>,
/*typename TargetEncoding*/ rapidjson::UTF8<>,
/*typename StackAllocator*/ rapidjson::CrtAllocator,
/*unsigned writeFlags*/ rapidjson::kWriteNanAndInfNullFlag | rapidjson::kWriteNanAndInfFlag>
writer(buff);
writer.SetFormatOptions(rapidjson::PrettyFormatOptions::kFormatSingleLineArray);
output.Accept(writer);
utils::io::write_file(get_work_path(header).string(), buff.GetString());

125
deps/iw4-open-formats/src/iw4-of/assets/asset_interfaces/iphyscollmap.cpp vendored Normal file
View File

@ -0,0 +1,125 @@
#include <std_include.hpp>
#include "assets/assets.hpp"
#include "iphyscollmap.hpp"
#include <utils/io.hpp>
#include <utils/string.hpp>
#include <utils/json.hpp>
#include <rapidjson/prettywriter.h>
#define IW4X_PHYS_COLLMAP_VERSION 1
namespace iw4of::interfaces
{
bool iphyscollmap::write_internal(const native::XAssetHeader& header) const
{
rapidjson::Document output(rapidjson::kObjectType);
auto& allocator = output.GetAllocator();
auto asset = header.physCollmap;
assert(asset);
output.AddMember("version", IW4X_PHYS_COLLMAP_VERSION, allocator);
output.AddMember("name", RAPIDJSON_STR(asset->name), allocator);
rapidjson::Value geoms(rapidjson::kArrayType);
for (size_t i = 0; i < asset->count; i++)
{
rapidjson::Value geom_info(rapidjson::kObjectType);
const auto geom = &asset->geoms[i];
{
rapidjson::Value json_brush_wrapper(rapidjson::kObjectType);
const auto brush_wrapper = geom->brushWrapper;
json_brush_wrapper.AddMember("bounds", utils::json::to_json(brush_wrapper->bounds, allocator), allocator);
json_brush_wrapper.AddMember("planes", utils::json::to_json(brush_wrapper->planes, brush_wrapper->brush.numsides, allocator), allocator);
geom_info.AddMember("brushwrapper", json_brush_wrapper, allocator);
}
rapidjson::Value orientation(rapidjson::kArrayType);
for (size_t j = 0; j < 3; j++)
{
orientation.PushBack(utils::json::make_json_array(geom->orientation[j], 3, allocator), allocator);
}
geom_info.AddMember("type", static_cast<int>(geom->type), allocator);
geom_info.AddMember("orientation", orientation, allocator);
geom_info.AddMember("bounds", utils::json::to_json(geom->bounds, allocator), allocator);
}
rapidjson::StringBuffer buff;
rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buff);
output.Accept(writer);
const auto& dump = buff.GetString();
return utils::io::write_file(get_work_path(header).string(), dump);
}
void* iphyscollmap::read_internal(const std::string& name) const
{
const auto& path = get_work_path(name).string();
if (utils::io::file_exists(path))
{
auto asset = local_allocator.allocate<native::PhysPreset>();
rapidjson::Document physPresetJson;
try
{
const auto& content = utils::io::read_file(path);
physPresetJson.Parse(content.data());
}
catch (const std::exception& e)
{
print_error("Invalid JSON for physpreset {}! {}", name, e.what());
return nullptr;
}
try
{
// Must NOT be null!
assert(!physPresetJson["sndAliasPrefix"].IsNull());
asset->name = local_allocator.duplicate_string(physPresetJson["name"].GetString());
asset->type = physPresetJson["type"].Get<int32_t>();
asset->bounce = physPresetJson["bounce"].Get<float>();
asset->mass = physPresetJson["mass"].Get<float>();
asset->friction = physPresetJson["friction"].Get<float>();
asset->bulletForceScale = physPresetJson["bulletForceScale"].Get<float>();
asset->explosiveForceScale = physPresetJson["explosiveForceScale"].Get<float>();
asset->sndAliasPrefix = local_allocator.duplicate_string(physPresetJson["sndAliasPrefix"].GetString());
asset->piecesSpreadFraction = physPresetJson["piecesSpreadFraction"].Get<float>();
asset->piecesUpwardVelocity = physPresetJson["piecesUpwardVelocity"].Get<float>();
asset->tempDefaultToCylinder = physPresetJson["tempDefaultToCylinder"].Get<bool>();
asset->perSurfaceSndAlias = physPresetJson["perSurfaceSndAlias"].Get<bool>();
assert(asset->mass > FLT_EPSILON);
}
catch (const std::exception& e)
{
print_error("Malformed JSON for physpreset {}! {}", name, e.what());
return nullptr;
}
return asset;
}
return nullptr;
}
std::filesystem::path iphyscollmap::get_file_name(const std::string& basename) const
{
return std::format("{}.iw4x.json", basename);
}
std::filesystem::path iphyscollmap::get_folder_name() const
{
return "physcollmap";
}
} // namespace iw4of::interfaces

30
deps/iw4-open-formats/src/iw4-of/assets/asset_interfaces/iphyscollmap.hpp vendored Normal file
View File

@ -0,0 +1,30 @@
#pragma once
#include <utils/stream.hpp>
#include "assets/asset_interface.hpp"
namespace iw4of::interfaces
{
struct iphyscollmap : asset_interface
{
public:
iphyscollmap(const iw4of::assets* assets)
: asset_interface(assets)
{
}
protected:
bool write_internal(const native::XAssetHeader& header) const override;
void* read_internal(const std::string& name) const override;
std::filesystem::path get_file_name(const std::string& basename) const override;
std::filesystem::path get_folder_name() const override;
private:
void write(const native::XSurfaceCollisionTree* entry, utils::stream* buffer) const;
void write(const native::XSurface* surf, utils::stream* buffer) const;
void write(const native::XModelSurfs* asset, utils::stream* buffer) const;
void read(native::XSurfaceCollisionTree* entry, utils::stream::reader* reader) const;
void read(native::XSurface* asset, utils::stream::reader* reader) const;
void read(native::XModelSurfs* asset, utils::stream::reader* reader) const;
};
} // namespace iw4of::interfaces

1
deps/iw4-open-formats/src/iw4-of/assets/asset_interfaces/irawfile.cpp vendored
View File

@ -222,6 +222,7 @@ namespace iw4of::interfaces
}
else
{
print_error("Could not find animtree {}\n", animtree_name);
assert(false);
}
}

10
deps/iw4-open-formats/src/iw4-of/assets/asset_interfaces/isndalias.cpp vendored
View File

@ -427,8 +427,16 @@ namespace iw4of::interfaces
output.AddMember("count", ents->count, allocator);
output.AddMember("head", head, allocator);
// Write to disk
rapidjson::StringBuffer buff;
rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buff);
rapidjson::PrettyWriter<
/*typename OutputStream */ rapidjson::StringBuffer,
/*typename SourceEncoding*/ rapidjson::UTF8<>,
/*typename TargetEncoding*/ rapidjson::UTF8<>,
/*typename StackAllocator*/ rapidjson::CrtAllocator,
/*unsigned writeFlags*/ rapidjson::kWriteNanAndInfFlag>
writer(buff);
writer.SetFormatOptions(rapidjson::PrettyFormatOptions::kFormatSingleLineArray);
output.Accept(writer);
const auto& dump = buff.GetString();

9
deps/iw4-open-formats/src/iw4-of/assets/asset_interfaces/isndcurve.cpp vendored
View File

@ -90,8 +90,15 @@ namespace iw4of::interfaces
output.AddMember("knots", knots_array, allocator);
// Write to disk
rapidjson::StringBuffer buff;
rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buff);
rapidjson::PrettyWriter<
/*typename OutputStream */ rapidjson::StringBuffer,
/*typename SourceEncoding*/ rapidjson::UTF8<>,
/*typename TargetEncoding*/ rapidjson::UTF8<>,
/*typename StackAllocator*/ rapidjson::CrtAllocator,
/*unsigned writeFlags*/ rapidjson::kWriteNanAndInfFlag>
writer(buff);
writer.SetFormatOptions(rapidjson::PrettyFormatOptions::kFormatSingleLineArray);
output.Accept(writer);

4
deps/iw4-open-formats/src/iw4-of/assets/asset_interfaces/itechniqueset.cpp vendored
View File

@ -114,7 +114,7 @@ namespace iw4of::interfaces
/*typename SourceEncoding*/ rapidjson::UTF8<>,
/*typename TargetEncoding*/ rapidjson::UTF8<>,
/*typename StackAllocator*/ rapidjson::CrtAllocator,
/*unsigned writeFlags*/ rapidjson::kWriteNanAndInfFlag
/*unsigned writeFlags*/ rapidjson::kWriteNanAndInfNullFlag | rapidjson::kWriteNanAndInfFlag
>
writer(buff);
@ -461,7 +461,7 @@ namespace iw4of::interfaces
/*typename SourceEncoding*/ rapidjson::UTF8<>,
/*typename TargetEncoding*/ rapidjson::UTF8<>,
/*typename StackAllocator*/ rapidjson::CrtAllocator,
/*unsigned writeFlags*/ rapidjson::kWriteNanAndInfFlag
/*unsigned writeFlags*/ rapidjson::kWriteNanAndInfNullFlag
>
writer(buff);

11
deps/iw4-open-formats/src/iw4-of/assets/assets.hpp vendored
View File

@ -24,7 +24,16 @@ namespace iw4of
if (check_type_is_supported(iw4_int_type))
{
const auto& path = asset_interfaces[iw4_int_type]->get_work_path({header});
if (can_write(path))
const bool writes_in_single_file = asset_interfaces[iw4_int_type]->writes_single_file();
if (writes_in_single_file && !written_assets.contains(path.string()))
{
// We have never written this file but it exists on disk, so we destroy it because
// we will be appending to it in the future
std::filesystem::remove(path);
}
if (writes_in_single_file || can_write(path))
{
bool written = asset_interfaces[iw4_int_type]->write<T>(header);

5
src/Components/Modules/Friends.cpp
View File

@ -315,7 +315,10 @@ namespace Components
Friends::LoggedOn = (Steam::Proxy::SteamUser_ && Steam::Proxy::SteamUser_->LoggedOn());
if (!Steam::Proxy::SteamFriends) return;
Game::UI_UpdateArenas();
if (Game::Sys_IsMainThread())
{
Game::UI_UpdateArenas();
}
int count = Steam::Proxy::SteamFriends->GetFriendCount(4);

308
src/Components/Modules/Logger.cpp
View File

@ -38,32 +38,32 @@ namespace Components
void Logger::MessagePrint(const int channel, const std::string& msg)
{
static const auto shouldPrint = []() -> bool
{
return Flags::HasFlag("stdout") || Loader::IsPerformingUnitTests();
}();
{
return Flags::HasFlag("stdout") || Loader::IsPerformingUnitTests();
}();
if (shouldPrint)
{
(void)std::fputs(msg.data(), stdout);
(void)std::fflush(stdout);
return;
}
if (shouldPrint)
{
(void)std::fputs(msg.data(), stdout);
(void)std::fflush(stdout);
return;
}
#ifdef _DEBUG
if (!IsConsoleReady())
{
OutputDebugStringA(msg.data());
}
if (!IsConsoleReady())
{
OutputDebugStringA(msg.data());
}
#endif
if (!Game::Sys_IsMainThread())
{
EnqueueMessage(msg);
}
else
{
Game::Com_PrintMessage(channel, msg.data(), 0);
}
if (!Game::Sys_IsMainThread())
{
EnqueueMessage(msg);
}
else
{
Game::Com_PrintMessage(channel, msg.data(), 0);
}
}
void Logger::DebugInternal(const std::string_view& fmt, std::format_args&& args, [[maybe_unused]] const std::source_location& loc)
@ -120,33 +120,33 @@ namespace Components
void Logger::PrintFail2BanInternal(const std::string_view& fmt, std::format_args&& args)
{
static const auto shouldPrint = []() -> bool
{
return Flags::HasFlag("fail2ban");
}();
{
return Flags::HasFlag("fail2ban");
}();
if (!shouldPrint)
{
return;
}
if (!shouldPrint)
{
return;
}
auto msg = std::vformat(fmt, args);
auto msg = std::vformat(fmt, args);
static auto log_next_time_stamp = true;
if (log_next_time_stamp)
{
auto now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
// Convert to local time
std::tm timeInfo = *std::localtime(&now);
static auto log_next_time_stamp = true;
if (log_next_time_stamp)
{
auto now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
// Convert to local time
std::tm timeInfo = *std::localtime(&now);
std::ostringstream ss;
ss << std::put_time(&timeInfo, "%Y-%m-%d %H:%M:%S ");
std::ostringstream ss;
ss << std::put_time(&timeInfo, "%Y-%m-%d %H:%M:%S ");
msg.insert(0, ss.str());
}
msg.insert(0, ss.str());
}
log_next_time_stamp = (msg.find('\n') != std::string::npos);
log_next_time_stamp = (msg.find('\n') != std::string::npos);
Utils::IO::WriteFile(IW4x_fail2ban_location.get<std::string>(), msg, true);
Utils::IO::WriteFile(IW4x_fail2ban_location.get<std::string>(), msg, true);
}
void Logger::Frame()
@ -227,28 +227,28 @@ namespace Components
pushad
push [esp + 28h]
push[esp + 28h]
call PrintMessagePipe
add esp, 4h
popad
ret
returnPrint:
returnPrint :
pushad
push 0 // gLog
push [esp + 2Ch] // data
call NetworkLog
add esp, 8h
push 0 // gLog
push[esp + 2Ch] // data
call NetworkLog
add esp, 8h
popad
popad
push esi
mov esi, [esp + 0Ch]
push esi
mov esi, [esp + 0Ch]
push 4AA835h
ret
push 4AA835h
ret
}
}
@ -262,13 +262,16 @@ namespace Components
{
const auto* g_log = (*Game::g_log) ? (*Game::g_log)->current.string : "";
if (std::strcmp(g_log, file) == 0)
if (g_log) // This can be null - has happened before
{
if (std::strcmp(folder, "userraw") != 0)
if (std::strcmp(g_log, file) == 0)
{
if (IW4x_one_log.get<bool>())
if (std::strcmp(folder, "userraw") != 0)
{
strncpy_s(folder, 256, "userraw", _TRUNCATE);
if (IW4x_one_log.get<bool>())
{
strncpy_s(folder, 256, "userraw", _TRUNCATE);
}
}
}
}
@ -280,8 +283,8 @@ namespace Components
{
pushad
push [esp + 20h + 8h]
push [esp + 20h + 10h]
push[esp + 20h + 8h]
push[esp + 20h + 10h]
call RedirectOSPath
add esp, 8h
@ -310,117 +313,140 @@ namespace Components
void Logger::AddServerCommands()
{
Command::AddSV("log_add", [](const Command::Params* params)
{
if (params->size() < 2) return;
std::unique_lock lock(LoggingMutex);
Network::Address addr(params->get(1));
if (std::ranges::find(LoggingAddresses[0], addr) == LoggingAddresses[0].end())
{
LoggingAddresses[0].push_back(addr);
}
});
if (params->size() < 2) return;
std::unique_lock lock(LoggingMutex);
Network::Address addr(params->get(1));
if (std::ranges::find(LoggingAddresses[0], addr) == LoggingAddresses[0].end())
{
LoggingAddresses[0].push_back(addr);
}
});
Command::AddSV("log_del", [](const Command::Params* params)
{
if (params->size() < 2) return;
std::unique_lock lock(LoggingMutex);
const auto num = std::atoi(params->get(1));
if (!std::strcmp(VA("%i", num), params->get(1)) && static_cast<unsigned int>(num) < LoggingAddresses[0].size())
{
auto addr = Logger::LoggingAddresses[0].begin() + num;
Print("Address {} removed\n", addr->getString());
LoggingAddresses[0].erase(addr);
}
else
{
Network::Address addr(params->get(1));
if (params->size() < 2) return;
if (const auto i = std::ranges::find(LoggingAddresses[0], addr); i != LoggingAddresses[0].end())
std::unique_lock lock(LoggingMutex);
const auto num = std::atoi(params->get(1));
if (!std::strcmp(VA("%i", num), params->get(1)) && static_cast<unsigned int>(num) < LoggingAddresses[0].size())
{
LoggingAddresses[0].erase(i);
Print("Address {} removed\n", addr.getString());
auto addr = Logger::LoggingAddresses[0].begin() + num;
Print("Address {} removed\n", addr->getString());
LoggingAddresses[0].erase(addr);
}
else
{
Print("Address {} not found!\n", addr.getString());
Network::Address addr(params->get(1));
if (const auto i = std::ranges::find(LoggingAddresses[0], addr); i != LoggingAddresses[0].end())
{
LoggingAddresses[0].erase(i);
Print("Address {} removed\n", addr.getString());
}
else
{
Print("Address {} not found!\n", addr.getString());
}
}
}
});
});
Command::AddSV("log_list", []([[maybe_unused]] const Command::Params* params)
{
Print("# ID: Address\n");
Print("-------------\n");
std::unique_lock lock(LoggingMutex);
for (unsigned int i = 0; i < LoggingAddresses[0].size(); ++i)
{
Print("#{:03d}: {}\n", i, LoggingAddresses[0][i].getString());
}
});
Print("# ID: Address\n");
Print("-------------\n");
std::unique_lock lock(LoggingMutex);
for (unsigned int i = 0; i < LoggingAddresses[0].size(); ++i)
{
Print("#{:03d}: {}\n", i, LoggingAddresses[0][i].getString());
}
});
Command::AddSV("g_log_add", [](const Command::Params* params)
{
if (params->size() < 2) return;
std::unique_lock lock(LoggingMutex);
const Network::Address addr(params->get(1));
if (std::ranges::find(LoggingAddresses[1], addr) == LoggingAddresses[1].end())
{
LoggingAddresses[1].push_back(addr);
}
});
if (params->size() < 2) return;
std::unique_lock lock(LoggingMutex);
const Network::Address addr(params->get(1));
if (std::ranges::find(LoggingAddresses[1], addr) == LoggingAddresses[1].end())
{
LoggingAddresses[1].push_back(addr);
}
});
Command::AddSV("g_log_del", [](const Command::Params* params)
{
if (params->size() < 2) return;
std::unique_lock lock(LoggingMutex);
const auto num = std::atoi(params->get(1));
if (!std::strcmp(VA("%i", num), params->get(1)) && static_cast<unsigned int>(num) < LoggingAddresses[1].size())
{
const auto addr = LoggingAddresses[1].begin() + num;
Print("Address {} removed\n", addr->getString());
LoggingAddresses[1].erase(addr);
}
else
{
const Network::Address addr(params->get(1));
const auto i = std::ranges::find(LoggingAddresses[1].begin(), LoggingAddresses[1].end(), addr);
if (i != LoggingAddresses[1].end())
if (params->size() < 2) return;
std::unique_lock lock(LoggingMutex);
const auto num = std::atoi(params->get(1));
if (!std::strcmp(VA("%i", num), params->get(1)) && static_cast<unsigned int>(num) < LoggingAddresses[1].size())
{
LoggingAddresses[1].erase(i);
Print("Address {} removed\n", addr.getString());
const auto addr = LoggingAddresses[1].begin() + num;
Print("Address {} removed\n", addr->getString());
LoggingAddresses[1].erase(addr);
}
else
{
Print("Address {} not found!\n", addr.getString());
const Network::Address addr(params->get(1));
const auto i = std::ranges::find(LoggingAddresses[1].begin(), LoggingAddresses[1].end(), addr);
if (i != LoggingAddresses[1].end())
{
LoggingAddresses[1].erase(i);
Print("Address {} removed\n", addr.getString());
}
else
{
Print("Address {} not found!\n", addr.getString());
}
}
}
});
});
Command::AddSV("g_log_list", []([[maybe_unused]] const Command::Params* params)
{
Print("# ID: Address\n");
Print("-------------\n");
std::unique_lock lock(LoggingMutex);
for (std::size_t i = 0; i < LoggingAddresses[1].size(); ++i)
{
Print("#{:03d}: {}\n", i, LoggingAddresses[1][i].getString());
Print("# ID: Address\n");
Print("-------------\n");
std::unique_lock lock(LoggingMutex);
for (std::size_t i = 0; i < LoggingAddresses[1].size(); ++i)
{
Print("#{:03d}: {}\n", i, LoggingAddresses[1][i].getString());
}
});
}
void PrintAliasError(Game::conChannel_t channel, const char* originalMsg, const char* soundName, const char* lastErrorStr)
{
// We add a bit more info and we clear the sound stream when it happens
// to avoid spamming the error
const auto newMsg = std::format("{}Make sure you have the 'miles' folder in your game directory! Otherwise MP3 and other codecs will be unavailable.\n", originalMsg);
Game::Com_PrintError(channel, newMsg.c_str(), soundName, lastErrorStr);
for (size_t i = 0; i < ARRAYSIZE(Game::milesGlobal->streamReadInfo); i++)
{
if (0 == std::strncmp(Game::milesGlobal->streamReadInfo[i].path, soundName, ARRAYSIZE(Game::milesGlobal->streamReadInfo[i].path)))
{
Game::milesGlobal->streamReadInfo[i].path[0] = '\x00'; // This kills it and make sure it doesn't get played again for now
break;
}
});
}
}
Logger::Logger()
{
// Print sound aliases errors
if (!Dedicated::IsEnabled())
{
Utils::Hook(0x64BA67, PrintAliasError, HOOK_CALL).install()->quick();
}
Utils::Hook(0x642139, BuildOSPath_Stub, HOOK_JUMP).install()->quick();
Scheduler::Loop(Frame, Scheduler::Pipeline::SERVER);
@ -438,10 +464,10 @@ namespace Components
Events::OnSVInit(AddServerCommands);
Events::OnDvarInit([]
{
IW4x_one_log = Dvar::Register<bool>("iw4x_onelog", false, Game::DVAR_LATCH, "Only write the game log to the 'userraw' OS folder");
IW4x_fail2ban_location = Dvar::Register<const char*>("iw4x_fail2ban_location", "/var/log/iw4x.log", Game::DVAR_NONE, "Fail2Ban logfile location");
});
{
IW4x_one_log = Dvar::Register<bool>("iw4x_onelog", false, Game::DVAR_LATCH, "Only write the game log to the 'userraw' OS folder");
IW4x_fail2ban_location = Dvar::Register<const char*>("iw4x_fail2ban_location", "/var/log/iw4x.log", Game::DVAR_NONE, "Fail2Ban logfile location");
});
}
Logger::~Logger()

12
src/Components/Modules/Logger.hpp
View File

@ -23,12 +23,12 @@ namespace Components
static void Print(const std::string_view& fmt)
{
PrintInternal(Game::CON_CHANNEL_DONT_FILTER, fmt, std::make_format_args(0));
PrintInternal(Game::CON_CHANNEL_DONT_FILTER, fmt, std::make_format_args());
}
static void Print(Game::conChannel_t channel, const std::string_view& fmt)
{
PrintInternal(channel, fmt, std::make_format_args(0));
PrintInternal(channel, fmt, std::make_format_args());
}
template <typename... Args>
@ -47,7 +47,7 @@ namespace Components
static void Error(Game::errorParm_t error, const std::string_view& fmt)
{
ErrorInternal(error, fmt, std::make_format_args(0));
ErrorInternal(error, fmt, std::make_format_args());
}
template <typename... Args>
@ -59,7 +59,7 @@ namespace Components
static void Warning(Game::conChannel_t channel, const std::string_view& fmt)
{
WarningInternal(channel, fmt, std::make_format_args(0));
WarningInternal(channel, fmt, std::make_format_args());
}
template <typename... Args>
@ -71,7 +71,7 @@ namespace Components
static void PrintError(Game::conChannel_t channel, const std::string_view& fmt)
{
PrintErrorInternal(channel, fmt, std::make_format_args(0));
PrintErrorInternal(channel, fmt, std::make_format_args());
}
template <typename... Args>
@ -83,7 +83,7 @@ namespace Components
static void PrintFail2Ban(const std::string_view& fmt)
{
PrintFail2BanInternal(fmt, std::make_format_args(0));
PrintFail2BanInternal(fmt, std::make_format_args());
}
template <typename... Args>

178
src/Components/Modules/Maps.cpp
View File

@ -103,9 +103,9 @@ namespace Components
const char* Maps::LoadArenaFileStub(const char* name, char* buffer, int size)
{
std::string data = RawFiles::ReadRawFile(name, buffer, size);
std::string data;
if (Maps::UserMap.isValid())
if (Maps::UserMap.isValid())
{
const auto mapname = Maps::UserMap.getName();
const auto arena = GetArenaPath(mapname);
@ -116,6 +116,10 @@ namespace Components
data = Utils::IO::ReadFile(arena);
}
}
else
{
data = RawFiles::ReadRawFile(name, buffer, size);
}
strncpy_s(buffer, size, data.data(), _TRUNCATE);
return buffer;
@ -141,11 +145,11 @@ namespace Components
Maps::CurrentDependencies.clear();
auto dependencies = GetDependenciesForMap(zoneInfo->name);
std::vector<Game::XZoneInfo> data;
Utils::Merge(&data, zoneInfo, zoneCount);
Utils::Memory::Allocator allocator;
if (dependencies.requiresTeamZones)
{
auto teams = dependencies.requiredTeams;
@ -177,7 +181,7 @@ namespace Components
auto patchZone = std::format("patch_{}", zoneInfo->name);
if (FastFiles::Exists(patchZone))
{
data.push_back({patchZone.data(), zoneInfo->allocFlags, zoneInfo->freeFlags});
data.push_back({ patchZone.data(), zoneInfo->allocFlags, zoneInfo->freeFlags });
}
return FastFiles::LoadLocalizeZones(data.data(), data.size(), sync);
@ -185,18 +189,18 @@ namespace Components
void Maps::OverrideMapEnts(Game::MapEnts* ents)
{
auto callback = [] (Game::XAssetHeader header, void* ents)
{
Game::MapEnts* mapEnts = reinterpret_cast<Game::MapEnts*>(ents);
Game::clipMap_t* clipMap = header.clipMap;
if (clipMap && mapEnts && !_stricmp(mapEnts->name, clipMap->name))
auto callback = [](Game::XAssetHeader header, void* ents)
{
clipMap->mapEnts = mapEnts;
//*Game::marMapEntsPtr = mapEnts;
//Game::G_SpawnEntitiesFromString();
}
};
Game::MapEnts* mapEnts = reinterpret_cast<Game::MapEnts*>(ents);
Game::clipMap_t* clipMap = header.clipMap;
if (clipMap && mapEnts && !_stricmp(mapEnts->name, clipMap->name))
{
clipMap->mapEnts = mapEnts;
//*Game::marMapEntsPtr = mapEnts;
//Game::G_SpawnEntitiesFromString();
}
};
// Internal doesn't lock the thread, as locking is impossible, due to executing this in the thread that holds the current lock
Game::DB_EnumXAssets_Internal(Game::XAssetType::ASSET_TYPE_CLIPMAP_MP, callback, ents, true);
@ -276,7 +280,7 @@ namespace Components
Logger::Print("Waiting for database...\n");
while (!Game::Sys_IsDatabaseReady()) std::this_thread::sleep_for(10ms);
if (!Game::DB_XAssetPool[Game::XAssetType::ASSET_TYPE_GAMEWORLD_MP].gameWorldMp || !Game::DB_XAssetPool[Game::XAssetType::ASSET_TYPE_GAMEWORLD_MP].gameWorldMp->name ||
if (!Game::DB_XAssetPool[Game::XAssetType::ASSET_TYPE_GAMEWORLD_MP].gameWorldMp || !Game::DB_XAssetPool[Game::XAssetType::ASSET_TYPE_GAMEWORLD_MP].gameWorldMp->name ||
!Game::DB_XAssetPool[Game::XAssetType::ASSET_TYPE_GAMEWORLD_MP].gameWorldMp->g_glassData || Maps::SPMap)
{
return Game::DB_XAssetPool[Game::XAssetType::ASSET_TYPE_GAMEWORLD_SP].gameWorldSp->g_glassData;
@ -294,7 +298,7 @@ namespace Components
call Maps::GetWorldData
mov [esp + 20h], eax
mov[esp + 20h], eax
popad
pop eax
@ -314,6 +318,28 @@ namespace Components
}
}
void Maps::ForceRefreshArenas()
{
if (Game::Sys_IsMainThread())
{
if (*Game::g_quitRequested)
{
// No need to refresh if we're exiting the game
return;
}
Game::sharedUiInfo_t* uiInfo = reinterpret_cast<Game::sharedUiInfo_t*>(0x62E4B78);
uiInfo->updateArenas = 1;
Game::UI_UpdateArenas();
}
else
{
// Dangerous!!
assert(false && "Arenas refreshed from wrong thread??");
Logger::Print("Tried to refresh arenas from a thread that is NOT the main thread!! This could have lead to a crash. Please report this bug and how you got it!");
}
}
// TODO : Remove hook entirely?
void Maps::GetBSPName(char* buffer, size_t size, const char* format, const char* mapname)
{
@ -459,7 +485,7 @@ namespace Components
char hashBuf[100] = { 0 };
unsigned int hash = atoi(Game::MSG_ReadStringLine(msg, hashBuf, sizeof hashBuf));
if(!Maps::CheckMapInstalled(mapname, false, true) || hash && hash != Maps::GetUsermapHash(mapname))
if (!Maps::CheckMapInstalled(mapname, false, true) || hash && hash != Maps::GetUsermapHash(mapname))
{
// Reconnecting forces the client to download the new map
Command::Execute("disconnect", false);
@ -480,12 +506,12 @@ namespace Components
push eax
pushad
push [esp + 28h]
push[esp + 28h]
push ebp
call Maps::TriggerReconnectForMap
add esp, 8h
mov [esp + 20h], eax
mov[esp + 20h], eax
popad
pop eax
@ -495,7 +521,7 @@ namespace Components
push 487C50h // Rotate map
skipRotation:
skipRotation :
retn
}
}
@ -506,7 +532,7 @@ namespace Components
{
pushad
push [esp + 24h]
push[esp + 24h]
call Maps::PrepareUsermap
pop eax
@ -523,7 +549,7 @@ namespace Components
{
pushad
push [esp + 24h]
push[esp + 24h]
call Maps::PrepareUsermap
pop eax
@ -668,7 +694,7 @@ namespace Components
Logger::Error(Game::ERR_DISCONNECT,
"Missing map file {}.\nYou may have a damaged installation or are attempting to load a non-existent map.", mapname);
}
return false;
}
@ -706,7 +732,7 @@ namespace Components
void Maps::G_SpawnTurretHook(Game::gentity_s* ent, int unk, int unk2)
{
if (Maps::CurrentMainZone == "mp_backlot_sh"s || Maps::CurrentMainZone == "mp_con_spring"s ||
if (Maps::CurrentMainZone == "mp_backlot_sh"s || Maps::CurrentMainZone == "mp_con_spring"s ||
Maps::CurrentMainZone == "mp_mogadishu_sh"s || Maps::CurrentMainZone == "mp_nightshift_sh"s)
{
return;
@ -736,7 +762,7 @@ namespace Components
Logger::Error(Game::errorParm_t::ERR_DROP, "Invalid trigger index ({}) in entities exceeds the maximum trigger count ({}) defined in the clipmap. Check your map ents, or your clipmap!", triggerIndex, ents->trigger.count);
return 0;
}
else
else
{
return Utils::Hook::Call<unsigned short(int, Game::Bounds*)>(0x4416C0)(triggerIndex, bounds);
}
@ -744,29 +770,29 @@ namespace Components
return 0;
}
Maps::Maps()
{
Scheduler::Once([]
{
Dvar::Register<bool>("isDlcInstalled_All", false, Game::DVAR_EXTERNAL | Game::DVAR_INIT, "");
Maps::RListSModels = Dvar::Register<bool>("r_listSModels", false, Game::DVAR_NONE, "Display a list of visible SModels");
Maps::AddDlc({ 1, "Stimulus Pack", {"mp_complex", "mp_compact", "mp_storm", "mp_overgrown", "mp_crash"} });
Maps::AddDlc({ 2, "Resurgence Pack", {"mp_abandon", "mp_vacant", "mp_trailerpark", "mp_strike", "mp_fuel2"} });
Maps::AddDlc({ 3, "IW4x Classics", {"mp_nuked", "mp_cross_fire", "mp_cargoship", "mp_bloc", "mp_killhouse", "mp_bog_sh", "mp_cargoship_sh", "mp_shipment", "mp_shipment_long", "mp_rust_long", "mp_firingrange", "mp_bloc_sh", "mp_crash_tropical", "mp_estate_tropical", "mp_fav_tropical", "mp_storm_spring"} });
Maps::AddDlc({ 4, "Call Of Duty 4 Pack", {"mp_farm", "mp_backlot", "mp_pipeline", "mp_countdown", "mp_crash_snow", "mp_carentan", "mp_broadcast", "mp_showdown", "mp_convoy", "mp_citystreets"} });
Maps::AddDlc({ 5, "Modern Warfare 3 Pack", {"mp_dome", "mp_hardhat", "mp_paris", "mp_seatown", "mp_bravo", "mp_underground", "mp_plaza2", "mp_village", "mp_alpha"}});
Maps::UpdateDlcStatus();
UIScript::Add("downloadDLC", []([[maybe_unused]] const UIScript::Token& token, [[maybe_unused]] const Game::uiInfo_s* info)
{
const auto dlc = token.get<int>();
Dvar::Register<bool>("isDlcInstalled_All", false, Game::DVAR_EXTERNAL | Game::DVAR_INIT, "");
Maps::RListSModels = Dvar::Register<bool>("r_listSModels", false, Game::DVAR_NONE, "Display a list of visible SModels");
Game::ShowMessageBox(Utils::String::VA("DLC %d does not exist!", dlc), "ERROR");
});
}, Scheduler::Pipeline::MAIN);
Maps::AddDlc({ 1, "Stimulus Pack", {"mp_complex", "mp_compact", "mp_storm", "mp_overgrown", "mp_crash"} });
Maps::AddDlc({ 2, "Resurgence Pack", {"mp_abandon", "mp_vacant", "mp_trailerpark", "mp_strike", "mp_fuel2"} });
Maps::AddDlc({ 3, "IW4x Classics", {"mp_nuked", "mp_cross_fire", "mp_cargoship", "mp_bloc", "mp_killhouse", "mp_bog_sh", "mp_cargoship_sh", "mp_shipment", "mp_shipment_long", "mp_rust_long", "mp_firingrange", "mp_bloc_sh", "mp_crash_tropical", "mp_estate_tropical", "mp_fav_tropical", "mp_storm_spring"} });
Maps::AddDlc({ 4, "Call Of Duty 4 Pack", {"mp_farm", "mp_backlot", "mp_pipeline", "mp_countdown", "mp_crash_snow", "mp_carentan", "mp_broadcast", "mp_showdown", "mp_convoy", "mp_citystreets"} });
Maps::AddDlc({ 5, "Modern Warfare 3 Pack", {"mp_dome", "mp_hardhat", "mp_paris", "mp_seatown", "mp_bravo", "mp_underground", "mp_plaza2", "mp_village", "mp_alpha"} });
Maps::UpdateDlcStatus();
UIScript::Add("downloadDLC", []([[maybe_unused]] const UIScript::Token& token, [[maybe_unused]] const Game::uiInfo_s* info)
{
const auto dlc = token.get<int>();
Game::ShowMessageBox(Utils::String::VA("DLC %d does not exist!", dlc), "ERROR");
});
}, Scheduler::Pipeline::MAIN);
// disable turrets on CoD:OL 448+ maps for now
Utils::Hook(0x5EE577, Maps::G_SpawnTurretHook, HOOK_CALL).install()->quick();
@ -782,7 +808,7 @@ namespace Components
#endif
//
//#define SORT_SMODELS
#if !defined(DEBUG) || !defined(SORT_SMODELS)
// Don't sort static models
@ -825,13 +851,13 @@ namespace Components
Utils::Hook(0x5B34DD, Maps::LoadMapLoadscreenStub, HOOK_CALL).install()->quick();
Command::Add("delayReconnect", []()
{
Scheduler::Once([]
{
Command::Execute("closemenu popup_reconnectingtoparty", false);
Command::Execute("reconnect", false);
}, Scheduler::Pipeline::CLIENT, 10s);
});
Scheduler::Once([]
{
Command::Execute("closemenu popup_reconnectingtoparty", false);
Command::Execute("reconnect", false);
}, Scheduler::Pipeline::CLIENT, 10s);
});
if (Dedicated::IsEnabled())
{
@ -845,12 +871,6 @@ namespace Components
// Load usermap arena file
Utils::Hook(0x630A88, Maps::LoadArenaFileStub, HOOK_CALL).install()->quick();
// Always refresh arena when loading or unloading a zone
Utils::Hook::Nop(0x485017, 2);
Utils::Hook::Nop(0x4BDFB7, 2); // Unknown
Utils::Hook::Nop(0x45ED6F, 2); // loadGameInfo
Utils::Hook::Nop(0x4A5888, 2); // UI_InitOnceForAllClients
// Allow hiding specific smodels
Utils::Hook(0x50E67C, Maps::HideModelStub, HOOK_CALL).install()->quick();
@ -861,33 +881,33 @@ namespace Components
// Client only
Scheduler::Loop([]
{
auto*& gameWorld = *reinterpret_cast<Game::GfxWorld**>(0x66DEE94);
if (!Game::CL_IsCgameInitialized() || !gameWorld || !Maps::RListSModels.get<bool>()) return;
std::map<std::string, int> models;
for (unsigned int i = 0; i < gameWorld->dpvs.smodelCount; ++i)
{
if (gameWorld->dpvs.smodelVisData[0][i])
auto*& gameWorld = *reinterpret_cast<Game::GfxWorld**>(0x66DEE94);
if (!Game::CL_IsCgameInitialized() || !gameWorld || !Maps::RListSModels.get<bool>()) return;
std::map<std::string, int> models;
for (unsigned int i = 0; i < gameWorld->dpvs.smodelCount; ++i)
{
std::string name = gameWorld->dpvs.smodelDrawInsts[i].model->name;
if (gameWorld->dpvs.smodelVisData[0][i])
{
std::string name = gameWorld->dpvs.smodelDrawInsts[i].model->name;
if (!models.contains(name)) models[name] = 1;
else models[name]++;
if (!models.contains(name)) models[name] = 1;
else models[name]++;
}
}
}
Game::Font_s* font = Game::R_RegisterFont("fonts/smallFont", 0);
auto height = Game::R_TextHeight(font);
auto scale = 0.75f;
float color[4] = {0.0f, 1.0f, 0.0f, 1.0f};
Game::Font_s* font = Game::R_RegisterFont("fonts/smallFont", 0);
auto height = Game::R_TextHeight(font);
auto scale = 0.75f;
float color[4] = { 0.0f, 1.0f, 0.0f, 1.0f };
unsigned int i = 0;
for (auto& model : models)
{
Game::R_AddCmdDrawText(Utils::String::VA("%d %s", model.second, model.first.data()), std::numeric_limits<int>::max(), font, 15.0f, (height * scale + 1) * (i++ + 1) + 15.0f, scale, scale, 0.0f, color, Game::ITEM_TEXTSTYLE_NORMAL);
}
}, Scheduler::Pipeline::RENDERER);
unsigned int i = 0;
for (auto& model : models)
{
Game::R_AddCmdDrawText(Utils::String::VA("%d %s", model.second, model.first.data()), std::numeric_limits<int>::max(), font, 15.0f, (height * scale + 1) * (i++ + 1) + 15.0f, scale, scale, 0.0f, color, Game::ITEM_TEXTSTYLE_NORMAL);
}
}, Scheduler::Pipeline::RENDERER);
}
Maps::~Maps()

9
src/Components/Modules/Maps.hpp
View File

@ -13,7 +13,7 @@ namespace Components
{
ZeroMemory(&this->searchPath, sizeof this->searchPath);
this->hash = Maps::GetUsermapHash(this->mapname);
Game::UI_UpdateArenas();
Maps::ForceRefreshArenas();
}
~UserMapContainer()
@ -29,7 +29,10 @@ namespace Components
{
bool wasValid = this->isValid();
this->mapname.clear();
if (wasValid) Game::UI_UpdateArenas();
if (wasValid)
{
Maps::ForceRefreshArenas();
}
}
void loadIwd();
@ -95,6 +98,8 @@ namespace Components
static Dvar::Var RListSModels;
static void ForceRefreshArenas();
static void GetBSPName(char* buffer, size_t size, const char* format, const char* mapname);
static void LoadAssetRestrict(Game::XAssetType type, Game::XAssetHeader asset, const std::string& name, bool* restrict);
static void LoadMapZones(Game::XZoneInfo *zoneInfo, unsigned int zoneCount, int sync);

134
src/Components/Modules/StructuredData.cpp
View File

@ -3,6 +3,8 @@
namespace Components
{
constexpr auto BASE_PLAYERSTATS_VERSION = 155;
Utils::Memory::Allocator StructuredData::MemAllocator;
const char* StructuredData::EnumTranslation[COUNT] =
@ -26,6 +28,11 @@ namespace Components
{
if (!data || type >= StructuredData::PlayerDataType::COUNT) return;
// Reallocate them before patching
Game::StructuredDataEnum* newEnums = MemAllocator.allocateArray<Game::StructuredDataEnum>(data->enumCount);
std::memcpy(newEnums, data->enums, sizeof(Game::StructuredDataEnum) * data->enumCount);
data->enums = newEnums;
Game::StructuredDataEnum* dataEnum = &data->enums[type];
// Build index-sorted data vector
@ -87,23 +94,52 @@ namespace Components
void StructuredData::PatchCustomClassLimit(Game::StructuredDataDef* data, int count)
{
const int customClassSize = 64;
constexpr auto CLASS_ARRAY = 5;
const auto originalClassCount = data->indexedArrays[CLASS_ARRAY].arraySize;
for (int i = 0; i < data->structs[0].propertyCount; ++i)
if (count != originalClassCount)
{
// 3003 is the offset of the customClasses structure
if (data->structs[0].properties[i].offset >= 3643)
const int customClassSize = 64;
// We need to recreate the struct list cause it's used in order definitions
auto newStructs = StructuredData::MemAllocator.allocateArray<Game::StructuredDataStruct>(data->structCount);
std::memcpy(newStructs, data->structs, data->structCount * sizeof(Game::StructuredDataStruct));
data->structs = newStructs;
constexpr auto structIndex = 0;
{
// -10 because 10 is the default amount of custom classes.
data->structs[0].properties[i].offset += ((count - 10) * customClassSize);
auto strct = &data->structs[structIndex];
auto newProperties = StructuredData::MemAllocator.allocateArray<Game::StructuredDataStructProperty>(strct->propertyCount);
std::memcpy(newProperties, strct->properties, strct->propertyCount * sizeof(Game::StructuredDataStructProperty));
strct->properties = newProperties;
for (int propertyIndex = 0; propertyIndex < strct->propertyCount; ++propertyIndex)
{
// 3643 is the offset of the customClasses structure
if (strct->properties[propertyIndex].offset >= 3643)
{
// -10 because 10 is the default amount of custom classes.
strct->properties[propertyIndex].offset += ((count - originalClassCount) * customClassSize);
}
}
}
// update structure size
data->size += ((count - originalClassCount) * customClassSize);
// Update amount of custom classes
if (data->indexedArrays[CLASS_ARRAY].arraySize != count)
{
// We need to recreate the whole array - this reference could be reused accross definitions
auto newIndexedArray = StructuredData::MemAllocator.allocateArray<Game::StructuredDataIndexedArray>(data->indexedArrayCount);
std::memcpy(newIndexedArray, data->indexedArrays, data->indexedArrayCount * sizeof(Game::StructuredDataIndexedArray));
data->indexedArrays = newIndexedArray;
// Add classes
data->indexedArrays[CLASS_ARRAY].arraySize = count;
}
}
// update structure size
data->size += ((count - 10) * customClassSize);
// Update amount of custom classes
data->indexedArrays[5].arraySize = count;
}
void StructuredData::PatchAdditionalData(Game::StructuredDataDef* data, std::unordered_map<std::string, std::string>& patches)
@ -119,26 +155,44 @@ namespace Components
bool StructuredData::UpdateVersionOffsets(Game::StructuredDataDefSet* set, Game::StructuredDataBuffer* buffer, Game::StructuredDataDef* whatever)
{
Game::StructuredDataDef* newDef = &set->defs[0];
Game::StructuredDataDef* oldDef = &set->defs[0];
for (unsigned int i = 0; i < set->defCount; ++i)
if (set->defCount > 1)
{
if (newDef->version < set->defs[i].version)
int bufferVersion = *reinterpret_cast<int*>(buffer->data);
for (size_t i = 0; i < set->defCount; i++)
{
newDef = &set->defs[i];
if (set->defs[i].version == bufferVersion)
{
if (i == 0)
{
// No update to conduct
}
else
{
Game::StructuredDataDef* newDef = &set->defs[i - 1];
Game::StructuredDataDef* oldDef = &set->defs[i];
if (newDef->version == 159 && oldDef->version <= 158)
{
// this should move the data 320 bytes infront
std::memmove(&buffer->data[3963], &buffer->data[3643], oldDef->size - 3643);
}
else if (newDef->version > 159 && false)
{
// 159 cannot be translated upwards and it's hard to say why
// Reading it fails in various ways
// might be the funky class bump...?
Command::Execute("setPlayerData prestige 10");
Command::Execute("setPlayerData experience 2516000");
}
return Utils::Hook::Call<bool(void*, void*, void*)>(0x456830)(set, buffer, whatever);
}
}
}
if (set->defs[i].version == *reinterpret_cast<int*>(buffer->data))
{
oldDef = &set->defs[i];
}
}
if (newDef->version >= 159 && oldDef->version <= 158)
{
// this should move the data 320 bytes infront
std::memmove(&buffer->data[3963], &buffer->data[3643], oldDef->size - 3643);
return Utils::Hook::Call<bool(void*, void*, void*)>(0x456830)(set, buffer, whatever);
}
// StructuredData_UpdateVersion
@ -182,7 +236,7 @@ namespace Components
return;
}
if (data->defs[0].version != 155)
if (data->defs[0].version != BASE_PLAYERSTATS_VERSION)
{
Logger::Error(Game::ERR_FATAL, "Initial PlayerDataDef is not version 155, patching not possible!");
return;
@ -262,16 +316,10 @@ namespace Components
auto* newData = StructuredData::MemAllocator.allocateArray<Game::StructuredDataDef>(data->defCount + patchDefinitions.size());
std::memcpy(&newData[patchDefinitions.size()], data->defs, sizeof Game::StructuredDataDef * data->defCount);
// Prepare the buffers
// Set the versions
for (unsigned int i = 0; i < patchDefinitions.size(); ++i)
{
std::memcpy(&newData[i], data->defs, sizeof Game::StructuredDataDef);
newData[i].version = (patchDefinitions.size() - i) + 155;
// Reallocate the enum array
auto* newEnums = StructuredData::MemAllocator.allocateArray<Game::StructuredDataEnum>(data->defs->enumCount);
std::memcpy(newEnums, data->defs->enums, sizeof Game::StructuredDataEnum * data->defs->enumCount);
newData[i].enums = newEnums;
newData[i].version = (patchDefinitions.size() - i) + BASE_PLAYERSTATS_VERSION;
}
// Apply new data
@ -279,10 +327,18 @@ namespace Components
data->defCount += patchDefinitions.size();
// Patch the definition
for (unsigned int i = 0; i < data->defCount; ++i)
for (int i = data->defCount - 1; i >= 0; --i)
{
// No need to patch version 155
if (newData[i].version == 155) continue;
if (newData[i].version == BASE_PLAYERSTATS_VERSION)
{
continue;
}
// We start from the previous one
const auto version = newData[i].version;
data->defs[i] = data->defs[i + 1];
newData[i].version = version;
if (patchDefinitions.contains(newData[i].version))
{

22
src/Components/Modules/Vote.cpp
View File

@ -2,11 +2,14 @@
#include "ClientCommand.hpp"
#include "MapRotation.hpp"
#include "Vote.hpp"
#include "Events.hpp"
using namespace Utils::String;
namespace Components
{
Dvar::Var Vote::SV_VotesRequired;
std::unordered_map<std::string, Vote::CommandHandler> Vote::VoteCommands =
{
{"map_restart", HandleMapRestart},
@ -37,6 +40,17 @@ namespace Components
Game::SV_SetConfigstring(Game::CS_VOTE_NO, VA("%i", Game::level->voteNo));
}
int Vote::VotesRequired()
{
auto votesRequired = Vote::SV_VotesRequired.get<int>();
if (votesRequired > 0)
{
return votesRequired;
}
return Game::level->numConnectedClients / 2 + 1;
}
bool Vote::IsInvalidVoteString(const std::string& input)
{
static const char* separators[] = { "\n", "\r", ";" };
@ -204,7 +218,7 @@ namespace Components
return;
}
if (Game::level->numConnectedClients < 2)
if (Game::level->numConnectedClients < VotesRequired())
{
Game::SV_GameSendServerCommand(ent - Game::g_entities, Game::SV_CMD_CAN_IGNORE, VA("%c \"GAME_VOTINGNOTENOUGHPLAYERS\"", 0x65));
return;
@ -218,7 +232,7 @@ namespace Components
return;
}
if (ent->client->sess.voteCount >= 3)
if (ent->client->sess.voteCount >= VotesRequired())
{
Game::SV_GameSendServerCommand(ent - Game::g_entities, Game::SV_CMD_CAN_IGNORE, VA("%c \"GAME_MAXVOTESCALLED\"", 0x65));
return;
@ -321,6 +335,10 @@ namespace Components
// Replicate g_allowVote
Utils::Hook::Set<std::uint32_t>(0x5E3A4F, Game::DVAR_INTERNAL | Game::DVAR_CODINFO);
Events::OnDvarInit([]{
Vote::SV_VotesRequired = Game::Dvar_RegisterInt("sv_votesRequired", 0, 0, 18, Game::DVAR_NONE, "Set the amount of votes required for a vote to pass.\n0 = (players / 2) + 1");
});
ClientCommand::Add("callvote", Cmd_CallVote_f);
ClientCommand::Add("vote", Cmd_Vote_f);

3
src/Components/Modules/Vote.hpp
View File

@ -11,11 +11,14 @@ namespace Components
using CommandHandler = std::function<bool(const Game::gentity_s* ent, const Command::ServerParams* params)>;
static std::unordered_map<std::string, CommandHandler> VoteCommands;
static Dvar::Var SV_VotesRequired;
static constexpr auto* CallVoteDesc = "%c \"GAME_VOTECOMMANDSARE\x15 map_restart, map_rotate, map <mapname>, g_gametype <typename>, typemap <typename> <mapname>, "
"kick <player>, tempBanUser <player>\"";
static void DisplayVote(const Game::gentity_s* ent);
static bool IsInvalidVoteString(const std::string& input);
static int VotesRequired();
static bool HandleMapRestart(const Game::gentity_s* ent, const Command::ServerParams* params);
static bool HandleMapRotate(const Game::gentity_s* ent, const Command::ServerParams* params);

3
src/Game/Game.cpp
View File

@ -17,10 +17,13 @@ namespace Game
G_DebugLineWithDuration_t G_DebugLineWithDuration = G_DebugLineWithDuration_t(0x4C3280);
gentity_s* g_entities = reinterpret_cast<gentity_s*>(0x18835D8);
bool* g_quitRequested = reinterpret_cast<bool*>(0x649FB61);
NetField* clientStateFields = reinterpret_cast<Game::NetField*>(0x741E40);
size_t clientStateFieldsCount = Utils::Hook::Get<size_t>(0x7433C8);
MssLocal* milesGlobal = reinterpret_cast<MssLocal*>(0x649A1A0);
const char* origErrorMsg = reinterpret_cast<const char*>(0x79B124);
XModel* G_GetModel(const int index)

3
src/Game/Game.hpp
View File

@ -52,10 +52,13 @@ namespace Game
constexpr std::size_t MAX_GENTITIES = 2048;
constexpr std::size_t ENTITYNUM_NONE = MAX_GENTITIES - 1;
extern gentity_s* g_entities;
extern bool* g_quitRequested;
// This does not belong anywhere else
extern NetField* clientStateFields;
extern size_t clientStateFieldsCount;
extern MssLocal* milesGlobal;
extern const char* origErrorMsg;

214
src/Game/Structs.hpp
View File

@ -1139,11 +1139,11 @@ namespace Game
unsigned __int16 triCount;
XSurfaceCollisionTree* collisionTree;
};
struct DObjSkelMat
{
float axis[3][4];
float origin[4];
float axis[3][4];
float origin[4];
};
struct XSurface
@ -2426,7 +2426,7 @@ namespace Game
float scale;
unsigned int noScalePartBits[6];
unsigned __int16* boneNames;
unsigned char *parentList;
unsigned char* parentList;
short* quats;
float* trans;
unsigned char* partClassification;
@ -4021,7 +4021,7 @@ namespace Game
GfxSurfaceBounds* surfacesBounds;
GfxStaticModelDrawInst* smodelDrawInsts;
GfxDrawSurf* surfaceMaterials;
unsigned int* surfaceCastsSunShadow;
unsigned int* surfaceCastsSunShadow;
volatile int usageCount;
};
@ -4032,7 +4032,7 @@ namespace Game
unsigned __int16 materialSortedIndex : 12;
unsigned __int16 visDataRefCountLessOne : 4;
};
union GfxSModelSurfHeader
{
GfxSModelSurfHeaderFields fields;
@ -5519,6 +5519,32 @@ namespace Game
StructuredDataEnumEntry* entries;
};
enum LookupResultDataType
{
LOOKUP_RESULT_INT = 0x0,
LOOKUP_RESULT_BOOL = 0x1,
LOOKUP_RESULT_STRING = 0x2,
LOOKUP_RESULT_FLOAT = 0x3,
LOOKUP_RESULT_SHORT = 0x4,
};
enum LookupState
{
LOOKUP_IN_PROGRESS = 0x0,
LOOKUP_FINISHED = 0x1,
LOOKUP_ERROR = 0x2,
};
enum LookupError
{
LOOKUP_ERROR_NONE = 0x0,
LOOKUP_ERROR_WRONG_DATA_TYPE = 0x1,
LOOKUP_ERROR_INDEX_OUTSIDE_BOUNDS = 0x2,
LOOKUP_ERROR_INVALID_STRUCT_PROPERTY = 0x3,
LOOKUP_ERROR_INVALID_ENUM_VALUE = 0x4,
LOOKUP_ERROR_COUNT = 0x5,
};
enum StructuredDataTypeCategory
{
DATA_INT = 0x0,
@ -5594,6 +5620,15 @@ namespace Game
unsigned int size;
};
struct StructuredDataLookup
{
StructuredDataDef* def;
StructuredDataType* type;
unsigned int offset;
LookupError error;
};
struct StructuredDataDefSet
{
const char* name;
@ -7932,8 +7967,8 @@ namespace Game
struct GfxCmdBufContext
{
GfxCmdBufSourceState *source;
GfxCmdBufState *state;
GfxCmdBufSourceState* source;
GfxCmdBufState* state;
};
struct GfxDrawGroupSetupFields
@ -8385,18 +8420,18 @@ namespace Game
int timeStamp;
DObjAnimMat* mat;
};
struct bitarray
{
int array[6];
int array[6];
};
/* 1923 */
struct XAnimCalcAnimInfo
{
DObjAnimMat rotTransArray[1152];
bitarray animPartBits;
bitarray ignorePartBits;
DObjAnimMat rotTransArray[1152];
bitarray animPartBits;
bitarray ignorePartBits;
};
@ -11101,6 +11136,159 @@ namespace Game
FFD_USER_MAP = 0x2,
};
struct ASISTAGE
{
int(__stdcall* ASI_stream_open)(unsigned int, int(__stdcall*)(unsigned int, void*, int, int), unsigned int);
int(__stdcall* ASI_stream_process)(int, void*, int);
int(__stdcall* ASI_stream_seek)(int, int);
int(__stdcall* ASI_stream_close)(int);
int(__stdcall* ASI_stream_property)(int, unsigned int, void*, const void*, void*);
unsigned int INPUT_BIT_RATE;
unsigned int INPUT_SAMPLE_RATE;
unsigned int INPUT_BITS;
unsigned int INPUT_CHANNELS;
unsigned int OUTPUT_BIT_RATE;
unsigned int OUTPUT_SAMPLE_RATE;
unsigned int OUTPUT_BITS;
unsigned int OUTPUT_CHANNELS;
unsigned int OUTPUT_RESERVOIR;
unsigned int POSITION;
unsigned int PERCENT_DONE;
unsigned int MIN_INPUT_BLOCK_SIZE;
unsigned int RAW_RATE;
unsigned int RAW_BITS;
unsigned int RAW_CHANNELS;
unsigned int REQUESTED_RATE;
unsigned int REQUESTED_BITS;
unsigned int REQUESTED_CHANS;
unsigned int STREAM_SEEK_POS;
unsigned int DATA_START_OFFSET;
unsigned int DATA_LEN;
int stream;
};
struct _STREAM
{
int block_oriented;
int using_ASI;
ASISTAGE* ASI;
void* samp;
unsigned int fileh;
char* bufs[3];
unsigned int bufsizes[3];
int reset_ASI[3];
int reset_seek_pos[3];
int bufstart[3];
void* asyncs[3];
int loadedbufstart[2];
int loadedorder[2];
int loadorder;
int bufsize;
int readsize;
unsigned int buf1;
int size1;
unsigned int buf2;
int size2;
unsigned int buf3;
int size3;
unsigned int datarate;
int filerate;
int filetype;
unsigned int fileflags;
int totallen;
int substart;
int sublen;
int subpadding;
unsigned int blocksize;
int padding;
int padded;
int loadedsome;
unsigned int startpos;
unsigned int totalread;
unsigned int loopsleft;
unsigned int error;
int preload;
unsigned int preloadpos;
int noback;
int alldone;
int primeamount;
int readatleast;
int playcontrol;
void(__stdcall* callback)(_STREAM*);
int user_data[8];
void* next;
int autostreaming;
int docallback;
};
enum SND_EQTYPE
{
SND_EQTYPE_FIRST = 0x0,
SND_EQTYPE_LOWPASS = 0x0,
SND_EQTYPE_HIGHPASS = 0x1,
SND_EQTYPE_LOWSHELF = 0x2,
SND_EQTYPE_HIGHSHELF = 0x3,
SND_EQTYPE_BELL = 0x4,
SND_EQTYPE_LAST = 0x4,
SND_EQTYPE_COUNT = 0x5,
SND_EQTYPE_INVALID = 0x5,
};
struct __declspec(align(4)) SndEqParams
{
SND_EQTYPE type;
float gain;
float freq;
float q;
bool enabled;
};
struct MssEqInfo
{
SndEqParams params[3][64];
};
struct MssFileHandle
{
unsigned int id;
MssFileHandle* next;
int handle;
char fileName[128];
unsigned int hashCode;
int offset;
int fileOffset;
int fileLength;
};
struct __declspec(align(4)) MssStreamReadInfo
{
char path[256];
int timeshift;
float fraction;
int startDelay;
_STREAM* handle;
bool readError;
};
struct MssLocal
{
struct _DIG_DRIVER* driver;
struct _SAMPLE* handle_sample[40];
_STREAM* handle_stream[12];
bool voiceEqDisabled[52];
MssEqInfo eq[2];
float eqLerp;
unsigned int eqFilter;
int currentRoomtype;
MssFileHandle fileHandle[12];
MssFileHandle* freeFileHandle;
bool isMultiChannel;
float realVolume[12];
int playbackRate[52];
MssStreamReadInfo streamReadInfo[12];
};
#pragma endregion
#ifndef IDA