Нужна конструктивная критика по оформлению и читабельности кода (Game Trainer C++)

#pragma once
#ifndef TRAINER_H
#define TRAINER_H
 
#include "lib/Game.h"
 
class Trainer
{
public:
    Trainer();
    ~Trainer();
 
    void start();
 
    static DWORD getProcessIdByName(char* processName);
    static bool gameIsRun();
    static bool trainerIsRun();
 
private:
    enum Msg { MSG_WAIT_FOR_START, MSG_HOTKEYS };
 
    LPSTR sound[3];
    bool bGodMode, bNoReload;
    Game game;
 
    bool gameOnFocus();
    LPSTR getResource(int resourceId);
 
    inline void speech(int type);
 
    static void printMsg(Msg type);
};
 
#endif

#include "lib/config.h"
#include "lib/Trainer.h"
#include "lib/Game.h"
#include "resource.h"
 
Trainer::Trainer()
{
    sound[0] = getResource(SND_OFF);
    sound[1] = getResource(SND_ON);
    sound[2] = getResource(SND_MONEY);
    bGodMode = false;
    bNoReload = false;
    printMsg(MSG_HOTKEYS);
}
 
Trainer::~Trainer(){}
 
void Trainer::start()
{
    while (true)
    {
        // Close Trainer IF GAME is NOT RUNNING
        if (!gameIsRun())
        {
            break;
        }
 
        // Continue IF GAME is not active || PLAYER is DEAD
        if (!gameOnFocus() || game.playerIsDead())
        {
            Sleep(1000);
            continue;
        }
 
        // Rewrite data if FREEZE FLAG enabled
        if (bGodMode)
        {
            game.updatePoints();
        }
        if (bNoReload)
        {
            game.updateAmmo();
        }
 
        // Keyboard handling
        if (GetAsyncKeyState(KEY_GODMODE) & 1)
        {
            bGodMode = !bGodMode;
            game.freezePoints();
            speech(bGodMode);
        }
        if (GetAsyncKeyState(KEY_AMMO) & 1)
        {
            bNoReload = !bNoReload;
            game.freezeAmmo();
            speech(bNoReload);
        }
 
        #ifdef MONEY_EXISTS
        if (GetAsyncKeyState(KEY_MONEY) & 1)
        {
            game.addMoney((TYPE_MONEY)MONEY_AMMOUNT);
            speech(2);
        }
        #endif
        Sleep(50);
    }
}
 
DWORD Trainer::getProcessIdByName(char* processName)
{
    DWORD pid = 0;
 
    // Create toolhelp snapshot.
    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    PROCESSENTRY32 process;
    ZeroMemory(&process, sizeof(process));
    process.dwSize = sizeof(process);
 
    // Walkthrough all processes.
    if (Process32First(snapshot, &process))
    {
        do
        {
            // Compare process.szExeFile based on format of name, i.e., trim file path
            // trim .exe if necessary, etc.
            if (_stricmp(process.szExeFile, processName) == 0)
            {
                pid = process.th32ProcessID;
                break;
            }
        } while (Process32Next(snapshot, &process));
    }
 
    CloseHandle(snapshot);
    return pid;
}
 
bool Trainer::gameIsRun()
{
    return 0 != getProcessIdByName(GAME_PROCESS);
}
 
bool Trainer::trainerIsRun()
{
    HANDLE mutex = CreateMutex(NULL, TRUE, TRAINER_TITLE);
 
    if (mutex == NULL || GetLastError() == ERROR_ALREADY_EXISTS)
    {
        HWND existingApp = FindWindow(0, TEXT(TRAINER_TITLE));
        if (existingApp)
        {
            ShowWindow(existingApp, SW_RESTORE);
            SetForegroundWindow(existingApp);
            return true;
        }
    }
 
    SetConsoleTitle(TRAINER_TITLE);
    system("color a");
    printMsg(MSG_WAIT_FOR_START);
 
    return false;
}
 
bool Trainer::gameOnFocus()
{
    DWORD idActive;
    GetWindowThreadProcessId(GetForegroundWindow(), &idActive);
    return idActive == getProcessIdByName(GAME_PROCESS);
}
 
// MSDN.function
LPSTR Trainer::getResource(int resourseId)
{
    HMODULE hInst = GetModuleHandle(NULL);
    if(!hInst)
    {
        return FALSE;
    }  
    LPSTR lpRes; 
    HANDLE hResInfo, hRes; 
 
    // Find the WAVE resource. 
 
    hResInfo = FindResource(hInst, MAKEINTRESOURCE(resourseId), "WAVE");
    if (hResInfo == NULL) 
        return FALSE; 
 
    // Load the WAVE resource. 
 
    hRes = LoadResource(hInst, (HRSRC)hResInfo); 
    if (hRes == NULL) 
        return FALSE; 
 
    // Lock the WAVE resource and play it. 
 
    lpRes = (LPSTR)LockResource(hRes); 
    if (lpRes != NULL)
    {  
        UnlockResource(hRes); 
    } 
 
    // Free the WAVE resource and return success or failure. 
 
    FreeResource(hRes); 
    return lpRes; 
}
 
inline void Trainer::speech(int type)
{
    sndPlaySound(sound[type], SND_MEMORY | SND_ASYNC | SND_NODEFAULT);
}
 
void Trainer::printMsg(Msg type)
{
    system("cls");
    std::cout << std::endl << std::endl << std::endl
        << "\t$$$$$$_$$$$$___$$$$__$$$$$$_$$__$$_$$$$$__$$$$$______________$$$$" << std::endl
        << "\t__$$___$$__$$_$$__$$___$$___$$$_$$_$$_____$$__$$_______$$___$___$$" << std::endl
        << "\t__$$___$$$$$__$$$$$$___$$___$$_$$$_$$$$___$$$$$______$$$$$$___$$$" << std::endl
        << "\t__$$___$$__$$_$$__$$___$$___$$__$$_$$_____$$__$$_______$$___$___$$" << std::endl
        << "\t__$$___$$__$$_$$__$$_$$$$$$_$$__$$_$$$$$__$$__$$_____________$$$$" << std::endl << std::endl
        << "\t\t* * * * * * * * * * * * * * * * * * *"                << std::endl
        << "\t\t* * * * * * * * * * * * * * * * * * *"                << std::endl
        << "\t\t* *                               * *"                << std::endl;
 
    if(type == MSG_WAIT_FOR_START)
    {
        std::cout
            << "\t\t\t Waiting for start:" << std::endl 
            << "\t\t\t " << GAME_PROCESS << std::endl;
    }
    else if(type == MSG_HOTKEYS)
    {
        std::cout
            << "\t\t* *   F" << (KEY_GODMODE - 111) << " - toggle God Mode        * *" << std::endl
            << "\t\t* *   F" << (KEY_AMMO - 111)    << " - toggle No Reload       * *" << std::endl
            << "\t\t* *   F" << (KEY_MONEY - 111)   << " - add 10000$             * *" << std::endl;
    }
 
    std::cout
            << "\t\t* *                               * *" << std::endl
            << "\t\t* * * * * * * * * * * * * * * * * * *" << std::endl
            << "\t\t* * * * * * * * * * * * * * * * * * *" << std::endl;
}