Maximum PC

/*
Player.h

Contains a class that provides functions for reading in and retrieving player information
in Halo.

Copyright 2004 Kybo Ren
*/
#include <windows.h>
#include <string>
#include <algorithm>
#include <cmath>
#include <cstring>

/*
#ifdef _DEBUG
#define CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#endif
//this is a class I have to detect memory leaks for me -- don't worry about it
*/

#define MAX_INSTANCES 12
#define MAX_NAMELENGTH 24

#define PC_DS 1
#define PC_GM 2
#define CE_DS 3
#define CE_GM 4//pc and ce ingame and DS servers

#define PC_DS_CLASS 0x4029CF64
#define PC_DS_SCORE 0x63A090

#define CE_GM_CLASS 0x402AB07A
#define CE_GM_SCORE 0x64C280

#define PC_GM_CLASS 0x0
#define PC_GM_SCORE 0x0//PC ingame is obviously not supported right now.

int my_itoa(const int number, char *data);//base can only be 10, and ASSUMES the data buffer supplied is big enough to hold the number

class Player
{
   int player_score;
   short player_deaths;
   short player_assists;
   short player_kills;
   short player_betrayals;
   short player_suicides;
   char player_team;
   char player_ingame;
   std::string player_name;
   std::string player_ipadd;
   std::string player_cdkey;
   //end of player data
   //start of class data
   int SIZE;//offset between players
   int ASSISTS;//offset of assists from kills
   int DEATHS;//offset of deaths from kills (beginning of player info structure)
   int SUICIDES;//offset of suicides from kills
   int TKS;//offset of TKs for each player from kills
   int NAMES;//offset of name from player's kills.
   int TEAMS;//IMPORTANT: this is the offset of player teams from player 1 kills! this is an array of characters! ***NOT PART OF THE STRUCTURE***
   int PLAYERIN;//IMPORTANT: this is the offset of player teams from player 1 score! this is an array of separate structures! ***NOT PART OF THE PLAYER INFO STRUCTURE**
   int PLAYERSZ;//Size of the abovementioned structure
   //start of individual class data
   unsigned int player_class_location;
   unsigned int player_score_location;
   unsigned int player_number;

   unsigned long process_PID;
   HANDLE hProc;//the handle to the process

public:
   
   Player();
   Player(const unsigned long &PID, const unsigned int &type, const unsigned int &player_number);
   ~Player();
   int Score();
   short Deaths();
   short Kills();
   short Betrayals();
   short Assists();
   short Suicides();
   char Team();
   char In_game();
   const char *Name();
   int Refresh();
   int Refresh_Score();
   int Refresh_Kills();
   int Refresh_Assists();
   int Refresh_Deaths();
   int Refresh_Suicides();
   int Refresh_Betrayals();
   int Refresh_Team();
   int Refresh_In_Game();
   int Refresh_Name();
   //end of player info
   //start of class info
   void Set_PID(const unsigned long &PID);
   void Set_Location(const unsigned long &class_location, const unsigned long &score_location, const unsigned long &ipadd_location);
   void Set_Player_Number(const unsigned int &player_num);
   void Set_Size(const unsigned long &size);
   void Set_Type(const unsigned long &type);
   bool Handle_Is_Null();
   unsigned int Open_Halo();
};//our player class

Player::Player()
{
   SIZE    = 0x200;
   ASSISTS = 0x8;
   DEATHS  = 0x12;
   SUICIDES= 0x14;
   TKS     = 0x44;
   NAMES   = -0x54;
   TEAMS   = -0x7C;
   PLAYERIN= -0x890;
   PLAYERSZ= 0x30;

   player_score = 0;
   player_deaths = 0;
   player_kills = 0;
   player_betrayals = 0;
   player_team = 0;
   player_ingame = 0;
   player_name = "<NULL>";

   player_class_location = 0;
   player_score_location = 0;
   player_ipadd_location = 0;
   player_number = 0;
   process_PID = 0;
}

Player::Player(const unsigned long& PID, const unsigned int &type, const unsigned int &player_num)
{
   switch(type)
   {
   case PC_DS:
      player_class_location = PC_DS_CLASS;
      player_score_location = PC_DS_SCORE;
      break;
   case CE_GM:
      player_class_location = CE_GM_CLASS;
      player_score_location = CE_GM_SCORE;
      break;
   case PC_GM:
      player_class_location = PC_GM_CLASS;
      player_score_location = PC_GM_SCORE;
      break;
   default:
      break;
   }

   if( (player_num <= 16) && (player_num >= 1) )//if valid range
   {
      player_number = player_num;
   }

   process_PID = PID;//assign PID

   SIZE    = 0x200;
   ASSISTS = 0x8;
   DEATHS  = 0x12;
   SUICIDES= 0x14;
   TKS     = 0x44;
   NAMES   = -0x54;
   TEAMS   = -0x7C;
   PLAYERIN= -0x890;
   PLAYERSZ= 0x30;

   player_score = 0;
   player_deaths = 0;
   player_kills = 0;
   player_team = 0;
   player_ingame = 0;
   player_name = "<NULL>";

   hProc = OpenProcess(PROCESS_VM_READ, FALSE, process_PID);//attempt to open the process
   if(hProc == NULL)
   {      
      hProc = NULL;//assign a NULL value
   }//we failed.  Oh. Noes.  We'll try again when refreshing

}

Player::~Player()
{
   CloseHandle(hProc);//close our handle
}

int Player::Score()
{
   return player_score;
}

short Player::Deaths()
{
   return player_deaths;
}

short Player::Suicides()
{
   return player_suicides;
}

short Player::Kills()
{
   return player_kills;
}

short Player::Betrayals()
{
   return player_betrayals;
}

short Player::Assists()
{
   return player_assists;
}

char Player::Team()
{
   return player_team;
}

char Player::In_game()
{
   return player_ingame;
}

const char * Player::Name()
{
   return player_name.c_str();
}

int Player::Refresh()
{   
   int result = 1;// we start with one so we can mutiply
   char name[13];//temp buffer for name
   ipaddr_union address;//for the IP address
   
   if(hProc == NULL)
   {   
      hProc = OpenProcess(PROCESS_VM_READ, FALSE, process_PID);
      
      if(hProc == NULL)
      {
         MessageBox(0, "Couldn't open the Halo process for reading.  \nIf you are sure Halo is running and you have access, send an email to Kybo Ren at:\nkyboren@gmail.com", "Warning", MB_OK | MB_ICONWARNING);
         return 0;//0 is fail
      }//we try once more then fail
   }
   
    result *= ReadProcessMemory(hProc, reinterpret_cast<void*>((player_score_location) + ((player_number-1)*4)        + 0      ), (void*)&player_score    , 4, 0);//read scores
   result *= ReadProcessMemory(hProc, reinterpret_cast<void*>((player_class_location) + ((player_number-1)*SIZE)     + 0      ), (void*)&player_kills    , 2, 0);//read kills
   result *= ReadProcessMemory(hProc, reinterpret_cast<void*>((player_class_location) + ((player_number-1)*SIZE)     + DEATHS ), (void*)&player_deaths   , 2, 0);//read deaths
   result *= ReadProcessMemory(hProc, reinterpret_cast<void*>((player_class_location) + ((player_number-1)*SIZE)     +SUICIDES), (void*)&player_suicides , 2, 0);//read suicides
   result *= ReadProcessMemory(hProc, reinterpret_cast<void*>((player_class_location) + ((player_number-1)*SIZE)     + ASSISTS), (void*)&player_assists  , 2, 0);//read assists
   result *= ReadProcessMemory(hProc, reinterpret_cast<void*>((player_class_location) + ((player_number-1)*SIZE)     + TKS    ), (void*)&player_betrayals, 2, 0);//read TKs
   result *= ReadProcessMemory(hProc, reinterpret_cast<void*>((player_score_location) + ((player_number-1)*PLAYERSZ)+ PLAYERIN), (void*)&player_ingame   , 1, 0);//read ingame
   result *= ReadProcessMemory(hProc, reinterpret_cast<void*>((player_class_location) + ((player_number-1)*SIZE)     + TEAMS  ), (void*)&player_team     , 1, 0);//read team
   for(unsigned int name_index = 0; name_index < MAX_NAMELENGTH; name_index += 2)
   {
      result *= ReadProcessMemory(hProc, reinterpret_cast<void*>((player_class_location) + ((player_number-1)*SIZE) + NAMES + name_index), (void*)&name[(name_index / 2)], 1, 0);//read name
   }
   name[12] = '\0';//nullify the name
   player_name = name;//the name is what we just read   

   return result;
}

int Player::Refresh_Score()
{
   if(hProc == NULL)
   {   
      hProc = OpenProcess(PROCESS_VM_READ, FALSE, process_PID);
      
      if(hProc == NULL)
      {
         MessageBox(0, "Couldn't open the Halo process for reading.  \nIf you are sure Halo is running and you have access, send an email to Kybo Ren at:\nkyboren@gmail.com", "Warning", MB_OK | MB_ICONWARNING);
         return 0;//0 is fail
      }//we try once more then fail
      
   }//if hProc still is messed   
   int result = 1;

   result *= ReadProcessMemory(hProc, reinterpret_cast<void*>((player_score_location) + ((player_number-1)*4)        + 0      ), (void*)&player_score    , 4, 0);//read scores
   
   return result;
}

int Player::Refresh_Kills()
{
   if(hProc == NULL)
   {   
      hProc = OpenProcess(PROCESS_VM_READ, FALSE, process_PID);
      
      if(hProc == NULL)
      {
         MessageBox(0, "Couldn't open the Halo process for reading.  \nIf you are sure Halo is running and you have access, send an email to Kybo Ren at:\nkyboren@gmail.com", "Warning", MB_OK | MB_ICONWARNING);
         return 0;//0 is fail
      }//we try once more then fail
      
   }//if hProc still is messed   
   int result = 1;

   result *= ReadProcessMemory(hProc, reinterpret_cast<void*>((player_class_location) + ((player_number-1)*SIZE)     + 0      ), (void*)&player_kills    , 2, 0);//read kills
   
   return result;
}

int Player::Refresh_Betrayals()
{
   if(hProc == NULL)
   {   
      hProc = OpenProcess(PROCESS_VM_READ, FALSE, process_PID);
      
      if(hProc == NULL)
      {
         MessageBox(0, "Couldn't open the Halo process for reading.  \nIf you are sure Halo is running and you have access, send an email to Kybo Ren at:\nkyboren@gmail.com", "Warning", MB_OK | MB_ICONWARNING);
         return 0;//0 is fail
      }//we try once more then fail
   }//if hProc still is messed   
   int result = 1;

   result *= ReadProcessMemory(hProc, reinterpret_cast<void*>((player_class_location) + ((player_number-1)*SIZE)     + TKS    ), (void*)&player_betrayals, 2, 0);//read TKs
   
   return result;
}

int Player::Refresh_Assists()
{
   if(hProc == NULL)
   {   
      hProc = OpenProcess(PROCESS_VM_READ, FALSE, process_PID);
      
      if(hProc == NULL)
      {
         MessageBox(0, "Couldn't open the Halo process for reading.  \nIf you are sure Halo is running and you have access, send an email to Kybo Ren at:\nkyboren@gmail.com", "Warning", MB_OK | MB_ICONWARNING);
         return 0;//0 is fail
      }//we try once more then fail

   }//if hProc still is messed   
   int result = 1;

   result *= ReadProcessMemory(hProc, reinterpret_cast<void*>((player_class_location) + ((player_number-1)*SIZE)     + ASSISTS), (void*)&player_assists  , 2, 0);//read assists
   
   return result;
}

int Player::Refresh_Deaths()
{
   if(hProc == NULL)
   {   
      hProc = OpenProcess(PROCESS_VM_READ, FALSE, process_PID);
      
      if(hProc == NULL)
      {
         MessageBox(0, "Couldn't open the Halo process for reading.  \nIf you are sure Halo is running and you have access, send an email to Kybo Ren at:\nkyboren@gmail.com", "Warning", MB_OK | MB_ICONWARNING);
         return 0;//0 is fail
      }//we try once more then fail
      
   }//if hProc still is messed   
   int result = 1;

   result *= ReadProcessMemory(hProc, reinterpret_cast<void*>((player_class_location) + ((player_number-1)*SIZE)     + DEATHS ), (void*)&player_deaths   , 2, 0);//read deaths
   
   return result;
}


int Player::Refresh_Suicides()
{
   if(hProc == NULL)
   {   
      hProc = OpenProcess(PROCESS_VM_READ, FALSE, process_PID);
      
      if(hProc == NULL)
      {
         MessageBox(0, "Couldn't open the Halo process for reading.  \nIf you are sure Halo is running and you have access, send an email to Kybo Ren at:\nkyboren@gmail.com", "Warning", MB_OK | MB_ICONWARNING);
         return 0;//0 is fail
      }//we try once more then fail
      
   }//if hProc still is messed   
   int result = 1;

   result *= ReadProcessMemory(hProc, reinterpret_cast<void*>((player_class_location) + ((player_number-1)*SIZE)     +SUICIDES), (void*)&player_suicides , 2, 0);//read suicides
   return result;
}


int Player::Refresh_Team()
{
   if(hProc == NULL)
   {   
      hProc = OpenProcess(PROCESS_VM_READ, FALSE, process_PID);
      
      if(hProc == NULL)
      {
         MessageBox(0, "Couldn't open the Halo process for reading.  \nIf you are sure Halo is running and you have access, send an email to Kybo Ren at:\nkyboren@gmail.com", "Warning", MB_OK | MB_ICONWARNING);
         return 0;//0 is fail
      }//we try once more then fail
   }//if hProc still is messed   
   int result = 1;

   result *= ReadProcessMemory(hProc, reinterpret_cast<void*>((player_class_location) + ((player_number-1)*SIZE)     + TEAMS  ), (void*)&player_team     , 1, 0);//read team
   
   return result;
}

int Player::Refresh_In_Game()
{
   if(hProc == NULL)
   {   
      hProc = OpenProcess(PROCESS_VM_READ, FALSE, process_PID);
      
      if(hProc == NULL)
      {
         MessageBox(0, "Couldn't open the Halo process for reading.  \nIf you are sure Halo is running and you have access, send an email to Kybo Ren at:\nkyboren@gmail.com", "Warning", MB_OK | MB_ICONWARNING);
         return 0;//0 is fail
      }//we try once more then fail

   }//if hProc still is messed   
   int result = 1;

   result *= ReadProcessMemory(hProc, reinterpret_cast<void*>((player_score_location) + ((player_number-1)*PLAYERSZ) + PLAYERIN     ), (void*)&player_ingame   , 1, 0);//read ingame
   
   return result;
}

int Player::Refresh_Name()
{
   if(hProc == NULL)
   {   
      hProc = OpenProcess(PROCESS_VM_READ, FALSE, process_PID);
      
      if(hProc == NULL)
      {
         MessageBox(0, "Couldn't open the Halo process for reading.  \nIf you are sure Halo is running and you have access, send an email to Kybo Ren at:\nkyboren@gmail.com", "Warning", MB_OK | MB_ICONWARNING);
         return 0;//0 is fail
      }//we try once more then fail
   }//if hProc still is messed   
   int result = 1;
   char name[13];

   for(unsigned int name_index = 0; name_index < MAX_NAMELENGTH; name_index += 2)
   {
      result *= ReadProcessMemory(hProc, reinterpret_cast<void*>((player_class_location) + ((player_number-1)*SIZE) + NAMES + name_index), (void*)&name[(name_index / 2)], 1, 0);//read name
   }
   name[12] = '\0';//nullify the name
   player_name = name;//the name is what we just read

   return result;
}

void Player::Set_PID(const unsigned long &PID)
{
   process_PID=PID;
}

void Player::Set_Location(const unsigned long &class_location, const unsigned long &score_location, const unsigned long &ipadd_location)
{
   player_class_location = class_location;
   player_score_location = score_location;
   player_ipadd_location = ipadd_location;
}

void Player::Set_Player_Number(const unsigned int &player_num)
{
   player_number = player_num;
}

void Player::Set_Size(const unsigned long &size)
{
   SIZE = size;
}

void Player::Set_Type(const unsigned long &type)
{
   switch(type)
   {
   case PC_DS:
      player_class_location = PC_DS_CLASS;
      player_score_location = PC_DS_SCORE;
      break;
   case CE_GM:
      player_class_location = CE_GM_CLASS;
      player_score_location = CE_GM_SCORE;
      break;
   case PC_GM:
      player_class_location = PC_GM_CLASS;
      player_score_location = PC_GM_SCORE;
      break;
   default:
      break;
   }
}
bool Player::Handle_Is_Null()
{
   return (hProc == NULL);
}

unsigned int Player::Open_Halo()
{
   hProc = OpenProcess(PROCESS_VM_READ, FALSE, process_PID);
   return (hProc != NULL);//return 1 for success
}

int my_itoa(const int number, char *data)
{
   std::string buf;
   std::string buffer;
   int num = std::abs(number);
   const unsigned int numdigits = (log((float)num) / log(10.0f)) + 1;
   unsigned int dig_buf;
   
   for(int i = 1; i <= numdigits; ++i)
   {
      dig_buf = static_cast<int>(std::pow(10.0f, i-1));

      buffer = (num % static_cast<int>(std::pow(10.0f, i))) / dig_buf + '0';
      buf += buffer;
   }

   if(number < 0)
   {
      buf += '-';
   }

   std::reverse(buf.begin(), buf.end());

   std::strcpy(data, buf.c_str());

   return (buf.size() > 0);
   
};

/*
Server.h

Provides a class interface to be used between your application and Halo.

Copyright 2004 Kybo Ren
*/
#include <vector>
#include "Player.h"

#define MAX_PLAYERS 16

#define ERROR 0
#define PC_DS 1
#define PC_GM 2
#define CE_DS 3
#define CE_GM 4//pc and ce ingame and DS servers

#define PC_DS_GAMETYPE 0x6712D8 //1 = CTF, 2 = Slayer, 3 = Oddball, 4 = KOTH, 5 = Race
#define CE_GM_GAMETYPE 0x0
#define PC_GM_GAMETYPE 0x0//obviously these aren't implemented#nwe

const int CTF     = 1;
const int SLAYER  = 2;
const int ODDBALL = 3;
const int KOTH    = 4;
const int RACE    = 5;//gametypes
const char gametypes[5][15] = {"CTF","Slayer","Oddball","KOTH","Race"};//gametype strings


class Server
{
   unsigned long server_PID;//the PID of the server
   unsigned long server_isEnabled;//is it enabled?  did the user check off this box?
   unsigned long server_Number;//i.e. 1 for "Halo Console (1)", 2 for "Halo Console (2)"
   unsigned long server_Type;//type of server, i.e. Halo PC DS, Halo CE game
   unsigned long server_Gametype;//gametype on server
   unsigned long server_gametype_loc;//location of gametype on server proc
   HANDLE hProc;//handle to the process
   HANDLE server_thread;//handle to the thread for this process

public:
   Server();//default constructor
   ~Server();//destructor
   std::vector<Player*> Players;//vector of POINTERS to Player objects
   ConsoleLogger Console;//for logging the console data if it is a DS
   const char *Gametype();//returns gametype string of current gametype on server
   const unsigned long PID();
   HANDLE Thread();//returns a handle to the current thread
   const unsigned long isEnabled();
   const unsigned long Number();
   const unsigned long Type();//echoes the variables above
   const int Refresh(void);//refresh all
   const int Set_PID(const unsigned long PID);
   const int Set_Thread(HANDLE hThread);
   const int Set_Enabled(const unsigned long isEnabled);
   const int Set_Number(const unsigned long Number);//sets the variables above
   const int Set_Type(const unsigned int Type);//set type
   const int Set_All(const unsigned long PID, HANDLE hThread, const unsigned long isEnabled, const unsigned long Number, const unsigned long Type);

};

Server::Server()
{
   server_PID = 0;
   server_thread = 0;
   server_isEnabled = 0;
   server_Number = 0;
   server_Type = 0;
   server_thread = 0;//0 the values


   for(unsigned int i=0; i < MAX_PLAYERS; ++i)
   {
      Players.push_back(new Player(server_PID, server_Type, (i+1)));//insert a new player
   }

}

const int Server::Set_All(const unsigned long PID, HANDLE hThread, const unsigned long isEnabled, const unsigned long Number, const unsigned long Type)
{
   server_PID = PID;
   server_thread = hThread;
   server_isEnabled = isEnabled;
   server_Number = Number;
   server_Type = Type;

   switch(Type)
   {
      case PC_DS:
         server_gametype_loc = PC_DS_GAMETYPE;
         break;
      case CE_GM:
         server_gametype_loc = CE_GM_GAMETYPE;
         break;
      case PC_GM:
         server_gametype_loc = PC_GM_GAMETYPE;
         break;

      default:
         server_gametype_loc = PC_DS_GAMETYPE;//weird type, assume PC dedicated server
         break;
   }

   return 0;
}

Server::~Server()
{
   for(unsigned int i=0; i < MAX_PLAYERS; ++i)
   {
      delete Players[i];//delete memory
   }

   CloseHandle(hProc);//close the handle to the proc
   CloseHandle(server_thread);//close the thread handle
}

const unsigned long Server::PID()
{
   return server_PID;
}

HANDLE Server::Thread()
{
   return server_thread;
}

const unsigned long Server::isEnabled()
{
   return server_isEnabled;
}

const unsigned long Server::Number()
{
   return server_Number;
}

const unsigned long Server::Type()
{
   return server_Type;
}

const int Server::Refresh()
{
   int result = 1;

   if(hProc == NULL)
   {   
      hProc = OpenProcess(PROCESS_VM_READ, FALSE, server_PID);
      
      if(hProc == NULL)
      {
         MessageBox(0, "Couldn't open the Halo process for reading.  \nIf you are sure Halo is running and you have access, send an email to Kybo Ren at:\nkyboren@gmail.com", "Warning", MB_OK | MB_ICONWARNING);
         return 0;//0 is fail
      }//we try once more, then fail
      
   }//if hProc still is messed   

   for(unsigned int i = 0; i < MAX_PLAYERS; ++i)
   {
      if(Players[i]->Handle_Is_Null())//null handle
      {
         Players[i]->Open_Halo();//try to open the process
      }

      result *= Players[i]->Refresh();
   }
   result *= ReadProcessMemory(hProc, reinterpret_cast<void*>(server_gametype_loc), (void*)&server_Gametype, 1, 0);//read gametype

   return result;
}


const int Server::Set_PID(const unsigned long PID)
{
   server_PID = PID;

   for(unsigned int i=0; i < MAX_PLAYERS; ++i)
   {
      Players[i]->Set_PID(PID);
   }

   return 0;
}

const int Server::Set_Thread(HANDLE hThread)
{
   if(hThread = NULL)
   {
      return 1;
   }

   server_thread = hThread;

   return 0;
}

const int Server::Set_Enabled(const unsigned long isEnabled)
{
   server_isEnabled = isEnabled;
   
   return 0;
}

const int Server::Set_Number(const unsigned long Number)
{
   server_Number = Number;

   return 0;
}
const int Server::Set_Type(const unsigned int Type)
{
   server_Type = Type;

   
   for(unsigned int i = 0; i < MAX_PLAYERS; ++i)
   {
      Players[i]->Set_Type(Type);
   }//set the type

   return Type;
}

const char *Server::Gametype()
{
   if(hProc == NULL)
   {   
      hProc = OpenProcess(PROCESS_VM_READ, FALSE, server_PID);
      
      if(hProc == NULL)
      {
         MessageBox(0, "Couldn't open the Halo process for reading.  \nIf you are sure Halo is running and you have access, send an email to Kybo Ren at:\nkyboren@gmail.com", "Warning", MB_OK | MB_ICONWARNING);
         return 0;//0 is fail
      }//we try once more, then fail
      
   }//if hProc still is messed   
   int result = 1;

   result *= ReadProcessMemory(hProc, reinterpret_cast<void*>(server_gametype_loc), (void*)&server_Gametype, 1, 0);//read gametype

   return gametypes[server_Gametype];
}

unsigned char text[];

void textReplacer()
{



}

__declspec(naked) void getReplaceText(void)
{
   __asm
   {
   pop retnAddr
   
   MOV text, EAX
   
   pushfd
   pushad
   }


textReplacer();

   __asm
      {   
         popfd
         popad
         ADD ESP, 8
         MOV esi, text
         PUSH EDI
         push retnAddr   
         ret
      }
}