CBaseEntity.cpp

Go to the documentation of this file.

// Generated by `voltmod framework schemagen`. Do not edit.
 
#include "Schema/Notify.hpp"
 
#include <VoltMod/Engine/Memory/MemoryAccess.hpp>
#include <VoltMod/Schema/Generated/CBaseEntity.hpp>
#include <VoltMod/Schema/Generated/CBodyComponent.hpp>
 
namespace VoltMod::Schema
{
 
// ---- CBaseEntity, 1192 bytes ---------------------------------------
static constexpr int32_t kCBaseEntity_Health = 720;          // int32
static constexpr int32_t kCBaseEntity_MaxHealth = 724;       // int32
static constexpr int32_t kCBaseEntity_GravityScale = 1020;   // float32
static constexpr int32_t kCBaseEntity_TeamNum = 836;         // uint8
static constexpr int32_t kCBaseEntity_LifeState = 728;       // uint8
static constexpr int32_t kCBaseEntity_Flags = 904;           // uint32
static constexpr int32_t kCBaseEntity_AbsVelocity = 908;     // Vector
static constexpr int32_t kCBaseEntity_MoveTypeRaw = 755;     // MoveType_t
static constexpr int32_t kCBaseEntity_ActualMoveType = 757;  // MoveType_t
static constexpr int32_t kCBaseEntity_GroundEntity = 1004;   // CHandle< CBaseEntity >
static constexpr int32_t kCBaseEntity_OwnerEntity = 996;     // CHandle< CBaseEntity >
static constexpr int32_t kCBaseEntity_BodyComponent = 48;    // CBodyComponent*
 
int32_t CBaseEntity::Health() const
{
    if (!_base)
    {
        return {};
    }
 
    return *MemberPtr<int32_t>(_base, kCBaseEntity_Health);
}
 
void CBaseEntity::SetHealth(int32_t value) const
{
    if (!_base)
    {
        return;
    }
 
    *MemberPtr<int32_t>(_base, kCBaseEntity_Health) = value;
    NotifyEntity(_owner, _ownerOffset + kCBaseEntity_Health);
}
 
int32_t CBaseEntity::MaxHealth() const
{
    if (!_base)
    {
        return {};
    }
 
    return *MemberPtr<int32_t>(_base, kCBaseEntity_MaxHealth);
}
 
void CBaseEntity::SetMaxHealth(int32_t value) const
{
    if (!_base)
    {
        return;
    }
 
    *MemberPtr<int32_t>(_base, kCBaseEntity_MaxHealth) = value;
    NotifyEntity(_owner, _ownerOffset + kCBaseEntity_MaxHealth);
}
 
float CBaseEntity::GravityScale() const
{
    if (!_base)
    {
        return {};
    }
 
    return *MemberPtr<float>(_base, kCBaseEntity_GravityScale);
}
 
void CBaseEntity::SetGravityScale(float value) const
{
    if (!_base)
    {
        return;
    }
 
    *MemberPtr<float>(_base, kCBaseEntity_GravityScale) = value;
    NotifyEntity(_owner, _ownerOffset + kCBaseEntity_GravityScale);
}
 
VoltMod::Team CBaseEntity::TeamNum() const
{
    if (!_base)
    {
        return {};
    }
 
    return *MemberPtr<VoltMod::Team>(_base, kCBaseEntity_TeamNum);
}
 
void CBaseEntity::SetTeamNum(VoltMod::Team value) const
{
    if (!_base)
    {
        return;
    }
 
    *MemberPtr<VoltMod::Team>(_base, kCBaseEntity_TeamNum) = value;
    NotifyEntity(_owner, _ownerOffset + kCBaseEntity_TeamNum);
}
 
uint8_t CBaseEntity::LifeState() const
{
    if (!_base)
    {
        return {};
    }
 
    return *MemberPtr<uint8_t>(_base, kCBaseEntity_LifeState);
}
 
void CBaseEntity::SetLifeState(uint8_t value) const
{
    if (!_base)
    {
        return;
    }
 
    *MemberPtr<uint8_t>(_base, kCBaseEntity_LifeState) = value;
    NotifyEntity(_owner, _ownerOffset + kCBaseEntity_LifeState);
}
 
uint32_t CBaseEntity::Flags() const
{
    if (!_base)
    {
        return {};
    }
 
    return *MemberPtr<uint32_t>(_base, kCBaseEntity_Flags);
}
 
void CBaseEntity::SetFlags(uint32_t value) const
{
    if (!_base)
    {
        return;
    }
 
    *MemberPtr<uint32_t>(_base, kCBaseEntity_Flags) = value;
    NotifyEntity(_owner, _ownerOffset + kCBaseEntity_Flags);
}
 
Vector CBaseEntity::AbsVelocity() const
{
    if (!_base)
    {
        return {};
    }
 
    return *MemberPtr<Vector>(_base, kCBaseEntity_AbsVelocity);
}
 
void CBaseEntity::SetAbsVelocity(Vector value) const
{
    if (!_base)
    {
        return;
    }
 
    *MemberPtr<Vector>(_base, kCBaseEntity_AbsVelocity) = value;
}
 
MoveType_t CBaseEntity::MoveTypeRaw() const
{
    if (!_base)
    {
        return {};
    }
 
    return *MemberPtr<MoveType_t>(_base, kCBaseEntity_MoveTypeRaw);
}
 
void CBaseEntity::SetMoveTypeRaw(MoveType_t value) const
{
    if (!_base)
    {
        return;
    }
 
    *MemberPtr<MoveType_t>(_base, kCBaseEntity_MoveTypeRaw) = value;
    NotifyEntity(_owner, _ownerOffset + kCBaseEntity_MoveTypeRaw);
}
 
MoveType_t CBaseEntity::ActualMoveType() const
{
    if (!_base)
    {
        return {};
    }
 
    return *MemberPtr<MoveType_t>(_base, kCBaseEntity_ActualMoveType);
}
 
void CBaseEntity::SetActualMoveType(MoveType_t value) const
{
    if (!_base)
    {
        return;
    }
 
    *MemberPtr<MoveType_t>(_base, kCBaseEntity_ActualMoveType) = value;
}
 
EntityRef CBaseEntity::GroundEntity() const
{
    if (!_base)
    {
        return {};
    }
 
    return *MemberPtr<EntityRef>(_base, kCBaseEntity_GroundEntity);
}
 
void CBaseEntity::SetGroundEntity(EntityRef value) const
{
    if (!_base)
    {
        return;
    }
 
    *MemberPtr<EntityRef>(_base, kCBaseEntity_GroundEntity) = value;
    NotifyEntity(_owner, _ownerOffset + kCBaseEntity_GroundEntity);
}
 
EntityRef CBaseEntity::OwnerEntity() const
{
    if (!_base)
    {
        return {};
    }
 
    return *MemberPtr<EntityRef>(_base, kCBaseEntity_OwnerEntity);
}
 
void CBaseEntity::SetOwnerEntity(EntityRef value) const
{
    if (!_base)
    {
        return;
    }
 
    *MemberPtr<EntityRef>(_base, kCBaseEntity_OwnerEntity) = value;
    NotifyEntity(_owner, _ownerOffset + kCBaseEntity_OwnerEntity);
}
 
CBodyComponent CBaseEntity::BodyComponent() const
{
    if (!_base)
    {
        return {};
    }
 
    return CBodyComponent{*MemberPtr<void*>(_base, kCBaseEntity_BodyComponent)};
}
 
}  // namespace VoltMod::Schema