rendered paste body#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <mmsystem.h>
#pragma warning (disable:4786)
#pragma warning (disable:4244)
#pragma warning (disable:4731)
#include <map>
#include <vector>
#include <list>
#undef NDEBUG
#include <assert.h>
#include "engine/wrect.h"
#include "engine/cl_dll.h"
#include "engine/cdll_int.h"
#include "engine/const.h"
#include "engine/progdefs.h"
#include "engine/eiface.h"
#include "engine/edict.h"
#include "engine/studio_event.h"
#include "engine/entity_types.h"
#include "engine/pmtrace.h"
#include "common/ref_params.h"
#include "common/screenfade.h"
#include "common/event_api.h"
#include "common/com_model.h"
#include "parsemsg.h"
#include "engine/r_studioint.h"
#include "engine/triangleapi.h"
#include "engine/pm_defs.h"
#include "engine/r_efx.h"
#include "sprites.h"
#include "common/net_api.h"
#include <time.h>
#include <gl/gl.h>
#include "stdafx.h"
using namespace std;
#include <tlhelp32.h>
#include <fstream>
#include "cvar.h"
#include "calcscreen.h"
#include "timehandling.h"
#include "stringfinder.h"
#include "color.h"
#include "aimbot.h"
#include "attack.h"
#include "playeritems.h"
#include "bind.h"
#include "interpreter.h"
#include "client.h"
#include "menu.h"
#include "console.h"
#include "engine/studio.h"
#include "recoil.h"
#include "eventhook.h"
#include "gpatch.h"
#pragma warning (disable:4005)
#pragma warning (disable:4800)
#pragma optimize("gt",on)
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
using namespace std;
//===================================================================================
typedef void( *fCL_CreateMove )( float, struct usercmd_s *, int );
typedef int( *fHUD_AddEntity )( int, struct cl_entity_s *, const char * );
typedef int( *fHUD_DirectorEvent )( unsigned char command, unsigned int firstObject, unsigned int secondObject, unsigned int flags );
typedef void( *fHUD_Frame )( double time );
typedef int( *fHUD_Key_Event )( int, int, const char * );
typedef void( *fHUD_PlayerMove )( struct playermove_s *, int );
typedef void( *fHUD_PlayerMoveInit )( struct playermove_s * );
typedef char( *fHUD_PlayerMoveTexture )( char * );
typedef void( *fHUD_PostRunCmd )( struct local_state_s *from, struct local_state_s *to, struct usercmd_s *cmd, int runfuncs, double time, unsigned int random_seed );
typedef int( *fHUD_Redraw )( float, int );
typedef int( *fHUD_Init )( void );
typedef void( *fHUD_Shutdown )( void );
typedef void( *fHUD_TempEntUpdate )( double, double, double, struct tempent_s **, struct tempent_s **, int( *Callback_AddVisibleEntity )( struct cl_entity_s *fEntity ), void( *Callback_TempEntPlaySound )( struct tempent_s *fTemp, float damp ) );
typedef void( *fIN_MouseEvent )( int mstate );
typedef int( *fInitialize )( cl_enginefunc_t *, int );
typedef struct kbutton_s *( *fKB_Find )( const char *name );
typedef void( *fV_CalcRefdef )( struct ref_params_s *fparams );
typedef void (*fHUD_DirectorMessage)(unsigned char, unsigned int, unsigned int, unsigned int);
void( *pCL_CreateMove )( float, struct usercmd_s *, int );
int( *pHUD_AddEntity )( int, struct cl_entity_s *, const char * );
int( *pHUD_DirectorEvent )( unsigned char command, unsigned int firstObject, unsigned int secondObject, unsigned int flags );
void( *pHUD_Frame )( double time );
int( *pHUD_Key_Event )( int, int, const char * );
void( *pHUD_PlayerMove )( struct playermove_s *, int );
void( *pHUD_PlayerMoveInit )( struct playermove_s * );
char( *pHUD_PlayerMoveTexture )( char * );
void( *pHUD_PostRunCmd )( struct local_state_s *from, struct local_state_s *to, struct usercmd_s *cmd, int runfuncs, double time, unsigned int random_seed );
int( *pHUD_Redraw )( float, int );
void( *pHUD_Shutdown )( void );
void( *pHUD_TempEntUpdate )( double, double, double, struct tempent_s **, struct tempent_s **, int( *Callback_AddVisibleEntity )( struct cl_entity_s *pEntity ), void( *Callback_TempEntPlaySound )( struct tempent_s *pTemp, float damp ) );
void( *pIN_MouseEvent )( int mstate );
int( *pInitialize )( cl_enginefunc_t *, int );
struct kbutton_s *( *pKB_Find )( const char *name );
void( *pV_CalcRefdef )( struct ref_params_s *pparams );
void (*pHUD_DirectorMessage)(unsigned char, unsigned int, unsigned int, unsigned int);
//Hook User Messages
DWORD HookUserMsgOrg;
pfnUserMsgHook TeamInfoOrg=NULL;
pfnUserMsgHook CurWeaponOrg=NULL;
pfnUserMsgHook ScoreAttribOrg=NULL;
pfnUserMsgHook TextMsgOrg=NULL;
pfnUserMsgHook ResetHUDOrg=NULL;
pfnUserMsgHook WeaponListOrg=NULL;
pfnUserMsgHook MoneyOrg=NULL;
pfnUserMsgHook BatteryOrg=NULL;
pfnUserMsgHook DeathMsgOrg=NULL;
pfnUserMsgHook ScoreInfoOrg=NULL;
pfnUserMsgHook SayMsgOrg=NULL;
pfnUserMsgHook DamageMsgOrg=NULL;
pfnUserMsgHook AmmoXOrg=NULL;
pfnUserMsgHook AmmoOrg=NULL;
pfnUserMsgHook HealthOrg=NULL;
int WallActive(void)
{ return cvar.wall; }
SCREENINFO screeninfo;
struct hostage_info
{ cl_entity_s *ent; };
struct cl_enginefuncs_s gEngfuncs;
struct cl_enginefuncs_s gHookedEngfuncs;
struct efx_api_s gHookEfxApi;
engine_studio_api_t IEngineStudio;
engine_studio_api_t* pIEngineStudio=0;
cl_enginefuncs_s *pEngfuncs = (cl_enginefuncs_s*) 0x01EA0A08;
playermove_s *ppmove = (playermove_s*) 0x02D590A0;
engine_studio_api_s *pstudio = (engine_studio_api_s*) 0x01EBC978;
//r_studio_interface_s* *ppinterface;
DWORD* slots = (DWORD*)0x01EA0C20;
r_studio_interface_s *ppinterface = (r_studio_interface_s*) 0x01EBCA3C;
////////////
local_player_info me;
VecPlayers vPlayers;
vector<hostage_info> vEntity;
bool bNewFrame=false;
bool sniper=false;
bool bBombIsPlanted=false;
float fBombPlantedTime=0;
int iC4Timer=0;
int iRounds=0;
// Blinking for Radar/Esp
StopTimer blinkTimer;
bool blinkPhase = false;
PlayerItems playerItems;
//ofstream commandLogFile;
//bool commandLogFileOpened = false;
char gHudMessage[256]="";
StopTimer gHudTimer;
char gHudMessage2[256]="";
StopTimer gHudTimer2;
struct ScheduledCommand
{string cmd; RunningStopTimer timer; };
typedef list<ScheduledCommand> ScheduleList;
ScheduleList scheduleList;
static bool bGotHeadshot=false;
int currentWeaponID=0;
int lastWeaponID=0;
int iCurrentFOV=90;
float fCurrentFOV=90.0;
BurstInfo burstInfo;
HANDLE hProcess=0;
DWORD hw_dll_offset=0;
HMODULE hClientDll=0;
DWORD client_dll_offset=0;
DWORD client_dll_end=0;
int Cstrike_SequenceInfo[] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 2, 0, 1, 2, 0, 1, 2, 0,
1, 2, 0, 1, 1, 2, 0, 1, 1, 2,
0, 1, 2, 0, 1, 2, 0, 1, 2, 0,
1, 2, 0, 1, 2, 0, 1, 2, 0, 1,
2, 0, 1, 2, 0, 0, 0, 4, 0, 4,
0, 5, 0, 5, 0, 0, 1, 1, 2, 0,
1, 1, 2, 0, 1, 0, 1, 0, 1, 2,
0, 1, 2, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3
};
enum { SEQUENCE_SHOOT=1, SEQUENCE_RELOAD=2, SEQUENCE_DIE=3, SEQUENCE_THROW=4, SEQUENCE_ARM_C4=5 };
char* Cstrike_infotext[] = {"", "(PenG)", "|| reloading ||", "", "|| throwing ||", "|| planting ||" };
bool Aimbot_active=false;
#define BOUND_VALUE(var,min,max) if((var)>(max)){(var)=(max);};if((var)<(min)){(var)=(min);}
#define MAX_VALUE(a,b,c) ( a>b? (a>c?a:(b>c?b:c)) : (b>c?b:c) )
static ColorEntry dummycolor;
static bool bAttacking = false;
static bool bAttack2 = false;
char ogcdir [256]="";
char hldir [256]="";
int beamindex = 0;
//===================================================================================
string getOgcDirFile(const char* basename)
{
if(strstr(basename,"..")){ return ":*?\\/<>\""; }
string ret = ogcdir;
return (ret+basename);
}
//===================================================================================
inline float GetPseudoDistance(const float* const pos1, const float* const pos2)
{
return
fabs(pos1[0]-pos2[0])+
fabs(pos1[1]-pos2[1])+
fabs(pos1[2]-pos2[2]);
}
//===================================================================================
inline float GetDistanceFrom(float* pos)
{
register float a = pos[0] - me.pmEyePos[0];
register float b = pos[1] - me.pmEyePos[1];
register float c = pos[2] - me.pmEyePos[2];
return sqrt(a*a + b*b + c*c);
}
int __fastcall CalcScreen(float *origin, float *vecScreen)
{
if(!cvar.chase_cam)
{
return NewCalcScreen(origin, vecScreen);
}
else if(cvar.chase_cam)
{
int cResult = 0;
if( gEngfuncs.GetLocalPlayer() != NULL )
cResult = gEngfuncs.pTriAPI->WorldToScreen( origin, vecScreen );
if( vecScreen[0] < 1 && vecScreen[1] < 1 && vecScreen[0] > -1 && vecScreen [1] > -1 && !cResult )
{
vecScreen[0] = vecScreen[0] * displayCenterX + displayCenterX;
vecScreen[1] = -vecScreen[1] * displayCenterY + displayCenterY;
return true;
}
return NULL;
}
return NULL;
}
//===================================================================================
void gDrawFilledBoxAtLocation( float* origin, DWORD color, int radius)
{
float vecScreen[2];
if( !CalcScreen(origin, vecScreen) ) { return; }
int red = (color>>24);
int green = (color>>16)&0xFF;
int blue = (color>>8)&0xFF;
int alpha = (color)&0xFF;
int radius2 = radius<<1;
gEngfuncs.pfnFillRGBA(vecScreen[0]-radius,vecScreen[1]-radius,radius2,radius2,red,green,blue,alpha);
}
//===================================================================================
void SPR_Draw (int frame, int x, int y, const wrect_t *prc)
{
if (!sniper) gEngfuncs.pfnSPR_Draw (frame, x, y, prc);
}
//===================================================================================
void SPR_DrawHoles (int frame, int x, int y, const wrect_t *prc)
{
if (!sniper) gEngfuncs.pfnSPR_DrawHoles (frame, x, y, prc);
}
//===================================================================================
HSPRITE sprset_hsprite = 0;
int sprset_r, sprset_g, sprset_b;
extern bool oglSubtractive;
void SPR_DrawAdditive( int frame, int x, int y, const wrect_t *prc )
{
if(cvar.hud) gEngfuncs.pfnSPR_Set (sprset_hsprite,sprset_r,sprset_g,sprset_b);
gEngfuncs.pfnSPR_DrawAdditive(frame,x,y,prc);
}
//===================================================================================
void FillRGBA( int x, int y, int width, int height, int r, int g, int b, int a )
{
if(cvar.hud)
{
register ColorEntry* color = colorList.get(5);
gEngfuncs.pfnFillRGBA(x,y,width,height,color->r,color->g,color->b,a);
} else {
gEngfuncs.pfnFillRGBA(x,y,width,height,r,g,b,a);
}
}
//===================================================================================
int DrawCharacter( int x, int y, int number, int r, int g, int b )
{
if( b==0 && g>0 && cvar.hud)
{
register double ratio = (double(r)/double(g));
if( ratio>=1.5 && ratio<=1.7 )
{
register ColorEntry* color = colorList.get(5);
return gEngfuncs.pfnDrawCharacter(x,y,number,color->r*r/255,color->g*r/255,color->b*r/255);
}
}
return gEngfuncs.pfnDrawCharacter(x,y,number,r,g,b);
}
//===================================================================================
static void updateLocalPlayer()
{
me.ent = gEngfuncs.GetLocalPlayer();
static cl_entity_s dummy;
memset((char*)&dummy,0,sizeof(dummy));
if(!me.ent){ me.ent = &dummy; }
}
//===================================================================================
void SPR_Set (HSPRITE hPic, int r, int g, int b)
{
if(cvar.sniper)
{
const char * SPR_TOP = "sprites/top";
const char * SPR_BOTTOM = "sprites/bottom";
const char * SPR_LEFT = "sprites/left";
const char * SPR_RIGHT = "sprites/right";
const char * SPR_VERTICAL = "sprites/vertical";
const char * SPR_HORIZONTAL = "sprites/horizontal";
const char * sprite_name = sprite_lookup(hPic);
if( !strncmp(sprite_name, SPR_TOP, strlen(SPR_TOP) )
|| !strncmp(sprite_name, SPR_BOTTOM, strlen(SPR_BOTTOM) )
|| !strncmp(sprite_name, SPR_LEFT, strlen(SPR_LEFT) )
|| !strncmp(sprite_name, SPR_RIGHT, strlen(SPR_RIGHT) )
|| !strncmp(sprite_name, SPR_VERTICAL, strlen(SPR_VERTICAL) )
|| !strncmp(sprite_name, SPR_RIGHT, strlen(SPR_HORIZONTAL)))
{
sniper=true;
}
else sniper = false;
}
else sniper = false;
if(cvar.hud)
{
register ColorEntry* color = colorList.get(5);
sprset_hsprite=hPic;
int intensity = MAX_VALUE(r,g,b);
sprset_r = color->r*intensity/255;
sprset_g = color->g*intensity/255;
sprset_b = color->b*intensity/255;
}
gEngfuncs.pfnSPR_Set (hPic,r,g,b);
}
//===================================================================================
void tintArea(int x,int y,int w,int h, ColorEntry* clr)
{
gEngfuncs.pfnFillRGBA(x,y,w,h,clr->r,clr->g,clr->b,clr->a);
}
//===================================================================================
int DrawLen(char *fmt)
{
int len=0;
for ( char * p = fmt; *p; p++ ) len+=screeninfo.charWidths[*p];
return len;
}
//===================================================================================
void DrawHudStringCenter (int x, int y, int r, int g, int b, const char *fmt, ... )
{
va_list va_alist;
char buf[256];
va_start (va_alist, fmt);
_vsnprintf (buf, sizeof(buf), fmt, va_alist);
va_end (va_alist);
if( cvar.confont ) {
int length, height;
gEngfuncs.pfnDrawConsoleStringLen( buf, &length, &height );
x = x - length/2;
gEngfuncs.pfnDrawSetTextColor(/*(float)*/r/255.0,/*(float)*/g/255.0,/*(float)*/b/255.0);
gEngfuncs.pfnDrawConsoleString(x,y,buf);
} else {
int borderY = displayCenterY*2-18;
if( y<0 || y>borderY ) { return; }
int drawLen = DrawLen(buf);
x = x-drawLen/2;
int borderX = displayCenterX*2-11;
int minX = x;
int maxX = x+drawLen;
bool needSingleCheck = (minX<1 || maxX>borderX);
if( needSingleCheck )
{
for ( char * p = buf; *p; p++ )
{
int next = x + screeninfo.charWidths[*p];
if( x>0 && x<borderX )
gEngfuncs.pfnDrawCharacter (x, y, *p, r, g, b);
x = next;
}
} else {
for ( char * p = buf; *p; p++ )
{
int next = x + screeninfo.charWidths[*p];
gEngfuncs.pfnDrawCharacter (x, y, *p, r, g, b);
x = next;
}
}
}
}
//===================================================================================
void DrawHudString (int x, int y, int r, int g, int b, const char *fmt, ... )
{
va_list va_alist;
char buf[256];
va_start (va_alist, fmt);
_vsnprintf (buf, sizeof(buf), fmt, va_alist);
va_end (va_alist);
if(cvar.confont)
{
gEngfuncs.pfnDrawSetTextColor(/*(float)*/r/255.0,/*(float)*/g/255.0,/*(float)*/b/255.0);
gEngfuncs.pfnDrawConsoleString(x,y,buf);
} else {
int borderY = displayCenterY*2-18;
if( y<0 || y>borderY ) { return; }
bool needSingleCheck=false;
int borderX = displayCenterX*2-11;
int drawLen = DrawLen(buf);
if( x<1 ){ needSingleCheck=true; }
else
{
int maxX = x+drawLen;
needSingleCheck = (maxX>borderX);
}
if( needSingleCheck )
{
for ( char * p = buf; *p; p++ )
{
int next = x + screeninfo.charWidths[*p];
if( x>0 && x<borderX )
gEngfuncs.pfnDrawCharacter (x, y, *p, r, g, b);
x = next;
}
}else {
for ( char * p = buf; *p; p++ )
{
int next = x + screeninfo.charWidths[*p];
gEngfuncs.pfnDrawCharacter (x, y, *p, r, g, b);
x = next;
}
}
}
}
//===================================================================================
char *getPlayerNameByIndex(int ax)
{
char *name;
if (ax == -1)
return "";
name = vPlayers[ax].entinfo.name;
if (name)
return name;
else
return "";
}
//===================================================================================
void Con_Echo(const char *fmt, ... )
{
va_list va_alist;
char buf[256];
va_start (va_alist, fmt);
_vsnprintf (buf, sizeof(buf), fmt, va_alist);
va_end (va_alist);
gConsole.echo("%s",buf);
}
static int TeamInfo (const char *pszName, int iSize, void *pbuf)
{
const char PROC_NAME[50] = "TeamInfo\0";
int retval;
static bool done=false;
static StringFinder teamNumber;
if(!done)
{
teamNumber.add("terrorist" ,1);teamNumber.add("ct" ,2);
teamNumber.add("unassigned" ,0);teamNumber.add("spectator" ,0);
done = true;
}
BEGIN_READ(pbuf,iSize);
int px = READ_BYTE();
char * teamtext = READ_STRING();
updateLocalPlayer();
if(!*teamtext) { vPlayers[px].team = 0; }
else
{
_strlwr(teamtext);
if(teamNumber.find(teamtext))
{
vPlayers[px].team = teamNumber.num;
if(px==me.ent->index){ me.team = teamNumber.num; }
}
else
{
Con_Echo("TeamInfo: unknown px=%d, team=%s",px,teamtext);
vPlayers[px].team = -1;
if(px==me.ent->index){ me.team = -1; }
}
}
retval = (*TeamInfoOrg)(pszName, iSize, pbuf);
return retval;
}
//===================================================================================
int CurWeapon(const char *pszName, int iSize, void *pbuf )
{
const char PROC_NAME[50] = "CurWeapon\0";
int retval;
BEGIN_READ( pbuf, iSize );
int iState = READ_BYTE();
int iID = READ_CHAR();
int iClip = READ_CHAR();
if (iState) me.iClip = iClip;
playerItems.msgCurWeapon (iState,iID,iClip);
if(iState)
{
char * name = playerItems.getNamebyId(iID);
if(!strcmp(name,"mp5navy")) currentWeaponID = WEAPON_MP5;
else currentWeaponID = burstInfo.getWeaponID( name );
}
retval = (*CurWeaponOrg)(pszName,iSize,pbuf);
return retval;
}
//===================================================================================
int SayMsg(const char *pszName, int iSize, void *pbuf )
{
const char PROC_NAME[50] = "SayMsg\0";
int retval;
updateLocalPlayer();
if(gConsole.mode == OgcConsole::MODE_CHAT)
{
BEGIN_READ( pbuf, iSize);
int client = READ_BYTE();
char* text = READ_STRING();
char* realtext = strstr(text," : ");
if(realtext)
{
char* name = text;
*realtext=0;
realtext+=3;
while(*realtext==' ')realtext++;
if( vPlayers[client].entinfo.name[0]!='\\' || client==me.ent->index )
{
cmd.exec("sigmessage");
gConsole.say(realtext,name,vPlayers[client].team );
return 1;
}
}
}
retval = (*SayMsgOrg)(pszName,iSize,pbuf);
return retval;
}
//===================================================================================
int DeathMsg(const char *pszName, int iSize, void *pbuf )
{
const char PROC_NAME[50] = "DeathMsg\0";
int retval;
updateLocalPlayer();
BEGIN_READ( pbuf, iSize );
int killer = READ_BYTE();
int victim = READ_BYTE();
int headshot = READ_BYTE();
char* weaponName = READ_STRING();
if(victim==me.ent->index)
{
cvar.spec_fix = false;
}
if(cvar.alive_method==1)
{
vPlayers[victim].setAlive(false);
if(victim==me.ent->index){ me.alive = false; }
}
if( killer==me.ent->index && headshot)
{
bGotHeadshot=true;
}
retval = (*DeathMsgOrg)(pszName,iSize,pbuf);
return retval;
}
//===================================================================================
int MsgMoney(const char *pszName, int iSize, void *pbuf )
{
const char PROC_NAME[50] = "MsgMoney\0";
int retval;
BEGIN_READ( pbuf, iSize );
playerItems.money = READ_SHORT();
if (playerItems.money!=16000 && me.alive)
{
cmd.exec("#impulse 101");
}
retval = (*MoneyOrg)(pszName,iSize,pbuf);
return retval;
}
//===================================================================================
int MsgBattery(const char *pszName, int iSize, void *pbuf )
{
const char PROC_NAME[50] = "MsgBattery\0";
int retval;
BEGIN_READ( pbuf, iSize );
playerItems.armor = READ_BYTE();
retval = (*BatteryOrg)(pszName,iSize,pbuf);
return retval;
}
//===================================================================================
int ScoreAttrib(const char *pszName, int iSize, void *pbuf )
{
const char PROC_NAME[50] = "ScoreAttrib\0";
int retval;
updateLocalPlayer();
BEGIN_READ(pbuf, iSize);
int idx = READ_BYTE();
int info = READ_BYTE();
vPlayers[idx].iInfo = info;
if( cvar.alive_method==0)
{
if(info&1) { vPlayers[idx].setAlive(false); vPlayers[idx].clearPVS(); }
else { vPlayers[idx].setAlive(); }
}
if(idx==me.ent->index) me.alive = ((info&1)==0);
retval = (*ScoreAttribOrg)(pszName,iSize,pbuf);
return retval;
}
//===================================================================================
int TextMsg(const char *pszName, int iSize, void *pbuf )
{
const char PROC_NAME[50] = "TextMsg\0";
int retval;
updateLocalPlayer();
BEGIN_READ(pbuf, iSize);
int id = READ_BYTE();
char* msg = READ_STRING();
if( *msg )
{
if (!strcmp(msg, "#Bomb_Planted"))
{
fBombPlantedTime = ClientTime::current;
bBombIsPlanted=true;
}
else if (!strcmp(msg, "#Target_Bombed"))
{
if (bBombIsPlanted)
{
iC4Timer = (int) ((ClientTime::current-fBombPlantedTime)+0.4999999);
if(iC4Timer<0 || iC4Timer>120) { iC4Timer=0; }
bBombIsPlanted=false;
}
}
else if (!strcmp(msg, "#Bomb_Defused"))
{
bBombIsPlanted=false;
}
}
retval = (*TextMsgOrg)(pszName,iSize,pbuf);
return retval;
}
//===================================================================================
void AtRoundStart(void);
int ResetHUD(const char *pszName, int iSize, void *pbuf )
{
const char PROC_NAME[50] = "ResetHUD\0";
int retval;
updateLocalPlayer();
bBombIsPlanted=false;
if (iRounds) AtRoundStart();
iRounds++;
if (currentWeaponID == WEAPON_SG550 || currentWeaponID == WEAPON_G3SG1)
me.spread.brokentime = 0; // This catches all cases except when you buy one and than shoot some bullets and that buy another
retval = (*ResetHUDOrg)(pszName,iSize,pbuf);
return retval;
}
//===================================================================================
int WeaponList(const char *pszName, int iSize, void *pbuf )
{
const char PROC_NAME[50] = "WeaponList\0";
int retval;
updateLocalPlayer();
playerItems.msgWeaponList(iSize,pbuf);
retval = (*WeaponListOrg)(pszName,iSize,pbuf);
return retval;
}
//========================================================================================
int ScoreInfo(const char *pszName, int iSize, void *pbuf )
{
const char PROC_NAME[50] = "ScoreInfo\0";
int retval;
updateLocalPlayer();
BEGIN_READ(pbuf, iSize);
int idx = READ_BYTE();
PlayerInfo& r = vPlayers[idx];
r.frags = READ_SHORT();
r.deaths = READ_SHORT();
if(r.frags<=0 ) { r.ratio=0; }
else { r.ratio = (double)r.frags / ((r.deaths<=0)?1:r.deaths); }
r.bestplayer = false;
bool foundbetter = false;
for(int i=0;i<vPlayers.size();i++)
{
if ( r.ratio < vPlayers[i].ratio ) foundbetter = true;
else if( r.ratio > vPlayers[i].ratio ) vPlayers[i].bestplayer=false;
}
if(!foundbetter) r.bestplayer = true;
if(idx==me.ent->index)
{
static int lastfrags=0;
static int lastdeaths=0;
if(me.headshots>r.frags || r.frags==0)
{
me.headshots = 0;
me.hspercent = 0;
bGotHeadshot = false;
lastfrags = r.frags;
lastdeaths = r.deaths;
}
else
{
if(bGotHeadshot) { ++me.headshots; }
double den = r.frags ? (double)r.frags : 1.0;
me.hspercent = (double)me.headshots/den*100.0;
double den2 = r.frags? (double)r.frags : 1.0;
if(r.deaths == 0 && r.frags) me.kdratio = r.frags;
else me.kdratio = (double)r.frags/r.deaths;
if(cvar.saystats && (lastfrags!=r.frags || lastdeaths!=r.deaths ))
{me.hspercent
;char tmp[128];
switch(cvar.saystats)
{
case 1:
sprintf(tmp,"say GooeyBase v.o0 - Kills: %d - Deaths: %d - HeadShots: %d - HeadShot Percentage: %4.02f Kills To Deaths Ratio: %4.02f", r.frags,r.deaths,me.headshots, me.hspercent, me.kdratio);
gEngfuncs.pfnClientCmd(tmp);
break;
}
}
}
bGotHeadshot = false;
lastfrags = r.frags;
lastdeaths = r.deaths;
}
retval = (*ScoreInfoOrg)(pszName,iSize,pbuf);
return retval;
}
//===================================================================================
int HookUserMsg (char *szMsgName, pfnUserMsgHook pfn)
{
int retval = gEngfuncs.pfnHookUserMsg (szMsgName, pfn);
if (!strcmp(szMsgName,"TeamInfo"))
{
TeamInfoOrg = pfn;
retval = gEngfuncs.pfnHookUserMsg (szMsgName, TeamInfo );
}
if (!strcmp(szMsgName,"CurWeapon"))
{
CurWeaponOrg = pfn;
retval = gEngfuncs.pfnHookUserMsg (szMsgName, CurWeapon );
}
if (!strcmp(szMsgName,"ScoreAttrib"))
{
ScoreAttribOrg = pfn;
retval = gEngfuncs.pfnHookUserMsg (szMsgName, ScoreAttrib );
pEngfuncs->pfnHookUserMsg = gEngfuncs.pfnHookUserMsg;
}
if (!strcmpi(szMsgName,"TextMsg"))
{
TextMsgOrg = pfn;
retval = gEngfuncs.pfnHookUserMsg (szMsgName, TextMsg );
}
if (!strcmpi(szMsgName,"ResetHUD"))
{
ResetHUDOrg = pfn;
retval = gEngfuncs.pfnHookUserMsg (szMsgName, ResetHUD );
}
if (!strcmpi(szMsgName,"WeaponList"))
{
WeaponListOrg = pfn;
retval = gEngfuncs.pfnHookUserMsg (szMsgName, WeaponList);
}
if (!strcmpi(szMsgName,"Money"))
{
MoneyOrg = pfn;
retval = gEngfuncs.pfnHookUserMsg (szMsgName, MsgMoney);
}
if (!strcmpi(szMsgName,"Battery"))
{
BatteryOrg = pfn;
retval = gEngfuncs.pfnHookUserMsg (szMsgName, MsgBattery);
}
if (!strcmpi(szMsgName,"DeathMsg"))
{
DeathMsgOrg = pfn;
retval = gEngfuncs.pfnHookUserMsg (szMsgName, DeathMsg);
}
if (!strcmpi(szMsgName,"SayText"))
{
SayMsgOrg = pfn;
retval = gEngfuncs.pfnHookUserMsg (szMsgName, SayMsg);
}
if (!strcmpi(szMsgName,"ScoreInfo"))
{
ScoreInfoOrg = pfn;
retval = gEngfuncs.pfnHookUserMsg (szMsgName, ScoreInfo);
}
return retval;
}
//===================================================================================
inline bool isEnemy(int ax)
{
return (me.team != vPlayers[ax].team);
}
//===================================================================================
ColorEntry* PlayerColor(int ax)
{
static ColorEntry colorDefault;
if (cvar.tglow && (ax == gAimbot.target)) { return colorList.get(4); }
if (vPlayers[ax].team == 1) { return colorList.get(1); }
else { return colorList.get(2); }
}
//===================================================================================
HSPRITE ch_sniper=-1, sniper_scope=-1;
void drawCrosshair()
{
if( me.inZoomMode ) { return; }
int centerX = displayCenterX;
int centerY = displayCenterY;
ColorEntry* clr = colorList.get(0);
int r=clr->r, g=clr->g, b=clr->b, a=clr->a;
}
//===================================================================================
char* gGetWeaponName( int weaponmodel )
{
static char weapon[50];
weapon[0]=0;
model_s* mdl = IEngineStudio.GetModelByIndex( weaponmodel );
if( !mdl ){ return weapon; }
char* name = mdl->name; if( !name ) { return weapon; }
int len = strlen(name); if( len>48 || len<10){ return weapon; }
strcpy(weapon,name+9); len -=9;
if(len>4)weapon[len-4]=(char)0;
return weapon;
}
//===================================================================================
inline void gDrawBoxAtScreenXY( int x, int y, int r, int g, int b, int alpha, int radius=1)
{
int radius2 = radius<<1;
gEngfuncs.pfnFillRGBA(x-radius+2, y-radius, radius2-2,2,r,g,b,alpha);
gEngfuncs.pfnFillRGBA(x-radius, y-radius, 2,radius2,r,g,b,alpha);
gEngfuncs.pfnFillRGBA(x-radius, y+radius, radius2,2,r,g,b,alpha);
gEngfuncs.pfnFillRGBA(x+radius, y-radius, 2,radius2+2,r,g,b,alpha);
}
//======================================================================================
void consoleBorder(int x,int y,int w, int h,int r,int g,int b)
{
oglSubtractive = true;
gEngfuncs.pfnFillRGBA( x-6, y-6, w+11, 1 , 0, 0, 0, 255 );
gEngfuncs.pfnFillRGBA( x-6, y-6, 1, h+12 , 0, 0, 0, 255 );
gEngfuncs.pfnFillRGBA( x+w+5, y-6, 1, h+12 , 0, 0, 0, 255 );
gEngfuncs.pfnFillRGBA( x-6, y+h+6, w+12, 1 , 0, 0, 0, 255 );
gEngfuncs.pfnFillRGBA( x-1, y-1, w+2, 1 , 0, 0, 0, 255 );
gEngfuncs.pfnFillRGBA( x-1, y-1, 1, h+2 , 0, 0, 0, 255 );
gEngfuncs.pfnFillRGBA( x-1, y+h+1, w+2, 1 , 0, 0, 0, 255 );
gEngfuncs.pfnFillRGBA( x+w, y-1, 1, h+2 , 0, 0, 0, 255 );
gEngfuncs.pfnFillRGBA( x-2, y-2, w+4, 1 , r/2, g/2, b/2, 255 );
gEngfuncs.pfnFillRGBA( x-2, y-2, 1, h+4 , r/2, g/2, b/2, 255 );
gEngfuncs.pfnFillRGBA( x-5, y+h+5, w+10, 1 , r/2, g/2, b/2, 255 );
gEngfuncs.pfnFillRGBA( x+w+4, y-4, 1, h+10 , r/2, g/2, b/2, 255 );
gEngfuncs.pfnFillRGBA( x-4, y-4, w+8, 2 , 0, 0, 5, 255 );
gEngfuncs.pfnFillRGBA( x-4, y-4, 2, h+8 , 0, 0, 5, 255 );
gEngfuncs.pfnFillRGBA( x-4, y+h+3, w+8, 2 , 0, 0, 5, 255 );
gEngfuncs.pfnFillRGBA( x+w+2, y-4, 2, h+9 , 0, 0, 5, 255 );
oglSubtractive = false;
gEngfuncs.pfnFillRGBA( x-5, y-5, w+10, 1 , 0, 0, 0, 192 );
gEngfuncs.pfnFillRGBA( x-5, y-5, 1, h+10 , 0, 0, 0, 192 );
gEngfuncs.pfnFillRGBA( x-2, y+h+2, w+4, 1 , 0, 0, 0, 192 );
gEngfuncs.pfnFillRGBA( x+w+1, y-1, 1, h+3 , 0, 0, 0, 192 );
}
static OgcCommandMenu::Menu* curMenu = ogcMenu.baseMenu;
bool menu_active = false;
bool gMenuActive(){ return menu_active; }
//===================================================================================
void drawMenu( )
{
if(!curMenu) return;
vector<OgcCommandMenu::MenuEntry>& items = curMenu->items;
int x=cvar.menu_x, y=cvar.menu_y, w=cvar.menu_w;
enum{ TEXT_H = 20 };
int title_h = TEXT_H+5;
int frame_y = cvar.menu_y - title_h;
int frame_h = items.size()*TEXT_H + title_h;
// title background
tintArea(x,frame_y,w,title_h,colorList.get(21));
consoleBorder(x,frame_y,w,frame_h);
// upper background
int h1 = curMenu->selection*TEXT_H;
if(h1)
{
tintArea(x,y,w,h1,colorList.get(21));
y+=h1;
}
// selection background
tintArea(x,y,w,TEXT_H,colorList.get(22));
y+=TEXT_H;
// lower background
int numItemsLeft = items.size() - curMenu->selection - 1;
if(numItemsLeft>0)
{
tintArea(x,y,w,numItemsLeft*TEXT_H,colorList.get(21));
}
// draw frame
register int c = 200;
gEngfuncs.pfnFillRGBA(x,frame_y,w,1 ,c,c,c,c);
gEngfuncs.pfnFillRGBA(x,frame_y,1,frame_h ,c,c,c,c);
gEngfuncs.pfnFillRGBA(x+w,frame_y,1,frame_h,c,c,c,c);
gEngfuncs.pfnFillRGBA(x,frame_y+frame_h,w,1,c,c,c,c);
gEngfuncs.pfnFillRGBA(x,cvar.menu_y,w+1,1 ,c,c,c,c);
DrawHudString(cvar.menu_x+10,frame_y+5,150,200,50,const_cast<char*>(curMenu->name.c_str()));
y=cvar.menu_y+4;
x+=4;
for(unsigned int i=0;i<items.size();i++)
{
OgcCommandMenu::MenuEntry& item = items[i];
ColorEntry* clr = colorList.get(23); // "menu_text"
gEngfuncs.pfnDrawSetTextColor(clr->onebased_r,clr->onebased_g,clr->onebased_b);
gEngfuncs.pfnDrawConsoleString(x,y,const_cast<char*>(item.name.c_str()));
y+=TEXT_H;
}
}
//===================================================================================
void menu_describe_current()
{
if(!menu_active||!curMenu) return;
OgcCommandMenu::MenuEntry& entry = curMenu->items[curMenu->selection];
strcpy(gHudMessage2, entry.description.c_str());
gHudTimer2.countdown(6);
}
//===================================================================================
void sendScriptSignal(const char* name)
{
char signal[32];
sprintf(signal,"sig%s",name);
cmd.exec(signal);
}
//===================================================================================
inline void drawPlayerEsp(int ax)
{
if( !vPlayers[ax].getPVS() ) { return; }
cl_entity_s* ent = vPlayers[ax].getEnt();
ColorEntry* color = PlayerColor(ax);
int r = color->r * cvar.esp_trans;
int g = color->g * cvar.esp_trans;
int b = color->b * cvar.esp_trans;
int a = color->a * cvar.esp_trans;
oglSubtractive = true;
oglSubtractive = false;
float vecScreen[2];
if (!CalcScreen(ent->origin,vecScreen)){ return; }
float distance = vPlayers[ax].distance/22.0;
int boxradius = (300.0*90.0) / (distance*fCurrentFOV);
BOUND_VALUE(boxradius,1,200);
int x = vecScreen[0];
int y = vecScreen[1];
const char* format_string;
const char* format_int;
if (vPlayers[ax].visible) { format_string="%s"; format_int="%i"; }
else { format_string="-%s-";format_int="-%i-"; }
enum{ CHAR_HEIGHT = 16 };
int text_dist = (int)(cvar.esp_offs*(float)boxradius);
int ystep = -CHAR_HEIGHT;
if (cvar.weapon)
{
DrawHudStringCenter(x,y,r,g,b,format_string,gGetWeaponName(ent->curstate.weaponmodel));
y += ystep;
}
if (cvar.name )
{
char displayname[32];
int len = (cvar.name==1) ? 8 : cvar.name;
if(len<0 || len>30) { len = 30; }
strncpy(displayname,vPlayers[ax].entinfo.name,len);
displayname[len] = 0;
DrawHudStringCenter(x,y,r,g,b,format_string,displayname);
y += ystep;
}
}
//===================================================================================
inline void drawEsp(int ab)
{
float vecScreen[2];
char weapon[64];
vec3_t EntViewOrg;
VectorCopy(vEntity[ab].ent->origin,EntViewOrg);
memset(&weapon,0,50);
if(!( vEntity[ab].ent
&& vEntity[ab].ent->model
&& vEntity[ab].ent->model->name )) { return; }
char* text = vEntity[ab].ent->model->name;
ColorEntry* color = colorList.get(9);
bool special = false;
int len = strlen(text);
if( len<8 ) { return; }
char* w_pos = strstr(text, "w_");
if (len>10 && w_pos)
{
strcpy(weapon,text+9);
if( (w_pos[2]=='c'&&w_pos[3]=='4')||
(w_pos[2]=='b'&&w_pos[3]=='a'&&w_pos[4]=='c') )
{
color = colorList.get(3); special=true;
}
}
else
{
strcpy(weapon,text+7);
vec3_t forward,right,up;
gEngfuncs.pfnAngleVectors (vEntity[ab].ent->angles, forward, right, up);
EntViewOrg = EntViewOrg + up * 75;
color = colorList.get(3);
special = true;
}
if(cvar.esp && CalcScreen(EntViewOrg,vecScreen) && (!special||blinkPhase) )
{
weapon[strlen(weapon)-4]=(char)0;
DrawHudStringCenter(vecScreen[0],vecScreen[1],color->r,color->g,color->b,weapon);
}
}
//===================================================================================
void ogc_exec(const char* filename)
{
string file = getOgcDirFile(filename);
file += ".cfg";
cmd.execFile( file.c_str() );
}
//===================================================================================
void playerCalcExtraData(int ax, cl_entity_s* ent)
{
PlayerInfo& r = vPlayers[ax];
if( ent->curstate.effects&EF_NODRAW ) { r.clearPVS(); return; }
if( ent==me.ent ) { r.clearPVS(); return; }
switch(ent->curstate.rendermode)
{
case kRenderTransColor:
case kRenderTransTexture:
if( ent->curstate.renderamt<128 ) { r.clearPVS(); return; }
break;
case kRenderNormal:
break;
default:
r.clearPVS();
return;
}
if(!r.getPVS()) return;
r.distance = GetDistanceFrom (ent->origin); if(r.distance<1) r.distance=1;
gAimbot.CalcFovangleAndVisibility(ax);
}
//===================================================================================
void hudDrawInfoTexts()
{
int line_y = displayCenterY*2-180;
int line_x = 20;
#define DECREMENT_LINE_Y { line_y-=16; }
if(cvar.hudvec)
{
int& stat_x = cvar.stat_x;
int& stat_y = cvar.stat_y;
DrawHudString(stat_x,stat_y-26, 150,200,50,"[ Vectorizatoin ]:");
DrawHudString(stat_x,stat_y-16, 150,200,50," ----------------");
DrawHudString(stat_x,stat_y, 150,200,50,"avadd 0:");
vector<aimvec>::iterator si = gAimbot.AimVecsS.begin();
DrawHudString(stat_x+75 ,stat_y, 150,200,50,"[ Height ]: %4.2f [ Forward ]: %4.2f [ Right ]: %4.2f",si->h,si->f,si->r);
DrawHudString(stat_x ,stat_y+16, 150,200,50,"avadd 1:");
vector<aimvec>::iterator dsi = gAimbot.AimVecsD.begin();
DrawHudString(stat_x+75 ,stat_y+16,150,200,50,"[ Height ]: %4.2f [ Forward ]: %4.2f [ Right ]: %4.2f",dsi->h,dsi->f,dsi->r);
DrawHudString(stat_x ,stat_y+32, 150,200,50,"avadd 2:");
vector<aimvec>::iterator jsi = gAimbot.AimVecsJ.begin();
DrawHudString(stat_x+75 ,stat_y+32, 150,200,50,"[ Height ]: %4.2f [ Forward ]: %4.2f [ Right ]: %4.2f",jsi->h,jsi->f,jsi->r);
}
if(cvar.myhud)
{
PlayerInfo& r = vPlayers[me.ent->index];
int& hudstats_x = cvar.hudstats_x;
int& hudstats_y = cvar.hudstats_y;
int iHealth = *(int*)0x119848;
int iArmor = *(int*)0x1A1D894;
DrawHudString(hudstats_x,hudstats_y ,150,200,50, "[ GooeyBase Info ]");
DrawHudString(hudstats_x,hudstats_y+10 ,150,200,50, " -------------------");
DrawHudString(hudstats_x,hudstats_y+20 ,150,200,50, "--Kills: %d",r.frags);
DrawHudString(hudstats_x,hudstats_y+40 ,150,200,50, "--Deaths: %d",r.deaths);
DrawHudString(hudstats_x,hudstats_y+60 ,150,200,50, "--Health %d", iHealth);
DrawHudString(hudstats_x,hudstats_y+80 ,150,200,50, "--Armor: %d", iArmor);
DrawHudString(hudstats_x,hudstats_y+100 ,150,200,50, "--Cash: %d",playerItems.money);
DrawHudString(hudstats_x,hudstats_y+120 ,150,200,50, "--Spread: %1.2f",me.spread.spreadvar);
DrawHudString(hudstats_x,hudstats_y+140 ,150,200,50, "--Recoil: %1.2f",cvar.recoil);
DrawHudString(hudstats_x,hudstats_y+160 ,150,200,50, "--Rounds: %i", iRounds);
DrawHudString(hudstats_x,hudstats_y+180 ,150,200,50, "--Headshots: %d",me.headshots);
DrawHudString(hudstats_x,hudstats_y+200 ,150,200,50, "--HS Prcnt: %4.1f",me.hspercent);
DrawHudString(hudstats_x,hudstats_y+220 ,150,200,50, "--Weapon: %s",gGetWeaponName(me.ent->curstate.weaponmodel));
}
if (cvar.info)
{
ColorEntry* clr=colorList.get(13);
if(gHudTimer.running())
{
DrawHudString(line_x,line_y,clr->r,clr->g,clr->b, gHudMessage );
DECREMENT_LINE_Y
}
if( gHudTimer2.running() )
{
DrawHudString(line_x,line_y,clr->r,clr->g,clr->b,gHudMessage2 );
DECREMENT_LINE_Y
}
}
}
//========================================================================================
void UpdateScreenInfo(void)
{
screeninfo.iSize=sizeof(SCREENINFO);
gEngfuncs.pfnGetScreenInfo(&screeninfo);
displayCenterX = screeninfo.iWidth/2;
displayCenterY = screeninfo.iHeight/2;
}
void ThatTimeAndDay()
{
char time[128];
char date[128];
int& time_x = cvar.time_x;
int& time_y = cvar.time_y;
_strtime( time );
DrawHudString(time_x, time_y, 150,200,50, "%s", time );
_strdate( date );
DrawHudString(time_x, time_y-20, 150,200,50, "%s", date );
}
//===================================================================================
int HUD_Redraw (float x, int y)
{
int nResult=0;
if(cvar.timeday)
{
ThatTimeAndDay();
}
if(cvar.chase_cam)
{
cmd.exec("chase_active hide 1;r_drawviewmodel hide 0");
cvar.chaseofs = -100;
} else {
cmd.exec("chase_active hide 0;r_drawviewmodel hide 1");
cvar.chaseofs = 0.0;
}
ClientTime::reportMapTime(gEngfuncs.GetClientTime());
me.ent = gEngfuncs.GetLocalPlayer();
hudDrawInfoTexts();
if (menu_active) { drawMenu (); }
for( ScheduleList::iterator pos = scheduleList.begin();
pos != scheduleList.end();
++pos)
{
if( (*pos).timer.expired() )
{
cmd.exec( const_cast<char*>((*pos).cmd.c_str()) );
scheduleList.erase(pos);
break;
}
}
static bool done=false;
if(!done)
{
UpdateScreenInfo();
done=true;
}
static bool previous_alive_state=false;
if ( previous_alive_state && !me.alive ) { sendScriptSignal("dead" ); }
else if( !previous_alive_state && me.alive ) { sendScriptSignal("alive" ); }
previous_alive_state = me.alive;
if(blinkTimer.expired())
{
blinkPhase = !blinkPhase;
if(blinkPhase){ blinkTimer.countdown(0.2f); }
else { blinkTimer.countdown(0.1f); }
}
if (cvar.flash)
{
static screenfade_t sf = { 0.0, 0.0, 0.0, 0.0, 0, 0, 0, 0, 0 };
gEngfuncs.pfnSetScreenFade( &sf );
}
if(cvar.esp)
for (int ab=0;ab<vEntity.size();ab++) drawEsp(ab);
vEntity.clear();
for (int ax=0;ax<vPlayers.size();ax++)
{
cl_entity_s* ent = vPlayers[ax].getEnt();
int seqinfo = Cstrike_SequenceInfo[ent->curstate.sequence];
float vecScreen[3];
if(CalcScreen(vPlayers[ax].getEnt()->origin,vecScreen))
{
int x = vecScreen[0];
int y = vecScreen[1];
float val1 = vPlayers[ax].getEnt()->curstate.animtime;
float val2 = vPlayers[ax].lastMsg;
static lastSame[36] = { false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false};
static repeat[36] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
if(!lastSame[ax] && val1==val2)
{
repeat[ax]++;
lastSame[ax] = true;
}
else if(lastSame[ax] && val1==val2)
repeat[ax]++;
else if(lastSame[ax] && val1!=val2)
{
repeat[ax] = 0;
lastSame[ax] = false;
}
if(vPlayers[ax].getPVS() && vPlayers[ax].getEnt()->curstate.solid)
{
if(cvar.frzn_esp)
{
if(val1=val2 && repeat[ax]>34)
DrawHudStringCenter(x,y+32,64,144,255,"frozEn");
}
}
vPlayers[ax].lastMsg = vPlayers[ax].getEnt()->curstate.animtime;
}
if (vPlayers[ax].getPVS()) drawPlayerEsp(ax);
}
if(cvar.avdraw) gAimbot.Draw();
gConsole.draw(cvar.con_x,cvar.con_y,cvar.con_w,cvar.con_h);
if(!gConsole.active)
{
cvar.timeday = false;
cvar.hudvec = false;
cvar.myhud = false;
}
return nResult;
}
//===================================================================================
void ActivatePlayer(struct cl_entity_s *ent)
{
int px = ent->index;
if(cvar.alive_method==1)
{
if(ent->curstate.solid) { vPlayers[px].setAlive(); }
if(ent==me.ent) { me.alive = vPlayers[px].getAlive(); }
}
else if(cvar.alive_method==2)
{
if(ent->curstate.solid) { vPlayers[px].setAlive(); }
else { vPlayers[px].setAlive(false);}
if(ent==me.ent) { me.alive = vPlayers[px].getAlive(); }
}
vPlayers[px].setPVS();
gEngfuncs.pfnGetPlayerInfo(ent->index, &vPlayers[px].entinfo);
if(ent == me.ent)
{
vPlayers[px].distance = 100000.0;
vPlayers[px].visible = 0;
vPlayers[px].fovangle = 360;
vPlayers[px].clearPVS();
return;
}
playerCalcExtraData(px,ent);
}
//===================================================================================
void AddEntity(struct cl_entity_s *ent)
{
hostage_info dummy;
dummy.ent = ent;
if(vEntity.size()<64) vEntity.push_back(dummy);
}
//===================================================================================
inline void drawLine(float*from, float*to, ColorEntry*color)
{
gEngfuncs.pEfxAPI->R_BeamPoints(from,to,beamindex,0.001f,0.9f,0.5,32,2,0,10,color->fr,color->fg,color->fb);
}
//===================================================================================
void HUD_TempEntUpdate (
double frametime,
double client_time,
double cl_gravity,
TEMPENTITY **ppTempEntFree,
TEMPENTITY **ppTempEntActive,
int ( *Callback_AddVisibleEntity )( cl_entity_t *pEntity ),
void ( *Callback_TempEntPlaySound )( TEMPENTITY *pTemp, float damp ) )
{
typedef void (*HUD_TempEntUpdateFunc)(double,double,double,TEMPENTITY**,TEMPENTITY**, int(*)(cl_entity_t*),void(*)(TEMPENTITY*,float));
(*(HUD_TempEntUpdateFunc)(pHUD_TempEntUpdate))(
frametime,
client_time,
cl_gravity,
ppTempEntFree,
ppTempEntActive,
Callback_AddVisibleEntity,
Callback_TempEntPlaySound
);
me.ent = gEngfuncs.GetLocalPlayer();
ClientTime::reportMapTime( client_time );
if(!beamindex) { beamindex = gEngfuncs.pEventAPI->EV_FindModelIndex("sprites/laserbeam.spr"); }
}
//===================================================================================
void PreV_CalcRefdef (struct ref_params_s *pparams)
{
VectorCopy(pparams->punchangle,me.punchangle);
if (cvar.recoil) for (int i=0; i<3; i++) pparams->punchangle[i] = 0;
if( pparams->nextView == 0 )
{
if (cvar.spec_fix)
{
gAimbot.FindTarget();
} else {
gAimbot.target = -1;
}
if ( !me.alive) { cvar.speed = 0.0; }
if ( cvar.aim )
if ( (me.iClip && me.pmMoveType!=5) || !me.alive )
if ( gAimbot.target!=-1 )
if ( pparams->nextView == 0 )
{
Aimbot_active = true;
gAimbot.CalcViewAngles();
VectorCopy(gAimbot.aim_viewangles, pparams->viewangles);
VectorCopy(gAimbot.aim_viewangles, pparams->cl_viewangles);
}
for (int ax=0;ax<vPlayers.size();ax++)
{
vPlayers[ax].decrPVS();
vPlayers[ax].numTargetSpots = 0;
}
}
}
//===================================================================================
void PostV_CalcRefdef (struct ref_params_s *pparams)
{
if( pparams->nextView == 0 )
{
VectorCopy(pparams->viewangles,mainViewAngles);
VectorCopy(pparams->vieworg,mainViewOrigin);
if(cvar.chaseofs)
{
vec3_t vecEnd, up, right, forward, EntViewOrg;
gEngfuncs.pfnAngleVectors (mainViewAngles, forward, right, up);
mainViewOrigin[0] += cvar.chaseofs*forward[0];
mainViewOrigin[1] += cvar.chaseofs*forward[1];
mainViewOrigin[2] -= cvar.chaseofs*forward[2];
}
}
}
//===================================================================================
void V_CalcRefdef (struct ref_params_s *pparams)
{
me.ent = gEngfuncs.GetLocalPlayer();
PreV_CalcRefdef(pparams);
pV_CalcRefdef(pparams);
PostV_CalcRefdef(pparams);
}
bool IsFrozen(void)
{
if (cvar.mefrozen)
return gEngfuncs.GetClientTime() - me.ent->ph[me.ent->current_position].animtime > cvar.mefrozen;
return false;
}
void opengl_ClearBackground();
//===================================================================================
void CL_CreateMove (float frametime, struct usercmd_s *usercmd, int active)
{
static StopTimer nextSwitchWait;
static float recoiltime = 0;
float offset[3];
me.ent = gEngfuncs.GetLocalPlayer();
bNewFrame = true;
if (cvar.wall >= 1) { opengl_ClearBackground(); }
if (IsFrozen())
{
cvar.speed = cvar.fspeed;
return;
}
if (gAimbot.target != -1 && me.iClip && me.pmMoveType != 5 && cvar.aim)
{
VectorCopy ( gAimbot.aim_viewangles, usercmd->viewangles );
gEngfuncs.SetViewAngles ( gAimbot.aim_viewangles);
}
if ((gAimbot.target!=-1) && cvar.aim)
{
if (me.iClip)
{
if (cvar.spam)
{
usercmd->buttons |= IN_ATTACK;
}
} else {
if (playerItems.canSwitch() && nextSwitchWait.expired())
{
nextSwitchWait.countdown(.001);
cmd.exec("#slot2");
}
if (playerItems.canswitch() && nextSwitchWait.expired())
{
nextSwitchWait.countdown(.001);
cmd.exec("#slot1");
}
}
}
if (usercmd->buttons&IN_ATTACK && me.alive)
{
if (!me.iClip && playerItems.canSwitch() && nextSwitchWait.expired())
{
nextSwitchWait.countdown(.001);
cmd.exec("#slot2");
}
if (!me.iClip && playerItems.canswitch() && nextSwitchWait.expired())
{
nextSwitchWait.countdown(.001);
cmd.exec("#slot1");
}
if (currentWeaponID>=WEAPON_USP && currentWeaponID<=WEAPON_FIVE7)
{
static bool flipFlop = true;
if(flipFlop){ usercmd->buttons |= IN_ATTACK; }
else { usercmd->buttons &= (~IN_ATTACK); }
flipFlop = !flipFlop;
}
if (cvar.aspeed>1 && currentWeaponID!=WEAPON_C4 && currentWeaponID!=WEAPON_HE && currentWeaponID!=WEAPON_FLASH && currentWeaponID!=WEAPON_SMOKE)
{
cvar.speed = cvar.aspeed;
}
if (cvar.aspeed>1 && currentWeaponID!=WEAPON_C4)
{
cvar.speed = cvar.aspeed;
}
} else {
if (cvar.aspeed>1)
{
cvar.speed = 1.0;
}
}
if (currentWeaponID!=WEAPON_HE && currentWeaponID!=WEAPON_FLASH && currentWeaponID!=WEAPON_SMOKE && currentWeaponID!=WEAPON_C4 && me.alive)
{ cvar.aim = 1;} else { cvar.aim = 0;}
if (me.alive)
{
if (cvar.nospread)
{
GetRecoilOffset(me.spread.random_seed, 1, usercmd->viewangles, me.pmVelocity, offset);
usercmd->viewangles[0] += offset[0];
usercmd->viewangles[1] += offset[1];
usercmd->viewangles[2] += offset[2];
}
if (cvar.recoil)
{
usercmd->viewangles[0] -= (me.punchangle[0] * cvar.recoil);
usercmd->viewangles[1] -= (me.punchangle[1] * cvar.recoil);
}
if (cvar.jump && (usercmd->buttons & IN_JUMP) && !(me.pmFlags & FL_ONGROUND)) usercmd->buttons &= ~IN_JUMP;
if (cvar.duck && !(me.pmFlags & FL_ONGROUND) && me.pmVelocity[2]>0) usercmd->buttons |= IN_DUCK;
}
}
//===================================================================================
void HUD_PlayerMove (struct playermove_s *a, int b)
{
me.ent = gEngfuncs.GetLocalPlayer();
me.pmFlags = a->flags;
me.pmMoveType = a->movetype;
VectorCopy(a->velocity,me.pmVelocity);
gEngfuncs.pEventAPI->EV_LocalPlayerViewheight(me.pmEyePos);
if(me.alive) me.pmEyePos[2] += cvar.height_correction;
me.pmEyePos[0]+= a->origin[0];
me.pmEyePos[1]+= a->origin[1];
me.pmEyePos[2]+= a->origin[2];
float yaw = a->angles[1] * (3.141592/180 );
me.sin_yaw = sin(yaw);
me.minus_cos_yaw = -cos(yaw);
me.viewAngles[0] = a->angles[0];
me.viewAngles[1] = a->angles[1];
me.viewAngles[2] = a->angles[2];
}
static void playerRenderOptions(cl_entity_s* ent)
{
ColorEntry* color = PlayerColor(ent->index);
}
int AddEntResult = 1;
//===================================================================================
void HUD_AddEntity (int type, struct cl_entity_s *ent, const char *modelname)
{
int retval = 1;
static int beamindex = 0;
if (ent->player){
ActivatePlayer(ent);
if(vPlayers[ent->index].getPVS()) {
ent->curstate.rendermode = 0;
playerRenderOptions(ent);
}
}else if(strstr(modelname, "w_") || strstr(modelname, "hostage") || strstr(modelname, "scientist")) {
AddEntity(ent);
}
else if (type==ET_NORMAL && cvar.trans && ent->curstate.solid==SOLID_BSP)
{
ent->curstate.rendermode=2;
ent->curstate.renderamt=cvar.trans;
}
if (cvar.smoke && (strstr(modelname, "black_smoke")||strstr(modelname, "fast_wallpuff")))
retval= 0;
if (cvar.smoke > 1 && strstr(modelname, "steam1"))
retval= 0;
AddEntResult = retval;
}
//===================================================================================
HSPRITE SPR_Load(const char *szPicName)
{
HSPRITE spr = gEngfuncs.pfnSPR_Load (szPicName);
if(strstr(szPicName,"sniper_scope")) sniper_scope = spr;
else if(strstr(szPicName,"ch_sniper")) ch_sniper = spr;
add_sprite (spr, szPicName);
return spr;
}
//===================================================================================
inline void strcpy_x(char* dest, const char* pos)
{
do{
while( *pos>='0' && *pos<='9' ) ++pos;
if(*pos=='.') {*dest=0;break; }
*dest=*pos;
++dest;
++pos;
}
while(*pos);
}
//===================================================================================
inline void strcpy_x2(char* dest, const char* pos)
{
do{
if(*pos=='.'||*pos=='-'||*pos=='_') {*dest=0;break; }
*dest=*pos;
++dest;
++pos;
}
while(*pos);
}
//===================================================================================
inline static void lowercase(char* str)
{
while(*str){ *str = tolower(*str); ++str; }
}
//===================================================================================
void semicolonToZero(string& s)
{
for(string::iterator pos = s.begin();pos!=s.end();pos++)
{
if(*pos==';') { *pos=0; }
}
}
//===================================================================================
void func_alias()
{
const char* name = cmd.argC(1);
string& content = cmd.argS(2);
cmd.AddAlias(name,content);
}
//===================================================================================
void func_bind()
{
keyBindManager.addBind(cmd.argC(1),cmd.argC(2));
}
//===================================================================================
void func_unbind()
{
keyBindManager.removeBind(cmd.argC(1));
}
//===================================================================================
void func_remap()
{
keyBindManager.remapKey(cmd.argC(1),cmd.argC(2));
}
//===================================================================================
void hookCommandParser( char* cmdString, int size )
{
char* pos = cmdString;
int charsLeft = size;
bool passThroughBlock = false;
if( *(DWORD*)pos == cmd.excludePrefixDword )
{
passThroughBlock = true;
pos[0]=pos[1]=pos[2]=pos[3]=' ';
charsLeft-=4;
pos+=4;
}
while(charsLeft>0 && (*pos==' '||*pos=='\t')){pos++;charsLeft--;}
if(charsLeft<=0){ return; }
char command[32];
char* commandPos = command;
int commandCharsLeft = 30;
while(charsLeft>0 && *pos>' ' && commandCharsLeft>0)
{
*commandPos = tolower(*pos);
commandPos++;
pos++;
charsLeft--;
commandCharsLeft--;
}
*commandPos = 0;
if(!*command) return;
if(!strcmp(command,"messagemode")||!strcmp(command,"messagemode2"))
{
keyBindManager.messageMode = true;
}
}
//===================================================================================
void CB_KeyManager_Exec(const string& commandlist)
{
cmd.exec( const_cast<char*>( commandlist.c_str() ) );
}
//===================================================================================
void CB_KeyManager_ConType(char ch)
{
gConsole.key(ch);
}
//===================================================================================
void gSetHudMessage2(const char* message)
{
strcpy(gHudMessage2,message);
gHudTimer2.countdown(4);
}
//===================================================================================
void gSetHudMessage(const char* message)
{
strcpy(gHudMessage,message);
gHudTimer.countdown(4);
}
void AtRoundStart(void)
{
int Id;
cmd.exec ("later 4 #say GooeyBase v.o0");
gAimbot.target = -1;
cvar.spec_fix = true;
playerItems.clearWeaponSlots();
cvar.inpvs = 0;
cvar.inpvs = 2;
if(me.team>0 && cvar.alive_method==1 )
{
me.alive = true;
}
sendScriptSignal("round");
Id = playerItems.CurrentID();
if (Id == WEAPONLIST_SG550 || Id == WEAPONLIST_G3SG1)
me.spread.brokentime = 0; // This catches all cases except when you buy one and than shoot some bullets and that buy another
}
//===================================================================================
void AtMapChange()
{
iRounds=0;
bBombIsPlanted=false;
fBombPlantedTime=0;
iC4Timer=0;
gAimbot.target = -1;
playerItems.clearWeaponSlots();
gHudTimer.setExpired();
gHudTimer2.setExpired();
me.spread.prcflags = 0;
me.spread.random_seed = 0;
me.spread.recoil = 0;
me.spread.gtime = 0;
me.spread.prevtime = 0;
me.spread.brokentime = 0;
me.spread.spreadvar = 0;
me.spread.recoiltime = 0;
me.spread.firing = false;
}
//===================================================================================
void HlEngineCommand(const char* command)
{
if(!gEngfuncs.pfnClientCmd) { return; }
gEngfuncs.pfnClientCmd( const_cast<char*>(command) );
}
//===================================================================================
void HandleCvarInt(char* name, int* value)
{
char* arg1 = cmd.argC(1);
if (!strcmp(arg1,"change"))
{
if (*value) *value=0; else *value=1;
if(cvar.info==3||menu_active){ sprintf(gHudMessage,"%s changed to %d", name, *value );gHudTimer.countdown(3);}
return;
}
if (!strcmp(arg1,"up"))
{
*value += cmd.argI(2);
if(cvar.info==3||menu_active){ sprintf(gHudMessage,"%s increased to %d", name, *value );gHudTimer.countdown(3);}
return;
}
if (!strcmp(arg1,"down"))
{
*value -= cmd.argI(2);
if(cvar.info==3||menu_active){ sprintf(gHudMessage,"%s decreased to %d", name, *value );gHudTimer.countdown(3);}
return;
}
if (!strcmp(arg1,"hide"))
{
*value = cmd.argI(2);
return;
}
if (!*arg1)
{
Con_Echo( "CvaR &w%s&a = %i\n",name,*value);
return;
}
*value = cmd.argI(1);
if(cvar.info==3||menu_active){ sprintf(gHudMessage,"%s: %d", name, *value );gHudTimer.countdown(3);}
}
//===================================================================================
void HandleCvarFloat(char* name, float* value)
{
char* arg1 = cmd.argC(1);
if (!strcmp(arg1,"change"))
{
if (*value) *value=0; else *value=1;
if(cvar.info==3||menu_active){ sprintf(gHudMessage,"%s changed to %f", name, *value );gHudTimer.countdown(3); }
return;
}
if (!strcmp(arg1,"up"))
{
*value += cmd.argF(2);
if(cvar.info==3||menu_active){ sprintf(gHudMessage,"%s increased to %f", name, *value );gHudTimer.countdown(3);}
return;
}
if (!strcmp(arg1,"down"))
{
*value -= cmd.argF(2);
if(cvar.info==3||menu_active){ sprintf(gHudMessage,"%s decreased to %f", name, *value );gHudTimer.countdown(3);}
return;
}
if (!strcmp(arg1,"hide"))
{
*value = cmd.argI(2);
return;
}
if (!*arg1)
{
Con_Echo( "CVAR &w%s&r = %f\n",name,*value);
return;
}
*value = cmd.argF(1);
if(cvar.info==3||menu_active){sprintf(gHudMessage,"%s: %f", name, *value );gHudTimer.countdown(3);}
}
//===================================================================================
bool isHlCvar(char* name)
{
if(!gEngfuncs.pfnGetCvarPointer) { return false; }
cvar_s* test = gEngfuncs.pfnGetCvarPointer(name);
return (test!=NULL);
}
//===================================================================================
void HandleHlCvar(char* name)
{
if(!gEngfuncs.pfnGetCvarPointer) { return; }
cvar_s* ptr = gEngfuncs.pfnGetCvarPointer(name);
if(!ptr) return;
HandleCvarFloat(name,&ptr->value);
}
//===================================================================================
void func_menu_back()
{
if(!menu_active || !curMenu) return;
curMenu = curMenu->parent;
if(!curMenu)
{
curMenu = ogcMenu.baseMenu;
menu_active=false;
gHudTimer.countdown(0.1);
sendScriptSignal("menuoff");
}
curMenu->boundSelection();
menu_describe_current();
}
void func_menu_up()
{
if(!menu_active || !curMenu) return;
--curMenu->selection;
curMenu->boundSelection();
menu_describe_current();
}
void func_menu_off()
{
menu_active=false;
gHudTimer.countdown(0.1);
sendScriptSignal("menuoff");
cmd.exec("play sounds/Menu/close.wav");
}
void func_menu_down()
{
if(!menu_active || !curMenu) return;
++curMenu->selection;
curMenu->boundSelection();
menu_describe_current();
}
void func_menu_select()
{
if(!curMenu)
{
curMenu = ogcMenu.baseMenu;
menu_active = true;
menu_describe_current();
return;
}
if(menu_active)
{
OgcCommandMenu::MenuEntry& entry = curMenu->items[curMenu->selection];
if(entry.menu)
{
curMenu = entry.menu;
curMenu->boundSelection();
menu_describe_current();
}
else
cmd.exec(const_cast<char*>(entry.content.c_str()));
}
menu_active=true;
}
//===================================================================================
void func_echo()
{
string str;
cmd.collectArguments(str);
Con_Echo ("%s\n",str.c_str());
}
//===================================================================================
void func_text()
{
string s;
cmd.collectArguments(s);
gSetHudMessage2( s.c_str() );
}
//===================================================================================
void func_avadd(void)
{
aimvec av;
int duck = cmd.argI(1);
int arg = 2;
while(*cmd.argC(arg))
{
av.h = cmd.argF(arg++);
av.f = cmd.argF(arg++);
av.r = cmd.argF(arg++);
if (duck == 1)
{
gAimbot.AimVecsD.push_back(av);
}
if (duck == 0)
{
gAimbot.AimVecsS.push_back(av);
}
if (duck == 2)
{
gAimbot.AimVecsJ.push_back(av);
}
}
}
void func_avclear(void)
{
gAimbot.AimVecsS.clear();
gAimbot.AimVecsJ.clear();
gAimbot.AimVecsD.clear();
}
//
//===================================================================================
void func_later()
{
if(cmd.argS(1).empty())
{
list<ScheduledCommand>::iterator pos;
for(pos=scheduleList.begin();pos!=scheduleList.end();++pos)
{
Con_Echo("%6.2f sec: \"%s\"", (*pos).timer.timeleft(), (*pos).cmd.c_str() );
}
return;
}
if(cmd.argS(1)=="clear")
{
scheduleList.erase(scheduleList.begin(),scheduleList.end());
return;
}
float time = cmd.argF(1);
ScheduledCommand tmp;
cmd.collectArguments( tmp.cmd, 2);
tmp.timer.countdown(time);
if(scheduleList.size()<32) scheduleList.push_back(tmp);
}
//===================================================================================
void func_color()
{
int arg=1;
while(*cmd.argC(arg)){
colorList.set( cmd.argC(arg ), cmd.argC(arg+1),
cmd.argC(arg+2), cmd.argC(arg+3), cmd.argC(arg+4));
arg+=5;
}
}
//===================================================================================
bool func_eval_condition(int& refArgIndex)
{
char* test = cmd.argC(refArgIndex++);
char* szArg = cmd.argC(refArgIndex++);
if(!*test||!*szArg){ return false; }
if( !strcmp(test,"has" )) { return playerItems.hasWeapon(szArg);}
if( !strcmp(test,"hasno" )) { return !playerItems.hasWeapon(szArg);}
if( !strcmp(test,"is" ))
{
if(!strcmp(szArg,"t" )) { return me.team==1; }
if(!strcmp(szArg,"ct" )) { return me.team!=1; }
if(!strcmp(szArg,"alive")) { return (me.alive); }
}
if(!strcmp(test,"money<" )){ return (playerItems.money<atoi(szArg)); }
if(!strcmp(test,"money>="))
{
bool condition = (playerItems.money>=atoi(szArg));
if(!condition){ strcpy(gHudMessage,"[OGC] Not enough money.");gHudTimer.countdown(1.5); }
return condition;
}
if( !strcmp(test,"armor<" ) ){ return (playerItems.armor< atoi(szArg));}
if( !strcmp(test,"armor>=") ){ return (playerItems.armor>=atoi(szArg));}
return false;
}
//===================================================================================
void func_if()
{
int pos = 1;
bool final_condition = func_eval_condition(pos);
while(1){
if( *cmd.argC(pos)=='&' ) {
final_condition &= func_eval_condition(pos);
} else if( *cmd.argC(pos)=='|' ) {
final_condition |= func_eval_condition(pos);
} else {
break;
}
}
int truepos = pos;
int elsepos = 0;
while(1){
char* arg = cmd.argC(pos);
if(!*arg) { break; }
if(!strcmp(arg,"else")) { elsepos = pos; break; }
pos++;
}
string command;
if( !elsepos )
{
if(final_condition)
{
cmd.collectArguments(command,truepos);
cmd.exec( const_cast<char*>( command.c_str() ) );
}
} else {
if(final_condition)
{
cmd.collectArguments(command,truepos,elsepos-1);
cmd.exec( const_cast<char*>( command.c_str() ) );
} else {
cmd.collectArguments(command,elsepos+1);
cmd.exec( const_cast<char*>( command.c_str() ) );
}
}
}
void func_quit() { ExitProcess(0); }
void func_exec() { ogc_exec( cmd.argC(1) ); }
void func_colortag() { gConsole.setcolortag(cmd.argC(1)[0],cmd.argI(2),cmd.argI(3),cmd.argI(4)); }
void func_console_toggle()
{
gConsole.active = !gConsole.active;
}
//===================================================================================
void collectArgumentsX(string& dest,int from=1, int to=1000000)
{
while(from<=to){
char* arg = gEngfuncs.Cmd_Argv(from++);
if(!*arg) { break;}
dest += '\"';
dest += arg ;
dest += '\"';
if(from!=to)dest += " ";
};
}
//===================================================================================
void interface_func()
{
string ogc_command = gEngfuncs.Cmd_Argv(1);
ogc_command += " ";
collectArgumentsX(ogc_command,2);
cmd.exec( ogc_command.c_str() );
}
//===================================================================================
void func_interface()
{
if(cmd.argS(1).empty()) return;
gEngfuncs.pfnAddCommand( strdup(cmd.argC(1)), interface_func );
}
//===================================================================================
void Init_Command_Interpreter()
{
cmd.init();
cvar.init();
cmd.AddCvarInt( "alive", (int*)&me.alive );
cmd.AddCvarInt( "target", (int*)&gAimbot.target );
#define REGISTER_COMMAND(c) cmd.AddCommand( #c, func_##c);
REGISTER_COMMAND(avadd )
REGISTER_COMMAND(echo )
REGISTER_COMMAND(later )
REGISTER_COMMAND(alias )
REGISTER_COMMAND(menu_select)
REGISTER_COMMAND(menu_back )
REGISTER_COMMAND(colortag )
REGISTER_COMMAND(menu_off )
REGISTER_COMMAND(interface )
REGISTER_COMMAND(menu_up )
REGISTER_COMMAND(avclear )
REGISTER_COMMAND(text )
REGISTER_COMMAND(color )
REGISTER_COMMAND(if )
REGISTER_COMMAND(quit )
REGISTER_COMMAND(bind )
REGISTER_COMMAND(unbind )
REGISTER_COMMAND(exec )
REGISTER_COMMAND(menu_down )
REGISTER_COMMAND(console_toggle)
cmd.AddCommand("txt" , func_text);
}
//=====================================================================================
int KeyEventResult = 1;
void HUD_Key_Event( int eventcode, int keynum, const char *pszCurrentBinding )
{
const char PROC_NAME[50] = "HUD_Key_Event_Hook\0";
int retval = 1;
if (keynum >= 239 && keynum <= 244)
{
switch (keynum) {
case 239:
keyBindManager.notifyMouseEvent("mwheeldown", (eventcode == 1));
break;
case 240:
keyBindManager.notifyMouseEvent("mwheelup", (eventcode ==1));
break;
case 241:
keyBindManager.notifyMouseEvent("mouse1", (eventcode == 1));
break;
case 242:
keyBindManager.notifyMouseEvent("mouse2", (eventcode == 1));
break;
case 243:
keyBindManager.notifyMouseEvent("mouse3", (eventcode == 1));
break;
case 244:
keyBindManager.notifyMouseEvent("mouse4", (eventcode == 1));
break;
case 245:
keyBindManager.notifyMouseEvent("mouse5", (eventcode == 1));
break;
}
}
else
if (eventcode)
keyBindManager.notifyKeyEvent(keynum, true, false);
else
keyBindManager.notifyKeyEvent(keynum, false, false);
retval = (keyBindManager.keyBlocked(keynum, (eventcode) ? true : false)) ? 0 : 1;
if( gMenuActive() && (keynum >= 239 && keynum <= 244))
retval = 0;
KeyEventResult = retval;
}
void DefaultSpreadVar(int weaponid)
{
if (weaponid == WEAPONLIST_DEAGLE)
me.spread.spreadvar = 0.9f;
else if (weaponid == WEAPONLIST_MP5)
me.spread.spreadvar = 0;
else if (weaponid == WEAPONLIST_AK47)
me.spread.spreadvar = 0.2f;
else if (weaponid == WEAPONLIST_SG552)
me.spread.spreadvar = 0.2f;
else if (weaponid == WEAPONLIST_AUG)
me.spread.spreadvar = 0.3f;
else if (weaponid == WEAPONLIST_M4A1)
me.spread.spreadvar = 0.2f;
else if (weaponid == WEAPONLIST_M249)
me.spread.spreadvar = 0.2f;
else if (weaponid == WEAPONLIST_MAC10)
me.spread.spreadvar = 0.15f;
else if (weaponid == WEAPONLIST_UMP45)
me.spread.spreadvar = 0;
else if (weaponid == WEAPONLIST_TMP)
me.spread.spreadvar = 0.2f;
else if (weaponid == WEAPONLIST_P90)
me.spread.spreadvar = 0.15f;
else if (weaponid == WEAPONLIST_P228)
me.spread.spreadvar = 0.9f;
else if (weaponid == WEAPONLIST_FIVESEVEN)
me.spread.spreadvar = 0.92f;
else if (weaponid == WEAPONLIST_ELITE)
me.spread.spreadvar = 0.88f;
else if (weaponid == WEAPONLIST_GLOCK18)
me.spread.spreadvar = 0.9f;
else if (weaponid == WEAPONLIST_USP)
me.spread.spreadvar = 0.92f;
else if (weaponid == WEAPONLIST_G3SG1)
me.spread.spreadvar = 0.2f;
else if (weaponid == WEAPONLIST_SG550)
me.spread.spreadvar = 0.2f;
else
me.spread.spreadvar = 0;
}
//===================================================================================
void HUD_PostRunCmd( struct local_state_s *from, struct local_state_s *to, struct usercmd_s *usercmd, int runfuncs, double time, unsigned int random_seed )
{
int Id;
if (runfuncs)
{
me.spread.random_seed = random_seed;
me.spread.gtime = time;
me.spread.prcflags = to->client.flags;
Id = to->client.m_iId;
if (Id >= 0 && Id < MAX_WEAPONS)
me.spread.WeaponState = to->weapondata[Id].m_iWeaponState;
if (!(usercmd->buttons & (IN_ATTACK | IN_ATTACK2)))
{
if (me.spread.firing)
{
me.spread.firing = false;
if (me.spread.recoil > 15)
me.spread.recoil = 15;
me.spread.recoiltime = time + 0.4f;
}
if (currentWeaponID >= WEAPON_USP && currentWeaponID <= WEAPON_FIVE7)
{
me.spread.recoil = 0;
}
else if (me.spread.recoil > 0)
{
if (me.spread.recoiltime <= time)
{
me.spread.recoiltime = me.spread.recoiltime + 0.0225f;
me.spread.recoil--;
}
}
}
if (Id >= 0 && Id < MAX_WEAPONS && to->weapondata[Id].m_fInReload)
{
me.spread.recoil = 0;
me.spread.prevtime = 0;
DefaultSpreadVar(Id);
me.spread.recoiltime = time;
me.spread.firing = false;
}
if (lastWeaponID != currentWeaponID)
{
lastWeaponID = currentWeaponID;
me.spread.recoil = 0;
me.spread.prevtime = 0;
DefaultSpreadVar(Id);
me.spread.recoiltime = time;
me.spread.firing = true;
if (gAimbot.target != -1 && cvar.inverse==1 && me.alive)
{
char signal[128];
sprintf(signal, "inv_%s",gGetWeaponName(vPlayers[gAimbot.target].getEnt()->curstate.weaponmodel));
extern CommandInterpreter cmd;;
cmd.exec(signal);
}
if (cvar.vec_switch && me.alive)
{
if( strstr("usp",gGetWeaponName(me.ent->curstate.weaponmodel)) ||
strstr("glock18",gGetWeaponName(me.ent->curstate.weaponmodel)) ||
strstr("deagle",gGetWeaponName(me.ent->curstate.weaponmodel)) ||
strstr("p228",gGetWeaponName(me.ent->curstate.weaponmodel)) ||
strstr("elite",gGetWeaponName(me.ent->curstate.weaponmodel)) ||
strstr("fiveseven",gGetWeaponName(me.ent->curstate.weaponmodel)) )
{
cmd.exec("deaglevec");
}
else if ( strstr("ump45",gGetWeaponName(me.ent->curstate.weaponmodel)) )
{
cmd.exec("umpvec");
}
else if( strstr("ak47",gGetWeaponName(me.ent->curstate.weaponmodel)) )
{
cmd.exec("akvec");
}
else if( strstr("sg552",gGetWeaponName(me.ent->curstate.weaponmodel)) )
{
cmd.exec("sigvec");
}
else if( strstr("aug",gGetWeaponName(me.ent->curstate.weaponmodel)) )
{
cmd.exec("augvec");
}
else if( strstr("m4a1",gGetWeaponName(me.ent->curstate.weaponmodel)) )
{
cmd.exec("coltvec");
}
else if( strstr("scout",gGetWeaponName(me.ent->curstate.weaponmodel)) )
{
cmd.exec("scoutvec");
}
else if( strstr("knife",gGetWeaponName(me.ent->curstate.weaponmodel)) )
{
cmd.exec("knifevec");
}
else if( strstr("m249",gGetWeaponName(me.ent->curstate.weaponmodel)) )
{
cmd.exec("paravec");
}
else if( strstr("g3sg1",gGetWeaponName(me.ent->curstate.weaponmodel)) )
{
cmd.exec("g3sg1vec");
}
else if( strstr("sg550",gGetWeaponName(me.ent->curstate.weaponmodel)) )
{
cmd.exec("sg550vec");
}
else if( strstr("mp5",gGetWeaponName(me.ent->curstate.weaponmodel)) )
{
cmd.exec("mp5vec");
}
else if( strstr("xm1014",gGetWeaponName(me.ent->curstate.weaponmodel)) )
{
cmd.exec("xm1014vec");
}
else if( strstr("m3",gGetWeaponName(me.ent->curstate.weaponmodel)) )
{
cmd.exec("m3vec");
}
else if( strstr("awp",gGetWeaponName(me.ent->curstate.weaponmodel)) )
{
cmd.exec("awpvec");
}
}
}
}
if (cvar.recoil_switch && me.alive)
{
char signal0[128];
sprintf(signal0, "rcl_%s", gGetWeaponName(me.ent->curstate.weaponmodel));
extern CommandInterpreter cmd;;
cmd.exec(signal0);
}
}
//===================================================================================
void OGC_ConsoleScrollUp(const char* message)
{
gConsole.echo(message);
}
void OGCmessage(const char *fmt, ... )
{
const char PROC_NAME[50] = "OGCmessage\0";
va_list va_alist;
char buf[256];
va_start (va_alist, fmt);
_vsnprintf (buf, sizeof(buf), fmt, va_alist);
va_end (va_alist);
// echo + scroll up:
OGC_ConsoleScrollUp(buf);
}
DWORD retaddress;
void OGCmessageD(const char *fmt, ... )
{
const char PROC_NAME[50] = "OGCmessage\0";
va_list va_alist;
char buf[256];
va_start (va_alist, fmt);
_vsnprintf (buf, sizeof(buf), fmt, va_alist);
va_end (va_alist);
// echo + scroll up:
}
void HUD_VoiceStatus(int entindex, qboolean bTalking)
{
OGCmessageD("%d %d", entindex, bTalking);
}
int HUD_Init (void)
{
return 1;
}
__declspec( naked )void Gateway2_HUD_VoiceStatus( void )
{
__asm
{
call HUD_VoiceStatus;
jmp retaddress;
}
}
DWORD VoiceStatus = (DWORD)&Gateway2_HUD_VoiceStatus;
__declspec( naked )void Gateway1_HUD_VoiceStatus( void )
{
__asm
{
push esi;
mov esi,dword ptr ss:[esp+0x10];
mov retaddress,esi;
push VoiceStatus;
pop esi;
mov dword ptr ss:[esp+0x10],esi;
pop esi;
ret;
}
}
__declspec( naked )void Gateway2_V_CalcRefdef( void )
{
__asm
{
call PostV_CalcRefdef;
jmp retaddress;
}
}
DWORD CalcRef = (DWORD)&Gateway2_V_CalcRefdef;
__declspec( naked )void Gateway1_V_CalcRefdef( void )
{
__asm
{
push esi;
mov esi,dword ptr ss:[esp+0x10];
push esi;
call PreV_CalcRefdef;
add esp,4;
mov esi,dword ptr ss:[esp+0x0c];
mov retaddress,esi;
push CalcRef;
pop esi;
mov dword ptr ss:[esp+0x0c],esi;
pop esi;
ret;
}
}
__declspec( naked )void Gateway2_CL_CreateMove( void )
{
__asm
{
call CL_CreateMove;
jmp retaddress;
}
}
DWORD CreateMove = (DWORD)&Gateway2_CL_CreateMove;
__declspec( naked )void Gateway1_CL_CreateMove( void )
{
__asm
{
push esi;
mov esi,dword ptr ss:[esp+0x28];
mov retaddress,esi;
push CreateMove;
pop esi;
mov dword ptr ss:[esp+0x28],esi;
pop esi;
ret;
}
}
__declspec( naked )void Gateway2_HUD_TempEntUpdate( void )
{
__asm
{
call HUD_TempEntUpdate;
jmp retaddress;
}
}
DWORD Temp= (DWORD)&Gateway2_HUD_TempEntUpdate;
__declspec( naked )void Gateway1_HUD_TempEntUpdate( void )
{
__asm
{
push esi;
mov esi,dword ptr ss:[esp+0x35];
mov retaddress,esi;
push Temp
pop esi;
mov dword ptr ss:[esp+0x35],esi;
pop esi;
ret;
}
}
__declspec( naked )void Gateway2_HUD_Redraw( void )
{
__asm
{
call HUD_Redraw;
jmp retaddress;
}
}
DWORD Redraw= (DWORD)&Gateway2_HUD_Redraw;
__declspec( naked )void Gateway1_HUD_Redraw( void )
{
__asm
{
push esi;
mov esi,dword ptr ss:[esp+0x10];
mov retaddress,esi;
push Redraw
pop esi;
mov dword ptr ss:[esp+0x10],esi;
pop esi;
ret;
}
}
__declspec( naked )void Gateway2_HUD_PostRunCmd( void )
{
__asm
{
call HUD_PostRunCmd;
jmp retaddress;
}
}
DWORD PostRunCmd= (DWORD)&Gateway2_HUD_PostRunCmd;
__declspec( naked )void Gateway1_HUD_PostRunCmd( void )
{
__asm
{
push esi;
mov esi,dword ptr ss:[esp+0x40];
mov retaddress,esi;
push PostRunCmd
pop esi;
mov dword ptr ss:[esp+0x40],esi;
pop esi;
ret;
}
}
__declspec( naked )void Gateway2_HUD_PlayerMove( void )
{
__asm
{
call HUD_PlayerMove;
jmp retaddress;
}
}
DWORD PlayerMove = (DWORD)&Gateway2_HUD_PlayerMove;
__declspec( naked )void Gateway1_HUD_PlayerMove( void )
{
__asm
{
push esi;
mov esi,dword ptr ss:[esp+0x10];
mov retaddress,esi;
push PlayerMove
pop esi;
mov dword ptr ss:[esp+0x10],esi;
pop esi;
ret;
}
}
__declspec( naked )void Gateway2_HUD_Init( void )
{
__asm
{
call HUD_Init;
jmp retaddress;
}
}
DWORD Init = (DWORD)&Gateway2_HUD_Init;
__declspec( naked )void Gateway1_HUD_Init( void )
{
__asm
{
push esi;
mov esi,dword ptr ss:[esp+0x08];
mov retaddress,esi;
push Init
pop esi;
mov dword ptr ss:[esp+0x08],esi;
pop esi;
ret;
}
}
__declspec( naked )void Gateway2_HUD_AddEntity( void )
{
__asm
{
mov AddEntResult, eax;
call HUD_AddEntity;
mov eax, AddEntResult;
jmp retaddress;
}
}
DWORD AddEnt = (DWORD)&Gateway2_HUD_AddEntity;
__declspec( naked )void Gateway1_HUD_AddEntity( void )
{
__asm
{
push esi;
mov esi,dword ptr ss:[esp+0x14];
mov retaddress,esi;
push AddEnt
pop esi;
mov dword ptr ss:[esp+0x14],esi;
pop esi;
ret;
}
}
__declspec( naked )void Gateway2_HUD_Key_Event( void )
{
__asm
{
mov KeyEventResult, eax;
call HUD_Key_Event;
mov eax, KeyEventResult;
jmp retaddress;
}
}
DWORD KeyEvent = (DWORD)&Gateway2_HUD_Key_Event;
__declspec( naked )void Gateway1_HUD_Key_Event( void )
{
__asm
{
push esi;
mov esi,dword ptr ss:[esp+0x14];
mov retaddress,esi;
push KeyEvent
pop esi;
mov dword ptr ss:[esp+0x14],esi;
pop esi;
ret;
}
}
__declspec(naked) void nullStub()
{
_asm ret;
}
static bool bFirstTime = true;
static bool bStudioFirst = true;
static bool bTableFirst = true;
static bool loaded = false;
static bool done = false;
////////////////
int DrawConsoleString( int x, int y, char *string )
{
if (!strstr(string, ".wav"))
{
return gEngfuncs.pfnDrawConsoleString( x, y, string);
}
return 0;
}
static bool hackActive = false;
//===================================================================================
void StudioDynamicLight(cl_entity_s *ent,alight_s *plight)
{
ent = pstudio->GetCurrentEntity();
if(ent && ent->player && pstudio->GetModelByIndex(ent->index))
{
}
IEngineStudio.StudioDynamicLight(ent,plight);
}
//===================================================================================
DWORD FindPattern(char *pattern, int len, DWORD dwStart, DWORD dwLen)
{
char *m = (char *)dwStart;
for(; (DWORD)m < (dwStart + dwLen); m++)
if(!memcmp(m, pattern, len))
return (DWORD)m;
return NULL;
}
//===================================================================================
void OnlyHook(LARGE_INTEGER *lp, bool force = true)
{
static bool NotPatched = true;
if (NotPatched)
{
char engine_sig[] = "\x89\x74\x24\x5C\x89\x74\x24\x60\x89\x74\x24\x64\x89\x74\x24\x68\x89\x74\x24\x6C\x89\x74\x24\x70\x89\x74\x24\x74\x89\x74\x24\x78\x89\x74\x24\x7C\0";
DWORD dwEngine = FindPattern(engine_sig, strlen(engine_sig), 0x01D60000, 0x01000000);
DWORD Slots_sig = (*(DWORD*)(dwEngine - 0x74));
slots = (DWORD*)Slots_sig;
int a;
for(a=0x01D00000;a<0x01D0FFFF;a++)
{
if(*(PBYTE)(a) == 0x68 && *(PBYTE)(a + 0x05) == 0xE8 &&
*(PBYTE)(a + 0x0A) == 0x6A && *(PBYTE)(a + 0x0B) == 0x07 &&
*(PBYTE)(a + 0x0C) == 0x68 && *(PBYTE)(a + 0x11) == 0xFF &&
*(PBYTE)(a + 0x12) == 0x15 && *(PBYTE)(a + 0x17) == 0x68)
{
pEngfuncs = (cl_enginefunc_t*)*(DWORD*)(a+0x0D);
}
}
int b;
for(b=0x01D00000;b<0x01D0FFFF;b++)
{
if(*(PBYTE)(b) == 0xE8 && *(PBYTE)(b + 0x05) == 0x6A &&
*(PBYTE)(b + 0x06) == 0x07 && *(PBYTE)(b + 0x07) == 0x68 &&
*(PBYTE)(b + 0x0C) == 0xFF && *(PBYTE)(b + 0x0D) == 0x15 &&
*(PBYTE)(b + 0x12) == 0x68 && *(PBYTE)(b + 0x1C) == 0x81)
{
ppmove = (playermove_s*)*(DWORD*)(b+0x13);
}
}
int c;
for(c=0x01D00000;c<0x01D0FFFF;c++)
{
if(*(PBYTE)(c) == 0x68 && *(PBYTE)(c + 0x05) == 0x68 &&
*(PBYTE)(c + 0x0A) == 0x6A && *(PBYTE)(c + 0x0B) == 0x01 &&
*(PBYTE)(c + 0x0C) == 0xFF && *(PBYTE)(c + 0x0D) == 0xD0 &&
*(PBYTE)(c + 0x0E) == 0x83 && *(PBYTE)(c + 0x27) == 0xC3)
{
pstudio = (engine_studio_api_s*)*(DWORD*)(c+0x01);
ppinterface = (r_studio_interface_s*)*(DWORD*)(c+0x06);
}
}
NotPatched = false;
}
if( pEngfuncs->pfnHookUserMsg && pEngfuncs->pfnHookEvent && bFirstTime )
{
memcpy( &gEngfuncs, pEngfuncs, sizeof( cl_enginefunc_t ) );
HookUserMsgOrg = (DWORD)*pEngfuncs->pfnHookUserMsg;
// Start hooking game functions
pEngfuncs->pfnSPR_Set = &SPR_Set;
pEngfuncs->pfnSPR_DrawHoles = &SPR_DrawHoles;
pEngfuncs->pfnSPR_DrawAdditive = &SPR_DrawAdditive;
pEngfuncs->pfnSPR_Draw = &SPR_Draw;
pEngfuncs->pfnSPR_Load = &SPR_Load;
pEngfuncs->pfnHookUserMsg = &HookUserMsg;
pEngfuncs->pfnDrawCharacter = &DrawCharacter;
pEngfuncs->pfnFillRGBA = &FillRGBA;
pEngfuncs->pfnHookEvent = &HookEvent;
pEngfuncs->pfnDrawConsoleString = &DrawConsoleString;
keyBindManager.init();
keyBindManager.CallBack_Execute = CB_KeyManager_Exec;
keyBindManager.CallBack_ConType = CB_KeyManager_ConType;
keyBindManager.con_visible = gEngfuncs.Con_IsVisible;
gConsole.setcolortag( 'b', 0,0,255);
gConsole.setcolortag( 'r',165, 42, 42);
gConsole.setcolortag( 'g',150,200,50);
gConsole.setcolortag( 'w',240,255,255);
gConsole.setcolortag( 'y', -10,-10,-10);
//////////////
const char sDateStamp[255] = __DATE__;
const char sCompileStamp[255] = __TIME__;
////////////////
gConsole.echo("&w --GooeyBase v.o0");
gConsole.echo("&w --You Know!");
gConsole.echo("&w --Breathed Into Life: %s %s",sDateStamp,sCompileStamp);
gConsole.echo("");
OGCmessage("&g GooeyBase v.o0 ::Auto Offsets Applied");
OGCmessage("&w -----------------------------------------");
OGCmessage("&g PlayerMove &w: 0x%X",ppmove);
OGCmessage("&g EngineFuncs &w: 0x%X",pEngfuncs);
OGCmessage("&g SlotsPointer &w: 0x%X",slots);
OGCmessage("&g EngineStudio &w: 0x%X",pstudio);
OGCmessage("&g StudioInterface &w: 0x%X",ppinterface);
OGCmessage("&w -----------------------------------------");
gConsole.echo("");
ogcMenu.init(getOgcDirFile("menu.txt").c_str());
Init_Command_Interpreter();
ogc_exec("config");
cmd.exec("#hideradar");
cvar.alive_method = 1;
cvar.spec_fix = false;
me.spread.prcflags = 0;
me.spread.random_seed = 0;
me.spread.recoil = 0;
me.spread.gtime = 0;
me.spread.prevtime = 0;
me.spread.brokentime = 0;
me.spread.spreadvar = 0;
me.spread.recoiltime = 0;
me.spread.firing = false;
bool AllowedToHookGL();
if (!AllowedToHookGL())
OGCmessage("&wNOTICE: &r OpenGL Is NOT Hooked");
void initWeaponID();
initWeaponID();
bFirstTime = false;
}
if( pstudio->GetModelByIndex && bStudioFirst )
{
memcpy( &IEngineStudio, pstudio, sizeof( engine_studio_api_t ) );
bStudioFirst = false;
}
if(bNewFrame)
bNewFrame = true;
{
pstudio->StudioDynamicLight = StudioDynamicLight;
bNewFrame = false;
}
static bool patched = false;
if( GetAsyncKeyState(VK_END)&0x8000 || force) // Change END to something else if you want, f12 or maybe to scroll lock oo i bet you didnt think about that yet?
{
unsigned char* c;
if(!patched)
{
patched=true;
for(int s=0;s<40;s++)
{
c = (unsigned char*)slots[s];
if( c[0] != 0xc3 )
{
patched=false;
MessageBox(NULL, "Things look wrong... very wrong A.K.A. YOUR FUCKED", NULL, MB_OK);
}
}
}
c = (unsigned char*)slots[3];
if( c[0] == 0xc3 ){
slots[3] = (DWORD)&Gateway1_HUD_Redraw; //HUD_Redraw
}
c = (unsigned char*)slots[6];
if( c[0] == 0xc3 ){
slots[6] = (DWORD)&Gateway1_HUD_PlayerMove;} //HUD_PlayerMove
c = (unsigned char*)slots[14];
if( c[0] == 0xc3 ){
slots[14] = (DWORD)&Gateway1_CL_CreateMove;}//CL_CreateMove
c = (unsigned char*)slots[19];
if( c[0] == 0xc3 ){
slots[19] = (DWORD)&Gateway1_V_CalcRefdef; }//V_CalcRefdef
c = (unsigned char*)slots[20];
if( c[0] == 0xc3 ){
slots[20] = (DWORD)&Gateway1_HUD_AddEntity;}//HUD_AddEntity
c = (unsigned char*)slots[25];
if (c[0] == 0xc3){
slots[25] = (DWORD)&Gateway1_HUD_PostRunCmd; } //HUD_PostRunCmd
c = (unsigned char*)slots[34];
if( c[0] == 0xc3 ){
slots[34] = (DWORD)&Gateway1_HUD_Key_Event; }//HUD_Key_Event
c = (unsigned char*)slots[35];
if (c[0] == 0xc3){
slots[55] = (DWORD)&Gateway1_HUD_TempEntUpdate;} //HUD_TempEntUpdate
c = (unsigned char*)slots[37];
if (c[0] == 0xc3){
slots[37] = (DWORD)&Gateway1_HUD_VoiceStatus;
}
hackActive = true;
AtRoundStart();
done = true;
}
if (force)
return;
}
//===================================================================================
int HUD_DirectorEvent( unsigned char command, unsigned int firstObject, unsigned int secondObject, unsigned int flags )
{
int retval = NULL;
retval = pHUD_DirectorEvent( command, firstObject, secondObject, flags );
return( retval );
}
//===================================================================================
void HUD_Frame( double time )
{
pHUD_Frame( time );
}
//===================================================================================
void HUD_PlayerMoveInit( struct playermove_s *ppmove )
{
pHUD_PlayerMoveInit( ppmove );
}
//===================================================================================
char HUD_PlayerMoveTexture( char *name )
{
char retval = NULL;
retval = pHUD_PlayerMoveTexture( name );
return( retval );
}
void HUD_Shutdown( void )
{
if (gAimbot.AimVecsS.size() > 0 && gAimbot.AimVecsD.size() > 0)
cmd.exec("saveaimvecs autovecs testvec");
pHUD_Shutdown( );
}
//===================================================================================
void IN_MouseEvent( int mstate )
{
pIN_MouseEvent( mstate );
}
//===================================================================================
struct kbutton_s *KB_Find( const char *name )
{
struct kbutton_s *retval = NULL;
retval = pKB_Find( name );
return( retval );
}
//===================================================================================
void HUD_DirectorMessage(unsigned char command, unsigned int firstObject, unsigned int secondObject, unsigned int flags)
{
pHUD_DirectorEvent(command, firstObject, secondObject, flags);
}
//===================================================================================