Paste helo

Ive gone through editing a paste entirely removing features and everything, making it UD but now i realised the players all view one direction.
(Based on ayyware)
What should i cahnge to fix this bit. Everything else works.

This is the AntiAim Doc

Code:

#include "Interfaces.h"
#include "Menu.h"
#include "AntiAntiAim.h"
#include "Resolvermeme.h"
#include "MiscDefinitions.h"
#include "Entities.h"

int Globals::Shots = 0;
bool Globals::change;
CUserCmd* Globals::UserCmd;
int Globals::TargetID;
IClientEntity* Globals::Target;
float YawDelta[64];
float reset[64];
float Delta[64];
float OldLowerBodyYaw[64];
float Resolved_angles[64];
int iSmart;
static int jitter = -1;

void R::Resolver()
{
	// This is basically a bruteforce resolver
	IClientEntity *pLocal = Interfaces::EntList->GetClientEntity(Interfaces::Engine->GetLocalPlayer());

	for (int i = 0; i < Interfaces::Engine->GetMaxClients(); ++i)
	{
		IClientEntity *pEntity = Interfaces::EntList->GetClientEntity(i);

		if (!pEntity || pEntity->IsDormant() || !pEntity->IsAlive())
			continue;

		if (pEntity->GetTeamNum() == pLocal->GetTeamNum() || !pLocal->IsAlive())
			continue;

		Vector* eyeAngles = pEntity->GetEyeAnglesPointer();

		if (Menu::Window.RageBotTab.AccuracyResolverYaw.GetIndex()  || Menu::Window.RageBotTab.AccuracyResolverPitch.GetState())
		{
			if (pEntity != Globals::Target) continue;

			Vector AimAngle;
			CalcAngleYawOnly(pEntity->GetEyePosition(), pLocal->GetAbsOrigin2(), AimAngle);
			NormalizeVector(AimAngle);
			static float StoredYaw = 0;
			static bool bLowerBodyIsUpdated = false;
			if (pEntity->GetLowerBodyYaw() != StoredYaw) bLowerBodyIsUpdated = true;
			else bLowerBodyIsUpdated = false;
			if (bLowerBodyIsUpdated) StoredYaw = pEntity->GetLowerBodyYaw();
			if (pEntity->GetFlags() & FL_ONGROUND && pEntity->GetVelocity().Length2D() != 0) eyeAngles->y = pEntity->GetLowerBodyYaw();
			else
			{
				if (Menu::Window.RageBotTab.AccuracyResolverYaw.GetIndex() == 1) // LBY Bruteforce 1
				{
					int num = Globals::Shots % 9;
					switch (num) {
					case 0:eyeAngles->y = pEntity->GetLowerBodyYaw() + 180; break;
					case 1:eyeAngles->y = pEntity->GetLowerBodyYaw() - 90; break;
					case 2:eyeAngles->y = pEntity->GetLowerBodyYaw() + 90; break;
					case 3:eyeAngles->y = pEntity->GetLowerBodyYaw() + 179.95; break;
					case 4:eyeAngles->y = pEntity->GetLowerBodyYaw() - 179.95; break;
					case 5:eyeAngles->y = pEntity->GetLowerBodyYaw() + 40; break;
					case 6:eyeAngles->y = pEntity->GetLowerBodyYaw() + 30; break;
					case 7:eyeAngles->y = pEntity->GetLowerBodyYaw() - 30; break;
					case 8:eyeAngles->y = pEntity->GetLowerBodyYaw() + 15; break;
					}
				}
				if (Menu::Window.RageBotTab.AccuracyResolverYaw.GetIndex() == 2) // LBY Bruteforce 2
				{
					int num = Globals::Shots % 4;
					switch (num) {
					case 1:eyeAngles->y = pEntity->GetLowerBodyYaw() - 15; break;
					case 2:eyeAngles->y = pEntity->GetLowerBodyYaw() + 40; break;
					case 3:eyeAngles->y = pEntity->GetLowerBodyYaw() - 40; break;
					case 4:eyeAngles->y = pEntity->GetLowerBodyYaw() + 15; break;
					}
				}
				if (Menu::Window.RageBotTab.AccuracyResolverYaw.GetIndex() == 3 && eyeAngles->y != pEntity->GetLowerBodyYaw()) // LBY Bruteforce 3
				{
					int value = (iSmart) % 13;
					switch (value) {
					case 0: eyeAngles->y += 0.0f; break;
					case 1: eyeAngles->y += 10; break;
					case 2: eyeAngles->y += 20; break;
					case 3: eyeAngles->y += 30; break;
					case 4: eyeAngles->y += 40; break;
					case 5: eyeAngles->y += 50; break;
					case 6: eyeAngles->y += 60; break;
					case 7: eyeAngles->y += 70; break;
					case 8: eyeAngles->y += 80; break;
					case 9: eyeAngles->y += 90; break;
					case 10: eyeAngles->y += 100; break;
					case 11: eyeAngles->y += 110; break;
					case 12: eyeAngles->y += 120; break;
					case 13: eyeAngles->y += 130; break;
					case 14: eyeAngles->y += 140; break;
					case 15: eyeAngles->y += 150; break;
					case 16: eyeAngles->y += 160; break;
					case 17: eyeAngles->y += 170; break;
					case 18: eyeAngles->y += 180; break;
					case 19: eyeAngles->y += 190; break;
					case 20: eyeAngles->y += 200; break;
					case 21: eyeAngles->y += 210; break;
					case 22: eyeAngles->y += 220; break;
					case 23: eyeAngles->y += 230; break;
					case 24: eyeAngles->y += 240; break;
					case 25: eyeAngles->y += 250; break;
					case 26: eyeAngles->y += 260; break;
					case 27: eyeAngles->y += 270; break;
					case 28: eyeAngles->y += 280; break;
					case 29: eyeAngles->y += 290; break;
					case 30: eyeAngles->y += 300; break;
					case 31: eyeAngles->y += 310; break;
					case 32: eyeAngles->y += 320; break;
					case 33: eyeAngles->y += 330; break;
					case 34: eyeAngles->y += 340; break;
					case 35: eyeAngles->y += 350; break;
					case 36: eyeAngles->y += 360; break;
					case 37: eyeAngles->y += 0.0f; break;
					case 38: eyeAngles->y -= 10; break;
					case 39: eyeAngles->y -= 20; break;
					case 40: eyeAngles->y -= 30; break;
					case 41: eyeAngles->y -= 40; break;
					case 42: eyeAngles->y -= 50; break;
					case 43: eyeAngles->y -= 60; break;
					case 44: eyeAngles->y -= 70; break;
					case 45: eyeAngles->y -= 80; break;
					case 46: eyeAngles->y -= 90; break;
					case 47: eyeAngles->y -= 100; break;
					case 48: eyeAngles->y -= 110; break;
					case 49: eyeAngles->y -= 120; break;
					case 50: eyeAngles->y -= 130; break;
					case 51: eyeAngles->y -= 140; break;
					case 52: eyeAngles->y -= 150; break;
					case 53: eyeAngles->y -= 160; break;
					case 54: eyeAngles->y -= 170; break;
					case 55: eyeAngles->y -= 180; break;
					case 56: eyeAngles->y -= 190; break;
					case 57: eyeAngles->y -= 200; break;
					case 58: eyeAngles->y -= 210; break;
					case 59: eyeAngles->y -= 220; break;
					case 60: eyeAngles->y -= 230; break;
					case 61: eyeAngles->y -= 240; break;
					case 62: eyeAngles->y -= 250; break;
					case 63: eyeAngles->y -= 260; break;
					case 64: eyeAngles->y -= 270; break;
					case 65: eyeAngles->y -= 280; break;
					case 66: eyeAngles->y -= 290; break;
					case 67: eyeAngles->y -= 300; break;
					case 68: eyeAngles->y -= 310; break;
					case 69: eyeAngles->y -= 320; break;
					case 70: eyeAngles->y -= 330; break;
					case 71: eyeAngles->y -= 340; break;
					case 72: eyeAngles->y -= 350; break;
					case 73: eyeAngles->y -= 360; break;
						if (jitter)
							eyeAngles->y += 90;
						else
							eyeAngles->y + 90;
						break;
						if (jitter)
							eyeAngles->y -= 90;
						else
							eyeAngles->y = -90;
						break;
					}
				}
				if (Menu::Window.RageBotTab.AccuracyResolverYaw.GetIndex() == 4) // Normal Bruteforce
				{
					int num = Globals::Shots % 5;
					switch (num) {
					case 0:eyeAngles->y = AimAngle.y - 0; break;
					case 1:eyeAngles->y = AimAngle.y - 15; break;
					case 2:eyeAngles->y = AimAngle.y + 40; break;
					case 3:eyeAngles->y = AimAngle.y - 40; break;
					case 4:eyeAngles->y = AimAngle.y + 15; break;
					}
				}
				if (Menu::Window.RageBotTab.AccuracyResolverYaw.GetIndex() == 5) // Auto 1
				{
					for (int i = 0; i < 64; ++i)
					{
						IClientEntity* ent = Interfaces::EntList->GetClientEntity(i);

						if (!ent || !ent->IsAlive())
							continue;

						*(float*)((uintptr_t)ent + 0xAA08 + 4) += Delta[i];
						reset[i] = *(float*)((uintptr_t)ent + 0xAA08 + 4);

						float LowerBodyYaw = *(float*)((uintptr_t)ent + 0x39F8);

						if (OldLowerBodyYaw[i] != LowerBodyYaw)
						{
							YawDelta[i] = reset[i] - LowerBodyYaw;
							OldLowerBodyYaw[i] = LowerBodyYaw;
							*(float*)((uintptr_t)ent + 0xAA08 + 4) = LowerBodyYaw;
						}
						else
						{
							*(float*)((uintptr_t)ent + 0xAA08 + 4) = reset[i] - YawDelta[i];

							while (*(float*)((uintptr_t)ent + 0xAA08 + 4) < -180.0f)
								*(float*)((uintptr_t)ent + 0xAA08 + 4) += 360.0f;

							while (*(float*)((uintptr_t)ent + 0xAA08 + 4) > 180.0f)
								*(float*)((uintptr_t)ent + 0xAA08 + 4) -= 360.0f;
						}
						Resolved_angles[i] = *(float*)((uintptr_t)ent + 0xAA08 + 4);
					}
				}
				if (Menu::Window.RageBotTab.AccuracyResolverYaw.GetIndex() == 6)
				{
					static float lowerDelta[64];
					static float lastYaw[64];

					IClientEntity *ent = Interfaces::EntList->GetClientEntity(i);

					float curLower = ent->GetLowerBodyYaw();
					float curYaw = ent->GetEyeAngles().y;

					lowerDelta[i] = curYaw - curLower;

					if (fabs(lowerDelta[i]) > 15.f)
					{
						if (ent->isMoving())
						{
							eyeAngles->y = ent->GetLowerBodyYaw();
						}
						else {
							if (curYaw != lastYaw[i])
							{
								eyeAngles->y += lowerDelta[i];
								lastYaw[i] = curYaw;
							}
						}
					}
				}
				if (Menu::Window.RageBotTab.AccuracyResolverYaw.GetIndex() == 7)
				{
					static float OldLowerBodyYaws[64];
					static float OldYawDeltas[64];

					IClientEntity *ent = Interfaces::EntList->GetClientEntity(i);

					float CurYaw = ent->GetLowerBodyYaw();
					if (OldLowerBodyYaws[i] != CurYaw) {
						OldYawDeltas[i] = ent->GetEyeAngles().y - CurYaw;
						OldLowerBodyYaws[i] = CurYaw;
						eyeAngles->y = CurYaw;
						continue;
					}
					else {
						eyeAngles->y = ent->GetEyeAngles().y - OldYawDeltas[i];
					}
				}
				if (Menu::Window.RageBotTab.AccuracyResolverYaw.GetIndex() == 8)
				{
					static bool isMoving;
					float PlayerIsMoving = abs(pEntity->GetVelocity().Length());
					if (PlayerIsMoving > 0.1) isMoving = true;
					else if (PlayerIsMoving <= 0.1) isMoving = false;

					static float StoredLBY = 0.0f;
					static bool bLowerBodyIsUpdated;
					if (pEntity->GetLowerBodyYaw() != StoredLBY) bLowerBodyIsUpdated = true;
					else bLowerBodyIsUpdated = false;

					float bodyeyedelta = pEntity->GetEyeAngles().y - pEntity->GetLowerBodyYaw();

					if (bLowerBodyIsUpdated || isMoving || fabsf(bodyeyedelta) >= 35.0f)
					{
						eyeAngles->y = pEntity->GetLowerBodyYaw();
						StoredLBY = pEntity->GetLowerBodyYaw();
					}

					else
					{
						if (fabsf(bodyeyedelta) < 35.0f && fabsf(bodyeyedelta) > 0.0f)
							eyeAngles->y = pEntity->GetLowerBodyYaw() + bodyeyedelta;
					}
				}
				if (Menu::Window.RageBotTab.AccuracyResolverYaw.GetIndex() == 9)
				{
					int num = Globals::Shots % 4;
					switch (num)
					{
					case 0:eyeAngles->y = rand() % 360; break;
					case 1:eyeAngles->y = 0; break;
					case 2:eyeAngles->y = rand() % 180; break;
					case 3:eyeAngles->y = 180; break;
					}
				}
			}

			// Pitch Resolver
			if (Menu::Window.RageBotTab.AccuracyResolverPitch.GetState()) // Test 1
			{
				std::string strPitch = std::to_string(eyeAngles->x);

				if (eyeAngles->x < -179.f) eyeAngles->x += 360.f;
				else if (eyeAngles->x > 90.0 || eyeAngles->x < -90.0) eyeAngles->x = 89.f;
				else if (eyeAngles->x > 89.0 && eyeAngles->x < 91.0) eyeAngles->x -= 90.f;
				else if (eyeAngles->x > 179.0 && eyeAngles->x < 181.0) eyeAngles->x -= 180;
				else if (eyeAngles->x > -179.0 && eyeAngles->x < -181.0) eyeAngles->x += 180;
				else if (fabs(eyeAngles->x) == 0) eyeAngles->x = std::copysign(89.0f, eyeAngles->x);

			}
		}
	}
}

void FixY(const CRecvProxyData *pData, void *pStruct, void *pOut)
{
	static Vector vLast[65];
	static bool bShotLastTime[65];
	static bool bJitterFix[65];

	float *flPitch = (float*)((DWORD)pOut - 4);
	float flYaw = pData->m_Value.m_Float;
	bool bHasAA;
	bool bSpinbot;

	if (Menu::Window.RageBotTab.AccuracyResolverYaw.GetIndex() > 0)
	{
		int value = rand() % 3 + 0;

		switch (value)
		{
		case 0:
		{
			flYaw = (rand() % 180);
			break;
		}
		case 1:
		{
			flYaw = (rand() % 360);
			break;
		}
		case 2:
		{
			flYaw = 0;
			break;
		}
		}
	}
}

// Simple Resolver for Fake Down
void FixX(const CRecvProxyData* pData, void* pStruct, void* pOut)
{
	float* ang = (float*)pOut;
	*ang = pData->m_Value.m_Float;

	if (!Menu::Window.RageBotTab.AccuracyResolverPitch.GetState()) return;

	if (pData->m_Value.m_Float > 180.0f)
		*ang -= 360.0f;
	else if (pData->m_Value.m_Float < -180.0f)
		*ang += 360.0f;

	if (pData->m_Value.m_Float > 89.0f && pData->m_Value.m_Float < 91.0f)
		*ang -= 90.0f;
	else if (pData->m_Value.m_Float > -89.0f && pData->m_Value.m_Float < -91)
		*ang += 90.0f;
}

RecvVarProxyFn oRecvnModelIndex;

void Hooked_RecvProxy_Viewmodel(CRecvProxyData *pData, void *pStruct, void *pOut)
{
	// Get the knife view model id's
	int default_t = Interfaces::ModelInfo->GetModelIndex("models/weapons/v_knife_default_t.mdl");
	int default_ct = Interfaces::ModelInfo->GetModelIndex("models/weapons/v_knife_default_ct.mdl");
	int iBayonet = Interfaces::ModelInfo->GetModelIndex("models/weapons/v_knife_bayonet.mdl");
	int iButterfly = Interfaces::ModelInfo->GetModelIndex("models/weapons/v_knife_butterfly.mdl");
	int iFlip = Interfaces::ModelInfo->GetModelIndex("models/weapons/v_knife_flip.mdl");
	int iGut = Interfaces::ModelInfo->GetModelIndex("models/weapons/v_knife_gut.mdl");
	int iKarambit = Interfaces::ModelInfo->GetModelIndex("models/weapons/v_knife_karam.mdl");
	int iM9Bayonet = Interfaces::ModelInfo->GetModelIndex("models/weapons/v_knife_m9_bay.mdl");
	int iHuntsman = Interfaces::ModelInfo->GetModelIndex("models/weapons/v_knife_tactical.mdl");
	int iFalchion = Interfaces::ModelInfo->GetModelIndex("models/weapons/v_knife_falchion_advanced.mdl");
	int iDagger = Interfaces::ModelInfo->GetModelIndex("models/weapons/v_knife_push.mdl");
	int iBowie = Interfaces::ModelInfo->GetModelIndex("models/weapons/v_knife_survival_bowie.mdl");

	int iGunGame = Interfaces::ModelInfo->GetModelIndex("models/weapons/v_knife_gg.mdl");

	// Get local player (just to stop replacing spectators knifes)
	IClientEntity* pLocal = Interfaces::EntList->GetClientEntity(Interfaces::Engine->GetLocalPlayer());
	if (Menu::Window.SkinTab.SkinEnable.GetState() && pLocal)
	{
		// If we are alive and holding a default knife(if we already have a knife don't worry about changing)
		if (pLocal->IsAlive() && (
			pData->m_Value.m_Int == default_t ||
			pData->m_Value.m_Int == default_ct ||
			pData->m_Value.m_Int == iBayonet ||
			pData->m_Value.m_Int == iButterfly ||
			pData->m_Value.m_Int == iFlip ||
			pData->m_Value.m_Int == iGunGame ||
			pData->m_Value.m_Int == iGut ||
			pData->m_Value.m_Int == iKarambit ||
			pData->m_Value.m_Int == iM9Bayonet ||
			pData->m_Value.m_Int == iHuntsman ||
			pData->m_Value.m_Int == iFalchion ||
			pData->m_Value.m_Int == iDagger ||
			pData->m_Value.m_Int == iBowie))
		{
			// Set whatever knife we want
			if (Menu::Window.SkinTab.KnifeModel.GetIndex() == 0)
				pData->m_Value.m_Int = iBayonet;
			else if (Menu::Window.SkinTab.KnifeModel.GetIndex() == 1)
				pData->m_Value.m_Int = iBowie;
			else if (Menu::Window.SkinTab.KnifeModel.GetIndex() == 2)
				pData->m_Value.m_Int = iButterfly;
			else if (Menu::Window.SkinTab.KnifeModel.GetIndex() == 3)
				pData->m_Value.m_Int = iFalchion;
			else if (Menu::Window.SkinTab.KnifeModel.GetIndex() == 4)
				pData->m_Value.m_Int = iFlip;
			else if (Menu::Window.SkinTab.KnifeModel.GetIndex() == 5)
				pData->m_Value.m_Int = iGut;
			else if (Menu::Window.SkinTab.KnifeModel.GetIndex() == 6)
				pData->m_Value.m_Int = iHuntsman;
			else if (Menu::Window.SkinTab.KnifeModel.GetIndex() == 7)
				pData->m_Value.m_Int = iKarambit;
			else if (Menu::Window.SkinTab.KnifeModel.GetIndex() == 8)
				pData->m_Value.m_Int = iM9Bayonet;
			else if (Menu::Window.SkinTab.KnifeModel.GetIndex() == 9)
				pData->m_Value.m_Int = iDagger;
		}
	}

	// Carry on the to original proxy
	oRecvnModelIndex(pData, pStruct, pOut);
}

void ApplyAAAHooks()
{
	ClientClass *pClass = Interfaces::Client->GetAllClasses();
	while (pClass)
	{
		const char *pszName = pClass->m_pRecvTable->m_pNetTableName;
		if (!strcmp(pszName, "DT_CSPlayer"))
		{
			for (int i = 0; i < pClass->m_pRecvTable->m_nProps; i++)
			{
				RecvProp *pProp = &(pClass->m_pRecvTable->m_pProps[i]);
				const char *name = pProp->m_pVarName;

				// Pitch Fix
				if (!strcmp(name, "m_angEyeAngles[0]"))
				{
					pProp->m_ProxyFn = FixX;
				}

				// Yaw Fix
				if (!strcmp(name, "m_angEyeAngles[1]"))
				{
					Utilities::Log("Yaw Fix Applied");
					pProp->m_ProxyFn = FixY;
				}
			}
		}
		else if (!strcmp(pszName, "DT_BaseViewModel"))
		{
			for (int i = 0; i < pClass->m_pRecvTable->m_nProps; i++)
			{
				RecvProp *pProp = &(pClass->m_pRecvTable->m_pProps[i]);
				const char *name = pProp->m_pVarName;

				// Knives
				if (!strcmp(name, "m_nModelIndex"))
				{
					oRecvnModelIndex = (RecvVarProxyFn)pProp->m_ProxyFn;
					pProp->m_ProxyFn = Hooked_RecvProxy_Viewmodel;
				}
			}
		}
		pClass = pClass->m_pNext;
	}
}

Nothing of that has to do with it. Its your YawFix and your PitchFix thats doing that.
You must've done it wrong, or calling it wrong.

You probs use DNKA his ayyware pastr which has that problem. Learncpp.com and it will be fixed as soon as you lesrned it!

aka.. Ayy is potato

Remove these lines:

Code:

// Pitch Fix
	if (!strcmp(name, "m_angEyeAngles[0]"))
	{
		pProp->m_ProxyFn = FixX; //<-THIS LINE
	}

// Yaw Fix
	if (!strcmp(name, "m_angEyeAngles[1]"))
	{
		Utilities::Log("Yaw Fix Applied");
		pProp->m_ProxyFn = FixY; //<- AND THIS LINE
	}

Or if you are an expert level copy paster, you can find a FixX/Y source from another cheat that actually works.

Learncpp.com
Players dont view one direction retard go back to school and learn what X Y AND Z are.

Originally Posted by hotted1135

Learncpp.com
Players dont view one direction retard go back to school and learn what X Y AND Z are.

Much help such wow +rep for you

Originally Posted by jonluke

Much help such wow +rep for you

Here is the OP dumb tutorial:
X is Left and Right aka horizontal axis
Y is up and down aka vertical axis
Z is location in space i think aka 3D axis not really needed in csgo shits

Thank you guys that actually helped. I managed to fix it before i went sleep.

Paste helo

Post a Reply

Similar Threads

Tags for this Thread