Entity.cpp

#include "SDK.h"

int	CBaseEntity::GetHealth()
{
	return *(int*)((DWORD)this + offsets.m_iHealth);
}

bool CBaseEntity::IsValid()
{
	if (!this)
		return false;

	if (this->GetHealth() < 1)
		return false;

	if (this->IsDormant())
		return false;

	return true;
}

int CBaseEntity::GetTeam()
{
	return *(int*)((DWORD)this + offsets.m_iTeamNum);
}

int CBaseEntity::GetFlags()
{
	return *(int*)((DWORD)this + offsets.m_fFlags);
}

int CBaseEntity::GetTickBase()
{
	return *(int*)((DWORD)this + offsets.m_nTickBase);
}

int CBaseEntity::GetDistance()
{
	return M::VectorDistance(G::LocalPlayer->GetOrigin(), this->GetOrigin());
}

model_t* CBaseCombatWeapon::GetModel()
{
	return *(model_t**)((DWORD)this + 0x6C);
}

int CBaseEntity::GetShotsFired()
{
	return *(int*)((DWORD)this + offsets.m_iShotsFired);
}

int CBaseEntity::GetMoney()
{
	return *(int*)((DWORD)this + offsets.m_iAccount);
}

int CBaseEntity::GetMoveType()
{
	return *(int*)((DWORD)this + offsets.m_nMoveType);
}

int CBaseEntity::GetModelIndex()
{
	return *(int*)((DWORD)this + offsets.m_nModelIndex);
}

int CBaseEntity::GetHitboxSet()
{
	return *(int*)((DWORD)this + offsets.m_nHitboxSet);
}

int CBaseEntity::GetUserID()
{
	return this->GetPlayerInfo().userid;
}

int CBaseEntity::GetArmor()
{
	return *(int*)((DWORD)this + offsets.m_ArmorValue);
}

int CBaseEntity::PhysicsSolidMaskForEntity()
{
	typedef unsigned int(__thiscall* OriginalFn)(PVOID);
	return U::GetVFunc<OriginalFn>(this, 154)(this);
}

bool CBaseEntity::HasDefuser()
{
	return *(bool*)((DWORD)this + offsets.m_bHasDefuser);
}

int CBaseEntity::GetOwner()
{
	return *(int*)((DWORD)this + offsets.m_hOwnerEntity);
}

float& CBaseEntity::GetSimulationTime()
{
	return *(float*)((DWORD)this + offsets.m_flSimulationTime);
}

float& CBaseEntity::GetOldSimulationTime()
{
	return *(float*)((DWORD)this + offsets.m_flSimulationTime + 0x4);
}

float& CBaseEntity::GetCycle()
{
	return *(float*)((DWORD)this + offsets.m_flCycle);
}
int& CBaseEntity::GetSequence()
{
	return *(int*)((DWORD)this + offsets.m_nSequence);
}

CBaseEntity* CBaseEntity::GetObserverTarget()
{
	return I::ClientEntList->GetClientEntityFromHandle(ReadPtr<DWORD>(this, offsets.m_hObserverTarget));
}

ObserverMode_t* CBaseEntity::GetObserverMode()
{
	return (ObserverMode_t*)((DWORD)this + offsets.m_iObserverMode);
}

int CBaseEntity::GetGlowIndex()
{
	return *(int*)((DWORD)this + offsets.m_iGlowIndex);
}

int CBaseEntity::GetAmmo(CBaseCombatWeapon* wep)
{
	return *(int*)((DWORD)wep + offsets.m_iClip1);
}

bool CBaseEntity::IsDefusing()
{
	return *(bool*)((DWORD)this + offsets.m_bIsDefusing);
}

bool CBaseEntity::IsBombPlanted()
{
	return *(bool*)((DWORD)this + offsets.m_bBombTicking);
}

float CBaseEntity::GetBombTimer()
{
	float bombTime = *(float*)((DWORD)this + offsets.m_flC4Blow);
	float returnValue = bombTime - I::Globals->curtime;
	return (returnValue < 0) ? 0.f : returnValue;
}

bool CBaseEntity::IsBombDefused()
{
	return *(bool*)((DWORD)this + offsets.m_bBombDefused);
}

int CBaseEntity::GetBombDefuser()
{
	return *(int*)((DWORD)this + offsets.m_hBombDefuser);
}

float CBaseEntity::GetFlashDuration()
{
	return *(float*)((DWORD)this + offsets.m_flFlashDuration);
}

float* CBaseEntity::GetFlashMaxAlpha()
{
	return (float*)((DWORD)this + offsets.m_flFlashMaxAlpha);
}

bool CBaseEntity::IsFlashed()
{
	return GetFlashDuration() > 0 ? true : false;
}

bool CBaseEntity::IsAlive()
{
	return (bool)(*(int*)((DWORD)this + offsets.m_lifeState) == 0);
}

bool CBaseEntity::IsDormant()
{
	return *(bool*)((DWORD)this + offsets.m_bDormant);
}

int CBaseEntity::GetIndex()
{
	return *(int*)((DWORD)this + 0x64);
}

bool CBaseEntity::HasImmunity()
{
	return *(bool*)((DWORD)this + offsets.m_bGunGameImmunity);
}

bool CBaseEntity::HasHelmet()
{
	return *(bool*)((DWORD)this + offsets.m_bHasHelmet);
}

bool CBaseEntity::IsScoped()
{
	return *(bool*)((DWORD)this + offsets.m_bIsScoped);
}

bool* CBaseEntity::IsSpotted()
{
	return (bool*)((DWORD)this + offsets.m_bIsSpotted);
}

bool CBaseEntity::IsTargetingLocal()
{
	Vector src, dst, forward;
	trace_t tr;

	if (!this)
		return false;

	QAngle viewangle = this->GetEyeAngles();

	M::AngleVectors(viewangle, &forward);
	forward *= 8142.f;
	src = this->GetEyePosition();
	dst = src + forward;

	U::TraceLine(src, dst, MASK_SHOT, this, &tr);

	if (tr.m_pEnt == G::LocalPlayer)
		return true;

	return false;
}

model_t* CBaseEntity::GetModel()
{
	return *(model_t**)((DWORD)this + 0x6C);
}

bool CBaseEntity::IsEnemy()
{
	return (this->GetTeam() == G::LocalPlayer->GetTeam() || this->GetTeam() == 0) ? false : true;
}

bool CBaseEntity::IsVisible(int bone)
{
	Ray_t ray;
	trace_t tr;
	m_visible = false;
	ray.Init(G::LocalPlayer->GetEyePosition(), this->GetBonePosition(bone));

	CTraceFilter filter;
	filter.pSkip = G::LocalPlayer;

	I::EngineTrace->TraceRay(ray, MASK_NPCWORLDSTATIC | MASK_SHOT, &filter, &tr);

	if (tr.m_pEnt == this || tr.fraction > 0.99f)
	{
		m_visible = true;
		return true;
	}

	return false;
}

bool CBaseEntity::IsBroken()
{
	return *(bool*)((DWORD)this + offsets.m_bIsBroken);
}

QAngle CBaseEntity::GetViewPunch()
{
	return *(QAngle*)((DWORD)this + offsets.m_viewPunchAngle);
}

Vector CBaseEntity::GetAimPunchAngle()
{
	return *(Vector*)((DWORD)this + offsets.m_aimPunchAngle);
}

QAngle CBaseEntity::GetPunch()
{
	return *(QAngle*)((DWORD)this + offsets.m_aimPunchAngle);
}

QAngle* CBaseEntity::GetEyeAnglesPointer()
{
	return reinterpret_cast<QAngle*>((DWORD)this + (DWORD)0xAA08);
}

QAngle CBaseEntity::GetEyeAngles()
{
	return *(QAngle*)((DWORD)this + offsets.m_angEyeAngles);
}

Vector CBaseEntity::GetOrigin()
{
	return *(Vector*)((DWORD)this + offsets.m_vecOrigin);
}

Vector CBaseEntity::GetOrigin2()
{
	return *(Vector*)((DWORD)this + 0x00000134);
}

Vector CBaseEntity::GetAbsOrigin()
{
	typedef Vector(__thiscall* oGetAbsOriginal)(void*);
	return U::GetVFunc<oGetAbsOriginal>(this, 10)(this);
}

Vector CBaseEntity::GetAbsOrigin2()
{
	__asm
	{
		MOV ECX, this
		MOV EAX, DWORD PTR DS : [ECX]
		CALL DWORD PTR DS : [EAX + 0x28]
	}
}

Vector CBaseEntity::GetAbsAngles()
{
	typedef Vector(__thiscall* oGetAbsAngles)(void*);
	return U::GetVFunc<oGetAbsAngles>(this, 11)(this);
}

Vector CBaseEntity::GetAbsAngles2()
{
	__asm
	{
		MOV ECX, this;
		MOV EAX, DWORD PTR DS : [ECX];
		CALL DWORD PTR DS : [EAX + 0x2C]
	}
}

Vector CBaseEntity::GetEyePosition()
{
	Vector origin = this->GetOrigin();
	Vector offset = *(Vector*)((DWORD)this + offsets.m_vecViewOffset);

	return(origin + offset);
}

Vector CBaseEntity::GetVecViewOffset()
{
	return *(Vector*)((DWORD)this + offsets.m_vecViewOffset);
}

Vector CBaseEntity::GetBonePosition(int iBone)
{
	matrix3x4_t BoneMatrix[MAXSTUDIOBONES];

	if (this->SetupBones(BoneMatrix, MAXSTUDIOBONES, BONE_USED_BY_HITBOX, 0))
		return Vector(BoneMatrix[iBone][0][3], BoneMatrix[iBone][1][3], BoneMatrix[iBone][2][3]);
	else
		return Vector(0, 0, 0);
}

QAngle* CBaseEntity::GetVAngles()
{
	return (QAngle*)((DWORD)this + offsets.deadflag + 0x4);
}

bool CBaseEntity::SetupBones(matrix3x4_t* pBoneToWorldOut, int nMaxBones, int boneMask, float currentTime)
{
	__asm
	{
		mov edi, this
		lea ecx, DWORD ptr ds : [edi + 0x4]
		mov edx, DWORD ptr ds : [ecx]
		push currentTime
		push boneMask
		push nMaxBones
		push pBoneToWorldOut
		call DWORD ptr ds : [edx + 0x34]
	}
}

Vector CBaseEntity::GetVelocity()
{
	return *(Vector*)((DWORD)this + offsets.m_vecVelocity);
}

Vector CBaseEntity::GetPredicted(Vector p0)
{
	return M::ExtrapolateTick(p0, this->GetVelocity());
}

float& CBaseEntity::GetPoseParameter(int i)
{
	return *(float*)((DWORD)this + offsets.m_flPoseParameter + sizeof(float) * i);
}

ICollideable* CBaseEntity::GetCollideable()
{
	return (ICollideable*)((DWORD)this + offsets.m_Collision);
}

void CBaseEntity::UpdateClientSideAnimation()
{
	typedef void(__thiscall* oUpdateClientSideAnimation)(void*);
	return U::GetVFunc<oUpdateClientSideAnimation>(this, 218)(this); // ? return
}

player_info_t CBaseEntity::GetPlayerInfo()
{
	player_info_t pinfo;
	I::Engine->GetPlayerInfo(this->index, &pinfo);
	return pinfo;
}

std::string	CBaseEntity::GetName()
{
	return this->GetPlayerInfo().name;
}

std::string	CBaseEntity::GetSteamID() //outdated needs update
{
	return this->GetPlayerInfo().name;
}

std::string CBaseEntity::GetLastPlace()
{
	return std::string((const char*)this + offsets.m_szLastPlaceName);
}

CBaseCombatWeapon* CBaseEntity::GetWeapon()
{
	DWORD weaponData = *(DWORD*)((DWORD)this + offsets.m_hActiveWeapon);
	return (CBaseCombatWeapon*)I::ClientEntList->GetClientEntityFromHandle(weaponData);
}

ClientClass* CBaseEntity::GetClientClass()
{
	PVOID pNetworkable = (PVOID)((DWORD)(this) + 0x8);
	typedef ClientClass*(__thiscall* OriginalFn)(PVOID);
	return U::GetVFunc<OriginalFn>(pNetworkable, 2)(pNetworkable);
}

int CBaseEntity::GetCollisionGroup()
{
	return *(int*)((DWORD)this + offsets.m_CollisionGroup);
}

int& CBaseCombatWeapon::GetWeaponID()
{
	return *(int*)((DWORD)this + offsets.m_iWeaponID);
}

float& CBaseCombatWeapon::GetNextPrimaryAttack()
{
	return *(float*)((DWORD)this + offsets.m_flNextPrimaryAttack);
}

float& CBaseCombatWeapon::GetAccuracyPenalty()
{
	return *(float*)((DWORD)this + offsets.m_fAccuracyPenalty);
}

float& CBaseCombatWeapon::GetPostponeFireReadyTime()
{
	return *(float*)((DWORD)this + offsets.m_flPostponeFireReadyTime);
}

int& CBaseCombatWeapon::GetXUIDLow()
{
	return *(int*)((DWORD)this + offsets.m_OriginalOwnerXuidLow);
}

int& CBaseCombatWeapon::GetXUIDHigh()
{
	return *(int*)((DWORD)this + offsets.m_OriginalOwnerXuidHigh);
}

int& CBaseCombatWeapon::GetEntityQuality()
{
	return *(int*)((DWORD)this + offsets.m_iEntityQuality);
}

int& CBaseCombatWeapon::GetAccountID()
{
	return *(int*)((DWORD)this + offsets.m_iAccountID);
}

int& CBaseCombatWeapon::GetItemIDHigh()
{
	return *(int*)((DWORD)this + offsets.m_iItemIDHigh);
}

int& CBaseCombatWeapon::GetItemDefinitionIndex()
{
	return *(int*)((DWORD)this + offsets.m_iItemDefinitionIndex);
}

int& CBaseCombatWeapon::ViewModelIndex()
{
	return *(int*)((DWORD)this + offsets.m_iViewModelIndex);
}

int& CBaseCombatWeapon::WorldModelIndex()
{
	return *(int*)((DWORD)this + offsets.m_iWorldModelIndex);
}

int& CBaseCombatWeapon::GetFallbackPaintKit()
{
	return *(int*)((DWORD)this + offsets.m_nFallbackPaintKit);
}

int& CBaseCombatWeapon::GetFallbackStatTrak()
{
	return *(int*)((DWORD)this + offsets.m_nFallbackStatTrak);
}

float& CBaseCombatWeapon::GetFallbackWear()
{
	return *(float*)((DWORD)this + offsets.m_flFallbackWear);
}

WeaponInfo_t* CBaseCombatWeapon::GetCSWpnData()
{
	if (!this) return nullptr;

	typedef WeaponInfo_t*(__thiscall* OriginalFn)(PVOID);
	return U::GetVFunc<OriginalFn>(this, 446)(this); // FIXed
}

bool CBaseCombatWeapon::IsEmpty()
{
	int clip = *(int*)((DWORD)this + offsets.m_iClip1);
	return clip == 0;
}

bool CBaseCombatWeapon::IsReloading()
{
	return *(bool*)((DWORD)this + 0x3235);
}

float CBaseCombatWeapon::GetInaccuracy()
{
	typedef float(__thiscall* oInaccuracy)(PVOID);
	return U::GetVFunc<oInaccuracy>(this, 469)(this);
}

float CBaseCombatWeapon::GetInaccuracy2()
{
	if (!this) return 0;
	typedef float(__thiscall* oInaccuracy)(PVOID);
	return U::GetVFunc<oInaccuracy>(this, 469)(this);
}

float CBaseCombatWeapon::GetSpread()
{
	typedef float(__thiscall* oWeaponSpread)(PVOID);
	return U::GetVFunc<oWeaponSpread>(this, 439)(this); //
}

void CBaseCombatWeapon::UpdateAccuracyPenalty()
{
	typedef void(__thiscall *FunctionFn)(void*);
	reinterpret_cast< FunctionFn >(*reinterpret_cast< PDWORD >(*reinterpret_cast< PDWORD >(this) + 0x748))((void*)this);
}

float CBaseCombatWeapon::GetWeaponCone()
{
	if (!this)
		return 0.f;

	typedef float(__thiscall* oWeaponCone)(PVOID);
	return U::GetVFunc<oWeaponCone>(this, 478)(this); //What do we miss here?
}

float CBaseCombatWeapon::GetWeaponSpread()
{
	if (!this) return 0.f;

	typedef float(__thiscall* OriginalFn)(void*);
	return U::GetVFunc<OriginalFn>(this, 439)(this);
	//return U::GetVFunc<OriginalFn>( this, 479 )( this ); //Wrong since update 18.08.17
}

float CBaseCombatWeapon::GetHitchance()
{
	float inaccuracy = GetInaccuracy();
	if (inaccuracy == 0)
		inaccuracy = 0.0000001;
	inaccuracy = 1 / inaccuracy;
	return inaccuracy;
}

float CBaseEntity::GetLowerBodyYaw()
{
	return *(float*)((DWORD)this + offsets.m_flLowerBodyYawTarget);
}

bool CBaseCombatWeapon::IsGun()
{
	if (!this)
		return false;

	int id = this->GetWeaponID();

	switch (id)
	{
	case WEAPON_DEAGLE:
	case WEAPON_ELITE:
	case WEAPON_FIVESEVEN:
	case WEAPON_GLOCK:
	case WEAPON_AK47:
	case WEAPON_AUG:
	case WEAPON_AWP:
	case WEAPON_FAMAS:
	case WEAPON_G3SG1:
	case WEAPON_GALILAR:
	case WEAPON_M249:
	case WEAPON_M4A1:
	case WEAPON_MAC10:
	case WEAPON_P90:
	case WEAPON_UMP45:
	case WEAPON_XM1014:
	case WEAPON_BIZON:
	case WEAPON_MAG7:
	case WEAPON_NEGEV:
	case WEAPON_SAWEDOFF:
	case WEAPON_TEC9:
	case WEAPON_HKP2000:
	case WEAPON_MP7:
	case WEAPON_MP9:
	case WEAPON_NOVA:
	case WEAPON_P250:
	case WEAPON_SCAR20:
	case WEAPON_SG556:
	case WEAPON_SSG08:
		return true;
	case WEAPON_KNIFE:
	case WEAPON_FLASHBANG:
	case WEAPON_HEGRENADE:
	case WEAPON_SMOKEGRENADE:
	case WEAPON_MOLOTOV:
	case WEAPON_DECOY:
	case WEAPON_INCGRENADE:
	case WEAPON_C4:
	case WEAPON_KNIFE_T:
	case WEAPON_TASER:
		return false;
	case WEAPON_M4A1_SILENCER:
	case WEAPON_USP_SILENCER:
	case WEAPON_CZ75A:
	case WEAPON_REVOLVER:
		return true;
	default:
		return false;
	}
}

bool CBaseCombatWeapon::IsGunSniper()
{
	if (!this)
		return false;

	int id = this->GetWeaponID();

	switch (id)
	{
	case WEAPON_DEAGLE:
	case WEAPON_ELITE:
	case WEAPON_FIVESEVEN:
	case WEAPON_GLOCK:
	case WEAPON_AK47:
	case WEAPON_AUG:
	case WEAPON_FAMAS:
	case WEAPON_GALILAR:
	case WEAPON_M249:
	case WEAPON_M4A1:
	case WEAPON_MAC10:
	case WEAPON_P90:
	case WEAPON_UMP45:
	case WEAPON_XM1014:
	case WEAPON_BIZON:
	case WEAPON_MAG7:
	case WEAPON_NEGEV:
	case WEAPON_SAWEDOFF:
	case WEAPON_TEC9:
	case WEAPON_TASER:
	case WEAPON_HKP2000:
	case WEAPON_MP7:
	case WEAPON_MP9:
	case WEAPON_NOVA:
	case WEAPON_P250:
	case WEAPON_SG556:
	case WEAPON_KNIFE:
	case WEAPON_FLASHBANG:
	case WEAPON_HEGRENADE:
	case WEAPON_SMOKEGRENADE:
	case WEAPON_MOLOTOV:
	case WEAPON_DECOY:
	case WEAPON_INCGRENADE:
	case WEAPON_C4:
	case WEAPON_KNIFE_T:
	case WEAPON_M4A1_SILENCER:
	case WEAPON_USP_SILENCER:
	case WEAPON_CZ75A:
	case WEAPON_REVOLVER:
		return false;
	case WEAPON_G3SG1:
	case WEAPON_SCAR20:
	case WEAPON_SSG08:
	case WEAPON_AWP:
		return true;
	default:
		return false;
	}
}

bool CBaseCombatWeapon::IsGunCanScope()
{
	if (!this)
		return false;

	int id = this->GetWeaponID();

	switch (id)
	{
	case WEAPON_DEAGLE:
	case WEAPON_ELITE:
	case WEAPON_FIVESEVEN:
	case WEAPON_GLOCK:
	case WEAPON_AK47:
	case WEAPON_FAMAS:
	case WEAPON_GALILAR:
	case WEAPON_M249:
	case WEAPON_M4A1:
	case WEAPON_MAC10:
	case WEAPON_P90:
	case WEAPON_UMP45:
	case WEAPON_XM1014:
	case WEAPON_BIZON:
	case WEAPON_MAG7:
	case WEAPON_NEGEV:
	case WEAPON_SAWEDOFF:
	case WEAPON_TEC9:
	case WEAPON_TASER:
	case WEAPON_HKP2000:
	case WEAPON_MP7:
	case WEAPON_MP9:
	case WEAPON_NOVA:
	case WEAPON_P250:
	case WEAPON_KNIFE:
	case WEAPON_FLASHBANG:
	case WEAPON_HEGRENADE:
	case WEAPON_SMOKEGRENADE:
	case WEAPON_MOLOTOV:
	case WEAPON_DECOY:
	case WEAPON_INCGRENADE:
	case WEAPON_C4:
	case WEAPON_KNIFE_T:
	case WEAPON_M4A1_SILENCER:
	case WEAPON_USP_SILENCER:
	case WEAPON_CZ75A:
	case WEAPON_REVOLVER:
		return false;
	case WEAPON_G3SG1:
	case WEAPON_SCAR20:
	case WEAPON_SSG08:
	case WEAPON_AWP:
	case WEAPON_SG556:
	case WEAPON_AUG:
		return true;
	default:
		return false;
	}
}

bool CBaseCombatWeapon::IsGunGrenade()
{
	if (!this)
		return false;

	int id = this->GetWeaponID();

	switch (id)
	{
	case WEAPON_DEAGLE:
	case WEAPON_ELITE:
	case WEAPON_FIVESEVEN:
	case WEAPON_GLOCK:
	case WEAPON_AK47:
	case WEAPON_AUG:
	case WEAPON_FAMAS:
	case WEAPON_GALILAR:
	case WEAPON_M249:
	case WEAPON_M4A1:
	case WEAPON_MAC10:
	case WEAPON_P90:
	case WEAPON_UMP45:
	case WEAPON_XM1014:
	case WEAPON_BIZON:
	case WEAPON_MAG7:
	case WEAPON_NEGEV:
	case WEAPON_SAWEDOFF:
	case WEAPON_TEC9:
	case WEAPON_HKP2000:
	case WEAPON_MP7:
	case WEAPON_MP9:
	case WEAPON_NOVA:
	case WEAPON_P250:
	case WEAPON_SG556:
	case WEAPON_KNIFE:
	case WEAPON_KNIFE_T:
	case WEAPON_C4:
	case WEAPON_TASER:
	case WEAPON_M4A1_SILENCER:
	case WEAPON_USP_SILENCER:
	case WEAPON_CZ75A:
	case WEAPON_REVOLVER:
	case WEAPON_G3SG1:
	case WEAPON_SCAR20:
	case WEAPON_SSG08:
	case WEAPON_AWP:
		return false;
	case WEAPON_INCGRENADE:
	case WEAPON_SMOKEGRENADE:
	case WEAPON_HEGRENADE:
	case WEAPON_FLASHBANG:
	case WEAPON_DECOY:
	case WEAPON_MOLOTOV:
		return true;
	default:
		return false;
	}
}

std::string CBaseCombatWeapon::GetWeaponName()
{
	if (!this)
		return "";

	int id = this->GetWeaponID();

	switch (id)
	{
	case WEAPON_DEAGLE:
		return XorStr("Desert Eagle");
	case WEAPON_ELITE:
		return XorStr("Dual Berettas");
	case WEAPON_FIVESEVEN:
		return XorStr("Five-SeveN");
	case WEAPON_GLOCK:
		return XorStr("Glock-18");
	case WEAPON_AK47:
		return XorStr("AK-47");
	case WEAPON_AUG:
		return XorStr("AUG");
	case WEAPON_AWP:
		return XorStr("AWP");
	case WEAPON_FAMAS:
		return XorStr("FAMAS");
	case WEAPON_G3SG1:
		return XorStr("G3SG1");
	case WEAPON_GALILAR:
		return XorStr("Galil-AR");
	case WEAPON_M249:
		return XorStr("M249");
	case WEAPON_M4A1:
		return XorStr("M4A1");
	case WEAPON_MAC10:
		return XorStr("MAC-10");
	case WEAPON_P90:
		return XorStr("P90");
	case WEAPON_UMP45:
		return XorStr("UMP-45");
	case WEAPON_XM1014:
		return XorStr("XM1014");
	case WEAPON_BIZON:
		return XorStr("PP-Bizon");
	case WEAPON_MAG7:
		return XorStr("MAG-7");
	case WEAPON_NEGEV:
		return XorStr("Negev");
	case WEAPON_SAWEDOFF:
		return XorStr("Sawed-Off");
	case WEAPON_TEC9:
		return XorStr("Tec-9");
	case WEAPON_TASER:
		return XorStr("Taser");
	case WEAPON_HKP2000:
		return XorStr("P2000");
	case WEAPON_MP7:
		return XorStr("MP7");
	case WEAPON_MP9:
		return XorStr("MP9");
	case WEAPON_NOVA:
		return XorStr("Nova");
	case WEAPON_P250:
		return XorStr("P250");
	case WEAPON_SCAR20:
		return XorStr("SCAR-20");
	case WEAPON_SG556:
		return XorStr("SG 553");
	case WEAPON_SSG08:
		return XorStr("SSG 08");
	case WEAPON_KNIFE:
		return XorStr("Knife");
	case WEAPON_FLASHBANG:
		return XorStr("Flashbang");
	case WEAPON_HEGRENADE:
		return XorStr("HE Grenade");
	case WEAPON_SMOKEGRENADE:
		return XorStr("Smoke Grenade");
	case WEAPON_MOLOTOV:
		return XorStr("Molotov");
	case WEAPON_DECOY:
		return XorStr("Decoy");
	case WEAPON_INCGRENADE:
		return XorStr("Incendiary Grenade");
	case WEAPON_C4:
		return XorStr("C4");
	case WEAPON_KNIFE_T:
		return XorStr("Knife");
	case WEAPON_M4A1_SILENCER:
		return XorStr("M4A1-S");
	case WEAPON_USP_SILENCER:
		return XorStr("USP-S");
	case WEAPON_CZ75A:
		return XorStr("CZ75-Auto");
	case WEAPON_REVOLVER:
		return XorStr("R8 Revolver");
	default:
		return XorStr("Knife");
	}

	return "";
}

int CBaseCombatWeapon::GetWeaponType()
{
	if (!this)
		return WEAPONTYPE_UNKNOWN;

	auto id = this->GetWeaponID();
	switch (id)
	{
	case WEAPON_DEAGLE:
	case WEAPON_ELITE:
	case WEAPON_FIVESEVEN:
	case WEAPON_HKP2000:
	case WEAPON_USP_SILENCER:
	case WEAPON_CZ75A:
	case WEAPON_TEC9:
	case WEAPON_REVOLVER:
	case WEAPON_GLOCK:
	case WEAPON_P250:
		return WEAPONTYPE_PISTOL;
		break;
	case WEAPON_AK47:
	case WEAPON_M4A1:
	case WEAPON_M4A1_SILENCER:
	case WEAPON_GALILAR:
	case WEAPON_AUG:
	case WEAPON_FAMAS:
	case WEAPON_SG556:
		return WEAPONTYPE_RIFLE;
		break;
	case WEAPON_P90:
	case WEAPON_BIZON:
	case WEAPON_MP7:
	case WEAPON_MP9:
	case WEAPON_MAC10:
	case WEAPON_UMP45:
		return WEAPONTYPE_SUBMACHINEGUN;
		break;
	case WEAPON_AWP:
	case WEAPON_G3SG1:
	case WEAPON_SCAR20:
	case WEAPON_SSG08:
		return WEAPONTYPE_SNIPER;
		break;
	case WEAPON_NEGEV:
	case WEAPON_M249:
		return WEAPONTYPE_MACHINEGUN;
		break;
	case WEAPON_MAG7:
	case WEAPON_SAWEDOFF:
	case WEAPON_NOVA:
	case WEAPON_XM1014:
		return WEAPONTYPE_SHOTGUN;
		break;
	case WEAPON_KNIFE:
	case WEAPON_KNIFE_BAYONET:
	case WEAPON_KNIFE_BUTTERFLY:
	case WEAPON_KNIFE_FALCHION:
	case WEAPON_KNIFE_FLIP:
	case WEAPON_KNIFE_GUT:
	case WEAPON_KNIFE_KARAMBIT:
	case WEAPON_KNIFE_TACTICAL:
	case WEAPON_KNIFE_M9_BAYONET:
	case WEAPON_KNIFE_PUSH:
	case WEAPON_KNIFE_SURVIVAL_BOWIE:
	case WEAPON_KNIFE_T:
		return WEAPONTYPE_KNIFE;
		break;

	default:
		return WEAPONTYPE_UNKNOWN;
	}
}