Solved What ya thinkk?

Hexui Undetected CSGO Cheats Sinkicheat PUBG Cheat

Roman_Ablo

Banned
Feb 27, 2017
355
2,402
1
So I'm trying to work on a header for myself (enough have been released already :D)
I'm looking to get some feedback on mine, I coded it in like 30 minutes aprox. in total (2 different days).

xScore.cpp
C++:
#include "xHead.h"
#include <iostream>
#include <cstdlib>
#include <string>
#include <string.h>
#include <signal.h>
#include <windows.h>
#include <tlhelp32.h>
#include <conio.h>

int xScore::GetProcessID(const wchar_t *Process) {
	PROCESSENTRY32 Entry32;
	Entry32.dwSize = sizeof(PROCESSENTRY32);
	HANDLE Snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
	if (Process32First(Snapshot, &Entry32) == TRUE) {
		while (Process32Next(Snapshot, &Entry32) == TRUE) {
			if (NULL == wcsncpy(Entry32.szExeFile, Process, Entry32.dwSize)) {
				return Entry32.th32ProcessID;
			}
		}
	}
	CloseHandle(Snapshot);
}

int xScore::GetProcessModule(const char *Process, DWORD PID){
	HANDLE Snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, PID);
	MODULEENTRY32 Entry32;
	Entry32.dwSize = sizeof(MODULEENTRY32);
	if (!Snapshot) {
		CloseHandle(Snapshot);
		raise(SIGILL);
	}
	if (!Process) {
		CloseHandle(Snapshot);
		raise(SIGILL);
	}
	if (!PID) {
		CloseHandle(Snapshot);
		raise(SIGILL);
	}
	BOOL First = Module32First(Snapshot, &Entry32);
	while (First){
		if (Entry32.th32ProcessID == PID && !strcmp(Process, reinterpret_cast<const char*>(Entry32.szModule))){
			CloseHandle(Snapshot);
			return *reinterpret_cast<DWORD*>(Entry32.hModule);
		}
		First = Module32Next(Snapshot, &Entry32);
	}
	CloseHandle(Snapshot);
}

BOOL xScore::Launch(const char *Path, unsigned int Instances) {
	struct stat Dir;
	unsigned int i;
	if (stat(Path, &Dir) != 0) return FALSE;
	else {
		for (i; i < Instances; i++) {
			LPCTSTR lpD = (LPCTSTR)Path;
			STARTUPINFO lpS = { sizeof(lpS) };
			PROCESS_INFORMATION lpP;
			if (CreateProcess(lpD, nullptr, nullptr, nullptr, TRUE, NULL, nullptr, nullptr, &lpS, &lpP)) {
				WaitForSingleObject(lpP.hProcess, 10);
				CloseHandle(lpP.hProcess);
				CloseHandle(lpP.hThread);
			}
			i += i;
			Sleep(1000);
			if (i == Instances) {
				break;
				return TRUE;
			}
		}
	}
}

int xScore::SetPrivilege(LPCWSTR zName, BOOL zStatus) {
	unsigned int zCheck = NULL;
	HANDLE zToken;
	if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES, &zToken)) raise(SIGSEGV);
	TOKEN_PRIVILEGES zPrivileges;
	zPrivileges.PrivilegeCount = 1;
	zPrivileges.Privileges[0].Attributes == zStatus ? SE_PRIVILEGE_ENABLED : zCheck == zCheck;
	if (!LookupPrivilegeValueW(NULL, zName, &zPrivileges.Privileges[0].Luid)) {
		CloseHandle(zToken);
		raise(SIGILL);
	}
	if (!AdjustTokenPrivileges(zToken, FALSE, &zPrivileges, sizeof(TOKEN_PRIVILEGES), nullptr, nullptr)) {
		CloseHandle(zToken);
		raise(SIGILL);
	}
	CloseHandle(zToken);
}

template<typename WRITE_TYPE>
void xScore::WriteMemory(UINT_PTR Address, WRITE_TYPE Value, BOOL Overloaded, DWORD PID) {
	HANDLE zProcess = OpenProcess(WRITE_OWNER, FALSE, PID);
	if (Overloaded == 1 || TRUE) {
		WriteProcessMemory(zProcess, reinterpret_cast<void*>(Address), &Value, sizeof(Value), nullptr);
	}
	else if (Overloaded == 0 || FALSE) {
		WriteProcessMemory(zProcess, (void*)Address, &Value, sizeof(Value), NULL);
	}
	else {
		WriteProcessMemory(zProcess, (void*)Address, &Value, sizeof(Value), NULL);
	}
}

void xScore::PatchMemory(UINT_PTR Address, BYTE Bytes, BOOL Overloaded, DWORD PID) {
	HANDLE zProcess = OpenProcess(WRITE_OWNER, FALSE, PID);
	if (Overloaded == 1 || TRUE) {
		WriteProcessMemory(zProcess, reinterpret_cast<void*>(Address), &Bytes, sizeof(Bytes), nullptr);
	}
	else if (Overloaded == 0 || FALSE) {
		WriteProcessMemory(zProcess, (void*)Address, &Bytes, sizeof(Bytes), NULL);
	}
	else {
		WriteProcessMemory(zProcess, (void*)Address, &Bytes, sizeof(Bytes), NULL);
	}
}

int xScore::ReadMemory(UINT_PTR Address, BOOL Overloaded, DWORD PID) {
	HANDLE zProcess = OpenProcess(READ_CONTROL, FALSE, PID);
	UINT zValue;
	if (Overloaded == 1 || TRUE) {
		ReadProcessMemory(zProcess, reinterpret_cast<void*>(Address), &zValue, sizeof(zValue), nullptr);
	}
	else if (Overloaded == 0 || FALSE) {
		ReadProcessMemory(zProcess, (void*)Address, &zValue, sizeof(zValue), NULL);
	}
	else {
		ReadProcessMemory(zProcess, (void*)Address, &zValue, sizeof(zValue), NULL);
	}
	return zValue;
}

BOOL xScore::IsProcessActive(HANDLE Process) {
	if (!Process) return FALSE;
	DWORD dwFlags = NULL;
	if (!GetHandleInformation(Process, &dwFlags)) return FALSE;
	if (WaitForSingleObject(Process, 0) == WAIT_TIMEOUT) return FALSE;
	return TRUE;
}

void xScore::GenerateKey(UINT VritualKey, UINT Times) {
	KEYBDINPUT KeyboardIn = { 0 };
	INPUT Input = { 0 };

	KeyboardIn.wVk = VritualKey;
	Input.type = INPUT_KEYBOARD;
	Input.ki = KeyboardIn;
	SendInput(Times, &Input, sizeof(Input));

	RtlZeroMemory(&KeyboardIn, sizeof(KEYBDINPUT));
	RtlZeroMemory(&Input, sizeof(INPUT));
	KeyboardIn.dwFlags = KEYEVENTF_KEYUP;

	KeyboardIn.wVk = VritualKey;
	Input.type = INPUT_KEYBOARD;
	Input.ki = KeyboardIn;
	SendInput(Times, &Input, sizeof(Input));
}
xScore.h
C++:
#pragma once
#ifndef XSCORE
#define XSCORE
#include <iostream>
#include <cstdlib>
#include <string>
#include <string.h>
#include <signal.h>
#include <windows.h>
#include <tlhelp32.h>

class xScore {
private:

public:
	int GetProcessID(const wchar_t *Process);
	BOOL Launch(const char *Path, unsigned int Instances);
	int SetPrivilege(LPCWSTR zName, BOOL zStatus);
	template<typename WRITE_TYPE>
	void WriteMemory(UINT_PTR Address, WRITE_TYPE Value, BOOL Overloaded, DWORD PID);
	void PatchMemory(UINT_PTR Address, BYTE Bytes, BOOL Overloaded, DWORD PID);
	int ReadMemory(UINT_PTR Address, BOOL Overloaded, DWORD PID);
	int GetProcessModule(const char *Process, DWORD PID);
	BOOL IsProcessActive(HANDLE Process);
	void GenerateKey(UINT VritualKey, UINT Times);
};

#endif
What ya think?
 

Broihon

edgy 12 y/o
Escobar Tier VIP
Fleep Tier Donator
Dec 22, 2013
1,746
40,528
316
Overall nice clean code. I have a few questions though.
To me the if statements in WriteMemory/PatchMemory/ReadMemory don't add up since if (Overloaded == 1 || TRUE) will always be true and the else if/else won't be executed.
Also don't forget to close those process handles or pass them as another argument and let the caller manage the handles.

Then this line:
zPrivileges.Privileges[0].Attributes == zStatus ? SE_PRIVILEGE_ENABLED : zCheck == zCheck;
should probably look like this:
zPrivileges.Privileges[0].Attributes == zStatus ? SE_PRIVILEGE_ENABLED : 0;
SE_PRIVILEGE_ENABLED is defined as 2. zCheck == zCheck will always be 1 (even if you declare it as NULL) and SE_PRIVILEGE_ENABLED_BY_DEFAULT is defined as 1.
My guess is that the zStatus argument is supposed to enable/disable the privilege. To disable a privilege the Attributes member of the token privilege must be 0.

In GetProcessID you forget to close the snapshot handle and if the process isn't active no return value is defined (don't ignore all those compiler warnings).

I bet half of the includes are useless and it'd be nice to have not that many void functions but functions which return true/false or error codes to check if the succeeded or not.

Last thing I want to mention is that I don't see a point in using a class at this state. There aren't any member values. A normal namespace would be more efficient at the moment.
 

Rake

Cesspool Admin
Administrator
Jan 21, 2014
12,153
78,998
2,396
Always cool to see someone else's methods, thanks for sharing
 

Roman_Ablo

Banned
Feb 27, 2017
355
2,402
1
To me the if statements in WriteMemory/PatchMemory/ReadMemory don't add up since if (Overloaded == 1 || TRUE) will always be true and the else if/else won't be executed.
My brain cannot process why this is, sorry :(

Then this line:
zPrivileges.Privileges[0].Attributes == zStatus ? SE_PRIVILEGE_ENABLED : zCheck == zCheck;
should probably look like this:
zPrivileges.Privileges[0].Attributes == zStatus ? SE_PRIVILEGE_ENABLED : 0;
SE_PRIVILEGE_ENABLED is defined as 2. zCheck == zCheck will always be 1 (even if you declare it as NULL) and SE_PRIVILEGE_ENABLED_BY_DEFAULT is defined as 1.
My guess is that the zStatus argument is supposed to enable/disable the privilege. To disable a privilege the Attributes member of the token privilege must be 0.
Yes. When I coded this, the zCheck == zCheck line is supposed to be like a do nothing line and move on, my bad.

In GetProcessID you forget to close the snapshot handle and if the process isn't active no return value is defined (don't ignore all those compiler warnings).
Ah yes, I didn't think it would be a problem but fixed regardless :)

I bet half of the includes are useless and it'd be nice to have not that many void functions but functions which return true/false or error codes to check if the succeeded or not.

Last thing I want to mention is that I don't see a point in using a class at this state. There aren't any member values. A normal namespace would be more efficient at the moment.
Besides the string ones (which I was planning to use), they aren't.


Here's the new codens:

C++:
#include <iostream>
#include <cstdlib>
#include <signal.h>
#include <windows.h>
#include <tlhelp32.h>
#include <conio.h>

namespace xScore {
	int GetProcessID(const wchar_t *Process) {
		HWND zWind = FindWindowW(NULL, Process);
		if (!zWind) return FALSE;
		PROCESSENTRY32 Entry32;
		Entry32.dwSize = sizeof(PROCESSENTRY32);
		HANDLE Snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
		if (Process32First(Snapshot, &Entry32) == TRUE) {
			while (Process32Next(Snapshot, &Entry32) == TRUE) {
				if (NULL == wcsncpy(Entry32.szExeFile, Process, Entry32.dwSize)) {
					return Entry32.th32ProcessID;
				}
				CloseHandle(Snapshot);
			}
		}
		CloseHandle(Snapshot);
	}

	int GetProcessModule(const char *Process, DWORD PID) {
		HANDLE Snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, PID);
		MODULEENTRY32 Entry32;
		Entry32.dwSize = sizeof(MODULEENTRY32);
		if (!Snapshot) {
			CloseHandle(Snapshot);
			raise(SIGILL);
		}
		if (!Process) {
			CloseHandle(Snapshot);
			raise(SIGILL);
		}
		if (!PID) {
			CloseHandle(Snapshot);
			raise(SIGILL);
		}
		BOOL First = Module32First(Snapshot, &Entry32);
		while (First) {
			if (Entry32.th32ProcessID == PID && !strcmp(Process, reinterpret_cast<const char*>(Entry32.szModule))) {
				CloseHandle(Snapshot);
				return *reinterpret_cast<DWORD*>(Entry32.hModule);
			}
			First = Module32Next(Snapshot, &Entry32);
		}
		CloseHandle(Snapshot);
	}

	BOOL Launch(const char *Path, unsigned int Instances) {
		struct stat Dir;
		unsigned int i;
		if (stat(Path, &Dir) != 0) return FALSE;
		else {
			for (i; i < Instances; i++) {
				LPCTSTR lpD = (LPCTSTR)Path;
				STARTUPINFO lpS = { sizeof(lpS) };
				PROCESS_INFORMATION lpP;
				if (CreateProcess(lpD, nullptr, nullptr, nullptr, TRUE, NULL, nullptr, nullptr, &lpS, &lpP)) {
					WaitForSingleObject(lpP.hProcess, 10);
					CloseHandle(lpP.hProcess);
					CloseHandle(lpP.hThread);
				}
				i += i;
				Sleep(1000);
				if (i == Instances) {
					break;
					return TRUE;
				}
			}
		}
	}

	int SetPrivilege(LPCWSTR zName, BOOL zStatus) {
		unsigned int zCheck = NULL;
		HANDLE zToken;
		if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES, &zToken)) raise(SIGSEGV);
		TOKEN_PRIVILEGES zPrivileges;
		zPrivileges.PrivilegeCount = 1;
		zPrivileges.Privileges[0].Attributes == zStatus ? SE_PRIVILEGE_ENABLED : 0;
		if (!LookupPrivilegeValueW(NULL, zName, &zPrivileges.Privileges[0].Luid)) {
			CloseHandle(zToken);
			raise(SIGILL);
		}
		if (!AdjustTokenPrivileges(zToken, FALSE, &zPrivileges, sizeof(TOKEN_PRIVILEGES), nullptr, nullptr)) {
			CloseHandle(zToken);
			raise(SIGILL);
		}
		CloseHandle(zToken);
	}

	template<typename WRITE_TYPE>
	BOOL WriteMemory(UINT_PTR Address, WRITE_TYPE Value, BOOL Overloaded, DWORD PID) {
		HANDLE zProcess = OpenProcess(WRITE_OWNER, FALSE, PID);
		if (Overloaded == 1 || TRUE) {
			if (!WriteProcessMemory(zProcess, reinterpret_cast<void*>(Address), &Value, sizeof(Value), nullptr)) {
				CloseHandle(zProcess);
				return FALSE;
			}
			return TRUE;
		}
		else if (Overloaded == 0 || FALSE) {
			if (!WriteProcessMemory(zProcess, (void*)Address, &Value, sizeof(Value), NULL)) {
				CloseHandle(zProcess);
				return FALSE;
			}
			return TRUE;
		}
		else {
			if (!WriteProcessMemory(zProcess, (void*)Address, &Value, sizeof(Value), NULL)) {
				CloseHandle(zProcess);
				return FALSE;
			}
			return TRUE;
		}
		CloseHandle(zProcess);
		Value = NULL;
	}

	BOOL PatchMemory(UINT_PTR Address, BYTE Bytes, BOOL Overloaded, DWORD PID) {
		HANDLE zProcess = OpenProcess(WRITE_OWNER, FALSE, PID);
		if (Overloaded == 1 || TRUE) {
			if (!WriteProcessMemory(zProcess, reinterpret_cast<void*>(Address), &Bytes, sizeof(Bytes), nullptr)) {
				CloseHandle(zProcess);
				return FALSE;
			}
			return TRUE;
		}
		else if (Overloaded == 0 || FALSE) {
			if (!WriteProcessMemory(zProcess, (void*)Address, &Bytes, sizeof(Bytes), NULL)) {
				CloseHandle(zProcess);
				return FALSE;
			}
			return TRUE;
		}
		else {
			if (!WriteProcessMemory(zProcess, (void*)Address, &Bytes, sizeof(Bytes), NULL)) {
				CloseHandle(zProcess);
				return FALSE;
			}
			return TRUE;
		}
		CloseHandle(zProcess);
		Bytes = NULL;
	}

	BOOL ReadMemory(UINT_PTR Address, BOOL Overloaded, DWORD PID) {
		HANDLE zProcess = OpenProcess(READ_CONTROL, FALSE, PID);
		UINT zValue;
		if (Overloaded == 1 || TRUE) {
			if (!ReadProcessMemory(zProcess, reinterpret_cast<void*>(Address), &zValue, sizeof(zValue), nullptr)) {
				CloseHandle(zProcess);
				return FALSE;
			}
			return TRUE;
		}
		else if (Overloaded == 0 || FALSE) {
			if (!ReadProcessMemory(zProcess, (void*)Address, &zValue, sizeof(zValue), NULL)) {
				CloseHandle(zProcess);
				return FALSE;
			}
			return TRUE;
		}
		else {
			if (!ReadProcessMemory(zProcess, (void*)Address, &zValue, sizeof(zValue), NULL)) {
				CloseHandle(zProcess);
				return FALSE;
			}
			return TRUE;
		}
		return zValue;
		CloseHandle(zProcess);
		zValue = NULL;
	}

	BOOL IsProcessActive(HANDLE Process) {
		if (!Process) return FALSE;
		DWORD dwFlags = NULL;
		if (!GetHandleInformation(Process, &dwFlags)) return FALSE;
		if (WaitForSingleObject(Process, 0) == WAIT_TIMEOUT) return FALSE;
		return TRUE;
	}
}
 

Rake

Cesspool Admin
Administrator
Jan 21, 2014
12,153
78,998
2,396
in regards to:
(Overloaded == 1 || TRUE)

This will always resolve to true because you're checking if overloaded is 1, OR if TRUE is true, and TRUE is always true...sounds funny but it's...TRUE :smile:
 

mambda

headass
Escobar Tier VIP
Trump Tier Donator
Jun 25, 2014
2,298
37,938
269
youve got a fuckload of useless/redundant includes.

if you #include xscore.h then your .cpp wont need to include everything the header already included.
for a header like that you only need windows.h && tlhelp32.h

C++:
 BOOL IsProcessActive(HANDLE Process) {
        if (!Process) return FALSE;
        DWORD dwFlags = NULL;
        if (!GetHandleInformation(Process, &dwFlags)) return FALSE;
        if (WaitForSingleObject(Process, 0) == WAIT_TIMEOUT) return FALSE;
        return TRUE;
    }
What's the point of using GetHandleInformation, if you dont use dwflags? you can just use the waitforsingleobject for that, checking for WAIT_FAILED i believe.

otherwise well done
 

Roman_Ablo

Banned
Feb 27, 2017
355
2,402
1
mambda, yeah I failed at copypaste, my clipboard has issues somehow smh.

Now I got a question, Broihon said that it in this case a class isn't needed and I'd rather use a namespace.
In what cases is a class needed?

Also, how are these 2 funcs?

C++:
namespace xConsole {
	BOOL Resize(int32_t Width, int32_t Height){
		if (Width == NULL)
			return FALSE;
		if (Height == NULL)
			return FALSE;
		COORD coord;
		coord.X = Width;
		coord.Y = Height;

		SMALL_RECT Rect;
		Rect.Top = 0;
		Rect.Left = 0;
		Rect.Bottom = Height - 1;
		Rect.Right = Width - 1;

		HANDLE Handle = GetStdHandle(STD_OUTPUT_HANDLE);
		if (Handle == nullptr)
			return FALSE;
		if (!SetConsoleScreenBufferSize(Handle, coord))
			return FALSE;
		if (!SetConsoleWindowInfo(Handle, TRUE, &Rect))
			return FALSE;
		return TRUE;
	}

	BOOL SetColor(std::string &Text, int32_t Color, BOOL EndLine) {
		if (Text == "")
			return FALSE;
		if (Color == NULL)
			return FALSE;
		
		if (EndLine == TRUE) {
			HANDLE zOtp = GetStdHandle(STD_OUTPUT_HANDLE);
			if (zOtp == nullptr)
				return FALSE;
			if (!SetConsoleTextAttribute(zOtp, Color))
				return FALSE;
			std::cout << Text << std::endl;
			return FALSE;
		}
		else if (EndLine == FALSE) {
			HANDLE zOtp = GetStdHandle(STD_OUTPUT_HANDLE);
			if (zOtp == nullptr)
				return FALSE;
			if (!SetConsoleTextAttribute(zOtp, Color))
				return FALSE;
			std::cout << Text;
			return FALSE;
		}
		else {
			HANDLE zOtp = GetStdHandle(STD_OUTPUT_HANDLE);
			if (zOtp == nullptr)
				return FALSE;
			if (!SetConsoleTextAttribute(zOtp, Color))
				return FALSE;
			std::cout << Text;
			return FALSE;
		}
	}
}
 
Last edited:

Rake

Cesspool Admin
Administrator
Jan 21, 2014
12,153
78,998
2,396
My thoughts on when to use a class:
Does the class have member variables?
Will having these member variables persistent in the object help the efficiency of your program by not calculating and returning the value on demand?
Is it possible to calculate the data in the member variable on demand?
Will you have multiple objects of this class per instance of the program?
Do you need to pass an object of this class to a function?
Are your member functions going to be needed for 75%+ of the instances of the objects? If not you probably don't need them in your class.

Functions in namespaces act on external data. Member functions typically don't need much input from outside of the member class

Also something to note, as I was adapting my hack framework to different games, using objects and object pointers was a nightmare. When I moved towards namespaces for lots of my logic it was much much much easier to edit and modify

Besides that stuff it's coder style and for speed of coding, if a quick class or namespace solves your problem, why spend all day theory crafting class/namespace designation
 

bYt3_w4LK3r

Jr.Coder
Full Member
Nobleman
Nov 20, 2014
58
283
1
there is something wrong with your get PID func...
you didn't process the information Process32First returned, because after the check if Process32First is good, you suddenly called Process32Next w/o doing something on the struct returned by Process32First. I May Be Wrong Though.
 

Teuvin

now I am become Death
Dank Tier VIP
Trump Tier Donator
Dec 8, 2016
403
10,388
65
I see a lots of
C++:
if(foo == true)
and
C++:
if(NULL == foo)
the last one particularly gives me the creeps, think you can work it out.
 

mambda

headass
Escobar Tier VIP
Trump Tier Donator
Jun 25, 2014
2,298
37,938
269
I see a lots of
C++:
if(foo == true)
and
C++:
if(NULL == foo)
the last one particularly gives me the creeps, think you can work it out.
actually NULL == X is a very common practice. the logic behind it is if you ever forget an =, then it wont compile because obviously you cant set a constant to another value.
 

Roman_Ablo

Banned
Feb 27, 2017
355
2,402
1
there is something wrong with your get PID func...
you didn't process the information Process32First returned, because after the check if Process32First is good, you suddenly called Process32Next w/o doing something on the struct returned by Process32First. I May Be Wrong Though.
you're right, ma bad :(
 

Teuvin

now I am become Death
Dank Tier VIP
Trump Tier Donator
Dec 8, 2016
403
10,388
65
actually NULL == X is a very common practice. the logic behind it is if you ever forget an =, then it wont compile because obviously you cant set a constant to another value.
Well but if you do forget one = inside a if statement the compiler would throw a warning
 

bYt3_w4LK3r

Jr.Coder
Full Member
Nobleman
Nov 20, 2014
58
283
1
about the NULL == foo, I have read it on a book, where it also featured a story about a programming error that transformed a good 10million dollar space rocket into a battered can.
 

Rake

Cesspool Admin
Administrator
Jan 21, 2014
12,153
78,998
2,396
about the NULL == foo, I have read it on a book, where it also featured a story about a programming error that transformed a good 10million dollar space rocket into a battered can.
Yeah they wrote/cast a 64 bit value into a 16 bit value :( woopsies

and it cost $630 million in current dollar value, with inflation
 
Attention! Before you post:

Read the How to Ask Questions Guide
99% of questions are answered in the Beginner's Guide, do it before asking a question.

No Hack Requests. Post in the correct section.  Search the forum first. Read the rules.

How to make a good post:

  • Fill out the form correctly
  • Tell us the game name & coding language
  • Post everything we need to know to help you
  • Ask specific questions, be descriptive
  • Post errors, line numbers & screenshots
  • Post code snippets using code tags
  • If it's a large project, zip it up and attach it

If you do not comply, your post may be deleted.  We want to help, please make a good post and we will do our best to help you.

Community Mods