Coding practices?

[lolp1]

*New to developing stuff, sorry if the question is too general/noobish.
A little general of a question/discussion for this section but I have found it to be one of the best resources for game 'hacking' related coding so I hope no one minds.

Anyways, does anyone have any advice/links to share that relate to good/solid coding practices in relation to developing game hacks/bots? For example, one habit I picked up is to name classes/enums/etc to the actual names the game uses for those structures or what ever.

A lot of people including myself tend to just make up their own random names for no reason, and it only seems to serve to confuse anyone who works on your code or even your self.

I'm also still unsure about enums(C#). I feel like I should really not be using them for integer offsets, but most do. Is there anything wrong with just a good old fashion static Offsets class with the offsets as readonly or const ints, and saving enums for actual types/etc?

So, I'm not really referring to general coding patterns - but more so what kind of habits should I be getting into related to developing game tools in general. Thanks ahead of time. : )

[Jadd]

Enums are not a great choice for offsets. Seeing as they're constant, you'll need to rebase them every time you use them. They're even worse to use in C# because of the way enum types work. IntPtr is your best option and you should rebase them once. Example:

private static bool _initialized;

internal static IntPtr
    Offset1     = (IntPtr) 0x11223344,
    Offset2     = (IntPtr) 0x55667788;

internal static void Initialize() {
    if (_initialized)
        return;

    var mainModule = ...;
    Rebase(mainModule, ref Offset1);
    Rebase(mainModule, ref Offset2);

    _initialized = true;
}

private static void Rebase(IntPtr baseAddress, ref IntPtr address) {
    address = (IntPtr)(baseAddress + address.ToInt64());
}

Also viable:

internal static readonly IntPtr
    Offset1,
    Offset2;

static Offsets() {
    var mainModule = ...;
    Offset1 = mainModule + 0x11223344;
    Offset2 = mainModule + 0x55667788;
}

I use the former because the base address is not necessarily ready before the static constructor is called. Whichever works best for you, you should use.

[Confucius]

As far as naming goes, just remember to comment your code if you are having trouble remembering what each name is for.

[lolp1]

As far as naming goes, just remember to comment your code if you are having trouble remembering what each name is for.

I'm referring more so to naming of things that should not need comments. For example, lets say there is a game structure called "GameDataElements", which contains mostly or all elements of the games in-game UI. It is tempting to just name your class "Ingameuielements". The issue is, for me anyways, as I did this more and more the general layout of the way the actual game structs work got confusing fast.

Thanks for the advice so far. Another thing I'm trying to work on is not over-using properties. I started out seeing and using them a lot, but as time goes by I see how they can be kind of confusing. Example:

var entityList =  GameExample.EntityList; // Bad?
var entityList =  GameExample.EntityListOld; // Bad?

vs

var freshEntityList =  GameExample.GetEntityList(); // Better?
var cachedEntityList =  GameExample.EntityListCache; // Better?

// Perhaps even better:
:
var freshEntityList =  GameExample.GetEntityList(true); // Bool to return fresh list
var cachedEntityList =  GameExample.GetEntityList(false);    // Bool to return cached

[Jadd]

IMO create a wrapper for the internal stuff. Then you can call the functions whatever you want.

As for caching:

var entitiesCached = Manager.EntityList;

Manager.Invalidate();
var entities = Manager.EntityList;