hxuanyu/cs2-dumper
1
0
Fork 0
mirror of https://github.com/a2x/cs2-dumper.git synced 2025-10-07 22:50:03 +08:00
Code Issues Packages Projects Releases Wiki Activity

Refactored code

Browse Source
This commit is contained in:
a2x
2023-09-16 13:32:01 +10:00
parent a3a3427561
commit a8d3318d94
58 changed files with 787 additions and 635 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
src/sdk/c_schema_class_info.cpp
View File

@@ -1,22 +0,0 @@
#include "sdk/sdk.hpp"
namespace sdk {
std::uint16_t CSchemaClassInfo::get_fields_count() const noexcept {
return process::read_memory<std::uint16_t>(reinterpret_cast<std::uint64_t>(this) + 0x1C);
}
std::vector<SchemaClassFieldData_t*> CSchemaClassInfo::get_fields() const noexcept {
std::vector<SchemaClassFieldData_t*> fields;
for (std::size_t i = 0; i < get_fields_count(); ++i) {
const auto field = reinterpret_cast<SchemaClassFieldData_t*>(process::read_memory<std::uint64_t>(reinterpret_cast<std::uint64_t>(this) + 0x28) + (i * 0x20));
if (field == nullptr)
continue;
fields.push_back(field);
}
return fields;
}
}

28
src/sdk/c_schema_system.cpp
View File

@@ -1,28 +0,0 @@
#include "sdk/c_schema_system.hpp"
#include "process.hpp"
namespace sdk {
CSchemaSystem* CSchemaSystem::get() noexcept {
std::optional<std::uintptr_t> address = process::find_pattern("schemasystem.dll", "48 8D 0D ? ? ? ? E9 ? ? ? ? CC CC CC CC 48 8D 0D ? ? ? ? E9 ? ? ? ? CC CC CC CC 48 83 EC 28");
if (!address.has_value())
return nullptr;
address = process::resolve_rip_relative_address(address.value());
if (!address.has_value())
return nullptr;
return reinterpret_cast<CSchemaSystem*>(address.value());
}
std::vector<CSchemaSystemTypeScope*> CSchemaSystem::get_type_scopes() const noexcept {
std::vector<CSchemaSystemTypeScope*> type_scopes;
type_scopes.resize(process::read_memory<std::uint32_t>(reinterpret_cast<std::uint64_t>(this) + 0x190));
process::read_memory(process::read_memory<std::uint64_t>(reinterpret_cast<std::uint64_t>(this) + 0x198), type_scopes.data(), type_scopes.size() * sizeof(std::uint64_t));
return type_scopes;
}
}

97
src/sdk/c_schema_system_type_scope.cpp
View File

@@ -1,97 +0,0 @@
#include "sdk/sdk.hpp"
#include "utility/murmur_hash.hpp"
namespace sdk {
CSchemaClassInfo* CSchemaSystemTypeScope::find_declared_class(const std::string_view class_name) const noexcept {
const std::uint32_t hash = utility::murmur_hash2(class_name.data(), static_cast<std::uint32_t>(class_name.length()), 0xBAADFEED);
const std::int32_t hash_transform1 = static_cast<std::uint8_t>(hash >> 0x10) - 0x2D6 + 0x21 * (0x21 * static_cast<std::uint8_t>(hash) + static_cast<std::uint8_t>(hash >> 0x8));
const std::int32_t hash_transform2 = 0x21 * hash_transform1 + static_cast<std::uint8_t>(hash >> 0x18);
const auto hash_part = static_cast<std::uint32_t>(static_cast<std::uint8_t>(hash >> 0x18));
const std::int32_t hash_transform4 = (hash_transform2 ^ (hash_transform2 >> 0x10)) ^ (static_cast<std::uint16_t>(hash_transform2 ^ (hash_part >> 0x10)) >> 0x8);
const auto get_class_info = [&](const std::uint64_t address) -> CSchemaClassInfo* {
const std::uint64_t class_info_address = address + 0x588 + static_cast<std::uint64_t>(0x28) * static_cast<std::uint8_t>(hash_transform4);
const auto initial_address = process::read_memory<std::uint64_t>(class_info_address + 0x58);
std::uint64_t class_address = initial_address;
if (initial_address != 0) {
while (process::read_memory<std::uint32_t>(class_address) != hash) {
class_address = process::read_memory<std::uint64_t>(class_address + 0x8);
if (class_address == 0)
break;
}
}
if (class_address == 0) {
const auto secondary_address = process::read_memory<std::uint64_t>(class_info_address + 0x60);
std::uint64_t final_address = 0;
if (secondary_address != 0 && secondary_address != initial_address) {
auto current_address = process::read_memory<std::uint64_t>(class_info_address + 0x60);
const auto starting_address = process::read_memory<std::uint64_t>(class_info_address + 0x58);
if (current_address != starting_address) {
while (process::read_memory<std::uint32_t>(current_address) != hash) {
current_address = process::read_memory<std::uint64_t>(current_address + 0x8);
if (current_address == starting_address)
break;
}
final_address = current_address;
}
}
class_address = final_address;
}
return reinterpret_cast<CSchemaClassInfo*>(class_address);
};
const CSchemaClassInfo* class_info = get_class_info(reinterpret_cast<std::uint64_t>(this));
if (class_info != nullptr)
return reinterpret_cast<CSchemaClassInfo*>(process::read_memory<std::uint64_t>(reinterpret_cast<std::uint64_t>(class_info) + 0x10));
const auto secondary_class_info = process::read_memory<std::uint64_t>(reinterpret_cast<std::uint64_t>(this) + 0x108);
return secondary_class_info != 0 ? reinterpret_cast<CSchemaClassInfo*>(process::read_memory<std::uint64_t>(reinterpret_cast<std::uint64_t>(get_class_info(secondary_class_info)) + 0x10)) : nullptr;
}
std::vector<CSchemaType_DeclaredClass*> CSchemaSystemTypeScope::get_declared_classes() const noexcept {
std::vector<CSchemaType_DeclaredClass*> classes;
const std::uint64_t base = reinterpret_cast<std::uint64_t>(this) + 0x588;
const auto block_size = process::read_memory<std::uint32_t>(base + 0x4);
const auto count = process::read_memory<std::uint32_t>(base + 0x10);
const auto unallocated_data = process::read_memory<std::uint64_t>(base + 0x18 + 0x18);
std::uint32_t index = 0;
for (std::uint64_t element = unallocated_data; element != 0; element = process::read_memory<std::uint64_t>(element)) {
for (std::size_t i = 0; i < block_size && i != count; ++i) {
classes.push_back(reinterpret_cast<CSchemaType_DeclaredClass*>(process::read_memory<std::uint64_t>(element + 0x20 + (i * 0x18))));
++index;
if (index >= count)
break;
}
}
return classes;
}
std::string CSchemaSystemTypeScope::get_module_name() const noexcept {
return process::read_string(reinterpret_cast<std::uint64_t>(this) + 0x8, 256);
}
}

7
src/sdk/c_schema_type_declared_class.cpp
View File

@@ -1,7 +0,0 @@
#include "sdk/sdk.hpp"
namespace sdk {
std::string CSchemaType_DeclaredClass::get_class_name() const noexcept {
return process::read_string(process::read_memory<std::uint64_t>(reinterpret_cast<std::uint64_t>(this) + 0x8), 64);
}
}

4
src/sdk/c_schema_class_field_data.cpp → src/sdk/schema_class_field_data.cpp
View File

@@ -1,11 +1,11 @@
#include "sdk/sdk.hpp"
namespace sdk {
std::string SchemaClassFieldData_t::get_name() const noexcept {
std::string SchemaClassFieldData::name() const noexcept {
return process::read_string(process::read_memory<std::uint64_t>(reinterpret_cast<std::uint64_t>(this)), 64);
}
std::uint16_t SchemaClassFieldData_t::get_offset() const noexcept {
std::uint16_t SchemaClassFieldData::offset() const noexcept {
return process::read_memory<std::uint16_t>(reinterpret_cast<std::uint64_t>(this) + 0x10);
}
}

18
src/sdk/schema_class_info.cpp Normal file
View File

@@ -0,0 +1,18 @@
#include "sdk/sdk.hpp"
namespace sdk {
std::uint16_t SchemaClassInfo::fields_count() const noexcept {
return process::read_memory<std::uint16_t>(reinterpret_cast<std::uint64_t>(this) + 0x1C);
}
void SchemaClassInfo::for_each_field(const std::function<void(SchemaClassFieldData*)>& callback) const noexcept {
for (std::size_t i = 0; i < fields_count(); ++i) {
const auto field = reinterpret_cast<SchemaClassFieldData*>(process::read_memory<std::uint64_t>(reinterpret_cast<std::uint64_t>(this) + 0x28) + (i * 0x20));
if (field == nullptr)
continue;
callback(field);
}
}
}

28
src/sdk/schema_system.cpp Normal file
View File

@@ -0,0 +1,28 @@
#include "sdk/sdk.hpp"
namespace sdk {
SchemaSystem* SchemaSystem::get() noexcept {
const auto address = process::find_pattern("schemasystem.dll", "48 8D 0D ? ? ? ? E9 ? ? ? ? CC CC CC CC 48 8D 0D ? ? ? ? E9 ? ? ? ? CC CC CC CC 48 83 EC 28");
if (!address.has_value())
return nullptr;
return address->rip().as<SchemaSystem*>();
}
std::vector<SchemaSystemTypeScope*> SchemaSystem::type_scopes() const noexcept {
const auto count = process::read_memory<std::uint32_t>(reinterpret_cast<std::uint64_t>(this) + 0x190);
const auto data = process::read_memory<std::uint64_t>(reinterpret_cast<std::uint64_t>(this) + 0x198);
if (count == 0 || data == 0)
return {};
std::vector<sdk::SchemaSystemTypeScope*> type_scopes;
type_scopes.resize(count);
process::read_memory(data, type_scopes.data(), count * sizeof(std::uint64_t));
return type_scopes;
}
}

14
src/sdk/schema_system_type_scope.cpp Normal file
View File

@@ -0,0 +1,14 @@
#include "sdk/sdk.hpp"
namespace sdk {
void SchemaSystemTypeScope::for_each_class(const std::function<void(std::pair<std::string, SchemaClassInfo*>)>& callback) const noexcept {
const auto classes = process::read_memory<UtlTsHash<SchemaTypeDeclaredClass*>>(reinterpret_cast<std::uint64_t>(this) + 0x588);
for (const auto& element : classes.elements())
callback({ element->binary_name(), reinterpret_cast<SchemaClassInfo*>(element) });
}
std::string SchemaSystemTypeScope::module_name() const noexcept {
return process::read_string(reinterpret_cast<std::uint64_t>(this) + 0x8, 256);
}
}

11
src/sdk/schema_type_declared_class.cpp Normal file
View File

@@ -0,0 +1,11 @@
#include "sdk/sdk.hpp"
namespace sdk {
std::string SchemaTypeDeclaredClass::binary_name() const noexcept {
return process::read_string(process::read_memory<std::uint64_t>(reinterpret_cast<std::uint64_t>(this) + 0x8), 64);
}
std::string SchemaTypeDeclaredClass::module_name() const noexcept {
return process::read_string(process::read_memory<std::uint64_t>(reinterpret_cast<std::uint64_t>(this) + 0x10), 256);
}
}