Mój pierwszy cheat

Witam,

Ostatnio próbuję napisać swojego pierwszego cheata do Assault Cube. Niestety Podczas kompilacji mam taki błąd: 

Cytat

Rozpoczęto kompilację...
1>------ Kompilacja rozpoczęta: Projekt: Cheat, Konfiguracja: Debug Win32 ------
1>Cheat.obj : error LNK2019: nierozpoznany symbol zewnętrzny "public: bool __thiscall Process::RPM<unsigned int>(void const *,unsigned int *)" (??$RPM@I@Process@@QAE_NPBXPAI@Z) przywołany w funkcji _main
1>Cheat.obj : error LNK2019: nierozpoznany symbol zewnętrzny "public: bool __thiscall Process::WPM<unsigned int>(void *,unsigned int *)" (??$WPM@I@Process@@QAE_NPAXPAI@Z) przywołany w funkcji _main
1>C:\Users\MojaNazwaUzytkownika\Desktop\Cheat\Cheat\Debug\Cheat.exe : fatal error LNK1120: liczba nierozpoznanych elementów zewnętrznych: 2
1>Kompilowanie projektu „Cheat.vcxproj” wykonane — NIEPOWODZENIE.
========== Kompilacja: 0 zakończono powodzeniem, 1 zakończono niepowodzeniem, 0 zaktualizowano, 0 pominięto ==========

Mój kod źródłowy:

#include "CheatProcess.h"

uintptr_t PlayerOffset = 0x509B74;
uintptr_t HealthOffset = 0xF8;

int main()
{
	Process AssaultCube;
	bool BoolReturn = AssaultCube.AttachToProcess("AssaultCube");

	if (!BoolReturn)
	{
		system("pause");
		return 1;
	}

	uintptr_t LocalPlayerAdress;
	BoolReturn = AssaultCube.RPM<uintptr_t>((LPCVOID)PlayerOffset, &LocalPlayerAdress);

	if (!BoolReturn)
	{
		system("pause");
		return 1;
	}

	uintptr_t HealthAdress = LocalPlayerAdress + HealthOffset;
	std::cout << std::hex << HealthAdress;
	while (true)
	{
		if (GetAsyncKeyState(VK_F1))
		{
			uintptr_t CurrentHealth;
			BoolReturn = AssaultCube.RPM<uintptr_t>((LPCVOID)HealthAdress, &CurrentHealth);

			CurrentHealth += 1;

			BoolReturn = AssaultCube.WPM<uintptr_t>((LPVOID)HealthAdress, &CurrentHealth);

			Sleep(10);
		}

		if (GetAsyncKeyState(VK_F2))
		{
			uintptr_t CurrentHealth;
			BoolReturn = AssaultCube.RPM<uintptr_t>((LPCVOID)HealthAdress, &CurrentHealth);

			CurrentHealth -= 1;

			BoolReturn = AssaultCube.WPM<uintptr_t>((LPVOID)HealthAdress, &CurrentHealth);
			Sleep(10);
		}
	}
	return 0;
}

#pragma once

#include <iostream>
#include <Windows.h>

class Process
{
public:
	Process();

	~Process();

	bool AttachToProcess(LPCSTR WindowName);

	bool UnattachFromProcess();

	template <class ClassToRead>
	bool RPM(LPCVOID AdressToRead, ClassToRead* ReadVariable);

	template <class ClassToWrite>
	bool WPM(LPVOID AdressToWrite, ClassToWrite* WriteVariable);

	HANDLE GetProcessHandle();

private:
	DWORD PID;
	HANDLE ProcessHandle;
	HWND hWnd;
	bool bIsAttachedToProcess = false;
};

#include "CheatProcess.h"

Process::Process()
{
	ProcessHandle = NULL;
	hWnd = NULL;
	PID = 0;
}

Process::~Process()
{
	UnattachFromProcess();
}

bool Process::AttachToProcess(LPCSTR WindowName)
{
	hWnd = FindWindowA(0, WindowName);

	if (hWnd == NULL)
	{
		std::cout << "The window could not be found. Error: " << GetLastError() << std::endl;
		return false;
	}

	GetWindowThreadProcessId(hWnd, &PID);

	ProcessHandle = OpenProcess(PROCESS_ALL_ACCESS, false, PID);

	if (ProcessHandle == INVALID_HANDLE_VALUE || ProcessHandle == NULL)
	{
		std::cout << "The Process could not be found. Error: " << GetLastError() << std::endl;
		return false;
	}

	bIsAttachedToProcess = true;
	return true;
}

bool Process::UnattachFromProcess()
{
	BOOL bReturn = CloseHandle(ProcessHandle);
	if (bReturn)
	{
		bIsAttachedToProcess = false;
		return true;
	}
	else
	{
		std::cout << "Could not close handle. Error: " << GetLastError() << std::endl;
		return false;
	}
}


template <class ClassToRead>
bool Process::RPM(LPCVOID AdressToRead, ClassToRead* ReadVariable)
{
	if (!bIsAttachedToProcess)
	{
		std::cout << "You must attach to process" << std::endl;
		return false;
	}

	BOOL bReturn = ReadProcessMemory(ProcessHandle, AdressToRead, (LPVOID)ReadVariable, sizeof(ClassToRead), NULL);

	if (!bReturn)
	{
		std::cout << "There was no attempt to read the process memory. Error: " << GetLastError() << std::endl;
	}

	return (bool)bReturn;
}

template <class ClassToWrite>
bool Process::WPM(LPVOID AdressToWrite, ClassToWrite* WriteVariable)
{
	if (!bIsAttachedToProcess)
	{
		std::cout << "You must attach to process" << std::endl;
		return false;
	}

	BOOL bReturn = WriteProcessMemory(ProcessHandle, AdressToWrite, (LPCVOID)WriteVariable, sizeof(ClassToWrite), NULL);

	if (!bReturn)
	{
		std::cout << "There was no attempt to write the process memory. Error: " << GetLastError() << std::endl;
	}

	return (bool)bReturn;
}

HANDLE Process::GetProcessHandle()
{
	return ProcessHandle;
}

Jeszcze dodam, że gdy implementację klasy Process umieszczę w pliku nagłówkowym to wszystko dobrze działa. Co mogę zrobić aby podczas kompilacji nie było błędów i definicje funkcji były w pliki .cpp?