client.cpp

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

	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)
{
	oglSubtractive = true;
	gEngfuncs.pfnFillRGBA(x,y,w,h,clr->r,clr->g,clr->b,clr->a);
	oglSubtractive = false;
}

//========================================================================================
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 {
		// y-check
		int borderY = displayCenterY*2-18;
		if( y<0 || y>borderY ) { return; }

		int drawLen = DrawLen(buf);
		x = x-drawLen/2;

		if(cvar.text_background)
		{
			// only do this with opengl:
			extern hookinfo glBeginInfo;
			if( glBeginInfo.oldfunc )
			{
				tintArea(x-2,y,drawLen+4,16,colorList.get(24));
			}
		}

		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];
				// IMPORTANT NOTE: when drawing admin-mod style charactters
				//    you MAY NOT provide x/y coordinates that cause drawing
				//    off screen. This causes HL to crash or just quit
				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];
				
				// IMPORTANT NOTE: when drawing admin-mod style charactters
				//    you MAY NOT provide x/y coordinates that cause drawing
				//    off screen. This causes HL to crash or just quit
				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 {
		// y-check
		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(cvar.text_background)
		{
			tintArea(x-2,y,drawLen+4,16,colorList.get(24));
		}

		if( needSingleCheck )
		{
			for ( char * p = buf; *p; p++ )
			{
				int next = x + screeninfo.charWidths[*p];
				// IMPORTANT NOTE: when drawing admin-mod style charactters
				//    you MAY NOT provide x/y coordinates that cause drawing
				//    off screen. This causes HL to crash or just quit
				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];
				// IMPORTANT NOTE: when drawing admin-mod style charactters
				//    you MAY NOT provide x/y coordinates that cause drawing
				//    off screen. This causes HL to crash or just quit
				gEngfuncs.pfnDrawCharacter (x, y, *p, r, g, b);
				x = next;
			}
		}
	}
}

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

	// echo + scroll up:
	gConsole.echo("%s",buf);
}

//===========================================================================================
//======================== USER MESSAGE HOOKS ===============================================
//===========================================================================================
#define USER_MSG_INTERCEPT(name) \
	static pfnUserMsgHook name ## Org = NULL; \
	static int UserMsg ## name ( const char *pszName, int iSize, void *pbuf)
#define USER_MSG_CALL(name) (*name ## Org)(pszName,iSize,pbuf)

//===========================================================================================
USER_MSG_INTERCEPT(TeamInfo)
{
	static bool         done=false;
	static StringFinder teamNumber;
	if(!done)
	{
		// cs
		teamNumber.add("terrorist"  ,1);teamNumber.add("ct"         ,2);
		teamNumber.add("unassigned" ,0);teamNumber.add("spectator"  ,0);
		teamNumber.add("axis"   ,1);teamNumber.add("allies" ,2);
		teamNumber.add("red force", 1);teamNumber.add("blue force",2);
		teamNumber.add("usa",    2);teamNumber.add("up-ko",  4);
		teamNumber.add("rebels", 2);teamNumber.add("agents", 4);
		teamNumber.add("united nations", 2);teamNumber.add("arab liberation force", 4);
		teamNumber.add("#dustbowl_team1",2 );teamNumber.add("#dustbowl_team2",3 );
		teamNumber.add("#dunted_team1"  ,2 );teamNumber.add("#dunted_team2"  ,2 );
		teamNumber.add("#dunted_team3"  ,3 );
		teamNumber.add("red"    ,1);teamNumber.add("blue"   ,2);
		teamNumber.add("yellow" ,3);teamNumber.add("green"  ,4);

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

	return USER_MSG_CALL(TeamInfo);
}

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

	// update our own weaponID:
	if(iState)
	{
		char * name = playerItems.getNamebyId(iID);

		if(!strcmp(name,"mp5navy")) currentWeaponID = WEAPON_MP5;
		else currentWeaponID = burstInfo.getWeaponID( name );
	}

	return USER_MSG_CALL(CurWeapon);
}

//========================================================================================
USER_MSG_INTERCEPT(Concuss)
{
	return 1;
}

//========================================================================================
USER_MSG_INTERCEPT(SayText)
{
	updateLocalPlayer();

	if(gConsole.mode == OgcConsole::MODE_CHAT)
	{
		BEGIN_READ( pbuf, iSize);
		int    client = READ_BYTE(); // the client who spoke the message
		char*  text   = READ_STRING();

		// cut name
		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;
			} 
		}
	}
	return USER_MSG_CALL(SayText);
}

//========================================================================================
USER_MSG_INTERCEPT(DeathMsg)
{
	updateLocalPlayer();

	//DeathMsg: [B]Killer [B]Victim [B]Headshot [S]Weapon Name
	BEGIN_READ( pbuf, iSize );
	int killer = READ_BYTE();
	int victim = READ_BYTE();
	int headshot = READ_BYTE();
    char* weaponName = READ_STRING();

	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;
	}
	
	if(victim==me.ent->index && killer!=victim && cvar.death)
	{
		int ax = killer;
		if(ax!=-1)
		{
			PlayerInfo& theKiller = vPlayers[ax];
			float* from = theKiller.getEnt()->curstate.origin;
			float* to   = me.pmEyePos;

			VectorCopy(from,deathInfos.from);
			VectorCopy(to,deathInfos.to);

			if( theKiller.getEnt()->curstate.usehull ) deathInfos.from[2]+=12.1f;
			else                                       deathInfos.from[2]+=17.1f;

			deathInfos.killerName = vPlayers[ax].entinfo.name;
			deathInfos.weaponName = weaponName;
			deathInfos.active     = true;
		}
	}

	return USER_MSG_CALL(DeathMsg);
}

//========================================================================================
USER_MSG_INTERCEPT(Money)
{
	BEGIN_READ( pbuf, iSize );
	playerItems.money = READ_SHORT();
	return USER_MSG_CALL(Money);
}

//========================================================================================
USER_MSG_INTERCEPT(Battery)
{
	BEGIN_READ( pbuf, iSize );
	playerItems.armor = READ_BYTE();
	return USER_MSG_CALL(Battery);
}

//========================================================================================
USER_MSG_INTERCEPT(SetFOV)
{
	BEGIN_READ( pbuf, iSize );
	me.iFOV = READ_BYTE();
	if(!me.iFOV)   { me.iFOV=90; }

	if(me.iFOV==90){ me.inZoomMode=false; }
	else           { me.inZoomMode=true;  } 

	if(cvar.antizoom && me.iFOV!=90 ) 
	{ 
		me.iFOV     = 89; 
		((unsigned char*)pbuf)[0]=89;	
	}

	iCurrentFOV = me.iFOV;
	fCurrentFOV = me.iFOV;
	return USER_MSG_CALL(SetFOV);
}

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

	return USER_MSG_CALL(ScoreAttrib);
}

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