client.cpp

我对他如何控制准星、显示敌友很好奇

	// update bestplayer
	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;

	
	// score handling:
	if(idx==me.ent->index)
	{
		static int lastfrags=0;
		static int lastdeaths=0;

		if(me.headshots>r.frags || r.frags==0) 
		{ 
			// reset statistics
			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;

			if(cvar.saystats && (lastfrags!=r.frags || lastdeaths!=r.deaths ))
			{
				char tmp[128];
				switch(cvar.saystats)
				{
				case 1:	
					sprintf(tmp,"say frags:[%d] deaths:[%d] ratio:[%4.2f] headshots:[%d = %4.1f percent]",
						r.frags,r.deaths,r.ratio,me.headshots,me.hspercent);
					gEngfuncs.pfnClientCmd(tmp);
					break;
				case 2:
					char* tag = "&y";
					if( r.frags>lastfrags  ) tag = "&g";
					if( r.frags<lastfrags  ) tag = "&r";
					if( r.deaths>lastdeaths) tag = "&r";

					Con_Echo("%sfrags:[%d] deaths:[%d] ratio:[%4.2f] headshots:[%d = %4.1f percent]",
						tag,r.frags,r.deaths,r.ratio,me.headshots,me.hspercent);
					break;
				}
			}
		}
		bGotHeadshot = false;
		lastfrags    = r.frags;
		lastdeaths   = r.deaths;
	}

	return USER_MSG_CALL(ScoreInfo);
}

//========================================================================================
USER_MSG_INTERCEPT(TextMsg)
{
	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;
		}

	}

	return USER_MSG_CALL(TextMsg);
}

////==========================================================================
//static int UserMsgCDChallenge( const char *pszName, int iSize, void *pbuf)
//{
//		if(!cvar.cdauth) return 1;
//
//		Challenge challenge;
//
//		BEGIN_READ(pbuf,iSize);
//		challenge.version     = READ_SHORT();
//		challenge.data_int[0] = READ_LONG();
//		challenge.data_int[1] = READ_LONG();
//		challenge.data_int[2] = READ_LONG();
//		challenge.data_int[3] = READ_LONG();
//		challenge.data_int[4] = READ_LONG();
//	    
//		CalcReply(&challenge);
//
//		char buf[128];
//		sprintf(buf, "CDReply %x %x %x %x %x %x", challenge.version,
//			challenge.data_int[0],challenge.data_int[1],
//			challenge.data_int[2],challenge.data_int[3],
//			challenge.data_int[4]);
//		Con_Echo("CD auth %x",challenge.version);
//
//		sprintf(gHudMessage,"CD");
//		gHudTimer.countdown(1.2);
//
//		gEngfuncs.pfnClientCmd(buf);
//	return 1;
//}

//========================================================================================
void AtRoundStart(void);
USER_MSG_INTERCEPT(ResetHUD)
{
	updateLocalPlayer();

	bBombIsPlanted=false;
	if (iRounds) AtRoundStart();
	iRounds++;

	return USER_MSG_CALL(ResetHUD);
}

//========================================================================================
USER_MSG_INTERCEPT(WeaponList)
{
	updateLocalPlayer();
	playerItems.msgWeaponList(iSize,pbuf);
	return USER_MSG_CALL(WeaponList);
}

//========================================================================================
int	HookUserMsg (char *szMsgName, pfnUserMsgHook pfn)
{
	int ret = gEngfuncs.pfnHookUserMsg (szMsgName, pfn);

	#define REDIRECT_MESSAGE(name) \
		else if (!strcmp(szMsgName,#name)) \
		{ \
			name##Org = pfn; \
			return gEngfuncs.pfnHookUserMsg (szMsgName, UserMsg##name ); \
		}

	if(0){}
	REDIRECT_MESSAGE( TeamInfo    ) REDIRECT_MESSAGE( CurWeapon   )
	REDIRECT_MESSAGE( ScoreAttrib ) REDIRECT_MESSAGE( ScoreInfo   )
	REDIRECT_MESSAGE( SetFOV      ) REDIRECT_MESSAGE( TextMsg     )
	REDIRECT_MESSAGE( ResetHUD    ) REDIRECT_MESSAGE( WeaponList  )
	REDIRECT_MESSAGE( Money       ) REDIRECT_MESSAGE( Battery     )
	REDIRECT_MESSAGE( DeathMsg    ) REDIRECT_MESSAGE( Concuss     )
	REDIRECT_MESSAGE( SayText     ) 
	return ret;
}

//========================================================================================
int	( *OrigStudioDrawPlayer	)( int flags, struct entity_state_s *pplayer );
int	 NewStudioDrawPlayer ( int flags, struct entity_state_s *pplayer )
{
	int ret = OrigStudioDrawPlayer ( flags, pplayer );
	gAimbot.PostStudioDrawPlayer( flags, pplayer);
	return ret;
}



//========================================================================================
inline bool isEnemy(int ax)
{
	return (me.team != vPlayers[ax].team);
}

//========================================================================================
ColorEntry* PlayerColor(int ax)
{
	static ColorEntry colorDefault;
	if ((cvar.sglow) && ((vPlayers[ax].iInfo & 2) || (vPlayers[ax].iInfo & 4))) { return colorList.get(3); }
	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;
	
	switch(cvar.cross)
	{
	case 1:
		gEngfuncs.pfnFillRGBA(centerX - 14, centerY, 9, 1,r,g,b,a);
		gEngfuncs.pfnFillRGBA(centerX +5,   centerY, 9, 1,r,g,b,a);
		gEngfuncs.pfnFillRGBA(centerX, centerY - 14, 1, 9,r,g,b,a);
		gEngfuncs.pfnFillRGBA(centerX, centerY +  5, 1, 9,r,g,b,a);
		gEngfuncs.pfnFillRGBA(centerX, centerY     , 1, 1,r,g,b,a); // center
		break;
	case 2:
		gEngfuncs.pfnFillRGBA(centerX - 14, centerY, 9,2,r,g,b,a); // left
		gEngfuncs.pfnFillRGBA(centerX +6,   centerY, 9,2,r,g,b,a); // right
		gEngfuncs.pfnFillRGBA(centerX, centerY - 14, 2,9,r,g,b,a); // top
		gEngfuncs.pfnFillRGBA(centerX, centerY +  7, 2,9,r,g,b,a); // bottom
		gEngfuncs.pfnFillRGBA(centerX, centerY     , 2,2,r,g,b,a); // center
		break;
	case 3:
		gEngfuncs.pfnFillRGBA(centerX-25,centerY,50,1,r,g,b,a);
		gEngfuncs.pfnFillRGBA(centerX,centerY-25,1,50,r,g,b,a);
		break;
	case 4:
		gEngfuncs.pfnFillRGBA(centerX-25,centerY,50,2,r,g,b,a);
		gEngfuncs.pfnFillRGBA(centerX,centerY-25,2,50,r,g,b,a);
		break;
	case 5:
		if(ch_sniper!=-1){
			gEngfuncs.pfnSPR_Set(ch_sniper,255,255,255);
			gEngfuncs.pfnSPR_DrawHoles(0,displayCenterX-128,displayCenterY-128,NULL);
		}	
		break;
	case 6:
		if(sniper_scope!=-1){
			gEngfuncs.pfnSPR_Set(sniper_scope,255,255,255);
			gEngfuncs.pfnSPR_DrawHoles(0,displayCenterX-128,displayCenterY-128,NULL);
		}	
		break;
	case 7:
		gEngfuncs.pfnFillRGBA(0,centerY,2*centerX,1,r,g,b,a);
		gEngfuncs.pfnFillRGBA(centerX,0,1,2*centerY,r,g,b,a);
		break;
	}
}


//========================================================================================
void handleContinuousZoom()
{
	if( cvar.czoom == 1000 ) // leave zoom mode
	{
		// reset zoom
		iCurrentFOV = 90;
		fCurrentFOV = 90.0;
		(*SetFOVOrg)("SetFOV", 1, &iCurrentFOV);
		
		// prevent further zooming
		cvar.czoom = 0; 
	} else 	{
		// advance/decrease zoom level
		iCurrentFOV -= cvar.czoom;
		BOUND_VALUE(iCurrentFOV,10,90);
		fCurrentFOV = iCurrentFOV;

		(*SetFOVOrg)("SetFOV", 1, &iCurrentFOV);
	}
}

//========================================================================================
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 calcRadarPoint(float* origin, int& screenx, int& screeny)
{
	float dx  = origin[0] - me.pmEyePos[0];
	float dy  = origin[1] - me.pmEyePos[1];

    // rotate
	float x =  dy*me.minus_cos_yaw + dx*me.sin_yaw;
	float y =  dx*me.minus_cos_yaw - dy*me.sin_yaw;

	float& range = cvar.radar_range;
	if(fabs(x)>range || fabs(y)>range)
	{ 
		// clipping
		if(y>x)
		{
			if(y>-x) {
				x = range*x/y;
				y = range;
			}  else  {
				y = -range*y/x; 
				x = -range; 
			}
		} else {
			if(y>-x) {
				y = range*y/x; 
				x = range; 
			}  else  {
				x = -range*x/y;
				y = -range;
			}
		}
	}

	screenx = cvar.radar_x+int(x/cvar.radar_range*float(cvar.radar_size));
	screeny = cvar.radar_y+int(y/cvar.radar_range*float(cvar.radar_size));
}

//========================================================================================
void drawRadarPoint(float* origin,int r,int g,int b,bool blink=false)
{
	int screenx,screeny;
	calcRadarPoint(origin,screenx,screeny);
	if(!blink || blinkPhase){ gEngfuncs.pfnFillRGBA(screenx,screeny,3,3,r,g,b,255);}
}


//========================================================================================
void drawRadarFrame()
{
	int& centerx = cvar.radar_x;
	int& centery = cvar.radar_y;
	int& size    = cvar.radar_size;
	
	ColorEntry* clr;
	
	clr = colorList.get(12);
	tintArea(centerx-size, centery-size, 2*size+2, 2*size+2, clr);

	clr = colorList.get(11);
	gEngfuncs.pfnFillRGBA(centerx,centery-size,1,2*size,clr->r,clr->g,clr->b,clr->a);
	gEngfuncs.pfnFillRGBA(centerx-size,centery,2*size,1,clr->r,clr->g,clr->b,clr->a);
}


//========================================================================================
static OgcCommandMenu::Menu* curMenu = ogcMenu.baseMenu;
bool  menu_active = false;

//========================================================================================
bool gMenuActive(){ return menu_active; }

//========================================================================================
void drawMenu(  )
{
	if(!menu_active) return;
	if(!curMenu) { curMenu = ogcMenu.baseMenu; }

	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));

	// 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);

	// title text
	gEngfuncs.pfnDrawSetTextColor (255,255,0);
	gEngfuncs.pfnDrawConsoleString(cvar.menu_x+10,frame_y+5, const_cast<char*>(curMenu->name.c_str()));
	

	// draw text
	y=cvar.menu_y+4;
	x+=4;
	for(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(gHudMessage, entry.description.c_str());
	gHudTimer.countdown(6);
}

//========================================================================================
void sendScriptSignal(const char* name)
{
	char signal[32];
	sprintf(signal,"sig%s",name);