cs2/Ray-Trace
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

Initial commit

Browse source
This commit is contained in:
SlynxCZ 2026-01-11 19:41:16 +04:00
parent 3dd53cf457
commit 5853554c70
85 changed files with 767 additions and 4511 deletions
Download patch file Download diff file Expand all files Collapse all files

45
src/schema/CBaseAnimGraph.h
View file

@ -1,45 +0,0 @@
//
// Created by Michal Přikryl on 26.06.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "CBaseEntity.h"
#include "globaltypes.h"
#include "CBaseModelEntity.h"
namespace
TemplatePlugin
{
class IChoreoServices
{
DECLARE_SCHEMA_CLASS(IChoreoServices)
};
class PhysicsRagdollPose_t
{
DECLARE_SCHEMA_CLASS(PhysicsRagdollPose_t)
SCHEMA_FIELD_POINTER(CUtlVector<CTransform>, m_Transforms)
SCHEMA_FIELD(CHandle<CBaseEntity>, m_hOwner)
SCHEMA_FIELD(bool, m_bSetFromDebugHistory)
};
class CBaseAnimGraph : public CBaseModelEntity
{
public:
DECLARE_SCHEMA_CLASS(CBaseAnimGraph)
SCHEMA_FIELD(bool, m_bInitiallyPopulateInterpHistory)
SCHEMA_FIELD(IChoreoServices *, m_pChoreoServices)
SCHEMA_FIELD(bool, m_bAnimGraphUpdateEnabled)
SCHEMA_FIELD(float, m_flMaxSlopeDistance)
SCHEMA_FIELD(Vector, m_vLastSlopeCheckPos)
SCHEMA_FIELD(bool, m_bAnimationUpdateScheduled)
SCHEMA_FIELD(Vector, m_vecForce)
SCHEMA_FIELD(int32, m_nForceBone)
SCHEMA_FIELD(PhysicsRagdollPose_t, m_RagdollPose)
SCHEMA_FIELD(bool, m_bRagdollEnabled)
SCHEMA_FIELD(bool, m_bRagdollClientSide)
SCHEMA_FIELD(CTransform, m_xParentedRagdollRootInEntitySpace)
};
}

53
src/schema/CBaseButton.h
View file

@ -1,53 +0,0 @@
//
// Created by Michal Přikryl on 07.11.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "CBaseTrigger.h"
#include "globaltypes.h"
namespace
TemplatePlugin
{
class locksound_t
{
public:
DECLARE_SCHEMA_CLASS(locksound_t);
SCHEMA_FIELD_POINTER(char, sLockedSound)
SCHEMA_FIELD_POINTER(char, sUnlockedSound)
SCHEMA_FIELD(float, flwaitSound)
};
class CBaseButton : public CBaseToggle
{
public:
DECLARE_SCHEMA_CLASS(CBaseButton);
SCHEMA_FIELD(QAngle, m_angMoveEntitySpace)
SCHEMA_FIELD(bool, m_fStayPushed)
SCHEMA_FIELD(bool, m_fRotating)
SCHEMA_FIELD(locksound_t, m_ls)
SCHEMA_FIELD_POINTER(char, m_sUseSound)
SCHEMA_FIELD_POINTER(char, m_sLockedSound)
SCHEMA_FIELD_POINTER(char, m_sUnlockedSound)
SCHEMA_FIELD_POINTER(char, m_sOverrideAnticipationName)
SCHEMA_FIELD(bool, m_bLocked)
SCHEMA_FIELD(bool, m_bDisabled)
SCHEMA_FIELD(float, m_flUseLockedTime)
SCHEMA_FIELD(bool, m_bSolidBsp)
SCHEMA_FIELD(CEntityIOOutput, m_OnDamaged)
SCHEMA_FIELD(CEntityIOOutput, m_OnPressed)
SCHEMA_FIELD(CEntityIOOutput, m_OnUseLocked)
SCHEMA_FIELD(CEntityIOOutput, m_OnIn)
SCHEMA_FIELD(CEntityIOOutput, m_OnOut)
SCHEMA_FIELD(int32, m_nState)
SCHEMA_FIELD(CHandle<CEntityInstance>, m_hConstraint)
SCHEMA_FIELD(CHandle<CEntityInstance>, m_hConstraintParent)
SCHEMA_FIELD(bool, m_bForceNpcExclude)
SCHEMA_FIELD_POINTER(char, m_sGlowEntity)
SCHEMA_FIELD(CHandle<CBaseModelEntity>, m_glowEntity)
SCHEMA_FIELD(bool, m_usable)
SCHEMA_FIELD_POINTER(char, m_szDisplayText)
};
}

926
src/schema/CBaseEntity.h
View file

@ -9,477 +9,475 @@
#include "schemasystem.h"
#include "ccollisionproperty.h"
#include "globaltypes.h"
#include "ctakedamageinfo.h"
#include "virtual.h"
#include "dynlibutils/module.h"
#include "Shared.h"
#include "ehandle.h"
namespace
TemplatePlugin
using namespace RayTracePlugin;
using UTIL_CreateEntityByName_t = CEntityInstance* (*)(const char* /*name*/, int /*forceEdictIndex*/);
inline UTIL_CreateEntityByName_t g_UTIL_CreateEntityByName = nullptr;
template <typename T>
inline T* UTIL_CreateEntityByName(const char* name)
{
using UTIL_CreateEntityByName_t = CEntityInstance* (*)(const char* /*name*/, int /*forceEdictIndex*/);
inline UTIL_CreateEntityByName_t g_UTIL_CreateEntityByName = nullptr;
template <typename T>
inline T* UTIL_CreateEntityByName(const char* name)
if (!g_UTIL_CreateEntityByName)
{
if (!g_UTIL_CreateEntityByName)
{
UTIL_CreateEntityByName_t addr = DynLibUtils::CModule(shared::g_pServer).FindPattern(
shared::g_pGameConfig->GetSignature("UTIL_CreateEntityByName")).RCast<UTIL_CreateEntityByName_t>();
UTIL_CreateEntityByName_t addr = DynLibUtils::CModule(shared::g_pServer).FindPattern(
shared::g_pGameConfig->GetSignature("UTIL_CreateEntityByName")).RCast<UTIL_CreateEntityByName_t>();
if (!addr)
return nullptr;
if (!addr)
return nullptr;
g_UTIL_CreateEntityByName = addr;
}
return reinterpret_cast<T*>(g_UTIL_CreateEntityByName(name, -1));
g_UTIL_CreateEntityByName = addr;
}
template <typename T>
inline std::vector<T*> UTIL_FindAllEntitiesByDesignerName(const char* designerName)
{
std::vector<T*> results;
if (!designerName || !shared::g_pEntitySystem)
return results;
auto* it = shared::g_pEntitySystem->m_EntityList.m_pFirstActiveEntity;
for (; it; it = it->m_pNext)
{
if (!it->m_pInstance) continue;
const char* dn = it->m_designerName.String();
if (!dn) continue;
if (std::strcmp(dn, designerName) == 0)
results.push_back((T*)it->m_pInstance);
}
return results;
}
inline CEntityInstance* UTIL_GetEntityByIndex(int index)
{
if (!shared::g_pEntitySystem) return nullptr;
CEntityIdentity* pEntity = shared::g_pEntitySystem->m_EntityList.m_pFirstActiveEntity;
for (; pEntity; pEntity = pEntity->m_pNext)
{
if (pEntity->m_EHandle.GetEntryIndex() == index)
return pEntity->m_pInstance;
};
return nullptr;
}
inline CEntityInstance* UTIL_FindEntityByClassname(const char* name)
{
if (!shared::g_pEntitySystem) return nullptr;
CEntityIdentity* pEntity = shared::g_pEntitySystem->m_EntityList.m_pFirstActiveEntity;
for (; pEntity; pEntity = pEntity->m_pNext)
{
if (!strcmp(pEntity->m_designerName.String(), name))
return pEntity->m_pInstance;
};
return nullptr;
}
inline CEntityInstance* UTIL_FindEntityByEHandle(CEntityInstance* pFind)
{
if (!shared::g_pEntitySystem) return nullptr;
CEntityIdentity* pEntity = shared::g_pEntitySystem->m_EntityList.m_pFirstActiveEntity;
for (; pEntity; pEntity = pEntity->m_pNext)
{
if (pEntity->GetRefEHandle() == pFind)
return pEntity->m_pInstance;
};
return nullptr;
}
typedef void (*CEntityInstance_AcceptInput_t)(CEntityInstance* pThis, const char* pInputName,
CEntityInstance* pActivator, CEntityInstance* pCaller,
const variant_t& pValue, int nOutputID, void* pUnk1);
inline CEntityInstance_AcceptInput_t g_CEntityInstance_AcceptInput = nullptr;
typedef void (*CEntitySystem_AddEntityIOEvent_t)(CEntitySystem* pEntitySystem, CEntityInstance* pThis,
const char* pInputName, CEntityInstance* pActivator,
CEntityInstance* pCaller, const variant_t& pValue, float delay,
int nOutputID, void* pUnk1, void* pUnk2);
inline CEntitySystem_AddEntityIOEvent_t g_CEntitySystem_AddEntityIOEvent = nullptr;
class CGameSceneNode
{
public:
DECLARE_SCHEMA_CLASS(CGameSceneNode)
SCHEMA_FIELD(CEntityInstance*, m_pOwner);
SCHEMA_FIELD(CGameSceneNode*, m_pParent);
SCHEMA_FIELD(CGameSceneNode*, m_pChild);
SCHEMA_FIELD(CNetworkOriginCellCoordQuantizedVector, m_vecOrigin);
SCHEMA_FIELD(QAngle, m_angRotation);
SCHEMA_FIELD(float, m_flScale);
SCHEMA_FIELD(float, m_flAbsScale);
SCHEMA_FIELD(Vector, m_vecAbsOrigin);
SCHEMA_FIELD(QAngle, m_angAbsRotation);
SCHEMA_FIELD(Vector, m_vRenderOrigin);
matrix3x4_t EntityToWorldTransform()
{
matrix3x4_t mat;
QAngle angles = this->m_angAbsRotation();
float sr, sp, sy, cr, cp, cy;
SinCos(DEG2RAD(angles[YAW]), &sy, &cy);
SinCos(DEG2RAD(angles[PITCH]), &sp, &cp);
SinCos(DEG2RAD(angles[ROLL]), &sr, &cr);
mat[0][0] = cp * cy;
mat[1][0] = cp * sy;
mat[2][0] = -sp;
float crcy = cr * cy;
float crsy = cr * sy;
float srcy = sr * cy;
float srsy = sr * sy;
mat[0][1] = sp * srcy - crsy;
mat[1][1] = sp * srsy + crcy;
mat[2][1] = sr * cp;
mat[0][2] = (sp * crcy + srsy);
mat[1][2] = (sp * crsy - srcy);
mat[2][2] = cr * cp;
Vector pos = this->m_vecAbsOrigin();
mat[0][3] = pos.x;
mat[1][3] = pos.y;
mat[2][3] = pos.z;
return mat;
}
};
class CBodyComponent
{
public:
DECLARE_SCHEMA_CLASS(CBodyComponent)
SCHEMA_FIELD(CGameSceneNode *, m_pSceneNode);
};
class CModelState
{
public:
DECLARE_SCHEMA_CLASS(CModelState)
SCHEMA_FIELD(CUtlSymbolLarge, m_ModelName)
SCHEMA_FIELD(uint64, m_MeshGroupMask)
};
class CSkeletonInstance : public CGameSceneNode
{
public:
DECLARE_SCHEMA_CLASS(CSkeletonInstance)
SCHEMA_FIELD(CModelState, m_modelState)
};
class CEntitySubclassVDataBase
{
public:
DECLARE_SCHEMA_CLASS(CEntitySubclassVDataBase)
};
class CBaseEntity : public CEntityInstance
{
public:
DECLARE_SCHEMA_CLASS(CBaseEntity)
SCHEMA_FIELD(float32, m_flSimulationTime)
SCHEMA_FIELD(float, m_flCreateTime);
SCHEMA_FIELD(CBodyComponent *, m_CBodyComponent)
SCHEMA_FIELD(CBitVec<64>, m_isSteadyState)
SCHEMA_FIELD(float, m_lastNetworkChange)
SCHEMA_FIELD_POINTER(CNetworkTransmitComponent, m_NetworkTransmitComponent)
SCHEMA_FIELD_POINTER(char, m_iszDamageFilterName);
SCHEMA_FIELD(int, m_iHealth)
SCHEMA_FIELD(int, m_iMaxHealth)
SCHEMA_FIELD(int, m_iTeamNum)
SCHEMA_FIELD(bool, m_bLagCompensate)
SCHEMA_FIELD(Vector, m_vecAbsVelocity)
SCHEMA_FIELD(Vector, m_vecBaseVelocity)
SCHEMA_FIELD(CCollisionProperty*, m_pCollision)
SCHEMA_FIELD(MoveCollide_t, m_MoveCollide)
SCHEMA_FIELD(MoveType_t, m_MoveType)
SCHEMA_FIELD(MoveType_t, m_nActualMoveType)
SCHEMA_FIELD(CHandle<CBaseEntity>, m_hEffectEntity)
SCHEMA_FIELD(uint32, m_spawnflags)
SCHEMA_FIELD(uint32, m_fFlags)
SCHEMA_FIELD(LifeState_t, m_lifeState)
SCHEMA_FIELD(float, m_flDamageAccumulator)
SCHEMA_FIELD(bool, m_bTakesDamage)
SCHEMA_FIELD(TakeDamageFlags_t, m_nTakeDamageFlags)
SCHEMA_FIELD_POINTER(CUtlStringToken, m_nSubclassID)
SCHEMA_FIELD(float, m_flFriction)
SCHEMA_FIELD(float, m_flActualGravityScale)
SCHEMA_FIELD(float, m_flTimeScale)
SCHEMA_FIELD(float, m_flSpeed)
SCHEMA_FIELD(CUtlString, m_sUniqueHammerID)
SCHEMA_FIELD(CUtlSymbolLarge, m_target)
SCHEMA_FIELD(CUtlSymbolLarge, m_iGlobalname)
SCHEMA_FIELD(CHandle<CBaseEntity>, m_hOwnerEntity)
SCHEMA_FIELD(CHandle<CBaseEntity>, m_hGroundEntity);
SCHEMA_FIELD(uint32, m_fEffects)
SCHEMA_FIELD(QAngle, m_vecAngVelocity)
// ---------------------------
// Flag helpers
// ---------------------------
void SetFlags(uint32_t mask)
{
auto& flags = m_fFlags();
flags = mask;
}
void AddFlags(uint32_t mask)
{
auto& flags = m_fFlags();
flags |= mask;
}
void ClearFlags(uint32_t mask)
{
auto& flags = m_fFlags();
flags &= ~mask;
}
bool HasFlags(uint32_t mask) const
{
return (const_cast<CBaseEntity*>(this)->m_fFlags() & mask) == mask;
}
uint32_t GetFlags() const
{
return const_cast<CBaseEntity*>(this)->m_fFlags();
}
// ---------------------------
// Basic entity info
// ---------------------------
Vector GetAbsOrigin()
{
if (!m_CBodyComponent) return Vector{};
if (!m_CBodyComponent->m_pSceneNode) return Vector{};
return m_CBodyComponent->m_pSceneNode->m_vecAbsOrigin();
}
QAngle GetAngRotation()
{
if (!m_CBodyComponent) return QAngle{};
if (!m_CBodyComponent->m_pSceneNode) return QAngle{};
return m_CBodyComponent->m_pSceneNode->m_angRotation();
}
QAngle GetAbsRotation()
{
if (!m_CBodyComponent) return QAngle{};
if (!m_CBodyComponent->m_pSceneNode) return QAngle{};
return m_CBodyComponent->m_pSceneNode->m_angAbsRotation();
}
Vector GetAbsVelocity() { return m_vecAbsVelocity; }
void SetAbsOrigin(const Vector& vecOrigin)
{
if (!m_CBodyComponent) return;
if (!m_CBodyComponent->m_pSceneNode) return;
m_CBodyComponent->m_pSceneNode->m_vecAbsOrigin(vecOrigin);
}
void SetAbsRotation(const QAngle& angAbsRotation)
{
if (!m_CBodyComponent) return;
if (!m_CBodyComponent->m_pSceneNode) return;
m_CBodyComponent->m_pSceneNode->m_angAbsRotation(angAbsRotation);
}
void SetAngRotation(const QAngle& angRotation)
{
if (!m_CBodyComponent) return;
if (!m_CBodyComponent->m_pSceneNode) return;
m_CBodyComponent->m_pSceneNode->m_angRotation(angRotation);
}
void SetAbsVelocity(const Vector& vecVelocity) { m_vecAbsVelocity = vecVelocity; }
void SetBaseVelocity(const Vector& vecVelocity) { m_vecBaseVelocity = vecVelocity; }
CEntitySubclassVDataBase* GetVData()
{
return *(CEntitySubclassVDataBase**)((uint8*)(m_nSubclassID()) + 4);
}
// ---------------------------
// Engine calls
// ---------------------------
void Teleport(const Vector* position, const QAngle* angles, const Vector* velocity)
{
static int offset = shared::g_pGameConfig->GetOffset("CBaseEntity_Teleport");
CALL_VIRTUAL(void, offset, this, position, angles, velocity);
}
void SetMoveType(MoveType_t nMoveType)
{
m_MoveType() = nMoveType;
m_nActualMoveType() = nMoveType;
}
void CollisionRulesChanged()
{
static int offset = shared::g_pGameConfig->GetOffset("CBaseEntity_CollisionRulesChanged");
CALL_VIRTUAL(void, offset, this);
}
int GetTeam() { return m_iTeamNum(); }
bool IsAlive() { return m_lifeState() == LifeState_t::LIFE_ALIVE; }
CHandle<CBaseEntity> GetHandle() const { return m_pEntity->m_EHandle; }
const char* GetName() const { return m_pEntity->m_name.String(); }
const char* GetDesignerName() const { return m_pEntity ? m_pEntity->m_designerName.String() : ""; }
// ---------------------------
// Detours
// ---------------------------
void DispatchSpawn()
{
using DispatchSpawn_t = void (*)(CBaseEntity* /*self*/, void* /*pMapData*/);
static DispatchSpawn_t s_DispatchSpawn = nullptr;
if (!s_DispatchSpawn)
{
DispatchSpawn_t addr = DynLibUtils::CModule(shared::g_pServer).FindPattern(
shared::g_pGameConfig->GetSignature("CBaseEntity_DispatchSpawn")).RCast<DispatchSpawn_t>();
if (!addr) return;
s_DispatchSpawn = addr;
}
s_DispatchSpawn(this, nullptr);
}
void AcceptInput(const char* pInputName, CEntityInstance* pActivator = nullptr,
CEntityInstance* pCaller = nullptr, const char* value = "")
{
if (!g_CEntityInstance_AcceptInput)
{
g_CEntityInstance_AcceptInput =
DynLibUtils::CModule(shared::g_pServer)
.FindPattern(shared::g_pGameConfig->GetSignature("CEntityInstance_AcceptInput"))
.RCast<CEntityInstance_AcceptInput_t>();
if (!g_CEntityInstance_AcceptInput)
return;
}
g_CEntityInstance_AcceptInput(this, pInputName, pActivator, pCaller, variant_t(value), 0, 0LL);
}
void AddEntityIOEvent(const char* pInputName, CEntityInstance* pActivator = nullptr,
CEntityInstance* pCaller = nullptr, const char* value = "", float flDelay = 0.0)
{
if (!g_CEntitySystem_AddEntityIOEvent)
{
g_CEntitySystem_AddEntityIOEvent =
DynLibUtils::CModule(shared::g_pServer)
.FindPattern(shared::g_pGameConfig->GetSignature("CEntitySystem_AddEntityIOEvent"))
.RCast<CEntitySystem_AddEntityIOEvent_t>();
if (!g_CEntitySystem_AddEntityIOEvent)
return;
}
g_CEntitySystem_AddEntityIOEvent(shared::g_pEntitySystem, this, pInputName, pActivator, pCaller,
variant_t(value), flDelay, 0,
0LL, 0LL);
}
};
class CBodyComponentSkeletonInstance : public CBodyComponent
{
public:
DECLARE_SCHEMA_CLASS(CBodyComponentSkeletonInstance);
};
class CBaseAnimGraphController
{
public:
DECLARE_SCHEMA_CLASS_INLINE(CBaseAnimGraphController);
SCHEMA_FIELD(float, m_flPlaybackRate);
};
class CBodyComponentBaseAnimGraph : public CBodyComponentSkeletonInstance
{
public:
DECLARE_SCHEMA_CLASS(CBodyComponentBaseAnimGraph);
SCHEMA_FIELD(CBaseAnimGraphController, m_animationController);
};
class SpawnPoint : public CBaseEntity
{
public:
DECLARE_SCHEMA_CLASS(SpawnPoint);
SCHEMA_FIELD(bool, m_bEnabled);
};
return reinterpret_cast<T*>(g_UTIL_CreateEntityByName(name, -1));
}
template <typename T>
inline std::vector<T*> UTIL_FindAllEntitiesByDesignerName(const char* designerName)
{
std::vector<T*> results;
if (!designerName || !shared::g_pEntitySystem)
return results;
auto* it = shared::g_pEntitySystem->m_EntityList.m_pFirstActiveEntity;
for (; it; it = it->m_pNext)
{
if (!it->m_pInstance) continue;
const char* dn = it->m_designerName.String();
if (!dn) continue;
if (std::strcmp(dn, designerName) == 0)
results.push_back((T*)it->m_pInstance);
}
return results;
}
inline CEntityInstance* UTIL_GetEntityByIndex(int index)
{
if (!shared::g_pEntitySystem) return nullptr;
CEntityIdentity* pEntity = shared::g_pEntitySystem->m_EntityList.m_pFirstActiveEntity;
for (; pEntity; pEntity = pEntity->m_pNext)
{
if (pEntity->m_EHandle.GetEntryIndex() == index)
return pEntity->m_pInstance;
};
return nullptr;
}
inline CEntityInstance* UTIL_FindEntityByClassname(const char* name)
{
if (!shared::g_pEntitySystem) return nullptr;
CEntityIdentity* pEntity = shared::g_pEntitySystem->m_EntityList.m_pFirstActiveEntity;
for (; pEntity; pEntity = pEntity->m_pNext)
{
if (!strcmp(pEntity->m_designerName.String(), name))
return pEntity->m_pInstance;
};
return nullptr;
}
inline CEntityInstance* UTIL_FindEntityByEHandle(CEntityInstance* pFind)
{
if (!shared::g_pEntitySystem) return nullptr;
CEntityIdentity* pEntity = shared::g_pEntitySystem->m_EntityList.m_pFirstActiveEntity;
for (; pEntity; pEntity = pEntity->m_pNext)
{
if (pEntity->GetRefEHandle() == pFind)
return pEntity->m_pInstance;
};
return nullptr;
}
typedef void (*CEntityInstance_AcceptInput_t)(CEntityInstance* pThis, const char* pInputName,
CEntityInstance* pActivator, CEntityInstance* pCaller,
const variant_t& pValue, int nOutputID, void* pUnk1);
inline CEntityInstance_AcceptInput_t g_CEntityInstance_AcceptInput = nullptr;
typedef void (*CEntitySystem_AddEntityIOEvent_t)(CEntitySystem* pEntitySystem, CEntityInstance* pThis,
const char* pInputName, CEntityInstance* pActivator,
CEntityInstance* pCaller, const variant_t& pValue, float delay,
int nOutputID, void* pUnk1, void* pUnk2);
inline CEntitySystem_AddEntityIOEvent_t g_CEntitySystem_AddEntityIOEvent = nullptr;
class CGameSceneNode
{
public:
DECLARE_SCHEMA_CLASS(CGameSceneNode)
SCHEMA_FIELD(CEntityInstance*, m_pOwner);
SCHEMA_FIELD(CGameSceneNode*, m_pParent);
SCHEMA_FIELD(CGameSceneNode*, m_pChild);
SCHEMA_FIELD(CNetworkOriginCellCoordQuantizedVector, m_vecOrigin);
SCHEMA_FIELD(QAngle, m_angRotation);
SCHEMA_FIELD(float, m_flScale);
SCHEMA_FIELD(float, m_flAbsScale);
SCHEMA_FIELD(Vector, m_vecAbsOrigin);
SCHEMA_FIELD(QAngle, m_angAbsRotation);
SCHEMA_FIELD(Vector, m_vRenderOrigin);
matrix3x4_t EntityToWorldTransform()
{
matrix3x4_t mat;
QAngle angles = this->m_angAbsRotation();
float sr, sp, sy, cr, cp, cy;
SinCos(DEG2RAD(angles[YAW]), &sy, &cy);
SinCos(DEG2RAD(angles[PITCH]), &sp, &cp);
SinCos(DEG2RAD(angles[ROLL]), &sr, &cr);
mat[0][0] = cp * cy;
mat[1][0] = cp * sy;
mat[2][0] = -sp;
float crcy = cr * cy;
float crsy = cr * sy;
float srcy = sr * cy;
float srsy = sr * sy;
mat[0][1] = sp * srcy - crsy;
mat[1][1] = sp * srsy + crcy;
mat[2][1] = sr * cp;
mat[0][2] = (sp * crcy + srsy);
mat[1][2] = (sp * crsy - srcy);
mat[2][2] = cr * cp;
Vector pos = this->m_vecAbsOrigin();
mat[0][3] = pos.x;
mat[1][3] = pos.y;
mat[2][3] = pos.z;
return mat;
}
};
class CBodyComponent
{
public:
DECLARE_SCHEMA_CLASS(CBodyComponent)
SCHEMA_FIELD(CGameSceneNode *, m_pSceneNode);
};
class CModelState
{
public:
DECLARE_SCHEMA_CLASS(CModelState)
SCHEMA_FIELD(CUtlSymbolLarge, m_ModelName)
SCHEMA_FIELD(uint64, m_MeshGroupMask)
};
class CSkeletonInstance : public CGameSceneNode
{
public:
DECLARE_SCHEMA_CLASS(CSkeletonInstance)
SCHEMA_FIELD(CModelState, m_modelState)
};
class CEntitySubclassVDataBase
{
public:
DECLARE_SCHEMA_CLASS(CEntitySubclassVDataBase)
};
class CBaseEntity : public CEntityInstance
{
public:
DECLARE_SCHEMA_CLASS(CBaseEntity)
SCHEMA_FIELD(float32, m_flSimulationTime)
SCHEMA_FIELD(float, m_flCreateTime);
SCHEMA_FIELD(CBodyComponent *, m_CBodyComponent)
SCHEMA_FIELD(CBitVec<64>, m_isSteadyState)
SCHEMA_FIELD(float, m_lastNetworkChange)
SCHEMA_FIELD_POINTER(CNetworkTransmitComponent, m_NetworkTransmitComponent)
SCHEMA_FIELD_POINTER(char, m_iszDamageFilterName);
SCHEMA_FIELD(int, m_iHealth)
SCHEMA_FIELD(int, m_iMaxHealth)
SCHEMA_FIELD(int, m_iTeamNum)
SCHEMA_FIELD(bool, m_bLagCompensate)
SCHEMA_FIELD(Vector, m_vecAbsVelocity)
SCHEMA_FIELD(Vector, m_vecBaseVelocity)
SCHEMA_FIELD(CCollisionProperty*, m_pCollision)
SCHEMA_FIELD(MoveCollide_t, m_MoveCollide)
SCHEMA_FIELD(MoveType_t, m_MoveType)
SCHEMA_FIELD(MoveType_t, m_nActualMoveType)
SCHEMA_FIELD(CHandle<CBaseEntity>, m_hEffectEntity)
SCHEMA_FIELD(uint32, m_spawnflags)
SCHEMA_FIELD(uint32, m_fFlags)
SCHEMA_FIELD(LifeState_t, m_lifeState)
SCHEMA_FIELD(float, m_flDamageAccumulator)
SCHEMA_FIELD(bool, m_bTakesDamage)
SCHEMA_FIELD(TakeDamageFlags_t, m_nTakeDamageFlags)
SCHEMA_FIELD_POINTER(CUtlStringToken, m_nSubclassID)
SCHEMA_FIELD(float, m_flFriction)
SCHEMA_FIELD(float, m_flActualGravityScale)
SCHEMA_FIELD(float, m_flTimeScale)
SCHEMA_FIELD(float, m_flSpeed)
SCHEMA_FIELD(CUtlString, m_sUniqueHammerID)
SCHEMA_FIELD(CUtlSymbolLarge, m_target)
SCHEMA_FIELD(CUtlSymbolLarge, m_iGlobalname)
SCHEMA_FIELD(CHandle<CBaseEntity>, m_hOwnerEntity)
SCHEMA_FIELD(CHandle<CBaseEntity>, m_hGroundEntity);
SCHEMA_FIELD(uint32, m_fEffects)
SCHEMA_FIELD(QAngle, m_vecAngVelocity)
// ---------------------------
// Flag helpers
// ---------------------------
void SetFlags(uint32_t mask)
{
auto& flags = m_fFlags();
flags = mask;
}
void AddFlags(uint32_t mask)
{
auto& flags = m_fFlags();
flags |= mask;
}
void ClearFlags(uint32_t mask)
{
auto& flags = m_fFlags();
flags &= ~mask;
}
bool HasFlags(uint32_t mask) const
{
return (const_cast<CBaseEntity*>(this)->m_fFlags() & mask) == mask;
}
uint32_t GetFlags() const
{
return const_cast<CBaseEntity*>(this)->m_fFlags();
}
// ---------------------------
// Basic entity info
// ---------------------------
Vector GetAbsOrigin()
{
if (!m_CBodyComponent) return Vector{};
if (!m_CBodyComponent->m_pSceneNode) return Vector{};
return m_CBodyComponent->m_pSceneNode->m_vecAbsOrigin();
}
QAngle GetAngRotation()
{
if (!m_CBodyComponent) return QAngle{};
if (!m_CBodyComponent->m_pSceneNode) return QAngle{};
return m_CBodyComponent->m_pSceneNode->m_angRotation();
}
QAngle GetAbsRotation()
{
if (!m_CBodyComponent) return QAngle{};
if (!m_CBodyComponent->m_pSceneNode) return QAngle{};
return m_CBodyComponent->m_pSceneNode->m_angAbsRotation();
}
Vector GetAbsVelocity() { return m_vecAbsVelocity; }
void SetAbsOrigin(const Vector& vecOrigin)
{
if (!m_CBodyComponent) return;
if (!m_CBodyComponent->m_pSceneNode) return;
m_CBodyComponent->m_pSceneNode->m_vecAbsOrigin(vecOrigin);
}
void SetAbsRotation(const QAngle& angAbsRotation)
{
if (!m_CBodyComponent) return;
if (!m_CBodyComponent->m_pSceneNode) return;
m_CBodyComponent->m_pSceneNode->m_angAbsRotation(angAbsRotation);
}
void SetAngRotation(const QAngle& angRotation)
{
if (!m_CBodyComponent) return;
if (!m_CBodyComponent->m_pSceneNode) return;
m_CBodyComponent->m_pSceneNode->m_angRotation(angRotation);
}
void SetAbsVelocity(const Vector& vecVelocity) { m_vecAbsVelocity = vecVelocity; }
void SetBaseVelocity(const Vector& vecVelocity) { m_vecBaseVelocity = vecVelocity; }
CEntitySubclassVDataBase* GetVData()
{
return *(CEntitySubclassVDataBase**)((uint8*)(m_nSubclassID()) + 4);
}
// ---------------------------
// Engine calls
// ---------------------------
void Teleport(const Vector* position, const QAngle* angles, const Vector* velocity)
{
static int offset = shared::g_pGameConfig->GetOffset("CBaseEntity_Teleport");
CALL_VIRTUAL(void, offset, this, position, angles, velocity);
}
void SetMoveType(MoveType_t nMoveType)
{
m_MoveType() = nMoveType;
m_nActualMoveType() = nMoveType;
}
void CollisionRulesChanged()
{
static int offset = shared::g_pGameConfig->GetOffset("CBaseEntity_CollisionRulesChanged");
CALL_VIRTUAL(void, offset, this);
}
int GetTeam() { return m_iTeamNum(); }
bool IsAlive() { return m_lifeState() == LifeState_t::LIFE_ALIVE; }
CHandle<CBaseEntity> GetHandle() const { return m_pEntity->m_EHandle; }
const char* GetName() const { return m_pEntity->m_name.String(); }
const char* GetDesignerName() const { return m_pEntity ? m_pEntity->m_designerName.String() : ""; }
// ---------------------------
// Detours
// ---------------------------
void DispatchSpawn()
{
using DispatchSpawn_t = void (*)(CBaseEntity* /*self*/, void* /*pMapData*/);
static DispatchSpawn_t s_DispatchSpawn = nullptr;
if (!s_DispatchSpawn)
{
DispatchSpawn_t addr = DynLibUtils::CModule(shared::g_pServer).FindPattern(
shared::g_pGameConfig->GetSignature("CBaseEntity_DispatchSpawn")).RCast<DispatchSpawn_t>();
if (!addr) return;
s_DispatchSpawn = addr;
}
s_DispatchSpawn(this, nullptr);
}
void AcceptInput(const char* pInputName, CEntityInstance* pActivator = nullptr,
CEntityInstance* pCaller = nullptr, const char* value = "")
{
if (!g_CEntityInstance_AcceptInput)
{
g_CEntityInstance_AcceptInput =
DynLibUtils::CModule(shared::g_pServer)
.FindPattern(shared::g_pGameConfig->GetSignature("CEntityInstance_AcceptInput"))
.RCast<CEntityInstance_AcceptInput_t>();
if (!g_CEntityInstance_AcceptInput)
return;
}
g_CEntityInstance_AcceptInput(this, pInputName, pActivator, pCaller, variant_t(value), 0, 0LL);
}
void AddEntityIOEvent(const char* pInputName, CEntityInstance* pActivator = nullptr,
CEntityInstance* pCaller = nullptr, const char* value = "", float flDelay = 0.0)
{
if (!g_CEntitySystem_AddEntityIOEvent)
{
g_CEntitySystem_AddEntityIOEvent =
DynLibUtils::CModule(shared::g_pServer)
.FindPattern(shared::g_pGameConfig->GetSignature("CEntitySystem_AddEntityIOEvent"))
.RCast<CEntitySystem_AddEntityIOEvent_t>();
if (!g_CEntitySystem_AddEntityIOEvent)
return;
}
g_CEntitySystem_AddEntityIOEvent(shared::g_pEntitySystem, this, pInputName, pActivator, pCaller,
variant_t(value), flDelay, 0,
0LL, 0LL);
}
};
class CBodyComponentSkeletonInstance : public CBodyComponent
{
public:
DECLARE_SCHEMA_CLASS(CBodyComponentSkeletonInstance);
};
class CBaseAnimGraphController
{
public:
DECLARE_SCHEMA_CLASS_INLINE(CBaseAnimGraphController);
SCHEMA_FIELD(float, m_flPlaybackRate);
};
class CBodyComponentBaseAnimGraph : public CBodyComponentSkeletonInstance
{
public:
DECLARE_SCHEMA_CLASS(CBodyComponentBaseAnimGraph);
SCHEMA_FIELD(CBaseAnimGraphController, m_animationController);
};
class SpawnPoint : public CBaseEntity
{
public:
DECLARE_SCHEMA_CLASS(SpawnPoint);
SCHEMA_FIELD(bool, m_bEnabled);
};

21
src/schema/CBaseFilter.h
View file

@ -1,21 +0,0 @@
//
// Created by Michal Přikryl on 07.11.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "CBaseTrigger.h"
#include "globaltypes.h"
namespace
TemplatePlugin
{
class CBaseFilter : public CBaseEntity
{
public:
DECLARE_SCHEMA_CLASS(CBaseFilter);
SCHEMA_FIELD(bool, m_bNegated)
SCHEMA_FIELD(CEntityIOOutput, m_OnPass)
SCHEMA_FIELD(CEntityIOOutput, m_OnFail)
};
}

33
src/schema/CBaseGrenade.h
View file

@ -1,33 +0,0 @@
//
// Created by Michal Přikryl on 26.06.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "CBaseModelEntity.h"
#include "CBasePlayerPawn.h"
#include "globaltypes.h"
namespace TemplatePlugin {
class CBaseGrenade : public CBaseModelEntity
{
public:
DECLARE_SCHEMA_CLASS(CBaseGrenade);
SCHEMA_FIELD(CHandle<CCSPlayerPawn>, m_hThrower);
SCHEMA_FIELD(float, m_flDamage);
SCHEMA_FIELD(float, m_DmgRadius);
};
class CBaseCSGrenadeProjectile : public CBaseGrenade
{
public:
DECLARE_SCHEMA_CLASS(CBaseCSGrenadeProjectile);
};
class CSmokeGrenadeProjectile : public CBaseCSGrenadeProjectile
{
public:
DECLARE_SCHEMA_CLASS(CSmokeGrenadeProjectile);
SCHEMA_FIELD(Vector, m_vSmokeColor);
SCHEMA_FIELD(int, m_nSmokeEffectTickBegin);
};
}

2
src/schema/CBaseModelEntity.h
View file

@ -7,7 +7,7 @@
#include "globaltypes.h"
namespace
TemplatePlugin
RayTracePlugin
{
class CBaseModelEntity : public CBaseEntity
{

83
src/schema/CBasePlayerController.h
View file

@ -1,83 +0,0 @@
//
// Created by Michal Přikryl on 26.06.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "ehandle.h"
#include "CCSPlayerPawn.h"
namespace TemplatePlugin
{
enum class PlayerConnectedState : uint32_t
{
PlayerNeverConnected = 0xFFFFFFFF,
PlayerConnected = 0x0,
PlayerConnecting = 0x1,
PlayerReconnecting = 0x2,
PlayerDisconnecting = 0x3,
PlayerDisconnected = 0x4,
PlayerReserved = 0x5,
};
class CBasePlayerController : public CBaseEntity
{
public:
DECLARE_SCHEMA_CLASS(CBasePlayerController);
SCHEMA_FIELD(CHandle<CBasePlayerPawn>, m_hPawn)
SCHEMA_FIELD_POINTER(char, m_iszPlayerName)
SCHEMA_FIELD(PlayerConnectedState, m_iConnected)
SCHEMA_FIELD(uint32_t, m_iDesiredFOV);
SCHEMA_FIELD_POINTER(uint64_t, m_steamID)
SCHEMA_FIELD_POINTER(bool, m_bIsHLTV)
CBasePlayerPawn* GetPawn() { return m_hPawn.Get(); }
const char* GetPlayerName() { return m_iszPlayerName(); }
void SetPlayerName(const std::string& name)
{
std::strncpy(m_iszPlayerName(), name.c_str(), 128);
m_iszPlayerName()[127] = '\0';
}
int GetPlayerSlot() { return GetEntityIndex().Get() - 1; }
bool IsConnected() { return m_iConnected() == PlayerConnectedState::PlayerConnected; }
uint64_t GetSteamID() { return *m_steamID(); }
void SetSteamID(uint64_t id) { *m_steamID() = id; }
bool GetIsHLTV() { return *m_bIsHLTV(); }
void SetIsHLTV(bool value) { *m_bIsHLTV() = value; }
uint64_t& SteamID() { return *m_steamID(); }
bool& IsHLTV() { return *m_bIsHLTV(); }
using CBasePlayerController_SetPawn_t = void(*)(CBasePlayerController* pController, CCSPlayerPawn* pPawn,
bool a3, bool a4, bool a5, bool a6);
void SetPawn(CCSPlayerPawn* pawn)
{
if (!pawn) return;
CBasePlayerController_SetPawn_t CBasePlayerController_SetPawn = nullptr;
if (!CBasePlayerController_SetPawn)
{
CBasePlayerController_SetPawn_t addr = addr =
DynLibUtils::CModule(shared::g_pServer)
.FindPattern(shared::g_pGameConfig->GetSignature("CBasePlayerController_SetPawn"))
.RCast<CBasePlayerController_SetPawn_t>();
if (!addr)
return;
CBasePlayerController_SetPawn = addr;
}
CBasePlayerController_SetPawn(this, pawn, true, false, false, false);
}
};
}

76
src/schema/CBasePlayerPawn.h
View file

@ -1,76 +0,0 @@
//
// Created by Michal Přikryl on 26.06.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "CBaseEntity.h"
#include "CBaseModelEntity.h"
#include "services.h"
namespace TemplatePlugin {
enum class Hull_t : uint32
{
HULL_HUMAN = 0,
HULL_SMALL_CENTERED = 1,
HULL_WIDE_HUMAN = 2,
HULL_TINY = 3,
HULL_MEDIUM = 4,
HULL_TINY_CENTERED = 5,
HULL_LARGE = 6,
HULL_LARGE_CENTERED = 7,
HULL_MEDIUM_TALL = 8,
HULL_SMALL = 9,
NUM_HULLS = 10,
HULL_NONE = 11,
};
class CMovementStatsProperty
{
public:
DECLARE_SCHEMA_CLASS(CMovementStatsProperty);
SCHEMA_FIELD(uint32, m_nUseCounter);
SCHEMA_FIELD(void*, m_emaMovementDirection);
};
class CBaseCombatCharacter : public CBaseModelEntity
{
public:
DECLARE_SCHEMA_CLASS(CBaseCombatCharacter);
SCHEMA_FIELD(bool, m_bForceServerRagdoll);
SCHEMA_FIELD_POINTER(CUtlVector<CHandle<CEconWearable>>, m_hMyWearables)
SCHEMA_FIELD(float, m_impactEnergyScale);
SCHEMA_FIELD(bool, m_bApplyStressDamage);
SCHEMA_FIELD(bool, m_bDeathEventsDispatched);
SCHEMA_FIELD(CUtlString, m_strRelationships);
SCHEMA_FIELD(Hull_t, m_eHull);
SCHEMA_FIELD(uint32, m_nNavHullIdx);
SCHEMA_FIELD(CMovementStatsProperty, m_movementStats);
};
class CBasePlayerPawn : public CBaseCombatCharacter
{
public:
DECLARE_SCHEMA_CLASS(CBasePlayerPawn);
SCHEMA_FIELD(CCSPlayer_MovementServices*, m_pMovementServices)
SCHEMA_FIELD(CCSPlayer_WeaponServices*, m_pWeaponServices)
SCHEMA_FIELD(CCSPlayer_ItemServices*, m_pItemServices)
SCHEMA_FIELD(CPlayer_ObserverServices*, m_pObserverServices)
SCHEMA_FIELD(CPlayer_CameraServices*, m_pCameraServices)
SCHEMA_FIELD(CHandle<CBasePlayerController>, m_hController)
SCHEMA_FIELD(QAngle, v_angle)
SCHEMA_FIELD(QAngle, v_anglePrevious)
SCHEMA_FIELD(uint32, m_iHideHUD)
SCHEMA_FIELD(bool, m_fInitHUD)
void CommitSuicide(bool bExplode, bool bForce)
{
static int offset = shared::g_pGameConfig->GetOffset("CBasePlayerPawn_CommitSuicide");
CALL_VIRTUAL(void, offset, this, bExplode, bForce);
}
CBasePlayerController *GetController() { return m_hController.Get(); }
};
}

23
src/schema/CBaseProp.h
View file

@ -1,23 +0,0 @@
//
// Created by Michal Přikryl on 31.10.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "CBaseEntity.h"
#include "globaltypes.h"
#include "CBaseAnimGraph.h"
namespace
TemplatePlugin
{
class CBaseProp : public CBaseAnimGraph
{
public:
DECLARE_SCHEMA_CLASS(CBaseProp)
SCHEMA_FIELD(bool, m_bModelOverrodeBlockLOS)
SCHEMA_FIELD(int, m_iShapeType)
SCHEMA_FIELD(bool, m_bConformToCollisionBounds)
SCHEMA_FIELD(CTransform, m_mPreferredCatchTransform)
};
}

79
src/schema/CBaseTrigger.h
View file

@ -1,79 +0,0 @@
//
// Created by Michal Přikryl on 26.06.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "CBaseModelEntity.h"
#include "schemasystem.h"
#define SF_TRIG_PUSH_ONCE 0x80
namespace TemplatePlugin {
enum TOGGLE_STATE : uint32_t
{
TS_AT_TOP = 0,
TS_AT_BOTTOM = 1,
TS_GOING_UP = 2,
TS_GOING_DOWN = 3,
DOOR_OPEN = 0,
DOOR_CLOSED = 1,
DOOR_OPENING = 2,
DOOR_CLOSING = 3,
};
class CBaseToggle : public CBaseModelEntity
{
public:
DECLARE_SCHEMA_CLASS(CBaseToggle);
SCHEMA_FIELD(TOGGLE_STATE, m_toggle_state)
SCHEMA_FIELD(float32, m_flMoveDistance)
SCHEMA_FIELD(float32, m_flWait)
SCHEMA_FIELD(float32, m_flLip)
SCHEMA_FIELD(bool, m_bAlwaysFireBlockedOutputs)
SCHEMA_FIELD(Vector, m_vecPosition1)
SCHEMA_FIELD(Vector, m_vecPosition2)
SCHEMA_FIELD(QAngle, m_vecMoveAng)
SCHEMA_FIELD(QAngle, m_vecAngle1)
SCHEMA_FIELD(QAngle, m_vecAngle2)
SCHEMA_FIELD(float32, m_flHeight)
SCHEMA_FIELD(CEntityHandle, m_hActivator)
SCHEMA_FIELD(Vector, m_vecFinalDest)
SCHEMA_FIELD(QAngle, m_vecFinalAngle)
SCHEMA_FIELD(int32, m_movementType)
SCHEMA_FIELD(CUtlSymbolLarge, m_sMaster)
};
class CBaseTrigger : public CBaseToggle
{
public:
DECLARE_SCHEMA_CLASS(CBaseTrigger);
SCHEMA_FIELD(CEntityIOOutput, m_OnStartTouch);
SCHEMA_FIELD(CEntityIOOutput, m_OnStartTouchAll);
SCHEMA_FIELD(CEntityIOOutput, m_OnEndTouch);
SCHEMA_FIELD(CEntityIOOutput, m_OnEndTouchAll);
SCHEMA_FIELD(CEntityIOOutput, m_OnTouching);
SCHEMA_FIELD(CEntityIOOutput, m_OnTouchingEachEntity);
SCHEMA_FIELD(CEntityIOOutput, m_OnNotTouching);
SCHEMA_FIELD_POINTER(CUtlVector<CHandle<CBaseEntity>>, m_hTouchingEntities)
SCHEMA_FIELD(CUtlSymbolLarge, m_iFilterName)
SCHEMA_FIELD(CEntityHandle, m_hFilter)
SCHEMA_FIELD(bool, m_bDisabled);
SCHEMA_FIELD(bool, m_bUseAsyncQueries);
};
class CTriggerMultiple : public CBaseTrigger
{
public:
DECLARE_SCHEMA_CLASS(CTriggerMultiple);
SCHEMA_FIELD(CEntityIOOutput, m_OnTrigger);
};
class CBombTarget : public CBaseTrigger
{
public:
DECLARE_SCHEMA_CLASS(CBombTarget);
SCHEMA_FIELD(bool, m_bIsBombSiteB);
};
}

81
src/schema/CBreakableProp.h
View file

@ -1,81 +0,0 @@
//
// Created by Michal Přikryl on 01.11.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "CBaseEntity.h"
#include "globaltypes.h"
#include "CBaseProp.h"
namespace
TemplatePlugin
{
class CPropDataComponent : public CEntityComponent
{
public:
DECLARE_SCHEMA_CLASS(CPropDataComponent)
SCHEMA_FIELD(float, m_flDmgModBullet)
SCHEMA_FIELD(float, m_flDmgModClub)
SCHEMA_FIELD(float, m_flDmgModExplosive)
SCHEMA_FIELD(float, m_flDmgModFire)
SCHEMA_FIELD_POINTER(char, m_iszPhysicsDamageTableName)
SCHEMA_FIELD_POINTER(char, m_iszBasePropData)
SCHEMA_FIELD(int32, m_nInteractions)
SCHEMA_FIELD(bool, m_bSpawnMotionDisabled)
SCHEMA_FIELD(int32, m_nDisableTakePhysicsDamageSpawnFlag)
SCHEMA_FIELD(int32, m_nMotionDisabledSpawnFlag)
};
enum BreakableContentsType_t : uint
{
BC_DEFAULT = 0x0,
BC_EMPTY = 0x1,
BC_PROP_GROUP_OVERRIDE = 0x2,
BC_PARTICLE_SYSTEM_OVERRIDE = 0x3,
};
enum PerformanceMode_t : uint
{
PM_NORMAL = 0x0,
PM_NO_GIBS = 0x1,
};
class CBreakableProp : public CBaseProp
{
public:
DECLARE_SCHEMA_CLASS(CBreakableProp);
SCHEMA_FIELD(CPropDataComponent, m_CPropDataComponent)
SCHEMA_FIELD(CEntityIOOutput, m_OnStartDeath)
SCHEMA_FIELD(CEntityIOOutput, m_OnBreak)
SCHEMA_FIELD(CEntityIOOutput, m_OnTakeDamage)
SCHEMA_FIELD(float, m_impactEnergyScale)
SCHEMA_FIELD(int32, m_iMinHealthDmg)
SCHEMA_FIELD(QAngle, m_preferredCarryAngles)
SCHEMA_FIELD(float, m_flPressureDelay)
SCHEMA_FIELD(float, m_flDefBurstScale)
SCHEMA_FIELD(Vector, m_vDefBurstOffset)
SCHEMA_FIELD(CHandle<CBaseEntity>, m_hBreaker)
SCHEMA_FIELD(PerformanceMode_t, m_PerformanceMode)
SCHEMA_FIELD(float, m_flPreventDamageBeforeTime)
SCHEMA_FIELD(BreakableContentsType_t, m_BreakableContentsType)
SCHEMA_FIELD_POINTER(char, m_strBreakableContentsPropGroupOverride)
SCHEMA_FIELD_POINTER(char, m_strBreakableContentsParticleOverride)
SCHEMA_FIELD(bool, m_bHasBreakPiecesOrCommands)
SCHEMA_FIELD(float, m_explodeDamage)
SCHEMA_FIELD(float, m_explodeRadius)
SCHEMA_FIELD(float, m_explosionDelay)
SCHEMA_FIELD_POINTER(char, m_explosionBuildupSound)
SCHEMA_FIELD_POINTER(char, m_explosionCustomEffect)
SCHEMA_FIELD_POINTER(char, m_explosionCustomSound)
SCHEMA_FIELD_POINTER(char, m_explosionModifier)
SCHEMA_FIELD(CHandle<CBasePlayerPawn>, m_hPhysicsAttacker)
SCHEMA_FIELD(float, m_flLastPhysicsInfluenceTime)
SCHEMA_FIELD(float, m_flDefaultFadeScale)
SCHEMA_FIELD(CHandle<CBaseEntity>, m_hLastAttacker)
SCHEMA_FIELD_POINTER(char, m_iszPuntSound)
SCHEMA_FIELD(bool, m_bUsePuntSound)
SCHEMA_FIELD(bool, m_bOriginalBlockLOS)
};
}

18
src/schema/CC4.h
View file

@ -1,18 +0,0 @@
//
// Created by Michal Přikryl on 26.06.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include <entity2/entityidentity.h>
#include "CGameRules.h"
#include "schemasystem.h"
namespace TemplatePlugin {
class CC4
{
public:
DECLARE_SCHEMA_CLASS(CC4);
SCHEMA_FIELD(GameTime_t, m_fArmedTime);
};
}

727
src/schema/CCSPlayerController.h
View file

@ -1,727 +0,0 @@
//
// Created by Michal Přikryl on 26.06.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include <colors.h>
#include <detourtypes.h>
#include <tasks.h>
#include <vectorextends.h>
#include "CBasePlayerController.h"
#include "serversideclient.h"
#include "services.h"
#include "Shared.h"
#include "RayTrace.h"
namespace TemplatePlugin {
extern CServerSideClient* GetClientBySlot(CPlayerSlot slot);
class CCSPlayerController : public CBasePlayerController
{
public:
DECLARE_SCHEMA_CLASS(CCSPlayerController);
SCHEMA_FIELD(CCSPlayerController_InGameMoneyServices*, m_pInGameMoneyServices);
SCHEMA_FIELD(CCSPlayerController_ActionTrackingServices*, m_pActionTrackingServices);
SCHEMA_FIELD(CCSPlayerController_InventoryServices*, m_pInventoryServices);
SCHEMA_FIELD(uint32_t, m_iPing);
SCHEMA_FIELD(CUtlSymbolLarge, m_szClan);
SCHEMA_FIELD_POINTER(char, m_szClanName) // char m_szClanName[32]
SCHEMA_FIELD(bool, m_bEverFullyConnected);
SCHEMA_FIELD(bool, m_bPawnIsAlive);
SCHEMA_FIELD(int32_t, m_nDisconnectionTick);
SCHEMA_FIELD(CHandle<CCSPlayerPawn>, m_hPlayerPawn);
SCHEMA_FIELD(int32, m_DesiredObserverMode);
SCHEMA_FIELD(int16_t, m_nPawnCharacterDefIndex);
SCHEMA_FIELD(CHandle<CCSPlayerPawnBase>, m_hObserverPawn);
SCHEMA_FIELD(CHandle<CCSPlayerController>, m_hOriginalControllerOfCurrentPawn);
SCHEMA_FIELD(uint32_t, m_iPawnHealth);
SCHEMA_FIELD(int32_t, m_iPawnArmor);
SCHEMA_FIELD(int32_t, m_iScore);
SCHEMA_FIELD(int32_t, m_iRoundScore);
SCHEMA_FIELD(int32_t, m_iRoundsWon);
SCHEMA_FIELD(int32_t, m_iMVPs);
SCHEMA_FIELD(float, m_flSmoothedPing);
SCHEMA_FIELD(GameTime_t, m_flForceTeamTime);
SCHEMA_FIELD(int32_t, m_iCompetitiveRanking);
SCHEMA_FIELD(int8_t, m_iCompetitiveRankType);
SCHEMA_FIELD(int32_t, m_iCompetitiveWins);
SCHEMA_FIELD(byte, m_iPendingTeamNum);
SCHEMA_FIELD(byte, m_bTeamChanged);
SCHEMA_FIELD(byte, m_bInSwitchTeam);
static CCSPlayerController* FromUserId(int userid)
{
for (int i = 0; i < shared::getGlobalVars()->maxClients; ++i)
{
CCSPlayerController* controller = FromSlot(i);
if (!controller)
continue;
int iUserId = shared::g_pEngine->GetPlayerUserId(i).Get();
if (userid == iUserId) return controller;
}
return nullptr;
}
static CCSPlayerController* FromPawn(CCSPlayerPawn* pawn)
{
return reinterpret_cast<CCSPlayerController*>(pawn->m_hController().Get());
}
static CCSPlayerController* FromIndex(int iIndex)
{
return static_cast<CCSPlayerController*>(shared::g_pEntitySystem->
GetEntityInstance(CEntityIndex(iIndex)));
}
static CCSPlayerController* FromSlot(int iSlot)
{
return static_cast<CCSPlayerController*>(shared::g_pEntitySystem->
GetEntityInstance(CEntityIndex(iSlot + 1)));
}
static CCSPlayerController* FromSteamId(uint64 steamid)
{
for (int i = 0; i < shared::getGlobalVars()->maxClients; ++i)
{
CCSPlayerController* controller = FromSlot(i);
if (!controller)
continue;
if (steamid == controller->GetSteamID()) return controller;
}
return nullptr;
}
CServerSideClient* GetServerSideClient()
{
return GetClientBySlot(GetPlayerSlot());
}
CCSPlayerPawn* GetPlayerPawn()
{
if (auto handle = m_hPlayerPawn(); handle.IsValid())
return handle.Get();
return nullptr;
}
CCSPlayerPawn* GetObserverPawn()
{
if (auto handle = m_hObserverPawn(); handle.IsValid())
return static_cast<CCSPlayerPawn*>(handle.Get());
return nullptr;
}
bool IsBot() { return GetSteamID() == 0; }
void ChangeTeam(CsTeam iTeam)
{
CALL_VIRTUAL(void, shared::g_pGameConfig->GetOffset("CCSPlayerController_ChangeTeam"), this,
static_cast<byte>(iTeam));
}
static std::string CsTeamToString(CsTeam team)
{
switch (team)
{
case CsTeam::None: return "None";
case CsTeam::Spectator: return "Spectator";
case CsTeam::Terrorist: return "Terrorist";
case CsTeam::CounterTerrorist: return "CounterTerrorist";
default: return "Unknown";
}
}
CsTeam Team()
{
byte teamNum = GetTeam();
if (teamNum < static_cast<byte>(CsTeam::None) || teamNum > static_cast<byte>(CsTeam::CounterTerrorist))
return CsTeam::None;
return static_cast<CsTeam>(teamNum);
}
void Respawn()
{
CCSPlayerPawn* pPawn = GetPlayerPawn();
if (!pPawn || m_bPawnIsAlive)
return;
SetPawn(pPawn);
CALL_VIRTUAL(void, shared::g_pGameConfig->GetOffset("CCSPlayerController_Respawn"), this);
}
bool CheckValid(bool alive = false)
{
CCSPlayerPawn* pawn = GetPlayerPawn();
if (IsBot() || GetIsHLTV() || GetSteamID() <= 0 || !IsConnected() || !pawn)
return false;
if (alive && !m_bPawnIsAlive())
{
return false;
}
return true;
}
void TakeFakeDamage(CCSPlayerController* attacker, int damage)
{
static CBaseEntity_TakeDamageOld_t s_TakeDamageOld = nullptr;
if (!s_TakeDamageOld)
{
CBaseEntity_TakeDamageOld_t addr =
DynLibUtils::CModule(shared::g_pServer)
.FindPattern(shared::g_pGameConfig->GetSignature("CBaseEntity_TakeDamageOld"))
.RCast<CBaseEntity_TakeDamageOld_t>();
if (!addr) return;
s_TakeDamageOld = addr;
}
if (!CheckValid(true) || !attacker || !attacker->CheckValid())
return;
auto* victimPawn = GetPlayerPawn();
if (!victimPawn) return;
auto* attackerPawn = attacker->GetPlayerPawn();
if (!attackerPawn) return;
const size_t infoSize = schema::GetClassSize("CTakeDamageInfo");
const size_t resultSize = schema::GetClassSize("CTakeDamageResult");
auto* infoMem = std::malloc(infoSize);
auto* resultMem = std::malloc(resultSize);
if (!infoMem || !resultMem)
{
std::free(infoMem);
std::free(resultMem);
return;
}
std::memset(infoMem, 0, infoSize);
std::memset(resultMem, 0, resultSize);
CAttackerInfo attackerInfo(attacker);
std::memcpy(reinterpret_cast<std::uint8_t*>(infoMem) + 0x98, &attackerInfo, sizeof(CAttackerInfo));
auto* info = reinterpret_cast<CTakeDamageInfo*>(infoMem);
auto* result = reinterpret_cast<CTakeDamageResult*>(resultMem);
info->m_hInflictor() = attackerPawn->GetHandle();
info->m_hAttacker() = attackerPawn->GetHandle();
info->m_flDamage() = static_cast<float>(damage);
info->m_flFriendlyFireDamageReductionRatio() = static_cast<float>(0);
info->m_bInTakeDamageFlow() = true;
info->m_bitsDamageType() = DMG_GENERIC;
result->m_pOriginatingInfo() = info;
result->m_nDamageDealt() = damage;
result->m_nHealthLost() = damage;
result->m_flPreModifiedDamage() = static_cast<float>(damage);
result->m_nTotalledDamageDealt() = damage;
result->m_nTotalledHealthLost() = damage;
result->m_bWasDamageSuppressed() = false;
s_TakeDamageOld(victimPawn, info, result);
std::free(infoMem);
std::free(resultMem);
}
void Kick(ENetworkDisconnectionReason reason)
{
if (!CheckValid()) return;
CPlayerSlot slot = CPlayerSlot(GetPlayerSlot());
Tasks::NextFrame([slot, reason]
{
shared::g_pEngine->DisconnectClient(
slot, reason);
});
}
PlayerConnectedState GetConnectedState() { return m_iConnected(); }
CSPlayerState GetPawnState()
{
CCSPlayerPawnBase* pPawn = static_cast<CCSPlayerPawnBase*>(GetPawn());
if (!pPawn)
return STATE_WELCOME;
return pPawn->m_iPlayerState();
}
CSPlayerState GetPlayerPawnState()
{
CCSPlayerPawn* pPawn = GetPlayerPawn();
if (!pPawn)
return STATE_WELCOME;
return pPawn->m_iPlayerState();
}
CBaseEntity* GetObserverTarget()
{
auto pPawn = GetPawn();
if (!pPawn)
return nullptr;
return pPawn->m_pObserverServices->m_hObserverTarget().Get();
}
// --- HEALTH & ARMOR ---
int GetHealth()
{
if (!CheckValid(true)) return 0;
auto pawn = GetPlayerPawn();
return pawn->m_iHealth;
}
void SetHealth(int health)
{
if (!CheckValid(true) || health <= 0) return;
auto pawn = GetPlayerPawn();
pawn->m_iHealth = health;
m_iPawnHealth = health;
if (health > pawn->m_iMaxHealth)
pawn->m_iMaxHealth = health;
}
void AddHealth(int delta)
{
if (!CheckValid(true) || delta <= 0) return;
auto pawn = GetPlayerPawn();
pawn->m_iHealth += delta;
m_iPawnHealth += delta;
}
void SetMaxHealth(int maxHp)
{
if (!CheckValid(true) || maxHp <= 0) return;
auto pawn = GetPlayerPawn();
pawn->m_iMaxHealth = maxHp;
}
void SetArmor(int armor, bool helmet = false)
{
if (!CheckValid(true) || armor < 0) return;
auto pawn = GetPlayerPawn();
pawn->m_ArmorValue = armor;
m_iPawnArmor = armor;
if (helmet && pawn->m_pItemServices)
pawn->m_pItemServices->m_bHasHelmet = true;
}
void AddArmor(int delta)
{
if (!CheckValid(true) || delta <= 0) return;
auto pawn = GetPlayerPawn();
pawn->m_ArmorValue() += delta;
m_iPawnArmor() += delta;
}
// --- WEAPONS ---
std::vector<CCSWeaponBase*> GetWeapons()
{
std::vector<CCSWeaponBase*> weapons;
auto pawn = GetPlayerPawn();
if (!pawn || !pawn->m_pWeaponServices() || !pawn->m_pWeaponServices()->m_hMyWeapons())
return weapons;
const auto& myWeapons = *pawn->m_pWeaponServices()->m_hMyWeapons();
for (int i = 0; i < myWeapons.Count(); ++i)
{
const auto& handle = myWeapons[i];
if (!handle.IsValid()) continue;
if (auto* weapon = static_cast<CCSWeaponBase*>(handle.Get()))
{
weapons.push_back(weapon);
}
}
return weapons;
}
CCSWeaponBase* GetWeaponByDefIndex(int defIndex)
{
for (auto* base : GetWeapons())
{
if (base->m_AttributeManager().m_Item().m_iItemDefinitionIndex() == defIndex)
return base;
}
return nullptr;
}
CCSWeaponBase* GetWeaponBySlot(gear_slot_t slot)
{
for (auto* base : GetWeapons())
{
if (base->GetWeaponVData() && base->GetWeaponVData()->m_GearSlot() == slot)
return base;
}
return nullptr;
}
CCSWeaponBase* GetWeaponByName(const std::string& weaponName)
{
for (auto* base : GetWeapons())
{
if (base->GetDesignerName() == weaponName)
return base;
}
return nullptr;
}
bool HasWeaponByName(const std::string& weaponName)
{
return GetWeaponByName(weaponName) != nullptr;
}
bool HasWeaponInSlot(gear_slot_t slot)
{
return GetWeaponBySlot(slot) != nullptr;
}
std::string GetWeaponNameBySlot(gear_slot_t slot)
{
if (auto* w = GetWeaponBySlot(slot))
{
return w->GetDesignerName();
}
return {};
}
void DropWeaponByName(const std::string& weaponName)
{
auto pawn = GetPlayerPawn();
if (!pawn || !pawn->m_pWeaponServices()) return;
if (auto* weapon = GetWeaponByName(weaponName))
{
pawn->m_pWeaponServices()->m_hActiveWeapon() = CHandle<CBaseEntity>(weapon);
pawn->m_pItemServices()->DropActiveWeapon(weapon);
}
}
// --- POSITION / AIM ---
Vector GetEyePosition()
{
auto pawn = GetPlayerPawn();
if (!pawn) return {0, 0, 0};
Vector origin = pawn->GetAbsOrigin();
Vector offset = pawn->m_vecViewOffset();
return {origin.x, origin.y, origin.z + offset.z};
}
CBaseEntity* GetAimEntity(bool includePlayers = false)
{
if (!CheckValid(true))
return nullptr;
auto* pawn = GetPlayerPawn();
if (!pawn)
return nullptr;
QAngle eyeAngles = pawn->GetEyeAngles();
Vector eyePos = GetEyePosition();
RayTrace::TraceOptions opts{};
if (!includePlayers)
opts.InteractsExclude = RayTrace::InteractionLayers::Player;
auto result = RayTrace::TraceShape(
eyePos,
eyeAngles,
pawn,
&opts
);
return result.has_value()
? static_cast<CBaseEntity*>(result->HitEntity)
: nullptr;
}
struct AimPositionResult
{
bool Hit{false};
Vector Origin{};
Vector Normal{};
};
AimPositionResult GetAimPositionEx(bool includePlayers = true)
{
AimPositionResult result{};
if (!CheckValid(true))
return result;
auto* pawn = GetPlayerPawn();
if (!pawn)
return result;
QAngle eyeAngles = pawn->GetEyeAngles();
Vector eyePos = GetEyePosition();
Vector forward{};
AngleVectors(eyeAngles, &forward, nullptr, nullptr);
Vector origin = eyePos + forward * 15.0f;
RayTrace::TraceOptions opts{};
if (!includePlayers)
opts.InteractsExclude = RayTrace::InteractionLayers::Player;
auto traceResult = RayTrace::TraceShape(
eyePos,
eyeAngles,
pawn,
&opts
);
if (traceResult.has_value())
{
result.Hit = true;
result.Origin = traceResult->EndPos;
result.Normal = traceResult->Normal;
return result;
}
result.Hit = false;
result.Origin = origin + forward * 8192.0f;
return result;
}
Vector GetAimPosition(bool includePlayers = true)
{
if (!CheckValid(true))
return {0, 0, 0};
auto* pawn = GetPlayerPawn();
if (!pawn)
return {0, 0, 0};
QAngle eyeAngles = pawn->GetEyeAngles();
Vector eyePos = GetEyePosition();
Vector forward{};
AngleVectors(eyeAngles, &forward, nullptr, nullptr);
Vector origin = eyePos + forward * 15.0f;
RayTrace::TraceOptions opts{};
if (!includePlayers)
opts.InteractsExclude = RayTrace::InteractionLayers::Player;
auto traceResult = RayTrace::TraceShape(
eyePos,
eyeAngles,
pawn,
&opts
);
if (traceResult.has_value())
{
return traceResult->EndPos;
}
return origin + forward * 8192.0f;
}
bool IsPlayerInSightRange(CCSPlayerController* target,
float distance = 0.0f, float angle = 90.0f, bool heightCheck = true,
bool negativeAngle = false)
{
if (!CheckValid(true) || !target->CheckValid(true) || GetPlayerPawn()->GetAbsOrigin().IsZero() ||
target->GetPlayerPawn()->GetAbsOrigin().IsZero())
return false;
float resultDistance = 0;
auto playerEyeAngles = GetPlayerPawn()->GetEyeAngles();
playerEyeAngles.x = 0.0f;
playerEyeAngles.z = 0.0f;
Vector angleVector;
AngleVectors(playerEyeAngles, &angleVector, nullptr, nullptr);
angleVector = VectorExtends::Normalize(angleVector);
if (negativeAngle)
angleVector = VectorExtends::NegateVector(angleVector);
auto playerOrigin = GetPlayerPawn()->GetAbsOrigin();
auto targetOrigin = target->GetPlayerPawn()->GetAbsOrigin();
if (heightCheck && distance > 0.0f)
resultDistance = VectorExtends::Distance(playerOrigin, targetOrigin);
if (distance > 0.0f)
{
if (resultDistance > distance)
return false;
}
playerOrigin.z = 0.0f;
targetOrigin.z = 0.0f;
auto targetVector = VectorExtends::MakeVectorFromPoints(playerOrigin, targetOrigin);
targetVector = VectorExtends::Normalize(targetVector);
auto resultAngle = VectorExtends::RadToDeg(
VectorExtends::ArcCosine(VectorExtends::GetVectorDotProduct(targetVector, angleVector)));
if (resultAngle > angle / 2)
return false;
if (distance > 0.0f)
{
if (!heightCheck)
resultDistance = VectorExtends::Distance(playerOrigin, targetOrigin);
return resultDistance <= distance;
}
return true;
}
void TeleportTo(CCSPlayerController* target)
{
if (!CheckValid(true) || !target || !target->CheckValid(true)) return;
auto pawn = GetPlayerPawn();
auto tpawn = target->GetPlayerPawn();
if (!pawn || !tpawn) return;
Vector origin = tpawn->GetAbsOrigin();
QAngle rot = tpawn->GetAbsRotation();
Vector vel = tpawn->GetAbsVelocity();
pawn->Teleport(&origin, &rot, &vel);
}
void TeleportPlayer(CCSPlayerController* target)
{
CCSPlayerPawn* myPawn = GetPlayerPawn();
CCSPlayerPawn* targetPawn = target ? target->GetPlayerPawn() : nullptr;
if (!myPawn || !targetPawn)
return;
const Vector& origin = targetPawn->GetAbsOrigin();
const QAngle& rotation = targetPawn->GetAbsRotation();
const Vector& velocity = targetPawn->GetAbsVelocity();
myPawn->Teleport(&origin, &rotation, &velocity);
}
void SetPlayerRenderColor(int a = 255, int r = 255, int g = 255, int b = 255)
{
CCSPlayerPawn* pawn = GetPlayerPawn();
if (!pawn) return;
pawn->m_clrRender() = Color(r, g, b, a);
}
void SetPlayerInvisible(int alpha = 0)
{
if (alpha < 0) alpha = 0;
if (alpha > 255) alpha = 255;
CCSPlayerPawn* pawn = GetPlayerPawn();
if (!pawn)
return;
SetPlayerRenderColor(alpha);
if (auto weaponServices = pawn->m_pWeaponServices())
{
CHandle<CBasePlayerWeapon> activeWeapon = weaponServices->m_hActiveWeapon();
if (activeWeapon && activeWeapon.IsValid())
{
auto* weapon = activeWeapon.Get();
weapon->m_clrRender() = colors(255, 255, 255, alpha).ToValveColor();
weapon->m_flShadowStrength() = 0.0f;
}
if (auto myWeapons = weaponServices->m_hMyWeapons())
{
FOR_EACH_VEC(*myWeapons, i)
{
const CHandle<CBasePlayerWeapon>& handle = (*myWeapons)[i];
if (!handle.IsValid() || !handle.Get())
continue;
auto* weapon = handle.Get();
weapon->m_clrRender() = colors(255, 255, 255, 0).ToValveColor();
weapon->m_flShadowStrength() = 0.0f;
}
}
}
}
void SetPlayerVisible()
{
CCSPlayerPawn* pawn = GetPlayerPawn();
if (!pawn)
return;
SetPlayerRenderColor();
if (auto weaponServices = pawn->m_pWeaponServices())
{
CHandle<CBasePlayerWeapon> activeWeapon = weaponServices->m_hActiveWeapon();
if (activeWeapon && activeWeapon.IsValid())
{
auto* weapon = activeWeapon.Get();
weapon->m_clrRender() = colors(255, 255, 255, 255).ToValveColor();
weapon->m_flShadowStrength() = 1.0f;
}
if (auto myWeapons = weaponServices->m_hMyWeapons())
{
FOR_EACH_VEC(*myWeapons, i)
{
const CHandle<CBasePlayerWeapon>& handle = (*myWeapons)[i];
if (!handle.IsValid() || !handle.Get())
continue;
auto* weapon = handle.Get();
weapon->m_clrRender() = colors(255, 255, 255, 255).ToValveColor();
weapon->m_flShadowStrength() = 1.0f;
}
}
}
}
};
}

141
src/schema/CCSPlayerPawn.h
View file

@ -1,141 +0,0 @@
//
// Created by Michal Přikryl on 26.06.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "ehandle.h"
#include "CBasePlayerPawn.h"
#include "services.h"
#include "CCSWeaponBase.h"
namespace TemplatePlugin {
enum CSPlayerState
{
STATE_ACTIVE = 0x0,
STATE_WELCOME = 0x1,
STATE_PICKINGTEAM = 0x2,
STATE_PICKINGCLASS = 0x3,
STATE_DEATH_ANIM = 0x4,
STATE_DEATH_WAIT_FOR_KEY = 0x5,
STATE_OBSERVER_MODE = 0x6,
STATE_GUNGAME_RESPAWN = 0x7,
STATE_DORMANT = 0x8,
NUM_PLAYER_STATES = 0x9,
};
class CCSPlayerController;
struct EntitySpottedState_t
{
private:
[[maybe_unused]] std::uint8_t __pad0000[ 0x8 ]; // 0x0
public:
// MNetworkEnable
// MNetworkChangeCallback "OnIsSpottedChanged"
bool m_bSpotted; // 0x8
private:
[[maybe_unused]] std::uint8_t __pad0009[ 0x3 ]; // 0x9
public:
// MNetworkEnable
// MNetworkChangeCallback "OnIsSpottedChanged"
std::uint32_t m_bSpottedByMask[2]; // 0xc
};
class CTouchExpansionComponent : public CEntityComponent
{
DECLARE_SCHEMA_CLASS(CTouchExpansionComponent)
};
class CCSPlayerPawnBase : public CBasePlayerPawn {
public:
DECLARE_SCHEMA_CLASS(CCSPlayerPawnBase);
SCHEMA_FIELD(CTouchExpansionComponent, m_CTouchExpansionComponent)
SCHEMA_FIELD(GameTime_t, m_blindUntilTime)
SCHEMA_FIELD(GameTime_t, m_blindStartTime)
SCHEMA_FIELD(CSPlayerState, m_iPlayerState)
SCHEMA_FIELD(bool, m_bRespawning)
SCHEMA_FIELD(GameTime_t, m_fImmuneToGunGameDamageTime)
SCHEMA_FIELD(bool, m_bGunGameImmunity)
SCHEMA_FIELD(float, m_fMolotovDamageTime)
SCHEMA_FIELD(bool, m_bHasMovedSinceSpawn)
SCHEMA_FIELD(int32, m_iNumSpawns)
SCHEMA_FIELD(float, m_flIdleTimeSinceLastAction)
SCHEMA_FIELD(float, m_fNextRadarUpdateTime)
SCHEMA_FIELD(float, m_flFlashDuration)
SCHEMA_FIELD(float, m_flFlashMaxAlpha)
SCHEMA_FIELD(float, m_flProgressBarStartTime)
SCHEMA_FIELD(int32, m_iProgressBarDuration)
SCHEMA_FIELD(bool, m_wasNotKilledNaturally)
SCHEMA_FIELD(bool, m_bCommittingSuicideOnTeamChange)
SCHEMA_FIELD(CHandle<CCSPlayerController>, m_hOriginalController)
};
enum CSPlayerBlockingUseAction_t : uint
{
k_CSPlayerBlockingUseAction_None = 0x0,
k_CSPlayerBlockingUseAction_DefusingDefault = 0x1,
k_CSPlayerBlockingUseAction_DefusingWithKit = 0x2,
k_CSPlayerBlockingUseAction_HostageGrabbing = 0x3,
k_CSPlayerBlockingUseAction_HostageDropping = 0x4,
k_CSPlayerBlockingUseAction_MapLongUseEntity_Pickup = 0x5,
k_CSPlayerBlockingUseAction_MapLongUseEntity_Place = 0x6,
k_CSPlayerBlockingUseAction_MaxCount = 0x7,
};
class CCSPlayerPawn : public CCSPlayerPawnBase
{
public:
DECLARE_SCHEMA_CLASS(CCSPlayerPawn);
SCHEMA_FIELD(CEconItemView, m_EconGloves)
SCHEMA_FIELD(uint8, m_nEconGlovesChanged)
SCHEMA_FIELD(uint16, m_nCharacterDefIndex)
SCHEMA_FIELD(CUtlString, m_strVOPrefix)
SCHEMA_FIELD(float, m_flVelocityModifier)
SCHEMA_FIELD(CCSPlayer_ActionTrackingServices*, m_pActionTrackingServices)
SCHEMA_FIELD(QAngle, m_angEyeAngles)
SCHEMA_FIELD(GameTime_t, m_flHealthShotBoostExpirationTime)
SCHEMA_FIELD(int32, m_ArmorValue)
SCHEMA_FIELD(bool, m_bInBuyZone)
SCHEMA_FIELD(bool, m_bInBombZone);
SCHEMA_FIELD(EntitySpottedState_t, m_entitySpottedState)
SCHEMA_FIELD(bool, m_bIsScoped)
SCHEMA_FIELD(int, m_aimPunchTickBase)
SCHEMA_FIELD(float, m_aimPunchTickFraction)
SCHEMA_FIELD(QAngle, m_aimPunchAngle)
SCHEMA_FIELD(QAngle, m_aimPunchAngleVel)
SCHEMA_FIELD(CSPlayerBlockingUseAction_t, m_iBlockingUseActionInProgress);
uint8 GetCollisionGroup()
{
return m_Collision().m_collisionAttribute().m_nCollisionGroup();
}
void SetCollisionGroup(uint8 nCollisionGroup = COLLISION_GROUP_DEBRIS)
{
m_Collision().m_CollisionGroup() = nCollisionGroup;
m_Collision().m_collisionAttribute().m_nCollisionGroup() = nCollisionGroup;
CollisionRulesChanged();
}
QAngle GetEyeAngles() {
return m_angEyeAngles.Get();
}
};
class CCSGO_TeamPreviewCharacterPosition: public CBaseEntity
{
public:
DECLARE_SCHEMA_CLASS(CCSGO_TeamPreviewCharacterPosition);
SCHEMA_FIELD(int32, m_nVariant);
SCHEMA_FIELD(int32, m_nRandom);
SCHEMA_FIELD(int32, m_nOrdinal);
SCHEMA_FIELD(CUtlString, m_sWeaponName);
SCHEMA_FIELD(uint64, m_xuid);
SCHEMA_FIELD_POINTER(CEconItemView, m_agentItem);
SCHEMA_FIELD_POINTER(CEconItemView, m_glovesItem);
SCHEMA_FIELD_POINTER(CEconItemView, m_weaponItem);
};
}

232
src/schema/CCSWeaponBase.h
View file

@ -1,232 +0,0 @@
//
// Created by Michal Přikryl on 26.06.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "CBaseEntity.h"
#include "virtual.h"
namespace TemplatePlugin {
enum gear_slot_t : uint32_t
{
GEAR_SLOT_INVALID = 0xffffffff,
GEAR_SLOT_RIFLE = 0x0,
GEAR_SLOT_PISTOL = 0x1,
GEAR_SLOT_KNIFE = 0x2,
GEAR_SLOT_GRENADES = 0x3,
GEAR_SLOT_C4 = 0x4,
GEAR_SLOT_RESERVED_SLOT6 = 0x5,
GEAR_SLOT_RESERVED_SLOT7 = 0x6,
GEAR_SLOT_RESERVED_SLOT8 = 0x7,
GEAR_SLOT_RESERVED_SLOT9 = 0x8,
GEAR_SLOT_RESERVED_SLOT10 = 0x9,
GEAR_SLOT_RESERVED_SLOT11 = 0xa,
GEAR_SLOT_BOOSTS = 0xb,
GEAR_SLOT_UTILITY = 0xc,
GEAR_SLOT_COUNT = 0xd,
GEAR_SLOT_FIRST = 0x0,
GEAR_SLOT_LAST = 0xc,
};
enum CSWeaponType : uint32_t
{
WEAPONTYPE_KNIFE = 0,
WEAPONTYPE_PISTOL = 1,
WEAPONTYPE_SUBMACHINEGUN = 2,
WEAPONTYPE_RIFLE = 3,
WEAPONTYPE_SHOTGUN = 4,
WEAPONTYPE_SNIPER_RIFLE = 5,
WEAPONTYPE_MACHINEGUN = 6,
WEAPONTYPE_C4 = 7,
WEAPONTYPE_TASER = 8,
WEAPONTYPE_GRENADE = 9,
WEAPONTYPE_EQUIPMENT = 10,
WEAPONTYPE_STACKABLEITEM = 11,
WEAPONTYPE_UNKNOWN = 12,
};
enum CSWeaponCategory : uint32_t
{
WEAPONCATEGORY_OTHER = 0,
WEAPONCATEGORY_MELEE = 1,
WEAPONCATEGORY_SECONDARY = 2,
WEAPONCATEGORY_SMG = 3,
WEAPONCATEGORY_RIFLE = 4,
WEAPONCATEGORY_HEAVY = 5,
WEAPONCATEGORY_COUNT = 6,
};
class CAttributeManager
{
public:
DECLARE_SCHEMA_CLASS_INLINE(CAttributeManager);
SCHEMA_FIELD_POINTER(CUtlVector<CAttributeManager>, m_CachedResults);
};
class CEconItemAttribute
{
public:
DECLARE_SCHEMA_CLASS_INLINE(CEconItemAttribute);
SCHEMA_FIELD(uint16_t, m_iAttributeDefinitionIndex);
SCHEMA_FIELD(float32, m_flValue);
SCHEMA_FIELD(float32, m_flInitialValue);
SCHEMA_FIELD(int32, m_nRefundableCurrency);
SCHEMA_FIELD(bool, m_bSetBonus);
};
class CAttributeList
{
public:
DECLARE_SCHEMA_CLASS_INLINE(CAttributeList);
SCHEMA_FIELD_POINTER(CUtlVector<CEconItemAttribute>, m_Attributes)
SCHEMA_FIELD(CAttributeManager*, m_pManager);
};
class CEconItemView
{
public:
DECLARE_SCHEMA_CLASS_INLINE(CEconItemView);
SCHEMA_FIELD(uint16, m_iItemDefinitionIndex)
SCHEMA_FIELD(int32, m_iEntityQuality)
SCHEMA_FIELD(uint32, m_iEntityLevel)
SCHEMA_FIELD(uint64_t, m_iItemID)
SCHEMA_FIELD(uint32, m_iItemIDHigh)
SCHEMA_FIELD(uint32, m_iItemIDLow)
SCHEMA_FIELD(uint32, m_iAccountID)
SCHEMA_FIELD(uint32, m_iInventoryPosition)
SCHEMA_FIELD(bool, m_bInitialized)
SCHEMA_FIELD(CAttributeList, m_AttributeList)
SCHEMA_FIELD(CAttributeList, m_NetworkedDynamicAttributes)
SCHEMA_FIELD_POINTER(char, m_szCustomName)
SCHEMA_FIELD_POINTER(char, m_szCustomNameOverride)
};
class CAttributeContainer
{
public:
DECLARE_SCHEMA_CLASS_INLINE(CAttributeContainer);
SCHEMA_FIELD(CEconItemView, m_Item)
};
class CEconEntity : public CBaseModelEntity
{
public:
DECLARE_SCHEMA_CLASS(CEconEntity)
SCHEMA_FIELD(CAttributeContainer, m_AttributeManager)
SCHEMA_FIELD(uint32, m_OriginalOwnerXuidLow)
SCHEMA_FIELD(uint32, m_OriginalOwnerXuidHigh)
SCHEMA_FIELD(int32, m_nFallbackPaintKit)
SCHEMA_FIELD(int32, m_nFallbackSeed)
SCHEMA_FIELD(float, m_flFallbackWear)
SCHEMA_FIELD(int32, m_nFallbackStatTrak)
};
class CEconWearable : public CEconEntity
{
public:
DECLARE_SCHEMA_CLASS(CEconWearable)
SCHEMA_FIELD(int32, m_nForceSkin)
SCHEMA_FIELD(bool, m_bAlwaysAllow)
};
class CBasePlayerWeaponVData : public CEntitySubclassVDataBase
{
public:
DECLARE_SCHEMA_CLASS(CBasePlayerWeaponVData)
SCHEMA_FIELD(int, m_iMaxClip1)
SCHEMA_FIELD(int, m_iMaxClip2)
SCHEMA_FIELD(int, m_iDefaultClip1)
};
class CCSWeaponBaseVData : public CBasePlayerWeaponVData
{
public:
DECLARE_SCHEMA_CLASS(CCSWeaponBaseVData)
SCHEMA_FIELD(CSWeaponType, m_WeaponType);
SCHEMA_FIELD(CSWeaponCategory, m_WeaponCategory);
SCHEMA_FIELD(gear_slot_t, m_GearSlot)
SCHEMA_FIELD(int, m_nPrice)
SCHEMA_FIELD(CUtlString, m_szName)
SCHEMA_FIELD(int, m_nPrimaryReserveAmmoMax)
SCHEMA_FIELD(int, m_nSecondaryReserveAmmoMax)
SCHEMA_FIELD(int, m_nDamage)
};
class CBasePlayerWeapon : public CEconEntity
{
public:
DECLARE_SCHEMA_CLASS(CBasePlayerWeapon)
SCHEMA_FIELD(int, m_nNextPrimaryAttackTick);
SCHEMA_FIELD(float, m_flNextPrimaryAttackTickRatio);
SCHEMA_FIELD(int, m_nNextSecondaryAttackTick);
SCHEMA_FIELD(float, m_flNextSecondaryAttackTickRatio);
SCHEMA_FIELD(int32_t, m_iClip1);
SCHEMA_FIELD(int32_t, m_iClip2);
SCHEMA_FIELD_POINTER(int, m_pReserveAmmo);
CCSWeaponBaseVData* GetWeaponVData() { return (CCSWeaponBaseVData*)GetVData(); }
const char* GetWeaponClassname() noexcept
{
const char* pszClassname = GetClassname();
if (V_StringHasPrefixCaseSensitive(pszClassname, "item_"))
return pszClassname;
switch (m_AttributeManager().m_Item().m_iItemDefinitionIndex)
{
case 23:
return "weapon_mp5sd";
case 41:
return "weapon_knifegg";
case 42:
return "weapon_knife";
case 59:
return "weapon_knife_t";
case 60:
return "weapon_m4a1_silencer";
case 61:
return "weapon_usp_silencer";
case 63:
return "weapon_cz75a";
case 64:
return "weapon_revolver";
default:
return pszClassname;
}
}
};
class CCSWeaponBase : public CBasePlayerWeapon
{
public:
DECLARE_SCHEMA_CLASS(CCSWeaponBase)
SCHEMA_FIELD(bool, m_bInReload);
SCHEMA_FIELD(bool, m_bReloadVisuallyComplete);
SCHEMA_FIELD(bool, m_bRequireUseToTouch);
SCHEMA_FIELD(float, m_flDroppedAtTime);
SCHEMA_FIELD(float, m_fAccuracyPenalty);
SCHEMA_FIELD(float, m_flRecoilIndex);
SCHEMA_FIELD(int, m_iRecoilIndex);
};
class CWeaponBaseItem : public CCSWeaponBase
{
public:
DECLARE_SCHEMA_CLASS(CWeaponBaseItem)
};
class CCSWeaponBaseGun : public CCSWeaponBase
{
public:
DECLARE_SCHEMA_CLASS(CCSWeaponBaseGun)
};
}

26
src/schema/CChicken.h
View file

@ -1,26 +0,0 @@
//
// Created by Michal Přikryl on 26.06.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "CBaseEntity.h"
namespace TemplatePlugin {
enum class ChickenActivity : uint32_t {
IDLE = 0x0,
SQUAT = 0x1,
WALK = 0x2,
RUN = 0x3,
GLIDE = 0x4,
LAND = 0x5,
PANIC = 0x6
};
class CChicken : public CBaseEntity
{
public:
DECLARE_SCHEMA_CLASS(CChicken)
SCHEMA_FIELD(ChickenActivity, m_currentActivity)
};
}

50
src/schema/CDynamicProp.h
View file

@ -1,50 +0,0 @@
//
// Created by Michal Přikryl on 01.11.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "CBaseEntity.h"
#include "globaltypes.h"
#include "CBreakableProp.h"
namespace
TemplatePlugin
{
enum AnimLoopMode_t : uint
{
ANIM_LOOP_MODE_INVALID = 0xFFFFFFFF,
ANIM_LOOP_MODE_NOT_LOOPING = 0x0,
ANIM_LOOP_MODE_LOOPING = 0x1,
ANIM_LOOP_MODE_USE_SEQUENCE_SETTINGS = 0x2,
ANIM_LOOP_MODE_COUNT = 0x3,
};
class CDynamicProp : public CBreakableProp
{
public:
DECLARE_SCHEMA_CLASS(CDynamicProp);
SCHEMA_FIELD(bool, m_bCreateNavObstacle)
SCHEMA_FIELD(bool, m_bNavObstacleUpdatesOverridden)
SCHEMA_FIELD(bool, m_bUseHitboxesForRenderBox)
SCHEMA_FIELD(bool, m_bUseAnimGraph)
SCHEMA_FIELD(CEntityIOOutput, m_pOutputAnimBegun)
SCHEMA_FIELD(CEntityIOOutput, m_pOutputAnimOver)
SCHEMA_FIELD(CEntityIOOutput, m_pOutputAnimLoopCycleOver)
SCHEMA_FIELD(CEntityIOOutput, m_OnAnimReachedStart)
SCHEMA_FIELD(CEntityIOOutput, m_OnAnimReachedEnd)
SCHEMA_FIELD_POINTER(char, m_iszIdleAnim)
SCHEMA_FIELD(AnimLoopMode_t, m_nIdleAnimLoopMode)
SCHEMA_FIELD(bool, m_bRandomizeCycle)
SCHEMA_FIELD(bool, m_bStartDisabled)
SCHEMA_FIELD(bool, m_bFiredStartEndOutput)
SCHEMA_FIELD(bool, m_bForceNpcExclude)
SCHEMA_FIELD(bool, m_bCreateNonSolid)
SCHEMA_FIELD(bool, m_bIsOverrideProp)
SCHEMA_FIELD(int32, m_iInitialGlowState)
SCHEMA_FIELD(int32, m_nGlowRange)
SCHEMA_FIELD(int32, m_nGlowRangeMin)
SCHEMA_FIELD(Color, m_glowColor)
SCHEMA_FIELD(int32, m_nGlowTeam)
};
}

20
src/schema/CEnvEntityMarker.h
View file

@ -1,20 +0,0 @@
//
// Created by Michal Přikryl on 26.06.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "CBaseEntity.h"
#include"schemasystem.h"
#define SF_TRIG_PUSH_ONCE 0x80
namespace TemplatePlugin {
class CEnvEntityMaker : public CBaseEntity
{
public:
DECLARE_SCHEMA_CLASS(CEnvEntityMaker);
SCHEMA_FIELD(CUtlSymbolLarge, m_iszTemplate)
};
}

29
src/schema/CFuncBrush.h
View file

@ -1,29 +0,0 @@
//
// Created by Michal Přikryl on 07.11.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
#pragma once
#include "CBaseModelEntity.h"
#include "globaltypes.h"
namespace
TemplatePlugin
{
enum BrushSolidities_e : uint
{
BRUSHSOLID_TOGGLE,
BRUSHSOLID_NEVER,
BRUSHSOLID_ALWAYS,
};
class CFuncBrush : public CBaseModelEntity
{
public:
DECLARE_SCHEMA_CLASS(CFuncBrush);
SCHEMA_FIELD(BrushSolidities_e, m_iSolidity)
SCHEMA_FIELD(int, m_iDisabled)
SCHEMA_FIELD(bool, m_bSolidBsp)
SCHEMA_FIELD_POINTER(char, m_iszExcludedClass)
SCHEMA_FIELD(bool, m_bInvertExclusion)
SCHEMA_FIELD(bool, m_bScriptedMovement)
};
}

17
src/schema/CFuncVPhysicsClip.h
View file

@ -1,17 +0,0 @@
//
// Created by Michal Přikryl on 07.11.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
#pragma once
#include "CBaseModelEntity.h"
#include "globaltypes.h"
namespace
TemplatePlugin
{
class CFuncVPhysicsClip : public CBaseModelEntity
{
public:
DECLARE_SCHEMA_CLASS(CFuncVPhysicsClip);
SCHEMA_FIELD(int, m_bDisabled)
};
}

125
src/schema/CGameRules.h
View file

@ -1,125 +0,0 @@
//
// Created by Michal Přikryl on 26.06.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include <platform.h>
#include "CBaseEntity.h"
namespace TemplatePlugin {
enum class RoundEndReason : uint32_t
{
Unknown = 0x0u,
TargetBombed = 0x1u,
TerroristsEscaped = 0x4u,
CTsPreventEscape = 0x5u,
EscapingTerroristsNeutralized = 0x6u,
BombDefused = 0x7u,
CTsWin = 0x8u,
TerroristsWin = 0x9u,
RoundDraw = 0xAu,
AllHostageRescued = 0xBu,
TargetSaved = 0xCu,
HostagesNotRescued = 0xDu,
TerroristsNotEscaped = 0xEu,
GameCommencing = 0x10u,
TerroristsSurrender = 0x11u,
CTsSurrender = 0x12u,
TerroristsPlanted = 0x13u,
CTsReachedHostage = 0x14u,
SurvivalWin = 0x15u,
SurvivalDraw = 0x16u,
TerroristsPlanned = 0x13u
};
class CGameRules
{
public:
DECLARE_SCHEMA_CLASS(CGameRules)
};
class CCSGameModeRules_Deathmatch : public CGameRules
{
public:
DECLARE_SCHEMA_CLASS(CCSGameModeRules_Deathmatch)
SCHEMA_FIELD(GameTime_t, m_flDMBonusStartTime);
SCHEMA_FIELD(float32, m_flDMBonusTimeLength);
SCHEMA_FIELD(CUtlString, m_sDMBonusWeapon);
};
class CCSGameRules;
class CCSGameRulesProxy : public CBaseEntity
{
public:
DECLARE_SCHEMA_CLASS(CCSGameRulesProxy)
SCHEMA_FIELD(CCSGameRules *, m_pGameRules);
};
class CCSGameRules : public CGameRules
{
public:
DECLARE_SCHEMA_CLASS(CCSGameRules)
SCHEMA_FIELD(float, m_fMatchStartTime);
SCHEMA_FIELD(float, m_flGameStartTime);
SCHEMA_FIELD(int, m_totalRoundsPlayed);
SCHEMA_FIELD(float, m_fRoundStartTime);
SCHEMA_FIELD(float, m_flRestartRoundTime);
SCHEMA_FIELD_POINTER(int, m_nEndMatchMapGroupVoteOptions)
SCHEMA_FIELD(int, m_nEndMatchMapVoteWinner);
SCHEMA_FIELD(int, m_iRoundTime);
SCHEMA_FIELD(bool, m_bWarmupPeriod);
SCHEMA_FIELD(float, m_fWarmupPeriodEnd);
SCHEMA_FIELD(float, m_fWarmupPeriodStart);
SCHEMA_FIELD(GamePhase, m_gamePhase);
SCHEMA_FIELD(bool, m_bGameRestart);
SCHEMA_FIELD(bool, m_bBombPlanted);
SCHEMA_FIELD(int32_t, m_totaArenaoundsPlayed);
SCHEMA_FIELD(int32_t, m_nOvertimePlaying);
SCHEMA_FIELD(bool, m_bBuyTimeEnded);
SCHEMA_FIELD(bool, m_bTCantBuy);
SCHEMA_FIELD(bool, m_bCTCantBuy);
SCHEMA_FIELD(bool, m_bSwitchingTeamsAtRoundReset);
SCHEMA_FIELD(int, m_iRoundEndWinnerTeam);
SCHEMA_FIELD(CUtlString, m_sRoundEndMessage);
SCHEMA_FIELD(CUtlString, m_sRoundEndFunFactToken);
SCHEMA_FIELD(bool, m_bIsValveDS);
SCHEMA_FIELD(bool, m_bIsQuestEligible);
SCHEMA_FIELD(int32, m_iSpectatorSlotCount);
SCHEMA_FIELD(float, m_fWarmupNextChatNoticeTime);
SCHEMA_FIELD_POINTER(CUtlVector<SpawnPoint*>, m_CTSpawnPoints);
SCHEMA_FIELD_POINTER(CUtlVector<SpawnPoint*>, m_TerroristSpawnPoints);
using TerminateRoundFn = void(*)(CCSGameRules*, RoundEndReason, float, void*, uint8_t);
TerminateRoundFn s_pTerminateRound = nullptr;
void TerminateRound(float delay, RoundEndReason roundEndReason) {
if (!s_pTerminateRound) {
TerminateRoundFn addr = DynLibUtils::CModule(shared::g_pServer).FindPattern(
shared::g_pGameConfig->GetSignature("CCSGameRules_TerminateRound")).RCast<TerminateRoundFn>();
if (!addr)
return;
s_pTerminateRound = addr;
}
s_pTerminateRound(this, roundEndReason, delay, nullptr, 0);
}
static CCSGameRules* FindGameRules()
{
auto entities = UTIL_FindAllEntitiesByDesignerName<CCSGameRulesProxy>("cs_gamerules");
if (entities.empty())
return nullptr;
auto* proxy = entities.front();
return proxy ? proxy->m_pGameRules() : nullptr;
}
};
}

38
src/schema/CParticleSystem.h
View file

@ -1,38 +0,0 @@
//
// Created by Michal Přikryl on 26.06.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "CBaseModelEntity.h"
namespace TemplatePlugin {
class CParticleSystem : public CBaseModelEntity
{
public:
DECLARE_SCHEMA_CLASS(CParticleSystem);
SCHEMA_FIELD(bool, m_bActive)
SCHEMA_FIELD(bool, m_bStartActive)
SCHEMA_FIELD(bool, m_bFrozen)
SCHEMA_FIELD(float32, m_flFreezeTransitionDuration)
SCHEMA_FIELD(int32, m_nStopType)
SCHEMA_FIELD(bool, m_bAnimateDuringGameplayPause)
SCHEMA_FIELD(CUtlSymbolLarge, m_iszEffectName)
SCHEMA_FIELD(int, m_nTintCP)
SCHEMA_FIELD(GameTime_t, m_flStartTime)
SCHEMA_FIELD_POINTER(Color, m_clrTint)
SCHEMA_FIELD_POINTER(CHandle<CBaseEntity>, m_hControlPointEnts)
};
class CEnvParticleGlow : public CParticleSystem
{
public:
DECLARE_SCHEMA_CLASS(CEnvParticleGlow);
SCHEMA_FIELD(float, m_flAlphaScale)
SCHEMA_FIELD(float, m_flRadiusScale)
SCHEMA_FIELD(float, m_flSelfIllumScale)
SCHEMA_FIELD_POINTER(Color, m_ColorTint)
};
}

27
src/schema/CPhysExplosion.h
View file

@ -1,27 +0,0 @@
//
// Created by Michal Přikryl on 09.11.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "CBaseEntity.h"
#include "globaltypes.h"
namespace TemplatePlugin
{
class CPhysExplosion : public CBaseEntity
{
public:
DECLARE_SCHEMA_CLASS(CPhysExplosion);
SCHEMA_FIELD(bool, m_bExplodeOnSpawn)
SCHEMA_FIELD(float, m_flMagnitude)
SCHEMA_FIELD(float, m_flDamage)
SCHEMA_FIELD(float, m_radius)
SCHEMA_FIELD_POINTER(char, m_targetEntityName)
SCHEMA_FIELD(float, m_flInnerRadius)
SCHEMA_FIELD(float, m_flPushScale)
SCHEMA_FIELD(bool, m_bConvertToDebrisWhenPossible)
SCHEMA_FIELD(bool, m_bAffectInvulnerableEnts)
SCHEMA_FIELD(CEntityIOOutput, m_OnPushedPlayer)
};
}

70
src/schema/CPhysicsProp.h
View file

@ -1,70 +0,0 @@
//
// Created by Michal Přikryl on 01.11.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "CBaseEntity.h"
#include "globaltypes.h"
#include "CBreakableProp.h"
namespace
TemplatePlugin
{
enum DynamicContinuousContactBehavior_t : byte
{
DYNAMIC_CONTINUOUS_ALLOW_IF_REQUESTED_BY_OTHER_BODY = 0x0,
DYNAMIC_CONTINUOUS_ALWAYS = 0x1,
DYNAMIC_CONTINUOUS_NEVER = 0x2,
};
enum CPhysicsPropCrateType_t : uint
{
CRATE_SPECIFIC_ITEM = 0x0,
CRATE_TYPE_COUNT = 0x1,
};
class CPhysicsProp : public CBreakableProp
{
public:
DECLARE_SCHEMA_CLASS(CPhysicsProp);
SCHEMA_FIELD(CEntityIOOutput, m_MotionEnabled)
SCHEMA_FIELD(CEntityIOOutput, m_OnAwakened)
SCHEMA_FIELD(CEntityIOOutput, m_OnAwake)
SCHEMA_FIELD(CEntityIOOutput, m_OnAsleep)
SCHEMA_FIELD(CEntityIOOutput, m_OnPlayerUse)
SCHEMA_FIELD(CEntityIOOutput, m_OnOutOfWorld)
SCHEMA_FIELD(CEntityIOOutput, m_OnPlayerPickup)
SCHEMA_FIELD(bool, m_bForceNavIgnore)
SCHEMA_FIELD(bool, m_bNoNavmeshBlocker)
SCHEMA_FIELD(bool, m_bForceNpcExclude)
SCHEMA_FIELD(float, m_massScale)
SCHEMA_FIELD(float, m_buoyancyScale)
SCHEMA_FIELD(int32, m_damageType)
SCHEMA_FIELD(int32, m_damageToEnableMotion)
SCHEMA_FIELD(float, m_flForceToEnableMotion)
SCHEMA_FIELD(bool, m_bThrownByPlayer)
SCHEMA_FIELD(bool, m_bDroppedByPlayer)
SCHEMA_FIELD(bool, m_bTouchedByPlayer)
SCHEMA_FIELD(bool, m_bFirstCollisionAfterLaunch)
SCHEMA_FIELD(bool, m_bHasBeenAwakened)
SCHEMA_FIELD(bool, m_bIsOverrideProp)
SCHEMA_FIELD(float, m_flLastBurn)
SCHEMA_FIELD(DynamicContinuousContactBehavior_t, m_nDynamicContinuousContactBehavior)
SCHEMA_FIELD(float, m_fNextCheckDisableMotionContactsTime)
SCHEMA_FIELD(int32, m_iInitialGlowState)
SCHEMA_FIELD(int32, m_nGlowRange)
SCHEMA_FIELD(int32, m_nGlowRangeMin)
SCHEMA_FIELD(Color, m_glowColor)
SCHEMA_FIELD(bool, m_bShouldAutoConvertBackFromDebris)
SCHEMA_FIELD(bool, m_bMuteImpactEffects)
SCHEMA_FIELD(bool, m_bAcceptDamageFromHeldObjects)
SCHEMA_FIELD(bool, m_bEnableUseOutput)
SCHEMA_FIELD(CPhysicsPropCrateType_t, m_CrateType)
SCHEMA_FIELD_POINTER(char, m_strItemClass)
SCHEMA_FIELD_POINTER(int32, m_nItemCount)
SCHEMA_FIELD(bool, m_bRemovableForAmmoBalancing)
SCHEMA_FIELD(bool, m_bAwake)
SCHEMA_FIELD(bool, m_bAttachedToReferenceFrame)
};
}

18
src/schema/CPlantedC4.h
View file

@ -1,18 +0,0 @@
//
// Created by Michal Přikryl on 26.06.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "CBaseModelEntity.h"
#include "globaltypes.h"
namespace TemplatePlugin {
class CPlantedC4 : public CBaseModelEntity
{
public:
DECLARE_SCHEMA_CLASS(CPlantedC4)
SCHEMA_FIELD(GameTime_t, m_flC4Blow);
SCHEMA_FIELD(GameTime_t, m_flDefuseCountDown);
};
}

74
src/schema/CPointWorldText.h
View file

@ -1,74 +0,0 @@
/**
* =============================================================================
* CS2Fixes
* Copyright (C) 2023-2025 Source2ZE
* =============================================================================
*
* This program is free software; you can redistribute it and/or modify it under
* the terms of the GNU General Public License, version 3.0, as published by the
* Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along with
* this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "CBaseModelEntity.h"
namespace TemplatePlugin {
enum class PointWorldTextJustifyHorizontal_t : uint32_t
{
POINT_WORLD_TEXT_JUSTIFY_HORIZONTAL_LEFT = 0x0,
POINT_WORLD_TEXT_JUSTIFY_HORIZONTAL_CENTER = 0x1,
POINT_WORLD_TEXT_JUSTIFY_HORIZONTAL_RIGHT = 0x2,
};
enum class PointWorldTextJustifyVertical_t : uint32_t
{
POINT_WORLD_TEXT_JUSTIFY_VERTICAL_BOTTOM = 0x0,
POINT_WORLD_TEXT_JUSTIFY_VERTICAL_CENTER = 0x1,
POINT_WORLD_TEXT_JUSTIFY_VERTICAL_TOP = 0x2,
};
enum class PointWorldTextReorientMode_t : uint32_t
{
POINT_WORLD_TEXT_REORIENT_NONE = 0x0,
POINT_WORLD_TEXT_REORIENT_AROUND_UP = 0x1,
};
class CPointWorldText : public CBaseModelEntity
{
public:
DECLARE_SCHEMA_CLASS(CPointWorldText)
SCHEMA_FIELD_POINTER(char, m_messageText) // char m_messageText[512]
SCHEMA_FIELD_POINTER(char, m_FontName) // char m_FontName[64]
SCHEMA_FIELD_POINTER(char, m_BackgroundMaterialName) // char m_BackgroundMaterialName[64]
SCHEMA_FIELD(bool, m_bEnabled)
SCHEMA_FIELD(bool, m_bFullbright)
SCHEMA_FIELD(float, m_flWorldUnitsPerPx)
SCHEMA_FIELD(float, m_flFontSize)
SCHEMA_FIELD(float, m_flDepthOffset)
SCHEMA_FIELD(bool, m_bDrawBackground)
SCHEMA_FIELD(float, m_flBackgroundBorderWidth)
SCHEMA_FIELD(float, m_flBackgroundBorderHeight)
SCHEMA_FIELD(float, m_flBackgroundWorldToUV)
SCHEMA_FIELD(Color, m_Color)
SCHEMA_FIELD(PointWorldTextJustifyHorizontal_t, m_nJustifyHorizontal)
SCHEMA_FIELD(PointWorldTextJustifyVertical_t, m_nJustifyVertical)
SCHEMA_FIELD(PointWorldTextReorientMode_t, m_nReorientMode)
void SetMessage(const char* sMessage)
{
V_strncpy(m_messageText, sMessage, 512);
}
};
}

28
src/schema/CSkyCamera.h
View file

@ -1,28 +0,0 @@
//
// Created by Michal Přikryl on 26.06.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "CBaseEntity.h"
#include "globaltypes.h"
#include "CBaseModelEntity.h"
namespace TemplatePlugin {
class CSkyCamera : public CBaseEntity
{
public:
DECLARE_SCHEMA_CLASS(CSkyCamera)
SCHEMA_FIELD(CUtlStringToken, m_skyboxSlotToken);
};
class CEnvSky : public CBaseModelEntity
{
public:
DECLARE_SCHEMA_CLASS(CEnvSky)
SCHEMA_FIELD(int, m_hSkyMaterial)
SCHEMA_FIELD(int, m_hSkyMaterialLightingOnly)
SCHEMA_FIELD(Color, m_vTintColor)
SCHEMA_FIELD(float32, m_flBrightnessScale)
};
}

40
src/schema/CSoundEventEntity.h
View file

@ -1,40 +0,0 @@
//
// Created by Michal Přikryl on 23.08.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "CBaseEntity.h"
namespace TemplatePlugin {
class CSoundEventEntity : public CBaseEntity {
public:
DECLARE_SCHEMA_CLASS(CSoundEventEntity)
SCHEMA_FIELD(bool, m_bStartOnSpawn);
SCHEMA_FIELD(bool, m_bToLocalPlayer);
SCHEMA_FIELD(bool, m_bStopOnNew);
SCHEMA_FIELD(bool, m_bSaveRestore);
SCHEMA_FIELD(bool, m_bSavedIsPlaying);
SCHEMA_FIELD(float32, m_flSavedElapsedTime);
SCHEMA_FIELD(CUtlSymbolLarge, m_iszSourceEntityName);
SCHEMA_FIELD(CUtlSymbolLarge, m_iszAttachmentName);
SCHEMA_FIELD(char, m_onGUIDChanged);
SCHEMA_FIELD(CEntityIOOutput, m_onSoundFinished);
SCHEMA_FIELD(float32, m_flClientCullRadius);
SCHEMA_FIELD(CUtlSymbolLarge, m_iszSoundName);
SCHEMA_FIELD(CEntityHandle, m_hSource);
SCHEMA_FIELD(int32, m_nEntityIndexSelection);
};
}

16
src/schema/CTeam.h
View file

@ -1,16 +0,0 @@
//
// Created by Michal Přikryl on 26.06.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "CBaseEntity.h"
namespace TemplatePlugin {
class CTeam : public CBaseEntity
{
public:
DECLARE_SCHEMA_CLASS(CTeam)
SCHEMA_FIELD(int32_t, m_iScore);
};
}

2
src/schema/CTimer.cpp
View file

@ -7,7 +7,7 @@
#include <Shared.h>
namespace
TemplatePlugin
RayTracePlugin
{
std::list<std::shared_ptr<CTimerBase>> g_timers;

2
src/schema/CTimer.h
View file

@ -16,7 +16,7 @@
#define TIMERFLAG_MAP (1 << 0) // Only valid for this map, cancels on map change
#define TIMERFLAG_ROUND (1 << 1) // Only valid for this round, cancels on new round
namespace TemplatePlugin {
namespace RayTracePlugin {
class CTimerBase
{
protected:

21
src/schema/CTriggerPush.h
View file

@ -1,21 +0,0 @@
//
// Created by Michal Přikryl on 26.06.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include "CBaseTrigger.h"
#include "schemasystem.h"
#define SF_TRIG_PUSH_ONCE 0x80
namespace TemplatePlugin {
class CTriggerPush : public CBaseTrigger
{
public:
DECLARE_SCHEMA_CLASS(CTriggerPush);
SCHEMA_FIELD(Vector, m_vecPushDirEntitySpace)
SCHEMA_FIELD(bool, m_bTriggerOnStartTouch)
};
}

2
src/schema/ccollisionproperty.h
View file

@ -6,7 +6,7 @@
#include "CBaseEntity.h"
namespace TemplatePlugin {
namespace RayTracePlugin {
struct VPhysicsCollisionAttribute_t
{
DECLARE_SCHEMA_CLASS_INLINE(VPhysicsCollisionAttribute_t)

2
src/schema/cgameresourceserviceserver.h
View file

@ -19,7 +19,7 @@
#pragma once
#include <cstdint>
#include "TemplatePlugin.h"
#include "Plugin.h"
class CGameEntitySystem;

53
src/schema/ctakedamageinfo.cpp
View file

@ -1,53 +0,0 @@
//
// Created by Michal Přikryl on 23.09.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#include "ctakedamageinfo.h"
#include "dynlibutils/module.h"
#include "CCSPlayerController.h"
#include <Shared.h>
namespace
TemplatePlugin
{
CAttackerInfo::CAttackerInfo(CEntityInstance* attacker)
{
NeedInit = false;
IsWorld = true;
IsPawn = false;
Attacker = attacker ? attacker->m_pEntity->GetRefEHandle().ToInt() : 0;
if (!attacker || (attacker->m_pEntity && attacker->m_pEntity->m_designerName.String() !=
"cs_player_controller"))
return;
if (auto* controller = static_cast<CCSPlayerController*>(attacker))
{
IsWorld = false;
IsPawn = true;
AttackerUserId = static_cast<unsigned short>(shared::g_pEngine->GetPlayerUserId(controller->GetPlayerSlot()).Get());
TeamNum = controller->m_iTeamNum();
TeamChecked = controller->m_iTeamNum();
}
}
HitGroup_t CTakeDamageInfo::GetHitGroup() const
{
const int off = shared::g_pGameConfig->GetOffset("CTakeDamageInfo_HitGroup");
if (off <= 0)
return HitGroup_t::HITGROUP_INVALID;
const uintptr_t base = reinterpret_cast<uintptr_t>(this);
const uintptr_t v4 = *reinterpret_cast<const uintptr_t*>(base + off);
if (!v4)
return HitGroup_t::HITGROUP_INVALID;
const uintptr_t v1 = *reinterpret_cast<const uintptr_t*>(v4 + 16);
if (!v1)
return HitGroup_t::HITGROUP_GENERIC;
const int32_t group = *reinterpret_cast<const int32_t*>(v1 + 56);
return static_cast<HitGroup_t>(group);
}
}

84
src/schema/ctakedamageinfo.h
View file

@ -1,84 +0,0 @@
//
// Created by Michal Přikryl on 23.09.2025.
// Copyright (c) 2025 slynxcz. All rights reserved.
//
#pragma once
#include <public/mathlib/vector.h>
#include "ehandle.h"
#include "schemasystem.h"
#include "globaltypes.h"
namespace
TemplatePlugin
{
class CBaseEntity;
class CTakeDamageInfo;
#pragma pack(push, 1)
struct CAttackerInfo
{
bool NeedInit = true; // 0x0
bool IsPawn = false; // 0x1
bool IsWorld = false; // 0x2
std::uint8_t pad_3[1] = {}; // vyrovnání na 4 bajty
std::uint32_t Attacker = 0; // 0x4
std::uint16_t AttackerUserId = 0; // 0x8
std::uint8_t pad_A[2] = {}; // vyrovnání na 0xC
int TeamChecked = -1; // 0x0C
int TeamNum = -1; // 0x10
CAttackerInfo() = default;
explicit CAttackerInfo(CEntityInstance* attacker);
};
#pragma pack(pop)
struct CTakeDamageInfoContainer
{
CTakeDamageInfo* pInfo;
};
class CTakeDamageInfo
{
public:
DECLARE_SCHEMA_CLASS(CTakeDamageInfo)
SCHEMA_FIELD(Vector, m_vecDamageForce);
SCHEMA_FIELD(Vector, m_vecDamagePosition);
SCHEMA_FIELD(Vector, m_vecReportedPosition);
SCHEMA_FIELD(Vector, m_vecDamageDirection);
SCHEMA_FIELD(CHandle<CBaseEntity>, m_hInflictor);
SCHEMA_FIELD(CHandle<CBaseEntity>, m_hAttacker);
SCHEMA_FIELD(CHandle<CBaseEntity>, m_hAbility);
SCHEMA_FIELD(float, m_flDamage);
SCHEMA_FIELD(float, m_flTotalledDamage);
SCHEMA_FIELD(int32_t, m_bitsDamageType);
SCHEMA_FIELD(int32_t, m_iDamageCustom);
SCHEMA_FIELD(int8_t, m_iAmmoType);
SCHEMA_FIELD(float, m_flOriginalDamage);
SCHEMA_FIELD(bool, m_bShouldBleed);
SCHEMA_FIELD(bool, m_bShouldSpark);
SCHEMA_FIELD(TakeDamageFlags_t, m_nDamageFlags);
SCHEMA_FIELD_POINTER(char, m_sDamageSourceName);
SCHEMA_FIELD(HitGroup_t, m_iHitGroupId);
SCHEMA_FIELD(int32_t, m_nNumObjectsPenetrated);
SCHEMA_FIELD(float, m_flFriendlyFireDamageReductionRatio);
SCHEMA_FIELD(bool, m_bInTakeDamageFlow);
HitGroup_t GetHitGroup() const;
};
class CTakeDamageResult
{
public:
DECLARE_SCHEMA_CLASS(CTakeDamageResult)
SCHEMA_FIELD(CTakeDamageInfo*, m_pOriginatingInfo)
SCHEMA_FIELD(int32, m_nHealthLost)
SCHEMA_FIELD(int32, m_nHealthBefore)
SCHEMA_FIELD(int32, m_nDamageDealt)
SCHEMA_FIELD(float32, m_flPreModifiedDamage)
SCHEMA_FIELD(int32, m_nTotalledHealthLost)
SCHEMA_FIELD(int32, m_nTotalledDamageDealt)
SCHEMA_FIELD(bool, m_bWasDamageSuppressed)
};
}

2
src/schema/globaltypes.h
View file

@ -11,7 +11,7 @@
// CBitVec<16384> *m_pTransmitEdict;
// };
namespace TemplatePlugin {
namespace RayTracePlugin {
enum CSRoundEndReason {
TargetBombed = 1, /**< Target Successfully Bombed! */
VIPEscaped, /**< The VIP has escaped! - Doesn't exist on CS:GO */

2
src/schema/schemasystem.cpp
View file

@ -21,7 +21,7 @@
#endif
namespace
TemplatePlugin
RayTracePlugin
{
using SchemaKeyValueMap_t = std::map<uint32_t, SchemaKey>;
using SchemaTableMap_t = std::map<uint32_t, SchemaKeyValueMap_t>;

2
src/schema/schemasystem.h
View file

@ -39,7 +39,7 @@
#undef schema
namespace
TemplatePlugin
RayTracePlugin
{
struct SchemaKey
{

2
src/schema/serversideclient.h
View file

@ -23,7 +23,7 @@
#include <netmessages.pb.h>
namespace
TemplatePlugin
RayTracePlugin
{
class CHLTVServer;
class INetMessage;

14
src/schema/services.h
View file

@ -24,13 +24,15 @@
#include <platform.h>
#include <unordered_map>
#include "schemasystem.h"
#define AMMO_OFFSET_HEGRENADE 13
#define AMMO_OFFSET_FLASHBANG 14
#define AMMO_OFFSET_SMOKEGRENADE 15
#define AMMO_OFFSET_MOLOTOV 16
#define AMMO_OFFSET_DECOY 17
namespace TemplatePlugin {
namespace RayTracePlugin {
class CCSPlayerController;
class CCSPlayerPawn;
extern bool g_bAwsChangingTeam;
@ -214,16 +216,6 @@ namespace TemplatePlugin {
SCHEMA_FIELD(bool, m_bIsPickingUpItemWithUse)
SCHEMA_FIELD(bool, m_bPickedUpWeapon)
void DropWeapon(CBasePlayerWeapon *pWeapon, Vector *pVecTarget = nullptr, Vector *pVelocity = nullptr) {
static int offset = shared::g_pGameConfig->GetOffset("CCSPlayer_WeaponServices_DropWeapon");
CALL_VIRTUAL(void, offset, this, pWeapon, pVecTarget, pVelocity);
}
void SelectItem(CBasePlayerWeapon *pWeapon, int unk1 = 0) {
static int offset = shared::g_pGameConfig->GetOffset("CCSPlayer_WeaponServices_SelectItem");
CALL_VIRTUAL(void, offset, this, pWeapon, unk1);
}
};
class CCSPlayerController_ActionTrackingServices : public CPlayerControllerComponent {

2
src/schema/vfunc.h
View file

@ -6,7 +6,7 @@
#include <cstdint>
namespace TemplatePlugin
namespace RayTracePlugin
{
template <typename T, typename... Args>
inline T CallVFunc(void* base, int index, Args... args)