Main.c und procfunc.c fehler?

#include <windows.h>
#include <resource.h>
#include <procfunc.h>
#include <cheats.h>
#include <log.h>

HWND dlg;							//Handle für das Fenster

// Funktionsdeklarationen

void ReadOriginalCode();
void DisableAllHax();
void RedirectAddresses();
void AttachGame();
void CopyOriginalCode();
BOOL Initialize();
BOOL DeInitialize();
void SetStatusText(LPCTSTR Text);

//////////////////////////////////////////////////////////////////////////////////////////

void ReadOriginalCode(){
/////////////////////////////////////////////////////////////////////////////////////////
// Ab Hier werden alle originalen Werte gespeichert bevor ein Hack sie verändern kann  //
// damit man später diese Codes wieder schreiben kann um eine toggle Funktion zu haben //
/////////////////////////////////////////////////////////////////////////////////////////

	if (!gameRunning) return;

	/////////////////////////////////////////////////////////////////////////////////////
	// Ab hier beginnt der Static Basepointer Abschnitt in dem die Addressen gespeichert werden

	Peek(gamePROC,gameExeBase+CHBase,sizeof(tmpBase1),&tmpBase1); // ab Hier Original Cursor
	Peek(gamePROC,tmpBase1+CHAdd1,sizeof(tmpBase2),&tmpBase2);   
	CHAddr = tmpBase2 + CHAdd2;

	Peek(gamePROC,gameDllBase+NFBase,sizeof(NFBase),&tmpBase1);// ab Hier NoFog
	NFAddr = tmpBase1 +  NFAdd;
	Peek(gamePROC,NFAddr,sizeof(NFHack),&NFOrg); // Fogweite 

	Peek(gamePROC,gameDllBase+VDBase,sizeof(VDBase),&tmpBase1);// ab Hier Viewdistance
	VDAddr = tmpBase1 +  VDAdd;
	Peek(gamePROC,VDAddr,sizeof(VDHack),&VDOrg); // Sichtweite

	Peek(gamePROC,gameDllBase+TVBase,sizeof(TVBase),&tmpBase1);// ab Hier Static TV
	TVAddr = tmpBase1 +  TVAdd;
	WriteLog("Static TV DMA @ 0x%08X",TVAddr);

	Peek(gamePROC,gameDllBase+NSBase,sizeof(NSBase),&tmpBase1);// ab Hier No Sky
	NSAddr = tmpBase1 +  NSAdd;
	WriteLog("Sky DMA @ 0x%08X",NSAddr);
}

void DisableAllHax(){
///////////////////////////////////////////////////////////////////////
// Hier werden die originalen werte in alle Addressen geschrieben    //
// und alle Hax ausgeschaltet                                        //
///////////////////////////////////////////////////////////////////////

	SetDlgItemText(dlg,IDC_STAT4,"Off");
	SetDlgItemText(dlg,IDC_STAT5,"0");
	SetDlgItemText(dlg,IDC_STAT6,"Off");
	SetDlgItemText(dlg,IDC_STAT7,"Off");
	SetDlgItemText(dlg,IDC_STAT8,"Off");
	 //Hackstatus auf Aus
	isCHOn=isNFOn=isVDOn=isFCOn=isZMOn=isTVOn=isNSOn=FALSE;

	if (!gameRunning) return;
	// DMA Hacks
	Poke(gamePROC,CHAddr,&CHOrg,sizeof(CHOrg)); // Original Cursor schreiben
	Poke(gamePROC,NFAddr,&NFOrg,sizeof(NFOrg)); // Original Fog schreiben
	if (FCAddr) Poke(gamePROC,FCAddr,&FCOrg,sizeof(FCOrg)); // Original Fog schreiben
	Poke(gamePROC,VDAddr,&VDOrg,sizeof(VDOrg)); // Original ViewDistance schreiben
	if (ZM1Addr) Poke(gamePROC,ZM1Addr,&ZM1Org,sizeof(ZM1Org)); // Original Zoom schreiben
	if (ZM2Addr) Poke(gamePROC,ZM2Addr,&ZM2Org,sizeof(ZM2Org));
	Poke(gamePROC,NSAddr,&NSOrg,sizeof(NSOrg)); // No Sky

}

BOOL Initialize(){
	hooksInjected=(InjectDLL(hookDll,gamePID));
	if (hooksInjected) SetStatusText("Anti SS injected");
	AttachGame();
	if (gameRunning){
		Sleep(500);
		ReadOriginalCode();
	}
	return TRUE;
}

BOOL Deinitialize(){
	DisableAllHax();
	CloseHandle(gamePROC);
	return TRUE;
}

//////////////////////////////////////////////////////////////////////////////////////////

void AttachGame() {// Diese Procedure sorgt dafür das der Prozess immer geöffnet ist um darin zu schreiben
				   // sollte dieser nicht geöffnet sein dann ist gameRunning FALSE
	CloseHandle(gamePROC);   // altes Handle von OpenProcess schließen
	gamePID = GetPID(gameExe);    // ProcessID von Game ermitteln
	gameDllBase = GetDLLBase(gamePID,gameDll); // Base
	gameRunning = (gamePID != 0);
	if (gameRunning) {
		gamePROC=OpenProcess(PROCESS_ALL_ACCESS,0,gamePID); // BF2 Prozess öffnen und Handle speichern
	}	
}

void TimerProc(){// Diese Procedure wird bei jedem Interval des Timer ausgeführt

	AttachGame();   //Spiel suchen und Prozess öffnen wenn gefunden

	if (!gameRunning){ // solange Spiel nicht läuft, nur diesen Block ausführen
		if (!firstRun){
			firstRun = TRUE; // Wenn der Prozess weg ist erststart wieder TRUE
			DisableAllHax(); // Cheatstaus alle aus
		}
		SetStatusText("Warte auf BF2142..."); // Text im Fenster ändern
		return; // Solange BF2 nicht gefunden wird bricht die Procedure hier ab
	}

	// erstes mal seit Prozessstart hier angekommen und Spiel läuft!
	if (firstRun && gameRunning){ 
		SetStatusText("BF2142 gefunden! 10 sek. warten"); // Text im Fenster ändern
		Sleep(10000); // 20 Sekunden Warten
		Initialize();
		SetStatusText("Hotkeys aktiviert"); // Text im Fenster ändern
		firstRun = FALSE;     // erstesmal auschalten
	}

  ///////////////////////////////////////////////////////////////////////////////////// 
  // Hier wird geprüft ob ein hack an ist und ob er wiederaufgerufen werden soll bei //
  // jedem Intervall z.B. RedDot damit er immer gezeichnet wird                      //
  /////////////////////////////////////////////////////////////////////////////////////

	// Crosshairtest
	Peek(gamePROC,CHAddr,sizeof(CHHack),&CHAkt);
	if ((isCHOn) && (CHHack != CHAkt)) Poke(gamePROC,CHAddr,&CHHack,sizeof(CHHack));  //Hack schreiben

	// Zoomtest
	if (ZM1Addr){
		Peek(gamePROC,ZM1Addr,sizeof(ZMAkt),&ZMAkt); //Aktuellen Zoom Speichern
		//SetDlgItemText(dlg,IDC_STATZM2,(char*) ZMAkt);
		if (ZM1Hack == ZMAkt){
			isZMOn = TRUE;
			SetDlgItemText(dlg,IDC_STATZM,"On");
		}else{
			isZMOn = FALSE;
			SetDlgItemText(dlg,IDC_STATZM,"Off");
		}
	}

	// Commandertest
	if (FCAddr){
		Peek(gamePROC,FCAddr,sizeof(FCHack),&FCAkt);
		if ((isFCOn) && (FCHack != FCAkt)) Poke(gamePROC,FCAddr,&FCHack,sizeof(FCHack));
	}

ReadProcessMemory(hand,(void*)0xA8BF28,dwBuffer1,sizeof(dwBuffer1),NULL);
ReadProcessMemory(hand,(void*)(dwBuffer1+0x6C),&dwLeaderBase,sizeof(dwLeaderBase),NULL);
dwTeamValue        = dwLeaderBase + 0xD8;

if(GetAsyncKeyState(VK_F10))
    { 
        if(dwTeamValue == 0x01)
        {
WriteProcessMemory(hand,(void*)(dwTeamValue),&two,1,NULL);
        }
        else
        {
WriteProcessMemory(hand,(void*)(dwTeamValue),&one,1,NULL);
        }
}

	else if(GetAsyncKeyState(TeamKey)){  // Team Switch
		Peek(gamePROC,gameExeBase+TSBase,sizeof(tmpBase1), &tmpBase1);// ab Hier Teamswitch
		Peek(gamePROC,tmpBase1+TSAdd1,sizeof(tmpBase2), &tmpBase2);
		TSAddr = tmpBase2 + TSAdd2;
		Peek(gamePROC,TSAddr,sizeof(TSAkt),&TSAkt);
		if (TSAkt==1){
			Poke(gamePROC,TSAddr,&TS2,sizeof(TS2));
		}else
			Poke(gamePROC,TSAddr,&TS1,sizeof(TS1));
	}

	else if (GetAsyncKeyState(VK_DELETE)){ // [Entf]ernen Taste
		DisableAllHax();    // Alle Hacks ausschalten und Originalwerte schreiben
	}
}

BOOL CALLBACK DialogProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){
    switch (message){ // Message übersetzen damit wir abfragen können
	    case WM_INITDIALOG:  // Wird beim erstellen unseres Fensters ausgeführt
			dlg = hwnd;
			SetTimer(hwnd,1001,tmrInterval,NULL);
			return TRUE;  // Funktion beenden und True übergeben
		case WM_COMMAND:  // Wird beim anclicken eines Buttons ausgeführt
			switch (LOWORD(wParam)){  // LOWORD(wParam) enthält die Message
				case IDC_EXIT:  // Exit wurde gedrückt
					EndDialog (hwnd, 0);  // Fenster schließen
					return TRUE;
			}
		    return TRUE;
		case WM_DESTROY:  // Wird beim beenden unseres Programs aufgerufen
			Deinitialize();
			PostQuitMessage(0);  
			return TRUE;
		case WM_CLOSE:  // Wird beim druck auf Ende ausgeführt
			PostQuitMessage(0);
			return TRUE;
		case WM_TIMER:  // Bei jedem Intervall vom Timer wird diese Message versendet
			TimerProc();  // timer ausführen
			return TRUE;
    }
    return FALSE;
}

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow )
{
	DialogBox(hInstance,MAKEINTRESOURCE(IDD_DLGMAIN), NULL,DialogProc); // DialogBox aus einer Resource erstellen mit Callback an DialogProc
	return 0;  // Hier kommt man erst hin wenn die Dialogbox geschlossen wird
}

void SetStatusText(LPCTSTR Text){
	SetDlgItemText(dlg,IDC_STATUSTEXT,Text);
}

#include <windows.h>
#include <procfunc.h>
#include <tlhelp32.h>
/

BOOL  Peek(HANDLE gamePROC,DWORD Address, DWORD Count,void * save){
// Diese Function Liest aus dem Speicher des Prozesses "proc" ab der Addresse "Address"
// "Count" Bytes und speichert diese in "save". Wenn alles erfolgreich ist wird TRUE übergeben
  UINT iRPM;
  DWORD pStateOld, pStateDummy;
  DWORD bw;   //  var für RPM

  iRPM = 0;
  if (gamePROC != 0){// Wenn gefunden
    //rechte im Speicher auf ALL_ACCESS
	if (VirtualProtectEx(gamePROC,(PDWORD)(Address),Count,PAGE_READWRITE,&pStateOld)){
	  // Ab Address Bytes lesen
      iRPM = ReadProcessMemory(gamePROC, (PDWORD)(Address),save, Count, &bw);
      //rechte im Speicher wieder standard
	  VirtualProtectEx(gamePROC,(PDWORD)(Address),Count,pStateOld,&pStateDummy);
	}
  }
  return ((iRPM!=0)&(bw==Count));
}

BOOL Poke(HANDLE gamePROC,DWORD Address, void *write, DWORD Count){
// Diese Function schreibt in den Speicher des Prozesses "proc" ab der Addresse "Address"
// "write".Count ist die große in Bytes. Wenn alles erfolgreich ist wird TRUE übergeben
  UINT iWPM;
  DWORD pStateOld, pStateDummy;
  DWORD bw;   //  var für WPM
  MEMORY_BASIC_INFORMATION mbi;

  iWPM = 0;
  if (gamePROC != 0){// Wenn gefunden
	//Information über den gewählten Speicherbereich holen
	VirtualQueryEx(gamePROC,(PDWORD)Address,&mbi,sizeof(MEMORY_BASIC_INFORMATION));
	//rechte im Speicherbereich auf READWRITE
	if (VirtualProtectEx(gamePROC,(PDWORD)mbi.BaseAddress,mbi.RegionSize,PAGE_READWRITE,&pStateOld)){
	   // Ab Address Bytes schreiben wenn Rechte erfolgreich gesetzt
       iWPM = WriteProcessMemory(gamePROC, (PDWORD)(Address),write, Count, &bw);
       //rechte im Speicherbereich wieder standard
	   VirtualProtectEx(gamePROC,(PDWORD)mbi.BaseAddress,mbi.RegionSize,pStateOld,&pStateDummy);
	}

  }
  return (bw==Count);
}

DWORD GetPID(char *ExeName){
// Diese Funktion gibt die ProzessID von "EXEName" in der Prozessliste zurück
  HANDLE snapProc;  
  PROCESSENTRY32 pe32;

  // Prozess finden
  snapProc = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
  if(snapProc == INVALID_HANDLE_VALUE) return 0; // Wenn kein gültiges Suchhandle dann Funktionsabbruch
  pe32.dwSize = sizeof(PROCESSENTRY32);  // Informationen Initialisieren
  if(Process32First(snapProc,&pe32)){  // Wenn 1. Prozess gefunden
	do{  // Schleifen anfang 
       if (stricmp(ExeName,pe32.szExeFile)==0){; // Ist Prozess.Exename = BF2 dann
	      CloseHandle(snapProc);   // Suchhandle schließen
		  return pe32.th32ProcessID;  // ProcessID übergeben und Funktion beenden
	   }
	} while(Process32Next(snapProc,&pe32));
  } //Sleife solange Prozesse gefunden werden 
  CloseHandle(snapProc);   // Suchhandle schließen
  return 0;
}

DWORD GetDLLBase(DWORD pid,char* DllName){
//Diese Function liest die Base Addresse des Moduls "DLLName" aus dem Prozess mit der ID "pid"
  HANDLE snapMod;  
  MODULEENTRY32 me32;

  // Modul im Prozess finden
  snapMod = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid);  //Suchhandle auf alle Module im Process iProcID
  me32.dwSize = sizeof(MODULEENTRY32);   // Informationen vorbereiten
  if (Module32First(snapMod, &me32)){   // Erstes Modul finden und informationen speichern
    do{   // Solange noch module gefunden werden
        if (stricmp(DllName,me32.szModule) == 0){  // Wenn aktuell gefundenes Modul.Name mit übergebenem DLLName übereinstimmt
          CloseHandle(snapMod);  //Suchhandle schließen
          return (DWORD) me32.modBaseAddr;  // Dll Base Addresse speichern
        }
    }while(Module32Next(snapMod,&me32));
  }
  // Hier kommt man nur an wenn das Modul nicht gefunden wurde
  CloseHandle(snapMod); // Suchhandle schließen
  return 0;   // 0 übergeben
}

BOOL InjectDLL(LPCTSTR sLibName,DWORD dwProcID){
// Diese Function Injeziert ein Modul "sLibName" in den Prozess mit der ID "dwProcID"
// Wenn erfolgreich injeziert wird TRUE übergeben
  DWORD dwLLA,dwTID,dwMemSize,dwTargetMemory,hMod;
  HANDLE hProc,hThread;
  char fullLibName[MAX_PATH];

  // Wenn die DLL bereits im Prozess Procedure beenden
  if (GetDLLBase(dwProcID,(char *)sLibName)!=0) return TRUE;
  // Prozess öffnen mit vollzugriff
  hProc = OpenProcess(PROCESS_ALL_ACCESS,FALSE,dwProcID);
  if (!hProc){
	 return FALSE;
  }
  // kompletter Pfad und dateiname ermitteln
  if (SearchPath(NULL,sLibName,NULL,MAX_PATH,fullLibName,0)){
    // Größe des vollen Dll-Namens ermitteln 

	dwMemSize = strlen(fullLibName)+1;
  }else return FALSE;
  // Speicher im Game für DllName reservieren
  dwTargetMemory = (DWORD) VirtualAllocEx(hProc,NULL,dwMemSize,MEM_COMMIT,PAGE_EXECUTE_READWRITE);
  // Addresse der Function LoadLibrary ermitteln
  dwLLA = (DWORD) GetProcAddress(GetModuleHandleA("kernel32.dll"),"LoadLibraryA");
  // Wenn Addresse gefunden und Speicher allokiert
  if ((dwLLA!=0) & (dwTargetMemory!=0)){
    // Modulname in Prozess schreiben
	Poke(hProc,dwTargetMemory,(void *)fullLibName,dwMemSize);
	// Thread im Process Prozess starten der LoadLibrary ausführt
	hThread = CreateRemoteThread(hProc,NULL,0, (void *)dwLLA,(void *)dwTargetMemory,0,&dwTID);
    // auf den Thread warten bis er fertig ist
	WaitForSingleObject(hThread,INFINITE);
	// LoadLibrary erfolgreich?
	GetExitCodeThread(hThread,&hMod);
	// Handle des Threads schließen
	CloseHandle(hThread);
  }
  // Speicher und Handles schließen
  if (dwTargetMemory) VirtualFreeEx(hProc,(PDWORD)dwTargetMemory,dwMemSize,MEM_DECOMMIT);
  if (hProc)CloseHandle(hProc);
  // Wenn DLL in Prozess TRUE übergeben
  if (GetDLLBase(dwProcID,(char *)sLibName)!=0) return TRUE;
  return FALSE;
}

BOOL EjectDLL(LPCTSTR sLibName,DWORD dwProcID){
// Diese Function Entlädt das Modul "sLibName" in den Prozess mit der ID "dwProcID"
// Wenn erfolgreich entladen wird TRUE übergeben
  DWORD dwFL,dwTID;
  PBYTE dwModuleHandle = 0;
  DWORD dwCRTResult;
  HANDLE hProc,hThread;

  // DLLBase (DWORD) als PBYTE schreiben
  dwModuleHandle=(PBYTE) GetDLLBase(dwProcID,(char *)sLibName);
  // Wenn die DLL bereits im Prozess beendet
  if (!dwModuleHandle) return TRUE;
  // Prozess öffnen mit vollzugriff
  hProc = OpenProcess(PROCESS_ALL_ACCESS,FALSE,dwProcID);
  if (!hProc) return FALSE;

  // Addresse der Function FreeLibrary ermitteln
  dwFL = (DWORD) GetProcAddress(GetModuleHandleA("kernel32.dll"),"FreeLibrary");
  if ((dwFL) && (dwModuleHandle)){
    // Thread im Process Prozess starten der LoadLibrary ausführt
    hThread = CreateRemoteThread(hProc,NULL,0, (void *)dwFL,(void*)dwModuleHandle,0,&dwTID);
    // auf den Thread warten bis er fertig ist
    WaitForSingleObject(hThread,INFINITE);
    // Ergebnis
    GetExitCodeThread(hThread,&dwCRTResult);
    // Handle des Threads schließen
    CloseHandle(hThread);
  }
  // Speicher und Handles schließen
  if (hProc)CloseHandle(hProc);
  // Wenn DLL in Prozess TRUE übergeben
  if (!GetDLLBase(dwProcID,(char *)sLibName)) return TRUE;
  return FALSE;
}

BOOL MemCopyEx(HANDLE hProcess,DWORD dwFrom,DWORD dwTo,DWORD dwSize){
// Diese Function kopiert im Prozess "hProcess" den Bereich ab "dwFrom" mit der 
// größe "dwSize" an die Addresse "dwTo" und übergibt TRUE wenn erfolgreich

  //Speicher für Buffer reservieren
  PBYTE dwBuffer = (PBYTE)VirtualAlloc(0,dwSize,MEM_COMMIT,PAGE_READWRITE);
  // Lesen und Zweischenspeichern
  if (Peek(hProcess,dwFrom,dwSize,dwBuffer)){
	// Zwischenspeicher schreiben
	if (Poke(hProcess,dwTo,dwBuffer,dwSize)){
	  // Zwischenspeicher leeren
	  VirtualFree(dwBuffer,dwSize,MEM_RELEASE);
	  // Function beenden
	  return TRUE;
    }
  }
  // Zwischenspeicher leeren
  VirtualFree(dwBuffer,dwSize,MEM_RELEASE);
  return FALSE;
}

DWORD CreateCopy(DWORD dwBase, DWORD dwSize){
// Diese Function kopiert im aktuellen Prozess den Bereich "dwBase" mit der größe "dwSize"
// und übergibt wenn erfolgreich die Addresse an die es kopiert worden ist

  //Speicher für Buffer reservieren
  PBYTE dwBuffer = (PBYTE)VirtualAlloc(0,dwSize,MEM_COMMIT,PAGE_READWRITE);
  if (!dwBuffer) return 0;
  //Speicher lesen und speichern
  if (Peek(GetCurrentProcess(),dwBase,dwSize,dwBuffer)){
	// Zwischenspeicher leeren
	VirtualFree(dwBuffer,dwSize,MEM_RELEASE);
	// Addresse des gespeicherten zurückgeben
	return (DWORD) dwBuffer;
  }
  // Zwischenspeicher leeren
  VirtualFree(dwBuffer,dwSize,MEM_RELEASE);
  return 0;
}

DWORD CreateCopyEx(HANDLE hProcess, DWORD dwBase, DWORD dwSize){
// Diese Function kopiert im Prozess "hProcess" den Bereich "dwBase" mit der größe "dwSize"
// und übergibt wenn erfolgreich die Addresse an die es kopiert worden ist
  DWORD dwBufferAddr;

  //Speicher für Buffer reservieren
  dwBufferAddr = (DWORD) VirtualAllocEx(hProcess,0,dwSize,MEM_COMMIT,PAGE_READWRITE);
  if (!dwBufferAddr) return 0;
  //Speicher kopieren
  if (MemCopyEx(hProcess,dwBase,dwBufferAddr,dwSize)){
    return (DWORD) dwBufferAddr;
  }
  // Zwischenspeicher leeren
  return 0;
}

BOOL DeleteCopy(DWORD dwBase, DWORD dwSize){
 return VirtualFree((PDWORD) dwBase,dwSize, MEM_RELEASE);
}

BOOL DeleteCopyEx(HANDLE hProcess, DWORD dwBase, DWORD dwSize){
 return VirtualFreeEx(hProcess,(PDWORD) dwBase,dwSize, MEM_DECOMMIT);
}

BOOL LoadSeDebugPrivilege(){
  HANDLE hToken;
  LUID Val;
  TOKEN_PRIVILEGES tp;

  if (!OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
     return(FALSE);
  if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &Val))
     return(FALSE);
  tp.PrivilegeCount = 1;
  tp.Privileges[0].Luid = Val;
  tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
  if (!AdjustTokenPrivileges(hToken,FALSE,&tp,sizeof(tp),NULL,NULL))
	 return(FALSE);
  CloseHandle(hToken);
  return TRUE;
}

void HideModule(HINSTANCE hModule)
{
	DWORD dwPEB_LDR_DATA = 0;
	_asm
	{
		pushad;
		pushfd;
		mov eax, fs:[30h]		   // PEB
		mov eax, [eax+0Ch]		  // PEB->ProcessModuleInfo
		mov dwPEB_LDR_DATA, eax	 // Save ProcessModuleInfo

InLoadOrderModuleList:
		mov esi, [eax+0Ch]					  // ProcessModuleInfo->InLoadOrderModuleList[FORWARD]
		mov edx, [eax+10h]					  //  ProcessModuleInfo->InLoadOrderModuleList[BACKWARD]

		LoopInLoadOrderModuleList: 
		    lodsd							   //  Load First Module
			mov esi, eax		    			//  ESI points to Next Module
			mov ecx, [eax+18h]		    		//  LDR_MODULE->BaseAddress
			cmp ecx, hModule		    		//  Is it Our Module ?
			jne SkipA		    		    	//  If Not, Next Please (@f jumps to nearest Unamed Lable @@:)
		    	mov ebx, [eax]				  //  [FORWARD] Module 
		    	mov ecx, [eax+4]    		    	//  [BACKWARD] Module
		    	mov [ecx], ebx				  //  Previous Module's [FORWARD] Notation, Points to us, Replace it with, Module++
		    	mov [ebx+4], ecx			    //  Next Modules, [BACKWARD] Notation, Points to us, Replace it with, Module--
			jmp InMemoryOrderModuleList		//  Hidden, so Move onto Next Set
		SkipA:
			cmp edx, esi					    //  Reached End of Modules ?
			jne LoopInLoadOrderModuleList		//  If Not, Re Loop

InMemoryOrderModuleList:
		mov eax, dwPEB_LDR_DATA		  //  PEB->ProcessModuleInfo
		mov esi, [eax+14h]			   //  ProcessModuleInfo->InMemoryOrderModuleList[START]
		mov edx, [eax+18h]			   //  ProcessModuleInfo->InMemoryOrderModuleList[FINISH]

		LoopInMemoryOrderModuleList: 
			lodsd
			mov esi, eax
			mov ecx, [eax+10h]
			cmp ecx, hModule
			jne SkipB
				mov ebx, [eax] 
				mov ecx, [eax+4]
				mov [ecx], ebx
				mov [ebx+4], ecx
				jmp InInitializationOrderModuleList
		SkipB:
			cmp edx, esi
			jne LoopInMemoryOrderModuleList

InInitializationOrderModuleList:
		mov eax, dwPEB_LDR_DATA				    //  PEB->ProcessModuleInfo
		mov esi, [eax+1Ch]						 //  ProcessModuleInfo->InInitializationOrderModuleList[START]
		mov edx, [eax+20h]						 //  ProcessModuleInfo->InInitializationOrderModuleList[FINISH]

		LoopInInitializationOrderModuleList: 
			lodsd
			mov esi, eax		
			mov ecx, [eax+08h]
			cmp ecx, hModule		
			jne SkipC
				mov ebx, [eax] 
				mov ecx, [eax+4]
				mov [ecx], ebx
				mov [ebx+4], ecx
				jmp Finished
		SkipC:
			cmp edx, esi
			jne LoopInInitializationOrderModuleList

		Finished:
			popfd;
			popad;
	}
}

So jetzt hab ich es richitg.Es soll zwar ein hack werden aber nur für Singelplayer.

Badestrand

Setz mal deine eigenen Dateien, also resource.h und procfunc.h in Anführungsstrichelchen:

#include "resource.h"
#include "procfunc.h"

Ok habs gemacht und jetzt kommem wieder Fehler.

------ Erstellen gestartet: Projekt: DMA HÄXXN, Konfiguration: Debug Win32 ------
Kompilieren...
main.c
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\cheats.h(27) : error C2054: Nach 'Variablendeklarationen' muss '(' folgen
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\cheats.h(27) : error C2085: 'firstRun': Nicht in der formalen Parameterliste enthalten
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\cheats.h(27) : error C2143: Syntaxfehler: Es fehlt ';' vor '='
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\main.c(5) : fatal error C1083: Datei (Include) kann nicht geöffnet werden: "log.h": No such file or directory
procfunc.c
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\procfunc.c(76) : warning C4996: 'stricmp' wurde als veraltet deklariert
c:\programme\microsoft visual studio 8\vc\include\string.h(213): Siehe Deklaration von 'stricmp'
Meldung: "The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: _stricmp. See online help for details."
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\procfunc.c(96) : warning C4996: 'stricmp' wurde als veraltet deklariert
c:\programme\microsoft visual studio 8\vc\include\string.h(213): Siehe Deklaration von 'stricmp'
Meldung: "The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: _stricmp. See online help for details."
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\procfunc.c(343) : warning C4102: 'InLoadOrderModuleList': Unreferenzierte Marke
Code wird generiert...
Das Buildprotokoll wurde unter "file://c:\Dokumente und Einstellungen\keller\Desktop\Neuer Ordner\Neuer Ordner\DMA_HÄXXN___Win32_Debug\BuildLog.htm" gespeichert.
DMA HÄXXN - 4 Fehler, 3 Warnung(en)
========== Erstellen: 0 erfolgreich, Fehler bei 1, 0 aktuell, 0 übersprungen ==========

CStoll

Erstmal: Kannst du mal dazusagen, welche der oben angegebenen Dateien welche ist (und du cheats.h dazugeben)?

Zweitens: Hast du zufällig etwas mit dem User "Chenoa" zu tun? (die letzten Warnmeldungen kommen mir irgendwie bekannt vor)

Drittens: Schreibst du eigentlich C oder C++? Wenn ersteres, würde ich dich eine Etage höher verschieben.

Badestrand

Erwin schrieb:

c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\cheats.h(27) : error C2054: Nach 'Variablendeklarationen' muss '(' folgen
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\cheats.h(27) : error C2085: 'firstRun': Nicht in der formalen Parameterliste enthalten
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\cheats.h(27) : error C2143: Syntaxfehler: Es fehlt ';' vor '='

Diese Fehler müsstest du auch selbst raushauen können, schließlich steht Zeilennummer und Begründung dabei...

CStoll schrieb:

Erstmal: Kannst du mal dazusagen, welche der oben angegebenen Dateien welche ist (und du cheats.h dazugeben)?

Zweitens: Hast du zufällig etwas mit dem User "Chenoa" zu tun? (die letzten Warnmeldungen kommen mir irgendwie bekannt vor)

Drittens: Schreibst du eigentlich C oder C++? Wenn ersteres, würde ich dich eine Etage höher verschieben.

Ja ich kenne ihn von eine Page.Da gibts source codes.Ich schätze die hat er auch genommen

Ich schreib in C++.Sry solte eig. Kein doppelpost werden.Das erste ist main.c das zweite ist procfunc.c

ok 3 fehler nur noch die ich aber nicht weg bekomme

----- Erstellen gestartet: Projekt: DMA HÄXXN, Konfiguration: Debug Win32 ------
Kompilieren...
main.c
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\cheats.h(27) : error C2054: Nach 'Variablendeklarationen' muss '(' folgen
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\main.c(27) : error C2449: '{' auf Dateiebene gefunden - fehlt der Funktionskopf?
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\main.c(261) : fatal error C1004: Unerwartetes Dateiende gefunden.
Das Buildprotokoll wurde unter "file://c:\Dokumente und Einstellungen\keller\Desktop\Neuer Ordner\Neuer Ordner\DMA_HÄXXN___Win32_Debug\BuildLog.htm" gespeichert.
DMA HÄXXN - 3 Fehler, 0 Warnung(en)
========== Erstellen: 0 erfolgreich, Fehler bei 1, 0 aktuell, 0 übersprungen ==========

Wenn ich bei der ersten fehler meldung ne { setze geht es immer noch nicht

ok hab nur noch einen fehler

.\rsrc.rc(10) : fatal error RC1015: cannot open include file 'afxres.h'.

Sry wegen meine doppelpost kann einer sie löschen?

Hi

Ich glaube du benutzt VC++ Express dan kann er es nicht.(Stimmt das?)

das ist ein Multiplayer hack, das erkennt man an zbsp. crosshair usw... und CSS und DoD_Source(parameter..)

Helft ihm bloss net, cheater an die Wand!

mad_martin

Ich glaube kaum, dass da Gefahr besteht.