Recoil compensation via memory writing

[hydrophobis]

I have a working recoil correction version of main and I was curious what the thought is on having writing cheats? It requires some weird winapi crap (at least how I did it) but Ive been using it off/on for a few months for testing now and never had a problem.

Writing is weird however and I wasn't ever able to get NtWriteVirtualMemory to work with this. Its pretty janky because CS2 seems to actually be pretty good about not allowing writes. It usually runs fine without administrator too somehow.

	template<class T>
	bool write(uintptr_t address, const T& value)
	{
		MEMORY_BASIC_INFORMATION mbi;
		if (VirtualQueryEx(handle_, (LPVOID)address, &mbi, sizeof(mbi)) == 0 || mbi.State != MEM_COMMIT)
		{
			std::cerr << "Invalid or uncommitted memory region" << std::endl;
			return false;
		}

		DWORD oldProtect;
		if (!VirtualProtectEx(handle_, (LPVOID)address, sizeof(T), PAGE_READWRITE, &oldProtect))
		{
			std::cerr << "VirtualProtectEx failed with error: " << GetLastError() << std::endl;
			return false;
		}

		SIZE_T bytesWritten = 0;
		BOOL result = WriteProcessMemory(handle_, (LPVOID)address, &value, sizeof(T), &bytesWritten);

		VirtualProtectEx(handle_, (LPVOID)address, sizeof(T), oldProtect, &oldProtect);

		if (!result || bytesWritten != sizeof(T))
		{
			std::cerr << "WriteProcessMemory failed with error: " << GetLastError() << std::endl;
			return false;
		}

		return true;
	}

Other than the writing however, the rest is very simple. All it would need is a new offset and then calculate new view angles while firing. My implementation of it (which I put inside reader.cpp) is here:

	players.clear();
	players.assign(list.begin(), list.end());
  // this is the end of the usual reader.cpp here

	viewAngle = process->read<Vector3>(base_client.base + updater::offsets::dwViewAngles);
	localAimPunch = ((GetAsyncKeyState(VK_LBUTTON) & 0x8000) ? process->read<Vector3>(localpCSPlayerPawn + 5860) : Vector3{ 0, 0, 0 });

	CPlayer* target = get_nearest_player();
	if (target) {
		Vector3 localEye = localOrigin;
		localEye.z += (GetAsyncKeyState(VK_LCONTROL) & 0x8000 ? 54.f : 73.f);

		Vector3 punchDelta = localAimPunch - lastPunch;
		Vector3 correction = { punchDelta.x * 2.f, punchDelta.y * 2.f, 0 };
		lastPunch = localAimPunch;

   Vector3 aimTo = viewAngle
   // there is an aimbot here in my source code which calculates aimTo as the vector to the nearest player's head; aimTo is equal to viewAngle without aimbot
   aimTo = aimTo - correction;

		// Smoothing can be removed without aimbot so this isn't neccesary
		Vector3 delta = aimTo - viewAngle;
		float deltaLength = sqrt(delta.x * delta.x + delta.y * delta.y);
		if (deltaLength > 0.0f) {
			delta.x /= deltaLength;
			delta.y /= deltaLength;
		}

		float smoothFactor = 0.4f;
		Vector3 newAngle = viewAngle + delta * smoothFactor;

		// clamp and normalize
		if (newAngle.x > 89.0f) newAngle.x = 89.0f;
		if (newAngle.x < -89.0f) newAngle.x = -89.0f;
		while (newAngle.y > 180.f) newAngle.y -= 360.f;
		while (newAngle.y < -180.f) newAngle.y += 360.f;
		newAngle.z = 0.0f;

		process->write<Vector3>(base_client.base + updater::offsets::dwViewAngles, newAngle);
  }