2005-11-18 02:38:19 +00:00
# include "AvHNetworkMessages.h"
# include "NetworkMeter.h"
# include "util/MathUtil.h" //for WrapFloat
# include "util/STLUtil.h" //for MakeBytesFromHexPairs
# include "cl_dll/parsemsg.h"
# ifndef AVH_SERVER
# include "cl_dll/chudmisc.h"
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// MESSAGE CODES - NEED TO BE INITIALIZED BEFORE CLIENT CONNECTION, OR THEY'D
// BE LOCAL STATICS INSIDE OF THE FUNCTIONS USING LAZY INSTANTIATION
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifdef AVH_SERVER
int g_msgAmmoPickup = 0 , g_msgAmmoX , g_msgBattery , g_msgCurWeapon , g_msgDamage , //5
g_msgDeathMsg , g_msgFade , g_msgFlashlight , g_msgGeigerRange , g_msgHealth , //10
g_msgHideWeapon , g_msgHudText , g_msgHudText2 , g_msgInitHUD , g_msgItemPickup ,
g_msgMOTD , g_msgResetHUD , g_msgSayText , g_msgScoreInfo , g_msgServerName ,
g_msgSetFOV , g_msgShake , g_msgShowGameTitle , g_msgShowMenu , g_msgStatusText ,
g_msgStatusValue , g_msgTeamInfo , g_msgTeamNames , g_msgTeamScore , g_msgTextMsg ,
g_msgTrain , g_msgWeaponList , g_msgWeapPickup , g_msgAlienInfo , g_msgBalanceVar ,
g_msgBlipList , g_msgBuildMiniMap , g_msgClientScripts , g_msgDebugCSP , g_msgEditPS ,
g_msgFog , g_msgGameStatus , g_msgListPS , g_msgPlayHUDNotification , g_msgProgressBar ,
g_msgServerVar , g_msgSetGammaRamp , g_msgSetOrder , g_msgSetParticleTemplates ,
g_msgSetSelect , g_msgSetRequest , g_msgSetSoundNames , g_msgSetTechNodes , g_msgSetTechSlots ,
g_msgSetTopDown , g_msgSetupMap , g_msgUpdateCountdown , g_msgUpdateEntityHierarchy ,
g_msgProfileInfo , g_msgNexusBytes , g_msgIssueOrder ;
void Net_InitializeMessages ( void )
{
if ( g_msgAmmoPickup ! = 0 ) { return ; }
g_msgAmmoPickup = REG_USER_MSG ( " AmmoPickup " , 2 ) ;
g_msgAmmoX = REG_USER_MSG ( " AmmoX " , 2 ) ;
g_msgBattery = REG_USER_MSG ( " Battery " , 2 ) ;
g_msgCurWeapon = REG_USER_MSG ( " CurWeapon " , 3 ) ;
g_msgDamage = REG_USER_MSG ( " Damage " , 12 ) ;
g_msgDeathMsg = REG_USER_MSG ( " DeathMsg " , - 1 ) ;
g_msgFade = REG_USER_MSG ( " ScreenFade " , sizeof ( ScreenFade ) ) ;
g_msgFlashlight = REG_USER_MSG ( " FLashlight " , 2 ) ;
g_msgGeigerRange = REG_USER_MSG ( " Geiger " , 1 ) ;
g_msgHealth = REG_USER_MSG ( " Health " , 2 ) ;
g_msgHideWeapon = REG_USER_MSG ( " HideWeapon " , 1 ) ;
g_msgHudText = REG_USER_MSG ( " HudText " , - 1 ) ;
g_msgHudText2 = REG_USER_MSG ( " HudText2 " , - 1 ) ;
g_msgInitHUD = REG_USER_MSG ( " InitHUD " , 0 ) ;
g_msgItemPickup = REG_USER_MSG ( " ItemPickup " , - 1 ) ;
g_msgMOTD = REG_USER_MSG ( " MOTD " , - 1 ) ;
g_msgResetHUD = REG_USER_MSG ( " ResetHUD " , 0 ) ;
g_msgSayText = REG_USER_MSG ( " SayText " , - 1 ) ;
// puzl: 0001073
g_msgScoreInfo = REG_USER_MSG ( " ScoreInfo " , - 1 ) ;
g_msgServerName = REG_USER_MSG ( " ServerName " , - 1 ) ;
g_msgSetFOV = REG_USER_MSG ( " SetFOV " , 1 ) ;
g_msgShake = REG_USER_MSG ( " ScreenShake " , 6 ) ;
g_msgShowGameTitle = REG_USER_MSG ( " GameTitle " , 1 ) ;
g_msgShowMenu = REG_USER_MSG ( " ShowMenu " , - 1 ) ;
g_msgStatusText = REG_USER_MSG ( " StatusText " , - 1 ) ;
g_msgStatusValue = REG_USER_MSG ( " StatusValue " , 3 ) ;
g_msgTeamInfo = REG_USER_MSG ( " TeamInfo " , - 1 ) ;
g_msgTeamNames = REG_USER_MSG ( " TeamNames " , - 1 ) ;
g_msgTeamScore = REG_USER_MSG ( " TeamScore " , - 1 ) ;
g_msgTextMsg = REG_USER_MSG ( " TextMsg " , - 1 ) ;
g_msgTrain = REG_USER_MSG ( " Train " , 1 ) ;
g_msgWeaponList = REG_USER_MSG ( " WeaponList " , - 1 ) ;
g_msgWeapPickup = REG_USER_MSG ( " WeapPickup " , 1 ) ;
g_msgAlienInfo = REG_USER_MSG ( " AlienInfo " , - 1 ) ;
g_msgBalanceVar = REG_USER_MSG ( " BalanceVar " , - 1 ) ;
g_msgBlipList = REG_USER_MSG ( " BlipList " , - 1 ) ;
g_msgBuildMiniMap = REG_USER_MSG ( " MiniMap " , - 1 ) ;
g_msgClientScripts = REG_USER_MSG ( " ClScript " , - 1 ) ;
g_msgDebugCSP = REG_USER_MSG ( " DebugCSP " , 14 ) ;
g_msgEditPS = REG_USER_MSG ( " EditPS " , 2 ) ;
g_msgFog = REG_USER_MSG ( " Fog " , - 1 ) ;
g_msgGameStatus = REG_USER_MSG ( " GameStatus " , - 1 ) ;
g_msgListPS = REG_USER_MSG ( " ListPS " , - 1 ) ;
g_msgPlayHUDNotification = REG_USER_MSG ( " PlayHUDNot " , 6 ) ;
g_msgProgressBar = REG_USER_MSG ( " Progress " , 3 ) ;
g_msgServerVar = REG_USER_MSG ( " ServerVar " , - 1 ) ;
g_msgSetGammaRamp = REG_USER_MSG ( " SetGmma " , 2 ) ;
g_msgSetOrder = REG_USER_MSG ( " SetOrder " , - 1 ) ;
g_msgSetParticleTemplates = REG_USER_MSG ( " Particles " , - 1 ) ;
g_msgSetSelect = REG_USER_MSG ( " SetSelect " , - 1 ) ;
g_msgSetRequest = REG_USER_MSG ( " SetRequest " , 2 ) ;
g_msgSetSoundNames = REG_USER_MSG ( " SoundNames " , - 1 ) ;
g_msgSetTechNodes = REG_USER_MSG ( " SetTech " , 9 ) ;
g_msgSetTechSlots = REG_USER_MSG ( " TechSlots " , 1 + kNumTechSlots ) ;
g_msgSetTopDown = REG_USER_MSG ( " SetTopDown " , - 1 ) ;
g_msgSetupMap = REG_USER_MSG ( " SetupMap " , - 1 ) ;
g_msgUpdateCountdown = REG_USER_MSG ( " Countdown " , 1 ) ;
g_msgUpdateEntityHierarchy = REG_USER_MSG ( " EntHier " , - 1 ) ;
g_msgProfileInfo = REG_USER_MSG ( " ProfileInfo " , 8 ) ;
g_msgNexusBytes = REG_USER_MSG ( " NexusBytes " , - 1 ) ;
// tankefugl: 0000971
g_msgIssueOrder = REG_USER_MSG ( " IssueOrder " , 9 ) ;
// :tankefugl
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// MESSAGE FUNCTIONS - READ/WRITE PAIRS FOR NETWORK MESSAGES
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# define END_READ() ;
# ifndef AVH_SERVER
void NetMsg_AmmoPickup ( void * const buffer , const int size , int & index , int & count )
{
BEGIN_READ ( buffer , size ) ;
index = READ_BYTE ( ) ;
count = READ_BYTE ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_AmmoPickup ( entvars_t * const pev , const int index , const int count )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgAmmoPickup , NULL , pev ) ;
WRITE_BYTE ( index ) ;
WRITE_BYTE ( count ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_AmmoX ( void * const buffer , const int size , int & index , int & count )
{
BEGIN_READ ( buffer , size ) ;
index = READ_BYTE ( ) ;
count = READ_BYTE ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_AmmoX ( entvars_t * pev , const int index , const int count )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgAmmoX , NULL , pev ) ;
WRITE_BYTE ( index ) ;
WRITE_BYTE ( count ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_Battery ( void * const buffer , const int size , int & armor_amount )
{
BEGIN_READ ( buffer , size ) ;
armor_amount = READ_SHORT ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_Battery ( entvars_t * const pev , const int armor_amount )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgBattery , NULL , pev ) ;
WRITE_SHORT ( armor_amount ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_CurWeapon ( void * const buffer , const int size , int & state , int & id , int & clip )
{
BEGIN_READ ( buffer , size ) ;
state = READ_BYTE ( ) ;
id = READ_BYTE ( ) ;
clip = READ_BYTE ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_CurWeapon ( entvars_t * const pev , const int state , const int id , const int clip )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgCurWeapon , NULL , pev ) ;
WRITE_BYTE ( state ) ;
WRITE_BYTE ( id ) ;
WRITE_BYTE ( clip ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_Damage ( void * const buffer , const int size , int & dmg_save , int & dmg_take , long & bits , float * origin )
{
BEGIN_READ ( buffer , size ) ;
dmg_save = READ_BYTE ( ) ;
dmg_take = READ_BYTE ( ) ;
bits = READ_LONG ( ) ;
origin [ 0 ] = READ_COORD ( ) ;
origin [ 1 ] = READ_COORD ( ) ;
origin [ 2 ] = READ_COORD ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_Damage ( entvars_t * const pev , const int dmg_save , const int dmg_take , const long bits , const float * origin )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgDamage , NULL , pev ) ;
WRITE_BYTE ( dmg_save ) ;
WRITE_BYTE ( dmg_take ) ;
WRITE_LONG ( bits ) ;
WRITE_COORD ( origin [ 0 ] ) ;
WRITE_COORD ( origin [ 1 ] ) ;
WRITE_COORD ( origin [ 2 ] ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_DeathMsg ( void * const buffer , const int size , int & killer_index , int & victim_index , string & weapon_name )
{
BEGIN_READ ( buffer , size ) ;
killer_index = READ_BYTE ( ) ;
victim_index = READ_BYTE ( ) ;
weapon_name = READ_STRING ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_DeathMsg ( const int killer_index , const int victim_index , string & weapon_name )
{
MESSAGE_BEGIN ( MSG_ALL , g_msgDeathMsg ) ;
WRITE_BYTE ( killer_index ) ;
WRITE_BYTE ( victim_index ) ;
WRITE_STRING ( weapon_name . c_str ( ) ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_Fade ( void * const buffer , const int size , ScreenFade & fade )
{
BEGIN_READ ( buffer , size ) ;
fade . duration = READ_SHORT ( ) ;
fade . holdTime = READ_SHORT ( ) ;
fade . fadeFlags = READ_SHORT ( ) ;
fade . r = READ_BYTE ( ) ;
fade . g = READ_BYTE ( ) ;
fade . b = READ_BYTE ( ) ;
fade . a = READ_BYTE ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_Fade ( entvars_t * const pev , const ScreenFade & fade )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgFade , NULL , pev ) ; // use the magic #1 for "one client"
WRITE_SHORT ( fade . duration ) ;
WRITE_SHORT ( fade . holdTime ) ;
WRITE_SHORT ( fade . fadeFlags ) ;
WRITE_BYTE ( fade . r ) ;
WRITE_BYTE ( fade . g ) ;
WRITE_BYTE ( fade . b ) ;
WRITE_BYTE ( fade . a ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_Flashlight ( void * const buffer , const int size , int & is_on , int & flash_battery )
{
BEGIN_READ ( buffer , size ) ;
is_on = READ_BYTE ( ) ;
flash_battery = READ_BYTE ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_Flashlight ( entvars_t * const pev , const int is_on , const int flash_battery )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgFlashlight , NULL , pev ) ;
WRITE_BYTE ( is_on ) ;
WRITE_BYTE ( flash_battery ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_GeigerRange ( void * const buffer , const int size , int & range )
{
BEGIN_READ ( buffer , size ) ;
range = READ_BYTE ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_GeigerRange ( entvars_t * const pev , const int range )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgGeigerRange , NULL , pev ) ;
WRITE_BYTE ( range ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_Health ( void * const buffer , const int size , int & health )
{
BEGIN_READ ( buffer , size ) ;
health = READ_SHORT ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_Health ( entvars_t * const pev , const int health )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgHealth , NULL , pev ) ;
WRITE_SHORT ( health ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_HideWeapon ( void * const buffer , const int size , int & hide )
{
BEGIN_READ ( buffer , size ) ;
hide = READ_BYTE ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_HideWeapon ( entvars_t * const pev , const int hide )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgHideWeapon , NULL , pev ) ;
WRITE_BYTE ( hide ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_HudText ( void * const buffer , const int size , string & text )
{
BEGIN_READ ( buffer , size ) ;
text = READ_STRING ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_HudText ( entvars_t * const pev , const string & text )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgHudText , NULL , pev ) ;
WRITE_STRING ( text . c_str ( ) ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_HudText2 ( void * const buffer , const int size , string & text , int & flags )
{
BEGIN_READ ( buffer , size ) ;
text = READ_STRING ( ) ;
flags = READ_BYTE ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_HudText2 ( entvars_t * const pev , const string & text , const int flags )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgHudText2 , NULL , pev ) ;
WRITE_STRING ( text . c_str ( ) ) ;
WRITE_BYTE ( flags ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_InitHUD ( void * const buffer , const int size )
{
BEGIN_READ ( buffer , size ) ;
END_READ ( ) ;
}
# else
void NetMsg_InitHUD ( entvars_t * const pev )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgInitHUD , NULL , pev ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_ItemPickup ( void * const buffer , const int size , string & item_name )
{
BEGIN_READ ( buffer , size ) ;
item_name = READ_STRING ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_ItemPickup ( entvars_t * const pev , const string & item_name )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgItemPickup , NULL , pev ) ;
WRITE_STRING ( item_name . c_str ( ) ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_MOTD ( void * const buffer , const int size , bool & is_finished , string & MOTD )
{
BEGIN_READ ( buffer , size ) ;
is_finished = ( READ_BYTE ( ) = = 1 ) ;
MOTD = READ_STRING ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_MOTD ( entvars_t * const pev , const bool is_finished , const string & MOTD )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgMOTD , NULL , pev ) ;
WRITE_BYTE ( is_finished ? 1 : 0 ) ;
WRITE_STRING ( MOTD . c_str ( ) ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_ResetHUD ( void * const buffer , const int size )
{
BEGIN_READ ( buffer , size ) ;
END_READ ( ) ;
}
# else
void NetMsg_ResetHUD ( entvars_t * const pev )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgResetHUD , NULL , pev ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_SayText ( void * const buffer , const int size , int & entity_index , string & text , string & location )
{
BEGIN_READ ( buffer , size ) ;
entity_index = READ_BYTE ( ) ;
text = READ_STRING ( ) ;
location = READ_STRING ( ) ;
END_READ ( ) ;
}
# else
//MESSAGE TO EVERYBODY
void NetMsg_SayText ( const int entity_index , const string & text , const string & location )
{
MESSAGE_BEGIN ( MSG_ALL , g_msgSayText , NULL ) ;
WRITE_BYTE ( entity_index ) ;
WRITE_STRING ( text . c_str ( ) ) ;
WRITE_STRING ( location . c_str ( ) ) ;
MESSAGE_END ( ) ;
}
//MESSAGE TO ONE PERSON
void NetMsg_SayText ( entvars_t * const pev , const int entity_index , const string & text , const string & location )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgSayText , NULL , pev ) ;
WRITE_BYTE ( entity_index ) ;
WRITE_STRING ( text . c_str ( ) ) ;
WRITE_STRING ( location . c_str ( ) ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// puzl: 0001073
# ifndef AVH_SERVER
void NetMsg_ScoreInfo ( void * const buffer , const int size , ScoreInfo & info )
{
BEGIN_READ ( buffer , size ) ;
info . player_index = READ_BYTE ( ) ;
info . score = READ_SHORT ( ) ;
info . frags = READ_SHORT ( ) ;
info . deaths = READ_SHORT ( ) ;
info . player_class = READ_BYTE ( ) ;
info . auth = READ_SHORT ( ) ;
info . team = READ_SHORT ( ) ;
char * theString = READ_STRING ( ) ;
# ifdef USE_OLDAUTH
if ( info . auth & PLAYERAUTH_CUSTOM )
{
//clear the string (I dont think this array is reset anywhere else (since everything is set when the score info message is sent anyways)
//so just memset it here to prevent any possible problems.
memset ( & g_PlayerExtraInfo [ info . player_index ] . customicon , 0 , sizeof ( g_PlayerExtraInfo [ info . player_index ] . customicon ) ) ;
// Read custom icon
if ( theString & & strlen ( theString ) > = 4 & & strlen ( theString ) < = CUSTOM_ICON_LENGTH + 2 ) //make sure the string is within the right size.
strncpy ( g_PlayerExtraInfo [ info . player_index ] . customicon , theString , sizeof ( g_PlayerExtraInfo [ info . player_index ] . customicon ) - 1 ) ;
}
# endif
END_READ ( ) ;
}
# else
void NetMsg_ScoreInfo ( const ScoreInfo & info )
{
MESSAGE_BEGIN ( MSG_ALL , g_msgScoreInfo ) ;
WRITE_BYTE ( info . player_index ) ;
WRITE_SHORT ( info . score ) ;
WRITE_SHORT ( info . frags ) ;
WRITE_SHORT ( info . deaths ) ;
WRITE_BYTE ( info . player_class ) ;
WRITE_SHORT ( info . auth ) ;
WRITE_SHORT ( info . team ) ;
WRITE_STRING ( " 0 " ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_ServerName ( void * const buffer , const int size , string & name )
{
BEGIN_READ ( buffer , size ) ;
name = READ_STRING ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_ServerName ( entvars_t * const pev , const string & name )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgServerName , NULL , pev ) ;
WRITE_STRING ( name . c_str ( ) ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_SetFOV ( void * const buffer , const int size , int & fov )
{
BEGIN_READ ( buffer , size ) ;
fov = READ_BYTE ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_SetFOV ( entvars_t * const pev , const int fov )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgSetFOV , NULL , pev ) ;
WRITE_BYTE ( fov ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_Shake ( void * const buffer , const int size , ScreenShake & shake )
{
BEGIN_READ ( buffer , size ) ;
shake . amplitude = READ_SHORT ( ) ;
shake . duration = READ_SHORT ( ) ;
shake . frequency = READ_SHORT ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_Shake ( entvars_t * const pev , const ScreenShake & shake )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgShake , NULL , pev ) ;
WRITE_SHORT ( shake . amplitude ) ;
WRITE_SHORT ( shake . duration ) ;
WRITE_SHORT ( shake . frequency ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_ShowGameTitle ( void * const buffer , const int size )
{
BEGIN_READ ( buffer , size ) ;
END_READ ( ) ;
}
# else
void NetMsg_ShowGameTitle ( entvars_t * const pev )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgShowGameTitle , NULL , pev ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_ShowMenu ( void * const buffer , const int size , int & valid_slots , int & display_time , int & flags , string & content )
{
BEGIN_READ ( buffer , size ) ;
valid_slots = READ_SHORT ( ) ;
display_time = READ_CHAR ( ) ;
flags = READ_BYTE ( ) ;
content = READ_STRING ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_ShowMenu ( entvars_t * const pev , const int valid_slots , const int display_time , const int flags , const string & content )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgShowMenu , NULL , pev ) ;
WRITE_SHORT ( valid_slots ) ;
WRITE_CHAR ( display_time ) ;
WRITE_BYTE ( flags ) ;
WRITE_STRING ( content . c_str ( ) ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_StatusText ( void * const buffer , const int size , int & location , string & content )
{
BEGIN_READ ( buffer , size ) ;
location = READ_BYTE ( ) ;
content = READ_STRING ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_StatusText ( entvars_t * const pev , const int location , const string & content )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgStatusText , NULL , pev ) ;
WRITE_BYTE ( location ) ;
WRITE_STRING ( content . c_str ( ) ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_StatusValue ( void * const buffer , const int size , int & location , int & state )
{
BEGIN_READ ( buffer , size ) ;
location = READ_BYTE ( ) ;
state = READ_SHORT ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_StatusValue ( entvars_t * const pev , const int location , const int state )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgStatusValue , NULL , pev ) ;
WRITE_BYTE ( location ) ;
WRITE_SHORT ( state ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_TeamInfo ( void * const buffer , const int size , int & player_index , string & team_id )
{
BEGIN_READ ( buffer , size ) ;
player_index = READ_BYTE ( ) ;
team_id = READ_STRING ( ) ;
END_READ ( ) ;
}
# else
//MESSAGE TO EVERYBODY
void NetMsg_TeamInfo ( const int player_index , const string & team_id )
{
MESSAGE_BEGIN ( MSG_ALL , g_msgTeamInfo ) ;
WRITE_BYTE ( player_index ) ;
WRITE_STRING ( team_id . c_str ( ) ) ;
MESSAGE_END ( ) ;
}
//MESSAGE TO SPECTATORS
void NetMsgSpec_TeamInfo ( const int player_index , const string & team_id )
{
MESSAGE_BEGIN ( MSG_SPEC , g_msgTeamInfo ) ;
WRITE_BYTE ( player_index ) ;
WRITE_STRING ( team_id . c_str ( ) ) ;
MESSAGE_END ( ) ;
}
//MESSAGE TO ONE PERSON
void NetMsg_TeamInfo ( entvars_t * const pev , const int player_index , const string & team_id )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgTeamInfo , NULL , pev ) ;
WRITE_BYTE ( player_index ) ;
WRITE_STRING ( team_id . c_str ( ) ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_TeamNames ( void * const buffer , const int size , StringList & team_names )
{
team_names . clear ( ) ;
BEGIN_READ ( buffer , size ) ;
int num_teams = READ_BYTE ( ) ;
for ( int counter = 0 ; counter < num_teams ; counter + + )
{
string name ( READ_STRING ( ) ) ;
team_names . push_back ( name ) ;
}
END_READ ( ) ;
}
# else
void NetMsg_TeamNames ( entvars_t * const pev , const StringList & team_names )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgTeamNames , NULL , pev ) ;
WRITE_BYTE ( team_names . size ( ) ) ;
for ( int counter = 0 ; counter < team_names . size ( ) ; counter + + )
{
WRITE_STRING ( team_names [ counter ] . c_str ( ) ) ;
}
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_TeamScore ( void * const buffer , const int size , string & team_name , int & score , int & deaths )
{
BEGIN_READ ( buffer , size ) ;
team_name = READ_STRING ( ) ;
score = READ_SHORT ( ) ;
deaths = READ_SHORT ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_TeamScore ( entvars_t * const pev , const string & team_name , const int score , const int deaths )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgTeamScore , NULL , pev ) ;
WRITE_STRING ( team_name . c_str ( ) ) ;
WRITE_SHORT ( score ) ;
WRITE_SHORT ( deaths ) ;
MESSAGE_END ( ) ;
}
void NetMsg_TeamScore ( const string & team_name , const int score , const int deaths )
{
MESSAGE_BEGIN ( MSG_ALL , g_msgTeamScore ) ;
WRITE_STRING ( team_name . c_str ( ) ) ;
WRITE_SHORT ( score ) ;
WRITE_SHORT ( deaths ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_TextMsg ( void * const buffer , const int size , int & destination , StringList & message )
{
message . clear ( ) ;
BEGIN_READ ( buffer , size ) ;
destination = READ_BYTE ( ) ;
message . push_back ( string ( READ_STRING ( ) ) ) ;
message . push_back ( string ( READ_STRING ( ) ) ) ;
message . push_back ( string ( READ_STRING ( ) ) ) ;
message . push_back ( string ( READ_STRING ( ) ) ) ;
message . push_back ( string ( READ_STRING ( ) ) ) ;
END_READ ( ) ;
}
# else
//MESSAGE TO EVERYBODY
void NetMsg_TextMsg ( const int destination , const StringList & message )
{
MESSAGE_BEGIN ( MSG_ALL , g_msgTextMsg ) ;
WRITE_BYTE ( destination ) ;
WRITE_STRING ( message [ 0 ] . c_str ( ) ) ;
if ( message . size ( ) > 1 )
WRITE_STRING ( message [ 1 ] . c_str ( ) ) ;
if ( message . size ( ) > 2 )
WRITE_STRING ( message [ 2 ] . c_str ( ) ) ;
if ( message . size ( ) > 3 )
WRITE_STRING ( message [ 3 ] . c_str ( ) ) ;
if ( message . size ( ) > 4 )
WRITE_STRING ( message [ 4 ] . c_str ( ) ) ;
MESSAGE_END ( ) ;
}
//MESSAGE TO SPECTATORS
void NetMsgSpec_TextMsg ( const int destination , const StringList & message )
{
MESSAGE_BEGIN ( MSG_SPEC , g_msgTextMsg ) ;
WRITE_BYTE ( destination ) ;
WRITE_STRING ( message [ 0 ] . c_str ( ) ) ;
if ( message . size ( ) > 1 )
WRITE_STRING ( message [ 1 ] . c_str ( ) ) ;
if ( message . size ( ) > 2 )
WRITE_STRING ( message [ 2 ] . c_str ( ) ) ;
if ( message . size ( ) > 3 )
WRITE_STRING ( message [ 3 ] . c_str ( ) ) ;
if ( message . size ( ) > 4 )
WRITE_STRING ( message [ 4 ] . c_str ( ) ) ;
MESSAGE_END ( ) ;
}
//MESSAGE TO ONE PERSON
void NetMsg_TextMsg ( entvars_t * const pev , const int destination , const StringList & message )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgTextMsg , NULL , pev ) ;
WRITE_BYTE ( destination ) ;
WRITE_STRING ( message [ 0 ] . c_str ( ) ) ;
if ( message . size ( ) > 1 )
WRITE_STRING ( message [ 1 ] . c_str ( ) ) ;
if ( message . size ( ) > 2 )
WRITE_STRING ( message [ 2 ] . c_str ( ) ) ;
if ( message . size ( ) > 3 )
WRITE_STRING ( message [ 3 ] . c_str ( ) ) ;
if ( message . size ( ) > 4 )
WRITE_STRING ( message [ 4 ] . c_str ( ) ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_Train ( void * const buffer , const int size , int & state )
{
BEGIN_READ ( buffer , size ) ;
state = READ_BYTE ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_Train ( entvars_t * const pev , const int state )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgTrain , NULL , pev ) ;
WRITE_BYTE ( state ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_WeaponList ( void * const buffer , const int size , WeaponList & weapon )
{
BEGIN_READ ( buffer , size ) ;
weapon . weapon_name = READ_STRING ( ) ;
weapon . ammo1_type = READ_CHAR ( ) ;
weapon . ammo1_max_amnt = READ_BYTE ( ) ;
weapon . ammo2_type = READ_CHAR ( ) ;
weapon . ammo2_max_amnt = READ_BYTE ( ) ;
weapon . bucket = READ_CHAR ( ) ;
weapon . bucket_pos = READ_CHAR ( ) ;
weapon . bit_index = READ_CHAR ( ) ;
weapon . flags = READ_BYTE ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_WeaponList ( entvars_t * const pev , const WeaponList & weapon )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgWeaponList , NULL , pev ) ;
WRITE_STRING ( weapon . weapon_name . c_str ( ) ) ;
WRITE_CHAR ( weapon . ammo1_type ) ;
WRITE_BYTE ( weapon . ammo1_max_amnt ) ;
WRITE_CHAR ( weapon . ammo2_type ) ;
WRITE_BYTE ( weapon . ammo2_max_amnt ) ;
WRITE_CHAR ( weapon . bucket ) ;
WRITE_CHAR ( weapon . bucket_pos ) ;
WRITE_CHAR ( weapon . bit_index ) ;
WRITE_BYTE ( weapon . flags ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_WeapPickup ( void * const buffer , const int size , int & weapon_id )
{
BEGIN_READ ( buffer , size ) ;
weapon_id = READ_BYTE ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_WeapPickup ( entvars_t * const pev , const int weapon_id )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgWeapPickup , NULL , pev ) ;
WRITE_BYTE ( weapon_id ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
enum AlienInfo_ChangeFlags
{
NO_CHANGE = 0 ,
COORDS_CHANGED = 1 ,
STATUS_CHANGED = 2 ,
HEALTH_CHANGED = 4
} ;
# ifndef AVH_SERVER
void NetMsg_AlienInfo ( void * const buffer , const int size , bool & was_hive_info , AvHAlienUpgradeListType & upgrades , HiveInfoListType & hives )
{
BEGIN_READ ( buffer , size ) ;
int status , type , header = READ_BYTE ( ) ;
was_hive_info = ( header & 0x80 ) = = 0 ;
if ( was_hive_info )
{
int num_hives = header ;
AlienInfo_ChangeFlags changes ;
for ( int counter = 0 ; counter < num_hives ; counter + + )
{
if ( hives . size ( ) < = counter )
{
AvHHiveInfo hive ;
hives . push_back ( hive ) ;
}
changes = ( AlienInfo_ChangeFlags ) READ_BYTE ( ) ;
if ( changes & COORDS_CHANGED )
{
hives [ counter ] . mPosX = READ_COORD ( ) ;
hives [ counter ] . mPosY = READ_COORD ( ) ;
hives [ counter ] . mPosZ = READ_COORD ( ) ;
}
if ( changes & STATUS_CHANGED )
{
status = READ_BYTE ( ) ;
type = ( status > > 3 ) & 0x03 ;
hives [ counter ] . mUnderAttack = ( status & 0x80 ) ! = 0 ;
hives [ counter ] . mStatus = status & 0x07 ;
switch ( type )
{
case 0 : hives [ counter ] . mTechnology = MESSAGE_NULL ; break ;
case 1 : hives [ counter ] . mTechnology = ALIEN_BUILD_DEFENSE_CHAMBER ; break ;
case 2 : hives [ counter ] . mTechnology = ALIEN_BUILD_SENSORY_CHAMBER ; break ;
case 3 : hives [ counter ] . mTechnology = ALIEN_BUILD_MOVEMENT_CHAMBER ; break ;
}
}
if ( changes & HEALTH_CHANGED )
{
hives [ counter ] . mHealthPercentage = READ_BYTE ( ) ;
}
}
}
else
{
int num_upgrades = READ_BYTE ( ) ;
upgrades . clear ( ) ;
for ( int counter = 0 ; counter < num_upgrades ; counter + + )
{
AvHAlienUpgradeCategory theUpgradeCategory = AvHAlienUpgradeCategory ( READ_BYTE ( ) ) ;
upgrades . push_back ( theUpgradeCategory ) ;
}
}
END_READ ( ) ;
}
# else
void NetMsg_AlienInfo_Upgrades ( entvars_t * const pev , const AvHAlienUpgradeListType & upgrades )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgAlienInfo , NULL , pev ) ;
WRITE_BYTE ( 0x80 ) ; //magic number for hive size field, upgrade info
WRITE_BYTE ( upgrades . size ( ) ) ;
AvHAlienUpgradeListType : : const_iterator current , end = upgrades . end ( ) ;
for ( current = upgrades . begin ( ) ; current ! = end ; + + current )
{
WRITE_BYTE ( * current ) ;
}
MESSAGE_END ( ) ;
}
void NetMsg_AlienInfo_Hives ( entvars_t * const pev , const HiveInfoListType & hives , const HiveInfoListType & client_hives )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgAlienInfo , NULL , pev ) ;
WRITE_BYTE ( hives . size ( ) ) ;
HiveInfoListType : : const_iterator current , end = hives . end ( ) ;
int status , tech , index = 0 ;
int change_flags = NO_CHANGE ;
for ( current = hives . begin ( ) ; current ! = end ; + + current , + + index )
{
//put together change bitfield
if ( client_hives . size ( ) < = index | | client_hives [ index ] . mPosX ! = current - > mPosX | |
client_hives [ index ] . mPosY ! = current - > mPosY | | client_hives [ index ] . mPosZ ! = current - > mPosZ )
{ change_flags | = COORDS_CHANGED ; }
if ( client_hives . size ( ) < = index | | client_hives [ index ] . mStatus ! = current - > mStatus | |
client_hives [ index ] . mUnderAttack ! = current - > mUnderAttack | | client_hives [ index ] . mTechnology ! = current - > mTechnology )
{ change_flags | = STATUS_CHANGED ; }
if ( client_hives . size ( ) < = index | | client_hives [ index ] . mHealthPercentage ! = current - > mHealthPercentage )
{ change_flags | = HEALTH_CHANGED ; }
WRITE_BYTE ( change_flags ) ;
//send change data
if ( change_flags & COORDS_CHANGED )
{
WRITE_COORD ( current - > mPosX ) ;
WRITE_COORD ( current - > mPosY ) ;
WRITE_COORD ( current - > mPosZ ) ;
}
if ( change_flags & STATUS_CHANGED )
{
status = current - > mStatus & 0x07 ; // 3 bits
switch ( current - > mTechnology ) // 2 bits
{
case MESSAGE_NULL : tech = 0 ; break ;
case ALIEN_BUILD_DEFENSE_CHAMBER : tech = 1 ; break ;
case ALIEN_BUILD_SENSORY_CHAMBER : tech = 2 ; break ;
case ALIEN_BUILD_MOVEMENT_CHAMBER : tech = 3 ; break ;
default : tech = 0 ; break ;
}
status | = tech < < 3 ;
status | = current - > mUnderAttack ? 0x80 : 0x00 ; // 1 bit
WRITE_BYTE ( status ) ;
}
if ( change_flags & HEALTH_CHANGED )
{
WRITE_BYTE ( current - > mHealthPercentage ) ;
}
}
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//TODO: sub rapid conversion as described in Game Programming Gems...
union float_converter
{
float f ;
long l ;
} ;
# ifndef AVH_SERVER
void NetMsg_BalanceVar ( void * const buffer , const int size , string & name , BalanceMessageAction & action , int & ivalue , float & fvalue , string & svalue )
{
BEGIN_READ ( buffer , size ) ;
action = static_cast < BalanceMessageAction > ( READ_BYTE ( ) ) ;
switch ( action )
{
case BALANCE_ACTION_INSERT_INT :
{
name = READ_STRING ( ) ;
ivalue = READ_LONG ( ) ;
break ;
}
case BALANCE_ACTION_INSERT_FLOAT :
{
float_converter c ;
name = READ_STRING ( ) ;
c . l = READ_LONG ( ) ;
fvalue = c . f ;
break ;
}
case BALANCE_ACTION_INSERT_STRING :
{
name = READ_STRING ( ) ;
svalue = READ_STRING ( ) ;
break ;
}
case BALANCE_ACTION_REMOVE :
{
name = READ_STRING ( ) ;
break ;
}
case BALANCE_ACTION_CLEAR :
case BALANCE_ACTION_NOTIFY_PENDING :
case BALANCE_ACTION_NOTIFY_FINISHED :
{
break ;
}
default :
break ;
//todo: error condition here?
}
END_READ ( ) ;
}
# else
void NetMsg_BalanceVarChangesPending ( entvars_t * const pev , const bool pending )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgBalanceVar , NULL , pev ) ;
WRITE_BYTE ( pending ? BALANCE_ACTION_NOTIFY_PENDING : BALANCE_ACTION_NOTIFY_FINISHED ) ;
MESSAGE_END ( ) ;
}
void NetMsg_BalanceVarInsertInt ( entvars_t * const pev , const string & name , const int data )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgBalanceVar , NULL , pev ) ;
WRITE_BYTE ( BALANCE_ACTION_INSERT_INT ) ;
WRITE_STRING ( name . c_str ( ) ) ;
WRITE_LONG ( data ) ;
MESSAGE_END ( ) ;
}
void NetMsg_BalanceVarInsertFloat ( entvars_t * const pev , const string & name , const float data )
{
float_converter c ;
c . f = data ;
MESSAGE_BEGIN ( MSG_ONE , g_msgBalanceVar , NULL , pev ) ;
WRITE_BYTE ( BALANCE_ACTION_INSERT_FLOAT ) ;
WRITE_STRING ( name . c_str ( ) ) ;
WRITE_LONG ( c . l ) ;
MESSAGE_END ( ) ;
}
void NetMsg_BalanceVarInsertString ( entvars_t * const pev , const string & name , const string & data )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgBalanceVar , NULL , pev ) ;
WRITE_BYTE ( BALANCE_ACTION_INSERT_STRING ) ;
WRITE_STRING ( name . c_str ( ) ) ;
WRITE_STRING ( data . c_str ( ) ) ;
MESSAGE_END ( ) ;
}
void NetMsg_BalanceVarRemove ( entvars_t * const pev , const string & name )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgBalanceVar , NULL , pev ) ;
WRITE_BYTE ( BALANCE_ACTION_REMOVE ) ;
WRITE_STRING ( name . c_str ( ) ) ;
MESSAGE_END ( ) ;
}
void NetMsg_BalanceVarClear ( entvars_t * const pev )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgBalanceVar , NULL , pev ) ;
WRITE_BYTE ( BALANCE_ACTION_CLEAR ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_BlipList ( void * const buffer , const int size , bool & friendly_blips , AvHVisibleBlipList & list )
{
int blip_count ;
int8 status , info ;
float X , Y , Z ;
list . Clear ( ) ;
BEGIN_READ ( buffer , size ) ;
int list_info = READ_BYTE ( ) ;
friendly_blips = ( list_info & 0x80 ) ! = 0 ;
blip_count = ( list_info & 0x7F ) ;
for ( int counter = 0 ; counter < blip_count ; counter + + )
{
X = READ_COORD ( ) ;
Y = READ_COORD ( ) ;
Z = READ_COORD ( ) ;
status = READ_BYTE ( ) ;
info = friendly_blips ? READ_BYTE ( ) : 0 ;
list . AddBlip ( X , Y , Z , status , info ) ;
}
END_READ ( ) ;
}
# else
void NetMsg_BlipList ( entvars_t * const pev , const bool friendly_blips , const AvHVisibleBlipList & list )
{
2005-11-19 01:25:38 +00:00
int maxBlips = friendly_blips ? 20 : 25 ;
maxBlips = min ( list . mNumBlips , maxBlips ) ;
2005-11-18 02:38:19 +00:00
MESSAGE_BEGIN ( MSG_ONE_UNRELIABLE , g_msgBlipList , NULL , pev ) ;
//pack header - 7 bits for blip count (doesn't go over 40 in practice), 1 bit for Friend or Foe
2005-11-19 01:25:38 +00:00
unsigned char list_info = maxBlips | ( friendly_blips ? 0x80 : 0 ) ;
2005-11-18 02:38:19 +00:00
WRITE_BYTE ( list_info ) ;
//pack each blip - this could be optimized as follows once bit packer is implemented:
// convert X, Y to integer values ranging from 0 to 2047 (11 bits each) based on map extents
// convert Z to integer value ranging from 0 to 511 (9 bits)
// 4 bits for status (range 0-15, 1-9 currently used)
// 5 bits for info (range 1-32, refers to player number)
// total is 40 bits = 5 bytes for friendly, 35 bits for foe.
// savings would be 37.5% for friendly bytes.
// blip precision would be equal to double large minimap precision, with worst case of 4 unit X,Y separation for MT.
// because maps are much smaller vertically than horizontally as a rule, the worst case of 16 unit Z separation
// will very rarely occur.
2005-11-19 01:25:38 +00:00
for ( int counter = 0 ; counter < maxBlips ; counter + + )
2005-11-18 02:38:19 +00:00
{
WRITE_COORD ( list . mBlipPositions [ counter ] [ 0 ] ) ;
WRITE_COORD ( list . mBlipPositions [ counter ] [ 1 ] ) ;
WRITE_COORD ( list . mBlipPositions [ counter ] [ 2 ] ) ;
WRITE_BYTE ( list . mBlipStatus [ counter ] ) ;
if ( friendly_blips ) { WRITE_BYTE ( list . mBlipInfo [ counter ] ) ; }
}
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_BuildMiniMap ( void * const buffer , const int size , string & name , int & num_samples , int & processed_samples , int & width , int & height , uint8 * * map , bool & finished )
{
BEGIN_READ ( buffer , size ) ;
switch ( READ_BYTE ( ) )
{
case 0 :
name = READ_STRING ( ) ;
num_samples = READ_LONG ( ) ;
processed_samples = 0 ;
width = READ_LONG ( ) ;
height = READ_LONG ( ) ;
* map = new uint8 [ num_samples ] ;
finished = false ;
break ;
case 1 :
{
int packet_samples = READ_BYTE ( ) ;
for ( int counter = 0 ; counter < packet_samples ; counter + + )
{
( * map ) [ processed_samples + + ] = READ_BYTE ( ) ;
}
finished = false ;
break ;
}
case 2 :
finished = true ;
break ;
}
END_READ ( ) ;
}
# else
void NetMsg_BuildMiniMap_Initialize ( entvars_t * const pev , const string & name , const int num_samples , const int width , const int height )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgBuildMiniMap , NULL , pev ) ;
WRITE_BYTE ( 0 ) ;
WRITE_STRING ( name . c_str ( ) ) ;
WRITE_LONG ( num_samples ) ;
WRITE_LONG ( width ) ;
WRITE_LONG ( height ) ;
MESSAGE_END ( ) ;
}
void NetMsg_BuildMiniMap_Update ( entvars_t * const pev , const int num_samples , const uint8 * const samples )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgBuildMiniMap , NULL , pev ) ;
WRITE_BYTE ( 1 ) ;
WRITE_BYTE ( num_samples ) ;
for ( int counter = 0 ; counter < num_samples ; counter + + )
{
WRITE_BYTE ( samples [ counter ] ) ;
}
MESSAGE_END ( ) ;
}
void NetMsg_BuildMiniMap_Complete ( entvars_t * const pev )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgBuildMiniMap , NULL , pev ) ;
WRITE_BYTE ( 2 ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_ClientScripts ( void * const buffer , const int size , StringList & script_names )
{
script_names . clear ( ) ;
BEGIN_READ ( buffer , size ) ;
int num_scripts = READ_BYTE ( ) ;
while ( script_names . size ( ) < num_scripts )
{
script_names . push_back ( string ( READ_STRING ( ) ) ) ;
}
END_READ ( ) ;
}
# else
void NetMsg_ClientScripts ( entvars_t * const pev , const StringList & script_names )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgClientScripts , NULL , pev ) ;
WRITE_BYTE ( script_names . size ( ) ) ;
StringList : : const_iterator current , end = script_names . end ( ) ;
for ( current = script_names . begin ( ) ; current ! = end ; + + current )
{
WRITE_STRING ( current - > c_str ( ) ) ;
}
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_DebugCSP ( void * const buffer , const int size , weapon_data_t & weapon_data , float & next_attack )
{
BEGIN_READ ( buffer , size ) ;
weapon_data . m_iId = READ_LONG ( ) ;
weapon_data . m_iClip = READ_LONG ( ) ;
weapon_data . m_flNextPrimaryAttack = READ_COORD ( ) ;
weapon_data . m_flTimeWeaponIdle = READ_COORD ( ) ;
next_attack = READ_COORD ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_DebugCSP ( entvars_t * const pev , const weapon_data_t & weapon_data , const float next_attack )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgDebugCSP , NULL , pev ) ;
WRITE_LONG ( weapon_data . m_iId ) ;
WRITE_LONG ( weapon_data . m_iClip ) ;
WRITE_COORD ( weapon_data . m_flNextPrimaryAttack ) ;
WRITE_COORD ( weapon_data . m_flTimeWeaponIdle ) ;
WRITE_COORD ( next_attack ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_EditPS ( void * const buffer , const int size , int & particle_index )
{
BEGIN_READ ( buffer , size ) ;
particle_index = READ_SHORT ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_EditPS ( entvars_t * const pev , const int particle_index )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgEditPS , NULL , pev ) ;
WRITE_SHORT ( particle_index ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_Fog ( void * const buffer , const int size , bool & enabled , int & R , int & G , int & B , float & start , float & end )
{
BEGIN_READ ( buffer , size ) ;
enabled = ( READ_BYTE ( ) ! = 0 ) ;
if ( enabled )
{
R = READ_BYTE ( ) ;
G = READ_BYTE ( ) ;
B = READ_BYTE ( ) ;
start = READ_COORD ( ) ;
end = READ_COORD ( ) ;
}
END_READ ( ) ;
}
# else
void NetMsg_Fog ( entvars_t * const pev , const bool enabled , const int R , const int G , const int B , const float start , const float end )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgFog , NULL , pev ) ;
WRITE_BYTE ( enabled ? 1 : 0 ) ;
if ( enabled )
{
WRITE_BYTE ( R ) ;
WRITE_BYTE ( G ) ;
WRITE_BYTE ( B ) ;
WRITE_COORD ( start ) ;
WRITE_COORD ( end ) ;
}
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_GameStatus ( void * const buffer , const int size , int & status_code , AvHMapMode & map_mode , int & game_time , int & timelimit , int & misc_data )
{
BEGIN_READ ( buffer , size ) ;
status_code = READ_BYTE ( ) ;
map_mode = ( AvHMapMode ) READ_BYTE ( ) ;
switch ( status_code )
{
case kGameStatusReset :
case kGameStatusResetNewMap :
case kGameStatusEnded :
break ;
case kGameStatusGameTime :
game_time = READ_SHORT ( ) ;
timelimit = READ_SHORT ( ) ;
misc_data = READ_BYTE ( ) ;
break ;
case kGameStatusUnspentLevels :
misc_data = READ_BYTE ( ) ;
break ;
}
END_READ ( ) ;
}
# else
void NetMsg_GameStatus_State ( const int status_code , const int map_mode )
{
MESSAGE_BEGIN ( MSG_ALL , g_msgGameStatus ) ;
WRITE_BYTE ( status_code ) ;
WRITE_BYTE ( map_mode ) ;
MESSAGE_END ( ) ;
}
void NetMsg_GameStatus_State ( entvars_t * const pev , const int status_code , const int map_mode )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgGameStatus , NULL , pev ) ;
WRITE_BYTE ( status_code ) ;
WRITE_BYTE ( map_mode ) ;
MESSAGE_END ( ) ;
}
void NetMsg_GameStatus_Time ( const int status_code , const int map_mode , const int game_time , const int timelimit , const int attacking_team_number , const bool is_reliable )
{
int message_type = is_reliable ? MSG_ALL : MSG_BROADCAST ;
MESSAGE_BEGIN ( message_type , g_msgGameStatus ) ;
WRITE_BYTE ( status_code ) ;
WRITE_BYTE ( map_mode ) ;
WRITE_SHORT ( game_time ) ;
WRITE_SHORT ( timelimit ) ;
WRITE_BYTE ( attacking_team_number ) ;
MESSAGE_END ( ) ;
}
void NetMsg_GameStatus_UnspentLevels ( entvars_t * const pev , const int status_code , const int map_mode , const int unspent_levels )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgGameStatus , NULL , pev ) ;
WRITE_BYTE ( status_code ) ;
WRITE_BYTE ( map_mode ) ;
WRITE_BYTE ( unspent_levels ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_ListPS ( void * const buffer , const int size , string & system_name )
{
BEGIN_READ ( buffer , size ) ;
system_name = READ_STRING ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_ListPS ( entvars_t * const pev , const string & system_name )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgListPS , NULL , pev ) ;
WRITE_STRING ( system_name . c_str ( ) ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_PlayHUDNotification ( void * const buffer , const int size , int & flags , int & sound , float & location_x , float & location_y )
{
BEGIN_READ ( buffer , size ) ;
flags = READ_BYTE ( ) ;
sound = READ_BYTE ( ) ;
location_x = READ_COORD ( ) ;
location_y = READ_COORD ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_PlayHUDNotification ( entvars_t * const pev , const int flags , const int sound , const float location_x , const float location_y )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgPlayHUDNotification , NULL , pev ) ;
WRITE_BYTE ( flags ) ;
WRITE_BYTE ( sound ) ;
WRITE_COORD ( location_x ) ;
WRITE_COORD ( location_y ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_ProgressBar ( void * const buffer , const int size , int & entity_number , int & progress )
{
BEGIN_READ ( buffer , size ) ;
entity_number = READ_SHORT ( ) ;
progress = READ_BYTE ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_ProgressBar ( entvars_t * const pev , const int entity_number , const int progress )
{
MESSAGE_BEGIN ( MSG_ONE_UNRELIABLE , g_msgProgressBar , NULL , pev ) ;
WRITE_SHORT ( entity_number ) ;
WRITE_BYTE ( progress ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_ServerVar ( void * const buffer , const int size , string & name , string & value )
{
BEGIN_READ ( buffer , size ) ;
name = READ_STRING ( ) ;
value = READ_STRING ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_ServerVar ( entvars_t * const pev , const string & name , const string & value )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgServerVar , NULL , pev ) ;
WRITE_STRING ( name . c_str ( ) ) ;
WRITE_STRING ( value . c_str ( ) ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_SetGammaRamp ( void * const buffer , const int size , float & gamma )
{
BEGIN_READ ( buffer , size ) ;
gamma = READ_COORD ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_SetGammaRamp ( entvars_t * const pev , const float gamma )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgSetGammaRamp , NULL , pev ) ;
WRITE_COORD ( gamma ) ;
MESSAGE_END ( ) ;
}
void NetMsgSpec_SetGammaRamp ( const float gamma )
{
MESSAGE_BEGIN ( MSG_SPEC , g_msgSetGammaRamp ) ;
WRITE_COORD ( gamma ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_SetOrder ( void * const buffer , const int size , AvHOrder & order )
{
EntityListType players ;
BEGIN_READ ( buffer , size ) ;
order . SetReceiver ( READ_BYTE ( ) ) ;
order . SetOrderType ( ( AvHOrderType ) READ_BYTE ( ) ) ;
//order.SetOrderTargetType((AvHOrderTargetType)READ_BYTE()); //this is a redundant byte because SetOrderType automatically sets the target type as well.
switch ( order . GetOrderTargetType ( ) )
{
case ORDERTARGETTYPE_LOCATION :
{
vec3_t location ;
location . x = READ_COORD ( ) ;
location . y = READ_COORD ( ) ;
location . z = READ_COORD ( ) ;
order . SetLocation ( location ) ;
break ;
}
case ORDERTARGETTYPE_TARGET :
order . SetTargetIndex ( READ_SHORT ( ) ) ;
break ;
}
order . SetUser3TargetType ( ( AvHUser3 ) READ_BYTE ( ) ) ;
order . SetOrderCompleted ( READ_BYTE ( ) ) ;
// puzl: 1050
// Need to sync the order status as it is only manipulated by the serverside state machine
order . SetOrderStatus ( READ_BYTE ( ) ) ;
END_READ ( ) ;
}
# else
void NetMsg_SetOrder ( entvars_t * const pev , const AvHOrder & order )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgSetOrder , NULL , pev ) ;
WRITE_BYTE ( order . GetReceiver ( ) ) ;
WRITE_BYTE ( order . GetOrderType ( ) ) ;
//WRITE_BYTE( order.GetOrderTargetType() ); //this is a redundant byte because SetOrderType automatically sets the target type as well.
switch ( order . GetOrderTargetType ( ) )
{
case ORDERTARGETTYPE_LOCATION :
{
vec3_t location ;
order . GetLocation ( location ) ;
WRITE_COORD ( location . x ) ;
WRITE_COORD ( location . y ) ;
WRITE_COORD ( location . z ) ;
break ;
}
case ORDERTARGETTYPE_TARGET :
WRITE_SHORT ( order . GetTargetIndex ( ) ) ;
break ;
}
WRITE_BYTE ( order . GetTargetUser3Type ( ) ) ;
WRITE_BYTE ( order . GetOrderCompleted ( ) ) ;
// puzl: 1050
// Need to sync the order status as it is only manipulated by the serverside state machine
WRITE_BYTE ( order . GetOrderStatus ( ) ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_SetParticleTemplate ( void * const buffer , const int size , AvHParticleTemplate & particle_template )
{
ParticleParams gen_params , vel_params ;
PSVector gravity ;
BEGIN_READ ( buffer , size ) ;
particle_template . SetName ( string ( READ_STRING ( ) ) ) ;
particle_template . SetMaxParticles ( READ_LONG ( ) ) ;
particle_template . SetParticleSize ( READ_COORD ( ) ) ;
particle_template . SetSprite ( string ( READ_STRING ( ) ) ) ;
particle_template . SetParticleSystemLifetime ( READ_COORD ( ) ) ;
particle_template . SetParticleLifetime ( READ_COORD ( ) ) ;
particle_template . SetAnimationSpeed ( READ_COORD ( ) ) ;
particle_template . SetNumSpriteFrames ( READ_BYTE ( ) ) ;
particle_template . SetParticleScaling ( READ_COORD ( ) ) ;
particle_template . SetRenderMode ( READ_BYTE ( ) ) ;
particle_template . SetGenerationRate ( READ_LONG ( ) ) ;
particle_template . SetGenerationShape ( READ_BYTE ( ) ) ;
for ( int counter = 0 ; counter < 8 ; counter + + ) { gen_params [ counter ] = READ_LONG ( ) ; }
particle_template . SetGenerationParams ( gen_params ) ;
particle_template . SetGenerationEntityIndex ( READ_LONG ( ) ) ;
particle_template . SetGenerationEntityParameter ( READ_COORD ( ) ) ;
particle_template . SetStartingVelocityShape ( READ_BYTE ( ) ) ;
for ( int counter = 0 ; counter < 8 ; counter + + ) { vel_params [ counter ] = READ_LONG ( ) ; }
particle_template . SetStartingVelocityParams ( vel_params ) ;
for ( int counter = 0 ; counter < 3 ; counter + + ) { gravity [ counter ] = READ_COORD ( ) ; }
particle_template . SetGravity ( gravity ) ;
particle_template . SetMaxAlpha ( READ_COORD ( ) ) ;
particle_template . SetParticleSystemIndexToGenerate ( READ_LONG ( ) ) ;
particle_template . SetFlags ( READ_LONG ( ) ) ;
END_READ ( ) ;
}
# else
void NetMsg_SetParticleTemplate ( entvars_t * const pev , const AvHParticleTemplate & particle_template )
{
ParticleParams gen_params , vel_params ;
PSVector gravity ;
MESSAGE_BEGIN ( MSG_ONE , g_msgSetParticleTemplates , NULL , pev ) ;
WRITE_STRING ( particle_template . GetName ( ) . c_str ( ) ) ;
WRITE_LONG ( particle_template . GetMaxParticles ( ) ) ;
WRITE_COORD ( particle_template . GetParticleSize ( ) ) ;
WRITE_STRING ( particle_template . GetSprite ( ) . c_str ( ) ) ;
WRITE_COORD ( particle_template . GetParticleSystemLifetime ( ) ) ;
WRITE_COORD ( particle_template . GetParticleLifetime ( ) ) ;
WRITE_COORD ( particle_template . GetAnimationSpeed ( ) ) ;
WRITE_BYTE ( particle_template . GetNumSpriteFrames ( ) ) ;
WRITE_COORD ( particle_template . GetParticleScaling ( ) ) ;
WRITE_BYTE ( particle_template . GetRenderMode ( ) ) ;
WRITE_LONG ( particle_template . GetGenerationRate ( ) ) ;
WRITE_BYTE ( particle_template . GetGenerationShape ( ) ) ;
particle_template . GetGenerationParams ( gen_params ) ;
for ( int counter = 0 ; counter < 8 ; counter + + ) { WRITE_LONG ( gen_params [ counter ] ) ; }
WRITE_LONG ( particle_template . GetGenerationEntityIndex ( ) ) ;
WRITE_COORD ( particle_template . GetGenerationEntityParameter ( ) ) ;
WRITE_BYTE ( particle_template . GetStartingVelocityShape ( ) ) ;
particle_template . GetStartingVelocityParams ( vel_params ) ;
for ( int counter = 0 ; counter < 8 ; counter + + ) { WRITE_LONG ( vel_params [ counter ] ) ; }
particle_template . GetGravity ( gravity ) ;
for ( int counter = 0 ; counter < 3 ; counter + + ) { WRITE_COORD ( gravity [ counter ] ) ; }
WRITE_COORD ( particle_template . GetMaxAlpha ( ) ) ;
WRITE_LONG ( particle_template . GetParticleSystemIndexToGenerate ( ) ) ;
WRITE_LONG ( particle_template . GetFlags ( ) ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_SetSelect ( void * const buffer , const int size , Selection & selection )
{
selection . selected_entities . clear ( ) ;
BEGIN_READ ( buffer , size ) ;
selection . group_number = READ_BYTE ( ) ;
int num_entities = READ_BYTE ( ) ;
for ( int counter = 0 ; counter < num_entities ; counter + + )
{ selection . selected_entities . push_back ( READ_SHORT ( ) ) ; }
switch ( selection . group_number )
{
case 0 :
selection . tracking_entity = ( READ_BYTE ( ) = = 0 ) ? 0 : READ_SHORT ( ) ;
break ;
case kSelectAllHotGroup :
break ;
default :
selection . group_type = ( AvHUser3 ) READ_BYTE ( ) ;
selection . group_alert = ( AvHAlertType ) READ_BYTE ( ) ;
break ;
}
END_READ ( ) ;
}
# else
void NetMsg_SetSelect ( entvars_t * const pev , Selection & selection )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgSetSelect , NULL , pev ) ;
WRITE_BYTE ( selection . group_number ) ;
WRITE_BYTE ( selection . selected_entities . size ( ) ) ;
EntityListType : : const_iterator current , end = selection . selected_entities . end ( ) ;
for ( current = selection . selected_entities . begin ( ) ; current ! = end ; + + current )
{ WRITE_SHORT ( * current ) ; }
switch ( selection . group_number )
{
case 0 :
if ( selection . tracking_entity ! = 0 )
{
WRITE_BYTE ( 1 ) ;
WRITE_SHORT ( selection . tracking_entity ) ;
}
else
{
WRITE_BYTE ( 0 ) ;
}
break ;
case kSelectAllHotGroup :
break ;
default :
WRITE_BYTE ( selection . group_type ) ;
WRITE_BYTE ( selection . group_alert ) ;
break ;
}
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_SetRequest ( void * const buffer , const int size , int & request_type , int & request_count )
{
BEGIN_READ ( buffer , size ) ;
request_type = READ_BYTE ( ) ;
request_count = READ_BYTE ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_SetRequest ( entvars_t * pev , const int request_type , const int request_count )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgSetRequest , NULL , pev ) ;
WRITE_BYTE ( request_type ) ;
WRITE_BYTE ( request_count ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_SetSoundNames ( void * const buffer , const int size , bool & reset , string & sound_name )
{
BEGIN_READ ( buffer , size ) ;
reset = ( READ_BYTE ( ) ! = 0 ) ? true : false ;
if ( ! reset )
{ sound_name = READ_STRING ( ) ; }
END_READ ( ) ;
}
# else
void NetMsg_SetSoundNames ( entvars_t * pev , const bool reset , const string & sound_name )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgSetSoundNames , NULL , pev ) ;
WRITE_BYTE ( reset ? 1 : 0 ) ;
if ( ! reset )
{ WRITE_STRING ( sound_name . c_str ( ) ) ; }
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_SetTechNode ( void * const buffer , const int size , AvHTechNode * & node )
{
BEGIN_READ ( buffer , size ) ;
node = new AvHTechNode ( ( AvHMessageID ) READ_BYTE ( ) ) ;
node - > setTechID ( ( AvHTechID ) READ_BYTE ( ) ) ;
node - > setPrereqTechID1 ( ( AvHTechID ) READ_BYTE ( ) ) ;
node - > setPrereqTechID2 ( ( AvHTechID ) READ_BYTE ( ) ) ;
node - > setCost ( READ_SHORT ( ) ) ;
node - > setBuildTime ( READ_SHORT ( ) ) ;
int flags = READ_BYTE ( ) ;
node - > setAllowMultiples ( ( flags & 0x01 ) ! = 0 ) ;
node - > setResearchState ( ( flags & 0x04 ) ! = 0 ) ;
node - > setResearchable ( ( flags & 0x02 ) ! = 0 ) ;
END_READ ( ) ;
}
# else
void NetMsg_SetTechNode ( entvars_t * pev , const AvHTechNode * node )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgSetTechNodes , NULL , pev ) ;
WRITE_BYTE ( node - > getMessageID ( ) ) ;
WRITE_BYTE ( node - > getTechID ( ) ) ;
WRITE_BYTE ( node - > getPrereqTechID1 ( ) ) ;
WRITE_BYTE ( node - > getPrereqTechID2 ( ) ) ;
WRITE_SHORT ( node - > getCost ( ) ) ;
WRITE_SHORT ( node - > getBuildTime ( ) ) ;
int flags = 0 ;
if ( node - > getAllowMultiples ( ) ) { flags | = 0x01 ; }
if ( node - > getIsResearchable ( ) ) { flags | = 0x02 ; }
if ( node - > getIsResearched ( ) ) { flags | = 0x04 ; }
WRITE_BYTE ( flags ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_SetTechSlots ( void * const buffer , const int size , AvHTechSlots & tech_slots )
{
BEGIN_READ ( buffer , size ) ;
tech_slots . mUser3 = ( AvHUser3 ) READ_BYTE ( ) ;
for ( int counter = 0 ; counter < kNumTechSlots ; counter + + )
{ tech_slots . mTechSlots [ counter ] = ( AvHMessageID ) READ_BYTE ( ) ; }
END_READ ( ) ;
}
# else
void NetMsg_SetTechSlots ( entvars_t * pev , const AvHTechSlots & tech_slots )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgSetTechSlots , NULL , pev ) ;
WRITE_BYTE ( tech_slots . mUser3 ) ;
for ( int counter = 0 ; counter < kNumTechSlots ; counter + + )
{ WRITE_BYTE ( tech_slots . mTechSlots [ counter ] ) ; }
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_SetTopDown ( void * const buffer , const int size , bool & is_menu_tech , bool & is_top_down , float * position , int & tech_slots )
{
BEGIN_READ ( buffer , size ) ;
is_menu_tech = ( READ_BYTE ( ) ! = 0 ) ;
if ( is_menu_tech )
{ tech_slots = READ_LONG ( ) ; }
else
{
is_top_down = ( READ_BYTE ( ) ! = 0 ) ;
position [ 0 ] = READ_COORD ( ) ;
position [ 1 ] = READ_COORD ( ) ;
position [ 2 ] = READ_COORD ( ) ;
}
END_READ ( ) ;
}
# else
void NetMsg_SetTopDown_Position ( entvars_t * const pev , const bool is_top_down , const float * const position )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgSetTopDown , NULL , pev ) ;
WRITE_BYTE ( 0 ) ;
WRITE_BYTE ( is_top_down ? 1 : 0 ) ;
WRITE_COORD ( position [ 0 ] ) ;
WRITE_COORD ( position [ 1 ] ) ;
WRITE_COORD ( position [ 2 ] ) ;
MESSAGE_END ( ) ;
}
void NetMsg_SetTopDown_TechSlots ( entvars_t * const pev , const int tech_slots )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgSetTopDown , NULL , pev ) ;
WRITE_BYTE ( 1 ) ;
WRITE_LONG ( tech_slots ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_SetupMap ( void * const buffer , const int size , bool & is_location , string & name , float * min_extents , float * max_extents , bool & draw_background )
{
BEGIN_READ ( buffer , size ) ;
is_location = ( READ_BYTE ( ) ! = 0 ) ;
name = READ_STRING ( ) ;
if ( is_location )
{
max_extents [ 0 ] = READ_COORD ( ) ;
max_extents [ 1 ] = READ_COORD ( ) ;
min_extents [ 0 ] = READ_COORD ( ) ;
min_extents [ 1 ] = READ_COORD ( ) ;
}
else
{
min_extents [ 2 ] = READ_COORD ( ) ;
max_extents [ 2 ] = READ_COORD ( ) ;
min_extents [ 0 ] = READ_COORD ( ) ;
min_extents [ 1 ] = READ_COORD ( ) ;
max_extents [ 0 ] = READ_COORD ( ) ;
max_extents [ 1 ] = READ_COORD ( ) ;
draw_background = ( READ_BYTE ( ) ! = 0 ) ;
}
}
# else
void NetMsg_SetupMap_Extents ( entvars_t * const pev , const string & name , const float * const min_extents , const float * const max_extents , const bool draw_background )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgSetupMap , NULL , pev ) ;
WRITE_BYTE ( 0 ) ;
WRITE_STRING ( name . c_str ( ) ) ;
WRITE_COORD ( min_extents [ 2 ] ) ;
WRITE_COORD ( max_extents [ 2 ] ) ;
WRITE_COORD ( min_extents [ 0 ] ) ;
WRITE_COORD ( min_extents [ 1 ] ) ;
WRITE_COORD ( max_extents [ 0 ] ) ;
WRITE_COORD ( max_extents [ 1 ] ) ;
WRITE_BYTE ( draw_background ? 1 : 0 ) ;
MESSAGE_END ( ) ;
}
void NetMsg_SetupMap_Location ( entvars_t * const pev , const string & name , const float * const min_extents , const float * const max_extents )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgSetupMap , NULL , pev ) ;
WRITE_BYTE ( 1 ) ;
WRITE_STRING ( name . c_str ( ) ) ;
WRITE_COORD ( max_extents [ 0 ] ) ;
WRITE_COORD ( max_extents [ 1 ] ) ;
WRITE_COORD ( min_extents [ 0 ] ) ;
WRITE_COORD ( min_extents [ 1 ] ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ifndef AVH_SERVER
void NetMsg_UpdateCountdown ( void * const buffer , const int size , int & countdown )
{
BEGIN_READ ( buffer , size ) ;
countdown = READ_BYTE ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_UpdateCountdown ( const int countdown )
{
MESSAGE_BEGIN ( MSG_ALL , g_msgUpdateCountdown ) ;
WRITE_BYTE ( countdown ) ;
MESSAGE_END ( ) ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
const int kNumStatusBits = 6 ;
const int kStatusMask = 0x3F ;
const int kNumTeamBits = 2 ;
const int kTeamMask = 0x03 ;
const int kNumPositionCoordinateBits = 12 ;
const int kPositionCoordinateMask = 0xFFF ;
const int kPositionCoordinateOffset = 4096 ;
const float kPositionCoordinateScale = 0.5f ;
const int kNumPositionBits = kNumPositionCoordinateBits * 2 ;
const int kNumSquadBits = 3 ;
const int kSquadMask = 0x07 ;
const int kNumAngleBits = 4 ;
const int kAngleMask = 0x0F ;
const int kNumPlayerIndexBits = 6 ;
const int kPlayerIndexMask = 0x3F ;
const int kNumIndexBits = 14 ;
const int kIndexMask = 0x3FFF ;
const int kNumFlagBits = 2 ;
const int kFlagMask = 0x03 ;
const int kEntHierFlagPlayer = 0x01 ;
const int kEntHierFlagDeletion = 0x02 ;
# ifndef AVH_SERVER
//TODO : replace OldItems with vector<int>
void ReadEntHier ( MapEntityMap & NewItems , EntityListType & OldItems , int short_data , int long_data ) ;
float UnpackageCoord ( const int packaged_coord ) ;
void NetMsg_UpdateEntityHierarchy ( void * const buffer , const int size , MapEntityMap & NewItems , EntityListType & OldItems )
{
NewItems . clear ( ) ;
OldItems . clear ( ) ;
int amnt_read = 0 ;
int short_data , long_data = 0 ;
BEGIN_READ ( buffer , size ) ;
while ( amnt_read < size )
{
short_data = READ_SHORT ( ) ;
amnt_read + = 2 ;
if ( ( short_data & kEntHierFlagDeletion ) = = 0 )
{
long_data = READ_LONG ( ) ;
amnt_read + = 4 ;
}
ReadEntHier ( NewItems , OldItems , short_data , long_data ) ;
}
END_READ ( ) ;
}
void ReadEntHier ( MapEntityMap & NewItems , EntityListType & OldItems , int short_data , int long_data )
{
int flags = short_data & kFlagMask ;
short_data > > = kNumFlagBits ;
if ( ( flags & kEntHierFlagDeletion ) = = kEntHierFlagDeletion ) // Deletion (player or otherwise)
{
OldItems . push_back ( short_data & kIndexMask ) ;
return ;
}
MapEntity ent ;
int index = 0 ;
ent . mUser3 = ( AvHUser3 ) ( long_data & kStatusMask ) ;
long_data > > = kNumStatusBits ;
ent . mTeam = ( AvHTeamNumber ) ( long_data & kTeamMask ) ;
long_data > > = kNumTeamBits ;
ent . mY = UnpackageCoord ( long_data & kPositionCoordinateMask ) ;
long_data > > = kNumPositionCoordinateBits ;
ent . mX = UnpackageCoord ( long_data & kPositionCoordinateMask ) ;
if ( ( flags & kEntHierFlagPlayer ) = = kEntHierFlagPlayer ) // Player added/changed
{
index = short_data & kPlayerIndexMask ;
short_data > > = kNumPlayerIndexBits ;
ent . mAngle = ( short_data & kAngleMask ) * 22.5f ;
short_data > > = kNumAngleBits ;
ent . mSquadNumber = short_data & kSquadMask ;
}
else // Other item added/changed
{
index = short_data & kIndexMask ;
ent . mSquadNumber = 0 ;
ent . mAngle = 0 ;
}
NewItems . insert ( MapEntityMap : : value_type ( index , ent ) ) ;
}
float UnpackageCoord ( const int packaged_coord )
{
float returnVal = packaged_coord ;
returnVal / = kPositionCoordinateScale ;
returnVal - = kPositionCoordinateOffset ;
return returnVal ;
}
# else
void WriteEntHier ( const int index , const MapEntity & ent , bool delete_flag , int & short_data , int & long_data ) ;
int PackageCoord ( const float coord ) ;
void NetMsg_UpdateEntityHierarchy ( entvars_t * const pev , const MapEntityMap & NewItems , const EntityListType & OldItems )
{
const int kMaxUpdatesPerPacket = 30 ;
if ( NewItems . empty ( ) & & OldItems . empty ( ) ) { return ; } //nothing to send!
MapEntityMap : : const_iterator new_current , new_end = NewItems . end ( ) ;
MapEntity temp ;
EntityListType : : const_iterator old_current , old_end = OldItems . end ( ) ;
int short_data , long_data , count = 1 ;
MESSAGE_BEGIN ( MSG_ONE , g_msgUpdateEntityHierarchy , NULL , pev ) ;
for ( new_current = NewItems . begin ( ) ; new_current ! = new_end ; + + new_current , + + count )
{
if ( count % kMaxUpdatesPerPacket = = 0 )
{
MESSAGE_END ( ) ;
MESSAGE_BEGIN ( MSG_ONE , g_msgUpdateEntityHierarchy , NULL , pev ) ;
}
WriteEntHier ( new_current - > first , new_current - > second , false , short_data , long_data ) ;
WRITE_SHORT ( short_data ) ;
WRITE_LONG ( long_data ) ;
}
for ( old_current = OldItems . begin ( ) ; old_current ! = old_end ; + + old_current , + + count )
{
if ( count % kMaxUpdatesPerPacket = = 0 )
{
MESSAGE_END ( ) ;
MESSAGE_BEGIN ( MSG_ONE , g_msgUpdateEntityHierarchy , NULL , pev ) ;
}
WriteEntHier ( * old_current , temp , true , short_data , long_data ) ;
WRITE_SHORT ( short_data ) ;
}
MESSAGE_END ( ) ;
}
void WriteEntHier ( const int index , const MapEntity & ent , bool delete_flag , int & short_data , int & long_data )
{
if ( delete_flag )
{
ASSERT ( ( index & ~ kIndexMask ) = = 0 ) ;
short_data = index ;
short_data < < = kNumFlagBits ;
ASSERT ( ( short_data & kFlagMask ) = = 0 ) ;
short_data | = kEntHierFlagDeletion ;
return ;
}
long_data = PackageCoord ( ent . mX ) ;
long_data < < = kNumPositionCoordinateBits ;
ASSERT ( ( long_data & kPositionCoordinateMask ) = = 0 ) ;
long_data | = PackageCoord ( ent . mY ) ;
long_data < < = kNumTeamBits ;
ASSERT ( ( long_data & kTeamMask ) = = 0 ) ;
ASSERT ( ( ent . mTeam & ~ kTeamMask ) = = 0 ) ;
long_data | = ent . mTeam & kTeamMask ;
long_data < < = kNumStatusBits ;
ASSERT ( ( long_data & kStatusMask ) = = 0 ) ;
ASSERT ( ( ent . mUser3 & ~ kStatusMask ) = = 0 ) ;
long_data | = ent . mUser3 & kStatusMask ;
switch ( ent . mUser3 )
{
case AVH_USER3_MARINE_PLAYER : case AVH_USER3_COMMANDER_PLAYER :
case AVH_USER3_ALIEN_PLAYER1 : case AVH_USER3_ALIEN_PLAYER2 :
case AVH_USER3_ALIEN_PLAYER3 : case AVH_USER3_ALIEN_PLAYER4 :
case AVH_USER3_ALIEN_PLAYER5 : case AVH_USER3_ALIEN_EMBRYO :
case AVH_USER3_HEAVY :
{
ASSERT ( ( ent . mSquadNumber & ~ kSquadMask ) = = 0 ) ;
short_data = ent . mSquadNumber ;
short_data < < = kNumAngleBits ;
int angle = WrapFloat ( ent . mAngle , 0 , 360 ) ;
angle / = 22.5f ;
ASSERT ( ( short_data & kAngleMask ) = = 0 ) ;
ASSERT ( ( angle & ~ kAngleMask ) = = 0 ) ;
short_data | = angle & kAngleMask ;
short_data < < = kNumPlayerIndexBits ;
ASSERT ( ( short_data & kPlayerIndexMask ) = = 0 ) ;
ASSERT ( ( index & ~ kPlayerIndexMask ) = = 0 ) ;
short_data | = index & kIndexMask ;
short_data < < = kNumFlagBits ;
ASSERT ( ( short_data & kFlagMask ) = = 0 ) ;
short_data | = kEntHierFlagPlayer ;
break ;
}
default :
ASSERT ( ( index & ~ kIndexMask ) = = 0 ) ;
short_data = index & kIndexMask ;
short_data < < = kNumFlagBits ;
}
}
int PackageCoord ( const float coord )
{
float adjustedCoord = coord ;
adjustedCoord + = kPositionCoordinateOffset ;
adjustedCoord * = kPositionCoordinateScale ;
int returnVal = adjustedCoord ;
ASSERT ( ( returnVal & ~ kPositionCoordinateMask ) = = 0 ) ;
returnVal & = kPositionCoordinateMask ;
return returnVal ;
}
# endif
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// tankefugl: 0000971
# ifndef AVH_SERVER
void NetMsg_IssueOrder ( void * const buffer , const int size , int & ordertype , int & ordersource , int & ordertarget )
{
BEGIN_READ ( buffer , size ) ;
ordertype = READ_BYTE ( ) ;
ordersource = READ_LONG ( ) ;
ordertarget = READ_LONG ( ) ;
END_READ ( ) ;
}
# else
void NetMsg_IssueOrder ( entvars_t * const pev , const int ordertype , const int ordersource , const int ordertarget )
{
MESSAGE_BEGIN ( MSG_ONE , g_msgIssueOrder , NULL , pev ) ;
WRITE_BYTE ( ordertype ) ;
WRITE_LONG ( ordersource ) ;
WRITE_LONG ( ordertarget ) ;
MESSAGE_END ( ) ;
}
# endif
// :tankefugl