mirror of https://github.com/FWGS/hlsdk-xash3d
Revert some changes from PR
This commit is contained in:
commit
008234143e
|
@ -26,9 +26,9 @@
|
|||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
DECLARE_MESSAGE( m_MOTD, MOTD );
|
||||
DECLARE_MESSAGE( m_MOTD, MOTD )
|
||||
|
||||
int CHudMOTD :: Init( void )
|
||||
int CHudMOTD::Init( void )
|
||||
{
|
||||
gHUD.AddHudElem( this );
|
||||
|
||||
|
@ -42,13 +42,13 @@ int CHudMOTD :: Init( void )
|
|||
return 1;
|
||||
}
|
||||
|
||||
int CHudMOTD :: VidInit( void )
|
||||
int CHudMOTD::VidInit( void )
|
||||
{
|
||||
// Load sprites here
|
||||
return 1;
|
||||
}
|
||||
|
||||
void CHudMOTD :: Reset( void )
|
||||
void CHudMOTD::Reset( void )
|
||||
{
|
||||
m_iFlags &= ~HUD_ACTIVE; // start out inactive
|
||||
m_szMOTD[0] = 0;
|
||||
|
@ -60,7 +60,7 @@ void CHudMOTD :: Reset( void )
|
|||
#define ROW_GAP 13
|
||||
#define ROW_RANGE_MIN 30
|
||||
#define ROW_RANGE_MAX ( ScreenHeight - 100 )
|
||||
int CHudMOTD :: Draw( float fTime )
|
||||
int CHudMOTD::Draw( float fTime )
|
||||
{
|
||||
gHUD.m_iNoConsolePrint &= ~( 1 << 1 );
|
||||
if( !m_bShow )
|
||||
|
@ -68,60 +68,61 @@ int CHudMOTD :: Draw( float fTime )
|
|||
gHUD.m_iNoConsolePrint |= 1 << 1;
|
||||
bool bScroll;
|
||||
// find the top of where the MOTD should be drawn, so the whole thing is centered in the screen
|
||||
int ypos = (ScreenHeight - LINE_HEIGHT * m_iLines)/2; // shift it up slightly
|
||||
int ypos = ( ScreenHeight - LINE_HEIGHT * m_iLines ) / 2; // shift it up slightly
|
||||
char *ch = m_szMOTD;
|
||||
int xpos = (ScreenWidth - gHUD.m_scrinfo.charWidths[ 'M' ] * m_iMaxLength) / 2;
|
||||
if( xpos < 30 ) xpos = 30;
|
||||
int xmax = xpos + gHUD.m_scrinfo.charWidths[ 'M' ] * m_iMaxLength;
|
||||
int xpos = ( ScreenWidth - gHUD.m_scrinfo.charWidths['M'] * m_iMaxLength ) / 2;
|
||||
if( xpos < 30 )
|
||||
xpos = 30;
|
||||
int xmax = xpos + gHUD.m_scrinfo.charWidths['M'] * m_iMaxLength;
|
||||
int height = LINE_HEIGHT * m_iLines;
|
||||
int ypos_r=ypos;
|
||||
if( height > ROW_RANGE_MAX )
|
||||
{
|
||||
ypos = ROW_RANGE_MIN + 7 + scroll;
|
||||
if( ypos > ROW_RANGE_MIN + 4 )
|
||||
scroll-= (ypos - ( ROW_RANGE_MIN + 4))/3.0;
|
||||
scroll-= ( ypos - ( ROW_RANGE_MIN + 4 ) ) / 3.0;
|
||||
if( ypos + height < ROW_RANGE_MAX )
|
||||
scroll+= (ROW_RANGE_MAX - (ypos + height))/ 3.0;
|
||||
scroll+= ( ROW_RANGE_MAX - ( ypos + height ) ) / 3.0;
|
||||
ypos_r = ROW_RANGE_MIN;
|
||||
height = ROW_RANGE_MAX;
|
||||
}
|
||||
int ymax = ypos + height;
|
||||
if( xmax > ScreenWidth - 30 ) xmax = ScreenWidth - 30;
|
||||
gHUD.DrawDarkRectangle(xpos-5, ypos_r - 5, xmax - xpos+10, height + 10);
|
||||
while ( *ch )
|
||||
gHUD.DrawDarkRectangle( xpos - 5, ypos_r - 5, xmax - xpos + 10, height + 10 );
|
||||
while( *ch )
|
||||
{
|
||||
char *next_line;
|
||||
int line_length = 0; // count the length of the current line
|
||||
for ( next_line = ch; *next_line != '\n' && *next_line != 0; next_line++ )
|
||||
line_length += gHUD.m_scrinfo.charWidths[ *next_line ];
|
||||
for( next_line = ch; *next_line != '\n' && *next_line != 0; next_line++ )
|
||||
line_length += gHUD.m_scrinfo.charWidths[*next_line];
|
||||
char *top = next_line;
|
||||
if ( *top == '\n' )
|
||||
if( *top == '\n' )
|
||||
*top = 0;
|
||||
else
|
||||
top = NULL;
|
||||
|
||||
// find where to start drawing the line
|
||||
if( (ypos > ROW_RANGE_MIN) && (ypos + LINE_HEIGHT <= ypos_r + height) )
|
||||
if( ( ypos > ROW_RANGE_MIN ) && ( ypos + LINE_HEIGHT <= ypos_r + height ) )
|
||||
gHUD.DrawHudString( xpos, ypos, xmax, ch, 255, 180, 0 );
|
||||
|
||||
ypos += LINE_HEIGHT;
|
||||
|
||||
if ( top ) // restore
|
||||
if( top ) // restore
|
||||
*top = '\n';
|
||||
ch = next_line;
|
||||
if ( *ch == '\n' )
|
||||
if( *ch == '\n' )
|
||||
ch++;
|
||||
|
||||
if ( ypos > (ScreenHeight - 20) )
|
||||
if( ypos > ( ScreenHeight - 20 ) )
|
||||
break; // don't let it draw too low
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudMOTD :: MsgFunc_MOTD( const char *pszName, int iSize, void *pbuf )
|
||||
int CHudMOTD::MsgFunc_MOTD( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
if ( m_iFlags & HUD_ACTIVE )
|
||||
if( m_iFlags & HUD_ACTIVE )
|
||||
{
|
||||
Reset(); // clear the current MOTD in prep for this one
|
||||
}
|
||||
|
@ -131,17 +132,16 @@ int CHudMOTD :: MsgFunc_MOTD( const char *pszName, int iSize, void *pbuf )
|
|||
int is_finished = READ_BYTE();
|
||||
strncat( m_szMOTD, READ_STRING(), sizeof(m_szMOTD) );
|
||||
|
||||
if ( is_finished )
|
||||
if( is_finished )
|
||||
{
|
||||
int length = 0;
|
||||
|
||||
m_iMaxLength = 0;
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
|
||||
|
||||
for ( char *sz = m_szMOTD; *sz != 0; sz++ ) // count the number of lines in the MOTD
|
||||
for( char *sz = m_szMOTD; *sz != 0; sz++ ) // count the number of lines in the MOTD
|
||||
{
|
||||
if ( *sz == '\n' )
|
||||
if( *sz == '\n' )
|
||||
{
|
||||
m_iLines++;
|
||||
if( length > m_iMaxLength )
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -27,76 +27,76 @@ public:
|
|||
// Initialization
|
||||
virtual void Init( void );
|
||||
|
||||
public:
|
||||
public:
|
||||
// Public Interfaces
|
||||
virtual int StudioDrawModel ( int flags );
|
||||
virtual int StudioDrawPlayer ( int flags, struct entity_state_s *pplayer );
|
||||
virtual int StudioDrawModel( int flags );
|
||||
virtual int StudioDrawPlayer( int flags, struct entity_state_s *pplayer );
|
||||
|
||||
public:
|
||||
// Local interfaces
|
||||
//
|
||||
|
||||
// Look up animation data for sequence
|
||||
virtual mstudioanim_t *StudioGetAnim ( model_t *m_pSubModel, mstudioseqdesc_t *pseqdesc );
|
||||
virtual mstudioanim_t *StudioGetAnim( model_t *m_pSubModel, mstudioseqdesc_t *pseqdesc );
|
||||
|
||||
// Interpolate model position and angles and set up matrices
|
||||
virtual void StudioSetUpTransform (int trivial_accept);
|
||||
virtual void StudioSetUpTransform( int trivial_accept );
|
||||
|
||||
// Set up model bone positions
|
||||
virtual void StudioSetupBones ( void );
|
||||
virtual void StudioSetupBones( void );
|
||||
|
||||
// Find final attachment points
|
||||
virtual void StudioCalcAttachments ( void );
|
||||
virtual void StudioCalcAttachments( void );
|
||||
|
||||
// Save bone matrices and names
|
||||
virtual void StudioSaveBones( void );
|
||||
|
||||
// Merge cached bones with current bones for model
|
||||
virtual void StudioMergeBones ( model_t *m_pSubModel );
|
||||
virtual void StudioMergeBones( model_t *m_pSubModel );
|
||||
|
||||
// Determine interpolation fraction
|
||||
virtual float StudioEstimateInterpolant( void );
|
||||
|
||||
// Determine current frame for rendering
|
||||
virtual float StudioEstimateFrame ( mstudioseqdesc_t *pseqdesc );
|
||||
virtual float StudioEstimateFrame( mstudioseqdesc_t *pseqdesc );
|
||||
|
||||
// Apply special effects to transform matrix
|
||||
virtual void StudioFxTransform( cl_entity_t *ent, float transform[3][4] );
|
||||
|
||||
// Spherical interpolation of bones
|
||||
virtual void StudioSlerpBones ( vec4_t q1[], float pos1[][3], vec4_t q2[], float pos2[][3], float s );
|
||||
virtual void StudioSlerpBones( vec4_t q1[], float pos1[][3], vec4_t q2[], float pos2[][3], float s );
|
||||
|
||||
// Compute bone adjustments ( bone controllers )
|
||||
virtual void StudioCalcBoneAdj ( float dadt, float *adj, const byte *pcontroller1, const byte *pcontroller2, byte mouthopen );
|
||||
// Compute bone adjustments( bone controllers )
|
||||
virtual void StudioCalcBoneAdj( float dadt, float *adj, const byte *pcontroller1, const byte *pcontroller2, byte mouthopen );
|
||||
|
||||
// Get bone quaternions
|
||||
virtual void StudioCalcBoneQuaterion ( int frame, float s, mstudiobone_t *pbone, mstudioanim_t *panim, float *adj, float *q );
|
||||
virtual void StudioCalcBoneQuaterion( int frame, float s, mstudiobone_t *pbone, mstudioanim_t *panim, float *adj, float *q );
|
||||
|
||||
// Get bone positions
|
||||
virtual void StudioCalcBonePosition ( int frame, float s, mstudiobone_t *pbone, mstudioanim_t *panim, float *adj, float *pos );
|
||||
virtual void StudioCalcBonePosition( int frame, float s, mstudiobone_t *pbone, mstudioanim_t *panim, float *adj, float *pos );
|
||||
|
||||
// Compute rotations
|
||||
virtual void StudioCalcRotations ( float pos[][3], vec4_t *q, mstudioseqdesc_t *pseqdesc, mstudioanim_t *panim, float f );
|
||||
virtual void StudioCalcRotations( float pos[][3], vec4_t *q, mstudioseqdesc_t *pseqdesc, mstudioanim_t *panim, float f );
|
||||
|
||||
// Send bones and verts to renderer
|
||||
virtual void StudioRenderModel ( void );
|
||||
virtual void StudioRenderModel( void );
|
||||
|
||||
// Finalize rendering
|
||||
virtual void StudioRenderFinal (void);
|
||||
virtual void StudioRenderFinal( void );
|
||||
|
||||
// GL&D3D vs. Software renderer finishing functions
|
||||
virtual void StudioRenderFinal_Software ( void );
|
||||
virtual void StudioRenderFinal_Hardware ( void );
|
||||
virtual void StudioRenderFinal_Software( void );
|
||||
virtual void StudioRenderFinal_Hardware( void );
|
||||
|
||||
// Player specific data
|
||||
// Determine pitch and blending amounts for players
|
||||
virtual void StudioPlayerBlend ( mstudioseqdesc_t *pseqdesc, int *pBlend, float *pPitch );
|
||||
virtual void StudioPlayerBlend( mstudioseqdesc_t *pseqdesc, int *pBlend, float *pPitch );
|
||||
|
||||
// Estimate gait frame for player
|
||||
virtual void StudioEstimateGait ( entity_state_t *pplayer );
|
||||
virtual void StudioEstimateGait( entity_state_t *pplayer );
|
||||
|
||||
// Process movement of player
|
||||
virtual void StudioProcessGait ( entity_state_t *pplayer );
|
||||
virtual void StudioProcessGait( entity_state_t *pplayer );
|
||||
|
||||
public:
|
||||
|
||||
|
@ -145,7 +145,7 @@ public:
|
|||
mstudiomodel_t *m_pSubModel;
|
||||
|
||||
// Palette substition for top and bottom of model
|
||||
int m_nTopColor;
|
||||
int m_nTopColor;
|
||||
int m_nBottomColor;
|
||||
|
||||
//
|
||||
|
@ -156,34 +156,34 @@ public:
|
|||
// Number of bones in bone cache
|
||||
int m_nCachedBones;
|
||||
// Names of cached bones
|
||||
char m_nCachedBoneNames[ MAXSTUDIOBONES ][ 32 ];
|
||||
char m_nCachedBoneNames[MAXSTUDIOBONES][32];
|
||||
// Cached bone & light transformation matrices
|
||||
float m_rgCachedBoneTransform [ MAXSTUDIOBONES ][ 3 ][ 4 ];
|
||||
float m_rgCachedLightTransform[ MAXSTUDIOBONES ][ 3 ][ 4 ];
|
||||
float m_rgCachedBoneTransform[MAXSTUDIOBONES][3][4];
|
||||
float m_rgCachedLightTransform[MAXSTUDIOBONES][3][4];
|
||||
|
||||
// Software renderer scale factors
|
||||
float m_fSoftwareXScale, m_fSoftwareYScale;
|
||||
|
||||
// Current view vectors and render origin
|
||||
float m_vUp[ 3 ];
|
||||
float m_vRight[ 3 ];
|
||||
float m_vNormal[ 3 ];
|
||||
float m_vUp[3];
|
||||
float m_vRight[3];
|
||||
float m_vNormal[3];
|
||||
|
||||
float m_vRenderOrigin[3];
|
||||
|
||||
float m_vRenderOrigin[ 3 ];
|
||||
|
||||
// Model render counters ( from engine )
|
||||
int *m_pStudioModelCount;
|
||||
int *m_pModelsDrawn;
|
||||
|
||||
// Matrices
|
||||
// Model to world transformation
|
||||
float (*m_protationmatrix)[ 3 ][ 4 ];
|
||||
float (*m_protationmatrix)[3][4];
|
||||
// Model to view transformation
|
||||
float (*m_paliastransform)[ 3 ][ 4 ];
|
||||
float (*m_paliastransform)[3][4];
|
||||
|
||||
// Concatenated bone and light transforms
|
||||
float (*m_pbonetransform) [ MAXSTUDIOBONES ][ 3 ][ 4 ];
|
||||
float (*m_plighttransform)[ MAXSTUDIOBONES ][ 3 ][ 4 ];
|
||||
float (*m_pbonetransform)[MAXSTUDIOBONES][3][4];
|
||||
float (*m_plighttransform)[MAXSTUDIOBONES][3][4];
|
||||
};
|
||||
|
||||
#endif // STUDIOMODELRENDERER_H
|
||||
#endif // STUDIOMODELRENDERER_H
|
||||
|
|
627
cl_dll/ammo.cpp
627
cl_dll/ammo.cpp
File diff suppressed because it is too large
Load Diff
|
@ -18,7 +18,6 @@
|
|||
|
||||
#define MAX_WEAPON_NAME 128
|
||||
|
||||
|
||||
#define WEAPON_FLAGS_SELECTONEMPTY 1
|
||||
|
||||
#define WEAPON_IS_ONTARGET 0x40
|
||||
|
@ -57,6 +56,4 @@ struct WEAPON
|
|||
};
|
||||
|
||||
typedef int AMMO;
|
||||
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
|
|
@ -24,10 +24,10 @@
|
|||
#include <stdio.h>
|
||||
#include "parsemsg.h"
|
||||
|
||||
DECLARE_MESSAGE( m_AmmoSecondary, SecAmmoVal );
|
||||
DECLARE_MESSAGE( m_AmmoSecondary, SecAmmoIcon );
|
||||
DECLARE_MESSAGE( m_AmmoSecondary, SecAmmoVal )
|
||||
DECLARE_MESSAGE( m_AmmoSecondary, SecAmmoIcon )
|
||||
|
||||
int CHudAmmoSecondary :: Init( void )
|
||||
int CHudAmmoSecondary::Init( void )
|
||||
{
|
||||
HOOK_MESSAGE( SecAmmoVal );
|
||||
HOOK_MESSAGE( SecAmmoIcon );
|
||||
|
@ -35,7 +35,7 @@ int CHudAmmoSecondary :: Init( void )
|
|||
gHUD.AddHudElem(this);
|
||||
m_HUD_ammoicon = 0;
|
||||
|
||||
for ( int i = 0; i < MAX_SEC_AMMO_VALUES; i++ )
|
||||
for( int i = 0; i < MAX_SEC_AMMO_VALUES; i++ )
|
||||
m_iAmmoAmounts[i] = -1; // -1 means don't draw this value
|
||||
|
||||
Reset();
|
||||
|
@ -43,67 +43,68 @@ int CHudAmmoSecondary :: Init( void )
|
|||
return 1;
|
||||
}
|
||||
|
||||
void CHudAmmoSecondary :: Reset( void )
|
||||
void CHudAmmoSecondary::Reset( void )
|
||||
{
|
||||
m_fFade = 0;
|
||||
}
|
||||
|
||||
int CHudAmmoSecondary :: VidInit( void )
|
||||
int CHudAmmoSecondary::VidInit( void )
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudAmmoSecondary :: Draw(float flTime)
|
||||
int CHudAmmoSecondary::Draw( float flTime )
|
||||
{
|
||||
if ( (gHUD.m_iHideHUDDisplay & ( HIDEHUD_WEAPONS | HIDEHUD_ALL )) )
|
||||
if( ( gHUD.m_iHideHUDDisplay & ( HIDEHUD_WEAPONS | HIDEHUD_ALL ) ) )
|
||||
return 1;
|
||||
|
||||
// draw secondary ammo icons above normal ammo readout
|
||||
int a, x, y, r, g, b, AmmoWidth;
|
||||
UnpackRGB( r, g, b, RGB_YELLOWISH );
|
||||
a = (int) max( MIN_ALPHA, m_fFade );
|
||||
if (m_fFade > 0)
|
||||
m_fFade -= (gHUD.m_flTimeDelta * 20); // slowly lower alpha to fade out icons
|
||||
a = (int)max( MIN_ALPHA, m_fFade );
|
||||
if( m_fFade > 0 )
|
||||
m_fFade -= ( gHUD.m_flTimeDelta * 20 ); // slowly lower alpha to fade out icons
|
||||
ScaleColors( r, g, b, a );
|
||||
|
||||
AmmoWidth = gHUD.GetSpriteRect(gHUD.m_HUD_number_0).right - gHUD.GetSpriteRect(gHUD.m_HUD_number_0).left;
|
||||
AmmoWidth = gHUD.GetSpriteRect( gHUD.m_HUD_number_0 ).right - gHUD.GetSpriteRect( gHUD.m_HUD_number_0 ).left;
|
||||
|
||||
y = ScreenHeight - (gHUD.m_iFontHeight*4); // this is one font height higher than the weapon ammo values
|
||||
y = ScreenHeight - ( gHUD.m_iFontHeight * 4 ); // this is one font height higher than the weapon ammo values
|
||||
x = ScreenWidth - AmmoWidth;
|
||||
|
||||
if ( m_HUD_ammoicon )
|
||||
if( m_HUD_ammoicon )
|
||||
{
|
||||
// Draw the ammo icon
|
||||
x -= (gHUD.GetSpriteRect(m_HUD_ammoicon).right - gHUD.GetSpriteRect(m_HUD_ammoicon).left);
|
||||
y -= (gHUD.GetSpriteRect(m_HUD_ammoicon).top - gHUD.GetSpriteRect(m_HUD_ammoicon).bottom);
|
||||
x -= ( gHUD.GetSpriteRect( m_HUD_ammoicon ).right - gHUD.GetSpriteRect( m_HUD_ammoicon ).left );
|
||||
y -= ( gHUD.GetSpriteRect( m_HUD_ammoicon ).top - gHUD.GetSpriteRect( m_HUD_ammoicon ).bottom );
|
||||
|
||||
SPR_Set( gHUD.GetSprite(m_HUD_ammoicon), r, g, b );
|
||||
SPR_DrawAdditive( 0, x, y, &gHUD.GetSpriteRect(m_HUD_ammoicon) );
|
||||
SPR_Set( gHUD.GetSprite( m_HUD_ammoicon ), r, g, b );
|
||||
SPR_DrawAdditive( 0, x, y, &gHUD.GetSpriteRect( m_HUD_ammoicon ) );
|
||||
}
|
||||
else
|
||||
{ // move the cursor by the '0' char instead, since we don't have an icon to work with
|
||||
{
|
||||
// move the cursor by the '0' char instead, since we don't have an icon to work with
|
||||
x -= AmmoWidth;
|
||||
y -= (gHUD.GetSpriteRect(gHUD.m_HUD_number_0).top - gHUD.GetSpriteRect(gHUD.m_HUD_number_0).bottom);
|
||||
y -= ( gHUD.GetSpriteRect( gHUD.m_HUD_number_0 ).top - gHUD.GetSpriteRect( gHUD.m_HUD_number_0 ).bottom );
|
||||
}
|
||||
|
||||
// draw the ammo counts, in reverse order, from right to left
|
||||
for ( int i = MAX_SEC_AMMO_VALUES-1; i >= 0; i-- )
|
||||
for( int i = MAX_SEC_AMMO_VALUES-1; i >= 0; i-- )
|
||||
{
|
||||
if ( m_iAmmoAmounts[i] < 0 )
|
||||
if( m_iAmmoAmounts[i] < 0 )
|
||||
continue; // negative ammo amounts imply that they shouldn't be drawn
|
||||
|
||||
// half a char gap between the ammo number and the previous pic
|
||||
x -= (AmmoWidth / 2);
|
||||
x -= ( AmmoWidth / 2 );
|
||||
|
||||
// draw the number, right-aligned
|
||||
x -= (gHUD.GetNumWidth( m_iAmmoAmounts[i], DHN_DRAWZERO ) * AmmoWidth);
|
||||
x -= ( gHUD.GetNumWidth( m_iAmmoAmounts[i], DHN_DRAWZERO ) * AmmoWidth );
|
||||
gHUD.DrawHudNumber( x, y, DHN_DRAWZERO, m_iAmmoAmounts[i], r, g, b );
|
||||
|
||||
if ( i != 0 )
|
||||
if( i != 0 )
|
||||
{
|
||||
// draw the divider bar
|
||||
x -= (AmmoWidth / 2);
|
||||
FillRGBA(x, y, (AmmoWidth/10), gHUD.m_iFontHeight, r, g, b, a);
|
||||
x -= ( AmmoWidth / 2 );
|
||||
FillRGBA( x, y, ( AmmoWidth/10 ), gHUD.m_iFontHeight, r, g, b, a );
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -113,7 +114,7 @@ int CHudAmmoSecondary :: Draw(float flTime)
|
|||
// Message handler for Secondary Ammo Value
|
||||
// accepts one value:
|
||||
// string: sprite name
|
||||
int CHudAmmoSecondary :: MsgFunc_SecAmmoIcon( const char *pszName, int iSize, void *pbuf )
|
||||
int CHudAmmoSecondary::MsgFunc_SecAmmoIcon( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
m_HUD_ammoicon = gHUD.GetSpriteIndex( READ_STRING() );
|
||||
|
@ -126,12 +127,12 @@ int CHudAmmoSecondary :: MsgFunc_SecAmmoIcon( const char *pszName, int iSize, vo
|
|||
// takes two values:
|
||||
// byte: ammo index
|
||||
// byte: ammo value
|
||||
int CHudAmmoSecondary :: MsgFunc_SecAmmoVal( const char *pszName, int iSize, void *pbuf )
|
||||
int CHudAmmoSecondary::MsgFunc_SecAmmoVal( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
int index = READ_BYTE();
|
||||
if ( index < 0 || index >= MAX_SEC_AMMO_VALUES )
|
||||
if( index < 0 || index >= MAX_SEC_AMMO_VALUES )
|
||||
return 1;
|
||||
|
||||
m_iAmmoAmounts[index] = READ_BYTE();
|
||||
|
@ -139,13 +140,14 @@ int CHudAmmoSecondary :: MsgFunc_SecAmmoVal( const char *pszName, int iSize, voi
|
|||
|
||||
// check to see if there is anything left to draw
|
||||
int count = 0;
|
||||
for ( int i = 0; i < MAX_SEC_AMMO_VALUES; i++ )
|
||||
for( int i = 0; i < MAX_SEC_AMMO_VALUES; i++ )
|
||||
{
|
||||
count += max( 0, m_iAmmoAmounts[i] );
|
||||
}
|
||||
|
||||
if ( count == 0 )
|
||||
{ // the ammo fields are all empty, so turn off this hud area
|
||||
if( count == 0 )
|
||||
{
|
||||
// the ammo fields are all empty, so turn off this hud area
|
||||
m_iFlags &= ~HUD_ACTIVE;
|
||||
return 1;
|
||||
}
|
||||
|
@ -155,5 +157,3 @@ int CHudAmmoSecondary :: MsgFunc_SecAmmoVal( const char *pszName, int iSize, voi
|
|||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -28,9 +28,9 @@
|
|||
|
||||
HistoryResource gHR;
|
||||
|
||||
#define AMMO_PICKUP_GAP (gHR.iHistoryGap+5)
|
||||
#define AMMO_PICKUP_PICK_HEIGHT (32 + (gHR.iHistoryGap * 2))
|
||||
#define AMMO_PICKUP_HEIGHT_MAX (ScreenHeight - 100)
|
||||
#define AMMO_PICKUP_GAP ( gHR.iHistoryGap + 5 )
|
||||
#define AMMO_PICKUP_PICK_HEIGHT ( 32 + ( gHR.iHistoryGap * 2 ) )
|
||||
#define AMMO_PICKUP_HEIGHT_MAX ( ScreenHeight - 100 )
|
||||
|
||||
#define MAX_ITEM_NAME 32
|
||||
int HISTORY_DRAW_TIME = 5;
|
||||
|
@ -43,13 +43,14 @@ struct ITEM_INFO
|
|||
wrect_t rect;
|
||||
};
|
||||
|
||||
void HistoryResource :: AddToHistory( int iType, int iId, int iCount )
|
||||
void HistoryResource::AddToHistory( int iType, int iId, int iCount )
|
||||
{
|
||||
if ( iType == HISTSLOT_AMMO && !iCount )
|
||||
if( iType == HISTSLOT_AMMO && !iCount )
|
||||
return; // no amount, so don't add
|
||||
|
||||
if ( (((AMMO_PICKUP_GAP * iCurrentHistorySlot) + AMMO_PICKUP_PICK_HEIGHT) > AMMO_PICKUP_HEIGHT_MAX) || (iCurrentHistorySlot >= MAX_HISTORY) )
|
||||
{ // the pic would have to be drawn too high
|
||||
if( ( ( ( AMMO_PICKUP_GAP * iCurrentHistorySlot ) + AMMO_PICKUP_PICK_HEIGHT ) > AMMO_PICKUP_HEIGHT_MAX ) || ( iCurrentHistorySlot >= MAX_HISTORY ) )
|
||||
{
|
||||
// the pic would have to be drawn too high
|
||||
// so start from the bottom
|
||||
iCurrentHistorySlot = 0;
|
||||
}
|
||||
|
@ -63,13 +64,14 @@ void HistoryResource :: AddToHistory( int iType, int iId, int iCount )
|
|||
freeslot->DisplayTime = gHUD.m_flTime + HISTORY_DRAW_TIME;
|
||||
}
|
||||
|
||||
void HistoryResource :: AddToHistory( int iType, const char *szName, int iCount )
|
||||
void HistoryResource::AddToHistory( int iType, const char *szName, int iCount )
|
||||
{
|
||||
if ( iType != HISTSLOT_ITEM )
|
||||
if( iType != HISTSLOT_ITEM )
|
||||
return;
|
||||
|
||||
if ( (((AMMO_PICKUP_GAP * iCurrentHistorySlot) + AMMO_PICKUP_PICK_HEIGHT) > AMMO_PICKUP_HEIGHT_MAX) || (iCurrentHistorySlot >= MAX_HISTORY) )
|
||||
{ // the pic would have to be drawn too high
|
||||
if( ( ( ( AMMO_PICKUP_GAP * iCurrentHistorySlot ) + AMMO_PICKUP_PICK_HEIGHT ) > AMMO_PICKUP_HEIGHT_MAX ) || ( iCurrentHistorySlot >= MAX_HISTORY ) )
|
||||
{
|
||||
// the pic would have to be drawn too high
|
||||
// so start from the bottom
|
||||
iCurrentHistorySlot = 0;
|
||||
}
|
||||
|
@ -77,9 +79,8 @@ void HistoryResource :: AddToHistory( int iType, const char *szName, int iCount
|
|||
HIST_ITEM *freeslot = &rgAmmoHistory[iCurrentHistorySlot++]; // default to just writing to the first slot
|
||||
|
||||
// I am really unhappy with all the code in this file
|
||||
|
||||
int i = gHUD.GetSpriteIndex( szName );
|
||||
if ( i == -1 )
|
||||
if( i == -1 )
|
||||
return; // unknown sprite name, don't add it to history
|
||||
|
||||
freeslot->iId = i;
|
||||
|
@ -90,12 +91,11 @@ void HistoryResource :: AddToHistory( int iType, const char *szName, int iCount
|
|||
freeslot->DisplayTime = gHUD.m_flTime + HISTORY_DRAW_TIME;
|
||||
}
|
||||
|
||||
|
||||
void HistoryResource :: CheckClearHistory( void )
|
||||
void HistoryResource::CheckClearHistory( void )
|
||||
{
|
||||
for ( int i = 0; i < MAX_HISTORY; i++ )
|
||||
for( int i = 0; i < MAX_HISTORY; i++ )
|
||||
{
|
||||
if ( rgAmmoHistory[i].type )
|
||||
if( rgAmmoHistory[i].type )
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -105,79 +105,81 @@ void HistoryResource :: CheckClearHistory( void )
|
|||
//
|
||||
// Draw Ammo pickup history
|
||||
//
|
||||
int HistoryResource :: DrawAmmoHistory( float flTime )
|
||||
int HistoryResource::DrawAmmoHistory( float flTime )
|
||||
{
|
||||
for ( int i = 0; i < MAX_HISTORY; i++ )
|
||||
for( int i = 0; i < MAX_HISTORY; i++ )
|
||||
{
|
||||
if ( rgAmmoHistory[i].type )
|
||||
if( rgAmmoHistory[i].type )
|
||||
{
|
||||
rgAmmoHistory[i].DisplayTime = min( rgAmmoHistory[i].DisplayTime, gHUD.m_flTime + HISTORY_DRAW_TIME );
|
||||
|
||||
if ( rgAmmoHistory[i].DisplayTime <= flTime )
|
||||
{ // pic drawing time has expired
|
||||
if( rgAmmoHistory[i].DisplayTime <= flTime )
|
||||
{
|
||||
// pic drawing time has expired
|
||||
memset( &rgAmmoHistory[i], 0, sizeof(HIST_ITEM) );
|
||||
CheckClearHistory();
|
||||
}
|
||||
else if ( rgAmmoHistory[i].type == HISTSLOT_AMMO )
|
||||
else if( rgAmmoHistory[i].type == HISTSLOT_AMMO )
|
||||
{
|
||||
wrect_t rcPic;
|
||||
HSPRITE *spr = gWR.GetAmmoPicFromWeapon( rgAmmoHistory[i].iId, rcPic );
|
||||
|
||||
int r, g, b;
|
||||
UnpackRGB(r,g,b, RGB_YELLOWISH);
|
||||
float scale = (rgAmmoHistory[i].DisplayTime - flTime) * 80;
|
||||
ScaleColors(r, g, b, min(scale, 255) );
|
||||
UnpackRGB( r, g, b, RGB_YELLOWISH );
|
||||
float scale = ( rgAmmoHistory[i].DisplayTime - flTime ) * 80;
|
||||
ScaleColors( r, g, b, min( scale, 255 ) );
|
||||
|
||||
// Draw the pic
|
||||
int ypos = ScreenHeight - (AMMO_PICKUP_PICK_HEIGHT + (AMMO_PICKUP_GAP * i));
|
||||
int xpos = ScreenWidth - 24;
|
||||
if ( spr && *spr ) // weapon isn't loaded yet so just don't draw the pic
|
||||
{ // the dll has to make sure it has sent info the weapons you need
|
||||
if( spr && *spr ) // weapon isn't loaded yet so just don't draw the pic
|
||||
{
|
||||
// the dll has to make sure it has sent info the weapons you need
|
||||
SPR_Set( *spr, r, g, b );
|
||||
SPR_DrawAdditive( 0, xpos, ypos, &rcPic );
|
||||
}
|
||||
|
||||
// do not draw black console string
|
||||
if( !(( hud_textmode->value == 2 ) && ( scale < 200 )) )
|
||||
if( !( ( hud_textmode->value == 2 ) && ( scale < 200 ) ) )
|
||||
// Draw the number
|
||||
gHUD.DrawHudNumberString( xpos - 10, ypos, xpos - 100, rgAmmoHistory[i].iCount, r, g, b );
|
||||
}
|
||||
else if ( rgAmmoHistory[i].type == HISTSLOT_WEAP )
|
||||
else if( rgAmmoHistory[i].type == HISTSLOT_WEAP )
|
||||
{
|
||||
WEAPON *weap = gWR.GetWeapon( rgAmmoHistory[i].iId );
|
||||
|
||||
if ( !weap )
|
||||
if( !weap )
|
||||
return 1; // we don't know about the weapon yet, so don't draw anything
|
||||
|
||||
int r, g, b;
|
||||
UnpackRGB(r,g,b, RGB_YELLOWISH);
|
||||
UnpackRGB( r,g,b, RGB_YELLOWISH );
|
||||
|
||||
if ( !gWR.HasAmmo( weap ) )
|
||||
UnpackRGB(r,g,b, RGB_REDISH); // if the weapon doesn't have ammo, display it as red
|
||||
if( !gWR.HasAmmo( weap ) )
|
||||
UnpackRGB( r, g, b, RGB_REDISH ); // if the weapon doesn't have ammo, display it as red
|
||||
|
||||
float scale = (rgAmmoHistory[i].DisplayTime - flTime) * 80;
|
||||
ScaleColors(r, g, b, min(scale, 255) );
|
||||
float scale = ( rgAmmoHistory[i].DisplayTime - flTime ) * 80;
|
||||
ScaleColors( r, g, b, min( scale, 255 ) );
|
||||
|
||||
int ypos = ScreenHeight - (AMMO_PICKUP_PICK_HEIGHT + (AMMO_PICKUP_GAP * i));
|
||||
int xpos = ScreenWidth - (weap->rcInactive.right - weap->rcInactive.left);
|
||||
int ypos = ScreenHeight - ( AMMO_PICKUP_PICK_HEIGHT + ( AMMO_PICKUP_GAP * i ) );
|
||||
int xpos = ScreenWidth - ( weap->rcInactive.right - weap->rcInactive.left );
|
||||
SPR_Set( weap->hInactive, r, g, b );
|
||||
SPR_DrawAdditive( 0, xpos, ypos, &weap->rcInactive );
|
||||
}
|
||||
else if ( rgAmmoHistory[i].type == HISTSLOT_ITEM )
|
||||
else if( rgAmmoHistory[i].type == HISTSLOT_ITEM )
|
||||
{
|
||||
int r, g, b;
|
||||
|
||||
if ( !rgAmmoHistory[i].iId )
|
||||
if( !rgAmmoHistory[i].iId )
|
||||
continue; // sprite not loaded
|
||||
|
||||
wrect_t rect = gHUD.GetSpriteRect( rgAmmoHistory[i].iId );
|
||||
|
||||
UnpackRGB(r,g,b, RGB_YELLOWISH);
|
||||
float scale = (rgAmmoHistory[i].DisplayTime - flTime) * 80;
|
||||
ScaleColors(r, g, b, min(scale, 255) );
|
||||
UnpackRGB( r, g, b, RGB_YELLOWISH );
|
||||
float scale = ( rgAmmoHistory[i].DisplayTime - flTime ) * 80;
|
||||
ScaleColors( r, g, b, min( scale, 255 ) );
|
||||
|
||||
int ypos = ScreenHeight - (AMMO_PICKUP_PICK_HEIGHT + (AMMO_PICKUP_GAP * i));
|
||||
int xpos = ScreenWidth - (rect.right - rect.left) - 10;
|
||||
int ypos = ScreenHeight - ( AMMO_PICKUP_PICK_HEIGHT + ( AMMO_PICKUP_GAP * i ) );
|
||||
int xpos = ScreenWidth - ( rect.right - rect.left ) - 10;
|
||||
|
||||
SPR_Set( gHUD.GetSprite( rgAmmoHistory[i].iId ), r, g, b );
|
||||
SPR_DrawAdditive( 0, xpos, ypos, &rect );
|
||||
|
@ -185,8 +187,5 @@ int HistoryResource :: DrawAmmoHistory( float flTime )
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -26,8 +26,8 @@ private:
|
|||
WEAPON rgWeapons[MAX_WEAPONS]; // Weapons Array
|
||||
|
||||
// counts of weapons * ammo
|
||||
WEAPON* rgSlots[MAX_WEAPON_SLOTS+1][MAX_WEAPON_POSITIONS+1]; // The slots currently in use by weapons. The value is a pointer to the weapon; if it's NULL, no weapon is there
|
||||
int riAmmo[MAX_AMMO_TYPES]; // count of each ammo type
|
||||
WEAPON* rgSlots[MAX_WEAPON_SLOTS + 1][MAX_WEAPON_POSITIONS + 1]; // The slots currently in use by weapons. The value is a pointer to the weapon; if it's NULL, no weapon is there
|
||||
int riAmmo[MAX_AMMO_TYPES]; // count of each ammo type
|
||||
|
||||
public:
|
||||
void Init( void )
|
||||
|
@ -49,25 +49,25 @@ public:
|
|||
WEAPON *GetWeapon( int iId ) { return &rgWeapons[iId]; }
|
||||
void AddWeapon( WEAPON *wp )
|
||||
{
|
||||
rgWeapons[ wp->iId ] = *wp;
|
||||
LoadWeaponSprites( &rgWeapons[ wp->iId ] );
|
||||
rgWeapons[wp->iId] = *wp;
|
||||
LoadWeaponSprites( &rgWeapons[wp->iId] );
|
||||
}
|
||||
|
||||
void PickupWeapon( WEAPON *wp )
|
||||
{
|
||||
rgSlots[ wp->iSlot ][ wp->iSlotPos ] = wp;
|
||||
rgSlots[wp->iSlot][wp->iSlotPos] = wp;
|
||||
}
|
||||
|
||||
void DropWeapon( WEAPON *wp )
|
||||
{
|
||||
rgSlots[ wp->iSlot ][ wp->iSlotPos ] = NULL;
|
||||
rgSlots[wp->iSlot][wp->iSlotPos] = NULL;
|
||||
}
|
||||
|
||||
void DropAllWeapons( void )
|
||||
{
|
||||
for ( int i = 0; i < MAX_WEAPONS; i++ )
|
||||
for( int i = 0; i < MAX_WEAPONS; i++ )
|
||||
{
|
||||
if ( rgWeapons[i].iId )
|
||||
if( rgWeapons[i].iId )
|
||||
DropWeapon( &rgWeapons[i] );
|
||||
}
|
||||
}
|
||||
|
@ -94,13 +94,12 @@ public:
|
|||
|
||||
extern WeaponsResource gWR;
|
||||
|
||||
|
||||
#define MAX_HISTORY 12
|
||||
enum {
|
||||
HISTSLOT_EMPTY,
|
||||
HISTSLOT_AMMO,
|
||||
HISTSLOT_WEAP,
|
||||
HISTSLOT_ITEM,
|
||||
HISTSLOT_ITEM
|
||||
};
|
||||
|
||||
class HistoryResource
|
||||
|
@ -138,6 +137,3 @@ public:
|
|||
};
|
||||
|
||||
extern HistoryResource gHR;
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -25,23 +25,22 @@
|
|||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
DECLARE_MESSAGE(m_Battery, Battery)
|
||||
DECLARE_MESSAGE( m_Battery, Battery )
|
||||
|
||||
int CHudBattery::Init(void)
|
||||
int CHudBattery::Init( void )
|
||||
{
|
||||
m_iBat = 0;
|
||||
m_fFade = 0;
|
||||
m_iFlags = 0;
|
||||
|
||||
HOOK_MESSAGE(Battery);
|
||||
HOOK_MESSAGE( Battery );
|
||||
|
||||
gHUD.AddHudElem(this);
|
||||
gHUD.AddHudElem( this );
|
||||
|
||||
return 1;
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
int CHudBattery::VidInit(void)
|
||||
int CHudBattery::VidInit( void )
|
||||
{
|
||||
int HUD_suit_empty = gHUD.GetSpriteIndex( "suit_empty" );
|
||||
int HUD_suit_full = gHUD.GetSpriteIndex( "suit_full" );
|
||||
|
@ -52,17 +51,16 @@ int CHudBattery::VidInit(void)
|
|||
m_iHeight = m_prc2->bottom - m_prc1->top;
|
||||
m_fFade = 0;
|
||||
return 1;
|
||||
};
|
||||
}
|
||||
|
||||
int CHudBattery:: MsgFunc_Battery(const char *pszName, int iSize, void *pbuf )
|
||||
int CHudBattery::MsgFunc_Battery( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
|
||||
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
int x = READ_SHORT();
|
||||
|
||||
if (x != m_iBat)
|
||||
if( x != m_iBat )
|
||||
{
|
||||
m_fFade = FADE_TIME;
|
||||
m_iBat = x;
|
||||
|
@ -71,68 +69,65 @@ int CHudBattery:: MsgFunc_Battery(const char *pszName, int iSize, void *pbuf )
|
|||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int CHudBattery::Draw(float flTime)
|
||||
int CHudBattery::Draw( float flTime )
|
||||
{
|
||||
if ( gHUD.m_iHideHUDDisplay & HIDEHUD_HEALTH )
|
||||
if( gHUD.m_iHideHUDDisplay & HIDEHUD_HEALTH )
|
||||
return 1;
|
||||
|
||||
int r, g, b, x, y, a;
|
||||
wrect_t rc;
|
||||
|
||||
rc = *m_prc2;
|
||||
rc.top += m_iHeight * ((float)(100-(min(100,m_iBat))) * 0.01); // battery can go from 0 to 100 so * 0.01 goes from 0 to 1
|
||||
rc.top += m_iHeight * ( (float)( 100 - ( min( 100,m_iBat ) ) ) * 0.01 ); // battery can go from 0 to 100 so * 0.01 goes from 0 to 1
|
||||
|
||||
UnpackRGB(r,g,b, RGB_YELLOWISH);
|
||||
UnpackRGB( r, g, b, RGB_YELLOWISH );
|
||||
|
||||
if (!(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT)) ))
|
||||
if( !( gHUD.m_iWeaponBits & ( 1 << ( WEAPON_SUIT ) ) ) )
|
||||
return 1;
|
||||
|
||||
// Has health changed? Flash the health #
|
||||
if (m_fFade)
|
||||
if( m_fFade )
|
||||
{
|
||||
if (m_fFade > FADE_TIME)
|
||||
if( m_fFade > FADE_TIME )
|
||||
m_fFade = FADE_TIME;
|
||||
|
||||
m_fFade -= (gHUD.m_flTimeDelta * 20);
|
||||
if (m_fFade <= 0)
|
||||
m_fFade -= ( gHUD.m_flTimeDelta * 20 );
|
||||
if( m_fFade <= 0 )
|
||||
{
|
||||
a = 128;
|
||||
m_fFade = 0;
|
||||
}
|
||||
|
||||
// Fade the health number back to dim
|
||||
|
||||
a = MIN_ALPHA + (m_fFade/FADE_TIME) * 128;
|
||||
|
||||
a = MIN_ALPHA + ( m_fFade / FADE_TIME ) * 128;
|
||||
}
|
||||
else
|
||||
a = MIN_ALPHA;
|
||||
|
||||
ScaleColors(r, g, b, a );
|
||||
|
||||
int iOffset = (m_prc1->bottom - m_prc1->top)/6;
|
||||
ScaleColors( r, g, b, a );
|
||||
|
||||
int iOffset = ( m_prc1->bottom - m_prc1->top ) / 6;
|
||||
|
||||
y = ScreenHeight - gHUD.m_iFontHeight - gHUD.m_iFontHeight / 2;
|
||||
x = ScreenWidth/5;
|
||||
x = ScreenWidth / 5;
|
||||
|
||||
// make sure we have the right sprite handles
|
||||
if ( !m_hSprite1 )
|
||||
if( !m_hSprite1 )
|
||||
m_hSprite1 = gHUD.GetSprite( gHUD.GetSpriteIndex( "suit_empty" ) );
|
||||
if ( !m_hSprite2 )
|
||||
if( !m_hSprite2 )
|
||||
m_hSprite2 = gHUD.GetSprite( gHUD.GetSpriteIndex( "suit_full" ) );
|
||||
|
||||
SPR_Set(m_hSprite1, r, g, b );
|
||||
SPR_DrawAdditive( 0, x, y - iOffset, m_prc1);
|
||||
SPR_Set( m_hSprite1, r, g, b );
|
||||
SPR_DrawAdditive( 0, x, y - iOffset, m_prc1 );
|
||||
|
||||
if (rc.bottom > rc.top)
|
||||
if( rc.bottom > rc.top )
|
||||
{
|
||||
SPR_Set(m_hSprite2, r, g, b );
|
||||
SPR_DrawAdditive( 0, x, y - iOffset + (rc.top - m_prc2->top), &rc);
|
||||
SPR_Set( m_hSprite2, r, g, b );
|
||||
SPR_DrawAdditive( 0, x, y - iOffset + ( rc.top - m_prc2->top ), &rc );
|
||||
}
|
||||
|
||||
x += (m_prc1->right - m_prc1->left);
|
||||
x = gHUD.DrawHudNumber(x, y, DHN_3DIGITS | DHN_DRAWZERO, m_iBat, r, g, b);
|
||||
x += ( m_prc1->right - m_prc1->left );
|
||||
x = gHUD.DrawHudNumber( x, y, DHN_3DIGITS | DHN_DRAWZERO, m_iBat, r, g, b );
|
||||
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -18,7 +18,6 @@ extern int cam_thirdperson;
|
|||
|
||||
void CAM_Init( void );
|
||||
void CAM_ClearStates( void );
|
||||
void CAM_StartMouseMove(void);
|
||||
void CAM_EndMouseMove(void);
|
||||
|
||||
#endif // _CAMERA_H_
|
||||
void CAM_StartMouseMove( void );
|
||||
void CAM_EndMouseMove( void );
|
||||
#endif // _CAMERA_H_
|
||||
|
|
|
@ -32,7 +32,7 @@ extern "C"
|
|||
cl_enginefunc_t gEngfuncs;
|
||||
CHud gHUD;
|
||||
mobile_engfuncs_t *gMobileEngfuncs = NULL;
|
||||
void InitInput (void);
|
||||
void InitInput( void );
|
||||
void EV_HookEvents( void );
|
||||
void IN_Commands( void );
|
||||
|
||||
|
@ -73,16 +73,16 @@ int DLLEXPORT HUD_GetHullBounds( int hullnumber, float *mins, float *maxs )
|
|||
{
|
||||
int iret = 0;
|
||||
|
||||
switch ( hullnumber )
|
||||
switch( hullnumber )
|
||||
{
|
||||
case 0: // Normal player
|
||||
mins = Vector(-16, -16, -36);
|
||||
maxs = Vector(16, 16, 36);
|
||||
mins = Vector( -16, -16, -36 );
|
||||
maxs = Vector( 16, 16, 36 );
|
||||
iret = 1;
|
||||
break;
|
||||
case 1: // Crouched player
|
||||
mins = Vector(-16, -16, -18 );
|
||||
maxs = Vector(16, 16, 18 );
|
||||
mins = Vector( -16, -16, -18 );
|
||||
maxs = Vector( 16, 16, 18 );
|
||||
iret = 1;
|
||||
break;
|
||||
case 2: // Point based hull
|
||||
|
@ -103,7 +103,7 @@ HUD_ConnectionlessPacket
|
|||
size of the response_buffer, so you must zero it out if you choose not to respond.
|
||||
================================
|
||||
*/
|
||||
int DLLEXPORT HUD_ConnectionlessPacket( const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size )
|
||||
int DLLEXPORT HUD_ConnectionlessPacket( const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size )
|
||||
{
|
||||
// Parse stuff from args
|
||||
int max_buffer_size = *response_buffer_size;
|
||||
|
@ -136,10 +136,10 @@ int DLLEXPORT Initialize( cl_enginefunc_t *pEnginefuncs, int iVersion )
|
|||
{
|
||||
gEngfuncs = *pEnginefuncs;
|
||||
|
||||
if (iVersion != CLDLL_INTERFACE_VERSION)
|
||||
if( iVersion != CLDLL_INTERFACE_VERSION )
|
||||
return 0;
|
||||
|
||||
memcpy(&gEngfuncs, pEnginefuncs, sizeof(cl_enginefunc_t));
|
||||
memcpy( &gEngfuncs, pEnginefuncs, sizeof(cl_enginefunc_t) );
|
||||
|
||||
EV_HookEvents();
|
||||
|
||||
|
@ -198,7 +198,6 @@ void DLLEXPORT HUD_Init( void )
|
|||
gHUD.Init();
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
==========================
|
||||
HUD_Redraw
|
||||
|
@ -215,7 +214,6 @@ int DLLEXPORT HUD_Redraw( float time, int intermission )
|
|||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
==========================
|
||||
HUD_UpdateClientData
|
||||
|
@ -229,11 +227,11 @@ returns 1 if anything has been changed, 0 otherwise.
|
|||
==========================
|
||||
*/
|
||||
|
||||
int DLLEXPORT HUD_UpdateClientData(client_data_t *pcldata, float flTime )
|
||||
int DLLEXPORT HUD_UpdateClientData( client_data_t *pcldata, float flTime )
|
||||
{
|
||||
IN_Commands();
|
||||
|
||||
return gHUD.UpdateClientData(pcldata, flTime );
|
||||
return gHUD.UpdateClientData( pcldata, flTime );
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -258,11 +256,9 @@ Called by engine every frame that client .dll is loaded
|
|||
*/
|
||||
|
||||
void DLLEXPORT HUD_Frame( double time )
|
||||
{
|
||||
gEngfuncs.VGui_ViewportPaintBackground(HUD_GetRect());
|
||||
{ gEngfuncs.VGui_ViewportPaintBackground(HUD_GetRect());
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
==========================
|
||||
HUD_VoiceStatus
|
||||
|
@ -271,7 +267,7 @@ Called when a player starts or stops talking.
|
|||
==========================
|
||||
*/
|
||||
|
||||
void DLLEXPORT HUD_VoiceStatus(int entindex, qboolean bTalking)
|
||||
void DLLEXPORT HUD_VoiceStatus( int entindex, qboolean bTalking )
|
||||
{
|
||||
|
||||
}
|
||||
|
@ -291,7 +287,7 @@ void DLLEXPORT HUD_DirectorMessage( int iSize, void *pbuf )
|
|||
|
||||
void DLLEXPORT HUD_MobilityInterface( mobile_engfuncs_t *gpMobileEngfuncs )
|
||||
{
|
||||
if( gpMobileEngfuncs->version != MOBILITY_API_VERSION )
|
||||
return;
|
||||
gMobileEngfuncs = gpMobileEngfuncs;
|
||||
if( gpMobileEngfuncs->version != MOBILITY_API_VERSION )
|
||||
return;
|
||||
gMobileEngfuncs = gpMobileEngfuncs;
|
||||
}
|
||||
|
|
|
@ -28,7 +28,7 @@
|
|||
typedef unsigned char byte;
|
||||
typedef unsigned short word;
|
||||
typedef float vec_t;
|
||||
typedef int (*pfnUserMsgHook)(const char *pszName, int iSize, void *pbuf);
|
||||
typedef int ( *pfnUserMsgHook )( const char *pszName, int iSize, void *pbuf );
|
||||
|
||||
#include "util_vector.h"
|
||||
|
||||
|
|
105
cl_dll/cl_util.h
105
cl_dll/cl_util.h
|
@ -15,6 +15,7 @@
|
|||
//
|
||||
// cl_util.h
|
||||
//
|
||||
|
||||
#include "exportdef.h"
|
||||
#include "cvardef.h"
|
||||
|
||||
|
@ -25,72 +26,70 @@
|
|||
|
||||
// Macros to hook function calls into the HUD object
|
||||
|
||||
#define HOOK_MESSAGE(x) gEngfuncs.pfnHookUserMsg(#x, __MsgFunc_##x );
|
||||
|
||||
#define DECLARE_MESSAGE(y, x) int __MsgFunc_##x(const char *pszName, int iSize, void *pbuf) \
|
||||
{ \
|
||||
return gHUD.y.MsgFunc_##x(pszName, iSize, pbuf ); \
|
||||
}
|
||||
#define HOOK_MESSAGE(x) gEngfuncs.pfnHookUserMsg( #x, __MsgFunc_##x );
|
||||
|
||||
#define DECLARE_MESSAGE(y, x) int __MsgFunc_##x( const char *pszName, int iSize, void *pbuf ) \
|
||||
{ \
|
||||
return gHUD.y.MsgFunc_##x(pszName, iSize, pbuf ); \
|
||||
}
|
||||
|
||||
#define HOOK_COMMAND(x, y) gEngfuncs.pfnAddCommand( x, __CmdFunc_##y );
|
||||
#define DECLARE_COMMAND(y, x) void __CmdFunc_##x( void ) \
|
||||
{ \
|
||||
gHUD.y.UserCmd_##x( ); \
|
||||
}
|
||||
|
||||
{ \
|
||||
gHUD.y.UserCmd_##x( ); \
|
||||
}
|
||||
|
||||
inline float CVAR_GET_FLOAT( const char *x ) { return gEngfuncs.pfnGetCvarFloat( (char*)x ); }
|
||||
inline char* CVAR_GET_STRING( const char *x ) { return gEngfuncs.pfnGetCvarString( (char*)x ); }
|
||||
inline struct cvar_s *CVAR_CREATE( const char *cv, const char *val, const int flags ) { return gEngfuncs.pfnRegisterVariable( (char*)cv, (char*)val, flags ); }
|
||||
|
||||
#define SPR_Load (*gEngfuncs.pfnSPR_Load)
|
||||
#define SPR_Set (*gEngfuncs.pfnSPR_Set)
|
||||
#define SPR_Frames (*gEngfuncs.pfnSPR_Frames)
|
||||
#define SPR_GetList (*gEngfuncs.pfnSPR_GetList)
|
||||
#define SPR_Load ( *gEngfuncs.pfnSPR_Load )
|
||||
#define SPR_Set ( *gEngfuncs.pfnSPR_Set )
|
||||
#define SPR_Frames ( *gEngfuncs.pfnSPR_Frames )
|
||||
#define SPR_GetList ( *gEngfuncs.pfnSPR_GetList )
|
||||
|
||||
// SPR_Draw draws a the current sprite as solid
|
||||
#define SPR_Draw (*gEngfuncs.pfnSPR_Draw)
|
||||
// SPR_DrawHoles draws the current sprites, with color index255 not drawn (transparent)
|
||||
#define SPR_DrawHoles (*gEngfuncs.pfnSPR_DrawHoles)
|
||||
#define SPR_Draw ( *gEngfuncs.pfnSPR_Draw )
|
||||
// SPR_DrawHoles draws the current sprites, with color index255 not drawn (transparent)
|
||||
#define SPR_DrawHoles ( *gEngfuncs.pfnSPR_DrawHoles )
|
||||
// SPR_DrawAdditive adds the sprites RGB values to the background (additive transulency)
|
||||
#define SPR_DrawAdditive (*gEngfuncs.pfnSPR_DrawAdditive)
|
||||
#define SPR_DrawAdditive ( *gEngfuncs.pfnSPR_DrawAdditive )
|
||||
|
||||
// SPR_EnableScissor sets a clipping rect for HUD sprites. (0,0) is the top-left hand corner of the screen.
|
||||
#define SPR_EnableScissor (*gEngfuncs.pfnSPR_EnableScissor)
|
||||
// SPR_EnableScissor sets a clipping rect for HUD sprites. (0,0) is the top-left hand corner of the screen.
|
||||
#define SPR_EnableScissor ( *gEngfuncs.pfnSPR_EnableScissor )
|
||||
// SPR_DisableScissor disables the clipping rect
|
||||
#define SPR_DisableScissor (*gEngfuncs.pfnSPR_DisableScissor)
|
||||
#define SPR_DisableScissor ( *gEngfuncs.pfnSPR_DisableScissor )
|
||||
//
|
||||
#define FillRGBA (*gEngfuncs.pfnFillRGBA)
|
||||
|
||||
#define FillRGBA ( *gEngfuncs.pfnFillRGBA )
|
||||
|
||||
// ScreenHeight returns the height of the screen, in pixels
|
||||
#define ScreenHeight (gHUD.m_scrinfo.iHeight)
|
||||
#define ScreenHeight ( gHUD.m_scrinfo.iHeight )
|
||||
// ScreenWidth returns the width of the screen, in pixels
|
||||
#define ScreenWidth (gHUD.m_scrinfo.iWidth)
|
||||
#define ScreenWidth ( gHUD.m_scrinfo.iWidth )
|
||||
|
||||
// Use this to set any co-ords in 640x480 space
|
||||
#define XRES(x) ((int)(float(x) * ((float)ScreenWidth / 640.0f) + 0.5f))
|
||||
#define YRES(y) ((int)(float(y) * ((float)ScreenHeight / 480.0f) + 0.5f))
|
||||
#define XRES(x) ( (int)( float(x) * ( (float)ScreenWidth / 640.0f ) + 0.5f ) )
|
||||
#define YRES(y) ( (int)( float(y) * ( (float)ScreenHeight / 480.0f ) + 0.5f ) )
|
||||
|
||||
// use this to project world coordinates to screen coordinates
|
||||
#define XPROJECT(x) ( (1.0f+(x))*ScreenWidth*0.5f )
|
||||
#define YPROJECT(y) ( (1.0f-(y))*ScreenHeight*0.5f )
|
||||
#define XPROJECT(x) ( ( 1.0f + (x) ) * ScreenWidth * 0.5f )
|
||||
#define YPROJECT(y) ( ( 1.0f - (y) ) * ScreenHeight * 0.5f )
|
||||
|
||||
#define GetScreenInfo (*gEngfuncs.pfnGetScreenInfo)
|
||||
#define ServerCmd (*gEngfuncs.pfnServerCmd)
|
||||
#define ClientCmd (*gEngfuncs.pfnClientCmd)
|
||||
#define SetCrosshair (*gEngfuncs.pfnSetCrosshair)
|
||||
#define AngleVectors (*gEngfuncs.pfnAngleVectors)
|
||||
#define GetScreenInfo ( *gEngfuncs.pfnGetScreenInfo )
|
||||
#define ServerCmd ( *gEngfuncs.pfnServerCmd )
|
||||
#define ClientCmd ( *gEngfuncs.pfnClientCmd )
|
||||
#define SetCrosshair ( *gEngfuncs.pfnSetCrosshair )
|
||||
#define AngleVectors ( *gEngfuncs.pfnAngleVectors )
|
||||
extern cvar_t *hud_textmode;
|
||||
extern float g_hud_text_color[3];
|
||||
inline void DrawSetTextColor(float r, float g, float b)
|
||||
inline void DrawSetTextColor( float r, float g, float b )
|
||||
{
|
||||
if( hud_textmode->value == 1 )
|
||||
g_hud_text_color[0]=r, g_hud_text_color[1] = g, g_hud_text_color[2] = b;
|
||||
g_hud_text_color[0] = r, g_hud_text_color[1] = g, g_hud_text_color[2] = b;
|
||||
else
|
||||
gEngfuncs.pfnDrawSetTextColor( r, g, b );
|
||||
}
|
||||
|
||||
// Gets the height & width of a sprite, at the specified frame
|
||||
inline int SPR_Height( HSPRITE x, int f ) { return gEngfuncs.pfnSPR_Height(x, f); }
|
||||
inline int SPR_Width( HSPRITE x, int f ) { return gEngfuncs.pfnSPR_Width(x, f); }
|
||||
|
@ -104,7 +103,7 @@ inline int TextMessageDrawChar( int x, int y, int number, int r, int g, in
|
|||
inline int DrawConsoleString( int x, int y, const char *string )
|
||||
{
|
||||
if( hud_textmode->value == 1 )
|
||||
return gHUD.DrawHudString( x, y, 9999, (char*)string, 255*g_hud_text_color[0], 255*g_hud_text_color[1], 255*g_hud_text_color[2]);
|
||||
return gHUD.DrawHudString( x, y, 9999, (char*)string, 255 * g_hud_text_color[0], 255 * g_hud_text_color[1], 255 * g_hud_text_color[2] );
|
||||
return gEngfuncs.pfnDrawConsoleString( x, y, (char*) string );
|
||||
}
|
||||
|
||||
|
@ -120,7 +119,7 @@ inline int ConsoleStringLen( const char *string )
|
|||
{
|
||||
int _width = 0, _height = 0;
|
||||
if( hud_textmode->value == 1 )
|
||||
return gHUD.DrawHudStringLen((char*)string);
|
||||
return gHUD.DrawHudStringLen( (char*)string );
|
||||
GetConsoleStringSize( string, &_width, &_height );
|
||||
return _width;
|
||||
}
|
||||
|
@ -136,7 +135,7 @@ inline void CenterPrint( const char *string )
|
|||
}
|
||||
|
||||
// returns the players name of entity no.
|
||||
#define GetPlayerInfo (*gEngfuncs.pfnGetPlayerInfo)
|
||||
#define GetPlayerInfo ( *gEngfuncs.pfnGetPlayerInfo )
|
||||
|
||||
// sound functions
|
||||
inline void PlaySound( char *szSound, float vol ) { gEngfuncs.pfnPlaySoundByName( szSound, vol ); }
|
||||
|
@ -148,16 +147,16 @@ inline void PlaySound( int iSound, float vol ) { gEngfuncs.pfnPlaySoundByIndex(
|
|||
|
||||
void ScaleColors( int &r, int &g, int &b, int a );
|
||||
|
||||
#define DotProduct(x,y) ((x)[0]*(y)[0]+(x)[1]*(y)[1]+(x)[2]*(y)[2])
|
||||
#define VectorSubtract(a,b,c) {(c)[0]=(a)[0]-(b)[0];(c)[1]=(a)[1]-(b)[1];(c)[2]=(a)[2]-(b)[2];}
|
||||
#define VectorAdd(a,b,c) {(c)[0]=(a)[0]+(b)[0];(c)[1]=(a)[1]+(b)[1];(c)[2]=(a)[2]+(b)[2];}
|
||||
#define VectorCopy(a,b) {(b)[0]=(a)[0];(b)[1]=(a)[1];(b)[2]=(a)[2];}
|
||||
inline void VectorClear(float *a) { a[0]=0.0;a[1]=0.0;a[2]=0.0;}
|
||||
float Length(const float *v);
|
||||
void VectorMA (const float *veca, float scale, const float *vecb, float *vecc);
|
||||
void VectorScale (const float *in, float scale, float *out);
|
||||
float VectorNormalize (float *v);
|
||||
void VectorInverse ( float *v );
|
||||
#define DotProduct(x, y) ((x)[0] * (y)[0] + (x)[1] * (y)[1] + (x)[2] * (y)[2])
|
||||
#define VectorSubtract(a, b, c) { (c)[0] = (a)[0] - (b)[0]; (c)[1] = (a)[1] - (b)[1]; (c)[2] = (a)[2] - (b)[2]; }
|
||||
#define VectorAdd(a, b, c) { (c)[0] = (a)[0] + (b)[0]; (c)[1] = (a)[1] + (b)[1]; (c)[2] = (a)[2] + (b)[2]; }
|
||||
#define VectorCopy(a, b) { (b)[0] = (a)[0]; (b)[1] = (a)[1]; (b)[2] = (a)[2]; }
|
||||
inline void VectorClear( float *a ) { a[0] = 0.0; a[1] = 0.0; a[2] = 0.0; }
|
||||
float Length( const float *v );
|
||||
void VectorMA( const float *veca, float scale, const float *vecb, float *vecc );
|
||||
void VectorScale( const float *in, float scale, float *out );
|
||||
float VectorNormalize( float *v );
|
||||
void VectorInverse( float *v );
|
||||
|
||||
extern vec3_t vec3_origin;
|
||||
|
||||
|
@ -166,11 +165,11 @@ extern vec3_t vec3_origin;
|
|||
// disable 'truncation from 'const double' to 'float' warning message
|
||||
#pragma warning( disable: 4305 )
|
||||
|
||||
inline void UnpackRGB(int &r, int &g, int &b, unsigned long ulRGB)\
|
||||
inline void UnpackRGB( int &r, int &g, int &b, unsigned long ulRGB )\
|
||||
{\
|
||||
r = (ulRGB & 0xFF0000) >>16;\
|
||||
g = (ulRGB & 0xFF00) >> 8;\
|
||||
r = ( ulRGB & 0xFF0000 ) >> 16;\
|
||||
g = ( ulRGB & 0xFF00 ) >> 8;\
|
||||
b = ulRGB & 0xFF;\
|
||||
}
|
||||
|
||||
HSPRITE LoadSprite(const char *pszName);
|
||||
HSPRITE LoadSprite( const char *pszName );
|
||||
|
|
|
@ -27,7 +27,7 @@
|
|||
// g_runfuncs is true if this is the first time we've "predicated" a particular movement/firing
|
||||
// command. If it is 1, then we should play events/sounds etc., otherwise, we just will be
|
||||
// updating state info, but not firing events
|
||||
int g_runfuncs = 0;
|
||||
int g_runfuncs = 0;
|
||||
|
||||
// During our weapon prediction processing, we'll need to reference some data that is part of
|
||||
// the final state passed into the postthink functionality. We'll set this pointer and then
|
||||
|
@ -41,14 +41,14 @@ COM_Log
|
|||
Log debug messages to file ( appends )
|
||||
====================
|
||||
*/
|
||||
void COM_Log( char *pszFile, char *fmt, ...)
|
||||
void COM_Log( char *pszFile, char *fmt, ... )
|
||||
{
|
||||
va_list argptr;
|
||||
char string[1024];
|
||||
FILE *fp;
|
||||
char *pfilename;
|
||||
|
||||
if ( !pszFile )
|
||||
|
||||
if( !pszFile )
|
||||
{
|
||||
pfilename = "c:\\hllog.txt";
|
||||
}
|
||||
|
@ -57,15 +57,15 @@ void COM_Log( char *pszFile, char *fmt, ...)
|
|||
pfilename = pszFile;
|
||||
}
|
||||
|
||||
va_start (argptr,fmt);
|
||||
vsprintf (string, fmt,argptr);
|
||||
va_end (argptr);
|
||||
va_start( argptr, fmt );
|
||||
vsprintf( string, fmt, argptr );
|
||||
va_end( argptr );
|
||||
|
||||
fp = fopen( pfilename, "a+t");
|
||||
if (fp)
|
||||
if( fp )
|
||||
{
|
||||
fprintf(fp, "%s", string);
|
||||
fclose(fp);
|
||||
fprintf( fp, "%s", string );
|
||||
fclose( fp );
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -83,7 +83,7 @@ Change weapon model animation
|
|||
void HUD_SendWeaponAnim( int iAnim, int body, int force )
|
||||
{
|
||||
// Don't actually change it.
|
||||
if ( !g_runfuncs && !force )
|
||||
if( !g_runfuncs && !force )
|
||||
return;
|
||||
|
||||
g_currentanim = iAnim;
|
||||
|
@ -113,7 +113,7 @@ Play a sound, if we are seeing this command for the first time
|
|||
*/
|
||||
void HUD_PlaySound( char *sound, float volume )
|
||||
{
|
||||
if ( !g_runfuncs || !g_finalstate )
|
||||
if( !g_runfuncs || !g_finalstate )
|
||||
return;
|
||||
|
||||
gEngfuncs.pfnPlaySoundByNameAtLocation( sound, volume, (float *)&g_finalstate->playerstate.origin );
|
||||
|
@ -132,7 +132,7 @@ void HUD_PlaybackEvent( int flags, const edict_t *pInvoker, unsigned short event
|
|||
vec3_t org;
|
||||
vec3_t ang;
|
||||
|
||||
if ( !g_runfuncs || !g_finalstate )
|
||||
if( !g_runfuncs || !g_finalstate )
|
||||
return;
|
||||
|
||||
// Weapon prediction events are assumed to occur at the player's origin
|
||||
|
@ -151,7 +151,6 @@ void HUD_SetMaxSpeed( const edict_t *ed, float speed )
|
|||
{
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
=====================
|
||||
UTIL_WeaponTimeBase
|
||||
|
@ -167,7 +166,7 @@ float UTIL_WeaponTimeBase( void )
|
|||
|
||||
static unsigned int glSeed = 0;
|
||||
|
||||
unsigned int seed_table[ 256 ] =
|
||||
unsigned int seed_table[256] =
|
||||
{
|
||||
28985, 27138, 26457, 9451, 17764, 10909, 28790, 8716, 6361, 4853, 17798, 21977, 19643, 20662, 10834, 20103,
|
||||
27067, 28634, 18623, 25849, 8576, 26234, 23887, 18228, 32587, 4836, 3306, 1811, 3035, 24559, 18399, 315,
|
||||
|
@ -188,16 +187,16 @@ unsigned int seed_table[ 256 ] =
|
|||
};
|
||||
|
||||
unsigned int U_Random( void )
|
||||
{
|
||||
{
|
||||
glSeed *= 69069;
|
||||
glSeed += seed_table[ glSeed & 0xff ];
|
||||
|
||||
return ( ++glSeed & 0x0fffffff );
|
||||
glSeed += seed_table[glSeed & 0xff];
|
||||
|
||||
return ( ++glSeed & 0x0fffffff );
|
||||
}
|
||||
|
||||
void U_Srand( unsigned int seed )
|
||||
{
|
||||
glSeed = seed_table[ seed & 0xff ];
|
||||
glSeed = seed_table[seed & 0xff];
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -212,7 +211,7 @@ int UTIL_SharedRandomLong( unsigned int seed, int low, int high )
|
|||
U_Srand( (int)seed + low + high );
|
||||
|
||||
range = high - low + 1;
|
||||
if ( !(range - 1) )
|
||||
if( !( range - 1 ) )
|
||||
{
|
||||
return low;
|
||||
}
|
||||
|
@ -225,7 +224,7 @@ int UTIL_SharedRandomLong( unsigned int seed, int low, int high )
|
|||
|
||||
offset = rnum % range;
|
||||
|
||||
return (low + offset);
|
||||
return ( low + offset );
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -236,7 +235,6 @@ UTIL_SharedRandomFloat
|
|||
*/
|
||||
float UTIL_SharedRandomFloat( unsigned int seed, float low, float high )
|
||||
{
|
||||
//
|
||||
unsigned int range;
|
||||
|
||||
U_Srand( (int)seed + *(int *)&low + *(int *)&high );
|
||||
|
@ -245,7 +243,7 @@ float UTIL_SharedRandomFloat( unsigned int seed, float low, float high )
|
|||
U_Random();
|
||||
|
||||
range = high - low;
|
||||
if ( !range )
|
||||
if( !range )
|
||||
{
|
||||
return low;
|
||||
}
|
||||
|
@ -258,7 +256,7 @@ float UTIL_SharedRandomFloat( unsigned int seed, float low, float high )
|
|||
|
||||
offset = (float)tensixrand / 65536.0;
|
||||
|
||||
return (low + offset * range );
|
||||
return ( low + offset * range );
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -270,8 +268,26 @@ stub functions for such things as precaching. So we don't have to modify weapon
|
|||
is compiled into both game and client .dlls.
|
||||
======================
|
||||
*/
|
||||
int stub_PrecacheModel ( char* s ) { return 0; }
|
||||
int stub_PrecacheSound ( char* s ) { return 0; }
|
||||
unsigned short stub_PrecacheEvent ( int type, const char *s ) { return 0; }
|
||||
const char *stub_NameForFunction ( unsigned long function ) { return "func"; }
|
||||
void stub_SetModel ( edict_t *e, const char *m ) {}
|
||||
int stub_PrecacheModel( char* s )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int stub_PrecacheSound( char* s )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
unsigned short stub_PrecacheEvent( int type, const char *s )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
const char *stub_NameForFunction( unsigned long function )
|
||||
{
|
||||
return "func";
|
||||
}
|
||||
|
||||
void stub_SetModel( edict_t *e, const char *m )
|
||||
{
|
||||
}
|
||||
|
|
|
@ -20,7 +20,7 @@ extern "C"
|
|||
void _DLLEXPORT HUD_PostRunCmd( struct local_state_s *from, struct local_state_s *to, struct usercmd_s *cmd, int runfuncs, double time, unsigned int random_seed );
|
||||
}
|
||||
|
||||
void COM_Log( char *pszFile, char *fmt, ...);
|
||||
void COM_Log( char *pszFile, char *fmt, ... );
|
||||
int CL_IsDead( void );
|
||||
|
||||
float UTIL_SharedRandomFloat( unsigned int seed, float low, float high );
|
||||
|
@ -34,9 +34,8 @@ void HUD_SetMaxSpeed( const struct edict_s *ed, float speed );
|
|||
int stub_PrecacheModel( char* s );
|
||||
int stub_PrecacheSound( char* s );
|
||||
unsigned short stub_PrecacheEvent( int type, const char *s );
|
||||
const char *stub_NameForFunction ( unsigned long function );
|
||||
void stub_SetModel ( struct edict_s *e, const char *m );
|
||||
|
||||
const char *stub_NameForFunction( unsigned long function );
|
||||
void stub_SetModel( struct edict_s *e, const char *m );
|
||||
|
||||
extern cvar_t *cl_lw;
|
||||
|
||||
|
@ -44,5 +43,4 @@ extern int g_runfuncs;
|
|||
extern vec3_t v_angles;
|
||||
extern float g_lastFOV;
|
||||
extern struct local_state_s *g_finalstate;
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
|
118
cl_dll/death.cpp
118
cl_dll/death.cpp
|
@ -15,6 +15,7 @@
|
|||
//
|
||||
// death notice
|
||||
//
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "parsemsg.h"
|
||||
|
@ -22,11 +23,11 @@
|
|||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
DECLARE_MESSAGE( m_DeathNotice, DeathMsg );
|
||||
DECLARE_MESSAGE( m_DeathNotice, DeathMsg )
|
||||
|
||||
struct DeathNoticeItem {
|
||||
char szKiller[MAX_PLAYER_NAME_LENGTH*2];
|
||||
char szVictim[MAX_PLAYER_NAME_LENGTH*2];
|
||||
char szKiller[MAX_PLAYER_NAME_LENGTH * 2];
|
||||
char szVictim[MAX_PLAYER_NAME_LENGTH * 2];
|
||||
int iId; // the index number of the associated sprite
|
||||
int iSuicide;
|
||||
int iTeamKill;
|
||||
|
@ -41,31 +42,30 @@ static int DEATHNOTICE_DISPLAY_TIME = 6;
|
|||
|
||||
#define DEATHNOTICE_TOP 32
|
||||
|
||||
DeathNoticeItem rgDeathNoticeList[ MAX_DEATHNOTICES + 1 ];
|
||||
DeathNoticeItem rgDeathNoticeList[MAX_DEATHNOTICES + 1];
|
||||
|
||||
float g_ColorBlue[3] = { 0.6, 0.8, 1.0 };
|
||||
float g_ColorRed[3] = { 1.0, 0.25, 0.25 };
|
||||
float g_ColorRed[3] = { 1.0, 0.25, 0.25 };
|
||||
float g_ColorGreen[3] = { 0.6, 1.0, 0.6 };
|
||||
float g_ColorYellow[3] = { 1.0, 0.7, 0.0 };
|
||||
float g_ColorGrey[3] = { 0.8, 0.8, 0.8 };
|
||||
|
||||
float *GetClientColor( int clientIndex )
|
||||
{
|
||||
switch ( g_PlayerExtraInfo[clientIndex].teamnumber )
|
||||
switch( g_PlayerExtraInfo[clientIndex].teamnumber )
|
||||
{
|
||||
case 1: return g_ColorBlue;
|
||||
case 2: return g_ColorRed;
|
||||
case 3: return g_ColorYellow;
|
||||
case 4: return g_ColorGreen;
|
||||
case 0: return g_ColorYellow;
|
||||
|
||||
default : return g_ColorGrey;
|
||||
default: return g_ColorGrey;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int CHudDeathNotice :: Init( void )
|
||||
int CHudDeathNotice::Init( void )
|
||||
{
|
||||
gHUD.AddHudElem( this );
|
||||
|
||||
|
@ -76,33 +76,32 @@ int CHudDeathNotice :: Init( void )
|
|||
return 1;
|
||||
}
|
||||
|
||||
|
||||
void CHudDeathNotice :: InitHUDData( void )
|
||||
void CHudDeathNotice::InitHUDData( void )
|
||||
{
|
||||
memset( rgDeathNoticeList, 0, sizeof(rgDeathNoticeList) );
|
||||
}
|
||||
|
||||
|
||||
int CHudDeathNotice :: VidInit( void )
|
||||
int CHudDeathNotice::VidInit( void )
|
||||
{
|
||||
m_HUD_d_skull = gHUD.GetSpriteIndex( "d_skull" );
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudDeathNotice :: Draw( float flTime )
|
||||
int CHudDeathNotice::Draw( float flTime )
|
||||
{
|
||||
int x, y, r, g, b;
|
||||
|
||||
for ( int i = 0; i < MAX_DEATHNOTICES; i++ )
|
||||
for( int i = 0; i < MAX_DEATHNOTICES; i++ )
|
||||
{
|
||||
if ( rgDeathNoticeList[i].iId == 0 )
|
||||
if( rgDeathNoticeList[i].iId == 0 )
|
||||
break; // we've gone through them all
|
||||
|
||||
if ( rgDeathNoticeList[i].flDisplayTime < flTime )
|
||||
{ // display time has expired
|
||||
if( rgDeathNoticeList[i].flDisplayTime < flTime )
|
||||
{
|
||||
// display time has expired
|
||||
// remove the current item from the list
|
||||
memmove( &rgDeathNoticeList[i], &rgDeathNoticeList[i+1], sizeof(DeathNoticeItem) * (MAX_DEATHNOTICES - i) );
|
||||
memmove( &rgDeathNoticeList[i], &rgDeathNoticeList[i + 1], sizeof(DeathNoticeItem) * ( MAX_DEATHNOTICES - i ) );
|
||||
i--; // continue on the next item; stop the counter getting incremented
|
||||
continue;
|
||||
}
|
||||
|
@ -111,26 +110,26 @@ int CHudDeathNotice :: Draw( float flTime )
|
|||
|
||||
// Only draw if the viewport will let me
|
||||
// vgui dropped out
|
||||
//if ( gViewPort && gViewPort->AllowedToPrintText() )
|
||||
//if( gViewPort && gViewPort->AllowedToPrintText() )
|
||||
{
|
||||
// Draw the death notice
|
||||
y = YRES(DEATHNOTICE_TOP) + 2 + (20 * i); //!!!
|
||||
y = YRES( DEATHNOTICE_TOP ) + 2 + ( 20 * i ); //!!!
|
||||
|
||||
int id = (rgDeathNoticeList[i].iId == -1) ? m_HUD_d_skull : rgDeathNoticeList[i].iId;
|
||||
x = ScreenWidth - ConsoleStringLen(rgDeathNoticeList[i].szVictim) - (gHUD.GetSpriteRect(id).right - gHUD.GetSpriteRect(id).left);
|
||||
int id = ( rgDeathNoticeList[i].iId == -1 ) ? m_HUD_d_skull : rgDeathNoticeList[i].iId;
|
||||
x = ScreenWidth - ConsoleStringLen( rgDeathNoticeList[i].szVictim ) - ( gHUD.GetSpriteRect(id).right - gHUD.GetSpriteRect(id).left );
|
||||
|
||||
if ( !rgDeathNoticeList[i].iSuicide )
|
||||
if( !rgDeathNoticeList[i].iSuicide )
|
||||
{
|
||||
x -= (5 + ConsoleStringLen( rgDeathNoticeList[i].szKiller ) );
|
||||
x -= ( 5 + ConsoleStringLen( rgDeathNoticeList[i].szKiller ) );
|
||||
|
||||
// Draw killers name
|
||||
if ( rgDeathNoticeList[i].KillerColor )
|
||||
if( rgDeathNoticeList[i].KillerColor )
|
||||
DrawSetTextColor( rgDeathNoticeList[i].KillerColor[0], rgDeathNoticeList[i].KillerColor[1], rgDeathNoticeList[i].KillerColor[2] );
|
||||
x = 5 + DrawConsoleString( x, y, rgDeathNoticeList[i].szKiller );
|
||||
}
|
||||
|
||||
r = 255; g = 80; b = 0;
|
||||
if ( rgDeathNoticeList[i].iTeamKill )
|
||||
r = 255; g = 80; b = 0;
|
||||
if( rgDeathNoticeList[i].iTeamKill )
|
||||
{
|
||||
r = 10; g = 240; b = 10; // display it in sickly green
|
||||
}
|
||||
|
@ -139,12 +138,12 @@ int CHudDeathNotice :: Draw( float flTime )
|
|||
SPR_Set( gHUD.GetSprite(id), r, g, b );
|
||||
SPR_DrawAdditive( 0, x, y, &gHUD.GetSpriteRect(id) );
|
||||
|
||||
x += (gHUD.GetSpriteRect(id).right - gHUD.GetSpriteRect(id).left);
|
||||
x += ( gHUD.GetSpriteRect(id).right - gHUD.GetSpriteRect(id).left );
|
||||
|
||||
// Draw victims name (if it was a player that was killed)
|
||||
if (rgDeathNoticeList[i].iNonPlayerKill == FALSE)
|
||||
if( rgDeathNoticeList[i].iNonPlayerKill == FALSE )
|
||||
{
|
||||
if ( rgDeathNoticeList[i].VictimColor )
|
||||
if( rgDeathNoticeList[i].VictimColor )
|
||||
DrawSetTextColor( rgDeathNoticeList[i].VictimColor[0], rgDeathNoticeList[i].VictimColor[1], rgDeathNoticeList[i].VictimColor[2] );
|
||||
x = DrawConsoleString( x, y, rgDeathNoticeList[i].szVictim );
|
||||
}
|
||||
|
@ -155,7 +154,7 @@ int CHudDeathNotice :: Draw( float flTime )
|
|||
}
|
||||
|
||||
// This message handler may be better off elsewhere
|
||||
int CHudDeathNotice :: MsgFunc_DeathMsg( const char *pszName, int iSize, void *pbuf )
|
||||
int CHudDeathNotice::MsgFunc_DeathMsg( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
int i;
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
|
@ -167,30 +166,29 @@ int CHudDeathNotice :: MsgFunc_DeathMsg( const char *pszName, int iSize, void *p
|
|||
|
||||
char killedwith[32];
|
||||
strcpy( killedwith, "d_" );
|
||||
strncat( killedwith, READ_STRING(), 32 );
|
||||
strncat( killedwith, READ_STRING(), sizeof(killedwith) - strlen(killedwith) - 1 );
|
||||
|
||||
gHUD.m_Spectator.DeathMessage( victim );
|
||||
|
||||
gHUD.m_Spectator.DeathMessage(victim);
|
||||
|
||||
for ( i = 0; i < MAX_DEATHNOTICES; i++ )
|
||||
for( i = 0; i < MAX_DEATHNOTICES; i++ )
|
||||
{
|
||||
if ( rgDeathNoticeList[i].iId == 0 )
|
||||
if( rgDeathNoticeList[i].iId == 0 )
|
||||
break;
|
||||
}
|
||||
if ( i == MAX_DEATHNOTICES )
|
||||
{ // move the rest of the list forward to make room for this item
|
||||
memmove( rgDeathNoticeList, rgDeathNoticeList+1, sizeof(DeathNoticeItem) * MAX_DEATHNOTICES );
|
||||
if( i == MAX_DEATHNOTICES )
|
||||
{
|
||||
// move the rest of the list forward to make room for this item
|
||||
memmove( rgDeathNoticeList, rgDeathNoticeList + 1, sizeof(DeathNoticeItem) * MAX_DEATHNOTICES );
|
||||
i = MAX_DEATHNOTICES - 1;
|
||||
}
|
||||
|
||||
//if (gViewPort)
|
||||
//if(gViewPort)
|
||||
// gViewPort->GetAllPlayersInfo();
|
||||
gHUD.m_Scoreboard.GetAllPlayersInfo();
|
||||
|
||||
|
||||
// Get the Killer's name
|
||||
char *killer_name = g_PlayerInfoList[ killer ].name;
|
||||
if ( !killer_name )
|
||||
char *killer_name = g_PlayerInfoList[killer].name;
|
||||
if( !killer_name )
|
||||
{
|
||||
killer_name = "";
|
||||
rgDeathNoticeList[i].szKiller[0] = 0;
|
||||
|
@ -199,14 +197,14 @@ int CHudDeathNotice :: MsgFunc_DeathMsg( const char *pszName, int iSize, void *p
|
|||
{
|
||||
rgDeathNoticeList[i].KillerColor = GetClientColor( killer );
|
||||
strncpy( rgDeathNoticeList[i].szKiller, killer_name, MAX_PLAYER_NAME_LENGTH );
|
||||
rgDeathNoticeList[i].szKiller[MAX_PLAYER_NAME_LENGTH-1] = 0;
|
||||
rgDeathNoticeList[i].szKiller[MAX_PLAYER_NAME_LENGTH - 1] = 0;
|
||||
}
|
||||
|
||||
// Get the Victim's name
|
||||
char *victim_name = NULL;
|
||||
// If victim is -1, the killer killed a specific, non-player object (like a sentrygun)
|
||||
if ( ((char)victim) != -1 )
|
||||
victim_name = g_PlayerInfoList[ victim ].name;
|
||||
if ( ( (char)victim ) != -1 )
|
||||
victim_name = g_PlayerInfoList[victim].name;
|
||||
if ( !victim_name )
|
||||
{
|
||||
victim_name = "";
|
||||
|
@ -216,16 +214,16 @@ int CHudDeathNotice :: MsgFunc_DeathMsg( const char *pszName, int iSize, void *p
|
|||
{
|
||||
rgDeathNoticeList[i].VictimColor = GetClientColor( victim );
|
||||
strncpy( rgDeathNoticeList[i].szVictim, victim_name, MAX_PLAYER_NAME_LENGTH );
|
||||
rgDeathNoticeList[i].szVictim[MAX_PLAYER_NAME_LENGTH-1] = 0;
|
||||
rgDeathNoticeList[i].szVictim[MAX_PLAYER_NAME_LENGTH - 1] = 0;
|
||||
}
|
||||
|
||||
// Is it a non-player object kill?
|
||||
if ( ((char)victim) == -1 )
|
||||
if ( ( (char)victim ) == -1 )
|
||||
{
|
||||
rgDeathNoticeList[i].iNonPlayerKill = TRUE;
|
||||
|
||||
// Store the object's name in the Victim slot (skip the d_ bit)
|
||||
strcpy( rgDeathNoticeList[i].szVictim, killedwith+2 );
|
||||
strcpy( rgDeathNoticeList[i].szVictim, killedwith + 2 );
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -244,7 +242,7 @@ int CHudDeathNotice :: MsgFunc_DeathMsg( const char *pszName, int iSize, void *p
|
|||
DEATHNOTICE_DISPLAY_TIME = CVAR_GET_FLOAT( "hud_deathnotice_time" );
|
||||
rgDeathNoticeList[i].flDisplayTime = gHUD.m_flTime + DEATHNOTICE_DISPLAY_TIME;
|
||||
|
||||
if (rgDeathNoticeList[i].iNonPlayerKill)
|
||||
if( rgDeathNoticeList[i].iNonPlayerKill )
|
||||
{
|
||||
ConsolePrint( rgDeathNoticeList[i].szKiller );
|
||||
ConsolePrint( " killed a " );
|
||||
|
@ -254,11 +252,11 @@ int CHudDeathNotice :: MsgFunc_DeathMsg( const char *pszName, int iSize, void *p
|
|||
else
|
||||
{
|
||||
// record the death notice in the console
|
||||
if ( rgDeathNoticeList[i].iSuicide )
|
||||
if( rgDeathNoticeList[i].iSuicide )
|
||||
{
|
||||
ConsolePrint( rgDeathNoticeList[i].szVictim );
|
||||
|
||||
if ( !strcmp( killedwith, "d_world" ) )
|
||||
if( !strcmp( killedwith, "d_world" ) )
|
||||
{
|
||||
ConsolePrint( " died" );
|
||||
}
|
||||
|
@ -267,7 +265,7 @@ int CHudDeathNotice :: MsgFunc_DeathMsg( const char *pszName, int iSize, void *p
|
|||
ConsolePrint( " killed self" );
|
||||
}
|
||||
}
|
||||
else if ( rgDeathNoticeList[i].iTeamKill )
|
||||
else if( rgDeathNoticeList[i].iTeamKill )
|
||||
{
|
||||
ConsolePrint( rgDeathNoticeList[i].szKiller );
|
||||
ConsolePrint( " killed his teammate " );
|
||||
|
@ -280,17 +278,17 @@ int CHudDeathNotice :: MsgFunc_DeathMsg( const char *pszName, int iSize, void *p
|
|||
ConsolePrint( rgDeathNoticeList[i].szVictim );
|
||||
}
|
||||
|
||||
if ( *killedwith && (*killedwith > 13 ) && strcmp( killedwith, "d_world" ) && !rgDeathNoticeList[i].iTeamKill )
|
||||
if( *killedwith && (*killedwith > 13 ) && strcmp( killedwith, "d_world" ) && !rgDeathNoticeList[i].iTeamKill )
|
||||
{
|
||||
ConsolePrint( " with " );
|
||||
|
||||
// replace the code names with the 'real' names
|
||||
if ( !strcmp( killedwith+2, "egon" ) )
|
||||
if( !strcmp( killedwith + 2, "egon" ) )
|
||||
strcpy( killedwith, "d_gluon gun" );
|
||||
if ( !strcmp( killedwith+2, "gauss" ) )
|
||||
if ( !strcmp( killedwith + 2, "gauss" ) )
|
||||
strcpy( killedwith, "d_tau cannon" );
|
||||
|
||||
ConsolePrint( killedwith+2 ); // skip over the "d_" part
|
||||
ConsolePrint( killedwith + 2 ); // skip over the "d_" part
|
||||
}
|
||||
|
||||
ConsolePrint( "\n" );
|
||||
|
@ -298,7 +296,3 @@ int CHudDeathNotice :: MsgFunc_DeathMsg( const char *pszName, int iSize, void *p
|
|||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -12,6 +12,7 @@
|
|||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "demo.h"
|
||||
|
@ -41,14 +42,14 @@ Write some data to the demo stream
|
|||
void Demo_WriteBuffer( int type, int size, unsigned char *buffer )
|
||||
{
|
||||
int pos = 0;
|
||||
unsigned char buf[ 32 * 1024 ];
|
||||
*( int * )&buf[pos] = type;
|
||||
pos+=sizeof( int );
|
||||
unsigned char buf[32 * 1024];
|
||||
*(int *)&buf[pos] = type;
|
||||
pos += sizeof(int);
|
||||
|
||||
memcpy( &buf[pos], buffer, size );
|
||||
|
||||
// Write full buffer out
|
||||
gEngfuncs.pDemoAPI->WriteBuffer( size + sizeof( int ), buf );
|
||||
gEngfuncs.pDemoAPI->WriteBuffer( size + sizeof(int), buf );
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -63,36 +64,36 @@ void DLLEXPORT Demo_ReadBuffer( int size, unsigned char *buffer )
|
|||
int type;
|
||||
int i = 0;
|
||||
|
||||
type = *( int * )buffer;
|
||||
i += sizeof( int );
|
||||
switch ( type )
|
||||
type = *(int *)buffer;
|
||||
i += sizeof(int);
|
||||
switch( type )
|
||||
{
|
||||
case TYPE_SNIPERDOT:
|
||||
g_demosniper = *(int * )&buffer[ i ];
|
||||
i += sizeof( int );
|
||||
g_demosniper = *(int *)&buffer[i];
|
||||
i += sizeof(int);
|
||||
|
||||
if ( g_demosniper )
|
||||
if( g_demosniper )
|
||||
{
|
||||
g_demosniperdamage = *( int * )&buffer[ i ];
|
||||
i += sizeof( int );
|
||||
g_demosniperdamage = *(int *)&buffer[i];
|
||||
i += sizeof(int);
|
||||
|
||||
g_demosniperangles[ 0 ] = *(float *)&buffer[i];
|
||||
i += sizeof( float );
|
||||
g_demosniperangles[ 1 ] = *(float *)&buffer[i];
|
||||
i += sizeof( float );
|
||||
g_demosniperangles[ 2 ] = *(float *)&buffer[i];
|
||||
i += sizeof( float );
|
||||
g_demosniperorg[ 0 ] = *(float *)&buffer[i];
|
||||
i += sizeof( float );
|
||||
g_demosniperorg[ 1 ] = *(float *)&buffer[i];
|
||||
i += sizeof( float );
|
||||
g_demosniperorg[ 2 ] = *(float *)&buffer[i];
|
||||
i += sizeof( float );
|
||||
g_demosniperangles[0] = *(float *)&buffer[i];
|
||||
i += sizeof(float);
|
||||
g_demosniperangles[1] = *(float *)&buffer[i];
|
||||
i += sizeof(float);
|
||||
g_demosniperangles[2] = *(float *)&buffer[i];
|
||||
i += sizeof(float);
|
||||
g_demosniperorg[0] = *(float *)&buffer[i];
|
||||
i += sizeof(float);
|
||||
g_demosniperorg[1] = *(float *)&buffer[i];
|
||||
i += sizeof(float);
|
||||
g_demosniperorg[2] = *(float *)&buffer[i];
|
||||
i += sizeof(float);
|
||||
}
|
||||
break;
|
||||
case TYPE_ZOOM:
|
||||
g_demozoom = *(float * )&buffer[ i ];
|
||||
i += sizeof( float );
|
||||
g_demozoom = *(float *)&buffer[i];
|
||||
i += sizeof(float);
|
||||
break;
|
||||
default:
|
||||
gEngfuncs.Con_DPrintf( "Unknown demo buffer type, skipping.\n" );
|
||||
|
|
|
@ -23,5 +23,4 @@ extern int g_demosniperdamage;
|
|||
extern float g_demosniperorg[3];
|
||||
extern float g_demosniperangles[3];
|
||||
extern float g_demozoom;
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
|
|
@ -20,14 +20,13 @@
|
|||
#include "pmtrace.h"
|
||||
#include "pm_shared.h"
|
||||
|
||||
|
||||
void Game_AddObjects( void );
|
||||
|
||||
extern vec3_t v_origin;
|
||||
|
||||
int g_iAlive = 1;
|
||||
|
||||
extern "C"
|
||||
extern "C"
|
||||
{
|
||||
int DLLEXPORT HUD_AddEntity( int type, struct cl_entity_s *ent, const char *modelname );
|
||||
void DLLEXPORT HUD_CreateEntities( void );
|
||||
|
@ -47,7 +46,7 @@ HUD_AddEntity
|
|||
*/
|
||||
int DLLEXPORT HUD_AddEntity( int type, struct cl_entity_s *ent, const char *modelname )
|
||||
{
|
||||
switch ( type )
|
||||
switch( type )
|
||||
{
|
||||
case ET_NORMAL:
|
||||
case ET_PLAYER:
|
||||
|
@ -62,14 +61,13 @@ int DLLEXPORT HUD_AddEntity( int type, struct cl_entity_s *ent, const char *mode
|
|||
// each frame every entity passes this function, so the overview hooks
|
||||
// it to filter the overview entities
|
||||
|
||||
if ( g_iUser1 )
|
||||
if( g_iUser1 )
|
||||
{
|
||||
gHUD.m_Spectator.AddOverviewEntity( type, ent, modelname );
|
||||
|
||||
if ( ( g_iUser1 == OBS_IN_EYE || gHUD.m_Spectator.m_pip->value == INSET_IN_EYE ) &&
|
||||
if( ( g_iUser1 == OBS_IN_EYE || gHUD.m_Spectator.m_pip->value == INSET_IN_EYE ) &&
|
||||
ent->index == g_iUser2 )
|
||||
return 0; // don't draw the player we are following in eye
|
||||
|
||||
}
|
||||
|
||||
return 1;
|
||||
|
@ -115,16 +113,16 @@ void DLLEXPORT HUD_ProcessPlayerState( struct entity_state_s *dst, const struct
|
|||
|
||||
VectorCopy( src->velocity, dst->velocity );
|
||||
|
||||
dst->frame = src->frame;
|
||||
dst->frame = src->frame;
|
||||
dst->modelindex = src->modelindex;
|
||||
dst->skin = src->skin;
|
||||
dst->skin = src->skin;
|
||||
dst->effects = src->effects;
|
||||
dst->weaponmodel = src->weaponmodel;
|
||||
dst->movetype = src->movetype;
|
||||
dst->sequence = src->sequence;
|
||||
dst->animtime = src->animtime;
|
||||
|
||||
dst->solid = src->solid;
|
||||
dst->solid = src->solid;
|
||||
|
||||
dst->rendermode = src->rendermode;
|
||||
dst->renderamt = src->renderamt;
|
||||
|
@ -134,10 +132,10 @@ void DLLEXPORT HUD_ProcessPlayerState( struct entity_state_s *dst, const struct
|
|||
dst->renderfx = src->renderfx;
|
||||
|
||||
dst->framerate = src->framerate;
|
||||
dst->body = src->body;
|
||||
dst->body = src->body;
|
||||
|
||||
memcpy( &dst->controller[0], &src->controller[0], 4 * sizeof( byte ) );
|
||||
memcpy( &dst->blending[0], &src->blending[0], 2 * sizeof( byte ) );
|
||||
memcpy( &dst->controller[0], &src->controller[0], 4 * sizeof(byte) );
|
||||
memcpy( &dst->blending[0], &src->blending[0], 2 * sizeof(byte) );
|
||||
|
||||
VectorCopy( src->basevelocity, dst->basevelocity );
|
||||
|
||||
|
@ -147,12 +145,12 @@ void DLLEXPORT HUD_ProcessPlayerState( struct entity_state_s *dst, const struct
|
|||
dst->spectator = src->spectator;
|
||||
dst->usehull = src->usehull;
|
||||
dst->playerclass = src->playerclass;
|
||||
dst->team = src->team;
|
||||
dst->team = src->team;
|
||||
dst->colormap = src->colormap;
|
||||
|
||||
// Save off some data so other areas of the Client DLL can get to it
|
||||
cl_entity_t *player = gEngfuncs.GetLocalPlayer(); // Get the local player's index
|
||||
if ( dst->number == player->index )
|
||||
if( dst->number == player->index )
|
||||
{
|
||||
g_iPlayerClass = dst->playerclass;
|
||||
g_iTeamNumber = dst->team;
|
||||
|
@ -173,7 +171,7 @@ Because we can predict an arbitrary number of frames before the server responds
|
|||
update is occupying.
|
||||
=========================
|
||||
*/
|
||||
void DLLEXPORT HUD_TxferPredictionData ( struct entity_state_s *ps, const struct entity_state_s *pps, struct clientdata_s *pcd, const struct clientdata_s *ppcd, struct weapon_data_s *wd, const struct weapon_data_s *pwd )
|
||||
void DLLEXPORT HUD_TxferPredictionData( struct entity_state_s *ps, const struct entity_state_s *pps, struct clientdata_s *pcd, const struct clientdata_s *ppcd, struct weapon_data_s *wd, const struct weapon_data_s *pwd )
|
||||
{
|
||||
ps->oldbuttons = pps->oldbuttons;
|
||||
ps->flFallVelocity = pps->flFallVelocity;
|
||||
|
@ -181,13 +179,13 @@ void DLLEXPORT HUD_TxferPredictionData ( struct entity_state_s *ps, const struct
|
|||
ps->playerclass = pps->playerclass;
|
||||
|
||||
pcd->viewmodel = ppcd->viewmodel;
|
||||
pcd->m_iId = ppcd->m_iId;
|
||||
pcd->m_iId = ppcd->m_iId;
|
||||
pcd->ammo_shells = ppcd->ammo_shells;
|
||||
pcd->ammo_nails = ppcd->ammo_nails;
|
||||
pcd->ammo_cells = ppcd->ammo_cells;
|
||||
pcd->ammo_rockets = ppcd->ammo_rockets;
|
||||
pcd->m_flNextAttack = ppcd->m_flNextAttack;
|
||||
pcd->fov = ppcd->fov;
|
||||
pcd->fov = ppcd->fov;
|
||||
pcd->weaponanim = ppcd->weaponanim;
|
||||
pcd->tfstate = ppcd->tfstate;
|
||||
pcd->maxspeed = ppcd->maxspeed;
|
||||
|
@ -204,18 +202,17 @@ void DLLEXPORT HUD_TxferPredictionData ( struct entity_state_s *ps, const struct
|
|||
// Duck prevention
|
||||
pcd->iuser3 = ppcd->iuser3;
|
||||
|
||||
if ( gEngfuncs.IsSpectateOnly() )
|
||||
if( gEngfuncs.IsSpectateOnly() )
|
||||
{
|
||||
// in specator mode we tell the engine who we want to spectate and how
|
||||
// iuser3 is not used for duck prevention (since the spectator can't duck at all)
|
||||
pcd->iuser1 = g_iUser1; // observer mode
|
||||
pcd->iuser2 = g_iUser2; // first target
|
||||
pcd->iuser3 = g_iUser3; // second target
|
||||
|
||||
}
|
||||
|
||||
// Fire prevention
|
||||
pcd->iuser4 = ppcd->iuser4;
|
||||
pcd->iuser4 = ppcd->iuser4;
|
||||
|
||||
pcd->fuser2 = ppcd->fuser2;
|
||||
pcd->fuser3 = ppcd->fuser3;
|
||||
|
@ -225,7 +222,7 @@ void DLLEXPORT HUD_TxferPredictionData ( struct entity_state_s *ps, const struct
|
|||
VectorCopy( ppcd->vuser3, pcd->vuser3 );
|
||||
VectorCopy( ppcd->vuser4, pcd->vuser4 );
|
||||
|
||||
memcpy( wd, pwd, 32 * sizeof( weapon_data_t ) );
|
||||
memcpy( wd, pwd, 32 * sizeof(weapon_data_t) );
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -243,35 +240,33 @@ void MoveModel( void )
|
|||
|
||||
// Load it up with some bogus data
|
||||
player = gEngfuncs.GetLocalPlayer();
|
||||
if ( !player )
|
||||
if( !player )
|
||||
return;
|
||||
|
||||
mod = gEngfuncs.CL_LoadModel( "models/sentry3.mdl", &modelindex );
|
||||
for ( i = 0; i < 3; i++ )
|
||||
for( i = 0; i < 3; i++ )
|
||||
{
|
||||
for ( j = 0; j < 3; j++ )
|
||||
for( j = 0; j < 3; j++ )
|
||||
{
|
||||
// Don't draw over ourself...
|
||||
if ( ( i == 1 ) && ( j == 1 ) )
|
||||
if( ( i == 1 ) && ( j == 1 ) )
|
||||
continue;
|
||||
|
||||
mymodel[ i * 3 + j ] = *player;
|
||||
mymodel[i * 3 + j] = *player;
|
||||
|
||||
mymodel[ i * 3 + j ].player = 0;
|
||||
mymodel[i * 3 + j].player = 0;
|
||||
|
||||
mymodel[ i * 3 + j ].model = mod;
|
||||
mymodel[ i * 3 + j ].curstate.modelindex = modelindex;
|
||||
mymodel[i * 3 + j].model = mod;
|
||||
mymodel[i * 3 + j].curstate.modelindex = modelindex;
|
||||
|
||||
// Move it out a bit
|
||||
mymodel[ i * 3 + j ].origin[0] = player->origin[0] + 50 * ( 1 - i );
|
||||
mymodel[ i * 3 + j ].origin[1] = player->origin[1] + 50 * ( 1 - j );
|
||||
// Move it out a bit
|
||||
mymodel[i * 3 + j].origin[0] = player->origin[0] + 50 * ( 1 - i );
|
||||
mymodel[i * 3 + j].origin[1] = player->origin[1] + 50 * ( 1 - j );
|
||||
|
||||
gEngfuncs.CL_CreateVisibleEntity( ET_NORMAL, &mymodel[i*3+j] );
|
||||
gEngfuncs.CL_CreateVisibleEntity( ET_NORMAL, &mymodel[i * 3 + j] );
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//#define TRACE_TEST
|
||||
|
@ -285,12 +280,12 @@ void TraceModel( void )
|
|||
{
|
||||
cl_entity_t *ent;
|
||||
|
||||
if ( hitent <= 0 )
|
||||
if( hitent <= 0 )
|
||||
return;
|
||||
|
||||
// Load it up with some bogus data
|
||||
ent = gEngfuncs.GetEntityByIndex( hitent );
|
||||
if ( !ent )
|
||||
if( !ent )
|
||||
return;
|
||||
|
||||
hit = *ent;
|
||||
|
@ -302,7 +297,6 @@ void TraceModel( void )
|
|||
|
||||
gEngfuncs.CL_CreateVisibleEntity( ET_NORMAL, &hit );
|
||||
}
|
||||
|
||||
#endif
|
||||
*/
|
||||
|
||||
|
@ -311,9 +305,9 @@ void ParticleCallback( struct particle_s *particle, float frametime )
|
|||
{
|
||||
int i;
|
||||
|
||||
for ( i = 0; i < 3; i++ )
|
||||
for( i = 0; i < 3; i++ )
|
||||
{
|
||||
particle->org[ i ] += particle->vel[ i ] * frametime;
|
||||
particle->org[i] += particle->vel[i] * frametime;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -322,13 +316,13 @@ void Particles( void )
|
|||
{
|
||||
static float lasttime;
|
||||
float curtime;
|
||||
|
||||
|
||||
curtime = gEngfuncs.GetClientTime();
|
||||
|
||||
if ( ( curtime - lasttime ) < 2.0 )
|
||||
if( ( curtime - lasttime ) < 2.0 )
|
||||
return;
|
||||
|
||||
if ( !color )
|
||||
if( !color )
|
||||
{
|
||||
color = gEngfuncs.pfnRegisterVariable ( "color","255 0 0", 0 );
|
||||
}
|
||||
|
@ -339,20 +333,20 @@ void Particles( void )
|
|||
particle_t *p;
|
||||
int i, j;
|
||||
|
||||
for ( i = 0; i < 1000; i++ )
|
||||
for( i = 0; i < 1000; i++ )
|
||||
{
|
||||
int r, g, b;
|
||||
p = gEngfuncs.pEfxAPI->R_AllocParticle( ParticleCallback );
|
||||
if ( !p )
|
||||
if( !p )
|
||||
break;
|
||||
|
||||
for ( j = 0; j < 3; j++ )
|
||||
for( j = 0; j < 3; j++ )
|
||||
{
|
||||
p->org[ j ] = v_origin[ j ] + gEngfuncs.pfnRandomFloat( -32.0, 32.0 );;
|
||||
p->vel[ j ] = gEngfuncs.pfnRandomFloat( -100.0, 100.0 );
|
||||
p->org[j] = v_origin[j] + gEngfuncs.pfnRandomFloat( -32.0, 32.0 );
|
||||
p->vel[j] = gEngfuncs.pfnRandomFloat( -100.0, 100.0 );
|
||||
}
|
||||
|
||||
if ( color )
|
||||
if( color )
|
||||
{
|
||||
sscanf( color->string, "%i %i %i", &r, &g, &b );
|
||||
}
|
||||
|
@ -363,7 +357,7 @@ void Particles( void )
|
|||
b = 0;
|
||||
}
|
||||
|
||||
p->color = gEngfuncs.pEfxAPI->R_LookupColor( r, g, b );
|
||||
p->color = gEngfuncs.pEfxAPI->R_LookupColor( r, g, b );
|
||||
gEngfuncs.pEfxAPI->R_GetPackedColor( &p->packedColor, p->color );
|
||||
|
||||
// p->die is set to current time so all you have to do is add an additional time to it
|
||||
|
@ -373,13 +367,13 @@ void Particles( void )
|
|||
*/
|
||||
|
||||
/*
|
||||
void TempEntCallback ( struct tempent_s *ent, float frametime, float currenttime )
|
||||
void TempEntCallback( struct tempent_s *ent, float frametime, float currenttime )
|
||||
{
|
||||
int i;
|
||||
|
||||
for ( i = 0; i < 3; i++ )
|
||||
for( i = 0; i < 3; i++ )
|
||||
{
|
||||
ent->entity.curstate.origin[ i ] += ent->entity.baseline.origin[ i ] * frametime;
|
||||
ent->entity.curstate.origin[i] += ent->entity.baseline.origin[i] * frametime;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -387,10 +381,10 @@ void TempEnts( void )
|
|||
{
|
||||
static float lasttime;
|
||||
float curtime;
|
||||
|
||||
|
||||
curtime = gEngfuncs.GetClientTime();
|
||||
|
||||
if ( ( curtime - lasttime ) < 10.0 )
|
||||
if( ( curtime - lasttime ) < 10.0 )
|
||||
return;
|
||||
|
||||
lasttime = curtime;
|
||||
|
@ -403,27 +397,27 @@ void TempEnts( void )
|
|||
|
||||
mod = gEngfuncs.CL_LoadModel( "sprites/laserdot.spr", &index );
|
||||
|
||||
for ( i = 0; i < 100; i++ )
|
||||
for( i = 0; i < 100; i++ )
|
||||
{
|
||||
for ( j = 0; j < 3; j++ )
|
||||
for( j = 0; j < 3; j++ )
|
||||
{
|
||||
origin[ j ] = v_origin[ j ];
|
||||
if ( j != 2 )
|
||||
origin[j] = v_origin[j];
|
||||
if( j != 2 )
|
||||
{
|
||||
origin[ j ] += 75;
|
||||
origin[j] += 75;
|
||||
}
|
||||
}
|
||||
|
||||
p = gEngfuncs.pEfxAPI->CL_TentEntAllocCustom( (float *)&origin, mod, 0, TempEntCallback );
|
||||
if ( !p )
|
||||
if( !p )
|
||||
break;
|
||||
|
||||
for ( j = 0; j < 3; j++ )
|
||||
for( j = 0; j < 3; j++ )
|
||||
{
|
||||
p->entity.curstate.origin[ j ] = origin[ j ];
|
||||
p->entity.curstate.origin[j] = origin[j];
|
||||
|
||||
// Store velocity in baseline origin
|
||||
p->entity.baseline.origin[ j ] = gEngfuncs.pfnRandomFloat( -100, 100 );
|
||||
p->entity.baseline.origin[j] = gEngfuncs.pfnRandomFloat( -100, 100 );
|
||||
}
|
||||
|
||||
// p->die is set to current time so all you have to do is add an additional time to it
|
||||
|
@ -433,9 +427,9 @@ void TempEnts( void )
|
|||
*/
|
||||
|
||||
#if defined( BEAM_TEST )
|
||||
// Note can't index beam[ 0 ] in Beam callback, so don't use that index
|
||||
// Note can't index beam[0] in Beam callback, so don't use that index
|
||||
// Room for 1 beam ( 0 can't be used )
|
||||
static cl_entity_t beams[ 2 ];
|
||||
static cl_entity_t beams[2];
|
||||
|
||||
void BeamEndModel( void )
|
||||
{
|
||||
|
@ -445,21 +439,21 @@ void BeamEndModel( void )
|
|||
|
||||
// Load it up with some bogus data
|
||||
player = gEngfuncs.GetLocalPlayer();
|
||||
if ( !player )
|
||||
if( !player )
|
||||
return;
|
||||
|
||||
mod = gEngfuncs.CL_LoadModel( "models/sentry3.mdl", &modelindex );
|
||||
if ( !mod )
|
||||
if( !mod )
|
||||
return;
|
||||
|
||||
// Slot 1
|
||||
model = &beams[ 1 ];
|
||||
model = &beams[1];
|
||||
|
||||
*model = *player;
|
||||
model->player = 0;
|
||||
model->model = mod;
|
||||
model->curstate.modelindex = modelindex;
|
||||
|
||||
|
||||
// Move it out a bit
|
||||
model->origin[0] = player->origin[0] - 100;
|
||||
model->origin[1] = player->origin[1];
|
||||
|
@ -480,22 +474,22 @@ void Beams( void )
|
|||
int index;
|
||||
|
||||
BeamEndModel();
|
||||
|
||||
curtime = gEngfuncs.GetClientTime();
|
||||
float end[ 3 ];
|
||||
|
||||
if ( ( curtime - lasttime ) < 10.0 )
|
||||
curtime = gEngfuncs.GetClientTime();
|
||||
float end[3];
|
||||
|
||||
if( ( curtime - lasttime ) < 10.0 )
|
||||
return;
|
||||
|
||||
mod = gEngfuncs.CL_LoadModel( "sprites/laserbeam.spr", &index );
|
||||
if ( !mod )
|
||||
if( !mod )
|
||||
return;
|
||||
|
||||
lasttime = curtime;
|
||||
|
||||
end [ 0 ] = v_origin.x + 100;
|
||||
end [ 1 ] = v_origin.y + 100;
|
||||
end [ 2 ] = v_origin.z;
|
||||
end[0] = v_origin.x + 100;
|
||||
end[1] = v_origin.y + 100;
|
||||
end[2] = v_origin.z;
|
||||
|
||||
BEAM *p1;
|
||||
p1 = gEngfuncs.pEfxAPI->R_BeamEntPoint( -1, end, index,
|
||||
|
@ -519,7 +513,6 @@ void DLLEXPORT HUD_CreateEntities( void )
|
|||
#if defined( TEST_IT )
|
||||
MoveModel();
|
||||
#endif
|
||||
|
||||
#if defined( TRACE_TEST )
|
||||
TraceModel();
|
||||
#endif
|
||||
|
@ -530,11 +523,9 @@ void DLLEXPORT HUD_CreateEntities( void )
|
|||
/*
|
||||
TempEnts();
|
||||
*/
|
||||
|
||||
#if defined( BEAM_TEST )
|
||||
Beams();
|
||||
#endif
|
||||
|
||||
// Add in any game specific objects
|
||||
Game_AddObjects();
|
||||
}
|
||||
|
@ -552,19 +543,19 @@ void DLLEXPORT HUD_StudioEvent( const struct mstudioevent_s *event, const struct
|
|||
switch( event->event )
|
||||
{
|
||||
case 5001:
|
||||
gEngfuncs.pEfxAPI->R_MuzzleFlash( (float *)&entity->attachment[0], atoi( event->options) );
|
||||
gEngfuncs.pEfxAPI->R_MuzzleFlash( (float *)&entity->attachment[0], atoi( event->options ) );
|
||||
break;
|
||||
case 5011:
|
||||
gEngfuncs.pEfxAPI->R_MuzzleFlash( (float *)&entity->attachment[1], atoi( event->options) );
|
||||
gEngfuncs.pEfxAPI->R_MuzzleFlash( (float *)&entity->attachment[1], atoi( event->options ) );
|
||||
break;
|
||||
case 5021:
|
||||
gEngfuncs.pEfxAPI->R_MuzzleFlash( (float *)&entity->attachment[2], atoi( event->options) );
|
||||
gEngfuncs.pEfxAPI->R_MuzzleFlash( (float *)&entity->attachment[2], atoi( event->options ) );
|
||||
break;
|
||||
case 5031:
|
||||
gEngfuncs.pEfxAPI->R_MuzzleFlash( (float *)&entity->attachment[3], atoi( event->options) );
|
||||
gEngfuncs.pEfxAPI->R_MuzzleFlash( (float *)&entity->attachment[3], atoi( event->options ) );
|
||||
break;
|
||||
case 5002:
|
||||
gEngfuncs.pEfxAPI->R_SparkEffect( (float *)&entity->attachment[0], atoi( event->options), -100, 100 );
|
||||
gEngfuncs.pEfxAPI->R_SparkEffect( (float *)&entity->attachment[0], atoi( event->options ), -100, 100 );
|
||||
break;
|
||||
// Client side sound
|
||||
case 5004:
|
||||
|
@ -610,19 +601,19 @@ void DLLEXPORT HUD_TempEntUpdate (
|
|||
gEngfuncs.pEventAPI->EV_PushPMStates();
|
||||
|
||||
// Now add in all of the players.
|
||||
gEngfuncs.pEventAPI->EV_SetSolidPlayers ( -1 );
|
||||
gEngfuncs.pEventAPI->EV_SetSolidPlayers( -1 );
|
||||
|
||||
// !!!BUGBUG -- This needs to be time based
|
||||
gTempEntFrame = (gTempEntFrame+1) & 31;
|
||||
gTempEntFrame = ( gTempEntFrame + 1 ) & 31;
|
||||
|
||||
pTemp = *ppTempEntActive;
|
||||
|
||||
// !!! Don't simulate while paused.... This is sort of a hack, revisit.
|
||||
if ( frametime <= 0 )
|
||||
if( frametime <= 0 )
|
||||
{
|
||||
while ( pTemp )
|
||||
while( pTemp )
|
||||
{
|
||||
if ( !(pTemp->flags & FTENT_NOMODEL ) )
|
||||
if( !( pTemp->flags & FTENT_NOMODEL ) )
|
||||
{
|
||||
Callback_AddVisibleEntity( &pTemp->entity );
|
||||
}
|
||||
|
@ -637,7 +628,7 @@ void DLLEXPORT HUD_TempEntUpdate (
|
|||
gravity = -frametime * cl_gravity;
|
||||
gravitySlow = gravity * 0.5;
|
||||
|
||||
while ( pTemp )
|
||||
while( pTemp )
|
||||
{
|
||||
int active;
|
||||
|
||||
|
@ -645,25 +636,24 @@ void DLLEXPORT HUD_TempEntUpdate (
|
|||
|
||||
life = pTemp->die - client_time;
|
||||
pnext = pTemp->next;
|
||||
if ( life < 0 )
|
||||
if( life < 0 )
|
||||
{
|
||||
if ( pTemp->flags & FTENT_FADEOUT )
|
||||
if( pTemp->flags & FTENT_FADEOUT )
|
||||
{
|
||||
if (pTemp->entity.curstate.rendermode == kRenderNormal)
|
||||
if( pTemp->entity.curstate.rendermode == kRenderNormal)
|
||||
pTemp->entity.curstate.rendermode = kRenderTransTexture;
|
||||
pTemp->entity.curstate.renderamt = pTemp->entity.baseline.renderamt * ( 1 + life * pTemp->fadeSpeed );
|
||||
if ( pTemp->entity.curstate.renderamt <= 0 )
|
||||
if( pTemp->entity.curstate.renderamt <= 0 )
|
||||
active = 0;
|
||||
|
||||
}
|
||||
else
|
||||
active = 0;
|
||||
}
|
||||
if ( !active ) // Kill it
|
||||
if( !active ) // Kill it
|
||||
{
|
||||
pTemp->next = *ppTempEntFree;
|
||||
*ppTempEntFree = pTemp;
|
||||
if ( !pprev ) // Deleting at head of list
|
||||
if( !pprev ) // Deleting at head of list
|
||||
*ppTempEntActive = pnext;
|
||||
else
|
||||
pprev->next = pnext;
|
||||
|
@ -671,14 +661,14 @@ void DLLEXPORT HUD_TempEntUpdate (
|
|||
else
|
||||
{
|
||||
pprev = pTemp;
|
||||
|
||||
|
||||
VectorCopy( pTemp->entity.origin, pTemp->entity.prevstate.origin );
|
||||
|
||||
if ( pTemp->flags & FTENT_SPARKSHOWER )
|
||||
if( pTemp->flags & FTENT_SPARKSHOWER )
|
||||
{
|
||||
// Adjust speed if it's time
|
||||
// Scale is next think time
|
||||
if ( client_time > pTemp->entity.baseline.scale )
|
||||
if( client_time > pTemp->entity.baseline.scale )
|
||||
{
|
||||
// Show Sparks
|
||||
gEngfuncs.pEfxAPI->R_SparkEffect( pTemp->entity.origin, 8, -200, 200 );
|
||||
|
@ -686,7 +676,7 @@ void DLLEXPORT HUD_TempEntUpdate (
|
|||
// Reduce life
|
||||
pTemp->entity.baseline.framerate -= 0.1;
|
||||
|
||||
if ( pTemp->entity.baseline.framerate <= 0.0 )
|
||||
if( pTemp->entity.baseline.framerate <= 0.0 )
|
||||
{
|
||||
pTemp->die = client_time;
|
||||
}
|
||||
|
@ -700,7 +690,7 @@ void DLLEXPORT HUD_TempEntUpdate (
|
|||
}
|
||||
}
|
||||
}
|
||||
else if ( pTemp->flags & FTENT_PLYRATTACHMENT )
|
||||
else if( pTemp->flags & FTENT_PLYRATTACHMENT )
|
||||
{
|
||||
cl_entity_t *pClient;
|
||||
|
||||
|
@ -708,16 +698,16 @@ void DLLEXPORT HUD_TempEntUpdate (
|
|||
|
||||
VectorAdd( pClient->origin, pTemp->tentOffset, pTemp->entity.origin );
|
||||
}
|
||||
else if ( pTemp->flags & FTENT_SINEWAVE )
|
||||
else if( pTemp->flags & FTENT_SINEWAVE )
|
||||
{
|
||||
pTemp->x += pTemp->entity.baseline.origin[0] * frametime;
|
||||
pTemp->y += pTemp->entity.baseline.origin[1] * frametime;
|
||||
|
||||
pTemp->entity.origin[0] = pTemp->x + sin( pTemp->entity.baseline.origin[2] + client_time * pTemp->entity.prevstate.frame ) * (10*pTemp->entity.curstate.framerate);
|
||||
pTemp->entity.origin[1] = pTemp->y + sin( pTemp->entity.baseline.origin[2] + fastFreq + 0.7 ) * (8*pTemp->entity.curstate.framerate);
|
||||
pTemp->entity.origin[0] = pTemp->x + sin( pTemp->entity.baseline.origin[2] + client_time * pTemp->entity.prevstate.frame ) * ( 10 * pTemp->entity.curstate.framerate );
|
||||
pTemp->entity.origin[1] = pTemp->y + sin( pTemp->entity.baseline.origin[2] + fastFreq + 0.7 ) * ( 8 * pTemp->entity.curstate.framerate );
|
||||
pTemp->entity.origin[2] += pTemp->entity.baseline.origin[2] * frametime;
|
||||
}
|
||||
else if ( pTemp->flags & FTENT_SPIRAL )
|
||||
else if( pTemp->flags & FTENT_SPIRAL )
|
||||
{
|
||||
float s, c;
|
||||
s = sin( pTemp->entity.baseline.origin[2] + fastFreq );
|
||||
|
@ -727,21 +717,20 @@ void DLLEXPORT HUD_TempEntUpdate (
|
|||
pTemp->entity.origin[1] += pTemp->entity.baseline.origin[1] * frametime + 4 * sin( client_time * 30 + (int)(size_t)pTemp );
|
||||
pTemp->entity.origin[2] += pTemp->entity.baseline.origin[2] * frametime;
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
for ( i = 0; i < 3; i++ )
|
||||
for( i = 0; i < 3; i++ )
|
||||
pTemp->entity.origin[i] += pTemp->entity.baseline.origin[i] * frametime;
|
||||
}
|
||||
|
||||
if ( pTemp->flags & FTENT_SPRANIMATE )
|
||||
if( pTemp->flags & FTENT_SPRANIMATE )
|
||||
{
|
||||
pTemp->entity.curstate.frame += frametime * pTemp->entity.curstate.framerate;
|
||||
if ( pTemp->entity.curstate.frame >= pTemp->frameMax )
|
||||
if( pTemp->entity.curstate.frame >= pTemp->frameMax )
|
||||
{
|
||||
pTemp->entity.curstate.frame = pTemp->entity.curstate.frame - (int)(pTemp->entity.curstate.frame);
|
||||
pTemp->entity.curstate.frame = pTemp->entity.curstate.frame - (int)( pTemp->entity.curstate.frame );
|
||||
|
||||
if ( !(pTemp->flags & FTENT_SPRANIMATELOOP) )
|
||||
if( !( pTemp->flags & FTENT_SPRANIMATELOOP ) )
|
||||
{
|
||||
// this animating sprite isn't set to loop, so destroy it.
|
||||
pTemp->die = client_time;
|
||||
|
@ -750,21 +739,21 @@ void DLLEXPORT HUD_TempEntUpdate (
|
|||
}
|
||||
}
|
||||
}
|
||||
else if ( pTemp->flags & FTENT_SPRCYCLE )
|
||||
else if( pTemp->flags & FTENT_SPRCYCLE )
|
||||
{
|
||||
pTemp->entity.curstate.frame += frametime * 10;
|
||||
if ( pTemp->entity.curstate.frame >= pTemp->frameMax )
|
||||
if( pTemp->entity.curstate.frame >= pTemp->frameMax )
|
||||
{
|
||||
pTemp->entity.curstate.frame = pTemp->entity.curstate.frame - (int)(pTemp->entity.curstate.frame);
|
||||
pTemp->entity.curstate.frame = pTemp->entity.curstate.frame - (int)( pTemp->entity.curstate.frame );
|
||||
}
|
||||
}
|
||||
// Experiment
|
||||
#if 0
|
||||
if ( pTemp->flags & FTENT_SCALE )
|
||||
pTemp->entity.curstate.framerate += 20.0 * (frametime / pTemp->entity.curstate.framerate);
|
||||
if( pTemp->flags & FTENT_SCALE )
|
||||
pTemp->entity.curstate.framerate += 20.0 * ( frametime / pTemp->entity.curstate.framerate );
|
||||
#endif
|
||||
|
||||
if ( pTemp->flags & FTENT_ROTATE )
|
||||
if( pTemp->flags & FTENT_ROTATE )
|
||||
{
|
||||
pTemp->entity.angles[0] += pTemp->entity.baseline.angles[0] * frametime;
|
||||
pTemp->entity.angles[1] += pTemp->entity.baseline.angles[1] * frametime;
|
||||
|
@ -773,98 +762,97 @@ void DLLEXPORT HUD_TempEntUpdate (
|
|||
VectorCopy( pTemp->entity.angles, pTemp->entity.latched.prevangles );
|
||||
}
|
||||
|
||||
if ( pTemp->flags & (FTENT_COLLIDEALL | FTENT_COLLIDEWORLD) )
|
||||
if( pTemp->flags & ( FTENT_COLLIDEALL | FTENT_COLLIDEWORLD ) )
|
||||
{
|
||||
vec3_t traceNormal;
|
||||
vec3_t traceNormal( 0.0f, 0.0f, 0.0f );
|
||||
float traceFraction = 1;
|
||||
|
||||
if ( pTemp->flags & FTENT_COLLIDEALL )
|
||||
if( pTemp->flags & FTENT_COLLIDEALL )
|
||||
{
|
||||
pmtrace_t pmtrace;
|
||||
physent_t *pe;
|
||||
|
||||
|
||||
gEngfuncs.pEventAPI->EV_SetTraceHull( 2 );
|
||||
|
||||
gEngfuncs.pEventAPI->EV_PlayerTrace( pTemp->entity.prevstate.origin, pTemp->entity.origin, PM_STUDIO_BOX, -1, &pmtrace );
|
||||
|
||||
|
||||
if ( pmtrace.fraction != 1 )
|
||||
if( pmtrace.fraction != 1 )
|
||||
{
|
||||
pe = gEngfuncs.pEventAPI->EV_GetPhysent( pmtrace.ent );
|
||||
|
||||
if ( !pmtrace.ent || ( pe->info != pTemp->clientIndex ) )
|
||||
if( !pmtrace.ent || ( pe->info != pTemp->clientIndex ) )
|
||||
{
|
||||
traceFraction = pmtrace.fraction;
|
||||
VectorCopy( pmtrace.plane.normal, traceNormal );
|
||||
|
||||
if ( pTemp->hitcallback )
|
||||
if( pTemp->hitcallback )
|
||||
{
|
||||
(*pTemp->hitcallback)( pTemp, &pmtrace );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else if ( pTemp->flags & FTENT_COLLIDEWORLD )
|
||||
else if( pTemp->flags & FTENT_COLLIDEWORLD )
|
||||
{
|
||||
pmtrace_t pmtrace;
|
||||
|
||||
|
||||
gEngfuncs.pEventAPI->EV_SetTraceHull( 2 );
|
||||
|
||||
gEngfuncs.pEventAPI->EV_PlayerTrace( pTemp->entity.prevstate.origin, pTemp->entity.origin, PM_STUDIO_BOX | PM_WORLD_ONLY, -1, &pmtrace );
|
||||
gEngfuncs.pEventAPI->EV_PlayerTrace( pTemp->entity.prevstate.origin, pTemp->entity.origin, PM_STUDIO_BOX | PM_WORLD_ONLY, -1, &pmtrace );
|
||||
|
||||
if ( pmtrace.fraction != 1 )
|
||||
if( pmtrace.fraction != 1 )
|
||||
{
|
||||
traceFraction = pmtrace.fraction;
|
||||
VectorCopy( pmtrace.plane.normal, traceNormal );
|
||||
|
||||
if ( pTemp->flags & FTENT_SPARKSHOWER )
|
||||
if( pTemp->flags & FTENT_SPARKSHOWER )
|
||||
{
|
||||
// Chop spark speeds a bit more
|
||||
//
|
||||
VectorScale( pTemp->entity.baseline.origin, 0.6, pTemp->entity.baseline.origin );
|
||||
|
||||
if ( Length( pTemp->entity.baseline.origin ) < 10 )
|
||||
if( Length( pTemp->entity.baseline.origin ) < 10 )
|
||||
{
|
||||
pTemp->entity.baseline.framerate = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
if ( pTemp->hitcallback )
|
||||
if( pTemp->hitcallback )
|
||||
{
|
||||
(*pTemp->hitcallback)( pTemp, &pmtrace );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ( traceFraction != 1 ) // Decent collision now, and damping works
|
||||
if( traceFraction != 1 ) // Decent collision now, and damping works
|
||||
{
|
||||
float proj, damp;
|
||||
|
||||
// Place at contact point
|
||||
VectorMA( pTemp->entity.prevstate.origin, traceFraction*frametime, pTemp->entity.baseline.origin, pTemp->entity.origin );
|
||||
VectorMA( pTemp->entity.prevstate.origin, traceFraction * frametime, pTemp->entity.baseline.origin, pTemp->entity.origin );
|
||||
// Damp velocity
|
||||
damp = pTemp->bounceFactor;
|
||||
if ( pTemp->flags & (FTENT_GRAVITY|FTENT_SLOWGRAVITY) )
|
||||
if( pTemp->flags & ( FTENT_GRAVITY | FTENT_SLOWGRAVITY ) )
|
||||
{
|
||||
damp *= 0.5;
|
||||
if ( traceNormal[2] > 0.9 ) // Hit floor?
|
||||
if( traceNormal[2] > 0.9 ) // Hit floor?
|
||||
{
|
||||
if ( pTemp->entity.baseline.origin[2] <= 0 && pTemp->entity.baseline.origin[2] >= gravity*3 )
|
||||
if( pTemp->entity.baseline.origin[2] <= 0 && pTemp->entity.baseline.origin[2] >= gravity*3 )
|
||||
{
|
||||
damp = 0; // Stop
|
||||
pTemp->flags &= ~(FTENT_ROTATE|FTENT_GRAVITY|FTENT_SLOWGRAVITY|FTENT_COLLIDEWORLD|FTENT_SMOKETRAIL);
|
||||
pTemp->flags &= ~( FTENT_ROTATE | FTENT_GRAVITY | FTENT_SLOWGRAVITY | FTENT_COLLIDEWORLD | FTENT_SMOKETRAIL);
|
||||
pTemp->entity.angles[0] = 0;
|
||||
pTemp->entity.angles[2] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (pTemp->hitSound)
|
||||
if( pTemp->hitSound )
|
||||
{
|
||||
Callback_TempEntPlaySound(pTemp, damp);
|
||||
Callback_TempEntPlaySound( pTemp, damp );
|
||||
}
|
||||
|
||||
if (pTemp->flags & FTENT_COLLIDEKILL)
|
||||
if( pTemp->flags & FTENT_COLLIDEKILL )
|
||||
{
|
||||
// die on impact
|
||||
pTemp->flags &= ~FTENT_FADEOUT;
|
||||
|
@ -873,16 +861,16 @@ void DLLEXPORT HUD_TempEntUpdate (
|
|||
else
|
||||
{
|
||||
// Reflect velocity
|
||||
if ( damp != 0 )
|
||||
if( damp != 0 )
|
||||
{
|
||||
proj = DotProduct( pTemp->entity.baseline.origin, traceNormal );
|
||||
VectorMA( pTemp->entity.baseline.origin, -proj*2, traceNormal, pTemp->entity.baseline.origin );
|
||||
VectorMA( pTemp->entity.baseline.origin, -proj * 2, traceNormal, pTemp->entity.baseline.origin );
|
||||
// Reflect rotation (fake)
|
||||
|
||||
pTemp->entity.angles[1] = -pTemp->entity.angles[1];
|
||||
}
|
||||
|
||||
if ( damp != 1 )
|
||||
if( damp != 1 )
|
||||
{
|
||||
|
||||
VectorScale( pTemp->entity.baseline.origin, damp, pTemp->entity.baseline.origin );
|
||||
|
@ -892,11 +880,10 @@ void DLLEXPORT HUD_TempEntUpdate (
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
if ( (pTemp->flags & FTENT_FLICKER) && gTempEntFrame == pTemp->entity.curstate.effects )
|
||||
if( ( pTemp->flags & FTENT_FLICKER ) && gTempEntFrame == pTemp->entity.curstate.effects )
|
||||
{
|
||||
dlight_t *dl = gEngfuncs.pEfxAPI->CL_AllocDlight (0);
|
||||
VectorCopy (pTemp->entity.origin, dl->origin);
|
||||
dlight_t *dl = gEngfuncs.pEfxAPI->CL_AllocDlight(0);
|
||||
VectorCopy( pTemp->entity.origin, dl->origin );
|
||||
dl->radius = 60;
|
||||
dl->color.r = 255;
|
||||
dl->color.g = 120;
|
||||
|
@ -904,30 +891,30 @@ void DLLEXPORT HUD_TempEntUpdate (
|
|||
dl->die = client_time + 0.01;
|
||||
}
|
||||
|
||||
if ( pTemp->flags & FTENT_SMOKETRAIL )
|
||||
if( pTemp->flags & FTENT_SMOKETRAIL )
|
||||
{
|
||||
gEngfuncs.pEfxAPI->R_RocketTrail (pTemp->entity.prevstate.origin, pTemp->entity.origin, 1);
|
||||
gEngfuncs.pEfxAPI->R_RocketTrail( pTemp->entity.prevstate.origin, pTemp->entity.origin, 1 );
|
||||
}
|
||||
|
||||
if ( pTemp->flags & FTENT_GRAVITY )
|
||||
if( pTemp->flags & FTENT_GRAVITY )
|
||||
pTemp->entity.baseline.origin[2] += gravity;
|
||||
else if ( pTemp->flags & FTENT_SLOWGRAVITY )
|
||||
else if( pTemp->flags & FTENT_SLOWGRAVITY )
|
||||
pTemp->entity.baseline.origin[2] += gravitySlow;
|
||||
|
||||
if ( pTemp->flags & FTENT_CLIENTCUSTOM )
|
||||
if( pTemp->flags & FTENT_CLIENTCUSTOM )
|
||||
{
|
||||
if ( pTemp->callback )
|
||||
if( pTemp->callback )
|
||||
{
|
||||
( *pTemp->callback )( pTemp, frametime, client_time );
|
||||
(*pTemp->callback)( pTemp, frametime, client_time );
|
||||
}
|
||||
}
|
||||
|
||||
// Cull to PVS (not frustum cull, just PVS)
|
||||
if ( !(pTemp->flags & FTENT_NOMODEL ) )
|
||||
if( !( pTemp->flags & FTENT_NOMODEL ) )
|
||||
{
|
||||
if ( !Callback_AddVisibleEntity( &pTemp->entity ) )
|
||||
if( !Callback_AddVisibleEntity( &pTemp->entity ) )
|
||||
{
|
||||
if ( !(pTemp->flags & FTENT_PERSIST) )
|
||||
if( !( pTemp->flags & FTENT_PERSIST ) )
|
||||
{
|
||||
pTemp->die = client_time; // If we can't draw it this frame, just dump it.
|
||||
pTemp->flags &= ~FTENT_FADEOUT; // Don't fade out, just die
|
||||
|
@ -937,7 +924,6 @@ void DLLEXPORT HUD_TempEntUpdate (
|
|||
}
|
||||
pTemp = pnext;
|
||||
}
|
||||
|
||||
finish:
|
||||
// Restore state info
|
||||
gEngfuncs.pEventAPI->EV_PopPMStates();
|
||||
|
@ -959,9 +945,9 @@ cl_entity_t DLLEXPORT *HUD_GetUserEntity( int index )
|
|||
#if defined( BEAM_TEST )
|
||||
// None by default, you would return a valic pointer if you create a client side
|
||||
// beam and attach it to a client side entity.
|
||||
if ( index > 0 && index <= 1 )
|
||||
if( index > 0 && index <= 1 )
|
||||
{
|
||||
return &beams[ index ];
|
||||
return &beams[index];
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -971,4 +957,3 @@ cl_entity_t DLLEXPORT *HUD_GetUserEntity( int index )
|
|||
return NULL;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
|
@ -13,6 +13,7 @@
|
|||
*
|
||||
****/
|
||||
// shared event functions
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "const.h"
|
||||
|
@ -25,7 +26,7 @@
|
|||
#include "event_api.h"
|
||||
#include "pm_shared.h"
|
||||
|
||||
#define IS_FIRSTPERSON_SPEC ( g_iUser1 == OBS_IN_EYE || (g_iUser1 && (gHUD.m_Spectator.m_pip->value == INSET_IN_EYE)) )
|
||||
#define IS_FIRSTPERSON_SPEC ( g_iUser1 == OBS_IN_EYE || ( g_iUser1 && ( gHUD.m_Spectator.m_pip->value == INSET_IN_EYE ) ) )
|
||||
/*
|
||||
=================
|
||||
GetEntity
|
||||
|
@ -71,7 +72,7 @@ Is the entity's index in the player range?
|
|||
*/
|
||||
qboolean EV_IsPlayer( int idx )
|
||||
{
|
||||
if ( idx >= 1 && idx <= gEngfuncs.GetMaxClients() )
|
||||
if( idx >= 1 && idx <= gEngfuncs.GetMaxClients() )
|
||||
return true;
|
||||
|
||||
return false;
|
||||
|
@ -87,8 +88,8 @@ Is the entity == the local player
|
|||
qboolean EV_IsLocal( int idx )
|
||||
{
|
||||
// check if we are in some way in first person spec mode
|
||||
if ( IS_FIRSTPERSON_SPEC )
|
||||
return (g_iUser2 == idx);
|
||||
if( IS_FIRSTPERSON_SPEC )
|
||||
return ( g_iUser2 == idx );
|
||||
else
|
||||
return gEngfuncs.pEventAPI->EV_IsLocal( idx - 1 ) ? true : false;
|
||||
}
|
||||
|
@ -110,15 +111,15 @@ void EV_GetGunPosition( event_args_t *args, float *pos, float *origin )
|
|||
VectorClear( view_ofs );
|
||||
view_ofs[2] = DEFAULT_VIEWHEIGHT;
|
||||
|
||||
if ( EV_IsPlayer( idx ) )
|
||||
if( EV_IsPlayer( idx ) )
|
||||
{
|
||||
// in spec mode use entity viewheigh, not own
|
||||
if ( EV_IsLocal( idx ) && !IS_FIRSTPERSON_SPEC )
|
||||
if( EV_IsLocal( idx ) && !IS_FIRSTPERSON_SPEC )
|
||||
{
|
||||
// Grab predicted result for local player
|
||||
gEngfuncs.pEventAPI->EV_LocalPlayerViewheight( view_ofs );
|
||||
}
|
||||
else if ( args->ducking == 1 )
|
||||
else if( args->ducking == 1 )
|
||||
{
|
||||
view_ofs[2] = VEC_DUCK_VIEW;
|
||||
}
|
||||
|
@ -162,13 +163,13 @@ void EV_GetDefaultShellInfo( event_args_t *args, float *origin, float *velocity,
|
|||
VectorClear( view_ofs );
|
||||
view_ofs[2] = DEFAULT_VIEWHEIGHT;
|
||||
|
||||
if ( EV_IsPlayer( idx ) )
|
||||
if( EV_IsPlayer( idx ) )
|
||||
{
|
||||
if ( EV_IsLocal( idx ) )
|
||||
if( EV_IsLocal( idx ) )
|
||||
{
|
||||
gEngfuncs.pEventAPI->EV_LocalPlayerViewheight( view_ofs );
|
||||
}
|
||||
else if ( args->ducking == 1 )
|
||||
else if( args->ducking == 1 )
|
||||
{
|
||||
view_ofs[2] = VEC_DUCK_VIEW;
|
||||
}
|
||||
|
@ -177,10 +178,10 @@ void EV_GetDefaultShellInfo( event_args_t *args, float *origin, float *velocity,
|
|||
fR = gEngfuncs.pfnRandomFloat( 50, 70 );
|
||||
fU = gEngfuncs.pfnRandomFloat( 100, 150 );
|
||||
|
||||
for ( i = 0; i < 3; i++ )
|
||||
for( i = 0; i < 3; i++ )
|
||||
{
|
||||
ShellVelocity[i] = velocity[i] + right[i] * fR + up[i] * fU + forward[i] * 25;
|
||||
ShellOrigin[i] = origin[i] + view_ofs[i] + up[i] * upScale + forward[i] * forwardScale + right[i] * rightScale;
|
||||
ShellOrigin[i] = origin[i] + view_ofs[i] + up[i] * upScale + forward[i] * forwardScale + right[i] * rightScale;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -195,11 +196,11 @@ void EV_MuzzleFlash( void )
|
|||
{
|
||||
// Add muzzle flash to current weapon model
|
||||
cl_entity_t *ent = GetViewEntity();
|
||||
if ( !ent )
|
||||
if( !ent )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Or in the muzzle flash
|
||||
ent->curstate.effects |= EF_MUZZLEFLASH;
|
||||
}
|
||||
}
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -20,10 +20,11 @@ typedef enum
|
|||
|
||||
BULLET_MONSTER_9MM,
|
||||
BULLET_MONSTER_MP5,
|
||||
BULLET_MONSTER_12MM,
|
||||
} Bullet;
|
||||
BULLET_MONSTER_12MM
|
||||
}Bullet;
|
||||
|
||||
enum glock_e {
|
||||
enum glock_e
|
||||
{
|
||||
GLOCK_IDLE1 = 0,
|
||||
GLOCK_IDLE2,
|
||||
GLOCK_IDLE3,
|
||||
|
@ -36,7 +37,8 @@ enum glock_e {
|
|||
GLOCK_ADD_SILENCER
|
||||
};
|
||||
|
||||
enum shotgun_e {
|
||||
enum shotgun_e
|
||||
{
|
||||
SHOTGUN_IDLE = 0,
|
||||
SHOTGUN_FIRE,
|
||||
SHOTGUN_FIRE2,
|
||||
|
@ -58,10 +60,11 @@ enum mp5_e
|
|||
MP5_DEPLOY,
|
||||
MP5_FIRE1,
|
||||
MP5_FIRE2,
|
||||
MP5_FIRE3,
|
||||
MP5_FIRE3
|
||||
};
|
||||
|
||||
enum python_e {
|
||||
enum python_e
|
||||
{
|
||||
PYTHON_IDLE1 = 0,
|
||||
PYTHON_FIDGET,
|
||||
PYTHON_FIRE1,
|
||||
|
@ -75,7 +78,8 @@ enum python_e {
|
|||
#define GAUSS_PRIMARY_CHARGE_VOLUME 256// how loud gauss is while charging
|
||||
#define GAUSS_PRIMARY_FIRE_VOLUME 450// how loud gauss is when discharged
|
||||
|
||||
enum gauss_e {
|
||||
enum gauss_e
|
||||
{
|
||||
GAUSS_IDLE = 0,
|
||||
GAUSS_IDLE2,
|
||||
GAUSS_FIDGET,
|
||||
|
@ -91,5 +95,4 @@ void EV_HLDM_GunshotDecalTrace( pmtrace_t *pTrace, char *decalName );
|
|||
void EV_HLDM_DecalGunshot( pmtrace_t *pTrace, int iBulletType );
|
||||
int EV_HLDM_CheckTracer( int idx, float *vecSrc, float *end, float *forward, float *right, int iBulletType, int iTracerFreq, int *tracerCount );
|
||||
void EV_HLDM_FireBullets( int idx, float *forward, float *right, float *up, int cShots, float *vecSrc, float *vecDirShooting, float flDistance, int iBulletType, int iTracerFreq, int *tracerCount, float flSpreadX, float flSpreadY );
|
||||
|
||||
#endif // EV_HLDMH
|
||||
#endif // EV_HLDMH
|
||||
|
|
|
@ -15,49 +15,6 @@
|
|||
|
||||
#define FTENT_FADEOUT 0x00000080
|
||||
|
||||
#define DMG_GENERIC 0 // generic damage was done
|
||||
#define DMG_CRUSH (1 << 0) // crushed by falling or moving object
|
||||
#define DMG_BULLET (1 << 1) // shot
|
||||
#define DMG_SLASH (1 << 2) // cut, clawed, stabbed
|
||||
#define DMG_BURN (1 << 3) // heat burned
|
||||
#define DMG_FREEZE (1 << 4) // frozen
|
||||
#define DMG_FALL (1 << 5) // fell too far
|
||||
#define DMG_BLAST (1 << 6) // explosive blast damage
|
||||
#define DMG_CLUB (1 << 7) // crowbar, punch, headbutt
|
||||
#define DMG_SHOCK (1 << 8) // electric shock
|
||||
#define DMG_SONIC (1 << 9) // sound pulse shockwave
|
||||
#define DMG_ENERGYBEAM (1 << 10) // laser or other high energy beam
|
||||
#define DMG_NEVERGIB (1 << 12) // with this bit OR'd in, no damage type will be able to gib victims upon death
|
||||
#define DMG_ALWAYSGIB (1 << 13) // with this bit OR'd in, any damage type can be made to gib victims upon death.
|
||||
|
||||
// time-based damage
|
||||
//mask off TF-specific stuff too
|
||||
#define DMG_TIMEBASED (~(0xff003fff)) // mask for time-based damage
|
||||
|
||||
#define DMG_DROWN (1 << 14) // Drowning
|
||||
#define DMG_FIRSTTIMEBASED DMG_DROWN
|
||||
|
||||
#define DMG_PARALYZE (1 << 15) // slows affected creature down
|
||||
#define DMG_NERVEGAS (1 << 16) // nerve toxins, very bad
|
||||
#define DMG_POISON (1 << 17) // blood poisioning
|
||||
#define DMG_RADIATION (1 << 18) // radiation exposure
|
||||
#define DMG_DROWNRECOVER (1 << 19) // drowning recovery
|
||||
#define DMG_ACID (1 << 20) // toxic chemicals or acid burns
|
||||
#define DMG_SLOWBURN (1 << 21) // in an oven
|
||||
#define DMG_SLOWFREEZE (1 << 22) // in a subzero freezer
|
||||
#define DMG_MORTAR (1 << 23) // Hit by air raid (done to distinguish grenade from mortar)
|
||||
|
||||
//TF ADDITIONS
|
||||
#define DMG_IGNITE (1 << 24) // Players hit by this begin to burn
|
||||
#define DMG_RADIUS_MAX (1 << 25) // Radius damage with this flag doesn't decrease over distance
|
||||
#define DMG_RADIUS_QUAKE (1 << 26) // Radius damage is done like Quake. 1/2 damage at 1/2 radius.
|
||||
#define DMG_IGNOREARMOR (1 << 27) // Damage ignores target's armor
|
||||
#define DMG_AIMED (1 << 28) // Does Hit location damage
|
||||
#define DMG_WALLPIERCING (1 << 29) // Blast Damages ents through walls
|
||||
|
||||
#define DMG_CALTROP (1<<30)
|
||||
#define DMG_HALLUC (1<<31)
|
||||
|
||||
// Some of these are HL/TFC specific?
|
||||
void EV_EjectBrass( float *origin, float *velocity, float rotation, int model, int soundtype );
|
||||
void EV_GetGunPosition( struct event_args_s *args, float *pos, float *origin );
|
||||
|
@ -69,5 +26,4 @@ void EV_CreateTracer( float *start, float *end );
|
|||
struct cl_entity_s *GetEntity( int idx );
|
||||
struct cl_entity_s *GetViewEntity( void );
|
||||
void EV_MuzzleFlash( void );
|
||||
|
||||
#endif // EVENTSCRIPTSH
|
||||
|
|
|
@ -25,76 +25,71 @@
|
|||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
|
||||
|
||||
DECLARE_MESSAGE(m_Flash, FlashBat)
|
||||
DECLARE_MESSAGE(m_Flash, Flashlight)
|
||||
DECLARE_MESSAGE( m_Flash, FlashBat )
|
||||
DECLARE_MESSAGE( m_Flash, Flashlight )
|
||||
|
||||
#define BAT_NAME "sprites/%d_Flashlight.spr"
|
||||
|
||||
int CHudFlashlight::Init(void)
|
||||
int CHudFlashlight::Init( void )
|
||||
{
|
||||
m_fFade = 0;
|
||||
m_fOn = 0;
|
||||
|
||||
HOOK_MESSAGE(Flashlight);
|
||||
HOOK_MESSAGE(FlashBat);
|
||||
HOOK_MESSAGE( Flashlight );
|
||||
HOOK_MESSAGE( FlashBat );
|
||||
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
|
||||
gHUD.AddHudElem(this);
|
||||
gHUD.AddHudElem( this );
|
||||
|
||||
return 1;
|
||||
};
|
||||
}
|
||||
|
||||
void CHudFlashlight::Reset(void)
|
||||
void CHudFlashlight::Reset( void )
|
||||
{
|
||||
m_fFade = 0;
|
||||
m_fOn = 0;
|
||||
}
|
||||
|
||||
int CHudFlashlight::VidInit(void)
|
||||
int CHudFlashlight::VidInit( void )
|
||||
{
|
||||
int HUD_flash_empty = gHUD.GetSpriteIndex( "flash_empty" );
|
||||
int HUD_flash_full = gHUD.GetSpriteIndex( "flash_full" );
|
||||
int HUD_flash_beam = gHUD.GetSpriteIndex( "flash_beam" );
|
||||
|
||||
m_hSprite1 = gHUD.GetSprite(HUD_flash_empty);
|
||||
m_hSprite2 = gHUD.GetSprite(HUD_flash_full);
|
||||
m_hBeam = gHUD.GetSprite(HUD_flash_beam);
|
||||
m_prc1 = &gHUD.GetSpriteRect(HUD_flash_empty);
|
||||
m_prc2 = &gHUD.GetSpriteRect(HUD_flash_full);
|
||||
m_hSprite1 = gHUD.GetSprite( HUD_flash_empty );
|
||||
m_hSprite2 = gHUD.GetSprite( HUD_flash_full );
|
||||
m_hBeam = gHUD.GetSprite( HUD_flash_beam );
|
||||
m_prc1 = &gHUD.GetSpriteRect( HUD_flash_empty );
|
||||
m_prc2 = &gHUD.GetSpriteRect( HUD_flash_full );
|
||||
m_prcBeam = &gHUD.GetSpriteRect(HUD_flash_beam);
|
||||
m_iWidth = m_prc2->right - m_prc2->left;
|
||||
|
||||
return 1;
|
||||
};
|
||||
}
|
||||
|
||||
int CHudFlashlight:: MsgFunc_FlashBat(const char *pszName, int iSize, void *pbuf )
|
||||
int CHudFlashlight::MsgFunc_FlashBat( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
|
||||
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
int x = READ_BYTE();
|
||||
m_iBat = x;
|
||||
m_flBat = ((float)x)/100.0;
|
||||
m_flBat = ( (float)x ) / 100.0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudFlashlight:: MsgFunc_Flashlight(const char *pszName, int iSize, void *pbuf )
|
||||
int CHudFlashlight::MsgFunc_Flashlight( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
m_fOn = READ_BYTE();
|
||||
int x = READ_BYTE();
|
||||
m_iBat = x;
|
||||
m_flBat = ((float)x)/100.0;
|
||||
m_flBat = ( (float)x ) / 100.0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudFlashlight::Draw(float flTime)
|
||||
int CHudFlashlight::Draw( float flTime )
|
||||
{
|
||||
static bool show = ( gHUD.m_iHideHUDDisplay & ( HIDEHUD_FLASHLIGHT | HIDEHUD_ALL ) );
|
||||
if( show != !( gHUD.m_iHideHUDDisplay & ( HIDEHUD_FLASHLIGHT | HIDEHUD_ALL ) ) )
|
||||
|
@ -105,54 +100,54 @@ int CHudFlashlight::Draw(float flTime)
|
|||
gMobileEngfuncs->pfnTouchHideButtons( "flashlight", !show );
|
||||
}
|
||||
}
|
||||
if ( !show )
|
||||
if( !show )
|
||||
return 1;
|
||||
|
||||
int r, g, b, x, y, a;
|
||||
wrect_t rc;
|
||||
|
||||
if (!(gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT)) ))
|
||||
if( !( gHUD.m_iWeaponBits & ( 1 << ( WEAPON_SUIT ) ) ) )
|
||||
return 1;
|
||||
|
||||
if (m_fOn)
|
||||
if( m_fOn )
|
||||
a = 225;
|
||||
else
|
||||
a = MIN_ALPHA;
|
||||
|
||||
if (m_flBat < 0.20)
|
||||
UnpackRGB(r,g,b, RGB_REDISH);
|
||||
if( m_flBat < 0.20 )
|
||||
UnpackRGB( r,g,b, RGB_REDISH );
|
||||
else
|
||||
UnpackRGB(r,g,b, RGB_YELLOWISH);
|
||||
UnpackRGB( r,g,b, RGB_YELLOWISH );
|
||||
|
||||
ScaleColors(r, g, b, a);
|
||||
ScaleColors( r, g, b, a );
|
||||
|
||||
y = (m_prc1->bottom - m_prc2->top)/2;
|
||||
x = ScreenWidth - m_iWidth - m_iWidth/2 ;
|
||||
y = ( m_prc1->bottom - m_prc2->top ) / 2;
|
||||
x = ScreenWidth - m_iWidth - m_iWidth / 2 ;
|
||||
|
||||
// Draw the flashlight casing
|
||||
SPR_Set(m_hSprite1, r, g, b );
|
||||
SPR_DrawAdditive( 0, x, y, m_prc1);
|
||||
SPR_Set( m_hSprite1, r, g, b );
|
||||
SPR_DrawAdditive( 0, x, y, m_prc1 );
|
||||
|
||||
if ( m_fOn )
|
||||
{ // draw the flashlight beam
|
||||
x = ScreenWidth - m_iWidth/2;
|
||||
if( m_fOn )
|
||||
{
|
||||
// draw the flashlight beam
|
||||
x = ScreenWidth - m_iWidth / 2;
|
||||
|
||||
SPR_Set( m_hBeam, r, g, b );
|
||||
SPR_DrawAdditive( 0, x, y, m_prcBeam );
|
||||
}
|
||||
|
||||
// draw the flashlight energy level
|
||||
x = ScreenWidth - m_iWidth - m_iWidth/2 ;
|
||||
int iOffset = m_iWidth * (1.0 - m_flBat);
|
||||
if (iOffset < m_iWidth)
|
||||
x = ScreenWidth - m_iWidth - m_iWidth / 2;
|
||||
int iOffset = m_iWidth * ( 1.0 - m_flBat );
|
||||
if( iOffset < m_iWidth )
|
||||
{
|
||||
rc = *m_prc2;
|
||||
rc.left += iOffset;
|
||||
|
||||
SPR_Set(m_hSprite2, r, g, b );
|
||||
SPR_DrawAdditive( 0, x + iOffset, y, &rc);
|
||||
SPR_Set( m_hSprite2, r, g, b );
|
||||
SPR_DrawAdditive( 0, x + iOffset, y, &rc );
|
||||
}
|
||||
|
||||
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -26,28 +26,28 @@
|
|||
|
||||
#include "parsemsg.h"
|
||||
|
||||
DECLARE_MESSAGE(m_Geiger, Geiger )
|
||||
DECLARE_MESSAGE( m_Geiger, Geiger )
|
||||
|
||||
int CHudGeiger::Init(void)
|
||||
int CHudGeiger::Init( void )
|
||||
{
|
||||
HOOK_MESSAGE( Geiger );
|
||||
|
||||
m_iGeigerRange = 0;
|
||||
m_iFlags = 0;
|
||||
|
||||
gHUD.AddHudElem(this);
|
||||
gHUD.AddHudElem( this );
|
||||
|
||||
srand( (unsigned)time( NULL ) );
|
||||
|
||||
return 1;
|
||||
};
|
||||
}
|
||||
|
||||
int CHudGeiger::VidInit(void)
|
||||
int CHudGeiger::VidInit( void )
|
||||
{
|
||||
return 1;
|
||||
};
|
||||
}
|
||||
|
||||
int CHudGeiger::MsgFunc_Geiger(const char *pszName, int iSize, void *pbuf)
|
||||
int CHudGeiger::MsgFunc_Geiger( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
@ -55,101 +55,101 @@ int CHudGeiger::MsgFunc_Geiger(const char *pszName, int iSize, void *pbuf)
|
|||
// update geiger data
|
||||
m_iGeigerRange = READ_BYTE();
|
||||
m_iGeigerRange = m_iGeigerRange << 2;
|
||||
|
||||
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudGeiger::Draw (float flTime)
|
||||
int CHudGeiger::Draw( float flTime )
|
||||
{
|
||||
int pct;
|
||||
float flvol = 0.0f;
|
||||
int rg[3];
|
||||
int i;
|
||||
|
||||
if (m_iGeigerRange < 1000 && m_iGeigerRange > 0)
|
||||
|
||||
if( m_iGeigerRange < 1000 && m_iGeigerRange > 0 )
|
||||
{
|
||||
// peicewise linear is better than continuous formula for this
|
||||
if (m_iGeigerRange > 800)
|
||||
if( m_iGeigerRange > 800 )
|
||||
{
|
||||
pct = 0; //Con_Printf ( "range > 800\n");
|
||||
pct = 0; //Con_Printf( "range > 800\n" );
|
||||
}
|
||||
else if (m_iGeigerRange > 600)
|
||||
else if( m_iGeigerRange > 600 )
|
||||
{
|
||||
pct = 2;
|
||||
flvol = 0.4; //Con_Printf ( "range > 600\n");
|
||||
flvol = 0.4; //Con_Printf( "range > 600\n" );
|
||||
rg[0] = 1;
|
||||
rg[1] = 1;
|
||||
i = 2;
|
||||
}
|
||||
else if (m_iGeigerRange > 500)
|
||||
else if( m_iGeigerRange > 500 )
|
||||
{
|
||||
pct = 4;
|
||||
flvol = 0.5; //Con_Printf ( "range > 500\n");
|
||||
flvol = 0.5; //Con_Printf( "range > 500\n" );
|
||||
rg[0] = 1;
|
||||
rg[1] = 2;
|
||||
i = 2;
|
||||
}
|
||||
else if (m_iGeigerRange > 400)
|
||||
else if( m_iGeigerRange > 400 )
|
||||
{
|
||||
pct = 8;
|
||||
flvol = 0.6; //Con_Printf ( "range > 400\n");
|
||||
flvol = 0.6; //Con_Printf( "range > 400\n" );
|
||||
rg[0] = 1;
|
||||
rg[1] = 2;
|
||||
rg[2] = 3;
|
||||
i = 3;
|
||||
}
|
||||
else if (m_iGeigerRange > 300)
|
||||
else if( m_iGeigerRange > 300 )
|
||||
{
|
||||
pct = 8;
|
||||
flvol = 0.7; //Con_Printf ( "range > 300\n");
|
||||
flvol = 0.7; //Con_Printf( "range > 300\n" );
|
||||
rg[0] = 2;
|
||||
rg[1] = 3;
|
||||
rg[2] = 4;
|
||||
i = 3;
|
||||
}
|
||||
else if (m_iGeigerRange > 200)
|
||||
else if( m_iGeigerRange > 200 )
|
||||
{
|
||||
pct = 28;
|
||||
flvol = 0.78; //Con_Printf ( "range > 200\n");
|
||||
flvol = 0.78; //Con_Printf( "range > 200\n" );
|
||||
rg[0] = 2;
|
||||
rg[1] = 3;
|
||||
rg[2] = 4;
|
||||
i = 3;
|
||||
}
|
||||
else if (m_iGeigerRange > 150)
|
||||
else if( m_iGeigerRange > 150 )
|
||||
{
|
||||
pct = 40;
|
||||
flvol = 0.80; //Con_Printf ( "range > 150\n");
|
||||
flvol = 0.80; //Con_Printf( "range > 150\n" );
|
||||
rg[0] = 3;
|
||||
rg[1] = 4;
|
||||
rg[2] = 5;
|
||||
i = 3;
|
||||
}
|
||||
else if (m_iGeigerRange > 100)
|
||||
else if( m_iGeigerRange > 100 )
|
||||
{
|
||||
pct = 60;
|
||||
flvol = 0.85; //Con_Printf ( "range > 100\n");
|
||||
flvol = 0.85; //Con_Printf( "range > 100\n" );
|
||||
rg[0] = 3;
|
||||
rg[1] = 4;
|
||||
rg[2] = 5;
|
||||
i = 3;
|
||||
}
|
||||
else if (m_iGeigerRange > 75)
|
||||
else if( m_iGeigerRange > 75 )
|
||||
{
|
||||
pct = 80;
|
||||
flvol = 0.9; //Con_Printf ( "range > 75\n");
|
||||
flvol = 0.9; //Con_Printf( "range > 75\n" );
|
||||
//gflGeigerDelay = cl.time + GEIGERDELAY * 0.75;
|
||||
rg[0] = 4;
|
||||
rg[1] = 5;
|
||||
rg[2] = 6;
|
||||
i = 3;
|
||||
}
|
||||
else if (m_iGeigerRange > 50)
|
||||
else if( m_iGeigerRange > 50 )
|
||||
{
|
||||
pct = 90;
|
||||
flvol = 0.95; //Con_Printf ( "range > 50\n");
|
||||
flvol = 0.95; //Con_Printf( "range > 50\n" );
|
||||
rg[0] = 5;
|
||||
rg[1] = 6;
|
||||
i = 2;
|
||||
|
@ -157,26 +157,25 @@ int CHudGeiger::Draw (float flTime)
|
|||
else
|
||||
{
|
||||
pct = 95;
|
||||
flvol = 1.0; //Con_Printf ( "range < 50\n");
|
||||
flvol = 1.0; //Con_Printf( "range < 50\n" );
|
||||
rg[0] = 5;
|
||||
rg[1] = 6;
|
||||
i = 2;
|
||||
}
|
||||
|
||||
flvol = (flvol * ((rand() & 127)) / 255) + 0.25; // UTIL_RandomFloat(0.25, 0.5);
|
||||
flvol = ( flvol * ( (rand() & 127) ) / 255) + 0.25; // UTIL_RandomFloat(0.25, 0.5);
|
||||
|
||||
if ((rand() & 127) < pct || (rand() & 127) < pct)
|
||||
if( ( rand() & 127 ) < pct || ( rand() & 127 ) < pct )
|
||||
{
|
||||
//S_StartDynamicSound (-1, 0, rgsfx[rand() % i], r_origin, flvol, 1.0, 0, 100);
|
||||
//S_StartDynamicSound( -1, 0, rgsfx[rand() % i], r_origin, flvol, 1.0, 0, 100 );
|
||||
char sz[256];
|
||||
|
||||
|
||||
int j = rand() & 1;
|
||||
if (i > 2)
|
||||
if( i > 2 )
|
||||
j += rand() & 1;
|
||||
|
||||
sprintf(sz, "player/geiger%d.wav", j + 1);
|
||||
PlaySound(sz, flvol);
|
||||
|
||||
sprintf( sz, "player/geiger%d.wav", j + 1 );
|
||||
PlaySound( sz, flvol );
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -29,15 +29,15 @@
|
|||
|
||||
#include "mobility_int.h"
|
||||
|
||||
DECLARE_MESSAGE(m_Health, Health )
|
||||
DECLARE_MESSAGE(m_Health, Damage )
|
||||
DECLARE_MESSAGE( m_Health, Health )
|
||||
DECLARE_MESSAGE( m_Health, Damage )
|
||||
|
||||
#define PAIN_NAME "sprites/%d_pain.spr"
|
||||
#define DAMAGE_NAME "sprites/%d_dmg.spr"
|
||||
|
||||
int giDmgHeight, giDmgWidth;
|
||||
|
||||
int giDmgFlags[NUM_DMG_TYPES] =
|
||||
int giDmgFlags[NUM_DMG_TYPES] =
|
||||
{
|
||||
DMG_POISON,
|
||||
DMG_ACID,
|
||||
|
@ -53,10 +53,10 @@ int giDmgFlags[NUM_DMG_TYPES] =
|
|||
DMG_HALLUC
|
||||
};
|
||||
|
||||
int CHudHealth::Init(void)
|
||||
int CHudHealth::Init( void )
|
||||
{
|
||||
HOOK_MESSAGE(Health);
|
||||
HOOK_MESSAGE(Damage);
|
||||
HOOK_MESSAGE( Health );
|
||||
HOOK_MESSAGE( Damage );
|
||||
m_iHealth = 100;
|
||||
m_fFade = 0;
|
||||
m_iFlags = 0;
|
||||
|
@ -65,10 +65,9 @@ int CHudHealth::Init(void)
|
|||
giDmgHeight = 0;
|
||||
giDmgWidth = 0;
|
||||
|
||||
memset(m_dmg, 0, sizeof(DAMAGE_IMAGE) * NUM_DMG_TYPES);
|
||||
memset( m_dmg, 0, sizeof(DAMAGE_IMAGE) * NUM_DMG_TYPES );
|
||||
|
||||
|
||||
gHUD.AddHudElem(this);
|
||||
gHUD.AddHudElem( this );
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
@ -77,28 +76,28 @@ void CHudHealth::Reset( void )
|
|||
// make sure the pain compass is cleared when the player respawns
|
||||
m_fAttackFront = m_fAttackRear = m_fAttackRight = m_fAttackLeft = 0;
|
||||
|
||||
|
||||
// force all the flashing damage icons to expire
|
||||
m_bitsDamage = 0;
|
||||
for ( int i = 0; i < NUM_DMG_TYPES; i++ )
|
||||
for( int i = 0; i < NUM_DMG_TYPES; i++ )
|
||||
{
|
||||
m_dmg[i].fExpire = 0;
|
||||
}
|
||||
}
|
||||
|
||||
int CHudHealth::VidInit(void)
|
||||
int CHudHealth::VidInit( void )
|
||||
{
|
||||
m_hSprite = 0;
|
||||
|
||||
m_HUD_dmg_bio = gHUD.GetSpriteIndex( "dmg_bio" ) + 1;
|
||||
m_HUD_cross = gHUD.GetSpriteIndex( "cross" );
|
||||
|
||||
giDmgHeight = gHUD.GetSpriteRect(m_HUD_dmg_bio).right - gHUD.GetSpriteRect(m_HUD_dmg_bio).left;
|
||||
giDmgWidth = gHUD.GetSpriteRect(m_HUD_dmg_bio).bottom - gHUD.GetSpriteRect(m_HUD_dmg_bio).top;
|
||||
giDmgHeight = gHUD.GetSpriteRect( m_HUD_dmg_bio ).right - gHUD.GetSpriteRect( m_HUD_dmg_bio ).left;
|
||||
giDmgWidth = gHUD.GetSpriteRect( m_HUD_dmg_bio ).bottom - gHUD.GetSpriteRect( m_HUD_dmg_bio ).top;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudHealth:: MsgFunc_Health(const char *pszName, int iSize, void *pbuf )
|
||||
int CHudHealth::MsgFunc_Health( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
// TODO: update local health data
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
@ -107,7 +106,7 @@ int CHudHealth:: MsgFunc_Health(const char *pszName, int iSize, void *pbuf )
|
|||
m_iFlags |= HUD_ACTIVE;
|
||||
|
||||
// Only update the fade if we've changed health
|
||||
if (x != m_iHealth)
|
||||
if( x != m_iHealth )
|
||||
{
|
||||
m_fFade = FADE_TIME;
|
||||
m_iHealth = x;
|
||||
|
@ -116,8 +115,7 @@ int CHudHealth:: MsgFunc_Health(const char *pszName, int iSize, void *pbuf )
|
|||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int CHudHealth:: MsgFunc_Damage(const char *pszName, int iSize, void *pbuf )
|
||||
int CHudHealth::MsgFunc_Damage( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
|
@ -127,47 +125,47 @@ int CHudHealth:: MsgFunc_Damage(const char *pszName, int iSize, void *pbuf )
|
|||
|
||||
vec3_t vecFrom;
|
||||
|
||||
for ( int i = 0 ; i < 3 ; i++)
|
||||
for( int i = 0; i < 3; i++ )
|
||||
vecFrom[i] = READ_COORD();
|
||||
|
||||
UpdateTiles(gHUD.m_flTime, bitsDamage);
|
||||
UpdateTiles( gHUD.m_flTime, bitsDamage );
|
||||
|
||||
// Actually took damage?
|
||||
if ( damageTaken > 0 || armor > 0 )
|
||||
if( damageTaken > 0 || armor > 0 )
|
||||
{
|
||||
CalcDamageDirection(vecFrom);
|
||||
CalcDamageDirection( vecFrom );
|
||||
|
||||
if( gMobileEngfuncs && damageTaken > 0 )
|
||||
{
|
||||
float time = damageTaken * 4.0f;
|
||||
float time = damageTaken * 4.0f;
|
||||
|
||||
if( time > 200.0f ) time = 200.0f;
|
||||
gMobileEngfuncs->pfnVibrate( time, 0 );
|
||||
if( time > 200.0f )
|
||||
time = 200.0f;
|
||||
gMobileEngfuncs->pfnVibrate( time, 0 );
|
||||
}
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
// Returns back a color from the
|
||||
// Green <-> Yellow <-> Red ramp
|
||||
void CHudHealth::GetPainColor( int &r, int &g, int &b )
|
||||
{
|
||||
int iHealth = m_iHealth;
|
||||
|
||||
if (iHealth > 25)
|
||||
if( iHealth > 25 )
|
||||
iHealth -= 25;
|
||||
else if ( iHealth < 0 )
|
||||
else if( iHealth < 0 )
|
||||
iHealth = 0;
|
||||
#if 0
|
||||
g = iHealth * 255 / 100;
|
||||
r = 255 - g;
|
||||
b = 0;
|
||||
#else
|
||||
if (m_iHealth > 25)
|
||||
if( m_iHealth > 25 )
|
||||
{
|
||||
UnpackRGB(r,g,b, RGB_YELLOWISH);
|
||||
UnpackRGB( r, g, b, RGB_YELLOWISH );
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -175,135 +173,131 @@ void CHudHealth::GetPainColor( int &r, int &g, int &b )
|
|||
g = 0;
|
||||
b = 0;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
int CHudHealth::Draw(float flTime)
|
||||
int CHudHealth::Draw( float flTime )
|
||||
{
|
||||
int r, g, b;
|
||||
int a = 0, x, y;
|
||||
int HealthWidth;
|
||||
|
||||
if ( (gHUD.m_iHideHUDDisplay & HIDEHUD_HEALTH) || gEngfuncs.IsSpectateOnly() )
|
||||
if( ( gHUD.m_iHideHUDDisplay & HIDEHUD_HEALTH ) || gEngfuncs.IsSpectateOnly() )
|
||||
return 1;
|
||||
|
||||
if ( !m_hSprite )
|
||||
m_hSprite = LoadSprite(PAIN_NAME);
|
||||
|
||||
if( !m_hSprite )
|
||||
m_hSprite = LoadSprite( PAIN_NAME );
|
||||
|
||||
// Has health changed? Flash the health #
|
||||
if (m_fFade)
|
||||
if( m_fFade )
|
||||
{
|
||||
m_fFade -= (gHUD.m_flTimeDelta * 20);
|
||||
if (m_fFade <= 0)
|
||||
m_fFade -= ( gHUD.m_flTimeDelta * 20 );
|
||||
if( m_fFade <= 0 )
|
||||
{
|
||||
a = MIN_ALPHA;
|
||||
m_fFade = 0;
|
||||
}
|
||||
|
||||
// Fade the health number back to dim
|
||||
|
||||
a = MIN_ALPHA + (m_fFade/FADE_TIME) * 128;
|
||||
|
||||
a = MIN_ALPHA + ( m_fFade / FADE_TIME ) * 128;
|
||||
}
|
||||
else
|
||||
a = MIN_ALPHA;
|
||||
|
||||
// If health is getting low, make it bright red
|
||||
if (m_iHealth <= 15)
|
||||
if( m_iHealth <= 15 )
|
||||
a = 255;
|
||||
|
||||
|
||||
GetPainColor( r, g, b );
|
||||
ScaleColors(r, g, b, a );
|
||||
ScaleColors( r, g, b, a );
|
||||
|
||||
// Only draw health if we have the suit.
|
||||
if (gHUD.m_iWeaponBits & (1<<(WEAPON_SUIT)))
|
||||
if( gHUD.m_iWeaponBits & ( 1 << ( WEAPON_SUIT ) ) )
|
||||
{
|
||||
HealthWidth = gHUD.GetSpriteRect(gHUD.m_HUD_number_0).right - gHUD.GetSpriteRect(gHUD.m_HUD_number_0).left;
|
||||
int CrossWidth = gHUD.GetSpriteRect(m_HUD_cross).right - gHUD.GetSpriteRect(m_HUD_cross).left;
|
||||
HealthWidth = gHUD.GetSpriteRect( gHUD.m_HUD_number_0 ).right - gHUD.GetSpriteRect( gHUD.m_HUD_number_0 ).left;
|
||||
int CrossWidth = gHUD.GetSpriteRect( m_HUD_cross ).right - gHUD.GetSpriteRect( m_HUD_cross ).left;
|
||||
|
||||
y = ScreenHeight - gHUD.m_iFontHeight - gHUD.m_iFontHeight / 2;
|
||||
x = CrossWidth /2;
|
||||
x = CrossWidth / 2;
|
||||
|
||||
SPR_Set(gHUD.GetSprite(m_HUD_cross), r, g, b);
|
||||
SPR_DrawAdditive(0, x, y, &gHUD.GetSpriteRect(m_HUD_cross));
|
||||
SPR_Set( gHUD.GetSprite( m_HUD_cross ), r, g, b );
|
||||
SPR_DrawAdditive( 0, x, y, &gHUD.GetSpriteRect( m_HUD_cross ) );
|
||||
|
||||
x = CrossWidth + HealthWidth / 2;
|
||||
|
||||
x = gHUD.DrawHudNumber(x, y, DHN_3DIGITS | DHN_DRAWZERO, m_iHealth, r, g, b);
|
||||
x = gHUD.DrawHudNumber( x, y, DHN_3DIGITS | DHN_DRAWZERO, m_iHealth, r, g, b );
|
||||
|
||||
x += HealthWidth/2;
|
||||
x += HealthWidth / 2;
|
||||
|
||||
int iHeight = gHUD.m_iFontHeight;
|
||||
int iWidth = HealthWidth/10;
|
||||
FillRGBA(x, y, iWidth, iHeight, 255, 160, 0, a);
|
||||
int iWidth = HealthWidth / 10;
|
||||
FillRGBA( x, y, iWidth, iHeight, 255, 160, 0, a );
|
||||
}
|
||||
|
||||
DrawDamage(flTime);
|
||||
return DrawPain(flTime);
|
||||
DrawDamage( flTime );
|
||||
return DrawPain( flTime );
|
||||
}
|
||||
|
||||
void CHudHealth::CalcDamageDirection(vec3_t vecFrom)
|
||||
void CHudHealth::CalcDamageDirection( vec3_t vecFrom )
|
||||
{
|
||||
vec3_t forward, right, up;
|
||||
float side, front;
|
||||
vec3_t forward, right, up;
|
||||
float side, front;
|
||||
vec3_t vecOrigin, vecAngles;
|
||||
|
||||
if (!vecFrom[0] && !vecFrom[1] && !vecFrom[2])
|
||||
if( !vecFrom[0] && !vecFrom[1] && !vecFrom[2] )
|
||||
{
|
||||
m_fAttackFront = m_fAttackRear = m_fAttackRight = m_fAttackLeft = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
memcpy( vecOrigin, gHUD.m_vecOrigin, sizeof(vec3_t) );
|
||||
memcpy( vecAngles, gHUD.m_vecAngles, sizeof(vec3_t) );
|
||||
|
||||
memcpy(vecOrigin, gHUD.m_vecOrigin, sizeof(vec3_t));
|
||||
memcpy(vecAngles, gHUD.m_vecAngles, sizeof(vec3_t));
|
||||
|
||||
|
||||
VectorSubtract (vecFrom, vecOrigin, vecFrom);
|
||||
VectorSubtract( vecFrom, vecOrigin, vecFrom );
|
||||
|
||||
float flDistToTarget = vecFrom.Length();
|
||||
|
||||
vecFrom = vecFrom.Normalize();
|
||||
AngleVectors (vecAngles, forward, right, up);
|
||||
AngleVectors( vecAngles, forward, right, up );
|
||||
|
||||
front = DotProduct (vecFrom, right);
|
||||
side = DotProduct (vecFrom, forward);
|
||||
front = DotProduct( vecFrom, right );
|
||||
side = DotProduct( vecFrom, forward );
|
||||
|
||||
if (flDistToTarget <= 50)
|
||||
if( flDistToTarget <= 50 )
|
||||
{
|
||||
m_fAttackFront = m_fAttackRear = m_fAttackRight = m_fAttackLeft = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (side > 0)
|
||||
if( side > 0 )
|
||||
{
|
||||
if (side > 0.3)
|
||||
m_fAttackFront = max(m_fAttackFront, side);
|
||||
if( side > 0.3 )
|
||||
m_fAttackFront = max( m_fAttackFront, side );
|
||||
}
|
||||
else
|
||||
{
|
||||
float f = fabs(side);
|
||||
if (f > 0.3)
|
||||
m_fAttackRear = max(m_fAttackRear, f);
|
||||
float f = fabs( side );
|
||||
if( f > 0.3 )
|
||||
m_fAttackRear = max( m_fAttackRear, f );
|
||||
}
|
||||
|
||||
if (front > 0)
|
||||
if( front > 0 )
|
||||
{
|
||||
if (front > 0.3)
|
||||
m_fAttackRight = max(m_fAttackRight, front);
|
||||
if( front > 0.3 )
|
||||
m_fAttackRight = max( m_fAttackRight, front );
|
||||
}
|
||||
else
|
||||
{
|
||||
float f = fabs(front);
|
||||
if (f > 0.3)
|
||||
m_fAttackLeft = max(m_fAttackLeft, f);
|
||||
float f = fabs( front );
|
||||
if( f > 0.3 )
|
||||
m_fAttackLeft = max( m_fAttackLeft, f );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int CHudHealth::DrawPain(float flTime)
|
||||
int CHudHealth::DrawPain( float flTime )
|
||||
{
|
||||
if (!(m_fAttackFront || m_fAttackRear || m_fAttackLeft || m_fAttackRight))
|
||||
if( !( m_fAttackFront || m_fAttackRear || m_fAttackLeft || m_fAttackRight) )
|
||||
return 1;
|
||||
|
||||
int r, g, b;
|
||||
|
@ -313,60 +307,62 @@ int CHudHealth::DrawPain(float flTime)
|
|||
a = 255; // max brightness until then
|
||||
|
||||
float fFade = gHUD.m_flTimeDelta * 2;
|
||||
|
||||
// SPR_Draw top
|
||||
if (m_fAttackFront > 0.4)
|
||||
{
|
||||
GetPainColor(r,g,b);
|
||||
shade = a * max( m_fAttackFront, 0.5 );
|
||||
ScaleColors(r, g, b, shade);
|
||||
SPR_Set(m_hSprite, r, g, b );
|
||||
|
||||
x = ScreenWidth/2 - SPR_Width(m_hSprite, 0)/2;
|
||||
y = ScreenHeight/2 - SPR_Height(m_hSprite,0) * 3;
|
||||
SPR_DrawAdditive(0, x, y, NULL);
|
||||
// SPR_Draw top
|
||||
if( m_fAttackFront > 0.4 )
|
||||
{
|
||||
GetPainColor( r, g, b );
|
||||
shade = a * max( m_fAttackFront, 0.5 );
|
||||
ScaleColors( r, g, b, shade );
|
||||
SPR_Set( m_hSprite, r, g, b );
|
||||
|
||||
x = ScreenWidth / 2 - SPR_Width( m_hSprite, 0 ) / 2;
|
||||
y = ScreenHeight / 2 - SPR_Height( m_hSprite, 0 ) * 3;
|
||||
SPR_DrawAdditive( 0, x, y, NULL );
|
||||
m_fAttackFront = max( 0, m_fAttackFront - fFade );
|
||||
} else
|
||||
m_fAttackFront = 0;
|
||||
|
||||
if (m_fAttackRight > 0.4)
|
||||
if( m_fAttackRight > 0.4 )
|
||||
{
|
||||
GetPainColor(r,g,b);
|
||||
GetPainColor( r, g, b );
|
||||
shade = a * max( m_fAttackRight, 0.5 );
|
||||
ScaleColors(r, g, b, shade);
|
||||
SPR_Set(m_hSprite, r, g, b );
|
||||
ScaleColors( r, g, b, shade );
|
||||
SPR_Set( m_hSprite, r, g, b );
|
||||
|
||||
x = ScreenWidth/2 + SPR_Width(m_hSprite, 1) * 2;
|
||||
y = ScreenHeight/2 - SPR_Height(m_hSprite,1)/2;
|
||||
SPR_DrawAdditive(1, x, y, NULL);
|
||||
x = ScreenWidth / 2 + SPR_Width( m_hSprite, 1 ) * 2;
|
||||
y = ScreenHeight / 2 - SPR_Height( m_hSprite,1 ) / 2;
|
||||
SPR_DrawAdditive( 1, x, y, NULL );
|
||||
m_fAttackRight = max( 0, m_fAttackRight - fFade );
|
||||
} else
|
||||
}
|
||||
else
|
||||
m_fAttackRight = 0;
|
||||
|
||||
if (m_fAttackRear > 0.4)
|
||||
if( m_fAttackRear > 0.4 )
|
||||
{
|
||||
GetPainColor(r,g,b);
|
||||
GetPainColor( r, g, b );
|
||||
shade = a * max( m_fAttackRear, 0.5 );
|
||||
ScaleColors(r, g, b, shade);
|
||||
SPR_Set(m_hSprite, r, g, b );
|
||||
ScaleColors( r, g, b, shade );
|
||||
SPR_Set( m_hSprite, r, g, b );
|
||||
|
||||
x = ScreenWidth/2 - SPR_Width(m_hSprite, 2)/2;
|
||||
y = ScreenHeight/2 + SPR_Height(m_hSprite,2) * 2;
|
||||
SPR_DrawAdditive(2, x, y, NULL);
|
||||
x = ScreenWidth / 2 - SPR_Width( m_hSprite, 2 ) / 2;
|
||||
y = ScreenHeight / 2 + SPR_Height( m_hSprite, 2 ) * 2;
|
||||
SPR_DrawAdditive( 2, x, y, NULL );
|
||||
m_fAttackRear = max( 0, m_fAttackRear - fFade );
|
||||
} else
|
||||
}
|
||||
else
|
||||
m_fAttackRear = 0;
|
||||
|
||||
if (m_fAttackLeft > 0.4)
|
||||
if( m_fAttackLeft > 0.4 )
|
||||
{
|
||||
GetPainColor(r,g,b);
|
||||
GetPainColor( r, g, b );
|
||||
shade = a * max( m_fAttackLeft, 0.5 );
|
||||
ScaleColors(r, g, b, shade);
|
||||
SPR_Set(m_hSprite, r, g, b );
|
||||
ScaleColors( r, g, b, shade );
|
||||
SPR_Set( m_hSprite, r, g, b );
|
||||
|
||||
x = ScreenWidth/2 - SPR_Width(m_hSprite, 3) * 3;
|
||||
y = ScreenHeight/2 - SPR_Height(m_hSprite,3)/2;
|
||||
SPR_DrawAdditive(3, x, y, NULL);
|
||||
x = ScreenWidth / 2 - SPR_Width( m_hSprite, 3 ) * 3;
|
||||
y = ScreenHeight / 2 - SPR_Height( m_hSprite,3 ) / 2;
|
||||
SPR_DrawAdditive( 3, x, y, NULL );
|
||||
|
||||
m_fAttackLeft = max( 0, m_fAttackLeft - fFade );
|
||||
} else
|
||||
|
@ -375,42 +371,34 @@ int CHudHealth::DrawPain(float flTime)
|
|||
return 1;
|
||||
}
|
||||
|
||||
int CHudHealth::DrawDamage(float flTime)
|
||||
int CHudHealth::DrawDamage( float flTime )
|
||||
{
|
||||
int i, r, g, b, a;
|
||||
DAMAGE_IMAGE *pdmg;
|
||||
|
||||
if (!m_bitsDamage)
|
||||
if( !m_bitsDamage )
|
||||
return 1;
|
||||
|
||||
UnpackRGB(r,g,b, RGB_YELLOWISH);
|
||||
|
||||
a = (int)( fabs(sin(flTime*2)) * 256.0);
|
||||
UnpackRGB( r, g, b, RGB_YELLOWISH );
|
||||
|
||||
ScaleColors(r, g, b, a);
|
||||
|
||||
// Draw all the items
|
||||
for (i = 0; i < NUM_DMG_TYPES; i++)
|
||||
{
|
||||
if (m_bitsDamage & giDmgFlags[i])
|
||||
{
|
||||
pdmg = &m_dmg[i];
|
||||
SPR_Set(gHUD.GetSprite(m_HUD_dmg_bio + i), r, g, b );
|
||||
SPR_DrawAdditive(0, pdmg->x, pdmg->y, &gHUD.GetSpriteRect(m_HUD_dmg_bio + i));
|
||||
}
|
||||
}
|
||||
a = (int)( fabs( sin( flTime * 2 ) ) * 256.0 );
|
||||
|
||||
ScaleColors( r, g, b, a );
|
||||
|
||||
// check for bits that should be expired
|
||||
for ( i = 0; i < NUM_DMG_TYPES; i++ )
|
||||
for( i = 0; i < NUM_DMG_TYPES; i++ )
|
||||
{
|
||||
pdmg = &m_dmg[i];
|
||||
|
||||
if ( m_bitsDamage & giDmgFlags[i] )
|
||||
if( m_bitsDamage & giDmgFlags[i] )
|
||||
{
|
||||
pdmg = &m_dmg[i];
|
||||
|
||||
// Draw all the items
|
||||
SPR_Set( gHUD.GetSprite( m_HUD_dmg_bio + i ), r, g, b );
|
||||
SPR_DrawAdditive( 0, pdmg->x, pdmg->y, &gHUD.GetSpriteRect( m_HUD_dmg_bio + i ) );
|
||||
|
||||
pdmg->fExpire = min( flTime + DMG_IMAGE_LIFE, pdmg->fExpire );
|
||||
|
||||
if ( pdmg->fExpire <= flTime // when the time has expired
|
||||
if( pdmg->fExpire <= flTime // when the time has expired
|
||||
&& a < 40 ) // and the flash is at the low point of the cycle
|
||||
{
|
||||
pdmg->fExpire = 0;
|
||||
|
@ -419,10 +407,10 @@ int CHudHealth::DrawDamage(float flTime)
|
|||
pdmg->x = pdmg->y = 0;
|
||||
|
||||
// move everyone above down
|
||||
for (int j = 0; j < NUM_DMG_TYPES; j++)
|
||||
for( int j = 0; j < NUM_DMG_TYPES; j++ )
|
||||
{
|
||||
pdmg = &m_dmg[j];
|
||||
if ((pdmg->y) && (pdmg->y < y))
|
||||
if( ( pdmg->y ) && ( pdmg->y < y ) )
|
||||
pdmg->y += giDmgHeight;
|
||||
|
||||
}
|
||||
|
@ -434,49 +422,47 @@ int CHudHealth::DrawDamage(float flTime)
|
|||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
void CHudHealth::UpdateTiles(float flTime, long bitsDamage)
|
||||
void CHudHealth::UpdateTiles( float flTime, long bitsDamage )
|
||||
{
|
||||
DAMAGE_IMAGE *pdmg;
|
||||
|
||||
// Which types are new?
|
||||
long bitsOn = ~m_bitsDamage & bitsDamage;
|
||||
|
||||
for (int i = 0; i < NUM_DMG_TYPES; i++)
|
||||
|
||||
for( int i = 0; i < NUM_DMG_TYPES; i++ )
|
||||
{
|
||||
pdmg = &m_dmg[i];
|
||||
|
||||
// Is this one already on?
|
||||
if (m_bitsDamage & giDmgFlags[i])
|
||||
if( m_bitsDamage & giDmgFlags[i] )
|
||||
{
|
||||
pdmg->fExpire = flTime + DMG_IMAGE_LIFE; // extend the duration
|
||||
if (!pdmg->fBaseline)
|
||||
if( !pdmg->fBaseline )
|
||||
pdmg->fBaseline = flTime;
|
||||
}
|
||||
|
||||
// Are we just turning it on?
|
||||
if (bitsOn & giDmgFlags[i])
|
||||
if( bitsOn & giDmgFlags[i] )
|
||||
{
|
||||
// put this one at the bottom
|
||||
pdmg->x = giDmgWidth/8;
|
||||
pdmg->x = giDmgWidth / 8;
|
||||
pdmg->y = ScreenHeight - giDmgHeight * 2;
|
||||
pdmg->fExpire=flTime + DMG_IMAGE_LIFE;
|
||||
|
||||
|
||||
// move everyone else up
|
||||
for (int j = 0; j < NUM_DMG_TYPES; j++)
|
||||
for( int j = 0; j < NUM_DMG_TYPES; j++ )
|
||||
{
|
||||
if (j == i)
|
||||
if( j == i )
|
||||
continue;
|
||||
|
||||
pdmg = &m_dmg[j];
|
||||
if (pdmg->y)
|
||||
if( pdmg->y )
|
||||
pdmg->y -= giDmgHeight;
|
||||
|
||||
}
|
||||
pdmg = &m_dmg[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// damage bits are only turned on here; they are turned off when the draw time has expired (in DrawDamage())
|
||||
m_bitsDamage |= bitsDamage;
|
||||
|
|
|
@ -23,6 +23,7 @@
|
|||
#define DMG_IMAGE_NERVE 5
|
||||
#define DMG_IMAGE_RAD 6
|
||||
#define DMG_IMAGE_SHOCK 7
|
||||
|
||||
//tf defines
|
||||
#define DMG_IMAGE_CALTROP 8
|
||||
#define DMG_IMAGE_TRANQ 9
|
||||
|
@ -46,12 +47,10 @@
|
|||
#define DMG_NEVERGIB (1 << 12) // with this bit OR'd in, no damage type will be able to gib victims upon death
|
||||
#define DMG_ALWAYSGIB (1 << 13) // with this bit OR'd in, any damage type can be made to gib victims upon death.
|
||||
|
||||
|
||||
// time-based damage
|
||||
//mask off TF-specific stuff too
|
||||
#define DMG_TIMEBASED (~(0xff003fff)) // mask for time-based damage
|
||||
|
||||
|
||||
#define DMG_DROWN (1 << 14) // Drowning
|
||||
#define DMG_FIRSTTIMEBASED DMG_DROWN
|
||||
|
||||
|
@ -78,35 +77,33 @@
|
|||
|
||||
// TF Healing Additions for TakeHealth
|
||||
#define DMG_IGNORE_MAXHEALTH DMG_IGNITE
|
||||
|
||||
// TF Redefines since we never use the originals
|
||||
#define DMG_NAIL DMG_SLASH
|
||||
#define DMG_NOT_SELF DMG_FREEZE
|
||||
|
||||
|
||||
#define DMG_TRANQ DMG_MORTAR
|
||||
#define DMG_CONCUSS DMG_SONIC
|
||||
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
float fExpire;
|
||||
float fBaseline;
|
||||
int x, y;
|
||||
} DAMAGE_IMAGE;
|
||||
}DAMAGE_IMAGE;
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
class CHudHealth: public CHudBase
|
||||
class CHudHealth : public CHudBase
|
||||
{
|
||||
public:
|
||||
virtual int Init( void );
|
||||
virtual int VidInit( void );
|
||||
virtual int Draw(float fTime);
|
||||
virtual int Draw( float fTime );
|
||||
virtual void Reset( void );
|
||||
int MsgFunc_Health(const char *pszName, int iSize, void *pbuf);
|
||||
int MsgFunc_Damage(const char *pszName, int iSize, void *pbuf);
|
||||
int MsgFunc_Health( const char *pszName, int iSize, void *pbuf );
|
||||
int MsgFunc_Damage( const char *pszName, int iSize, void *pbuf );
|
||||
int m_iHealth;
|
||||
int m_HUD_dmg_bio;
|
||||
int m_HUD_cross;
|
||||
|
@ -119,9 +116,9 @@ private:
|
|||
HSPRITE m_hDamage;
|
||||
|
||||
DAMAGE_IMAGE m_dmg[NUM_DMG_TYPES];
|
||||
int m_bitsDamage;
|
||||
int DrawPain(float fTime);
|
||||
int DrawDamage(float fTime);
|
||||
void CalcDamageDirection(vec3_t vecFrom);
|
||||
void UpdateTiles(float fTime, long bits);
|
||||
};
|
||||
int m_bitsDamage;
|
||||
int DrawPain( float fTime );
|
||||
int DrawDamage( float fTime );
|
||||
void CalcDamageDirection( vec3_t vecFrom );
|
||||
void UpdateTiles( float fTime, long bits );
|
||||
};
|
||||
|
|
|
@ -21,6 +21,7 @@ This file contains "stubs" of class member implementations so that we can predic
|
|||
add in the functionality you need.
|
||||
==========================
|
||||
*/
|
||||
|
||||
#include "extdll.h"
|
||||
#include "util.h"
|
||||
#include "cbase.h"
|
||||
|
@ -34,30 +35,30 @@ This file contains "stubs" of class member implementations so that we can predic
|
|||
const Vector g_vecZero = Vector( 0, 0, 0 );
|
||||
int gmsgWeapPickup = 0;
|
||||
enginefuncs_t g_engfuncs;
|
||||
globalvars_t *gpGlobals;
|
||||
globalvars_t *gpGlobals;
|
||||
|
||||
ItemInfo CBasePlayerItem::ItemInfoArray[MAX_WEAPONS];
|
||||
|
||||
void EMIT_SOUND_DYN(edict_t *entity, int channel, const char *sample, float volume, float attenuation, int flags, int pitch) { }
|
||||
void EMIT_SOUND_DYN( edict_t *entity, int channel, const char *sample, float volume, float attenuation, int flags, int pitch ) { }
|
||||
|
||||
// CBaseEntity Stubs
|
||||
int CBaseEntity :: TakeHealth( float flHealth, int bitsDamageType ) { return 1; }
|
||||
int CBaseEntity :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType ) { return 1; }
|
||||
int CBaseEntity::TakeHealth( float flHealth, int bitsDamageType ) { return 1; }
|
||||
int CBaseEntity::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType ) { return 1; }
|
||||
CBaseEntity *CBaseEntity::GetNextTarget( void ) { return NULL; }
|
||||
int CBaseEntity::Save( CSave &save ) { return 1; }
|
||||
int CBaseEntity::Restore( CRestore &restore ) { return 1; }
|
||||
void CBaseEntity::SetObjectCollisionBox( void ) { }
|
||||
int CBaseEntity :: Intersects( CBaseEntity *pOther ) { return 0; }
|
||||
void CBaseEntity :: MakeDormant( void ) { }
|
||||
int CBaseEntity :: IsDormant( void ) { return 0; }
|
||||
BOOL CBaseEntity :: IsInWorld( void ) { return TRUE; }
|
||||
int CBaseEntity::Intersects( CBaseEntity *pOther ) { return 0; }
|
||||
void CBaseEntity::MakeDormant( void ) { }
|
||||
int CBaseEntity::IsDormant( void ) { return 0; }
|
||||
BOOL CBaseEntity::IsInWorld( void ) { return TRUE; }
|
||||
int CBaseEntity::ShouldToggle( USE_TYPE useType, BOOL currentState ) { return 0; }
|
||||
int CBaseEntity :: DamageDecal( int bitsDamageType ) { return -1; }
|
||||
CBaseEntity * CBaseEntity::Create( char *szName, const Vector &vecOrigin, const Vector &vecAngles, edict_t *pentOwner ) { return NULL; }
|
||||
int CBaseEntity::DamageDecal( int bitsDamageType ) { return -1; }
|
||||
CBaseEntity *CBaseEntity::Create( char *szName, const Vector &vecOrigin, const Vector &vecAngles, edict_t *pentOwner ) { return NULL; }
|
||||
void CBaseEntity::SUB_Remove( void ) { }
|
||||
|
||||
// CBaseDelay Stubs
|
||||
void CBaseDelay :: KeyValue( struct KeyValueData_s * ) { }
|
||||
void CBaseDelay::KeyValue( struct KeyValueData_s * ) { }
|
||||
int CBaseDelay::Restore( class CRestore & ) { return 1; }
|
||||
int CBaseDelay::Save( class CSave & ) { return 1; }
|
||||
|
||||
|
@ -67,7 +68,7 @@ int CBaseAnimating::Save( class CSave & ) { return 1; }
|
|||
|
||||
// DEBUG Stubs
|
||||
edict_t *DBG_EntOfVars( const entvars_t *pev ) { return NULL; }
|
||||
void DBG_AssertFunction(BOOL fExpr, const char* szExpr, const char* szFile, int szLine, const char* szMessage) { }
|
||||
void DBG_AssertFunction( BOOL fExpr, const char *szExpr, const char *szFile, int szLine, const char *szMessage) { }
|
||||
|
||||
// UTIL_* Stubs
|
||||
void UTIL_PrecacheOther( const char *szClassname ) { }
|
||||
|
@ -85,7 +86,7 @@ void ClientPrint( entvars_t *client, int msg_dest, const char *msg_name, const c
|
|||
// CBaseToggle Stubs
|
||||
int CBaseToggle::Restore( class CRestore & ) { return 1; }
|
||||
int CBaseToggle::Save( class CSave & ) { return 1; }
|
||||
void CBaseToggle :: KeyValue( struct KeyValueData_s * ) { }
|
||||
void CBaseToggle::KeyValue( struct KeyValueData_s * ) { }
|
||||
|
||||
// CGrenade Stubs
|
||||
void CGrenade::BounceSound( void ) { }
|
||||
|
@ -93,12 +94,12 @@ void CGrenade::Explode( Vector, Vector ) { }
|
|||
void CGrenade::Explode( TraceResult *, int ) { }
|
||||
void CGrenade::Killed( entvars_t *, int ) { }
|
||||
void CGrenade::Spawn( void ) { }
|
||||
CGrenade * CGrenade:: ShootTimed( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity, float time ){ return 0; }
|
||||
CGrenade *CGrenade::ShootTimed( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity, float time ){ return 0; }
|
||||
CGrenade *CGrenade::ShootContact( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity ){ return 0; }
|
||||
void CGrenade::DetonateUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ){ }
|
||||
|
||||
void UTIL_Remove( CBaseEntity *pEntity ){ }
|
||||
struct skilldata_t gSkillData;
|
||||
struct skilldata_t gSkillData;
|
||||
void UTIL_SetSize( entvars_t *pev, const Vector &vecMin, const Vector &vecMax ){ }
|
||||
CBaseEntity *UTIL_FindEntityInSphere( CBaseEntity *pStartEntity, const Vector &vecCenter, float flRadius ){ return 0;}
|
||||
|
||||
|
@ -108,140 +109,139 @@ void CBeam::PointEntInit( const Vector &start, int endIndex ) { }
|
|||
CBeam *CBeam::BeamCreate( const char *pSpriteName, int width ) { return NULL; }
|
||||
void CSprite::Expand( float scaleSpeed, float fadeSpeed ) { }
|
||||
|
||||
|
||||
CBaseEntity* CBaseMonster :: CheckTraceHullAttack( float flDist, int iDamage, int iDmgType ) { return NULL; }
|
||||
void CBaseMonster :: Eat ( float flFullDuration ) { }
|
||||
BOOL CBaseMonster :: FShouldEat ( void ) { return TRUE; }
|
||||
void CBaseMonster :: BarnacleVictimBitten ( entvars_t *pevBarnacle ) { }
|
||||
void CBaseMonster :: BarnacleVictimReleased ( void ) { }
|
||||
void CBaseMonster :: Listen ( void ) { }
|
||||
float CBaseMonster :: FLSoundVolume ( CSound *pSound ) { return 0.0; }
|
||||
BOOL CBaseMonster :: FValidateHintType ( short sHint ) { return FALSE; }
|
||||
void CBaseMonster :: Look ( int iDistance ) { }
|
||||
int CBaseMonster :: ISoundMask ( void ) { return 0; }
|
||||
CSound* CBaseMonster :: PBestSound ( void ) { return NULL; }
|
||||
CSound* CBaseMonster :: PBestScent ( void ) { return NULL; }
|
||||
float CBaseAnimating :: StudioFrameAdvance ( float flInterval ) { return 0.0; }
|
||||
void CBaseMonster :: MonsterThink ( void ) { }
|
||||
void CBaseMonster :: MonsterUse ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { }
|
||||
int CBaseMonster :: IgnoreConditions ( void ) { return 0; }
|
||||
void CBaseMonster :: RouteClear ( void ) { }
|
||||
void CBaseMonster :: RouteNew ( void ) { }
|
||||
BOOL CBaseMonster :: FRouteClear ( void ) { return FALSE; }
|
||||
BOOL CBaseMonster :: FRefreshRoute ( void ) { return 0; }
|
||||
CBaseEntity* CBaseMonster::CheckTraceHullAttack( float flDist, int iDamage, int iDmgType ) { return NULL; }
|
||||
void CBaseMonster::Eat( float flFullDuration ) { }
|
||||
BOOL CBaseMonster::FShouldEat( void ) { return TRUE; }
|
||||
void CBaseMonster::BarnacleVictimBitten( entvars_t *pevBarnacle ) { }
|
||||
void CBaseMonster::BarnacleVictimReleased( void ) { }
|
||||
void CBaseMonster::Listen( void ) { }
|
||||
float CBaseMonster::FLSoundVolume( CSound *pSound ) { return 0.0; }
|
||||
BOOL CBaseMonster::FValidateHintType( short sHint ) { return FALSE; }
|
||||
void CBaseMonster::Look( int iDistance ) { }
|
||||
int CBaseMonster::ISoundMask( void ) { return 0; }
|
||||
CSound *CBaseMonster::PBestSound( void ) { return NULL; }
|
||||
CSound *CBaseMonster::PBestScent( void ) { return NULL; }
|
||||
float CBaseAnimating::StudioFrameAdvance( float flInterval ) { return 0.0; }
|
||||
void CBaseMonster::MonsterThink( void ) { }
|
||||
void CBaseMonster::MonsterUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { }
|
||||
int CBaseMonster::IgnoreConditions( void ) { return 0; }
|
||||
void CBaseMonster::RouteClear( void ) { }
|
||||
void CBaseMonster::RouteNew( void ) { }
|
||||
BOOL CBaseMonster::FRouteClear( void ) { return FALSE; }
|
||||
BOOL CBaseMonster::FRefreshRoute( void ) { return 0; }
|
||||
BOOL CBaseMonster::MoveToEnemy( Activity movementAct, float waitTime ) { return FALSE; }
|
||||
BOOL CBaseMonster::MoveToLocation( Activity movementAct, float waitTime, const Vector &goal ) { return FALSE; }
|
||||
BOOL CBaseMonster::MoveToTarget( Activity movementAct, float waitTime ) { return FALSE; }
|
||||
BOOL CBaseMonster::MoveToNode( Activity movementAct, float waitTime, const Vector &goal ) { return FALSE; }
|
||||
int ShouldSimplify( int routeType ) { return TRUE; }
|
||||
void CBaseMonster :: RouteSimplify( CBaseEntity *pTargetEnt ) { }
|
||||
BOOL CBaseMonster :: FBecomeProne ( void ) { return TRUE; }
|
||||
BOOL CBaseMonster :: CheckRangeAttack1 ( float flDot, float flDist ) { return FALSE; }
|
||||
BOOL CBaseMonster :: CheckRangeAttack2 ( float flDot, float flDist ) { return FALSE; }
|
||||
BOOL CBaseMonster :: CheckMeleeAttack1 ( float flDot, float flDist ) { return FALSE; }
|
||||
BOOL CBaseMonster :: CheckMeleeAttack2 ( float flDot, float flDist ) { return FALSE; }
|
||||
void CBaseMonster :: CheckAttacks ( CBaseEntity *pTarget, float flDist ) { }
|
||||
BOOL CBaseMonster :: FCanCheckAttacks ( void ) { return FALSE; }
|
||||
int CBaseMonster :: CheckEnemy ( CBaseEntity *pEnemy ) { return 0; }
|
||||
void CBaseMonster :: PushEnemy( CBaseEntity *pEnemy, Vector &vecLastKnownPos ) { }
|
||||
BOOL CBaseMonster :: PopEnemy( ) { return FALSE; }
|
||||
void CBaseMonster :: SetActivity ( Activity NewActivity ) { }
|
||||
void CBaseMonster :: SetSequenceByName ( char *szSequence ) { }
|
||||
int CBaseMonster :: CheckLocalMove ( const Vector &vecStart, const Vector &vecEnd, CBaseEntity *pTarget, float *pflDist ) { return 0; }
|
||||
float CBaseMonster :: OpenDoorAndWait( entvars_t *pevDoor ) { return 0.0; }
|
||||
void CBaseMonster :: AdvanceRoute ( float distance ) { }
|
||||
int CBaseMonster :: RouteClassify( int iMoveFlag ) { return 0; }
|
||||
BOOL CBaseMonster :: BuildRoute ( const Vector &vecGoal, int iMoveFlag, CBaseEntity *pTarget ) { return FALSE; }
|
||||
void CBaseMonster :: InsertWaypoint ( Vector vecLocation, int afMoveFlags ) { }
|
||||
BOOL CBaseMonster :: FTriangulate ( const Vector &vecStart , const Vector &vecEnd, float flDist, CBaseEntity *pTargetEnt, Vector *pApex ) { return FALSE; }
|
||||
void CBaseMonster :: Move ( float flInterval ) { }
|
||||
BOOL CBaseMonster:: ShouldAdvanceRoute( float flWaypointDist ) { return FALSE; }
|
||||
void CBaseMonster::RouteSimplify( CBaseEntity *pTargetEnt ) { }
|
||||
BOOL CBaseMonster::FBecomeProne( void ) { return TRUE; }
|
||||
BOOL CBaseMonster::CheckRangeAttack1( float flDot, float flDist ) { return FALSE; }
|
||||
BOOL CBaseMonster::CheckRangeAttack2( float flDot, float flDist ) { return FALSE; }
|
||||
BOOL CBaseMonster::CheckMeleeAttack1( float flDot, float flDist ) { return FALSE; }
|
||||
BOOL CBaseMonster::CheckMeleeAttack2( float flDot, float flDist ) { return FALSE; }
|
||||
void CBaseMonster::CheckAttacks( CBaseEntity *pTarget, float flDist ) { }
|
||||
BOOL CBaseMonster::FCanCheckAttacks( void ) { return FALSE; }
|
||||
int CBaseMonster::CheckEnemy( CBaseEntity *pEnemy ) { return 0; }
|
||||
void CBaseMonster::PushEnemy( CBaseEntity *pEnemy, Vector &vecLastKnownPos ) { }
|
||||
BOOL CBaseMonster::PopEnemy() { return FALSE; }
|
||||
void CBaseMonster::SetActivity( Activity NewActivity ) { }
|
||||
void CBaseMonster::SetSequenceByName( char *szSequence ) { }
|
||||
int CBaseMonster::CheckLocalMove( const Vector &vecStart, const Vector &vecEnd, CBaseEntity *pTarget, float *pflDist ) { return 0; }
|
||||
float CBaseMonster::OpenDoorAndWait( entvars_t *pevDoor ) { return 0.0; }
|
||||
void CBaseMonster::AdvanceRoute( float distance ) { }
|
||||
int CBaseMonster::RouteClassify( int iMoveFlag ) { return 0; }
|
||||
BOOL CBaseMonster::BuildRoute( const Vector &vecGoal, int iMoveFlag, CBaseEntity *pTarget ) { return FALSE; }
|
||||
void CBaseMonster::InsertWaypoint( Vector vecLocation, int afMoveFlags ) { }
|
||||
BOOL CBaseMonster::FTriangulate( const Vector &vecStart , const Vector &vecEnd, float flDist, CBaseEntity *pTargetEnt, Vector *pApex ) { return FALSE; }
|
||||
void CBaseMonster::Move( float flInterval ) { }
|
||||
BOOL CBaseMonster::ShouldAdvanceRoute( float flWaypointDist ) { return FALSE; }
|
||||
void CBaseMonster::MoveExecute( CBaseEntity *pTargetEnt, const Vector &vecDir, float flInterval ) { }
|
||||
void CBaseMonster :: MonsterInit ( void ) { }
|
||||
void CBaseMonster :: MonsterInitThink ( void ) { }
|
||||
void CBaseMonster :: StartMonster ( void ) { }
|
||||
void CBaseMonster :: MovementComplete( void ) { }
|
||||
void CBaseMonster::MonsterInit( void ) { }
|
||||
void CBaseMonster::MonsterInitThink( void ) { }
|
||||
void CBaseMonster::StartMonster( void ) { }
|
||||
void CBaseMonster::MovementComplete( void ) { }
|
||||
int CBaseMonster::TaskIsRunning( void ) { return 0; }
|
||||
int CBaseMonster::IRelationship ( CBaseEntity *pTarget ) { return 0; }
|
||||
BOOL CBaseMonster :: FindCover ( Vector vecThreat, Vector vecViewOffset, float flMinDist, float flMaxDist ) { return FALSE; }
|
||||
BOOL CBaseMonster :: BuildNearestRoute ( Vector vecThreat, Vector vecViewOffset, float flMinDist, float flMaxDist ) { return FALSE; }
|
||||
CBaseEntity *CBaseMonster :: BestVisibleEnemy ( void ) { return NULL; }
|
||||
BOOL CBaseMonster :: FInViewCone ( CBaseEntity *pEntity ) { return FALSE; }
|
||||
BOOL CBaseMonster :: FInViewCone ( Vector *pOrigin ) { return FALSE; }
|
||||
BOOL CBaseEntity :: FVisible ( CBaseEntity *pEntity ) { return FALSE; }
|
||||
BOOL CBaseEntity :: FVisible ( const Vector &vecOrigin ) { return FALSE; }
|
||||
void CBaseMonster :: MakeIdealYaw( Vector vecTarget ) { }
|
||||
float CBaseMonster::FlYawDiff ( void ) { return 0.0; }
|
||||
float CBaseMonster::ChangeYaw ( int yawSpeed ) { return 0; }
|
||||
float CBaseMonster::VecToYaw ( Vector vecDir ) { return 0.0; }
|
||||
int CBaseAnimating :: LookupActivity ( int activity ) { return 0; }
|
||||
int CBaseAnimating :: LookupActivityHeaviest ( int activity ) { return 0; }
|
||||
void CBaseMonster :: SetEyePosition ( void ) { }
|
||||
int CBaseAnimating :: LookupSequence ( const char *label ) { return 0; }
|
||||
void CBaseAnimating :: ResetSequenceInfo ( ) { }
|
||||
BOOL CBaseAnimating :: GetSequenceFlags( ) { return FALSE; }
|
||||
void CBaseAnimating :: DispatchAnimEvents ( float flInterval ) { }
|
||||
void CBaseMonster :: HandleAnimEvent( MonsterEvent_t *pEvent ) { }
|
||||
float CBaseAnimating :: SetBoneController ( int iController, float flValue ) { return 0.0; }
|
||||
void CBaseAnimating :: InitBoneControllers ( void ) { }
|
||||
float CBaseAnimating :: SetBlending ( int iBlender, float flValue ) { return 0; }
|
||||
void CBaseAnimating :: GetBonePosition ( int iBone, Vector &origin, Vector &angles ) { }
|
||||
void CBaseAnimating :: GetAttachment ( int iAttachment, Vector &origin, Vector &angles ) { }
|
||||
int CBaseAnimating :: FindTransition( int iEndingSequence, int iGoalSequence, int *piDir ) { return -1; }
|
||||
void CBaseAnimating :: GetAutomovement( Vector &origin, Vector &angles, float flInterval ) { }
|
||||
void CBaseAnimating :: SetBodygroup( int iGroup, int iValue ) { }
|
||||
int CBaseAnimating :: GetBodygroup( int iGroup ) { return 0; }
|
||||
Vector CBaseMonster :: GetGunPosition( void ) { return g_vecZero; }
|
||||
void CBaseEntity::TraceAttack(entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType) { }
|
||||
void CBaseEntity::FireBullets(ULONG cShots, Vector vecSrc, Vector vecDirShooting, Vector vecSpread, float flDistance, int iBulletType, int iTracerFreq, int iDamage, entvars_t *pevAttacker ) { }
|
||||
void CBaseEntity :: TraceBleed( float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType ) { }
|
||||
void CBaseMonster :: MakeDamageBloodDecal ( int cCount, float flNoise, TraceResult *ptr, const Vector &vecDir ) { }
|
||||
BOOL CBaseMonster :: FGetNodeRoute ( Vector vecDest ) { return TRUE; }
|
||||
int CBaseMonster :: FindHintNode ( void ) { return NO_NODE; }
|
||||
int CBaseMonster::IRelationship( CBaseEntity *pTarget ) { return 0; }
|
||||
BOOL CBaseMonster::FindCover( Vector vecThreat, Vector vecViewOffset, float flMinDist, float flMaxDist ) { return FALSE; }
|
||||
BOOL CBaseMonster::BuildNearestRoute( Vector vecThreat, Vector vecViewOffset, float flMinDist, float flMaxDist ) { return FALSE; }
|
||||
CBaseEntity *CBaseMonster::BestVisibleEnemy( void ) { return NULL; }
|
||||
BOOL CBaseMonster::FInViewCone( CBaseEntity *pEntity ) { return FALSE; }
|
||||
BOOL CBaseMonster::FInViewCone( Vector *pOrigin ) { return FALSE; }
|
||||
BOOL CBaseEntity::FVisible( CBaseEntity *pEntity ) { return FALSE; }
|
||||
BOOL CBaseEntity::FVisible( const Vector &vecOrigin ) { return FALSE; }
|
||||
void CBaseMonster::MakeIdealYaw( Vector vecTarget ) { }
|
||||
float CBaseMonster::FlYawDiff( void ) { return 0.0; }
|
||||
float CBaseMonster::ChangeYaw( int yawSpeed ) { return 0; }
|
||||
float CBaseMonster::VecToYaw( Vector vecDir ) { return 0.0; }
|
||||
int CBaseAnimating::LookupActivity( int activity ) { return 0; }
|
||||
int CBaseAnimating::LookupActivityHeaviest( int activity ) { return 0; }
|
||||
void CBaseMonster::SetEyePosition( void ) { }
|
||||
int CBaseAnimating::LookupSequence( const char *label ) { return 0; }
|
||||
void CBaseAnimating::ResetSequenceInfo() { }
|
||||
BOOL CBaseAnimating::GetSequenceFlags() { return FALSE; }
|
||||
void CBaseAnimating::DispatchAnimEvents( float flInterval ) { }
|
||||
void CBaseMonster::HandleAnimEvent( MonsterEvent_t *pEvent ) { }
|
||||
float CBaseAnimating::SetBoneController ( int iController, float flValue ) { return 0.0; }
|
||||
void CBaseAnimating::InitBoneControllers ( void ) { }
|
||||
float CBaseAnimating::SetBlending( int iBlender, float flValue ) { return 0; }
|
||||
void CBaseAnimating::GetBonePosition( int iBone, Vector &origin, Vector &angles ) { }
|
||||
void CBaseAnimating::GetAttachment( int iAttachment, Vector &origin, Vector &angles ) { }
|
||||
int CBaseAnimating::FindTransition( int iEndingSequence, int iGoalSequence, int *piDir ) { return -1; }
|
||||
void CBaseAnimating::GetAutomovement( Vector &origin, Vector &angles, float flInterval ) { }
|
||||
void CBaseAnimating::SetBodygroup( int iGroup, int iValue ) { }
|
||||
int CBaseAnimating::GetBodygroup( int iGroup ) { return 0; }
|
||||
Vector CBaseMonster::GetGunPosition( void ) { return g_vecZero; }
|
||||
void CBaseEntity::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType ) { }
|
||||
void CBaseEntity::FireBullets( ULONG cShots, Vector vecSrc, Vector vecDirShooting, Vector vecSpread, float flDistance, int iBulletType, int iTracerFreq, int iDamage, entvars_t *pevAttacker ) { }
|
||||
void CBaseEntity::TraceBleed( float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType ) { }
|
||||
void CBaseMonster::MakeDamageBloodDecal( int cCount, float flNoise, TraceResult *ptr, const Vector &vecDir ) { }
|
||||
BOOL CBaseMonster::FGetNodeRoute( Vector vecDest ) { return TRUE; }
|
||||
int CBaseMonster::FindHintNode( void ) { return NO_NODE; }
|
||||
void CBaseMonster::ReportAIState( void ) { }
|
||||
void CBaseMonster :: KeyValue( KeyValueData *pkvd ) { }
|
||||
BOOL CBaseMonster :: FCheckAITrigger ( void ) { return FALSE; }
|
||||
int CBaseMonster :: CanPlaySequence( BOOL fDisregardMonsterState, int interruptLevel ) { return FALSE; }
|
||||
BOOL CBaseMonster :: FindLateralCover ( const Vector &vecThreat, const Vector &vecViewOffset ) { return FALSE; }
|
||||
Vector CBaseMonster :: ShootAtEnemy( const Vector &shootOrigin ) { return g_vecZero; }
|
||||
BOOL CBaseMonster :: FacingIdeal( void ) { return FALSE; }
|
||||
BOOL CBaseMonster :: FCanActiveIdle ( void ) { return FALSE; }
|
||||
void CBaseMonster::KeyValue( KeyValueData *pkvd ) { }
|
||||
BOOL CBaseMonster::FCheckAITrigger( void ) { return FALSE; }
|
||||
int CBaseMonster::CanPlaySequence( BOOL fDisregardMonsterState, int interruptLevel ) { return FALSE; }
|
||||
BOOL CBaseMonster::FindLateralCover( const Vector &vecThreat, const Vector &vecViewOffset ) { return FALSE; }
|
||||
Vector CBaseMonster::ShootAtEnemy( const Vector &shootOrigin ) { return g_vecZero; }
|
||||
BOOL CBaseMonster::FacingIdeal( void ) { return FALSE; }
|
||||
BOOL CBaseMonster::FCanActiveIdle( void ) { return FALSE; }
|
||||
void CBaseMonster::PlaySentence( const char *pszSentence, float duration, float volume, float attenuation ) { }
|
||||
void CBaseMonster::PlayScriptedSentence( const char *pszSentence, float duration, float volume, float attenuation, BOOL bConcurrent, CBaseEntity *pListener ) { }
|
||||
void CBaseMonster::SentenceStop( void ) { }
|
||||
void CBaseMonster::CorpseFallThink( void ) { }
|
||||
void CBaseMonster :: MonsterInitDead( void ) { }
|
||||
BOOL CBaseMonster :: BBoxFlat ( void ) { return TRUE; }
|
||||
BOOL CBaseMonster :: GetEnemy ( void ) { return FALSE; }
|
||||
void CBaseMonster :: TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType) { }
|
||||
CBaseEntity* CBaseMonster :: DropItem ( char *pszItemName, const Vector &vecPos, const Vector &vecAng ) { return NULL; }
|
||||
BOOL CBaseMonster :: ShouldFadeOnDeath( void ) { return FALSE; }
|
||||
void CBaseMonster :: RadiusDamage(entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType ) { }
|
||||
void CBaseMonster :: RadiusDamage( Vector vecSrc, entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType ) { }
|
||||
void CBaseMonster::MonsterInitDead( void ) { }
|
||||
BOOL CBaseMonster::BBoxFlat( void ) { return TRUE; }
|
||||
BOOL CBaseMonster::GetEnemy( void ) { return FALSE; }
|
||||
void CBaseMonster::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType) { }
|
||||
CBaseEntity* CBaseMonster::DropItem( char *pszItemName, const Vector &vecPos, const Vector &vecAng ) { return NULL; }
|
||||
BOOL CBaseMonster::ShouldFadeOnDeath( void ) { return FALSE; }
|
||||
void CBaseMonster::RadiusDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType ) { }
|
||||
void CBaseMonster::RadiusDamage( Vector vecSrc, entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType ) { }
|
||||
void CBaseMonster::FadeMonster( void ) { }
|
||||
void CBaseMonster :: GibMonster( void ) { }
|
||||
BOOL CBaseMonster :: HasHumanGibs( void ) { return FALSE; }
|
||||
BOOL CBaseMonster :: HasAlienGibs( void ) { return FALSE; }
|
||||
Activity CBaseMonster :: GetDeathActivity ( void ) { return ACT_DIE_HEADSHOT; }
|
||||
MONSTERSTATE CBaseMonster :: GetIdealState ( void ) { return MONSTERSTATE_ALERT; }
|
||||
Schedule_t* CBaseMonster :: GetScheduleOfType ( int Type ) { return NULL; }
|
||||
Schedule_t *CBaseMonster :: GetSchedule ( void ) { return NULL; }
|
||||
void CBaseMonster :: RunTask ( Task_t *pTask ) { }
|
||||
void CBaseMonster :: StartTask ( Task_t *pTask ) { }
|
||||
void CBaseMonster::GibMonster( void ) { }
|
||||
BOOL CBaseMonster::HasHumanGibs( void ) { return FALSE; }
|
||||
BOOL CBaseMonster::HasAlienGibs( void ) { return FALSE; }
|
||||
Activity CBaseMonster::GetDeathActivity( void ) { return ACT_DIE_HEADSHOT; }
|
||||
MONSTERSTATE CBaseMonster::GetIdealState( void ) { return MONSTERSTATE_ALERT; }
|
||||
Schedule_t* CBaseMonster::GetScheduleOfType( int Type ) { return NULL; }
|
||||
Schedule_t *CBaseMonster::GetSchedule( void ) { return NULL; }
|
||||
void CBaseMonster::RunTask( Task_t *pTask ) { }
|
||||
void CBaseMonster::StartTask( Task_t *pTask ) { }
|
||||
Schedule_t *CBaseMonster::ScheduleFromName( const char *pName ) { return NULL;}
|
||||
void CBaseMonster::BecomeDead( void ) {}
|
||||
void CBaseMonster :: RunAI ( void ) {}
|
||||
void CBaseMonster :: Killed( entvars_t *pevAttacker, int iGib ) {}
|
||||
int CBaseMonster :: TakeHealth (float flHealth, int bitsDamageType) { return 0; }
|
||||
int CBaseMonster :: TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType ) { return 0; }
|
||||
void CBaseMonster::RunAI( void ) {}
|
||||
void CBaseMonster::Killed( entvars_t *pevAttacker, int iGib ) {}
|
||||
int CBaseMonster::TakeHealth(float flHealth, int bitsDamageType) { return 0; }
|
||||
int CBaseMonster::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType ) { return 0; }
|
||||
int CBaseMonster::Restore( class CRestore & ) { return 1; }
|
||||
int CBaseMonster::Save( class CSave & ) { return 1; }
|
||||
|
||||
int TrainSpeed(int iSpeed, int iMax) { return 0; }
|
||||
void CBasePlayer :: DeathSound( void ) { }
|
||||
int CBasePlayer :: TakeHealth( float flHealth, int bitsDamageType ) { return 0; }
|
||||
void CBasePlayer :: TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType) { }
|
||||
int CBasePlayer :: TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType ) { return 0; }
|
||||
int TrainSpeed( int iSpeed, int iMax ) { return 0; }
|
||||
void CBasePlayer::DeathSound( void ) { }
|
||||
int CBasePlayer::TakeHealth( float flHealth, int bitsDamageType ) { return 0; }
|
||||
void CBasePlayer::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType) { }
|
||||
int CBasePlayer::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType ) { return 0; }
|
||||
void CBasePlayer::PackDeadPlayerItems( void ) { }
|
||||
void CBasePlayer::RemoveAllItems( BOOL removeSuit ) { }
|
||||
void CBasePlayer::SetAnimation( PLAYER_ANIM playerAnim ) { }
|
||||
|
@ -250,77 +250,77 @@ BOOL CBasePlayer::IsOnLadder( void ) { return FALSE; }
|
|||
void CBasePlayer::PlayerDeathThink(void) { }
|
||||
void CBasePlayer::StartDeathCam( void ) { }
|
||||
void CBasePlayer::StartObserver( Vector vecPosition, Vector vecViewAngle ) { }
|
||||
void CBasePlayer::PlayerUse ( void ) { }
|
||||
void CBasePlayer::PlayerUse( void ) { }
|
||||
void CBasePlayer::Jump() { }
|
||||
void CBasePlayer::Duck( ) { }
|
||||
int CBasePlayer::Classify ( void ) { return 0; }
|
||||
void CBasePlayer::Duck() { }
|
||||
int CBasePlayer::Classify( void ) { return 0; }
|
||||
void CBasePlayer::PreThink(void) { }
|
||||
void CBasePlayer::CheckTimeBasedDamage() { }
|
||||
void CBasePlayer :: UpdateGeigerCounter( void ) { }
|
||||
void CBasePlayer::UpdateGeigerCounter( void ) { }
|
||||
void CBasePlayer::CheckSuitUpdate() { }
|
||||
void CBasePlayer::SetSuitUpdate(char *name, int fgroup, int iNoRepeatTime) { }
|
||||
void CBasePlayer :: UpdatePlayerSound ( void ) { }
|
||||
void CBasePlayer::UpdatePlayerSound ( void ) { }
|
||||
void CBasePlayer::PostThink() { }
|
||||
void CBasePlayer :: Precache( void ) { }
|
||||
void CBasePlayer::Precache( void ) { }
|
||||
int CBasePlayer::Save( CSave &save ) { return 0; }
|
||||
void CBasePlayer::RenewItems(void) { }
|
||||
void CBasePlayer::RenewItems( void ) { }
|
||||
int CBasePlayer::Restore( CRestore &restore ) { return 0; }
|
||||
void CBasePlayer::SelectNextItem( int iItem ) { }
|
||||
BOOL CBasePlayer::HasWeapons( void ) { return FALSE; }
|
||||
void CBasePlayer::SelectPrevItem( int iItem ) { }
|
||||
CBaseEntity *FindEntityForward( CBaseEntity *pMe ) { return NULL; }
|
||||
BOOL CBasePlayer :: FlashlightIsOn( void ) { return FALSE; }
|
||||
void CBasePlayer :: FlashlightTurnOn( void ) { }
|
||||
void CBasePlayer :: FlashlightTurnOff( void ) { }
|
||||
void CBasePlayer :: ForceClientDllUpdate( void ) { }
|
||||
void CBasePlayer::ImpulseCommands( ) { }
|
||||
BOOL CBasePlayer::FlashlightIsOn( void ) { return FALSE; }
|
||||
void CBasePlayer::FlashlightTurnOn( void ) { }
|
||||
void CBasePlayer::FlashlightTurnOff( void ) { }
|
||||
void CBasePlayer::ForceClientDllUpdate( void ) { }
|
||||
void CBasePlayer::ImpulseCommands() { }
|
||||
void CBasePlayer::CheatImpulseCommands( int iImpulse ) { }
|
||||
int CBasePlayer::AddPlayerItem( CBasePlayerItem *pItem ) { return FALSE; }
|
||||
int CBasePlayer::RemovePlayerItem( CBasePlayerItem *pItem ) { return FALSE; }
|
||||
void CBasePlayer::ItemPreFrame() { }
|
||||
void CBasePlayer::ItemPostFrame() { }
|
||||
int CBasePlayer::AmmoInventory( int iAmmoIndex ) { return -1; }
|
||||
int CBasePlayer::GetAmmoIndex(const char *psz) { return -1; }
|
||||
int CBasePlayer::GetAmmoIndex( const char *psz ) { return -1; }
|
||||
void CBasePlayer::SendAmmoUpdate(void) { }
|
||||
void CBasePlayer :: UpdateClientData( void ) { }
|
||||
BOOL CBasePlayer :: FBecomeProne ( void ) { return TRUE; }
|
||||
void CBasePlayer :: BarnacleVictimBitten ( entvars_t *pevBarnacle ) { }
|
||||
void CBasePlayer :: BarnacleVictimReleased ( void ) { }
|
||||
int CBasePlayer :: Illumination( void ) { return 0; }
|
||||
void CBasePlayer :: EnableControl(BOOL fControl) { }
|
||||
Vector CBasePlayer :: GetAutoaimVector( float flDelta ) { return g_vecZero; }
|
||||
Vector CBasePlayer :: AutoaimDeflection( Vector &vecSrc, float flDist, float flDelta ) { return g_vecZero; }
|
||||
void CBasePlayer :: ResetAutoaim( ) { }
|
||||
void CBasePlayer :: SetCustomDecalFrames( int nFrames ) { }
|
||||
int CBasePlayer :: GetCustomDecalFrames( void ) { return -1; }
|
||||
void CBasePlayer::DropPlayerItem ( char *pszItemName ) { }
|
||||
void CBasePlayer::UpdateClientData( void ) { }
|
||||
BOOL CBasePlayer::FBecomeProne( void ) { return TRUE; }
|
||||
void CBasePlayer::BarnacleVictimBitten( entvars_t *pevBarnacle ) { }
|
||||
void CBasePlayer::BarnacleVictimReleased( void ) { }
|
||||
int CBasePlayer::Illumination( void ) { return 0; }
|
||||
void CBasePlayer::EnableControl( BOOL fControl ) { }
|
||||
Vector CBasePlayer::GetAutoaimVector( float flDelta ) { return g_vecZero; }
|
||||
Vector CBasePlayer::AutoaimDeflection( Vector &vecSrc, float flDist, float flDelta ) { return g_vecZero; }
|
||||
void CBasePlayer::ResetAutoaim() { }
|
||||
void CBasePlayer::SetCustomDecalFrames( int nFrames ) { }
|
||||
int CBasePlayer::GetCustomDecalFrames( void ) { return -1; }
|
||||
void CBasePlayer::DropPlayerItem( char *pszItemName ) { }
|
||||
BOOL CBasePlayer::HasPlayerItem( CBasePlayerItem *pCheckItem ) { return FALSE; }
|
||||
BOOL CBasePlayer :: SwitchWeapon( CBasePlayerItem *pWeapon ) { return FALSE; }
|
||||
Vector CBasePlayer :: GetGunPosition( void ) { return g_vecZero; }
|
||||
BOOL CBasePlayer::SwitchWeapon( CBasePlayerItem *pWeapon ) { return FALSE; }
|
||||
Vector CBasePlayer::GetGunPosition( void ) { return g_vecZero; }
|
||||
const char *CBasePlayer::TeamID( void ) { return ""; }
|
||||
int CBasePlayer :: GiveAmmo( int iCount, char *szName, int iMax ) { return 0; }
|
||||
int CBasePlayer::GiveAmmo( int iCount, char *szName, int iMax ) { return 0; }
|
||||
void CBasePlayer::AddPoints( int score, BOOL bAllowNegativeScore ) { }
|
||||
void CBasePlayer::AddPointsToTeam( int score, BOOL bAllowNegativeScore ) { }
|
||||
|
||||
void ClearMultiDamage(void) { }
|
||||
void ApplyMultiDamage(entvars_t *pevInflictor, entvars_t *pevAttacker ) { }
|
||||
void ClearMultiDamage( void ) { }
|
||||
void ApplyMultiDamage( entvars_t *pevInflictor, entvars_t *pevAttacker ) { }
|
||||
void AddMultiDamage( entvars_t *pevInflictor, CBaseEntity *pEntity, float flDamage, int bitsDamageType) { }
|
||||
void SpawnBlood(Vector vecSpot, int bloodColor, float flDamage) { }
|
||||
void SpawnBlood( Vector vecSpot, int bloodColor, float flDamage ) { }
|
||||
int DamageDecal( CBaseEntity *pEntity, int bitsDamageType ) { return 0; }
|
||||
void DecalGunshot( TraceResult *pTrace, int iBulletType ) { }
|
||||
void EjectBrass ( const Vector &vecOrigin, const Vector &vecVelocity, float rotation, int model, int soundtype ) { }
|
||||
void EjectBrass( const Vector &vecOrigin, const Vector &vecVelocity, float rotation, int model, int soundtype ) { }
|
||||
void AddAmmoNameToAmmoRegistry( const char *szAmmoname ) { }
|
||||
int CBasePlayerItem::Restore( class CRestore & ) { return 1; }
|
||||
int CBasePlayerItem::Save( class CSave & ) { return 1; }
|
||||
int CBasePlayerWeapon::Restore( class CRestore & ) { return 1; }
|
||||
int CBasePlayerWeapon::Save( class CSave & ) { return 1; }
|
||||
void CBasePlayerItem :: SetObjectCollisionBox( void ) { }
|
||||
void CBasePlayerItem :: FallInit( void ) { }
|
||||
void CBasePlayerItem::FallThink ( void ) { }
|
||||
void CBasePlayerItem::SetObjectCollisionBox( void ) { }
|
||||
void CBasePlayerItem::FallInit( void ) { }
|
||||
void CBasePlayerItem::FallThink( void ) { }
|
||||
void CBasePlayerItem::Materialize( void ) { }
|
||||
void CBasePlayerItem::AttemptToMaterialize( void ) { }
|
||||
void CBasePlayerItem :: CheckRespawn ( void ) { }
|
||||
CBaseEntity* CBasePlayerItem::Respawn( void ) { return NULL; }
|
||||
void CBasePlayerItem::CheckRespawn( void ) { }
|
||||
CBaseEntity *CBasePlayerItem::Respawn( void ) { return NULL; }
|
||||
void CBasePlayerItem::DefaultTouch( CBaseEntity *pOther ) { }
|
||||
void CBasePlayerItem::DestroyItem( void ) { }
|
||||
int CBasePlayerItem::AddToPlayer( CBasePlayer *pPlayer ) { return TRUE; }
|
||||
|
@ -331,17 +331,17 @@ void CBasePlayerItem::AttachToPlayer ( CBasePlayer *pPlayer ) { }
|
|||
int CBasePlayerWeapon::AddDuplicate( CBasePlayerItem *pOriginal ) { return 0; }
|
||||
int CBasePlayerWeapon::AddToPlayer( CBasePlayer *pPlayer ) { return FALSE; }
|
||||
int CBasePlayerWeapon::UpdateClientData( CBasePlayer *pPlayer ) { return 0; }
|
||||
BOOL CBasePlayerWeapon :: AddPrimaryAmmo( int iCount, char *szName, int iMaxClip, int iMaxCarry ) { return TRUE; }
|
||||
BOOL CBasePlayerWeapon :: AddSecondaryAmmo( int iCount, char *szName, int iMax ) { return TRUE; }
|
||||
BOOL CBasePlayerWeapon :: IsUseable( void ) { return TRUE; }
|
||||
BOOL CBasePlayerWeapon::AddPrimaryAmmo( int iCount, char *szName, int iMaxClip, int iMaxCarry ) { return TRUE; }
|
||||
BOOL CBasePlayerWeapon::AddSecondaryAmmo( int iCount, char *szName, int iMax ) { return TRUE; }
|
||||
BOOL CBasePlayerWeapon::IsUseable( void ) { return TRUE; }
|
||||
int CBasePlayerWeapon::PrimaryAmmoIndex( void ) { return -1; }
|
||||
int CBasePlayerWeapon::SecondaryAmmoIndex( void ) { return -1; }
|
||||
int CBasePlayerWeapon::SecondaryAmmoIndex( void ) { return -1; }
|
||||
void CBasePlayerAmmo::Spawn( void ) { }
|
||||
CBaseEntity* CBasePlayerAmmo::Respawn( void ) { return this; }
|
||||
void CBasePlayerAmmo::Materialize( void ) { }
|
||||
void CBasePlayerAmmo :: DefaultTouch( CBaseEntity *pOther ) { }
|
||||
void CBasePlayerAmmo::DefaultTouch( CBaseEntity *pOther ) { }
|
||||
int CBasePlayerWeapon::ExtractAmmo( CBasePlayerWeapon *pWeapon ) { return 0; }
|
||||
int CBasePlayerWeapon::ExtractClipAmmo( CBasePlayerWeapon *pWeapon ) { return 0; }
|
||||
void CBasePlayerWeapon::RetireWeapon( void ) { }
|
||||
void CSoundEnt::InsertSound ( int iType, const Vector &vecOrigin, int iVolume, float flDuration ) {}
|
||||
void RadiusDamage( Vector vecSrc, entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, float flRadius, int iClassIgnore, int bitsDamageType ){}
|
||||
void CSoundEnt::InsertSound( int iType, const Vector &vecOrigin, int iVolume, float flDuration ) {}
|
||||
void RadiusDamage( Vector vecSrc, entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, float flRadius, int iClassIgnore, int bitsDamageType ){}
|
||||
|
|
|
@ -12,6 +12,7 @@
|
|||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
|
||||
#include "../hud.h"
|
||||
#include "../cl_util.h"
|
||||
#include "event_api.h"
|
||||
|
@ -38,8 +39,6 @@ void EV_HornetGunFire( struct event_args_s *args );
|
|||
void EV_TripmineFire( struct event_args_s *args );
|
||||
void EV_SnarkFire( struct event_args_s *args );
|
||||
|
||||
|
||||
|
||||
void EV_TrainPitchAdjust( struct event_args_s *args );
|
||||
}
|
||||
|
||||
|
@ -58,23 +57,23 @@ That was what we were going to do, but we ran out of time...oh well.
|
|||
*/
|
||||
void Game_HookEvents( void )
|
||||
{
|
||||
gEngfuncs.pfnHookEvent( "events/glock1.sc", EV_FireGlock1 );
|
||||
gEngfuncs.pfnHookEvent( "events/glock2.sc", EV_FireGlock2 );
|
||||
gEngfuncs.pfnHookEvent( "events/shotgun1.sc", EV_FireShotGunSingle );
|
||||
gEngfuncs.pfnHookEvent( "events/shotgun2.sc", EV_FireShotGunDouble );
|
||||
gEngfuncs.pfnHookEvent( "events/mp5.sc", EV_FireMP5 );
|
||||
gEngfuncs.pfnHookEvent( "events/mp52.sc", EV_FireMP52 );
|
||||
gEngfuncs.pfnHookEvent( "events/python.sc", EV_FirePython );
|
||||
gEngfuncs.pfnHookEvent( "events/gauss.sc", EV_FireGauss );
|
||||
gEngfuncs.pfnHookEvent( "events/gaussspin.sc", EV_SpinGauss );
|
||||
gEngfuncs.pfnHookEvent( "events/train.sc", EV_TrainPitchAdjust );
|
||||
gEngfuncs.pfnHookEvent( "events/crowbar.sc", EV_Crowbar );
|
||||
gEngfuncs.pfnHookEvent( "events/crossbow1.sc", EV_FireCrossbow );
|
||||
gEngfuncs.pfnHookEvent( "events/crossbow2.sc", EV_FireCrossbow2 );
|
||||
gEngfuncs.pfnHookEvent( "events/rpg.sc", EV_FireRpg );
|
||||
gEngfuncs.pfnHookEvent( "events/egon_fire.sc", EV_EgonFire );
|
||||
gEngfuncs.pfnHookEvent( "events/egon_stop.sc", EV_EgonStop );
|
||||
gEngfuncs.pfnHookEvent( "events/firehornet.sc", EV_HornetGunFire );
|
||||
gEngfuncs.pfnHookEvent( "events/tripfire.sc", EV_TripmineFire );
|
||||
gEngfuncs.pfnHookEvent( "events/snarkfire.sc", EV_SnarkFire );
|
||||
gEngfuncs.pfnHookEvent( "events/glock1.sc", EV_FireGlock1 );
|
||||
gEngfuncs.pfnHookEvent( "events/glock2.sc", EV_FireGlock2 );
|
||||
gEngfuncs.pfnHookEvent( "events/shotgun1.sc", EV_FireShotGunSingle );
|
||||
gEngfuncs.pfnHookEvent( "events/shotgun2.sc", EV_FireShotGunDouble );
|
||||
gEngfuncs.pfnHookEvent( "events/mp5.sc", EV_FireMP5 );
|
||||
gEngfuncs.pfnHookEvent( "events/mp52.sc", EV_FireMP52 );
|
||||
gEngfuncs.pfnHookEvent( "events/python.sc", EV_FirePython );
|
||||
gEngfuncs.pfnHookEvent( "events/gauss.sc", EV_FireGauss );
|
||||
gEngfuncs.pfnHookEvent( "events/gaussspin.sc", EV_SpinGauss );
|
||||
gEngfuncs.pfnHookEvent( "events/train.sc", EV_TrainPitchAdjust );
|
||||
gEngfuncs.pfnHookEvent( "events/crowbar.sc", EV_Crowbar );
|
||||
gEngfuncs.pfnHookEvent( "events/crossbow1.sc", EV_FireCrossbow );
|
||||
gEngfuncs.pfnHookEvent( "events/crossbow2.sc", EV_FireCrossbow2 );
|
||||
gEngfuncs.pfnHookEvent( "events/rpg.sc", EV_FireRpg );
|
||||
gEngfuncs.pfnHookEvent( "events/egon_fire.sc", EV_EgonFire );
|
||||
gEngfuncs.pfnHookEvent( "events/egon_stop.sc", EV_EgonStop );
|
||||
gEngfuncs.pfnHookEvent( "events/firehornet.sc", EV_HornetGunFire );
|
||||
gEngfuncs.pfnHookEvent( "events/tripfire.sc", EV_TripmineFire );
|
||||
gEngfuncs.pfnHookEvent( "events/snarkfire.sc", EV_SnarkFire );
|
||||
}
|
||||
|
|
|
@ -12,6 +12,7 @@
|
|||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
|
||||
#include "../hud.h"
|
||||
#include "../cl_util.h"
|
||||
#include "../demo.h"
|
||||
|
@ -30,7 +31,7 @@ extern BEAM *pBeam;
|
|||
extern BEAM *pBeam2;
|
||||
void HUD_GetLastOrg( float *org );
|
||||
|
||||
void UpdateBeams ( void )
|
||||
void UpdateBeams( void )
|
||||
{
|
||||
vec3_t forward, vecSrc, vecEnd, origin, angles, right, up;
|
||||
vec3_t view_ofs;
|
||||
|
@ -47,32 +48,32 @@ void UpdateBeams ( void )
|
|||
AngleVectors( angles, forward, right, up );
|
||||
|
||||
VectorCopy( origin, vecSrc );
|
||||
|
||||
|
||||
VectorMA( vecSrc, 2048, forward, vecEnd );
|
||||
|
||||
gEngfuncs.pEventAPI->EV_SetUpPlayerPrediction( false, true );
|
||||
|
||||
|
||||
// Store off the old count
|
||||
gEngfuncs.pEventAPI->EV_PushPMStates();
|
||||
|
||||
|
||||
// Now add in all of the players.
|
||||
gEngfuncs.pEventAPI->EV_SetSolidPlayers ( idx - 1 );
|
||||
gEngfuncs.pEventAPI->EV_SetSolidPlayers( idx - 1 );
|
||||
|
||||
gEngfuncs.pEventAPI->EV_SetTraceHull( 2 );
|
||||
gEngfuncs.pEventAPI->EV_PlayerTrace( vecSrc, vecEnd, PM_STUDIO_BOX, -1, &tr );
|
||||
|
||||
gEngfuncs.pEventAPI->EV_PopPMStates();
|
||||
|
||||
if ( pBeam )
|
||||
if( pBeam )
|
||||
{
|
||||
pBeam->target = tr.endpos;
|
||||
pBeam->die = gEngfuncs.GetClientTime() + 0.1; // We keep it alive just a little bit forward in the future, just in case.
|
||||
pBeam->die = gEngfuncs.GetClientTime() + 0.1; // We keep it alive just a little bit forward in the future, just in case.
|
||||
}
|
||||
|
||||
if ( pBeam2 )
|
||||
|
||||
if( pBeam2 )
|
||||
{
|
||||
pBeam2->target = tr.endpos;
|
||||
pBeam2->die = gEngfuncs.GetClientTime() + 0.1; // We keep it alive just a little bit forward in the future, just in case.
|
||||
pBeam2->die = gEngfuncs.GetClientTime() + 0.1; // We keep it alive just a little bit forward in the future, just in case.
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -85,6 +86,6 @@ Add game specific, client-side objects here
|
|||
*/
|
||||
void Game_AddObjects( void )
|
||||
{
|
||||
if ( pBeam && pBeam2 )
|
||||
if( pBeam && pBeam2 )
|
||||
UpdateBeams();
|
||||
}
|
||||
|
|
File diff suppressed because it is too large
Load Diff
192
cl_dll/hud.cpp
192
cl_dll/hud.cpp
|
@ -25,71 +25,69 @@
|
|||
#include "parsemsg.h"
|
||||
#include "hud_servers.h"
|
||||
|
||||
|
||||
#include "demo.h"
|
||||
#include "demo_api.h"
|
||||
|
||||
cvar_t *hud_textmode;
|
||||
float g_hud_text_color[3];
|
||||
|
||||
|
||||
extern client_sprite_t *GetSpriteList(client_sprite_t *pList, const char *psz, int iRes, int iCount);
|
||||
extern client_sprite_t *GetSpriteList( client_sprite_t *pList, const char *psz, int iRes, int iCount );
|
||||
|
||||
extern cvar_t *sensitivity;
|
||||
cvar_t *cl_lw = NULL;
|
||||
|
||||
void ShutdownInput (void);
|
||||
void ShutdownInput( void );
|
||||
|
||||
//DECLARE_MESSAGE(m_Logo, Logo)
|
||||
int __MsgFunc_Logo(const char *pszName, int iSize, void *pbuf)
|
||||
//DECLARE_MESSAGE( m_Logo, Logo )
|
||||
int __MsgFunc_Logo( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
return gHUD.MsgFunc_Logo(pszName, iSize, pbuf );
|
||||
return gHUD.MsgFunc_Logo( pszName, iSize, pbuf );
|
||||
}
|
||||
|
||||
//DECLARE_MESSAGE(m_Logo, Logo)
|
||||
int __MsgFunc_ResetHUD(const char *pszName, int iSize, void *pbuf)
|
||||
//DECLARE_MESSAGE( m_Logo, Logo )
|
||||
int __MsgFunc_ResetHUD( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
return gHUD.MsgFunc_ResetHUD(pszName, iSize, pbuf );
|
||||
return gHUD.MsgFunc_ResetHUD( pszName, iSize, pbuf );
|
||||
}
|
||||
|
||||
int __MsgFunc_InitHUD(const char *pszName, int iSize, void *pbuf)
|
||||
int __MsgFunc_InitHUD( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
gHUD.MsgFunc_InitHUD( pszName, iSize, pbuf );
|
||||
return 1;
|
||||
}
|
||||
|
||||
int __MsgFunc_ViewMode(const char *pszName, int iSize, void *pbuf)
|
||||
int __MsgFunc_ViewMode( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
gHUD.MsgFunc_ViewMode( pszName, iSize, pbuf );
|
||||
return 1;
|
||||
}
|
||||
|
||||
int __MsgFunc_SetFOV(const char *pszName, int iSize, void *pbuf)
|
||||
int __MsgFunc_SetFOV( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
return gHUD.MsgFunc_SetFOV( pszName, iSize, pbuf );
|
||||
}
|
||||
|
||||
int __MsgFunc_Concuss(const char *pszName, int iSize, void *pbuf)
|
||||
int __MsgFunc_Concuss( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
return gHUD.MsgFunc_Concuss( pszName, iSize, pbuf );
|
||||
}
|
||||
|
||||
int __MsgFunc_GameMode(const char *pszName, int iSize, void *pbuf )
|
||||
int __MsgFunc_GameMode( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
return gHUD.MsgFunc_GameMode( pszName, iSize, pbuf );
|
||||
}
|
||||
|
||||
// TFFree Command Menu
|
||||
void __CmdFunc_OpenCommandMenu(void)
|
||||
void __CmdFunc_OpenCommandMenu( void )
|
||||
{
|
||||
}
|
||||
|
||||
// TFC "special" command
|
||||
void __CmdFunc_InputPlayerSpecial(void)
|
||||
void __CmdFunc_InputPlayerSpecial( void )
|
||||
{
|
||||
}
|
||||
|
||||
void __CmdFunc_CloseCommandMenu(void)
|
||||
void __CmdFunc_CloseCommandMenu( void )
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -102,59 +100,58 @@ void __CmdFunc_ToggleServerBrowser( void )
|
|||
}
|
||||
|
||||
// TFFree Command Menu Message Handlers
|
||||
int __MsgFunc_ValClass(const char *pszName, int iSize, void *pbuf)
|
||||
int __MsgFunc_ValClass( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int __MsgFunc_TeamNames(const char *pszName, int iSize, void *pbuf)
|
||||
int __MsgFunc_TeamNames( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int __MsgFunc_Feign(const char *pszName, int iSize, void *pbuf)
|
||||
int __MsgFunc_Feign( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int __MsgFunc_Detpack(const char *pszName, int iSize, void *pbuf)
|
||||
int __MsgFunc_Detpack( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int __MsgFunc_VGUIMenu(const char *pszName, int iSize, void *pbuf)
|
||||
int __MsgFunc_VGUIMenu( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int __MsgFunc_BuildSt(const char *pszName, int iSize, void *pbuf)
|
||||
int __MsgFunc_BuildSt( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int __MsgFunc_RandomPC(const char *pszName, int iSize, void *pbuf)
|
||||
int __MsgFunc_RandomPC( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int __MsgFunc_ServerName(const char *pszName, int iSize, void *pbuf)
|
||||
int __MsgFunc_ServerName( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int __MsgFunc_Spectator(const char *pszName, int iSize, void *pbuf)
|
||||
int __MsgFunc_Spectator( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int __MsgFunc_AllowSpec(const char *pszName, int iSize, void *pbuf)
|
||||
int __MsgFunc_AllowSpec( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// This is called every time the DLL is loaded
|
||||
void CHud :: Init( void )
|
||||
void CHud::Init( void )
|
||||
{
|
||||
HOOK_MESSAGE( Logo );
|
||||
HOOK_MESSAGE( ResetHUD );
|
||||
|
@ -201,7 +198,7 @@ void CHud :: Init( void )
|
|||
m_pSpriteList = NULL;
|
||||
|
||||
// Clear any old HUD list
|
||||
if ( m_pHudList )
|
||||
if( m_pHudList )
|
||||
{
|
||||
HUDLIST *pList;
|
||||
while ( m_pHudList )
|
||||
|
@ -235,22 +232,21 @@ void CHud :: Init( void )
|
|||
|
||||
m_Menu.Init();
|
||||
|
||||
|
||||
MsgFunc_ResetHUD(0, 0, NULL );
|
||||
MsgFunc_ResetHUD( 0, 0, NULL );
|
||||
}
|
||||
|
||||
// CHud destructor
|
||||
// cleans up memory allocated for m_rg* arrays
|
||||
CHud :: ~CHud()
|
||||
CHud::~CHud()
|
||||
{
|
||||
delete [] m_rghSprites;
|
||||
delete [] m_rgrcRects;
|
||||
delete [] m_rgszSpriteNames;
|
||||
delete[] m_rghSprites;
|
||||
delete[] m_rgrcRects;
|
||||
delete[] m_rgszSpriteNames;
|
||||
|
||||
if ( m_pHudList )
|
||||
if( m_pHudList )
|
||||
{
|
||||
HUDLIST *pList;
|
||||
while ( m_pHudList )
|
||||
while( m_pHudList )
|
||||
{
|
||||
pList = m_pHudList;
|
||||
m_pHudList = m_pHudList->pNext;
|
||||
|
@ -258,59 +254,57 @@ CHud :: ~CHud()
|
|||
}
|
||||
m_pHudList = NULL;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
// GetSpriteIndex()
|
||||
// searches through the sprite list loaded from hud.txt for a name matching SpriteName
|
||||
// returns an index into the gHUD.m_rghSprites[] array
|
||||
// returns 0 if sprite not found
|
||||
int CHud :: GetSpriteIndex( const char *SpriteName )
|
||||
int CHud::GetSpriteIndex( const char *SpriteName )
|
||||
{
|
||||
// look through the loaded sprite name list for SpriteName
|
||||
for ( int i = 0; i < m_iSpriteCount; i++ )
|
||||
for( int i = 0; i < m_iSpriteCount; i++ )
|
||||
{
|
||||
if ( strncmp( SpriteName, m_rgszSpriteNames + (i * MAX_SPRITE_NAME_LENGTH), MAX_SPRITE_NAME_LENGTH ) == 0 )
|
||||
if( strncmp( SpriteName, m_rgszSpriteNames + ( i * MAX_SPRITE_NAME_LENGTH), MAX_SPRITE_NAME_LENGTH ) == 0 )
|
||||
return i;
|
||||
}
|
||||
|
||||
return -1; // invalid sprite
|
||||
}
|
||||
|
||||
void CHud :: VidInit( void )
|
||||
void CHud::VidInit( void )
|
||||
{
|
||||
int j;
|
||||
m_scrinfo.iSize = sizeof(m_scrinfo);
|
||||
GetScreenInfo(&m_scrinfo);
|
||||
GetScreenInfo( &m_scrinfo );
|
||||
|
||||
// ----------
|
||||
// Load Sprites
|
||||
// ---------
|
||||
// m_hsprFont = LoadSprite("sprites/%d_font.spr");
|
||||
|
||||
//m_hsprFont = LoadSprite("sprites/%d_font.spr");
|
||||
|
||||
m_hsprLogo = 0;
|
||||
m_hsprCursor = 0;
|
||||
|
||||
if (ScreenWidth < 640)
|
||||
if( ScreenWidth < 640 )
|
||||
m_iRes = 320;
|
||||
else
|
||||
m_iRes = 640;
|
||||
|
||||
// Only load this once
|
||||
if ( !m_pSpriteList )
|
||||
if( !m_pSpriteList )
|
||||
{
|
||||
// we need to load the hud.txt, and all sprites within
|
||||
m_pSpriteList = SPR_GetList("sprites/hud.txt", &m_iSpriteCountAllRes);
|
||||
m_pSpriteList = SPR_GetList( "sprites/hud.txt", &m_iSpriteCountAllRes );
|
||||
|
||||
if (m_pSpriteList)
|
||||
if( m_pSpriteList )
|
||||
{
|
||||
// count the number of sprites of the appropriate res
|
||||
m_iSpriteCount = 0;
|
||||
client_sprite_t *p = m_pSpriteList;
|
||||
for ( j = 0; j < m_iSpriteCountAllRes; j++ )
|
||||
for( j = 0; j < m_iSpriteCountAllRes; j++ )
|
||||
{
|
||||
if ( p->iRes == m_iRes )
|
||||
if( p->iRes == m_iRes )
|
||||
m_iSpriteCount++;
|
||||
p++;
|
||||
}
|
||||
|
@ -322,13 +316,13 @@ void CHud :: VidInit( void )
|
|||
|
||||
p = m_pSpriteList;
|
||||
int index = 0;
|
||||
for ( j = 0; j < m_iSpriteCountAllRes; j++ )
|
||||
for( j = 0; j < m_iSpriteCountAllRes; j++ )
|
||||
{
|
||||
if ( p->iRes == m_iRes )
|
||||
if( p->iRes == m_iRes )
|
||||
{
|
||||
char sz[256];
|
||||
sprintf(sz, "sprites/%s.spr", p->szSprite);
|
||||
m_rghSprites[index] = SPR_Load(sz);
|
||||
sprintf( sz, "sprites/%s.spr", p->szSprite );
|
||||
m_rghSprites[index] = SPR_Load( sz );
|
||||
m_rgrcRects[index] = p->rc;
|
||||
strncpy( &m_rgszSpriteNames[index * MAX_SPRITE_NAME_LENGTH], p->szName, MAX_SPRITE_NAME_LENGTH );
|
||||
|
||||
|
@ -347,16 +341,16 @@ void CHud :: VidInit( void )
|
|||
|
||||
// count the number of sprites of the appropriate res
|
||||
m_iSpriteCount = 0;
|
||||
for ( j = 0; j < m_iSpriteCountAllRes; j++ )
|
||||
for( j = 0; j < m_iSpriteCountAllRes; j++ )
|
||||
{
|
||||
if ( p->iRes == m_iRes )
|
||||
if( p->iRes == m_iRes )
|
||||
m_iSpriteCount++;
|
||||
p++;
|
||||
}
|
||||
|
||||
delete [] m_rghSprites;
|
||||
delete [] m_rgrcRects;
|
||||
delete [] m_rgszSpriteNames;
|
||||
delete[] m_rghSprites;
|
||||
delete[] m_rgrcRects;
|
||||
delete[] m_rgszSpriteNames;
|
||||
|
||||
// allocated memory for sprite handle arrays
|
||||
m_rghSprites = new HSPRITE[m_iSpriteCount];
|
||||
|
@ -365,13 +359,13 @@ void CHud :: VidInit( void )
|
|||
|
||||
p = m_pSpriteList;
|
||||
int index = 0;
|
||||
for ( j = 0; j < m_iSpriteCountAllRes; j++ )
|
||||
for( j = 0; j < m_iSpriteCountAllRes; j++ )
|
||||
{
|
||||
if ( p->iRes == m_iRes )
|
||||
if( p->iRes == m_iRes )
|
||||
{
|
||||
char sz[256];
|
||||
sprintf( sz, "sprites/%s.spr", p->szSprite );
|
||||
m_rghSprites[index] = SPR_Load(sz);
|
||||
m_rghSprites[index] = SPR_Load( sz );
|
||||
m_rgrcRects[index] = p->rc;
|
||||
strncpy( &m_rgszSpriteNames[index * MAX_SPRITE_NAME_LENGTH], p->szName, MAX_SPRITE_NAME_LENGTH );
|
||||
|
||||
|
@ -404,10 +398,9 @@ void CHud :: VidInit( void )
|
|||
m_StatusIcons.VidInit();
|
||||
m_Scoreboard.VidInit();
|
||||
m_MOTD.VidInit();
|
||||
|
||||
}
|
||||
|
||||
int CHud::MsgFunc_Logo(const char *pszName, int iSize, void *pbuf)
|
||||
int CHud::MsgFunc_Logo( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
|
@ -425,29 +418,28 @@ COM_FileBase
|
|||
============
|
||||
*/
|
||||
// Extracts the base name of a file (no path, no extension, assumes '/' as path separator)
|
||||
void COM_FileBase ( const char *in, char *out)
|
||||
void COM_FileBase ( const char *in, char *out )
|
||||
{
|
||||
int len, start, end;
|
||||
|
||||
len = strlen( in );
|
||||
|
||||
|
||||
// scan backward for '.'
|
||||
end = len - 1;
|
||||
while ( end && in[end] != '.' && in[end] != '/' && in[end] != '\\' )
|
||||
while( end && in[end] != '.' && in[end] != '/' && in[end] != '\\' )
|
||||
end--;
|
||||
|
||||
if ( in[end] != '.' ) // no '.', copy to end
|
||||
end = len-1;
|
||||
|
||||
if( in[end] != '.' ) // no '.', copy to end
|
||||
end = len - 1;
|
||||
else
|
||||
end--; // Found ',', copy to left of '.'
|
||||
|
||||
|
||||
// Scan backward for '/'
|
||||
start = len-1;
|
||||
while ( start >= 0 && in[start] != '/' && in[start] != '\\' )
|
||||
start = len - 1;
|
||||
while( start >= 0 && in[start] != '/' && in[start] != '\\' )
|
||||
start--;
|
||||
|
||||
if ( in[start] != '/' && in[start] != '\\' )
|
||||
if( in[start] != '/' && in[start] != '\\' )
|
||||
start = 0;
|
||||
else
|
||||
start++;
|
||||
|
@ -457,6 +449,7 @@ void COM_FileBase ( const char *in, char *out)
|
|||
|
||||
// Copy partial string
|
||||
strncpy( out, &in[start], len );
|
||||
|
||||
// Terminate it
|
||||
out[len] = 0;
|
||||
}
|
||||
|
@ -470,13 +463,13 @@ HUD_IsGame
|
|||
int HUD_IsGame( const char *game )
|
||||
{
|
||||
const char *gamedir;
|
||||
char gd[ 1024 ];
|
||||
char gd[1024];
|
||||
|
||||
gamedir = gEngfuncs.pfnGetGameDirectory();
|
||||
if ( gamedir && gamedir[0] )
|
||||
if( gamedir && gamedir[0] )
|
||||
{
|
||||
COM_FileBase( gamedir, gd );
|
||||
if ( !stricmp( gd, game ) )
|
||||
if( !stricmp( gd, game ) )
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
|
@ -491,27 +484,27 @@ Returns last FOV
|
|||
*/
|
||||
float HUD_GetFOV( void )
|
||||
{
|
||||
if ( gEngfuncs.pDemoAPI->IsRecording() )
|
||||
if( gEngfuncs.pDemoAPI->IsRecording() )
|
||||
{
|
||||
// Write it
|
||||
int i = 0;
|
||||
unsigned char buf[ 100 ];
|
||||
unsigned char buf[100];
|
||||
|
||||
// Active
|
||||
*( float * )&buf[ i ] = g_lastFOV;
|
||||
i += sizeof( float );
|
||||
*(float *)&buf[i] = g_lastFOV;
|
||||
i += sizeof(float);
|
||||
|
||||
Demo_WriteBuffer( TYPE_ZOOM, i, buf );
|
||||
}
|
||||
|
||||
if ( gEngfuncs.pDemoAPI->IsPlayingback() )
|
||||
if( gEngfuncs.pDemoAPI->IsPlayingback() )
|
||||
{
|
||||
g_lastFOV = g_demozoom;
|
||||
}
|
||||
return g_lastFOV;
|
||||
}
|
||||
|
||||
int CHud::MsgFunc_SetFOV(const char *pszName, int iSize, void *pbuf)
|
||||
int CHud::MsgFunc_SetFOV( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
|
@ -519,12 +512,12 @@ int CHud::MsgFunc_SetFOV(const char *pszName, int iSize, void *pbuf)
|
|||
int def_fov = CVAR_GET_FLOAT( "default_fov" );
|
||||
|
||||
//Weapon prediction already takes care of changing the fog. ( g_lastFOV ).
|
||||
if ( cl_lw && cl_lw->value )
|
||||
if( cl_lw && cl_lw->value )
|
||||
return 1;
|
||||
|
||||
g_lastFOV = newfov;
|
||||
|
||||
if ( newfov == 0 )
|
||||
if( newfov == 0 )
|
||||
{
|
||||
m_iFOV = def_fov;
|
||||
}
|
||||
|
@ -536,7 +529,7 @@ int CHud::MsgFunc_SetFOV(const char *pszName, int iSize, void *pbuf)
|
|||
// the clients fov is actually set in the client data update section of the hud
|
||||
|
||||
// Set a new sensitivity
|
||||
if ( m_iFOV == def_fov )
|
||||
if( m_iFOV == def_fov )
|
||||
{
|
||||
// reset to saved sensitivity
|
||||
m_flMouseSensitivity = 0;
|
||||
|
@ -550,24 +543,23 @@ int CHud::MsgFunc_SetFOV(const char *pszName, int iSize, void *pbuf)
|
|||
return 1;
|
||||
}
|
||||
|
||||
|
||||
void CHud::AddHudElem(CHudBase *phudelem)
|
||||
void CHud::AddHudElem( CHudBase *phudelem )
|
||||
{
|
||||
HUDLIST *pdl, *ptemp;
|
||||
|
||||
//phudelem->Think();
|
||||
//phudelem->Think();
|
||||
|
||||
if (!phudelem)
|
||||
if( !phudelem )
|
||||
return;
|
||||
|
||||
pdl = (HUDLIST *)malloc(sizeof(HUDLIST));
|
||||
if (!pdl)
|
||||
pdl = (HUDLIST *)malloc( sizeof(HUDLIST) );
|
||||
if( !pdl )
|
||||
return;
|
||||
|
||||
memset(pdl, 0, sizeof(HUDLIST));
|
||||
memset( pdl, 0, sizeof(HUDLIST) );
|
||||
pdl->p = phudelem;
|
||||
|
||||
if (!m_pHudList)
|
||||
if( !m_pHudList )
|
||||
{
|
||||
m_pHudList = pdl;
|
||||
return;
|
||||
|
@ -575,7 +567,7 @@ void CHud::AddHudElem(CHudBase *phudelem)
|
|||
|
||||
ptemp = m_pHudList;
|
||||
|
||||
while (ptemp->pNext)
|
||||
while( ptemp->pNext )
|
||||
ptemp = ptemp->pNext;
|
||||
|
||||
ptemp->pNext = pdl;
|
||||
|
@ -585,5 +577,3 @@ float CHud::GetSensitivity( void )
|
|||
{
|
||||
return m_flMouseSensitivity;
|
||||
}
|
||||
|
||||
|
||||
|
|
181
cl_dll/hud.h
181
cl_dll/hud.h
|
@ -20,7 +20,6 @@
|
|||
// CHud handles the message, calculation, and drawing the HUD
|
||||
//
|
||||
|
||||
|
||||
#define RGB_YELLOWISH 0x00FFA000 //255,160,0
|
||||
#define RGB_REDISH 0x00FF1010 //255,160,0
|
||||
#define RGB_GREENISH 0x0000A000 //0,160,0
|
||||
|
@ -36,7 +35,8 @@
|
|||
|
||||
#define HUDELEM_ACTIVE 1
|
||||
|
||||
typedef struct {
|
||||
typedef struct
|
||||
{
|
||||
int x, y;
|
||||
} POSITION;
|
||||
|
||||
|
@ -44,16 +44,16 @@ enum
|
|||
{
|
||||
MAX_PLAYERS = 64,
|
||||
MAX_TEAMS = 64,
|
||||
MAX_TEAM_NAME = 16,
|
||||
MAX_TEAM_NAME = 16
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
unsigned char r,g,b,a;
|
||||
typedef struct
|
||||
{
|
||||
unsigned char r, g, b, a;
|
||||
} RGBA;
|
||||
|
||||
typedef struct cvar_s cvar_t;
|
||||
|
||||
|
||||
#define HUD_ACTIVE 1
|
||||
#define HUD_INTERMISSION 2
|
||||
|
||||
|
@ -71,42 +71,39 @@ public:
|
|||
int m_type;
|
||||
int m_iFlags; // active, moving,
|
||||
virtual ~CHudBase() {}
|
||||
virtual int Init( void ) {return 0;}
|
||||
virtual int VidInit( void ) {return 0;}
|
||||
virtual int Draw(float flTime) {return 0;}
|
||||
virtual void Think(void) {return;}
|
||||
virtual void Reset(void) {return;}
|
||||
virtual int Init( void ) { return 0; }
|
||||
virtual int VidInit( void ) { return 0; }
|
||||
virtual int Draw( float flTime ) { return 0; }
|
||||
virtual void Think( void ) { return; }
|
||||
virtual void Reset( void ) { return; }
|
||||
virtual void InitHUDData( void ) {} // called every time a server is connected to
|
||||
|
||||
};
|
||||
|
||||
struct HUDLIST {
|
||||
struct HUDLIST
|
||||
{
|
||||
CHudBase *p;
|
||||
HUDLIST *pNext;
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
#include "hud_spectator.h"
|
||||
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
class CHudAmmo: public CHudBase
|
||||
class CHudAmmo : public CHudBase
|
||||
{
|
||||
public:
|
||||
int Init( void );
|
||||
int VidInit( void );
|
||||
int Draw(float flTime);
|
||||
void Think(void);
|
||||
void Reset(void);
|
||||
int DrawWList(float flTime);
|
||||
int MsgFunc_CurWeapon(const char *pszName, int iSize, void *pbuf);
|
||||
int MsgFunc_WeaponList(const char *pszName, int iSize, void *pbuf);
|
||||
int MsgFunc_AmmoX(const char *pszName, int iSize, void *pbuf);
|
||||
int Draw( float flTime );
|
||||
void Think( void );
|
||||
void Reset( void );
|
||||
int DrawWList( float flTime );
|
||||
int MsgFunc_CurWeapon( const char *pszName, int iSize, void *pbuf );
|
||||
int MsgFunc_WeaponList( const char *pszName, int iSize, void *pbuf );
|
||||
int MsgFunc_AmmoX( const char *pszName, int iSize, void *pbuf );
|
||||
int MsgFunc_AmmoPickup( const char *pszName, int iSize, void *pbuf );
|
||||
int MsgFunc_WeapPickup( const char *pszName, int iSize, void *pbuf );
|
||||
int MsgFunc_ItemPickup( const char *pszName, int iSize, void *pbuf );
|
||||
|
@ -131,16 +128,14 @@ private:
|
|||
float m_fFade;
|
||||
RGBA m_rgba;
|
||||
WEAPON *m_pWeapon;
|
||||
int m_HUD_bucket0;
|
||||
int m_HUD_bucket0;
|
||||
int m_HUD_selection;
|
||||
|
||||
};
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
|
||||
class CHudAmmoSecondary: public CHudBase
|
||||
class CHudAmmoSecondary : public CHudBase
|
||||
{
|
||||
public:
|
||||
int Init( void );
|
||||
|
@ -176,29 +171,27 @@ class CHudGeiger: public CHudBase
|
|||
public:
|
||||
int Init( void );
|
||||
int VidInit( void );
|
||||
int Draw(float flTime);
|
||||
int MsgFunc_Geiger(const char *pszName, int iSize, void *pbuf);
|
||||
int Draw( float flTime );
|
||||
int MsgFunc_Geiger( const char *pszName, int iSize, void *pbuf );
|
||||
|
||||
private:
|
||||
int m_iGeigerRange;
|
||||
|
||||
};
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
class CHudTrain: public CHudBase
|
||||
class CHudTrain : public CHudBase
|
||||
{
|
||||
public:
|
||||
int Init( void );
|
||||
int VidInit( void );
|
||||
int Draw(float flTime);
|
||||
int MsgFunc_Train(const char *pszName, int iSize, void *pbuf);
|
||||
int Draw( float flTime );
|
||||
int MsgFunc_Train( const char *pszName, int iSize, void *pbuf );
|
||||
|
||||
private:
|
||||
HSPRITE m_hSprite;
|
||||
int m_iPos;
|
||||
|
||||
};
|
||||
|
||||
//
|
||||
|
@ -206,7 +199,6 @@ private:
|
|||
//
|
||||
// REMOVED: Vgui has replaced this.
|
||||
//
|
||||
|
||||
class CHudMOTD : public CHudBase
|
||||
{
|
||||
public:
|
||||
|
@ -223,14 +215,13 @@ public:
|
|||
|
||||
protected:
|
||||
static int MOTD_DISPLAY_TIME;
|
||||
char m_szMOTD[ MAX_MOTD_LENGTH ];
|
||||
|
||||
char m_szMOTD[MAX_MOTD_LENGTH];
|
||||
|
||||
int m_iLines;
|
||||
int m_iMaxLength;
|
||||
};
|
||||
|
||||
|
||||
class CHudScoreboard: public CHudBase
|
||||
class CHudScoreboard : public CHudBase
|
||||
{
|
||||
public:
|
||||
int Init( void );
|
||||
|
@ -257,7 +248,6 @@ public:
|
|||
void GetAllPlayersInfo( void );
|
||||
};
|
||||
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
|
@ -274,10 +264,11 @@ public:
|
|||
int MsgFunc_StatusValue( const char *pszName, int iSize, void *pbuf );
|
||||
|
||||
protected:
|
||||
enum {
|
||||
enum
|
||||
{
|
||||
MAX_STATUSTEXT_LENGTH = 128,
|
||||
MAX_STATUSBAR_VALUES = 8,
|
||||
MAX_STATUSBAR_LINES = 2,
|
||||
MAX_STATUSBAR_LINES = 2
|
||||
};
|
||||
|
||||
char m_szStatusText[MAX_STATUSBAR_LINES][MAX_STATUSTEXT_LENGTH]; // a text string describing how the status bar is to be drawn
|
||||
|
@ -296,7 +287,7 @@ protected:
|
|||
// REMOVED: Vgui has replaced this.
|
||||
//
|
||||
/*
|
||||
class CHudScoreboard: public CHudBase
|
||||
class CHudScoreboard : public CHudBase
|
||||
{
|
||||
public:
|
||||
int Init( void );
|
||||
|
@ -319,13 +310,13 @@ public:
|
|||
int m_iShowscoresHeld;
|
||||
|
||||
void GetAllPlayersInfo( void );
|
||||
|
||||
private:
|
||||
struct cvar_s *cl_showpacketloss;
|
||||
|
||||
};
|
||||
*/
|
||||
|
||||
struct extra_player_info_t
|
||||
struct extra_player_info_t
|
||||
{
|
||||
short frags;
|
||||
short deaths;
|
||||
|
@ -334,7 +325,7 @@ struct extra_player_info_t
|
|||
char teamname[MAX_TEAM_NAME];
|
||||
};
|
||||
|
||||
struct team_info_t
|
||||
struct team_info_t
|
||||
{
|
||||
char name[MAX_TEAM_NAME];
|
||||
short frags;
|
||||
|
@ -348,11 +339,10 @@ struct team_info_t
|
|||
int teamnumber;
|
||||
};
|
||||
|
||||
extern hud_player_info_t g_PlayerInfoList[MAX_PLAYERS+1]; // player info from the engine
|
||||
extern extra_player_info_t g_PlayerExtraInfo[MAX_PLAYERS+1]; // additional player info sent directly to the client dll
|
||||
extern team_info_t g_TeamInfo[MAX_TEAMS+1];
|
||||
extern int g_IsSpectator[MAX_PLAYERS+1];
|
||||
|
||||
extern hud_player_info_t g_PlayerInfoList[MAX_PLAYERS + 1]; // player info from the engine
|
||||
extern extra_player_info_t g_PlayerExtraInfo[MAX_PLAYERS + 1]; // additional player info sent directly to the client dll
|
||||
extern team_info_t g_TeamInfo[MAX_TEAMS + 1];
|
||||
extern int g_IsSpectator[MAX_PLAYERS + 1];
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
|
@ -404,10 +394,9 @@ public:
|
|||
int MsgFunc_SayText( const char *pszName, int iSize, void *pbuf );
|
||||
void SayTextPrint( const char *pszBuf, int iBufSize, int clientIndex = -1 );
|
||||
void EnsureTextFitsInOneLineAndWrapIfHaveTo( int line );
|
||||
friend class CHudSpectator;
|
||||
friend class CHudSpectator;
|
||||
|
||||
private:
|
||||
|
||||
struct cvar_s * m_HUD_saytext;
|
||||
struct cvar_s * m_HUD_saytext_time;
|
||||
};
|
||||
|
@ -415,25 +404,24 @@ private:
|
|||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
class CHudBattery: public CHudBase
|
||||
class CHudBattery : public CHudBase
|
||||
{
|
||||
public:
|
||||
int Init( void );
|
||||
int VidInit( void );
|
||||
int Draw(float flTime);
|
||||
int MsgFunc_Battery(const char *pszName, int iSize, void *pbuf );
|
||||
int Draw( float flTime );
|
||||
int MsgFunc_Battery( const char *pszName, int iSize, void *pbuf );
|
||||
|
||||
private:
|
||||
HSPRITE m_hSprite1;
|
||||
HSPRITE m_hSprite2;
|
||||
wrect_t *m_prc1;
|
||||
wrect_t *m_prc2;
|
||||
int m_iBat;
|
||||
int m_iBat;
|
||||
float m_fFade;
|
||||
int m_iHeight; // width of the battery innards
|
||||
int m_iHeight; // width of the battery innards
|
||||
};
|
||||
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
|
@ -442,11 +430,11 @@ class CHudFlashlight: public CHudBase
|
|||
public:
|
||||
int Init( void );
|
||||
int VidInit( void );
|
||||
int Draw(float flTime);
|
||||
int Draw( float flTime );
|
||||
void Reset( void );
|
||||
int MsgFunc_Flashlight(const char *pszName, int iSize, void *pbuf );
|
||||
int MsgFunc_FlashBat(const char *pszName, int iSize, void *pbuf );
|
||||
|
||||
int MsgFunc_Flashlight( const char *pszName, int iSize, void *pbuf );
|
||||
int MsgFunc_FlashBat( const char *pszName, int iSize, void *pbuf );
|
||||
|
||||
private:
|
||||
HSPRITE m_hSprite1;
|
||||
HSPRITE m_hSprite2;
|
||||
|
@ -455,10 +443,10 @@ private:
|
|||
wrect_t *m_prc2;
|
||||
wrect_t *m_prcBeam;
|
||||
float m_flBat;
|
||||
int m_iBat;
|
||||
int m_fOn;
|
||||
int m_iBat;
|
||||
int m_fOn;
|
||||
float m_fFade;
|
||||
int m_iWidth; // width of the battery innards
|
||||
int m_iWidth; // width of the battery innards
|
||||
};
|
||||
|
||||
//
|
||||
|
@ -486,31 +474,31 @@ struct message_parms_t
|
|||
//-----------------------------------------------------
|
||||
//
|
||||
|
||||
class CHudTextMessage: public CHudBase
|
||||
class CHudTextMessage : public CHudBase
|
||||
{
|
||||
public:
|
||||
int Init( void );
|
||||
static char *LocaliseTextString( const char *msg, char *dst_buffer, int buffer_size );
|
||||
static char *BufferedLocaliseTextString( const char *msg );
|
||||
char *LookupString( const char *msg_name, int *msg_dest = NULL );
|
||||
int MsgFunc_TextMsg(const char *pszName, int iSize, void *pbuf);
|
||||
int MsgFunc_TextMsg( const char *pszName, int iSize, void *pbuf );
|
||||
};
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
|
||||
class CHudMessage: public CHudBase
|
||||
class CHudMessage : public CHudBase
|
||||
{
|
||||
public:
|
||||
int Init( void );
|
||||
int VidInit( void );
|
||||
int Draw(float flTime);
|
||||
int MsgFunc_HudText(const char *pszName, int iSize, void *pbuf);
|
||||
int MsgFunc_GameTitle(const char *pszName, int iSize, void *pbuf);
|
||||
int Draw( float flTime );
|
||||
int MsgFunc_HudText( const char *pszName, int iSize, void *pbuf );
|
||||
int MsgFunc_GameTitle( const char *pszName, int iSize, void *pbuf );
|
||||
|
||||
float FadeBlend( float fadein, float fadeout, float hold, float localTime );
|
||||
int XPosition( float x, int width, int lineWidth );
|
||||
int XPosition( float x, int width, int lineWidth );
|
||||
int YPosition( float y, int height );
|
||||
|
||||
void MessageAdd( const char *pName, float time );
|
||||
|
@ -536,20 +524,20 @@ private:
|
|||
//
|
||||
#define MAX_SPRITE_NAME_LENGTH 24
|
||||
|
||||
class CHudStatusIcons: public CHudBase
|
||||
class CHudStatusIcons : public CHudBase
|
||||
{
|
||||
public:
|
||||
int Init( void );
|
||||
int VidInit( void );
|
||||
void Reset( void );
|
||||
int Draw(float flTime);
|
||||
int MsgFunc_StatusIcon(const char *pszName, int iSize, void *pbuf);
|
||||
int Draw( float flTime );
|
||||
int MsgFunc_StatusIcon( const char *pszName, int iSize, void *pbuf );
|
||||
|
||||
enum {
|
||||
enum
|
||||
{
|
||||
MAX_ICONSPRITENAME_LENGTH = MAX_SPRITE_NAME_LENGTH,
|
||||
MAX_ICONSPRITES = 4,
|
||||
MAX_ICONSPRITES = 4
|
||||
};
|
||||
|
||||
|
||||
//had to make these public so CHud could access them (to enable concussion icon)
|
||||
//could use a friend declaration instead...
|
||||
|
@ -557,7 +545,6 @@ public:
|
|||
void DisableIcon( char *pszIconName );
|
||||
|
||||
private:
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char szSpriteName[MAX_ICONSPRITENAME_LENGTH];
|
||||
|
@ -567,15 +554,11 @@ private:
|
|||
} icon_sprite_t;
|
||||
|
||||
icon_sprite_t m_IconList[MAX_ICONSPRITES];
|
||||
|
||||
};
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
|
||||
|
||||
|
||||
class CHud
|
||||
{
|
||||
private:
|
||||
|
@ -589,7 +572,6 @@ private:
|
|||
int m_iConcussionEffect;
|
||||
|
||||
public:
|
||||
|
||||
HSPRITE m_hsprCursor;
|
||||
float m_flTime; // the current client time
|
||||
float m_fOldTime; // the time at which the HUD was last redrawn
|
||||
|
@ -605,13 +587,13 @@ public:
|
|||
cvar_t *m_pCvarDraw;
|
||||
|
||||
int m_iFontHeight;
|
||||
int DrawHudNumber(int x, int y, int iFlags, int iNumber, int r, int g, int b );
|
||||
int DrawHudString(int x, int y, int iMaxX, char *szString, int r, int g, int b );
|
||||
int DrawHudNumber( int x, int y, int iFlags, int iNumber, int r, int g, int b );
|
||||
int DrawHudString( int x, int y, int iMaxX, char *szString, int r, int g, int b );
|
||||
int DrawHudStringReverse( int xpos, int ypos, int iMinX, char *szString, int r, int g, int b );
|
||||
int DrawHudNumberString( int xpos, int ypos, int iMinX, int iNumber, int r, int g, int b );
|
||||
int GetNumWidth(int iNumber, int iFlags);
|
||||
int GetNumWidth( int iNumber, int iFlags );
|
||||
int DrawHudStringLen( char *szIt );
|
||||
void DrawDarkRectangle( int x, int y, int wide, int tall);
|
||||
void DrawDarkRectangle( int x, int y, int wide, int tall );
|
||||
|
||||
private:
|
||||
// the memory for these arrays are allocated in the first call to CHud::VidInit(), when the hud.txt and associated sprites are loaded.
|
||||
|
@ -624,14 +606,13 @@ private:
|
|||
public:
|
||||
HSPRITE GetSprite( int index )
|
||||
{
|
||||
return (index < 0) ? 0 : m_rghSprites[index];
|
||||
return ( index < 0 ) ? 0 : m_rghSprites[index];
|
||||
}
|
||||
|
||||
wrect_t& GetSpriteRect( int index )
|
||||
{
|
||||
return m_rgrcRects[index];
|
||||
}
|
||||
|
||||
|
||||
int GetSpriteIndex( const char *SpriteName ); // gets a sprite index, for use in the m_rghSprites[] array
|
||||
|
||||
|
@ -653,7 +634,6 @@ public:
|
|||
CHudScoreboard m_Scoreboard;
|
||||
CHudMOTD m_MOTD;
|
||||
|
||||
|
||||
void Init( void );
|
||||
void VidInit( void );
|
||||
void Think(void);
|
||||
|
@ -664,13 +644,13 @@ public:
|
|||
~CHud(); // destructor, frees allocated memory
|
||||
|
||||
// user messages
|
||||
int _cdecl MsgFunc_Damage(const char *pszName, int iSize, void *pbuf );
|
||||
int _cdecl MsgFunc_GameMode(const char *pszName, int iSize, void *pbuf );
|
||||
int _cdecl MsgFunc_Logo(const char *pszName, int iSize, void *pbuf);
|
||||
int _cdecl MsgFunc_ResetHUD(const char *pszName, int iSize, void *pbuf);
|
||||
int _cdecl MsgFunc_Damage( const char *pszName, int iSize, void *pbuf );
|
||||
int _cdecl MsgFunc_GameMode( const char *pszName, int iSize, void *pbuf );
|
||||
int _cdecl MsgFunc_Logo( const char *pszName, int iSize, void *pbuf );
|
||||
int _cdecl MsgFunc_ResetHUD( const char *pszName, int iSize, void *pbuf );
|
||||
void _cdecl MsgFunc_InitHUD( const char *pszName, int iSize, void *pbuf );
|
||||
void _cdecl MsgFunc_ViewMode( const char *pszName, int iSize, void *pbuf );
|
||||
int _cdecl MsgFunc_SetFOV(const char *pszName, int iSize, void *pbuf);
|
||||
int _cdecl MsgFunc_SetFOV( const char *pszName, int iSize, void *pbuf );
|
||||
int _cdecl MsgFunc_Concuss( const char *pszName, int iSize, void *pbuf );
|
||||
|
||||
// Screen information
|
||||
|
@ -685,13 +665,11 @@ public:
|
|||
|
||||
int m_iNoConsolePrint;
|
||||
|
||||
void AddHudElem(CHudBase *p);
|
||||
void AddHudElem( CHudBase *p );
|
||||
|
||||
float GetSensitivity();
|
||||
|
||||
};
|
||||
|
||||
|
||||
extern CHud gHUD;
|
||||
|
||||
extern int g_iPlayerClass;
|
||||
|
@ -699,4 +677,3 @@ extern int g_iTeamNumber;
|
|||
extern int g_iUser1;
|
||||
extern int g_iUser2;
|
||||
extern int g_iUser3;
|
||||
|
||||
|
|
|
@ -11,9 +11,8 @@
|
|||
|
||||
#include "exportdef.h"
|
||||
|
||||
typedef int (*pfnUserMsgHook)(const char *pszName, int iSize, void *pbuf);
|
||||
typedef int (*pfnUserMsgHook)( const char *pszName, int iSize, void *pbuf );
|
||||
#include "wrect.h"
|
||||
#include "../engine/cdll_int.h"
|
||||
extern cl_enginefunc_t gEngfuncs;
|
||||
|
||||
#endif
|
||||
|
|
|
@ -28,16 +28,16 @@ extern BEAM *pBeam2;
|
|||
|
||||
/// USER-DEFINED SERVER MESSAGE HANDLERS
|
||||
|
||||
int CHud :: MsgFunc_ResetHUD(const char *pszName, int iSize, void *pbuf )
|
||||
int CHud::MsgFunc_ResetHUD( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
ASSERT( iSize == 0 );
|
||||
|
||||
// clear all hud data
|
||||
HUDLIST *pList = m_pHudList;
|
||||
|
||||
while ( pList )
|
||||
while( pList )
|
||||
{
|
||||
if ( pList->p )
|
||||
if( pList->p )
|
||||
pList->p->Reset();
|
||||
pList = pList->pNext;
|
||||
}
|
||||
|
@ -51,21 +51,21 @@ int CHud :: MsgFunc_ResetHUD(const char *pszName, int iSize, void *pbuf )
|
|||
return 1;
|
||||
}
|
||||
|
||||
void CAM_ToFirstPerson(void);
|
||||
void CAM_ToFirstPerson( void );
|
||||
|
||||
void CHud :: MsgFunc_ViewMode( const char *pszName, int iSize, void *pbuf )
|
||||
void CHud::MsgFunc_ViewMode( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
CAM_ToFirstPerson();
|
||||
}
|
||||
|
||||
void CHud :: MsgFunc_InitHUD( const char *pszName, int iSize, void *pbuf )
|
||||
void CHud::MsgFunc_InitHUD( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
// prepare all hud data
|
||||
HUDLIST *pList = m_pHudList;
|
||||
|
||||
while (pList)
|
||||
while( pList )
|
||||
{
|
||||
if ( pList->p )
|
||||
if( pList->p )
|
||||
pList->p->InitHUDData();
|
||||
pList = pList->pNext;
|
||||
}
|
||||
|
@ -74,8 +74,7 @@ void CHud :: MsgFunc_InitHUD( const char *pszName, int iSize, void *pbuf )
|
|||
pBeam = pBeam2 = NULL;
|
||||
}
|
||||
|
||||
|
||||
int CHud :: MsgFunc_GameMode(const char *pszName, int iSize, void *pbuf )
|
||||
int CHud::MsgFunc_GameMode( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
m_Teamplay = READ_BYTE();
|
||||
|
@ -83,38 +82,36 @@ int CHud :: MsgFunc_GameMode(const char *pszName, int iSize, void *pbuf )
|
|||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int CHud :: MsgFunc_Damage(const char *pszName, int iSize, void *pbuf )
|
||||
int CHud::MsgFunc_Damage( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
int armor, blood;
|
||||
Vector from;
|
||||
int i;
|
||||
float count;
|
||||
|
||||
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
armor = READ_BYTE();
|
||||
blood = READ_BYTE();
|
||||
|
||||
for (i=0 ; i<3 ; i++)
|
||||
for( i = 0; i < 3; i++)
|
||||
from[i] = READ_COORD();
|
||||
|
||||
count = (blood * 0.5) + (armor * 0.5);
|
||||
count = ( blood * 0.5 ) + ( armor * 0.5 );
|
||||
|
||||
if (count < 10)
|
||||
if( count < 10 )
|
||||
count = 10;
|
||||
|
||||
// TODO: kick viewangles, show damage visually
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHud :: MsgFunc_Concuss( const char *pszName, int iSize, void *pbuf )
|
||||
int CHud::MsgFunc_Concuss( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
m_iConcussionEffect = READ_BYTE();
|
||||
if (m_iConcussionEffect)
|
||||
this->m_StatusIcons.EnableIcon("dmg_concuss",255,160,0);
|
||||
if( m_iConcussionEffect )
|
||||
this->m_StatusIcons.EnableIcon( "dmg_concuss", 255, 160, 0 );
|
||||
else
|
||||
this->m_StatusIcons.DisableIcon("dmg_concuss");
|
||||
this->m_StatusIcons.DisableIcon( "dmg_concuss" );
|
||||
return 1;
|
||||
}
|
||||
|
|
|
@ -20,17 +20,15 @@
|
|||
#include "cl_util.h"
|
||||
//#include "triangleapi.h"
|
||||
|
||||
|
||||
#define MAX_LOGO_FRAMES 56
|
||||
|
||||
int grgLogoFrame[MAX_LOGO_FRAMES] =
|
||||
int grgLogoFrame[MAX_LOGO_FRAMES] =
|
||||
{
|
||||
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13, 13, 13, 12, 11, 10, 9, 8, 14, 15,
|
||||
16, 17, 18, 19, 20, 20, 20, 20, 20, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
|
||||
29, 29, 29, 29, 29, 28, 27, 26, 25, 24, 30, 31
|
||||
};
|
||||
|
||||
|
||||
extern int g_iVisibleMouse;
|
||||
|
||||
float HUD_GetFOV( void );
|
||||
|
@ -38,20 +36,20 @@ float HUD_GetFOV( void );
|
|||
extern cvar_t *sensitivity;
|
||||
|
||||
// Think
|
||||
void CHud::Think(void)
|
||||
void CHud::Think( void )
|
||||
{
|
||||
int newfov;
|
||||
HUDLIST *pList = m_pHudList;
|
||||
|
||||
while (pList)
|
||||
while( pList )
|
||||
{
|
||||
if (pList->p->m_iFlags & HUD_ACTIVE)
|
||||
if( pList->p->m_iFlags & HUD_ACTIVE )
|
||||
pList->p->Think();
|
||||
pList = pList->pNext;
|
||||
}
|
||||
|
||||
newfov = HUD_GetFOV();
|
||||
if ( newfov == 0 )
|
||||
if( newfov == 0 )
|
||||
{
|
||||
m_iFOV = default_fov->value;
|
||||
}
|
||||
|
@ -61,22 +59,22 @@ void CHud::Think(void)
|
|||
}
|
||||
|
||||
// the clients fov is actually set in the client data update section of the hud
|
||||
|
||||
// Set a new sensitivity
|
||||
if ( m_iFOV == default_fov->value )
|
||||
{
|
||||
if( m_iFOV == default_fov->value )
|
||||
{
|
||||
// reset to saved sensitivity
|
||||
m_flMouseSensitivity = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
{
|
||||
// set a new sensitivity that is proportional to the change from the FOV default
|
||||
m_flMouseSensitivity = sensitivity->value * ((float)newfov / (float)default_fov->value) * CVAR_GET_FLOAT("zoom_sensitivity_ratio");
|
||||
}
|
||||
|
||||
// think about default fov
|
||||
if ( m_iFOV == 0 )
|
||||
{ // only let players adjust up in fov, and only if they are not overriden by something else
|
||||
if( m_iFOV == 0 )
|
||||
{
|
||||
// only let players adjust up in fov, and only if they are not overriden by something else
|
||||
m_iFOV = max( default_fov->value, 90 );
|
||||
}
|
||||
}
|
||||
|
@ -84,21 +82,20 @@ void CHud::Think(void)
|
|||
// Redraw
|
||||
// step through the local data, placing the appropriate graphics & text as appropriate
|
||||
// returns 1 if they've changed, 0 otherwise
|
||||
int CHud :: Redraw( float flTime, int intermission )
|
||||
int CHud::Redraw( float flTime, int intermission )
|
||||
{
|
||||
m_fOldTime = m_flTime; // save time of previous redraw
|
||||
m_flTime = flTime;
|
||||
m_flTimeDelta = (double)m_flTime - m_fOldTime;
|
||||
static float m_flShotTime = 0;
|
||||
|
||||
|
||||
// Clock was reset, reset delta
|
||||
if ( m_flTimeDelta < 0 )
|
||||
if( m_flTimeDelta < 0 )
|
||||
m_flTimeDelta = 0;
|
||||
|
||||
|
||||
if (m_flShotTime && m_flShotTime < flTime)
|
||||
if( m_flShotTime && m_flShotTime < flTime )
|
||||
{
|
||||
gEngfuncs.pfnClientCmd("snapshot\n");
|
||||
gEngfuncs.pfnClientCmd( "snapshot\n" );
|
||||
m_flShotTime = 0;
|
||||
}
|
||||
|
||||
|
@ -106,21 +103,22 @@ int CHud :: Redraw( float flTime, int intermission )
|
|||
|
||||
// if no redrawing is necessary
|
||||
// return 0;
|
||||
|
||||
if ( m_pCvarDraw->value )
|
||||
|
||||
if( m_pCvarDraw->value )
|
||||
{
|
||||
HUDLIST *pList = m_pHudList;
|
||||
|
||||
while (pList)
|
||||
while( pList )
|
||||
{
|
||||
if ( !intermission )
|
||||
if( !intermission )
|
||||
{
|
||||
if ( (pList->p->m_iFlags & HUD_ACTIVE) && !(m_iHideHUDDisplay & HIDEHUD_ALL) )
|
||||
pList->p->Draw(flTime);
|
||||
if ( ( pList->p->m_iFlags & HUD_ACTIVE ) && !( m_iHideHUDDisplay & HIDEHUD_ALL ) )
|
||||
pList->p->Draw( flTime );
|
||||
}
|
||||
else
|
||||
{ // it's an intermission, so only draw hud elements that are set to draw during intermissions
|
||||
if ( pList->p->m_iFlags & HUD_INTERMISSION )
|
||||
{
|
||||
// it's an intermission, so only draw hud elements that are set to draw during intermissions
|
||||
if( pList->p->m_iFlags & HUD_INTERMISSION )
|
||||
pList->p->Draw( flTime );
|
||||
}
|
||||
|
||||
|
@ -129,43 +127,43 @@ int CHud :: Redraw( float flTime, int intermission )
|
|||
}
|
||||
|
||||
// are we in demo mode? do we need to draw the logo in the top corner?
|
||||
if (m_iLogo)
|
||||
if( m_iLogo )
|
||||
{
|
||||
int x, y, i;
|
||||
|
||||
if (m_hsprLogo == 0)
|
||||
m_hsprLogo = LoadSprite("sprites/%d_logo.spr");
|
||||
if( m_hsprLogo == 0 )
|
||||
m_hsprLogo = LoadSprite( "sprites/%d_logo.spr" );
|
||||
|
||||
SPR_Set(m_hsprLogo, 250, 250, 250 );
|
||||
|
||||
x = SPR_Width(m_hsprLogo, 0);
|
||||
SPR_Set( m_hsprLogo, 250, 250, 250 );
|
||||
|
||||
x = SPR_Width( m_hsprLogo, 0 );
|
||||
x = ScreenWidth - x;
|
||||
y = SPR_Height(m_hsprLogo, 0)/2;
|
||||
y = SPR_Height( m_hsprLogo, 0 ) / 2;
|
||||
|
||||
// Draw the logo at 20 fps
|
||||
int iFrame = (int)(flTime * 20) % MAX_LOGO_FRAMES;
|
||||
int iFrame = (int)( flTime * 20 ) % MAX_LOGO_FRAMES;
|
||||
i = grgLogoFrame[iFrame] - 1;
|
||||
|
||||
SPR_DrawAdditive(i, x, y, NULL);
|
||||
SPR_DrawAdditive( i, x, y, NULL );
|
||||
}
|
||||
|
||||
/*
|
||||
if ( g_iVisibleMouse )
|
||||
if( g_iVisibleMouse )
|
||||
{
|
||||
void IN_GetMousePos( int *mx, int *my );
|
||||
int mx, my;
|
||||
|
||||
IN_GetMousePos( &mx, &my );
|
||||
|
||||
if (m_hsprCursor == 0)
|
||||
|
||||
if( m_hsprCursor == 0 )
|
||||
{
|
||||
char sz[256];
|
||||
sprintf( sz, "sprites/cursor.spr" );
|
||||
m_hsprCursor = SPR_Load( sz );
|
||||
}
|
||||
|
||||
SPR_Set(m_hsprCursor, 250, 250, 250 );
|
||||
|
||||
SPR_Set( m_hsprCursor, 250, 250, 250 );
|
||||
|
||||
// Draw the logo at 20 fps
|
||||
SPR_DrawAdditive( 0, mx, my, NULL );
|
||||
}
|
||||
|
@ -177,9 +175,9 @@ int CHud :: Redraw( float flTime, int intermission )
|
|||
void ScaleColors( int &r, int &g, int &b, int a )
|
||||
{
|
||||
float x = (float)a / 255;
|
||||
r = (int)(r * x);
|
||||
g = (int)(g * x);
|
||||
b = (int)(b * x);
|
||||
r = (int)( r * x );
|
||||
g = (int)( g * x );
|
||||
b = (int)( b * x );
|
||||
}
|
||||
|
||||
const unsigned char colors[8][3] =
|
||||
|
@ -194,11 +192,11 @@ const unsigned char colors[8][3] =
|
|||
{240, 180, 24}
|
||||
};
|
||||
|
||||
int CHud :: DrawHudString(int xpos, int ypos, int iMaxX, char *szIt, int r, int g, int b )
|
||||
int CHud::DrawHudString( int xpos, int ypos, int iMaxX, char *szIt, int r, int g, int b )
|
||||
{
|
||||
if( hud_textmode->value == 2 )
|
||||
{
|
||||
gEngfuncs.pfnDrawSetTextColor( r/255.0, g/255.0, b/255.0 );
|
||||
gEngfuncs.pfnDrawSetTextColor( r / 255.0, g / 255.0, b / 255.0 );
|
||||
return gEngfuncs.pfnDrawConsoleString( xpos, ypos, (char*) szIt );
|
||||
}
|
||||
|
||||
|
@ -206,18 +204,18 @@ int CHud :: DrawHudString(int xpos, int ypos, int iMaxX, char *szIt, int r, int
|
|||
TextMessageDrawChar( 0, 0, 0, 0, 0, 0 );
|
||||
|
||||
// draw the string until we hit the null character or a newline character
|
||||
for ( ; *szIt != 0 && *szIt != '\n'; szIt++ )
|
||||
for( ; *szIt != 0 && *szIt != '\n'; szIt++ )
|
||||
{
|
||||
int w = gHUD.m_scrinfo.charWidths[ 'M' ];
|
||||
if ( xpos + w > iMaxX )
|
||||
int w = gHUD.m_scrinfo.charWidths['M'];
|
||||
if( xpos + w > iMaxX )
|
||||
return xpos;
|
||||
if( (*szIt == '^') && (*(szIt + 1) >= '0') && (*(szIt + 1) <= '7') )
|
||||
if( ( *szIt == '^' ) && ( *( szIt + 1 ) >= '0') && ( *( szIt + 1 ) <= '7') )
|
||||
{
|
||||
szIt++;
|
||||
r = colors[ *szIt - '0' ][0];
|
||||
g = colors[ *szIt - '0' ][1];
|
||||
b = colors[ *szIt - '0' ][2];
|
||||
if( !*(++szIt))
|
||||
r = colors[*szIt - '0'][0];
|
||||
g = colors[*szIt - '0'][1];
|
||||
b = colors[*szIt - '0'][2];
|
||||
if( !*(++szIt) )
|
||||
return xpos;
|
||||
}
|
||||
int c = (unsigned int)(unsigned char)*szIt;
|
||||
|
@ -228,67 +226,65 @@ int CHud :: DrawHudString(int xpos, int ypos, int iMaxX, char *szIt, int r, int
|
|||
return xpos;
|
||||
}
|
||||
|
||||
int CHud :: DrawHudStringLen( char *szIt )
|
||||
int CHud::DrawHudStringLen( char *szIt )
|
||||
{
|
||||
int l = 0;
|
||||
for ( ; *szIt != 0 && *szIt != '\n'; szIt++ )
|
||||
for( ; *szIt != 0 && *szIt != '\n'; szIt++ )
|
||||
{
|
||||
l += gHUD.m_scrinfo.charWidths[ (unsigned char)*szIt ];
|
||||
l += gHUD.m_scrinfo.charWidths[(unsigned char)*szIt];
|
||||
}
|
||||
return l;
|
||||
}
|
||||
|
||||
|
||||
int CHud :: DrawHudNumberString( int xpos, int ypos, int iMinX, int iNumber, int r, int g, int b )
|
||||
int CHud::DrawHudNumberString( int xpos, int ypos, int iMinX, int iNumber, int r, int g, int b )
|
||||
{
|
||||
char szString[32];
|
||||
sprintf( szString, "%d", iNumber );
|
||||
return DrawHudStringReverse( xpos, ypos, iMinX, szString, r, g, b );
|
||||
|
||||
}
|
||||
|
||||
// draws a string from right to left (right-aligned)
|
||||
int CHud :: DrawHudStringReverse( int xpos, int ypos, int iMinX, char *szString, int r, int g, int b )
|
||||
int CHud::DrawHudStringReverse( int xpos, int ypos, int iMinX, char *szString, int r, int g, int b )
|
||||
{
|
||||
// find the end of the string
|
||||
for( char *szIt = szString; *szIt != 0; szIt++ )
|
||||
xpos -= gHUD.m_scrinfo.charWidths[ (unsigned char) *szIt ];
|
||||
xpos -= gHUD.m_scrinfo.charWidths[(unsigned char)*szIt];
|
||||
if( xpos < iMinX )
|
||||
xpos = iMinX;
|
||||
DrawHudString( xpos, ypos, gHUD.m_scrinfo.iWidth, szString, r, g, b );
|
||||
return xpos;
|
||||
}
|
||||
|
||||
int CHud :: DrawHudNumber( int x, int y, int iFlags, int iNumber, int r, int g, int b)
|
||||
int CHud::DrawHudNumber( int x, int y, int iFlags, int iNumber, int r, int g, int b )
|
||||
{
|
||||
int iWidth = GetSpriteRect(m_HUD_number_0).right - GetSpriteRect(m_HUD_number_0).left;
|
||||
int iWidth = GetSpriteRect( m_HUD_number_0 ).right - GetSpriteRect( m_HUD_number_0 ).left;
|
||||
int k;
|
||||
|
||||
if (iNumber > 0)
|
||||
if( iNumber > 0 )
|
||||
{
|
||||
// SPR_Draw 100's
|
||||
if (iNumber >= 100)
|
||||
if( iNumber >= 100 )
|
||||
{
|
||||
k = iNumber/100;
|
||||
SPR_Set(GetSprite(m_HUD_number_0 + k), r, g, b );
|
||||
SPR_DrawAdditive( 0, x, y, &GetSpriteRect(m_HUD_number_0 + k));
|
||||
k = iNumber / 100;
|
||||
SPR_Set( GetSprite( m_HUD_number_0 + k ), r, g, b );
|
||||
SPR_DrawAdditive( 0, x, y, &GetSpriteRect( m_HUD_number_0 + k ) );
|
||||
x += iWidth;
|
||||
}
|
||||
else if (iFlags & (DHN_3DIGITS))
|
||||
else if( iFlags & ( DHN_3DIGITS ) )
|
||||
{
|
||||
//SPR_DrawAdditive( 0, x, y, &rc );
|
||||
x += iWidth;
|
||||
}
|
||||
|
||||
// SPR_Draw 10's
|
||||
if (iNumber >= 10)
|
||||
if( iNumber >= 10 )
|
||||
{
|
||||
k = (iNumber % 100)/10;
|
||||
SPR_Set(GetSprite(m_HUD_number_0 + k), r, g, b );
|
||||
SPR_DrawAdditive( 0, x, y, &GetSpriteRect(m_HUD_number_0 + k));
|
||||
k = ( iNumber % 100 ) / 10;
|
||||
SPR_Set( GetSprite( m_HUD_number_0 + k ), r, g, b );
|
||||
SPR_DrawAdditive( 0, x, y, &GetSpriteRect( m_HUD_number_0 + k ) );
|
||||
x += iWidth;
|
||||
}
|
||||
else if (iFlags & (DHN_3DIGITS | DHN_2DIGITS))
|
||||
else if( iFlags & ( DHN_3DIGITS | DHN_2DIGITS ) )
|
||||
{
|
||||
//SPR_DrawAdditive( 0, x, y, &rc );
|
||||
x += iWidth;
|
||||
|
@ -296,70 +292,66 @@ int CHud :: DrawHudNumber( int x, int y, int iFlags, int iNumber, int r, int g,
|
|||
|
||||
// SPR_Draw ones
|
||||
k = iNumber % 10;
|
||||
SPR_Set(GetSprite(m_HUD_number_0 + k), r, g, b );
|
||||
SPR_DrawAdditive(0, x, y, &GetSpriteRect(m_HUD_number_0 + k));
|
||||
SPR_Set( GetSprite( m_HUD_number_0 + k ), r, g, b );
|
||||
SPR_DrawAdditive( 0, x, y, &GetSpriteRect( m_HUD_number_0 + k ) );
|
||||
x += iWidth;
|
||||
}
|
||||
else if (iFlags & DHN_DRAWZERO)
|
||||
}
|
||||
else if( iFlags & DHN_DRAWZERO )
|
||||
{
|
||||
SPR_Set(GetSprite(m_HUD_number_0), r, g, b );
|
||||
SPR_Set( GetSprite( m_HUD_number_0 ), r, g, b );
|
||||
|
||||
// SPR_Draw 100's
|
||||
if (iFlags & (DHN_3DIGITS))
|
||||
if( iFlags & ( DHN_3DIGITS ) )
|
||||
{
|
||||
//SPR_DrawAdditive( 0, x, y, &rc );
|
||||
x += iWidth;
|
||||
}
|
||||
|
||||
if (iFlags & (DHN_3DIGITS | DHN_2DIGITS))
|
||||
if( iFlags & ( DHN_3DIGITS | DHN_2DIGITS ) )
|
||||
{
|
||||
//SPR_DrawAdditive( 0, x, y, &rc );
|
||||
x += iWidth;
|
||||
}
|
||||
|
||||
// SPR_Draw ones
|
||||
|
||||
SPR_DrawAdditive( 0, x, y, &GetSpriteRect(m_HUD_number_0));
|
||||
SPR_DrawAdditive( 0, x, y, &GetSpriteRect( m_HUD_number_0 ) );
|
||||
x += iWidth;
|
||||
}
|
||||
|
||||
return x;
|
||||
}
|
||||
|
||||
|
||||
int CHud::GetNumWidth( int iNumber, int iFlags )
|
||||
{
|
||||
if (iFlags & (DHN_3DIGITS))
|
||||
if( iFlags & ( DHN_3DIGITS ) )
|
||||
return 3;
|
||||
|
||||
if (iFlags & (DHN_2DIGITS))
|
||||
if( iFlags & ( DHN_2DIGITS ) )
|
||||
return 2;
|
||||
|
||||
if (iNumber <= 0)
|
||||
if( iNumber <= 0 )
|
||||
{
|
||||
if (iFlags & (DHN_DRAWZERO))
|
||||
if( iFlags & ( DHN_DRAWZERO ) )
|
||||
return 1;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (iNumber < 10)
|
||||
if( iNumber < 10 )
|
||||
return 1;
|
||||
|
||||
if (iNumber < 100)
|
||||
if( iNumber < 100 )
|
||||
return 2;
|
||||
|
||||
return 3;
|
||||
|
||||
}
|
||||
|
||||
|
||||
void CHud::DrawDarkRectangle( int x, int y, int wide, int tall )
|
||||
{
|
||||
//gEngfuncs.pTriAPI->RenderMode( kRenderTransTexture );
|
||||
gEngfuncs.pfnFillRGBABlend( x, y, wide, tall, 0, 0, 0, 255 * 0.6 );
|
||||
FillRGBA( x+1, y, wide-1, 1, 255, 140, 0, 255 );
|
||||
FillRGBA( x, y, 1, tall-1, 255, 140, 0, 255 );
|
||||
FillRGBA( x+wide-1, y+1, 1, tall-1, 255, 140, 0, 255 );
|
||||
FillRGBA( x, y+tall-1, wide-1, 1, 255, 140, 0, 255 );
|
||||
FillRGBA( x + 1, y, wide - 1, 1, 255, 140, 0, 255 );
|
||||
FillRGBA( x, y, 1, tall - 1, 255, 140, 0, 255 );
|
||||
FillRGBA( x + wide - 1, y + 1, 1, tall - 1, 255, 140, 0, 255 );
|
||||
FillRGBA( x, y + tall - 1, wide - 1, 1, 255, 140, 0, 255 );
|
||||
}
|
||||
|
|
|
@ -39,7 +39,7 @@ Callback from engine
|
|||
*/
|
||||
void NET_CALLBACK ListResponse( struct net_response_s *response )
|
||||
{
|
||||
if ( g_pServers )
|
||||
if( g_pServers )
|
||||
{
|
||||
g_pServers->ListResponse( response );
|
||||
}
|
||||
|
@ -54,7 +54,7 @@ Callback from engine
|
|||
*/
|
||||
void NET_CALLBACK ServerResponse( struct net_response_s *response )
|
||||
{
|
||||
if ( g_pServers )
|
||||
if( g_pServers )
|
||||
{
|
||||
g_pServers->ServerResponse( response );
|
||||
}
|
||||
|
@ -69,7 +69,7 @@ Callback from engine
|
|||
*/
|
||||
void NET_CALLBACK PingResponse( struct net_response_s *response )
|
||||
{
|
||||
if ( g_pServers )
|
||||
if( g_pServers )
|
||||
{
|
||||
g_pServers->PingResponse( response );
|
||||
}
|
||||
|
@ -84,11 +84,12 @@ Callback from engine
|
|||
*/
|
||||
void NET_CALLBACK RulesResponse( struct net_response_s *response )
|
||||
{
|
||||
if ( g_pServers )
|
||||
if( g_pServers )
|
||||
{
|
||||
g_pServers->RulesResponse( response );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
PlayersResponse
|
||||
|
@ -98,11 +99,12 @@ Callback from engine
|
|||
*/
|
||||
void NET_CALLBACK PlayersResponse( struct net_response_s *response )
|
||||
{
|
||||
if ( g_pServers )
|
||||
if( g_pServers )
|
||||
{
|
||||
g_pServers->PlayersResponse( response );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
ListResponse
|
||||
|
@ -115,20 +117,20 @@ void CHudServers::ListResponse( struct net_response_s *response )
|
|||
request_t *p;
|
||||
int c = 0;
|
||||
|
||||
if ( !( response->error == NET_SUCCESS ) )
|
||||
if( !( response->error == NET_SUCCESS ) )
|
||||
return;
|
||||
|
||||
if ( response->type != NETAPI_REQUEST_SERVERLIST )
|
||||
if( response->type != NETAPI_REQUEST_SERVERLIST )
|
||||
return;
|
||||
|
||||
if ( response->response )
|
||||
if( response->response )
|
||||
{
|
||||
list = ( request_t * ) response->response;
|
||||
while ( list )
|
||||
{
|
||||
c++;
|
||||
|
||||
//if ( c < 40 )
|
||||
//if( c < 40 )
|
||||
{
|
||||
// Copy from parsed stuff
|
||||
p = new request_t;
|
||||
|
@ -161,23 +163,23 @@ void CHudServers::ServerResponse( struct net_response_s *response )
|
|||
request_t *p;
|
||||
server_t *browser;
|
||||
int len;
|
||||
char sz[ 32 ];
|
||||
char sz[32];
|
||||
|
||||
// Remove from active list
|
||||
p = FindRequest( response->context, m_pActiveList );
|
||||
if ( p )
|
||||
if( p )
|
||||
{
|
||||
RemoveServerFromList( &m_pActiveList, p );
|
||||
m_nActiveQueries--;
|
||||
}
|
||||
|
||||
if ( response->error != NET_SUCCESS )
|
||||
|
||||
if( response->error != NET_SUCCESS )
|
||||
return;
|
||||
|
||||
|
||||
switch ( response->type )
|
||||
{
|
||||
case NETAPI_REQUEST_DETAILS:
|
||||
if ( response->response )
|
||||
if( response->response )
|
||||
{
|
||||
szresponse = (char *)response->response;
|
||||
len = strlen( szresponse ) + 100 + 1;
|
||||
|
@ -185,13 +187,13 @@ void CHudServers::ServerResponse( struct net_response_s *response )
|
|||
|
||||
browser = new server_t;
|
||||
browser->remote_address = response->remote_address;
|
||||
browser->info = new char[ len ];
|
||||
browser->info = new char[len];
|
||||
browser->ping = (int)( 1000.0 * response->ping );
|
||||
strcpy( browser->info, szresponse );
|
||||
|
||||
NET_API->SetValueForKey( browser->info, "address", gEngfuncs.pNetAPI->AdrToString( &response->remote_address ), len );
|
||||
NET_API->SetValueForKey( browser->info, "ping", sz, len );
|
||||
|
||||
|
||||
AddServer( &m_pServers, browser );
|
||||
}
|
||||
break;
|
||||
|
@ -208,12 +210,12 @@ PingResponse
|
|||
*/
|
||||
void CHudServers::PingResponse( struct net_response_s *response )
|
||||
{
|
||||
char sz[ 32 ];
|
||||
char sz[32];
|
||||
|
||||
if ( response->error != NET_SUCCESS )
|
||||
if( response->error != NET_SUCCESS )
|
||||
return;
|
||||
|
||||
switch ( response->type )
|
||||
switch( response->type )
|
||||
{
|
||||
case NETAPI_REQUEST_PING:
|
||||
sprintf( sz, "%.2f", 1000.0 * response->ping );
|
||||
|
@ -235,13 +237,13 @@ void CHudServers::RulesResponse( struct net_response_s *response )
|
|||
{
|
||||
char *szresponse;
|
||||
|
||||
if ( response->error != NET_SUCCESS )
|
||||
if( response->error != NET_SUCCESS )
|
||||
return;
|
||||
|
||||
switch ( response->type )
|
||||
switch( response->type )
|
||||
{
|
||||
case NETAPI_REQUEST_RULES:
|
||||
if ( response->response )
|
||||
if( response->response )
|
||||
{
|
||||
szresponse = (char *)response->response;
|
||||
|
||||
|
@ -263,13 +265,13 @@ void CHudServers::PlayersResponse( struct net_response_s *response )
|
|||
{
|
||||
char *szresponse;
|
||||
|
||||
if ( response->error != NET_SUCCESS )
|
||||
if( response->error != NET_SUCCESS )
|
||||
return;
|
||||
|
||||
switch ( response->type )
|
||||
|
||||
switch( response->type )
|
||||
{
|
||||
case NETAPI_REQUEST_PLAYERS:
|
||||
if ( response->response )
|
||||
if( response->response )
|
||||
{
|
||||
szresponse = (char *)response->response;
|
||||
|
||||
|
@ -288,24 +290,24 @@ CompareServers
|
|||
Return 1 if p1 is "less than" p2, 0 otherwise
|
||||
===================
|
||||
*/
|
||||
int CHudServers::CompareServers( server_t *p1, server_t *p2 )
|
||||
int CHudServers::CompareServers( server_t *p1, server_t *p2 )
|
||||
{
|
||||
const char *n1, *n2;
|
||||
|
||||
if ( p1->ping < p2->ping )
|
||||
if( p1->ping < p2->ping )
|
||||
return 1;
|
||||
|
||||
if ( p1->ping == p2->ping )
|
||||
if( p1->ping == p2->ping )
|
||||
{
|
||||
// Pings equal, sort by second key: hostname
|
||||
if ( p1->info && p2->info )
|
||||
if( p1->info && p2->info )
|
||||
{
|
||||
n1 = NET_API->ValueForKey( p1->info, "hostname" );
|
||||
n2 = NET_API->ValueForKey( p2->info, "hostname" );
|
||||
|
||||
if ( n1 && n2 )
|
||||
if( n1 && n2 )
|
||||
{
|
||||
if ( stricmp( n1, n2 ) < 0 )
|
||||
if( stricmp( n1, n2 ) < 0 )
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
@ -322,9 +324,9 @@ AddServer
|
|||
*/
|
||||
void CHudServers::AddServer( server_t **ppList, server_t *p )
|
||||
{
|
||||
server_t *list;
|
||||
server_t *list;
|
||||
|
||||
if ( !ppList || ! p )
|
||||
if( !ppList || ! p )
|
||||
return;
|
||||
|
||||
m_nServerCount++;
|
||||
|
@ -333,7 +335,7 @@ server_t *list;
|
|||
list = *ppList;
|
||||
|
||||
// Head of list?
|
||||
if ( !list )
|
||||
if( !list )
|
||||
{
|
||||
p->next = NULL;
|
||||
*ppList = p;
|
||||
|
@ -341,17 +343,17 @@ server_t *list;
|
|||
}
|
||||
|
||||
// Put on head of list
|
||||
if ( CompareServers( p, list ) )
|
||||
if( CompareServers( p, list ) )
|
||||
{
|
||||
p->next = *ppList;
|
||||
*ppList = p;
|
||||
}
|
||||
else
|
||||
{
|
||||
while ( list->next )
|
||||
while( list->next )
|
||||
{
|
||||
// Insert before list next
|
||||
if ( CompareServers( p, list->next ) )
|
||||
if( CompareServers( p, list->next ) )
|
||||
{
|
||||
p->next = list->next->next;
|
||||
list->next = p;
|
||||
|
@ -377,15 +379,15 @@ void CHudServers::Think( double time )
|
|||
{
|
||||
m_fElapsed += time;
|
||||
|
||||
if ( !m_nRequesting )
|
||||
if( !m_nRequesting )
|
||||
return;
|
||||
|
||||
if ( !m_nQuerying )
|
||||
if( !m_nQuerying )
|
||||
return;
|
||||
|
||||
QueryThink();
|
||||
|
||||
if ( ServerListSize() > 0 )
|
||||
if( ServerListSize() > 0 )
|
||||
return;
|
||||
|
||||
m_dStarted = 0.0;
|
||||
|
@ -405,25 +407,25 @@ void CHudServers::QueryThink( void )
|
|||
{
|
||||
request_t *p;
|
||||
|
||||
if ( !m_nRequesting || m_nDone )
|
||||
if( !m_nRequesting || m_nDone )
|
||||
return;
|
||||
|
||||
if ( !m_nQuerying )
|
||||
if( !m_nQuerying )
|
||||
return;
|
||||
|
||||
if ( m_nActiveQueries > MAX_QUERIES )
|
||||
if( m_nActiveQueries > MAX_QUERIES )
|
||||
return;
|
||||
|
||||
// Nothing left
|
||||
if ( !m_pServerList )
|
||||
if( !m_pServerList )
|
||||
return;
|
||||
|
||||
while ( 1 )
|
||||
while( 1 )
|
||||
{
|
||||
p = m_pServerList;
|
||||
|
||||
// No more in list?
|
||||
if ( !p )
|
||||
if( !p )
|
||||
break;
|
||||
|
||||
// Move to next
|
||||
|
@ -443,7 +445,7 @@ void CHudServers::QueryThink( void )
|
|||
m_pActiveList = p;
|
||||
|
||||
// Too many active?
|
||||
if ( m_nActiveQueries > MAX_QUERIES )
|
||||
if( m_nActiveQueries > MAX_QUERIES )
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -455,20 +457,20 @@ ServerListSize
|
|||
# of servers in active query and in pending to be queried lists
|
||||
==================
|
||||
*/
|
||||
int CHudServers::ServerListSize( void )
|
||||
int CHudServers::ServerListSize( void )
|
||||
{
|
||||
int c = 0;
|
||||
request_t *p;
|
||||
|
||||
p = m_pServerList;
|
||||
while ( p )
|
||||
while( p )
|
||||
{
|
||||
c++;
|
||||
p = p->next;
|
||||
}
|
||||
|
||||
p = m_pActiveList;
|
||||
while ( p )
|
||||
while( p )
|
||||
{
|
||||
c++;
|
||||
p = p->next;
|
||||
|
@ -488,9 +490,9 @@ CHudServers::request_t *CHudServers::FindRequest( int context, request_t *pList
|
|||
{
|
||||
request_t *p;
|
||||
p = pList;
|
||||
while ( p )
|
||||
while( p )
|
||||
{
|
||||
if ( context == p->context )
|
||||
if( context == p->context )
|
||||
return p;
|
||||
|
||||
p = p->next;
|
||||
|
@ -510,14 +512,14 @@ void CHudServers::RemoveServerFromList( request_t **ppList, request_t *item )
|
|||
request_t *p, *n;
|
||||
request_t *newlist = NULL;
|
||||
|
||||
if ( !ppList )
|
||||
if( !ppList )
|
||||
return;
|
||||
|
||||
p = *ppList;
|
||||
while ( p )
|
||||
while( p )
|
||||
{
|
||||
n = p->next;
|
||||
if ( p != item )
|
||||
if( p != item )
|
||||
{
|
||||
p->next = newlist;
|
||||
newlist = p;
|
||||
|
@ -537,11 +539,11 @@ void CHudServers::ClearRequestList( request_t **ppList )
|
|||
{
|
||||
request_t *p, *n;
|
||||
|
||||
if ( !ppList )
|
||||
if( !ppList )
|
||||
return;
|
||||
|
||||
p = *ppList;
|
||||
while ( p )
|
||||
while( p )
|
||||
{
|
||||
n = p->next;
|
||||
delete p;
|
||||
|
@ -560,11 +562,11 @@ void CHudServers::ClearServerList( server_t **ppList )
|
|||
{
|
||||
server_t *p, *n;
|
||||
|
||||
if ( !ppList )
|
||||
if( !ppList )
|
||||
return;
|
||||
|
||||
p = *ppList;
|
||||
while ( p )
|
||||
while( p )
|
||||
{
|
||||
n = p->next;
|
||||
delete[] p->info;
|
||||
|
@ -585,11 +587,11 @@ int CompareField( CHudServers::server_t *p1, CHudServers::server_t *p2, const ch
|
|||
fv1 = atof( sz1 );
|
||||
fv2 = atof( sz2 );
|
||||
|
||||
if ( fv1 && fv2 )
|
||||
if( fv1 && fv2 )
|
||||
{
|
||||
if ( fv1 > fv2 )
|
||||
if( fv1 > fv2 )
|
||||
return iSortOrder;
|
||||
else if ( fv1 < fv2 )
|
||||
else if( fv1 < fv2 )
|
||||
return -iSortOrder;
|
||||
else
|
||||
return 0;
|
||||
|
@ -601,7 +603,7 @@ int CompareField( CHudServers::server_t *p1, CHudServers::server_t *p2, const ch
|
|||
|
||||
int CALLBACK ServerListCompareFunc( CHudServers::server_t *p1, CHudServers::server_t *p2, const char *fieldname )
|
||||
{
|
||||
if (!p1 || !p2) // No meaningful comparison
|
||||
if(!p1 || !p2) // No meaningful comparison
|
||||
return 0;
|
||||
|
||||
int iSortOrder = 1;
|
||||
|
@ -613,8 +615,8 @@ int CALLBACK ServerListCompareFunc( CHudServers::server_t *p1, CHudServers::serv
|
|||
return retval;
|
||||
}
|
||||
|
||||
static char g_fieldname[ 256 ];
|
||||
int __cdecl FnServerCompare(const void *elem1, const void *elem2 )
|
||||
static char g_fieldname[256];
|
||||
int __cdecl FnServerCompare( const void *elem1, const void *elem2 )
|
||||
{
|
||||
CHudServers::server_t *list1, *list2;
|
||||
|
||||
|
@ -628,7 +630,7 @@ void CHudServers::SortServers( const char *fieldname )
|
|||
{
|
||||
server_t *p;
|
||||
// Create a list
|
||||
if ( !m_pServers )
|
||||
if( !m_pServers )
|
||||
return;
|
||||
|
||||
strcpy( g_fieldname, fieldname );
|
||||
|
@ -637,7 +639,7 @@ void CHudServers::SortServers( const char *fieldname )
|
|||
int c = 0;
|
||||
|
||||
p = m_pServers;
|
||||
while ( p )
|
||||
while( p )
|
||||
{
|
||||
c++;
|
||||
p = p->next;
|
||||
|
@ -645,21 +647,21 @@ void CHudServers::SortServers( const char *fieldname )
|
|||
|
||||
server_t **pSortArray;
|
||||
|
||||
pSortArray = new server_t *[ c ];
|
||||
memset( pSortArray, 0, c * sizeof( server_t * ) );
|
||||
pSortArray = new server_t *[c];
|
||||
memset( pSortArray, 0, c * sizeof(server_t*) );
|
||||
|
||||
// Now copy the list into the pSortArray:
|
||||
p = m_pServers;
|
||||
i = 0;
|
||||
while ( p )
|
||||
while( p )
|
||||
{
|
||||
pSortArray[ i++ ] = p;
|
||||
pSortArray[i++] = p;
|
||||
p = p->next;
|
||||
}
|
||||
|
||||
// Now do that actual sorting.
|
||||
size_t nCount = c;
|
||||
size_t nSize = sizeof( server_t * );
|
||||
size_t nSize = sizeof(server_t*);
|
||||
|
||||
qsort(
|
||||
pSortArray,
|
||||
|
@ -670,11 +672,11 @@ void CHudServers::SortServers( const char *fieldname )
|
|||
|
||||
// Now rebuild the list.
|
||||
m_pServers = pSortArray[0];
|
||||
for ( i = 0; i < c - 1; i++ )
|
||||
for( i = 0; i < c - 1; i++ )
|
||||
{
|
||||
pSortArray[ i ]->next = pSortArray[ i + 1 ];
|
||||
pSortArray[i]->next = pSortArray[i + 1];
|
||||
}
|
||||
pSortArray[ c - 1 ]->next = NULL;
|
||||
pSortArray[c - 1]->next = NULL;
|
||||
|
||||
// Clean Up.
|
||||
delete[] pSortArray;
|
||||
|
@ -693,9 +695,9 @@ CHudServers::server_t *CHudServers::GetServer( int server )
|
|||
server_t *p;
|
||||
|
||||
p = m_pServers;
|
||||
while ( p )
|
||||
while( p )
|
||||
{
|
||||
if ( c == server )
|
||||
if( c == server )
|
||||
return p;
|
||||
|
||||
c++;
|
||||
|
@ -714,7 +716,7 @@ Return info ( key/value ) string for particular server
|
|||
char *CHudServers::GetServerInfo( int server )
|
||||
{
|
||||
server_t *p = GetServer( server );
|
||||
if ( p )
|
||||
if( p )
|
||||
{
|
||||
return p->info;
|
||||
}
|
||||
|
@ -731,8 +733,8 @@ Kill all pending requests in engine
|
|||
void CHudServers::CancelRequest( void )
|
||||
{
|
||||
m_nRequesting = 0;
|
||||
m_nQuerying = 0;
|
||||
m_nDone = 1;
|
||||
m_nQuerying = 0;
|
||||
m_nDone = 1;
|
||||
|
||||
NET_API->CancelAllRequests();
|
||||
}
|
||||
|
@ -747,16 +749,16 @@ Loads the master server addresses from file and into the passed in array
|
|||
int CHudServers::LoadMasterAddresses( int maxservers, int *count, netadr_t *padr )
|
||||
{
|
||||
int i;
|
||||
char szMaster[ 256 ];
|
||||
char szMaster[256];
|
||||
char szMasterFile[256];
|
||||
char *pbuffer = NULL;
|
||||
char *pstart = NULL ;
|
||||
netadr_t adr;
|
||||
char szAdr[64];
|
||||
int nPort;
|
||||
int nCount = 0;
|
||||
int nPort;
|
||||
int nCount = 0;
|
||||
bool bIgnore;
|
||||
int nDefaultPort;
|
||||
int nDefaultPort;
|
||||
|
||||
// Assume default master and master file
|
||||
strcpy( szMaster, VALVE_MASTER_ADDRESS ); // IP:PORT string
|
||||
|
@ -764,30 +766,30 @@ int CHudServers::LoadMasterAddresses( int maxservers, int *count, netadr_t *padr
|
|||
|
||||
// See if there is a command line override
|
||||
i = gEngfuncs.CheckParm( "-comm", &pstart );
|
||||
if ( i && pstart )
|
||||
if( i && pstart )
|
||||
{
|
||||
strcpy (szMasterFile, pstart );
|
||||
strcpy( szMasterFile, pstart );
|
||||
}
|
||||
|
||||
// Read them in from proper file
|
||||
pbuffer = (char *)gEngfuncs.COM_LoadFile( szMasterFile, 5, NULL ); // Use malloc
|
||||
if ( !pbuffer )
|
||||
if( !pbuffer )
|
||||
{
|
||||
goto finish_master;
|
||||
}
|
||||
|
||||
pstart = pbuffer;
|
||||
|
||||
while ( nCount < maxservers )
|
||||
while( nCount < maxservers )
|
||||
{
|
||||
pstart = gEngfuncs.COM_ParseFile( pstart, m_szToken );
|
||||
|
||||
if ( strlen(m_szToken) <= 0)
|
||||
if( strlen( m_szToken ) <= 0)
|
||||
break;
|
||||
|
||||
bIgnore = true;
|
||||
|
||||
if ( !stricmp( m_szToken, "Master" ) )
|
||||
if( !stricmp( m_szToken, "Master" ) )
|
||||
{
|
||||
nDefaultPort = PORT_MASTER;
|
||||
bIgnore = FALSE;
|
||||
|
@ -795,74 +797,72 @@ int CHudServers::LoadMasterAddresses( int maxservers, int *count, netadr_t *padr
|
|||
|
||||
// Now parse all addresses between { }
|
||||
pstart = gEngfuncs.COM_ParseFile( pstart, m_szToken );
|
||||
if ( strlen(m_szToken) <= 0 )
|
||||
if( strlen( m_szToken ) <= 0 )
|
||||
break;
|
||||
|
||||
if ( stricmp ( m_szToken, "{" ) )
|
||||
if( stricmp( m_szToken, "{" ) )
|
||||
break;
|
||||
|
||||
// Parse addresses until we get to "}"
|
||||
while ( nCount < maxservers )
|
||||
while( nCount < maxservers )
|
||||
{
|
||||
char base[256];
|
||||
|
||||
// Now parse all addresses between { }
|
||||
pstart = gEngfuncs.COM_ParseFile( pstart, m_szToken );
|
||||
|
||||
if (strlen(m_szToken) <= 0)
|
||||
if( strlen( m_szToken ) <= 0 )
|
||||
break;
|
||||
|
||||
if ( !stricmp ( m_szToken, "}" ) )
|
||||
if( !stricmp ( m_szToken, "}" ) )
|
||||
break;
|
||||
|
||||
|
||||
sprintf( base, "%s", m_szToken );
|
||||
|
||||
pstart = gEngfuncs.COM_ParseFile( pstart, m_szToken );
|
||||
|
||||
if (strlen(m_szToken) <= 0)
|
||||
if( strlen( m_szToken ) <= 0 )
|
||||
break;
|
||||
|
||||
if ( stricmp( m_szToken, ":" ) )
|
||||
if( stricmp( m_szToken, ":" ) )
|
||||
break;
|
||||
|
||||
pstart = gEngfuncs.COM_ParseFile( pstart, m_szToken );
|
||||
|
||||
if (strlen(m_szToken) <= 0)
|
||||
|
||||
if( strlen( m_szToken ) <= 0 )
|
||||
break;
|
||||
|
||||
nPort = atoi ( m_szToken );
|
||||
if ( !nPort )
|
||||
nPort = atoi( m_szToken );
|
||||
if( !nPort )
|
||||
nPort = nDefaultPort;
|
||||
|
||||
sprintf( szAdr, "%s:%i", base, nPort );
|
||||
|
||||
// Can we resolve it any better
|
||||
if ( !NET_API->StringToAdr( szAdr, &adr ) )
|
||||
if( !NET_API->StringToAdr( szAdr, &adr ) )
|
||||
bIgnore = true;
|
||||
|
||||
if ( !bIgnore )
|
||||
if( !bIgnore )
|
||||
{
|
||||
padr[ nCount++ ] = adr;
|
||||
padr[nCount++] = adr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
finish_master:
|
||||
if ( !nCount )
|
||||
if( !nCount )
|
||||
{
|
||||
sprintf( szMaster, VALVE_MASTER_ADDRESS ); // IP:PORT string
|
||||
|
||||
// Convert to netadr_t
|
||||
if ( NET_API->StringToAdr ( szMaster, &adr ) )
|
||||
if( NET_API->StringToAdr( szMaster, &adr ) )
|
||||
{
|
||||
|
||||
padr[ nCount++ ] = adr;
|
||||
padr[nCount++] = adr;
|
||||
}
|
||||
}
|
||||
|
||||
*count = nCount;
|
||||
|
||||
if ( pbuffer )
|
||||
if( pbuffer )
|
||||
{
|
||||
gEngfuncs.COM_FreeFile( pbuffer );
|
||||
}
|
||||
|
@ -879,14 +879,14 @@ Request list of game servers from master
|
|||
*/
|
||||
void CHudServers::RequestList( void )
|
||||
{
|
||||
m_nRequesting = 1;
|
||||
m_nDone = 0;
|
||||
m_dStarted = m_fElapsed;
|
||||
m_nRequesting = 1;
|
||||
m_nDone = 0;
|
||||
m_dStarted = m_fElapsed;
|
||||
|
||||
int count = 0;
|
||||
netadr_t adr;
|
||||
|
||||
if ( !LoadMasterAddresses( 1, &count, &adr ) )
|
||||
if( !LoadMasterAddresses( 1, &count, &adr ) )
|
||||
{
|
||||
gEngfuncs.Con_DPrintf( "SendRequest: Unable to read master server addresses\n" );
|
||||
return;
|
||||
|
@ -910,14 +910,13 @@ void CHudServers::RequestList( void )
|
|||
|
||||
void CHudServers::RequestBroadcastList( int clearpending )
|
||||
{
|
||||
m_nRequesting = 1;
|
||||
m_nDone = 0;
|
||||
m_dStarted = m_fElapsed;
|
||||
m_nRequesting = 1;
|
||||
m_nDone = 0;
|
||||
m_dStarted = m_fElapsed;
|
||||
|
||||
netadr_t adr;
|
||||
memset( &adr, 0, sizeof( adr ) );
|
||||
netadr_t adr = {0};
|
||||
|
||||
if ( clearpending )
|
||||
if( clearpending )
|
||||
{
|
||||
ClearRequestList( &m_pActiveList );
|
||||
ClearRequestList( &m_pServerList );
|
||||
|
@ -932,7 +931,7 @@ void CHudServers::RequestBroadcastList( int clearpending )
|
|||
// Make sure networking system has started.
|
||||
NET_API->InitNetworking();
|
||||
|
||||
if ( clearpending )
|
||||
if( clearpending )
|
||||
{
|
||||
// Kill off left overs if any
|
||||
NET_API->CancelAllRequests();
|
||||
|
@ -952,9 +951,9 @@ void CHudServers::RequestBroadcastList( int clearpending )
|
|||
void CHudServers::ServerPing( int server )
|
||||
{
|
||||
server_t *p;
|
||||
|
||||
|
||||
p = GetServer( server );
|
||||
if ( !p )
|
||||
if( !p )
|
||||
return;
|
||||
|
||||
// Make sure networking system has started.
|
||||
|
@ -967,9 +966,9 @@ void CHudServers::ServerPing( int server )
|
|||
void CHudServers::ServerRules( int server )
|
||||
{
|
||||
server_t *p;
|
||||
|
||||
|
||||
p = GetServer( server );
|
||||
if ( !p )
|
||||
if( !p )
|
||||
return;
|
||||
|
||||
// Make sure networking system has started.
|
||||
|
@ -982,9 +981,9 @@ void CHudServers::ServerRules( int server )
|
|||
void CHudServers::ServerPlayers( int server )
|
||||
{
|
||||
server_t *p;
|
||||
|
||||
|
||||
p = GetServer( server );
|
||||
if ( !p )
|
||||
if( !p )
|
||||
return;
|
||||
|
||||
// Make sure networking system has started.
|
||||
|
@ -999,7 +998,6 @@ int CHudServers::isQuerying()
|
|||
return m_nRequesting ? 1 : 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===================
|
||||
GetServerCount
|
||||
|
@ -1021,16 +1019,15 @@ CHudServers
|
|||
CHudServers::CHudServers( void )
|
||||
{
|
||||
m_nRequesting = 0;
|
||||
m_dStarted = 0.0;
|
||||
m_nDone = 0;
|
||||
m_dStarted = 0.0;
|
||||
m_nDone = 0;
|
||||
m_pServerList = NULL;
|
||||
m_pServers = NULL;
|
||||
m_pServers = NULL;
|
||||
m_pActiveList = NULL;
|
||||
m_nQuerying = 0;
|
||||
m_nQuerying = 0;
|
||||
m_nActiveQueries = 0;
|
||||
|
||||
m_fElapsed = 0.0;
|
||||
|
||||
m_fElapsed = 0.0;
|
||||
|
||||
m_pPingRequest = NULL;
|
||||
m_pRulesRequest = NULL;
|
||||
|
@ -1051,20 +1048,19 @@ CHudServers::~CHudServers( void )
|
|||
|
||||
m_nServerCount = 0;
|
||||
|
||||
if ( m_pPingRequest )
|
||||
if( m_pPingRequest )
|
||||
{
|
||||
delete m_pPingRequest;
|
||||
m_pPingRequest = NULL;
|
||||
|
||||
}
|
||||
|
||||
if ( m_pRulesRequest )
|
||||
|
||||
if( m_pRulesRequest )
|
||||
{
|
||||
delete m_pRulesRequest;
|
||||
m_pRulesRequest = NULL;
|
||||
}
|
||||
|
||||
if ( m_pPlayersRequest )
|
||||
if( m_pPlayersRequest )
|
||||
{
|
||||
delete m_pPlayersRequest;
|
||||
m_pPlayersRequest = NULL;
|
||||
|
@ -1083,18 +1079,18 @@ ServersGetCount
|
|||
|
||||
===================
|
||||
*/
|
||||
int ServersGetCount( void )
|
||||
int ServersGetCount( void )
|
||||
{
|
||||
if ( g_pServers )
|
||||
if( g_pServers )
|
||||
{
|
||||
return g_pServers->GetServerCount();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ServersIsQuerying( void )
|
||||
int ServersIsQuerying( void )
|
||||
{
|
||||
if ( g_pServers )
|
||||
if( g_pServers )
|
||||
{
|
||||
return g_pServers->isQuerying();
|
||||
}
|
||||
|
@ -1109,17 +1105,17 @@ ServersGetInfo
|
|||
*/
|
||||
const char *ServersGetInfo( int server )
|
||||
{
|
||||
if ( g_pServers )
|
||||
if( g_pServers )
|
||||
{
|
||||
return g_pServers->GetServerInfo( server );
|
||||
}
|
||||
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void SortServers( const char *fieldname )
|
||||
{
|
||||
if ( g_pServers )
|
||||
if( g_pServers )
|
||||
{
|
||||
g_pServers->SortServers( fieldname );
|
||||
}
|
||||
|
@ -1133,7 +1129,7 @@ ServersShutdown
|
|||
*/
|
||||
void ServersShutdown( void )
|
||||
{
|
||||
if ( g_pServers )
|
||||
if( g_pServers )
|
||||
{
|
||||
delete g_pServers;
|
||||
g_pServers = NULL;
|
||||
|
@ -1150,7 +1146,7 @@ void ServersInit( void )
|
|||
{
|
||||
// Kill any previous instance
|
||||
ServersShutdown();
|
||||
|
||||
|
||||
g_pServers = new CHudServers();
|
||||
}
|
||||
|
||||
|
@ -1162,7 +1158,7 @@ ServersThink
|
|||
*/
|
||||
void ServersThink( double time )
|
||||
{
|
||||
if ( g_pServers )
|
||||
if( g_pServers )
|
||||
{
|
||||
g_pServers->Think( time );
|
||||
}
|
||||
|
@ -1176,7 +1172,7 @@ ServersCancel
|
|||
*/
|
||||
void ServersCancel( void )
|
||||
{
|
||||
if ( g_pServers )
|
||||
if( g_pServers )
|
||||
{
|
||||
g_pServers->CancelRequest();
|
||||
}
|
||||
|
@ -1191,7 +1187,7 @@ ServersList
|
|||
*/
|
||||
void ServersList( void )
|
||||
{
|
||||
if ( g_pServers )
|
||||
if( g_pServers )
|
||||
{
|
||||
g_pServers->RequestList();
|
||||
}
|
||||
|
@ -1199,7 +1195,7 @@ void ServersList( void )
|
|||
|
||||
void BroadcastServersList( int clearpending )
|
||||
{
|
||||
if ( g_pServers )
|
||||
if( g_pServers )
|
||||
{
|
||||
g_pServers->RequestBroadcastList( clearpending );
|
||||
}
|
||||
|
@ -1207,7 +1203,7 @@ void BroadcastServersList( int clearpending )
|
|||
|
||||
void ServerPing( int server )
|
||||
{
|
||||
if ( g_pServers )
|
||||
if( g_pServers )
|
||||
{
|
||||
g_pServers->ServerPing( server );
|
||||
}
|
||||
|
@ -1215,7 +1211,7 @@ void ServerPing( int server )
|
|||
|
||||
void ServerRules( int server )
|
||||
{
|
||||
if ( g_pServers )
|
||||
if( g_pServers )
|
||||
{
|
||||
g_pServers->ServerRules( server );
|
||||
}
|
||||
|
@ -1223,8 +1219,8 @@ void ServerRules( int server )
|
|||
|
||||
void ServerPlayers( int server )
|
||||
{
|
||||
if ( g_pServers )
|
||||
if( g_pServers )
|
||||
{
|
||||
g_pServers->ServerPlayers( server );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -33,9 +33,8 @@ void ServerPing( int server );
|
|||
void ServerRules( int server );
|
||||
void ServerPlayers( int server );
|
||||
|
||||
int ServersGetCount( void );
|
||||
int ServersGetCount( void );
|
||||
const char *ServersGetInfo( int server );
|
||||
int ServersIsQuerying( void );
|
||||
int ServersIsQuerying( void );
|
||||
void SortServers( const char *fieldname );
|
||||
|
||||
#endif // HUD_SERVERSH
|
||||
#endif // HUD_SERVERSH
|
||||
|
|
|
@ -17,16 +17,16 @@ public:
|
|||
typedef struct request_s
|
||||
{
|
||||
struct request_s *next;
|
||||
netadr_t remote_address;
|
||||
int context;
|
||||
netadr_t remote_address;
|
||||
int context;
|
||||
} request_t;
|
||||
|
||||
typedef struct server_s
|
||||
{
|
||||
struct server_s *next;
|
||||
netadr_t remote_address;
|
||||
char *info;
|
||||
int ping;
|
||||
struct server_s *next;
|
||||
netadr_t remote_address;
|
||||
char *info;
|
||||
int ping;
|
||||
} server_t;
|
||||
|
||||
CHudServers();
|
||||
|
@ -34,9 +34,9 @@ public:
|
|||
|
||||
void Think( double time );
|
||||
void QueryThink( void );
|
||||
int isQuerying( void );
|
||||
int isQuerying( void );
|
||||
|
||||
int LoadMasterAddresses( int maxservers, int *count, netadr_t *padr );
|
||||
int LoadMasterAddresses( int maxservers, int *count, netadr_t *padr );
|
||||
|
||||
void RequestList( void );
|
||||
void RequestBroadcastList( int clearpending );
|
||||
|
@ -47,7 +47,7 @@ public:
|
|||
|
||||
void CancelRequest( void );
|
||||
|
||||
int CompareServers( server_t *p1, server_t *p2 );
|
||||
int CompareServers( server_t *p1, server_t *p2 );
|
||||
|
||||
void ClearServerList( server_t **ppList );
|
||||
void ClearRequestList( request_t **ppList );
|
||||
|
@ -58,9 +58,9 @@ public:
|
|||
|
||||
request_t *FindRequest( int context, request_t *pList );
|
||||
|
||||
int ServerListSize( void );
|
||||
int ServerListSize( void );
|
||||
char *GetServerInfo( int server );
|
||||
int GetServerCount( void );
|
||||
int GetServerCount( void );
|
||||
void SortServers( const char *fieldname );
|
||||
|
||||
void ListResponse( struct net_response_s *response );
|
||||
|
@ -73,26 +73,25 @@ private:
|
|||
server_t *GetServer( int server );
|
||||
|
||||
//
|
||||
char m_szToken[ 1024 ];
|
||||
int m_nRequesting;
|
||||
int m_nDone;
|
||||
char m_szToken[1024];
|
||||
int m_nRequesting;
|
||||
int m_nDone;
|
||||
|
||||
double m_dStarted;
|
||||
double m_dStarted;
|
||||
|
||||
request_t *m_pServerList;
|
||||
request_t *m_pActiveList;
|
||||
|
||||
server_t *m_pServers;
|
||||
server_t *m_pServers;
|
||||
|
||||
int m_nServerCount;
|
||||
int m_nServerCount;
|
||||
|
||||
int m_nActiveQueries;
|
||||
int m_nQuerying;
|
||||
double m_fElapsed;
|
||||
int m_nActiveQueries;
|
||||
int m_nQuerying;
|
||||
double m_fElapsed;
|
||||
|
||||
request_t *m_pPingRequest;
|
||||
request_t *m_pRulesRequest;
|
||||
request_t *m_pPlayersRequest;
|
||||
request_t *m_pPingRequest;
|
||||
request_t *m_pRulesRequest;
|
||||
request_t *m_pPlayersRequest;
|
||||
};
|
||||
|
||||
#endif // HUD_SERVERS_PRIVH
|
||||
#endif // HUD_SERVERS_PRIVH
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -11,17 +11,13 @@
|
|||
|
||||
#include "cl_entity.h"
|
||||
|
||||
|
||||
|
||||
#define INSET_OFF 0
|
||||
#define INSET_OFF 0
|
||||
#define INSET_CHASE_FREE 1
|
||||
#define INSET_IN_EYE 2
|
||||
#define INSET_MAP_FREE 3
|
||||
#define INSET_MAP_CHASE 4
|
||||
|
||||
#define MAX_SPEC_HUD_MESSAGES 8
|
||||
|
||||
|
||||
#define MAX_SPEC_HUD_MESSAGES 8
|
||||
|
||||
#define OVERVIEW_TILE_SIZE 128 // don't change this
|
||||
#define OVERVIEW_MAX_LAYERS 1
|
||||
|
@ -30,23 +26,24 @@
|
|||
// Purpose: Handles the drawing of the spectator stuff (camera & top-down map and all the things on it )
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
typedef struct overviewInfo_s {
|
||||
typedef struct overviewInfo_s
|
||||
{
|
||||
char map[64]; // cl.levelname or empty
|
||||
vec3_t origin; // center of map
|
||||
float zoom; // zoom of map images
|
||||
int layers; // how may layers do we have
|
||||
int layers; // how may layers do we have
|
||||
float layersHeights[OVERVIEW_MAX_LAYERS];
|
||||
char layersImages[OVERVIEW_MAX_LAYERS][255];
|
||||
qboolean rotated; // are map images rotated (90 degrees) ?
|
||||
|
||||
int insetWindowX;
|
||||
int insetWindowY;
|
||||
int insetWindowHeight;
|
||||
int insetWindowWidth;
|
||||
|
||||
int insetWindowX;
|
||||
int insetWindowY;
|
||||
int insetWindowHeight;
|
||||
int insetWindowWidth;
|
||||
} overviewInfo_t;
|
||||
|
||||
typedef struct overviewEntity_s {
|
||||
|
||||
typedef struct overviewEntity_s
|
||||
{
|
||||
HSPRITE hSprite;
|
||||
struct cl_entity_s * entity;
|
||||
double killTime;
|
||||
|
@ -58,11 +55,11 @@ class CHudSpectator : public CHudBase
|
|||
{
|
||||
public:
|
||||
void Reset();
|
||||
int ToggleInset(bool allowOff);
|
||||
int ToggleInset( bool allowOff );
|
||||
void CheckSettings();
|
||||
void InitHUDData( void );
|
||||
bool AddOverviewEntityToList( HSPRITE sprite, cl_entity_t * ent, double killTime);
|
||||
void DeathMessage(int victim);
|
||||
bool AddOverviewEntityToList( HSPRITE sprite, cl_entity_t * ent, double killTime );
|
||||
void DeathMessage( int victim );
|
||||
bool AddOverviewEntity( int type, struct cl_entity_s *ent, const char *modelname );
|
||||
void CheckOverviewEntities();
|
||||
void DrawOverview();
|
||||
|
@ -71,42 +68,40 @@ public:
|
|||
void DrawOverviewLayer();
|
||||
void LoadMapSprites();
|
||||
bool ParseOverviewFile();
|
||||
bool IsActivePlayer(cl_entity_t * ent);
|
||||
void SetModes(int iMainMode, int iInsetMode);
|
||||
void HandleButtonsDown(int ButtonPressed);
|
||||
void HandleButtonsUp(int ButtonPressed);
|
||||
bool IsActivePlayer( cl_entity_t * ent );
|
||||
void SetModes( int iMainMode, int iInsetMode );
|
||||
void HandleButtonsDown( int ButtonPressed );
|
||||
void HandleButtonsUp( int ButtonPressed );
|
||||
void FindNextPlayer( bool bReverse );
|
||||
void DirectorMessage( int iSize, void *pbuf );
|
||||
void SetSpectatorStartPosition();
|
||||
int Init();
|
||||
int VidInit();
|
||||
|
||||
int Draw(float flTime);
|
||||
int Draw( float flTime );
|
||||
|
||||
int m_iDrawCycle;
|
||||
client_textmessage_t m_HUDMessages[MAX_SPEC_HUD_MESSAGES];
|
||||
char m_HUDMessageText[MAX_SPEC_HUD_MESSAGES][128];
|
||||
int m_lastHudMessage;
|
||||
client_textmessage_t m_HUDMessages[MAX_SPEC_HUD_MESSAGES];
|
||||
char m_HUDMessageText[MAX_SPEC_HUD_MESSAGES][128];
|
||||
int m_lastHudMessage;
|
||||
overviewInfo_t m_OverviewData;
|
||||
overviewEntity_t m_OverviewEntities[MAX_OVERVIEW_ENTITIES];
|
||||
int m_iObserverFlags;
|
||||
int m_iSpectatorNumber;
|
||||
|
||||
float m_mapZoom; // zoom the user currently uses
|
||||
vec3_t m_mapOrigin; // origin where user rotates around
|
||||
cvar_t * m_drawnames;
|
||||
cvar_t * m_drawcone;
|
||||
cvar_t * m_drawstatus;
|
||||
cvar_t * m_autoDirector;
|
||||
cvar_t * m_pip;
|
||||
|
||||
int m_iObserverFlags;
|
||||
int m_iSpectatorNumber;
|
||||
|
||||
float m_mapZoom; // zoom the user currently uses
|
||||
vec3_t m_mapOrigin; // origin where user rotates around
|
||||
cvar_t *m_drawnames;
|
||||
cvar_t *m_drawcone;
|
||||
cvar_t *m_drawstatus;
|
||||
cvar_t *m_autoDirector;
|
||||
cvar_t *m_pip;
|
||||
|
||||
qboolean m_chatEnabled;
|
||||
|
||||
vec3_t m_cameraOrigin; // a help camera
|
||||
vec3_t m_cameraAngles; // and it's angles
|
||||
|
||||
|
||||
private:
|
||||
vec3_t m_vPlayerPos[MAX_PLAYERS];
|
||||
HSPRITE m_hsprPlayerBlue;
|
||||
|
@ -121,12 +116,11 @@ private:
|
|||
|
||||
wrect_t m_crosshairRect;
|
||||
|
||||
struct model_s * m_MapSprite; // each layer image is saved in one sprite, where each tile is a sprite frame
|
||||
struct model_s *m_MapSprite; // each layer image is saved in one sprite, where each tile is a sprite frame
|
||||
float m_flNextObserverInput;
|
||||
float m_zoomDelta;
|
||||
float m_moveDelta;
|
||||
int m_lastPrimaryObject;
|
||||
int m_lastSecondaryObject;
|
||||
int m_lastPrimaryObject;
|
||||
int m_lastSecondaryObject;
|
||||
};
|
||||
|
||||
#endif // SPECTATOR_H
|
||||
|
|
|
@ -29,11 +29,11 @@ extern float v_idlescale;
|
|||
float in_fov;
|
||||
extern void HUD_SetCmdBits( int bits );
|
||||
|
||||
int CHud::UpdateClientData(client_data_t *cdata, float time)
|
||||
int CHud::UpdateClientData( client_data_t *cdata, float time )
|
||||
{
|
||||
memcpy(m_vecOrigin, cdata->origin, sizeof(vec3_t));
|
||||
memcpy(m_vecAngles, cdata->viewangles, sizeof(vec3_t));
|
||||
|
||||
memcpy( m_vecOrigin, cdata->origin, sizeof(vec3_t) );
|
||||
memcpy( m_vecAngles, cdata->viewangles, sizeof(vec3_t) );
|
||||
|
||||
m_iKeyBits = CL_ButtonBits( 0 );
|
||||
m_iWeaponBits = cdata->iWeaponBits;
|
||||
|
||||
|
@ -42,7 +42,7 @@ int CHud::UpdateClientData(client_data_t *cdata, float time)
|
|||
Think();
|
||||
|
||||
cdata->fov = m_iFOV;
|
||||
|
||||
|
||||
v_idlescale = m_iConcussionEffect;
|
||||
|
||||
CL_ResetButtonBits( m_iKeyBits );
|
||||
|
@ -50,5 +50,3 @@ int CHud::UpdateClientData(client_data_t *cdata, float time)
|
|||
// return 1 if in anything in the client_data struct has been changed, 0 otherwise
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -15,10 +15,9 @@
|
|||
#include "camera.h"
|
||||
#include "in_defs.h"
|
||||
|
||||
float CL_KeyState( kbutton_t *key );
|
||||
|
||||
float CL_KeyState (kbutton_t *key);
|
||||
|
||||
extern "C"
|
||||
extern "C"
|
||||
{
|
||||
void DLLEXPORT CAM_Think( void );
|
||||
int DLLEXPORT CL_IsThirdPerson( void );
|
||||
|
@ -66,15 +65,14 @@ cvar_t *c_mindistance;
|
|||
// pitch, yaw, dist
|
||||
vec3_t cam_ofs;
|
||||
|
||||
|
||||
// In third person
|
||||
int cam_thirdperson;
|
||||
int cam_mousemove; //true if we are moving the cam with the mouse, False if not
|
||||
int iMouseInUse=0;
|
||||
int iMouseInUse = 0;
|
||||
int cam_distancemove;
|
||||
extern int mouse_x, mouse_y; //used to determine what the current x and y values are
|
||||
int cam_old_mouse_x, cam_old_mouse_y; //holds the last ticks mouse movement
|
||||
POINT cam_mouse;
|
||||
POINT cam_mouse;
|
||||
//-------------------------------------------------- Local Variables
|
||||
|
||||
static kbutton_t cam_pitchup, cam_pitchdown, cam_yawleft, cam_yawright;
|
||||
|
@ -87,7 +85,6 @@ void CAM_ToFirstPerson(void);
|
|||
void CAM_StartDistance(void);
|
||||
void CAM_EndDistance(void);
|
||||
|
||||
|
||||
//-------------------------------------------------- Local Functions
|
||||
|
||||
float MoveToward( float cur, float goal, float maxspeed )
|
||||
|
@ -118,7 +115,6 @@ float MoveToward( float cur, float goal, float maxspeed )
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
// bring cur back into range
|
||||
if( cur < 0 )
|
||||
cur += 360.0;
|
||||
|
@ -128,7 +124,6 @@ float MoveToward( float cur, float goal, float maxspeed )
|
|||
return cur;
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------- Gobal Functions
|
||||
|
||||
typedef struct
|
||||
|
@ -138,12 +133,12 @@ typedef struct
|
|||
vec3_t mins2, maxs2; // size when clipping against mosnters
|
||||
float *start, *end;
|
||||
trace_t trace;
|
||||
int type;
|
||||
int type;
|
||||
edict_t *passedict;
|
||||
qboolean monsterclip;
|
||||
} moveclip_t;
|
||||
|
||||
extern trace_t SV_ClipMoveToEntity (edict_t *ent, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end);
|
||||
extern trace_t SV_ClipMoveToEntity( edict_t *ent, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end );
|
||||
|
||||
void DLLEXPORT CAM_Think( void )
|
||||
{
|
||||
|
@ -158,16 +153,14 @@ void DLLEXPORT CAM_Think( void )
|
|||
#endif
|
||||
vec3_t viewangles;
|
||||
|
||||
switch( (int) cam_command->value )
|
||||
switch( (int)cam_command->value )
|
||||
{
|
||||
case CAM_COMMAND_TOTHIRDPERSON:
|
||||
CAM_ToThirdPerson();
|
||||
break;
|
||||
|
||||
case CAM_COMMAND_TOFIRSTPERSON:
|
||||
CAM_ToFirstPerson();
|
||||
break;
|
||||
|
||||
case CAM_COMMAND_NONE:
|
||||
default:
|
||||
break;
|
||||
|
@ -175,113 +168,108 @@ void DLLEXPORT CAM_Think( void )
|
|||
|
||||
if( !cam_thirdperson )
|
||||
return;
|
||||
|
||||
#ifdef LATER
|
||||
if ( cam_contain->value )
|
||||
if( cam_contain->value )
|
||||
{
|
||||
gEngfuncs.GetClientOrigin( origin );
|
||||
ext[0] = ext[1] = ext[2] = 0.0;
|
||||
}
|
||||
#endif
|
||||
|
||||
camAngles[ PITCH ] = cam_idealpitch->value;
|
||||
camAngles[ YAW ] = cam_idealyaw->value;
|
||||
camAngles[PITCH] = cam_idealpitch->value;
|
||||
camAngles[YAW] = cam_idealyaw->value;
|
||||
dist = cam_idealdist->value;
|
||||
|
||||
//
|
||||
//movement of the camera with the mouse
|
||||
//
|
||||
if (cam_mousemove)
|
||||
if( cam_mousemove )
|
||||
{
|
||||
//get windows cursor position
|
||||
GetCursorPos (&cam_mouse);
|
||||
//get windows cursor position
|
||||
GetCursorPos( &cam_mouse );
|
||||
|
||||
//check for X delta values and adjust accordingly
|
||||
//eventually adjust YAW based on amount of movement
|
||||
//don't do any movement of the cam using YAW/PITCH if we are zooming in/out the camera
|
||||
if (!cam_distancemove)
|
||||
{
|
||||
|
||||
//keep the camera within certain limits around the player (ie avoid certain bad viewing angles)
|
||||
if (cam_mouse.x>gEngfuncs.GetWindowCenterX())
|
||||
//don't do any movement of the cam using YAW/PITCH if we are zooming in/out the camera
|
||||
if( !cam_distancemove )
|
||||
{
|
||||
//if ((camAngles[YAW]>=225.0)||(camAngles[YAW]<135.0))
|
||||
if (camAngles[YAW]<c_maxyaw->value)
|
||||
//keep the camera within certain limits around the player (ie avoid certain bad viewing angles)
|
||||
if( cam_mouse.x>gEngfuncs.GetWindowCenterX() )
|
||||
{
|
||||
camAngles[ YAW ] += (CAM_ANGLE_MOVE)*((cam_mouse.x-gEngfuncs.GetWindowCenterX())/2);
|
||||
//if( ( camAngles[YAW] >= 225.0 ) || ( camAngles[YAW] < 135.0 ) )
|
||||
if( camAngles[YAW] < c_maxyaw->value )
|
||||
{
|
||||
camAngles[YAW] += CAM_ANGLE_MOVE * ( ( cam_mouse.x - gEngfuncs.GetWindowCenterX() ) / 2 );
|
||||
}
|
||||
if( camAngles[YAW] > c_maxyaw->value )
|
||||
{
|
||||
camAngles[YAW] = c_maxyaw->value;
|
||||
}
|
||||
}
|
||||
if (camAngles[YAW]>c_maxyaw->value)
|
||||
else if( cam_mouse.x<gEngfuncs.GetWindowCenterX() )
|
||||
{
|
||||
|
||||
camAngles[YAW]=c_maxyaw->value;
|
||||
//if( ( camAngles[YAW] <= 135.0 ) || ( camAngles[YAW] > 225.0 ) )
|
||||
if( camAngles[YAW] > c_minyaw->value )
|
||||
{
|
||||
camAngles[YAW] -= CAM_ANGLE_MOVE * ( ( gEngfuncs.GetWindowCenterX() - cam_mouse.x ) / 2 );
|
||||
}
|
||||
if( camAngles[YAW] < c_minyaw->value )
|
||||
{
|
||||
camAngles[YAW] = c_minyaw->value;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (cam_mouse.x<gEngfuncs.GetWindowCenterX())
|
||||
{
|
||||
//if ((camAngles[YAW]<=135.0)||(camAngles[YAW]>225.0))
|
||||
if (camAngles[YAW]>c_minyaw->value)
|
||||
{
|
||||
camAngles[ YAW ] -= (CAM_ANGLE_MOVE)* ((gEngfuncs.GetWindowCenterX()-cam_mouse.x)/2);
|
||||
|
||||
}
|
||||
if (camAngles[YAW]<c_minyaw->value)
|
||||
{
|
||||
camAngles[YAW]=c_minyaw->value;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
//check for y delta values and adjust accordingly
|
||||
//eventually adjust PITCH based on amount of movement
|
||||
//also make sure camera is within bounds
|
||||
if (cam_mouse.y>gEngfuncs.GetWindowCenterY())
|
||||
{
|
||||
if(camAngles[PITCH]<c_maxpitch->value)
|
||||
//check for y delta values and adjust accordingly
|
||||
//eventually adjust PITCH based on amount of movement
|
||||
//also make sure camera is within bounds
|
||||
if( cam_mouse.y>gEngfuncs.GetWindowCenterY() )
|
||||
{
|
||||
camAngles[PITCH] +=(CAM_ANGLE_MOVE)* ((cam_mouse.y-gEngfuncs.GetWindowCenterY())/2);
|
||||
if( camAngles[PITCH] < c_maxpitch->value )
|
||||
{
|
||||
camAngles[PITCH] += CAM_ANGLE_MOVE * ( ( cam_mouse.y - gEngfuncs.GetWindowCenterY() ) / 2 );
|
||||
}
|
||||
if( camAngles[PITCH] > c_maxpitch->value )
|
||||
{
|
||||
camAngles[PITCH] = c_maxpitch->value;
|
||||
}
|
||||
}
|
||||
if (camAngles[PITCH]>c_maxpitch->value)
|
||||
else if( cam_mouse.y<gEngfuncs.GetWindowCenterY() )
|
||||
{
|
||||
camAngles[PITCH]=c_maxpitch->value;
|
||||
if( camAngles[PITCH] > c_minpitch->value )
|
||||
{
|
||||
camAngles[PITCH] -= CAM_ANGLE_MOVE * ( ( gEngfuncs.GetWindowCenterY() - cam_mouse.y ) / 2 );
|
||||
}
|
||||
if( camAngles[PITCH] < c_minpitch->value )
|
||||
{
|
||||
camAngles[PITCH] = c_minpitch->value;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (cam_mouse.y<gEngfuncs.GetWindowCenterY())
|
||||
{
|
||||
if (camAngles[PITCH]>c_minpitch->value)
|
||||
{
|
||||
camAngles[PITCH] -= (CAM_ANGLE_MOVE)*((gEngfuncs.GetWindowCenterY()-cam_mouse.y)/2);
|
||||
}
|
||||
if (camAngles[PITCH]<c_minpitch->value)
|
||||
{
|
||||
camAngles[PITCH]=c_minpitch->value;
|
||||
}
|
||||
}
|
||||
|
||||
//set old mouse coordinates to current mouse coordinates
|
||||
//since we are done with the mouse
|
||||
|
||||
if ( ( flSensitivity = gHUD.GetSensitivity() ) != 0 )
|
||||
{
|
||||
cam_old_mouse_x=cam_mouse.x*flSensitivity;
|
||||
cam_old_mouse_y=cam_mouse.y*flSensitivity;
|
||||
//set old mouse coordinates to current mouse coordinates
|
||||
//since we are done with the mouse
|
||||
if( ( flSensitivity = gHUD.GetSensitivity() ) != 0 )
|
||||
{
|
||||
cam_old_mouse_x = cam_mouse.x * flSensitivity;
|
||||
cam_old_mouse_y = cam_mouse.y * flSensitivity;
|
||||
}
|
||||
else
|
||||
{
|
||||
cam_old_mouse_x = cam_mouse.x;
|
||||
cam_old_mouse_y = cam_mouse.y;
|
||||
}
|
||||
SetCursorPos( gEngfuncs.GetWindowCenterX(), gEngfuncs.GetWindowCenterY() );
|
||||
}
|
||||
else
|
||||
{
|
||||
cam_old_mouse_x=cam_mouse.x;
|
||||
cam_old_mouse_y=cam_mouse.y;
|
||||
}
|
||||
SetCursorPos (gEngfuncs.GetWindowCenterX(), gEngfuncs.GetWindowCenterY());
|
||||
}
|
||||
}
|
||||
|
||||
//Nathan code here
|
||||
if( CL_KeyState( &cam_pitchup ) )
|
||||
camAngles[ PITCH ] += CAM_ANGLE_DELTA;
|
||||
camAngles[PITCH] += CAM_ANGLE_DELTA;
|
||||
else if( CL_KeyState( &cam_pitchdown ) )
|
||||
camAngles[ PITCH ] -= CAM_ANGLE_DELTA;
|
||||
camAngles[PITCH] -= CAM_ANGLE_DELTA;
|
||||
|
||||
if( CL_KeyState( &cam_yawleft ) )
|
||||
camAngles[ YAW ] -= CAM_ANGLE_DELTA;
|
||||
camAngles[YAW] -= CAM_ANGLE_DELTA;
|
||||
else if( CL_KeyState( &cam_yawright ) )
|
||||
camAngles[ YAW ] += CAM_ANGLE_DELTA;
|
||||
camAngles[YAW] += CAM_ANGLE_DELTA;
|
||||
|
||||
if( CL_KeyState( &cam_in ) )
|
||||
{
|
||||
|
@ -289,44 +277,43 @@ void DLLEXPORT CAM_Think( void )
|
|||
if( dist < CAM_MIN_DIST )
|
||||
{
|
||||
// If we go back into first person, reset the angle
|
||||
camAngles[ PITCH ] = 0;
|
||||
camAngles[ YAW ] = 0;
|
||||
camAngles[PITCH] = 0;
|
||||
camAngles[YAW] = 0;
|
||||
dist = CAM_MIN_DIST;
|
||||
}
|
||||
|
||||
}
|
||||
else if( CL_KeyState( &cam_out ) )
|
||||
dist += CAM_DIST_DELTA;
|
||||
|
||||
if (cam_distancemove)
|
||||
if( cam_distancemove )
|
||||
{
|
||||
if (cam_mouse.y>gEngfuncs.GetWindowCenterY())
|
||||
if( cam_mouse.y > gEngfuncs.GetWindowCenterY() )
|
||||
{
|
||||
if(dist<c_maxdistance->value)
|
||||
if( dist < c_maxdistance->value )
|
||||
{
|
||||
dist +=CAM_DIST_DELTA * ((cam_mouse.y-gEngfuncs.GetWindowCenterY())/2);
|
||||
dist += CAM_DIST_DELTA * ( ( cam_mouse.y - gEngfuncs.GetWindowCenterY() ) / 2);
|
||||
}
|
||||
if (dist>c_maxdistance->value)
|
||||
if( dist > c_maxdistance->value )
|
||||
{
|
||||
dist=c_maxdistance->value;
|
||||
dist = c_maxdistance->value;
|
||||
}
|
||||
}
|
||||
else if (cam_mouse.y<gEngfuncs.GetWindowCenterY())
|
||||
else if( cam_mouse.y < gEngfuncs.GetWindowCenterY() )
|
||||
{
|
||||
if (dist>c_mindistance->value)
|
||||
if( dist > c_mindistance->value )
|
||||
{
|
||||
dist -= (CAM_DIST_DELTA)*((gEngfuncs.GetWindowCenterY()-cam_mouse.y)/2);
|
||||
dist -= CAM_DIST_DELTA * ( ( gEngfuncs.GetWindowCenterY() - cam_mouse.y ) / 2 );
|
||||
}
|
||||
if (dist<c_mindistance->value)
|
||||
if ( dist < c_mindistance->value )
|
||||
{
|
||||
dist=c_mindistance->value;
|
||||
dist = c_mindistance->value;
|
||||
}
|
||||
}
|
||||
//set old mouse coordinates to current mouse coordinates
|
||||
//since we are done with the mouse
|
||||
cam_old_mouse_x=cam_mouse.x*gHUD.GetSensitivity();
|
||||
cam_old_mouse_y=cam_mouse.y*gHUD.GetSensitivity();
|
||||
SetCursorPos (gEngfuncs.GetWindowCenterX(), gEngfuncs.GetWindowCenterY());
|
||||
cam_old_mouse_x = cam_mouse.x * gHUD.GetSensitivity();
|
||||
cam_old_mouse_y = cam_mouse.y * gHUD.GetSensitivity();
|
||||
SetCursorPos( gEngfuncs.GetWindowCenterX(), gEngfuncs.GetWindowCenterY() );
|
||||
}
|
||||
#ifdef LATER
|
||||
if( cam_contain->value )
|
||||
|
@ -334,17 +321,17 @@ void DLLEXPORT CAM_Think( void )
|
|||
// check new ideal
|
||||
VectorCopy( origin, pnt );
|
||||
AngleVectors( camAngles, camForward, camRight, camUp );
|
||||
for (i=0 ; i<3 ; i++)
|
||||
pnt[i] += -dist*camForward[i];
|
||||
for( i = 0; i < 3; i++ )
|
||||
pnt[i] += -dist * camForward[i];
|
||||
|
||||
// check line from r_refdef.vieworg to pnt
|
||||
memset ( &clip, 0, sizeof ( moveclip_t ) );
|
||||
memset( &clip, 0, sizeof(moveclip_t) );
|
||||
clip.trace = SV_ClipMoveToEntity( sv.edicts, r_refdef.vieworg, ext, ext, pnt );
|
||||
if( clip.trace.fraction == 1.0 )
|
||||
{
|
||||
// update ideal
|
||||
cam_idealpitch->value = camAngles[ PITCH ];
|
||||
cam_idealyaw->value = camAngles[ YAW ];
|
||||
cam_idealpitch->value = camAngles[PITCH];
|
||||
cam_idealyaw->value = camAngles[YAW];
|
||||
cam_idealdist->value = dist;
|
||||
}
|
||||
}
|
||||
|
@ -352,8 +339,8 @@ void DLLEXPORT CAM_Think( void )
|
|||
#endif
|
||||
{
|
||||
// update ideal
|
||||
cam_idealpitch->value = camAngles[ PITCH ];
|
||||
cam_idealyaw->value = camAngles[ YAW ];
|
||||
cam_idealpitch->value = camAngles[PITCH];
|
||||
cam_idealyaw->value = camAngles[YAW];
|
||||
cam_idealdist->value = dist;
|
||||
}
|
||||
|
||||
|
@ -364,91 +351,136 @@ void DLLEXPORT CAM_Think( void )
|
|||
|
||||
if( cam_snapto->value )
|
||||
{
|
||||
camAngles[ YAW ] = cam_idealyaw->value + viewangles[ YAW ];
|
||||
camAngles[ PITCH ] = cam_idealpitch->value + viewangles[ PITCH ];
|
||||
camAngles[ 2 ] = cam_idealdist->value;
|
||||
camAngles[YAW] = cam_idealyaw->value + viewangles[YAW];
|
||||
camAngles[PITCH] = cam_idealpitch->value + viewangles[PITCH];
|
||||
camAngles[2] = cam_idealdist->value;
|
||||
}
|
||||
else
|
||||
{
|
||||
if( camAngles[ YAW ] - viewangles[ YAW ] != cam_idealyaw->value )
|
||||
camAngles[ YAW ] = MoveToward( camAngles[ YAW ], cam_idealyaw->value + viewangles[ YAW ], CAM_ANGLE_SPEED );
|
||||
if( camAngles[YAW] - viewangles[YAW] != cam_idealyaw->value )
|
||||
camAngles[YAW] = MoveToward( camAngles[YAW], cam_idealyaw->value + viewangles[YAW], CAM_ANGLE_SPEED );
|
||||
|
||||
if( camAngles[ PITCH ] - viewangles[ PITCH ] != cam_idealpitch->value )
|
||||
camAngles[ PITCH ] = MoveToward( camAngles[ PITCH ], cam_idealpitch->value + viewangles[ PITCH ], CAM_ANGLE_SPEED );
|
||||
if( camAngles[PITCH] - viewangles[PITCH] != cam_idealpitch->value )
|
||||
camAngles[PITCH] = MoveToward( camAngles[PITCH], cam_idealpitch->value + viewangles[PITCH], CAM_ANGLE_SPEED );
|
||||
|
||||
if( fabs( camAngles[ 2 ] - cam_idealdist->value ) < 2.0 )
|
||||
camAngles[ 2 ] = cam_idealdist->value;
|
||||
if( fabs( camAngles[2] - cam_idealdist->value ) < 2.0 )
|
||||
camAngles[2] = cam_idealdist->value;
|
||||
else
|
||||
camAngles[ 2 ] += ( cam_idealdist->value - camAngles[ 2 ] ) / 4.0;
|
||||
camAngles[2] += ( cam_idealdist->value - camAngles[2] ) / 4.0;
|
||||
}
|
||||
#ifdef LATER
|
||||
if( cam_contain->value )
|
||||
{
|
||||
// Test new position
|
||||
dist = camAngles[ ROLL ];
|
||||
camAngles[ ROLL ] = 0;
|
||||
dist = camAngles[ROLL];
|
||||
camAngles[ROLL] = 0;
|
||||
|
||||
VectorCopy( origin, pnt );
|
||||
AngleVectors( camAngles, camForward, camRight, camUp );
|
||||
for (i=0 ; i<3 ; i++)
|
||||
pnt[i] += -dist*camForward[i];
|
||||
for( i = 0; i < 3; i++ )
|
||||
pnt[i] += -dist * camForward[i];
|
||||
|
||||
// check line from r_refdef.vieworg to pnt
|
||||
memset ( &clip, 0, sizeof ( moveclip_t ) );
|
||||
memset( &clip, 0, sizeof(moveclip_t) );
|
||||
ext[0] = ext[1] = ext[2] = 0.0;
|
||||
clip.trace = SV_ClipMoveToEntity( sv.edicts, r_refdef.vieworg, ext, ext, pnt );
|
||||
if( clip.trace.fraction != 1.0 )
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
cam_ofs[ 0 ] = camAngles[ 0 ];
|
||||
cam_ofs[ 1 ] = camAngles[ 1 ];
|
||||
cam_ofs[ 2 ] = dist;
|
||||
cam_ofs[0] = camAngles[0];
|
||||
cam_ofs[1] = camAngles[1];
|
||||
cam_ofs[2] = dist;
|
||||
}
|
||||
|
||||
extern void KeyDown (kbutton_t *b); // HACK
|
||||
extern void KeyUp (kbutton_t *b); // HACK
|
||||
extern void KeyDown( kbutton_t *b ); // HACK
|
||||
extern void KeyUp( kbutton_t *b ); // HACK
|
||||
|
||||
void CAM_PitchUpDown(void) { KeyDown( &cam_pitchup ); }
|
||||
void CAM_PitchUpUp(void) { KeyUp( &cam_pitchup ); }
|
||||
void CAM_PitchDownDown(void) { KeyDown( &cam_pitchdown ); }
|
||||
void CAM_PitchDownUp(void) { KeyUp( &cam_pitchdown ); }
|
||||
void CAM_YawLeftDown(void) { KeyDown( &cam_yawleft ); }
|
||||
void CAM_YawLeftUp(void) { KeyUp( &cam_yawleft ); }
|
||||
void CAM_YawRightDown(void) { KeyDown( &cam_yawright ); }
|
||||
void CAM_YawRightUp(void) { KeyUp( &cam_yawright ); }
|
||||
void CAM_InDown(void) { KeyDown( &cam_in ); }
|
||||
void CAM_InUp(void) { KeyUp( &cam_in ); }
|
||||
void CAM_OutDown(void) { KeyDown( &cam_out ); }
|
||||
void CAM_OutUp(void) { KeyUp( &cam_out ); }
|
||||
void CAM_PitchUpDown( void )
|
||||
{
|
||||
KeyDown( &cam_pitchup );
|
||||
}
|
||||
|
||||
void CAM_ToThirdPerson(void)
|
||||
{
|
||||
void CAM_PitchUpUp( void )
|
||||
{
|
||||
KeyUp( &cam_pitchup );
|
||||
}
|
||||
|
||||
void CAM_PitchDownDown( void )
|
||||
{
|
||||
KeyDown( &cam_pitchdown );
|
||||
}
|
||||
|
||||
void CAM_PitchDownUp( void )
|
||||
{
|
||||
KeyUp( &cam_pitchdown );
|
||||
}
|
||||
|
||||
void CAM_YawLeftDown( void )
|
||||
{
|
||||
KeyDown( &cam_yawleft );
|
||||
}
|
||||
|
||||
void CAM_YawLeftUp( void )
|
||||
{
|
||||
KeyUp( &cam_yawleft );
|
||||
}
|
||||
|
||||
void CAM_YawRightDown( void )
|
||||
{
|
||||
KeyDown( &cam_yawright );
|
||||
}
|
||||
|
||||
void CAM_YawRightUp( void )
|
||||
{
|
||||
KeyUp( &cam_yawright );
|
||||
}
|
||||
|
||||
void CAM_InDown( void )
|
||||
{
|
||||
KeyDown( &cam_in );
|
||||
}
|
||||
|
||||
void CAM_InUp( void )
|
||||
{
|
||||
KeyUp( &cam_in );
|
||||
}
|
||||
|
||||
void CAM_OutDown( void )
|
||||
{
|
||||
KeyDown( &cam_out );
|
||||
}
|
||||
|
||||
void CAM_OutUp( void )
|
||||
{
|
||||
KeyUp( &cam_out );
|
||||
}
|
||||
|
||||
void CAM_ToThirdPerson( void )
|
||||
{
|
||||
vec3_t viewangles;
|
||||
|
||||
#if !defined( _DEBUG )
|
||||
if ( gEngfuncs.GetMaxClients() > 1 )
|
||||
if( gEngfuncs.GetMaxClients() > 1 )
|
||||
{
|
||||
// no thirdperson in multiplayer.
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
gEngfuncs.GetViewAngles( (float *)viewangles );
|
||||
|
||||
if( !cam_thirdperson )
|
||||
{
|
||||
cam_thirdperson = 1;
|
||||
|
||||
cam_ofs[ YAW ] = viewangles[ YAW ];
|
||||
cam_ofs[ PITCH ] = viewangles[ PITCH ];
|
||||
cam_ofs[ 2 ] = CAM_MIN_DIST;
|
||||
|
||||
cam_ofs[YAW] = viewangles[YAW];
|
||||
cam_ofs[PITCH] = viewangles[PITCH];
|
||||
cam_ofs[2] = CAM_MIN_DIST;
|
||||
}
|
||||
|
||||
gEngfuncs.Cvar_SetValue( "cam_command", 0 );
|
||||
}
|
||||
|
||||
void CAM_ToFirstPerson(void)
|
||||
void CAM_ToFirstPerson( void )
|
||||
{
|
||||
cam_thirdperson = 0;
|
||||
|
||||
|
@ -482,19 +514,19 @@ void CAM_Init( void )
|
|||
gEngfuncs.pfnAddCommand( "-camdistance", CAM_EndDistance );
|
||||
gEngfuncs.pfnAddCommand( "snapto", CAM_ToggleSnapto );
|
||||
|
||||
cam_command = gEngfuncs.pfnRegisterVariable ( "cam_command", "0", 0 ); // tells camera to go to thirdperson
|
||||
cam_snapto = gEngfuncs.pfnRegisterVariable ( "cam_snapto", "0", 0 ); // snap to thirdperson view
|
||||
cam_idealyaw = gEngfuncs.pfnRegisterVariable ( "cam_idealyaw", "90", 0 ); // thirdperson yaw
|
||||
cam_idealpitch = gEngfuncs.pfnRegisterVariable ( "cam_idealpitch", "0", 0 ); // thirperson pitch
|
||||
cam_idealdist = gEngfuncs.pfnRegisterVariable ( "cam_idealdist", "64", 0 ); // thirdperson distance
|
||||
cam_contain = gEngfuncs.pfnRegisterVariable ( "cam_contain", "0", 0 ); // contain camera to world
|
||||
cam_command = gEngfuncs.pfnRegisterVariable( "cam_command", "0", 0 ); // tells camera to go to thirdperson
|
||||
cam_snapto = gEngfuncs.pfnRegisterVariable( "cam_snapto", "0", 0 ); // snap to thirdperson view
|
||||
cam_idealyaw = gEngfuncs.pfnRegisterVariable( "cam_idealyaw", "90", 0 ); // thirdperson yaw
|
||||
cam_idealpitch = gEngfuncs.pfnRegisterVariable( "cam_idealpitch", "0", 0 ); // thirperson pitch
|
||||
cam_idealdist = gEngfuncs.pfnRegisterVariable( "cam_idealdist", "64", 0 ); // thirdperson distance
|
||||
cam_contain = gEngfuncs.pfnRegisterVariable( "cam_contain", "0", 0 ); // contain camera to world
|
||||
|
||||
c_maxpitch = gEngfuncs.pfnRegisterVariable ( "c_maxpitch", "90.0", 0 );
|
||||
c_minpitch = gEngfuncs.pfnRegisterVariable ( "c_minpitch", "0.0", 0 );
|
||||
c_maxyaw = gEngfuncs.pfnRegisterVariable ( "c_maxyaw", "135.0", 0 );
|
||||
c_minyaw = gEngfuncs.pfnRegisterVariable ( "c_minyaw", "-135.0", 0 );
|
||||
c_maxdistance = gEngfuncs.pfnRegisterVariable ( "c_maxdistance", "200.0", 0 );
|
||||
c_mindistance = gEngfuncs.pfnRegisterVariable ( "c_mindistance", "30.0", 0 );
|
||||
c_maxpitch = gEngfuncs.pfnRegisterVariable( "c_maxpitch", "90.0", 0 );
|
||||
c_minpitch = gEngfuncs.pfnRegisterVariable( "c_minpitch", "0.0", 0 );
|
||||
c_maxyaw = gEngfuncs.pfnRegisterVariable( "c_maxyaw", "135.0", 0 );
|
||||
c_minyaw = gEngfuncs.pfnRegisterVariable( "c_minyaw", "-135.0", 0 );
|
||||
c_maxdistance = gEngfuncs.pfnRegisterVariable( "c_maxdistance", "200.0", 0 );
|
||||
c_mindistance = gEngfuncs.pfnRegisterVariable( "c_mindistance", "30.0", 0 );
|
||||
}
|
||||
|
||||
void CAM_ClearStates( void )
|
||||
|
@ -517,101 +549,100 @@ void CAM_ClearStates( void )
|
|||
cam_snapto->value = 0;
|
||||
cam_distancemove = 0;
|
||||
|
||||
cam_ofs[ 0 ] = 0.0;
|
||||
cam_ofs[ 1 ] = 0.0;
|
||||
cam_ofs[ 2 ] = CAM_MIN_DIST;
|
||||
cam_ofs[0] = 0.0;
|
||||
cam_ofs[1] = 0.0;
|
||||
cam_ofs[2] = CAM_MIN_DIST;
|
||||
|
||||
cam_idealpitch->value = viewangles[ PITCH ];
|
||||
cam_idealyaw->value = viewangles[ YAW ];
|
||||
cam_idealpitch->value = viewangles[PITCH];
|
||||
cam_idealyaw->value = viewangles[YAW];
|
||||
cam_idealdist->value = CAM_MIN_DIST;
|
||||
}
|
||||
|
||||
void CAM_StartMouseMove(void)
|
||||
void CAM_StartMouseMove( void )
|
||||
{
|
||||
float flSensitivity;
|
||||
|
||||
|
||||
//only move the cam with mouse if we are in third person.
|
||||
if (cam_thirdperson)
|
||||
if( cam_thirdperson )
|
||||
{
|
||||
//set appropriate flags and initialize the old mouse position
|
||||
//variables for mouse camera movement
|
||||
if (!cam_mousemove)
|
||||
if( !cam_mousemove )
|
||||
{
|
||||
cam_mousemove=1;
|
||||
iMouseInUse=1;
|
||||
GetCursorPos (&cam_mouse);
|
||||
cam_mousemove = 1;
|
||||
iMouseInUse = 1;
|
||||
GetCursorPos( &cam_mouse );
|
||||
|
||||
if ( ( flSensitivity = gHUD.GetSensitivity() ) != 0 )
|
||||
if( ( flSensitivity = gHUD.GetSensitivity() ) != 0 )
|
||||
{
|
||||
cam_old_mouse_x=cam_mouse.x*flSensitivity;
|
||||
cam_old_mouse_y=cam_mouse.y*flSensitivity;
|
||||
cam_old_mouse_x = cam_mouse.x * flSensitivity;
|
||||
cam_old_mouse_y = cam_mouse.y * flSensitivity;
|
||||
}
|
||||
else
|
||||
{
|
||||
cam_old_mouse_x=cam_mouse.x;
|
||||
cam_old_mouse_y=cam_mouse.y;
|
||||
cam_old_mouse_x = cam_mouse.x;
|
||||
cam_old_mouse_y = cam_mouse.y;
|
||||
}
|
||||
}
|
||||
}
|
||||
//we are not in 3rd person view..therefore do not allow camera movement
|
||||
else
|
||||
{
|
||||
cam_mousemove=0;
|
||||
iMouseInUse=0;
|
||||
cam_mousemove = 0;
|
||||
iMouseInUse = 0;
|
||||
}
|
||||
}
|
||||
|
||||
//the key has been released for camera movement
|
||||
//tell the engine that mouse camera movement is off
|
||||
void CAM_EndMouseMove(void)
|
||||
void CAM_EndMouseMove( void )
|
||||
{
|
||||
cam_mousemove=0;
|
||||
iMouseInUse=0;
|
||||
cam_mousemove = 0;
|
||||
iMouseInUse = 0;
|
||||
}
|
||||
|
||||
|
||||
//----------------------------------------------------------
|
||||
//routines to start the process of moving the cam in or out
|
||||
//using the mouse
|
||||
//----------------------------------------------------------
|
||||
void CAM_StartDistance(void)
|
||||
void CAM_StartDistance( void )
|
||||
{
|
||||
//only move the cam with mouse if we are in third person.
|
||||
if (cam_thirdperson)
|
||||
if( cam_thirdperson )
|
||||
{
|
||||
//set appropriate flags and initialize the old mouse position
|
||||
//variables for mouse camera movement
|
||||
if (!cam_distancemove)
|
||||
{
|
||||
cam_distancemove=1;
|
||||
cam_mousemove=1;
|
||||
iMouseInUse=1;
|
||||
GetCursorPos (&cam_mouse);
|
||||
cam_old_mouse_x=cam_mouse.x*gHUD.GetSensitivity();
|
||||
cam_old_mouse_y=cam_mouse.y*gHUD.GetSensitivity();
|
||||
}
|
||||
//set appropriate flags and initialize the old mouse position
|
||||
//variables for mouse camera movement
|
||||
if( !cam_distancemove )
|
||||
{
|
||||
cam_distancemove = 1;
|
||||
cam_mousemove = 1;
|
||||
iMouseInUse = 1;
|
||||
GetCursorPos( &cam_mouse );
|
||||
cam_old_mouse_x = cam_mouse.x * gHUD.GetSensitivity();
|
||||
cam_old_mouse_y = cam_mouse.y * gHUD.GetSensitivity();
|
||||
}
|
||||
}
|
||||
//we are not in 3rd person view..therefore do not allow camera movement
|
||||
else
|
||||
{
|
||||
cam_distancemove=0;
|
||||
cam_mousemove=0;
|
||||
iMouseInUse=0;
|
||||
{
|
||||
cam_distancemove = 0;
|
||||
cam_mousemove = 0;
|
||||
iMouseInUse = 0;
|
||||
}
|
||||
}
|
||||
|
||||
//the key has been released for camera movement
|
||||
//tell the engine that mouse camera movement is off
|
||||
void CAM_EndDistance(void)
|
||||
void CAM_EndDistance( void )
|
||||
{
|
||||
cam_distancemove=0;
|
||||
cam_mousemove=0;
|
||||
iMouseInUse=0;
|
||||
cam_distancemove = 0;
|
||||
cam_mousemove = 0;
|
||||
iMouseInUse = 0;
|
||||
}
|
||||
|
||||
int DLLEXPORT CL_IsThirdPerson( void )
|
||||
{
|
||||
return (cam_thirdperson ? 1 : 0) || (g_iUser1 && (g_iUser2 == gEngfuncs.GetLocalPlayer()->index) );
|
||||
return ( cam_thirdperson ? 1 : 0 ) || ( g_iUser1 && ( g_iUser2 == gEngfuncs.GetLocalPlayer()->index ) );
|
||||
}
|
||||
|
||||
void DLLEXPORT CL_CameraOffset( float *ofs )
|
||||
|
|
|
@ -21,12 +21,12 @@
|
|||
#include <windows.h>
|
||||
#undef HSPRITE
|
||||
#else
|
||||
typedef struct point_s{
|
||||
typedef struct point_s
|
||||
{
|
||||
int x;
|
||||
int y;
|
||||
} POINT;
|
||||
#define GetCursorPos(x)
|
||||
#define SetCursorPos(x,y)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
684
cl_dll/input.cpp
684
cl_dll/input.cpp
File diff suppressed because it is too large
Load Diff
|
@ -93,47 +93,46 @@ void IN_ToggleButtons( float forwardmove, float sidemove )
|
|||
}
|
||||
}
|
||||
|
||||
if ( forwardmove > 0.7 && !( moveflags & F ))
|
||||
if( forwardmove > 0.7 && !( moveflags & F ) )
|
||||
{
|
||||
moveflags |= F;
|
||||
in_forward.state |= BUTTON_DOWN;
|
||||
}
|
||||
if ( forwardmove < 0.7 && ( moveflags & F ))
|
||||
if( forwardmove < 0.7 && ( moveflags & F ) )
|
||||
{
|
||||
moveflags &= ~F;
|
||||
in_forward.state &= ~BUTTON_DOWN;
|
||||
}
|
||||
if ( forwardmove < -0.7 && !( moveflags & B ))
|
||||
if( forwardmove < -0.7 && !( moveflags & B ) )
|
||||
{
|
||||
moveflags |= B;
|
||||
in_back.state |= BUTTON_DOWN;
|
||||
}
|
||||
if ( forwardmove > -0.7 && ( moveflags & B ))
|
||||
if( forwardmove > -0.7 && ( moveflags & B ) )
|
||||
{
|
||||
moveflags &= ~B;
|
||||
in_back.state &= ~BUTTON_DOWN;
|
||||
}
|
||||
if ( sidemove > 0.9 && !( moveflags & R ))
|
||||
if( sidemove > 0.9 && !( moveflags & R ) )
|
||||
{
|
||||
moveflags |= R;
|
||||
in_moveright.state |= BUTTON_DOWN;
|
||||
}
|
||||
if ( sidemove < 0.9 && ( moveflags & R ))
|
||||
if( sidemove < 0.9 && ( moveflags & R ) )
|
||||
{
|
||||
moveflags &= ~R;
|
||||
in_moveright.state &= ~BUTTON_DOWN;
|
||||
}
|
||||
if ( sidemove < -0.9 && !( moveflags & L ))
|
||||
if( sidemove < -0.9 && !( moveflags & L ) )
|
||||
{
|
||||
moveflags |= L;
|
||||
in_moveleft.state |= BUTTON_DOWN;
|
||||
}
|
||||
if ( sidemove > -0.9 && ( moveflags & L ))
|
||||
if( sidemove > -0.9 && ( moveflags & L ) )
|
||||
{
|
||||
moveflags &= ~L;
|
||||
in_moveleft.state &= ~BUTTON_DOWN;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void IN_ClientMoveEvent( float forwardmove, float sidemove )
|
||||
|
@ -150,15 +149,16 @@ void IN_ClientLookEvent( float relyaw, float relpitch )
|
|||
rel_yaw += relyaw;
|
||||
rel_pitch += relpitch;
|
||||
}
|
||||
|
||||
// Rotate camera and add move values to usercmd
|
||||
void IN_Move( float frametime, usercmd_t *cmd )
|
||||
{
|
||||
Vector viewangles;
|
||||
bool fLadder = false;
|
||||
|
||||
|
||||
if( gHUD.m_iIntermission )
|
||||
return; // we can't move during intermission
|
||||
|
||||
|
||||
if( cl_laddermode->value != 2 )
|
||||
{
|
||||
cl_entity_t *pplayer = gEngfuncs.GetLocalPlayer();
|
||||
|
@ -198,14 +198,14 @@ void IN_Move( float frametime, usercmd_t *cmd )
|
|||
viewangles[YAW] -= ac_sidemove * 5;
|
||||
ac_sidemove = 0;
|
||||
}
|
||||
if(gHUD.m_MOTD.m_bShow)
|
||||
if( gHUD.m_MOTD.m_bShow )
|
||||
gHUD.m_MOTD.scroll += rel_pitch;
|
||||
else
|
||||
viewangles[PITCH] += rel_pitch;
|
||||
|
||||
if (viewangles[PITCH] > cl_pitchdown->value)
|
||||
|
||||
if( viewangles[PITCH] > cl_pitchdown->value )
|
||||
viewangles[PITCH] = cl_pitchdown->value;
|
||||
if (viewangles[PITCH] < -cl_pitchup->value)
|
||||
if( viewangles[PITCH] < -cl_pitchup->value )
|
||||
viewangles[PITCH] = -cl_pitchup->value;
|
||||
|
||||
// HACKHACK: change viewangles directly in viewcode,
|
||||
|
@ -214,20 +214,23 @@ void IN_Move( float frametime, usercmd_t *cmd )
|
|||
{
|
||||
gEngfuncs.SetViewAngles( viewangles );
|
||||
}
|
||||
|
||||
|
||||
dead_viewangles = viewangles; // keep them actual
|
||||
if( ac_movecount )
|
||||
{
|
||||
IN_ToggleButtons( ac_forwardmove / ac_movecount, ac_sidemove / ac_movecount );
|
||||
if( ac_forwardmove ) cmd->forwardmove = ac_forwardmove * cl_forwardspeed->value / ac_movecount;
|
||||
if( ac_sidemove ) cmd->sidemove = ac_sidemove * cl_sidespeed->value / ac_movecount;
|
||||
if( (in_speed.state & 1) && ( ac_sidemove || ac_forwardmove ) )
|
||||
|
||||
if( ac_forwardmove )
|
||||
cmd->forwardmove = ac_forwardmove * cl_forwardspeed->value / ac_movecount;
|
||||
if( ac_sidemove )
|
||||
cmd->sidemove = ac_sidemove * cl_sidespeed->value / ac_movecount;
|
||||
if( ( in_speed.state & 1 ) && ( ac_sidemove || ac_forwardmove ) )
|
||||
{
|
||||
cmd->forwardmove *= cl_movespeedkey->value;
|
||||
cmd->sidemove *= cl_movespeedkey->value;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
ac_sidemove = ac_forwardmove = rel_pitch = rel_yaw = 0;
|
||||
ac_movecount = 0;
|
||||
}
|
||||
|
@ -238,55 +241,56 @@ extern "C" void DLLEXPORT IN_MouseEvent( int mstate )
|
|||
// perform button actions
|
||||
for( int i = 0; i < 5; i++ )
|
||||
{
|
||||
if(( mstate & (1 << i)) && !( mouse_oldbuttonstate & (1 << i)))
|
||||
if( ( mstate & ( 1 << i ) ) && !( mouse_oldbuttonstate & ( 1 << i ) ) )
|
||||
{
|
||||
gEngfuncs.Key_Event( K_MOUSE1 + i, 1 );
|
||||
}
|
||||
|
||||
if( !( mstate & (1 << i)) && ( mouse_oldbuttonstate & (1 << i)))
|
||||
if( !( mstate & ( 1 << i ) ) && ( mouse_oldbuttonstate & ( 1 << i ) ) )
|
||||
{
|
||||
gEngfuncs.Key_Event( K_MOUSE1 + i, 0 );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
mouse_oldbuttonstate = mstate;
|
||||
}
|
||||
|
||||
// Stubs
|
||||
|
||||
extern "C" void DLLEXPORT IN_ClearStates ( void )
|
||||
extern "C" void DLLEXPORT IN_ClearStates( void )
|
||||
{
|
||||
//gEngfuncs.Con_Printf("IN_ClearStates\n");
|
||||
//gEngfuncs.Con_Printf( "IN_ClearStates\n" );
|
||||
}
|
||||
|
||||
extern "C" void DLLEXPORT IN_ActivateMouse ( void )
|
||||
extern "C" void DLLEXPORT IN_ActivateMouse( void )
|
||||
{
|
||||
//gEngfuncs.Con_Printf("IN_ActivateMouse\n");
|
||||
//gEngfuncs.Con_Printf( "IN_ActivateMouse\n" );
|
||||
}
|
||||
|
||||
extern "C" void DLLEXPORT IN_DeactivateMouse ( void )
|
||||
extern "C" void DLLEXPORT IN_DeactivateMouse( void )
|
||||
{
|
||||
//gEngfuncs.Con_Printf("IN_DeactivateMouse\n");
|
||||
//gEngfuncs.Con_Printf( "IN_DeactivateMouse\n" );
|
||||
}
|
||||
|
||||
extern "C" void DLLEXPORT IN_Accumulate ( void )
|
||||
extern "C" void DLLEXPORT IN_Accumulate( void )
|
||||
{
|
||||
//gEngfuncs.Con_Printf("IN_Accumulate\n");
|
||||
//gEngfuncs.Con_Printf( "IN_Accumulate\n" );
|
||||
}
|
||||
|
||||
void IN_Commands ( void )
|
||||
void IN_Commands( void )
|
||||
{
|
||||
//gEngfuncs.Con_Printf("IN_Commands\n");
|
||||
//gEngfuncs.Con_Printf( "IN_Commands\n" );
|
||||
}
|
||||
|
||||
void IN_Shutdown ( void )
|
||||
void IN_Shutdown( void )
|
||||
{
|
||||
}
|
||||
|
||||
// Register cvars and reset data
|
||||
void IN_Init( void )
|
||||
{
|
||||
sensitivity = gEngfuncs.pfnRegisterVariable ( "sensitivity", "3", FCVAR_ARCHIVE );
|
||||
in_joystick = gEngfuncs.pfnRegisterVariable ( "joystick", "0", FCVAR_ARCHIVE );
|
||||
cl_laddermode = gEngfuncs.pfnRegisterVariable ( "cl_laddermode", "2", FCVAR_ARCHIVE );
|
||||
sensitivity = gEngfuncs.pfnRegisterVariable( "sensitivity", "3", FCVAR_ARCHIVE );
|
||||
in_joystick = gEngfuncs.pfnRegisterVariable( "joystick", "0", FCVAR_ARCHIVE );
|
||||
cl_laddermode = gEngfuncs.pfnRegisterVariable( "cl_laddermode", "2", FCVAR_ARCHIVE );
|
||||
ac_forwardmove = ac_sidemove = rel_yaw = rel_pitch = 0;
|
||||
}
|
||||
|
|
|
@ -24,30 +24,30 @@
|
|||
#define MOUSE_BUTTON_COUNT 5
|
||||
|
||||
// Set this to 1 to show mouse cursor. Experimental
|
||||
int g_iVisibleMouse = 0;
|
||||
int g_iVisibleMouse = 0;
|
||||
|
||||
extern "C"
|
||||
{
|
||||
void DLLEXPORT IN_ActivateMouse( void );
|
||||
void DLLEXPORT IN_DeactivateMouse( void );
|
||||
void DLLEXPORT IN_MouseEvent (int mstate);
|
||||
void DLLEXPORT IN_Accumulate (void);
|
||||
void DLLEXPORT IN_ClearStates (void);
|
||||
void DLLEXPORT IN_MouseEvent( int mstate );
|
||||
void DLLEXPORT IN_Accumulate( void );
|
||||
void DLLEXPORT IN_ClearStates( void );
|
||||
}
|
||||
|
||||
extern cl_enginefunc_t gEngfuncs;
|
||||
|
||||
extern int iMouseInUse;
|
||||
|
||||
extern kbutton_t in_strafe;
|
||||
extern kbutton_t in_mlook;
|
||||
extern kbutton_t in_speed;
|
||||
extern kbutton_t in_jlook;
|
||||
extern kbutton_t in_strafe;
|
||||
extern kbutton_t in_mlook;
|
||||
extern kbutton_t in_speed;
|
||||
extern kbutton_t in_jlook;
|
||||
|
||||
extern cvar_t *m_pitch;
|
||||
extern cvar_t *m_yaw;
|
||||
extern cvar_t *m_forward;
|
||||
extern cvar_t *m_side;
|
||||
extern cvar_t *m_pitch;
|
||||
extern cvar_t *m_yaw;
|
||||
extern cvar_t *m_forward;
|
||||
extern cvar_t *m_side;
|
||||
|
||||
extern cvar_t *lookstrafe;
|
||||
extern cvar_t *lookspring;
|
||||
|
@ -60,26 +60,26 @@ extern cvar_t *cl_pitchspeed;
|
|||
extern cvar_t *cl_movespeedkey;
|
||||
|
||||
// mouse variables
|
||||
cvar_t *m_filter;
|
||||
cvar_t *sensitivity;
|
||||
cvar_t *m_filter;
|
||||
cvar_t *sensitivity;
|
||||
|
||||
int mouse_buttons;
|
||||
int mouse_oldbuttonstate;
|
||||
POINT current_pos;
|
||||
int mouse_x, mouse_y, old_mouse_x, old_mouse_y, mx_accum, my_accum;
|
||||
int mouse_buttons;
|
||||
int mouse_oldbuttonstate;
|
||||
POINT current_pos;
|
||||
int mouse_x, mouse_y, old_mouse_x, old_mouse_y, mx_accum, my_accum;
|
||||
|
||||
static int restore_spi;
|
||||
static int originalmouseparms[3], newmouseparms[3] = {0, 0, 1};
|
||||
static int mouseactive;
|
||||
int mouseinitialized;
|
||||
static int mouseparmsvalid;
|
||||
static int mouseshowtoggle = 1;
|
||||
static int restore_spi;
|
||||
static int originalmouseparms[3], newmouseparms[3] = {0, 0, 1};
|
||||
static int mouseactive;
|
||||
int mouseinitialized;
|
||||
static int mouseparmsvalid;
|
||||
static int mouseshowtoggle = 1;
|
||||
|
||||
// joystick defines and variables
|
||||
// where should defines be moved?
|
||||
#define JOY_ABSOLUTE_AXIS 0x00000000 // control like a joystick
|
||||
#define JOY_RELATIVE_AXIS 0x00000010 // control like a mouse, spinner, trackball
|
||||
#define JOY_MAX_AXES 6 // X, Y, Z, R, U, V
|
||||
#define JOY_MAX_AXES 6 // X, Y, Z, R, U, V
|
||||
#define JOY_AXIS_X 0
|
||||
#define JOY_AXIS_Y 1
|
||||
#define JOY_AXIS_Z 2
|
||||
|
@ -106,57 +106,57 @@ DWORD dwAxisFlags[JOY_MAX_AXES] =
|
|||
JOY_RETURNV
|
||||
};
|
||||
|
||||
DWORD dwAxisMap[ JOY_MAX_AXES ];
|
||||
DWORD dwControlMap[ JOY_MAX_AXES ];
|
||||
PDWORD pdwRawValue[ JOY_MAX_AXES ];
|
||||
DWORD dwAxisMap[JOY_MAX_AXES];
|
||||
DWORD dwControlMap[JOY_MAX_AXES];
|
||||
PDWORD pdwRawValue[JOY_MAX_AXES];
|
||||
|
||||
// none of these cvars are saved over a session
|
||||
// this means that advanced controller configuration needs to be executed
|
||||
// each time. this avoids any problems with getting back to a default usage
|
||||
// or when changing from one controller to another. this way at least something
|
||||
// works.
|
||||
cvar_t *in_joystick;
|
||||
cvar_t *joy_name;
|
||||
cvar_t *joy_advanced;
|
||||
cvar_t *joy_advaxisx;
|
||||
cvar_t *joy_advaxisy;
|
||||
cvar_t *joy_advaxisz;
|
||||
cvar_t *joy_advaxisr;
|
||||
cvar_t *joy_advaxisu;
|
||||
cvar_t *joy_advaxisv;
|
||||
cvar_t *joy_forwardthreshold;
|
||||
cvar_t *joy_sidethreshold;
|
||||
cvar_t *joy_pitchthreshold;
|
||||
cvar_t *joy_yawthreshold;
|
||||
cvar_t *joy_forwardsensitivity;
|
||||
cvar_t *joy_sidesensitivity;
|
||||
cvar_t *joy_pitchsensitivity;
|
||||
cvar_t *joy_yawsensitivity;
|
||||
cvar_t *joy_wwhack1;
|
||||
cvar_t *joy_wwhack2;
|
||||
cvar_t *in_joystick;
|
||||
cvar_t *joy_name;
|
||||
cvar_t *joy_advanced;
|
||||
cvar_t *joy_advaxisx;
|
||||
cvar_t *joy_advaxisy;
|
||||
cvar_t *joy_advaxisz;
|
||||
cvar_t *joy_advaxisr;
|
||||
cvar_t *joy_advaxisu;
|
||||
cvar_t *joy_advaxisv;
|
||||
cvar_t *joy_forwardthreshold;
|
||||
cvar_t *joy_sidethreshold;
|
||||
cvar_t *joy_pitchthreshold;
|
||||
cvar_t *joy_yawthreshold;
|
||||
cvar_t *joy_forwardsensitivity;
|
||||
cvar_t *joy_sidesensitivity;
|
||||
cvar_t *joy_pitchsensitivity;
|
||||
cvar_t *joy_yawsensitivity;
|
||||
cvar_t *joy_wwhack1;
|
||||
cvar_t *joy_wwhack2;
|
||||
|
||||
int joy_avail, joy_advancedinit, joy_haspov;
|
||||
DWORD joy_oldbuttonstate, joy_oldpovstate;
|
||||
int joy_avail, joy_advancedinit, joy_haspov;
|
||||
DWORD joy_oldbuttonstate, joy_oldpovstate;
|
||||
|
||||
int joy_id;
|
||||
DWORD joy_flags;
|
||||
DWORD joy_numbuttons;
|
||||
int joy_id;
|
||||
DWORD joy_flags;
|
||||
DWORD joy_numbuttons;
|
||||
|
||||
static JOYINFOEX ji;
|
||||
static JOYINFOEX ji;
|
||||
|
||||
/*
|
||||
===========
|
||||
Force_CenterView_f
|
||||
===========
|
||||
*/
|
||||
void Force_CenterView_f (void)
|
||||
void Force_CenterView_f( void )
|
||||
{
|
||||
vec3_t viewangles;
|
||||
|
||||
if (!iMouseInUse)
|
||||
if( !iMouseInUse )
|
||||
{
|
||||
gEngfuncs.GetViewAngles( (float *)viewangles );
|
||||
viewangles[PITCH] = 0;
|
||||
viewangles[PITCH] = 0;
|
||||
gEngfuncs.SetViewAngles( (float *)viewangles );
|
||||
}
|
||||
}
|
||||
|
@ -166,12 +166,12 @@ void Force_CenterView_f (void)
|
|||
IN_ActivateMouse
|
||||
===========
|
||||
*/
|
||||
void DLLEXPORT IN_ActivateMouse (void)
|
||||
void DLLEXPORT IN_ActivateMouse( void )
|
||||
{
|
||||
if (mouseinitialized)
|
||||
if( mouseinitialized )
|
||||
{
|
||||
if (mouseparmsvalid)
|
||||
restore_spi = SystemParametersInfo (SPI_SETMOUSE, 0, newmouseparms, 0);
|
||||
if( mouseparmsvalid )
|
||||
restore_spi = SystemParametersInfo( SPI_SETMOUSE, 0, newmouseparms, 0 );
|
||||
mouseactive = 1;
|
||||
}
|
||||
}
|
||||
|
@ -181,13 +181,12 @@ void DLLEXPORT IN_ActivateMouse (void)
|
|||
IN_DeactivateMouse
|
||||
===========
|
||||
*/
|
||||
void DLLEXPORT IN_DeactivateMouse (void)
|
||||
void DLLEXPORT IN_DeactivateMouse( void )
|
||||
{
|
||||
if (mouseinitialized)
|
||||
if( mouseinitialized )
|
||||
{
|
||||
if (restore_spi)
|
||||
SystemParametersInfo (SPI_SETMOUSE, 0, originalmouseparms, 0);
|
||||
|
||||
if( restore_spi )
|
||||
SystemParametersInfo( SPI_SETMOUSE, 0, originalmouseparms, 0 );
|
||||
mouseactive = 0;
|
||||
}
|
||||
}
|
||||
|
@ -197,26 +196,26 @@ void DLLEXPORT IN_DeactivateMouse (void)
|
|||
IN_StartupMouse
|
||||
===========
|
||||
*/
|
||||
void IN_StartupMouse (void)
|
||||
void IN_StartupMouse( void )
|
||||
{
|
||||
if ( gEngfuncs.CheckParm ("-nomouse", NULL ) )
|
||||
return;
|
||||
if( gEngfuncs.CheckParm( "-nomouse", NULL ) )
|
||||
return;
|
||||
|
||||
mouseinitialized = 1;
|
||||
mouseparmsvalid = SystemParametersInfo (SPI_GETMOUSE, 0, originalmouseparms, 0);
|
||||
mouseparmsvalid = SystemParametersInfo( SPI_GETMOUSE, 0, originalmouseparms, 0 );
|
||||
|
||||
if (mouseparmsvalid)
|
||||
if( mouseparmsvalid )
|
||||
{
|
||||
if ( gEngfuncs.CheckParm ("-noforcemspd", NULL ) )
|
||||
if( gEngfuncs.CheckParm( "-noforcemspd", NULL ) )
|
||||
newmouseparms[2] = originalmouseparms[2];
|
||||
|
||||
if ( gEngfuncs.CheckParm ("-noforcemaccel", NULL ) )
|
||||
if( gEngfuncs.CheckParm( "-noforcemaccel", NULL ) )
|
||||
{
|
||||
newmouseparms[0] = originalmouseparms[0];
|
||||
newmouseparms[1] = originalmouseparms[1];
|
||||
}
|
||||
|
||||
if ( gEngfuncs.CheckParm ("-noforcemparms", NULL ) )
|
||||
if( gEngfuncs.CheckParm( "-noforcemparms", NULL ) )
|
||||
{
|
||||
newmouseparms[0] = originalmouseparms[0];
|
||||
newmouseparms[1] = originalmouseparms[1];
|
||||
|
@ -232,7 +231,7 @@ void IN_StartupMouse (void)
|
|||
IN_Shutdown
|
||||
===========
|
||||
*/
|
||||
void IN_Shutdown (void)
|
||||
void IN_Shutdown( void )
|
||||
{
|
||||
IN_DeactivateMouse ();
|
||||
}
|
||||
|
@ -258,7 +257,7 @@ FIXME: Call through to engine?
|
|||
*/
|
||||
void IN_ResetMouse( void )
|
||||
{
|
||||
SetCursorPos ( gEngfuncs.GetWindowCenterX(), gEngfuncs.GetWindowCenterY() );
|
||||
SetCursorPos ( gEngfuncs.GetWindowCenterX(), gEngfuncs.GetWindowCenterY() );
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -266,29 +265,29 @@ void IN_ResetMouse( void )
|
|||
IN_MouseEvent
|
||||
===========
|
||||
*/
|
||||
void DLLEXPORT IN_MouseEvent (int mstate)
|
||||
void DLLEXPORT IN_MouseEvent( int mstate )
|
||||
{
|
||||
int i;
|
||||
int i;
|
||||
|
||||
if ( iMouseInUse || g_iVisibleMouse )
|
||||
if( iMouseInUse || g_iVisibleMouse )
|
||||
return;
|
||||
|
||||
// perform button actions
|
||||
for (i=0 ; i<mouse_buttons ; i++)
|
||||
for( i = 0; i < mouse_buttons; i++ )
|
||||
{
|
||||
if ( (mstate & (1<<i)) &&
|
||||
!(mouse_oldbuttonstate & (1<<i)) )
|
||||
if( ( mstate & ( 1 << i ) ) &&
|
||||
!( mouse_oldbuttonstate & ( 1 << i ) ) )
|
||||
{
|
||||
gEngfuncs.Key_Event (K_MOUSE1 + i, 1);
|
||||
gEngfuncs.Key_Event( K_MOUSE1 + i, 1 );
|
||||
}
|
||||
|
||||
if ( !(mstate & (1<<i)) &&
|
||||
(mouse_oldbuttonstate & (1<<i)) )
|
||||
if( !( mstate & ( 1 << i ) ) &&
|
||||
( mouse_oldbuttonstate & ( 1 << i ) ) )
|
||||
{
|
||||
gEngfuncs.Key_Event (K_MOUSE1 + i, 0);
|
||||
gEngfuncs.Key_Event( K_MOUSE1 + i, 0 );
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
mouse_oldbuttonstate = mstate;
|
||||
}
|
||||
|
||||
|
@ -297,18 +296,18 @@ void DLLEXPORT IN_MouseEvent (int mstate)
|
|||
IN_MouseMove
|
||||
===========
|
||||
*/
|
||||
void IN_MouseMove ( float frametime, usercmd_t *cmd)
|
||||
void IN_MouseMove( float frametime, usercmd_t *cmd )
|
||||
{
|
||||
int mx, my;
|
||||
int mx, my;
|
||||
vec3_t viewangles;
|
||||
|
||||
gEngfuncs.GetViewAngles( (float *)viewangles );
|
||||
|
||||
//jjb - this disbles normal mouse control if the user is trying to
|
||||
// move the camera, or if the mouse cursor is visible or if we're in intermission
|
||||
if ( !iMouseInUse && !g_iVisibleMouse && !gHUD.m_iIntermission )
|
||||
if( !iMouseInUse && !g_iVisibleMouse && !gHUD.m_iIntermission )
|
||||
{
|
||||
GetCursorPos (¤t_pos);
|
||||
GetCursorPos( ¤t_pos );
|
||||
|
||||
mx = current_pos.x - gEngfuncs.GetWindowCenterX() + mx_accum;
|
||||
my = current_pos.y - gEngfuncs.GetWindowCenterY() + my_accum;
|
||||
|
@ -316,10 +315,10 @@ void IN_MouseMove ( float frametime, usercmd_t *cmd)
|
|||
mx_accum = 0;
|
||||
my_accum = 0;
|
||||
|
||||
if (m_filter->value)
|
||||
if( m_filter->value )
|
||||
{
|
||||
mouse_x = (mx + old_mouse_x) * 0.5;
|
||||
mouse_y = (my + old_mouse_y) * 0.5;
|
||||
mouse_x = ( mx + old_mouse_x ) * 0.5;
|
||||
mouse_y = ( my + old_mouse_y ) * 0.5;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -330,7 +329,7 @@ void IN_MouseMove ( float frametime, usercmd_t *cmd)
|
|||
old_mouse_x = mx;
|
||||
old_mouse_y = my;
|
||||
|
||||
if ( gHUD.GetSensitivity() != 0 )
|
||||
if( gHUD.GetSensitivity() != 0 )
|
||||
{
|
||||
mouse_x *= gHUD.GetSensitivity();
|
||||
mouse_y *= gHUD.GetSensitivity();
|
||||
|
@ -342,22 +341,22 @@ void IN_MouseMove ( float frametime, usercmd_t *cmd)
|
|||
}
|
||||
|
||||
// add mouse X/Y movement to cmd
|
||||
if ( (in_strafe.state & 1) || (lookstrafe->value && (in_mlook.state & 1) ))
|
||||
if( ( in_strafe.state & 1 ) || ( lookstrafe->value && ( in_mlook.state & 1 ) ) )
|
||||
cmd->sidemove += m_side->value * mouse_x;
|
||||
else
|
||||
viewangles[YAW] -= m_yaw->value * mouse_x;
|
||||
|
||||
if ( (in_mlook.state & 1) && !(in_strafe.state & 1))
|
||||
if( ( in_mlook.state & 1 ) && !( in_strafe.state & 1 ) )
|
||||
{
|
||||
viewangles[PITCH] += m_pitch->value * mouse_y;
|
||||
if (viewangles[PITCH] > cl_pitchdown->value)
|
||||
if( viewangles[PITCH] > cl_pitchdown->value )
|
||||
viewangles[PITCH] = cl_pitchdown->value;
|
||||
if (viewangles[PITCH] < -cl_pitchup->value)
|
||||
if( viewangles[PITCH] < -cl_pitchup->value )
|
||||
viewangles[PITCH] = -cl_pitchup->value;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ((in_strafe.state & 1) && gEngfuncs.IsNoClipping() )
|
||||
if( ( in_strafe.state & 1 ) && gEngfuncs.IsNoClipping() )
|
||||
{
|
||||
cmd->upmove -= m_forward->value * mouse_y;
|
||||
}
|
||||
|
@ -368,7 +367,7 @@ void IN_MouseMove ( float frametime, usercmd_t *cmd)
|
|||
}
|
||||
|
||||
// if the mouse has moved, force it to the center, so there's room to move
|
||||
if ( mx || my )
|
||||
if( mx || my )
|
||||
{
|
||||
IN_ResetMouse();
|
||||
}
|
||||
|
@ -394,14 +393,14 @@ void IN_MouseMove ( float frametime, usercmd_t *cmd)
|
|||
IN_Accumulate
|
||||
===========
|
||||
*/
|
||||
void DLLEXPORT IN_Accumulate (void)
|
||||
void DLLEXPORT IN_Accumulate( void )
|
||||
{
|
||||
//only accumulate mouse if we are not moving the camera with the mouse
|
||||
if ( !iMouseInUse && !g_iVisibleMouse )
|
||||
if( !iMouseInUse && !g_iVisibleMouse )
|
||||
{
|
||||
if (mouseactive)
|
||||
{
|
||||
GetCursorPos (¤t_pos);
|
||||
if( mouseactive )
|
||||
{
|
||||
GetCursorPos( ¤t_pos );
|
||||
|
||||
mx_accum += current_pos.x - gEngfuncs.GetWindowCenterX();
|
||||
my_accum += current_pos.y - gEngfuncs.GetWindowCenterY();
|
||||
|
@ -410,7 +409,6 @@ void DLLEXPORT IN_Accumulate (void)
|
|||
IN_ResetMouse();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -418,9 +416,9 @@ void DLLEXPORT IN_Accumulate (void)
|
|||
IN_ClearStates
|
||||
===================
|
||||
*/
|
||||
void DLLEXPORT IN_ClearStates (void)
|
||||
void DLLEXPORT IN_ClearStates( void )
|
||||
{
|
||||
if ( !mouseactive )
|
||||
if( !mouseactive )
|
||||
return;
|
||||
|
||||
mx_accum = 0;
|
||||
|
@ -433,50 +431,50 @@ void DLLEXPORT IN_ClearStates (void)
|
|||
IN_StartupJoystick
|
||||
===============
|
||||
*/
|
||||
void IN_StartupJoystick (void)
|
||||
void IN_StartupJoystick( void )
|
||||
{
|
||||
int numdevs;
|
||||
JOYCAPS jc;
|
||||
MMRESULT mmr;
|
||||
|
||||
// assume no joystick
|
||||
int numdevs;
|
||||
JOYCAPS jc;
|
||||
MMRESULT mmr;
|
||||
|
||||
// assume no joystick
|
||||
joy_avail = 0;
|
||||
|
||||
// abort startup if user requests no joystick
|
||||
if ( gEngfuncs.CheckParm ("-nojoy", NULL ) )
|
||||
return;
|
||||
|
||||
if( gEngfuncs.CheckParm( "-nojoy", NULL ) )
|
||||
return;
|
||||
|
||||
// verify joystick driver is present
|
||||
if ((numdevs = joyGetNumDevs ()) == 0)
|
||||
if( ( numdevs = joyGetNumDevs() ) == 0 )
|
||||
{
|
||||
gEngfuncs.Con_DPrintf ("joystick not found -- driver not present\n\n");
|
||||
gEngfuncs.Con_DPrintf( "joystick not found -- driver not present\n\n" );
|
||||
return;
|
||||
}
|
||||
|
||||
// cycle through the joystick ids for the first valid one
|
||||
for (joy_id=0 ; joy_id<numdevs ; joy_id++)
|
||||
for( joy_id = 0; joy_id < numdevs; joy_id++ )
|
||||
{
|
||||
memset (&ji, 0, sizeof(ji));
|
||||
memset( &ji, 0, sizeof(ji) );
|
||||
ji.dwSize = sizeof(ji);
|
||||
ji.dwFlags = JOY_RETURNCENTERED;
|
||||
|
||||
if ((mmr = joyGetPosEx (joy_id, &ji)) == JOYERR_NOERROR)
|
||||
if( ( mmr = joyGetPosEx( joy_id, &ji ) ) == JOYERR_NOERROR )
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// abort startup if we didn't find a valid joystick
|
||||
if (mmr != JOYERR_NOERROR)
|
||||
if( mmr != JOYERR_NOERROR )
|
||||
{
|
||||
gEngfuncs.Con_DPrintf ("joystick not found -- no valid joysticks (%x)\n\n", mmr);
|
||||
gEngfuncs.Con_DPrintf( "joystick not found -- no valid joysticks (%x)\n\n", mmr );
|
||||
return;
|
||||
}
|
||||
|
||||
// get the capabilities of the selected joystick
|
||||
// abort startup if command fails
|
||||
memset (&jc, 0, sizeof(jc));
|
||||
if ((mmr = joyGetDevCaps (joy_id, &jc, sizeof(jc))) != JOYERR_NOERROR)
|
||||
memset( &jc, 0, sizeof(jc) );
|
||||
if( ( mmr = joyGetDevCaps( joy_id, &jc, sizeof(jc) ) ) != JOYERR_NOERROR )
|
||||
{
|
||||
gEngfuncs.Con_DPrintf ("joystick not found -- invalid joystick capabilities (%x)\n\n", mmr);
|
||||
gEngfuncs.Con_DPrintf( "joystick not found -- invalid joystick capabilities (%x)\n\n", mmr );
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -489,20 +487,19 @@ void IN_StartupJoystick (void)
|
|||
|
||||
// mark the joystick as available and advanced initialization not completed
|
||||
// this is needed as cvars are not available during initialization
|
||||
gEngfuncs.Con_Printf ("joystick found\n\n", mmr);
|
||||
gEngfuncs.Con_Printf( "joystick found\n\n", mmr );
|
||||
joy_avail = 1;
|
||||
joy_advancedinit = 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===========
|
||||
RawValuePointer
|
||||
===========
|
||||
*/
|
||||
PDWORD RawValuePointer (int axis)
|
||||
PDWORD RawValuePointer( int axis )
|
||||
{
|
||||
switch (axis)
|
||||
switch( axis )
|
||||
{
|
||||
case JOY_AXIS_X:
|
||||
return &ji.dwXpos;
|
||||
|
@ -521,29 +518,27 @@ PDWORD RawValuePointer (int axis)
|
|||
return &ji.dwXpos;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===========
|
||||
Joy_AdvancedUpdate_f
|
||||
===========
|
||||
*/
|
||||
void Joy_AdvancedUpdate_f (void)
|
||||
void Joy_AdvancedUpdate_f( void )
|
||||
{
|
||||
|
||||
// called once by IN_ReadJoystick and by user whenever an update is needed
|
||||
// cvars are now available
|
||||
int i;
|
||||
int i;
|
||||
DWORD dwTemp;
|
||||
|
||||
// initialize all the maps
|
||||
for (i = 0; i < JOY_MAX_AXES; i++)
|
||||
for( i = 0; i < JOY_MAX_AXES; i++ )
|
||||
{
|
||||
dwAxisMap[i] = AxisNada;
|
||||
dwControlMap[i] = JOY_ABSOLUTE_AXIS;
|
||||
pdwRawValue[i] = RawValuePointer(i);
|
||||
}
|
||||
|
||||
if( joy_advanced->value == 0.0)
|
||||
if( joy_advanced->value == 0.0 )
|
||||
{
|
||||
// default joystick initialization
|
||||
// 2 axes only with joystick control
|
||||
|
@ -554,134 +549,130 @@ void Joy_AdvancedUpdate_f (void)
|
|||
}
|
||||
else
|
||||
{
|
||||
if ( strcmp ( joy_name->string, "joystick") != 0 )
|
||||
if( strcmp( joy_name->string, "joystick" ) != 0 )
|
||||
{
|
||||
// notify user of advanced controller
|
||||
gEngfuncs.Con_Printf ("\n%s configured\n\n", joy_name->string);
|
||||
gEngfuncs.Con_Printf( "\n%s configured\n\n", joy_name->string );
|
||||
}
|
||||
|
||||
// advanced initialization here
|
||||
// data supplied by user via joy_axisn cvars
|
||||
dwTemp = (DWORD) joy_advaxisx->value;
|
||||
dwTemp = (DWORD)joy_advaxisx->value;
|
||||
dwAxisMap[JOY_AXIS_X] = dwTemp & 0x0000000f;
|
||||
dwControlMap[JOY_AXIS_X] = dwTemp & JOY_RELATIVE_AXIS;
|
||||
dwTemp = (DWORD) joy_advaxisy->value;
|
||||
dwTemp = (DWORD)joy_advaxisy->value;
|
||||
dwAxisMap[JOY_AXIS_Y] = dwTemp & 0x0000000f;
|
||||
dwControlMap[JOY_AXIS_Y] = dwTemp & JOY_RELATIVE_AXIS;
|
||||
dwTemp = (DWORD) joy_advaxisz->value;
|
||||
dwTemp = (DWORD)joy_advaxisz->value;
|
||||
dwAxisMap[JOY_AXIS_Z] = dwTemp & 0x0000000f;
|
||||
dwControlMap[JOY_AXIS_Z] = dwTemp & JOY_RELATIVE_AXIS;
|
||||
dwTemp = (DWORD) joy_advaxisr->value;
|
||||
dwTemp = (DWORD)joy_advaxisr->value;
|
||||
dwAxisMap[JOY_AXIS_R] = dwTemp & 0x0000000f;
|
||||
dwControlMap[JOY_AXIS_R] = dwTemp & JOY_RELATIVE_AXIS;
|
||||
dwTemp = (DWORD) joy_advaxisu->value;
|
||||
dwTemp = (DWORD)joy_advaxisu->value;
|
||||
dwAxisMap[JOY_AXIS_U] = dwTemp & 0x0000000f;
|
||||
dwControlMap[JOY_AXIS_U] = dwTemp & JOY_RELATIVE_AXIS;
|
||||
dwTemp = (DWORD) joy_advaxisv->value;
|
||||
dwTemp = (DWORD)joy_advaxisv->value;
|
||||
dwAxisMap[JOY_AXIS_V] = dwTemp & 0x0000000f;
|
||||
dwControlMap[JOY_AXIS_V] = dwTemp & JOY_RELATIVE_AXIS;
|
||||
}
|
||||
|
||||
// compute the axes to collect from DirectInput
|
||||
joy_flags = JOY_RETURNCENTERED | JOY_RETURNBUTTONS | JOY_RETURNPOV;
|
||||
for (i = 0; i < JOY_MAX_AXES; i++)
|
||||
for( i = 0; i < JOY_MAX_AXES; i++ )
|
||||
{
|
||||
if (dwAxisMap[i] != AxisNada)
|
||||
if( dwAxisMap[i] != AxisNada )
|
||||
{
|
||||
joy_flags |= dwAxisFlags[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===========
|
||||
IN_Commands
|
||||
===========
|
||||
*/
|
||||
void IN_Commands (void)
|
||||
void IN_Commands( void )
|
||||
{
|
||||
int i, key_index;
|
||||
DWORD buttonstate, povstate;
|
||||
int i, key_index;
|
||||
DWORD buttonstate, povstate;
|
||||
|
||||
if (!joy_avail)
|
||||
if( !joy_avail )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
// loop through the joystick buttons
|
||||
// key a joystick event or auxillary event for higher number buttons for each state change
|
||||
buttonstate = ji.dwButtons;
|
||||
for (i=0 ; i < (int)joy_numbuttons ; i++)
|
||||
for( i = 0; i < (int)joy_numbuttons; i++ )
|
||||
{
|
||||
if ( (buttonstate & (1<<i)) && !(joy_oldbuttonstate & (1<<i)) )
|
||||
if( ( buttonstate & ( 1 << i ) ) && !( joy_oldbuttonstate & ( 1 << i ) ) )
|
||||
{
|
||||
key_index = (i < 4) ? K_JOY1 : K_AUX1;
|
||||
gEngfuncs.Key_Event (key_index + i, 1);
|
||||
key_index = ( i < 4 ) ? K_JOY1 : K_AUX1;
|
||||
gEngfuncs.Key_Event( key_index + i, 1 );
|
||||
}
|
||||
|
||||
if ( !(buttonstate & (1<<i)) && (joy_oldbuttonstate & (1<<i)) )
|
||||
if( !( buttonstate & ( 1 << i ) ) && ( joy_oldbuttonstate & ( 1 << i ) ) )
|
||||
{
|
||||
key_index = (i < 4) ? K_JOY1 : K_AUX1;
|
||||
gEngfuncs.Key_Event (key_index + i, 0);
|
||||
key_index = ( i < 4 ) ? K_JOY1 : K_AUX1;
|
||||
gEngfuncs.Key_Event( key_index + i, 0 );
|
||||
}
|
||||
}
|
||||
joy_oldbuttonstate = buttonstate;
|
||||
|
||||
if (joy_haspov)
|
||||
if( joy_haspov )
|
||||
{
|
||||
// convert POV information into 4 bits of state information
|
||||
// this avoids any potential problems related to moving from one
|
||||
// direction to another without going through the center position
|
||||
povstate = 0;
|
||||
if(ji.dwPOV != JOY_POVCENTERED)
|
||||
if( ji.dwPOV != JOY_POVCENTERED )
|
||||
{
|
||||
if (ji.dwPOV == JOY_POVFORWARD)
|
||||
if( ji.dwPOV == JOY_POVFORWARD )
|
||||
povstate |= 0x01;
|
||||
if (ji.dwPOV == JOY_POVRIGHT)
|
||||
if( ji.dwPOV == JOY_POVRIGHT )
|
||||
povstate |= 0x02;
|
||||
if (ji.dwPOV == JOY_POVBACKWARD)
|
||||
if( ji.dwPOV == JOY_POVBACKWARD )
|
||||
povstate |= 0x04;
|
||||
if (ji.dwPOV == JOY_POVLEFT)
|
||||
if( ji.dwPOV == JOY_POVLEFT )
|
||||
povstate |= 0x08;
|
||||
}
|
||||
// determine which bits have changed and key an auxillary event for each change
|
||||
for (i=0 ; i < 4 ; i++)
|
||||
for( i = 0; i < 4; i++ )
|
||||
{
|
||||
if ( (povstate & (1<<i)) && !(joy_oldpovstate & (1<<i)) )
|
||||
if( ( povstate & ( 1 << i ) ) && !( joy_oldpovstate & ( 1 << i ) ) )
|
||||
{
|
||||
gEngfuncs.Key_Event (K_AUX29 + i, 1);
|
||||
gEngfuncs.Key_Event( K_AUX29 + i, 1 );
|
||||
}
|
||||
|
||||
if ( !(povstate & (1<<i)) && (joy_oldpovstate & (1<<i)) )
|
||||
if( !( povstate & ( 1 << i ) ) && ( joy_oldpovstate & ( 1 << i ) ) )
|
||||
{
|
||||
gEngfuncs.Key_Event (K_AUX29 + i, 0);
|
||||
gEngfuncs.Key_Event( K_AUX29 + i, 0 );
|
||||
}
|
||||
}
|
||||
joy_oldpovstate = povstate;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
/*
|
||||
===============
|
||||
IN_ReadJoystick
|
||||
===============
|
||||
*/
|
||||
int IN_ReadJoystick (void)
|
||||
int IN_ReadJoystick( void )
|
||||
{
|
||||
|
||||
memset (&ji, 0, sizeof(ji));
|
||||
memset( &ji, 0, sizeof(ji) );
|
||||
ji.dwSize = sizeof(ji);
|
||||
ji.dwFlags = joy_flags;
|
||||
|
||||
if (joyGetPosEx (joy_id, &ji) == JOYERR_NOERROR)
|
||||
if( joyGetPosEx( joy_id, &ji ) == JOYERR_NOERROR )
|
||||
{
|
||||
// this is a hack -- there is a bug in the Logitech WingMan Warrior DirectInput Driver
|
||||
// rather than having 32768 be the zero point, they have the zero point at 32668
|
||||
// go figure -- anyway, now we get the full resolution out of the device
|
||||
if (joy_wwhack1->value != 0.0)
|
||||
if( joy_wwhack1->value != 0.0 )
|
||||
{
|
||||
ji.dwUpos += 100;
|
||||
}
|
||||
|
@ -692,28 +683,26 @@ int IN_ReadJoystick (void)
|
|||
// read error occurred
|
||||
// turning off the joystick seems too harsh for 1 read error,\
|
||||
// but what should be done?
|
||||
// Con_Printf ("IN_ReadJoystick: no response\n");
|
||||
// Con_Printf( "IN_ReadJoystick: no response\n" );
|
||||
// joy_avail = 0;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===========
|
||||
IN_JoyMove
|
||||
===========
|
||||
*/
|
||||
void IN_JoyMove ( float frametime, usercmd_t *cmd )
|
||||
void IN_JoyMove( float frametime, usercmd_t *cmd )
|
||||
{
|
||||
float speed, aspeed;
|
||||
float fAxisValue, fTemp;
|
||||
int i;
|
||||
float speed, aspeed;
|
||||
float fAxisValue, fTemp;
|
||||
int i;
|
||||
vec3_t viewangles;
|
||||
|
||||
gEngfuncs.GetViewAngles( (float *)viewangles );
|
||||
|
||||
|
||||
// complete initialization if first time in
|
||||
// this is needed as cvars are not available at initialization time
|
||||
if( joy_advancedinit != 1 )
|
||||
|
@ -723,18 +712,18 @@ void IN_JoyMove ( float frametime, usercmd_t *cmd )
|
|||
}
|
||||
|
||||
// verify joystick is available and that the user wants to use it
|
||||
if (!joy_avail || !in_joystick->value)
|
||||
if( !joy_avail || !in_joystick->value )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
// collect the joystick data, if possible
|
||||
if (IN_ReadJoystick () != 1)
|
||||
if( IN_ReadJoystick () != 1 )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (in_speed.state & 1)
|
||||
if( in_speed.state & 1 )
|
||||
speed = cl_movespeedkey->value;
|
||||
else
|
||||
speed = 1;
|
||||
|
@ -742,126 +731,121 @@ void IN_JoyMove ( float frametime, usercmd_t *cmd )
|
|||
aspeed = speed * frametime;
|
||||
|
||||
// loop through the axes
|
||||
for (i = 0; i < JOY_MAX_AXES; i++)
|
||||
for( i = 0; i < JOY_MAX_AXES; i++ )
|
||||
{
|
||||
// get the floating point zero-centered, potentially-inverted data for the current axis
|
||||
fAxisValue = (float) *pdwRawValue[i];
|
||||
// move centerpoint to zero
|
||||
fAxisValue -= 32768.0;
|
||||
|
||||
if (joy_wwhack2->value != 0.0)
|
||||
if( joy_wwhack2->value != 0.0 )
|
||||
{
|
||||
if (dwAxisMap[i] == AxisTurn)
|
||||
if( dwAxisMap[i] == AxisTurn )
|
||||
{
|
||||
// this is a special formula for the Logitech WingMan Warrior
|
||||
// y=ax^b; where a = 300 and b = 1.3
|
||||
// also x values are in increments of 800 (so this is factored out)
|
||||
// then bounds check result to level out excessively high spin rates
|
||||
fTemp = 300.0 * pow(abs(fAxisValue) / 800.0, 1.3);
|
||||
if (fTemp > 14000.0)
|
||||
fTemp = 300.0 * pow( abs( fAxisValue ) / 800.0, 1.3 );
|
||||
if( fTemp > 14000.0 )
|
||||
fTemp = 14000.0;
|
||||
// restore direction information
|
||||
fAxisValue = (fAxisValue > 0.0) ? fTemp : -fTemp;
|
||||
fAxisValue = ( fAxisValue > 0.0 ) ? fTemp : -fTemp;
|
||||
}
|
||||
}
|
||||
|
||||
// convert range from -32768..32767 to -1..1
|
||||
// convert range from -32768..32767 to -1..1
|
||||
fAxisValue /= 32768.0;
|
||||
|
||||
switch (dwAxisMap[i])
|
||||
switch( dwAxisMap[i] )
|
||||
{
|
||||
case AxisForward:
|
||||
if ((joy_advanced->value == 0.0) && (in_jlook.state & 1))
|
||||
if( ( joy_advanced->value == 0.0 ) && ( in_jlook.state & 1 ) )
|
||||
{
|
||||
// user wants forward control to become look control
|
||||
if (fabs(fAxisValue) > joy_pitchthreshold->value)
|
||||
{
|
||||
if( fabs( fAxisValue ) > joy_pitchthreshold->value )
|
||||
{
|
||||
// if mouse invert is on, invert the joystick pitch value
|
||||
// only absolute control support here (joy_advanced is 0)
|
||||
if (m_pitch->value < 0.0)
|
||||
if( m_pitch->value < 0.0 )
|
||||
{
|
||||
viewangles[PITCH] -= (fAxisValue * joy_pitchsensitivity->value) * aspeed * cl_pitchspeed->value;
|
||||
viewangles[PITCH] -= ( fAxisValue * joy_pitchsensitivity->value ) * aspeed * cl_pitchspeed->value;
|
||||
}
|
||||
else
|
||||
{
|
||||
viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity->value) * aspeed * cl_pitchspeed->value;
|
||||
viewangles[PITCH] += ( fAxisValue * joy_pitchsensitivity->value ) * aspeed * cl_pitchspeed->value;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// user wants forward control to be forward control
|
||||
if (fabs(fAxisValue) > joy_forwardthreshold->value)
|
||||
if( fabs( fAxisValue ) > joy_forwardthreshold->value )
|
||||
{
|
||||
cmd->forwardmove += (fAxisValue * joy_forwardsensitivity->value) * speed * cl_forwardspeed->value;
|
||||
cmd->forwardmove += ( fAxisValue * joy_forwardsensitivity->value ) * speed * cl_forwardspeed->value;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case AxisSide:
|
||||
if (fabs(fAxisValue) > joy_sidethreshold->value)
|
||||
if( fabs( fAxisValue ) > joy_sidethreshold->value )
|
||||
{
|
||||
cmd->sidemove += (fAxisValue * joy_sidesensitivity->value) * speed * cl_sidespeed->value;
|
||||
cmd->sidemove += ( fAxisValue * joy_sidesensitivity->value ) * speed * cl_sidespeed->value;
|
||||
}
|
||||
break;
|
||||
|
||||
case AxisTurn:
|
||||
if ((in_strafe.state & 1) || (lookstrafe->value && (in_jlook.state & 1)))
|
||||
if( ( in_strafe.state & 1 ) || ( lookstrafe->value && ( in_jlook.state & 1 ) ) )
|
||||
{
|
||||
// user wants turn control to become side control
|
||||
if (fabs(fAxisValue) > joy_sidethreshold->value)
|
||||
if( fabs( fAxisValue ) > joy_sidethreshold->value )
|
||||
{
|
||||
cmd->sidemove -= (fAxisValue * joy_sidesensitivity->value) * speed * cl_sidespeed->value;
|
||||
cmd->sidemove -= ( fAxisValue * joy_sidesensitivity->value ) * speed * cl_sidespeed->value;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// user wants turn control to be turn control
|
||||
if (fabs(fAxisValue) > joy_yawthreshold->value)
|
||||
if( fabs( fAxisValue ) > joy_yawthreshold->value )
|
||||
{
|
||||
if(dwControlMap[i] == JOY_ABSOLUTE_AXIS)
|
||||
if( dwControlMap[i] == JOY_ABSOLUTE_AXIS )
|
||||
{
|
||||
viewangles[YAW] += (fAxisValue * joy_yawsensitivity->value) * aspeed * cl_yawspeed->value;
|
||||
viewangles[YAW] += ( fAxisValue * joy_yawsensitivity->value ) * aspeed * cl_yawspeed->value;
|
||||
}
|
||||
else
|
||||
{
|
||||
viewangles[YAW] += (fAxisValue * joy_yawsensitivity->value) * speed * 180.0;
|
||||
viewangles[YAW] += ( fAxisValue * joy_yawsensitivity->value ) * speed * 180.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case AxisLook:
|
||||
if (in_jlook.state & 1)
|
||||
if( in_jlook.state & 1 )
|
||||
{
|
||||
if (fabs(fAxisValue) > joy_pitchthreshold->value)
|
||||
if( fabs( fAxisValue ) > joy_pitchthreshold->value )
|
||||
{
|
||||
// pitch movement detected and pitch movement desired by user
|
||||
if(dwControlMap[i] == JOY_ABSOLUTE_AXIS)
|
||||
if( dwControlMap[i] == JOY_ABSOLUTE_AXIS )
|
||||
{
|
||||
viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity->value) * aspeed * cl_pitchspeed->value;
|
||||
viewangles[PITCH] += ( fAxisValue * joy_pitchsensitivity->value ) * aspeed * cl_pitchspeed->value;
|
||||
}
|
||||
else
|
||||
{
|
||||
viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity->value) * speed * 180.0;
|
||||
viewangles[PITCH] += ( fAxisValue * joy_pitchsensitivity->value ) * speed * 180.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// bounds check pitch
|
||||
if (viewangles[PITCH] > cl_pitchdown->value)
|
||||
if( viewangles[PITCH] > cl_pitchdown->value )
|
||||
viewangles[PITCH] = cl_pitchdown->value;
|
||||
if (viewangles[PITCH] < -cl_pitchup->value)
|
||||
if( viewangles[PITCH] < -cl_pitchup->value )
|
||||
viewangles[PITCH] = -cl_pitchup->value;
|
||||
|
||||
gEngfuncs.SetViewAngles( (float *)viewangles );
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -869,14 +853,14 @@ void IN_JoyMove ( float frametime, usercmd_t *cmd )
|
|||
IN_Move
|
||||
===========
|
||||
*/
|
||||
void IN_Move ( float frametime, usercmd_t *cmd)
|
||||
void IN_Move( float frametime, usercmd_t *cmd )
|
||||
{
|
||||
if ( !iMouseInUse && mouseactive )
|
||||
if( !iMouseInUse && mouseactive )
|
||||
{
|
||||
IN_MouseMove ( frametime, cmd);
|
||||
IN_MouseMove( frametime, cmd );
|
||||
}
|
||||
|
||||
IN_JoyMove ( frametime, cmd);
|
||||
IN_JoyMove( frametime, cmd );
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -884,30 +868,30 @@ void IN_Move ( float frametime, usercmd_t *cmd)
|
|||
IN_Init
|
||||
===========
|
||||
*/
|
||||
void IN_Init (void)
|
||||
void IN_Init( void )
|
||||
{
|
||||
m_filter = gEngfuncs.pfnRegisterVariable ( "m_filter","0", FCVAR_ARCHIVE );
|
||||
sensitivity = gEngfuncs.pfnRegisterVariable ( "sensitivity","3", FCVAR_ARCHIVE ); // user mouse sensitivity setting.
|
||||
m_filter = gEngfuncs.pfnRegisterVariable( "m_filter","0", FCVAR_ARCHIVE );
|
||||
sensitivity = gEngfuncs.pfnRegisterVariable( "sensitivity","3", FCVAR_ARCHIVE ); // user mouse sensitivity setting.
|
||||
|
||||
in_joystick = gEngfuncs.pfnRegisterVariable ( "joystick","0", FCVAR_ARCHIVE );
|
||||
joy_name = gEngfuncs.pfnRegisterVariable ( "joyname", "joystick", 0 );
|
||||
joy_advanced = gEngfuncs.pfnRegisterVariable ( "joyadvanced", "0", 0 );
|
||||
joy_advaxisx = gEngfuncs.pfnRegisterVariable ( "joyadvaxisx", "0", 0 );
|
||||
joy_advaxisy = gEngfuncs.pfnRegisterVariable ( "joyadvaxisy", "0", 0 );
|
||||
joy_advaxisz = gEngfuncs.pfnRegisterVariable ( "joyadvaxisz", "0", 0 );
|
||||
joy_advaxisr = gEngfuncs.pfnRegisterVariable ( "joyadvaxisr", "0", 0 );
|
||||
joy_advaxisu = gEngfuncs.pfnRegisterVariable ( "joyadvaxisu", "0", 0 );
|
||||
joy_advaxisv = gEngfuncs.pfnRegisterVariable ( "joyadvaxisv", "0", 0 );
|
||||
joy_forwardthreshold = gEngfuncs.pfnRegisterVariable ( "joyforwardthreshold", "0.15", 0 );
|
||||
joy_sidethreshold = gEngfuncs.pfnRegisterVariable ( "joysidethreshold", "0.15", 0 );
|
||||
joy_pitchthreshold = gEngfuncs.pfnRegisterVariable ( "joypitchthreshold", "0.15", 0 );
|
||||
joy_yawthreshold = gEngfuncs.pfnRegisterVariable ( "joyyawthreshold", "0.15", 0 );
|
||||
joy_forwardsensitivity = gEngfuncs.pfnRegisterVariable ( "joyforwardsensitivity", "-1.0", 0 );
|
||||
joy_sidesensitivity = gEngfuncs.pfnRegisterVariable ( "joysidesensitivity", "-1.0", 0 );
|
||||
joy_pitchsensitivity = gEngfuncs.pfnRegisterVariable ( "joypitchsensitivity", "1.0", 0 );
|
||||
joy_yawsensitivity = gEngfuncs.pfnRegisterVariable ( "joyyawsensitivity", "-1.0", 0 );
|
||||
joy_wwhack1 = gEngfuncs.pfnRegisterVariable ( "joywwhack1", "0.0", 0 );
|
||||
joy_wwhack2 = gEngfuncs.pfnRegisterVariable ( "joywwhack2", "0.0", 0 );
|
||||
in_joystick = gEngfuncs.pfnRegisterVariable( "joystick","0", FCVAR_ARCHIVE );
|
||||
joy_name = gEngfuncs.pfnRegisterVariable( "joyname", "joystick", 0 );
|
||||
joy_advanced = gEngfuncs.pfnRegisterVariable( "joyadvanced", "0", 0 );
|
||||
joy_advaxisx = gEngfuncs.pfnRegisterVariable( "joyadvaxisx", "0", 0 );
|
||||
joy_advaxisy = gEngfuncs.pfnRegisterVariable( "joyadvaxisy", "0", 0 );
|
||||
joy_advaxisz = gEngfuncs.pfnRegisterVariable( "joyadvaxisz", "0", 0 );
|
||||
joy_advaxisr = gEngfuncs.pfnRegisterVariable( "joyadvaxisr", "0", 0 );
|
||||
joy_advaxisu = gEngfuncs.pfnRegisterVariable( "joyadvaxisu", "0", 0 );
|
||||
joy_advaxisv = gEngfuncs.pfnRegisterVariable( "joyadvaxisv", "0", 0 );
|
||||
joy_forwardthreshold = gEngfuncs.pfnRegisterVariable( "joyforwardthreshold", "0.15", 0 );
|
||||
joy_sidethreshold = gEngfuncs.pfnRegisterVariable( "joysidethreshold", "0.15", 0 );
|
||||
joy_pitchthreshold = gEngfuncs.pfnRegisterVariable( "joypitchthreshold", "0.15", 0 );
|
||||
joy_yawthreshold = gEngfuncs.pfnRegisterVariable( "joyyawthreshold", "0.15", 0 );
|
||||
joy_forwardsensitivity = gEngfuncs.pfnRegisterVariable( "joyforwardsensitivity", "-1.0", 0 );
|
||||
joy_sidesensitivity = gEngfuncs.pfnRegisterVariable( "joysidesensitivity", "-1.0", 0 );
|
||||
joy_pitchsensitivity = gEngfuncs.pfnRegisterVariable( "joypitchsensitivity", "1.0", 0 );
|
||||
joy_yawsensitivity = gEngfuncs.pfnRegisterVariable( "joyyawsensitivity", "-1.0", 0 );
|
||||
joy_wwhack1 = gEngfuncs.pfnRegisterVariable( "joywwhack1", "0.0", 0 );
|
||||
joy_wwhack2 = gEngfuncs.pfnRegisterVariable( "joywwhack2", "0.0", 0 );
|
||||
|
||||
gEngfuncs.pfnAddCommand ("force_centerview", Force_CenterView_f);
|
||||
gEngfuncs.pfnAddCommand ("joyadvancedupdate", Joy_AdvancedUpdate_f);
|
||||
|
|
|
@ -11,8 +11,7 @@
|
|||
|
||||
typedef struct kbutton_s
|
||||
{
|
||||
int down[2]; // key nums holding it down
|
||||
int state; // low bit is down state
|
||||
int down[2]; // key nums holding it down
|
||||
int state; // low bit is down state
|
||||
} kbutton_t;
|
||||
|
||||
#endif // !KBUTTONH
|
||||
#endif // !KBUTTONH
|
||||
|
|
|
@ -17,23 +17,22 @@
|
|||
//
|
||||
// generic menu handler
|
||||
//
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "parsemsg.h"
|
||||
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
|
||||
#define MAX_MENU_STRING 512
|
||||
char g_szMenuString[MAX_MENU_STRING];
|
||||
char g_szPrelocalisedMenuString[MAX_MENU_STRING];
|
||||
|
||||
int KB_ConvertString( char *in, char **ppout );
|
||||
|
||||
DECLARE_MESSAGE( m_Menu, ShowMenu );
|
||||
DECLARE_MESSAGE( m_Menu, ShowMenu )
|
||||
|
||||
int CHudMenu :: Init( void )
|
||||
int CHudMenu::Init( void )
|
||||
{
|
||||
gHUD.AddHudElem( this );
|
||||
|
||||
|
@ -44,33 +43,34 @@ int CHudMenu :: Init( void )
|
|||
return 1;
|
||||
}
|
||||
|
||||
void CHudMenu :: InitHUDData( void )
|
||||
void CHudMenu::InitHUDData( void )
|
||||
{
|
||||
m_fMenuDisplayed = 0;
|
||||
m_bitsValidSlots = 0;
|
||||
Reset();
|
||||
}
|
||||
|
||||
void CHudMenu :: Reset( void )
|
||||
void CHudMenu::Reset( void )
|
||||
{
|
||||
g_szPrelocalisedMenuString[0] = 0;
|
||||
m_fWaitingForMore = FALSE;
|
||||
}
|
||||
|
||||
int CHudMenu :: VidInit( void )
|
||||
int CHudMenu::VidInit( void )
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudMenu :: Draw( float flTime )
|
||||
int CHudMenu::Draw( float flTime )
|
||||
{
|
||||
int i;
|
||||
|
||||
// check for if menu is set to disappear
|
||||
if ( m_flShutoffTime > 0 )
|
||||
if( m_flShutoffTime > 0 )
|
||||
{
|
||||
if ( m_flShutoffTime <= gHUD.m_flTime )
|
||||
{ // times up, shutoff
|
||||
if( m_flShutoffTime <= gHUD.m_flTime )
|
||||
{
|
||||
// times up, shutoff
|
||||
m_fMenuDisplayed = 0;
|
||||
m_iFlags &= ~HUD_ACTIVE;
|
||||
return 1;
|
||||
|
@ -78,43 +78,39 @@ int CHudMenu :: Draw( float flTime )
|
|||
}
|
||||
|
||||
// don't draw the menu if the scoreboard is being shown
|
||||
|
||||
|
||||
|
||||
// draw the menu, along the left-hand side of the screen
|
||||
|
||||
// count the number of newlines
|
||||
int nlc = 0;
|
||||
for ( i = 0; i < MAX_MENU_STRING && g_szMenuString[i] != '\0'; i++ )
|
||||
for( i = 0; i < MAX_MENU_STRING && g_szMenuString[i] != '\0'; i++ )
|
||||
{
|
||||
if ( g_szMenuString[i] == '\n' )
|
||||
nlc++;
|
||||
}
|
||||
|
||||
// center it
|
||||
int y = (ScreenHeight/2) - ((nlc/2)*12) - 40; // make sure it is above the say text
|
||||
int y = ( ScreenHeight / 2 ) - ( ( nlc / 2 ) * 12 ) - 40; // make sure it is above the say text
|
||||
int x = 20;
|
||||
|
||||
i = 0;
|
||||
while ( i < MAX_MENU_STRING && g_szMenuString[i] != '\0' )
|
||||
while( i < MAX_MENU_STRING && g_szMenuString[i] != '\0' )
|
||||
{
|
||||
gHUD.DrawHudString( x, y, 320, g_szMenuString + i, 255, 255, 255 );
|
||||
y += 12;
|
||||
|
||||
while ( i < MAX_MENU_STRING && g_szMenuString[i] != '\0' && g_szMenuString[i] != '\n' )
|
||||
while( i < MAX_MENU_STRING && g_szMenuString[i] != '\0' && g_szMenuString[i] != '\n' )
|
||||
i++;
|
||||
if ( g_szMenuString[i] == '\n' )
|
||||
if( g_szMenuString[i] == '\n' )
|
||||
i++;
|
||||
}
|
||||
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// selects an item from the menu
|
||||
void CHudMenu :: SelectMenuItem( int menu_item )
|
||||
void CHudMenu::SelectMenuItem( int menu_item )
|
||||
{
|
||||
// if menu_item is in a valid slot, send a menuselect command to the server
|
||||
if ( (menu_item > 0) && (m_bitsValidSlots & (1 << (menu_item-1))) )
|
||||
if( ( menu_item > 0 ) && ( m_bitsValidSlots & ( 1 << ( menu_item - 1 ) ) ) )
|
||||
{
|
||||
char szbuf[32];
|
||||
sprintf( szbuf, "menuselect %d\n", menu_item );
|
||||
|
@ -126,7 +122,6 @@ void CHudMenu :: SelectMenuItem( int menu_item )
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
// Message handler for ShowMenu message
|
||||
// takes four values:
|
||||
// short: a bitfield of keys that are valid input
|
||||
|
@ -134,7 +129,7 @@ void CHudMenu :: SelectMenuItem( int menu_item )
|
|||
// byte : a boolean, TRUE if there is more string yet to be received before displaying the menu, FALSE if it's the last string
|
||||
// string: menu string to display
|
||||
// if this message is never received, then scores will simply be the combined totals of the players.
|
||||
int CHudMenu :: MsgFunc_ShowMenu( const char *pszName, int iSize, void *pbuf )
|
||||
int CHudMenu::MsgFunc_ShowMenu( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
char *temp = NULL;
|
||||
|
||||
|
@ -144,29 +139,31 @@ int CHudMenu :: MsgFunc_ShowMenu( const char *pszName, int iSize, void *pbuf )
|
|||
int DisplayTime = READ_CHAR();
|
||||
int NeedMore = READ_BYTE();
|
||||
|
||||
if ( DisplayTime > 0 )
|
||||
if( DisplayTime > 0 )
|
||||
m_flShutoffTime = DisplayTime + gHUD.m_flTime;
|
||||
else
|
||||
m_flShutoffTime = -1;
|
||||
|
||||
if ( m_bitsValidSlots )
|
||||
if( m_bitsValidSlots )
|
||||
{
|
||||
if ( !m_fWaitingForMore ) // this is the start of a new menu
|
||||
if( !m_fWaitingForMore ) // this is the start of a new menu
|
||||
{
|
||||
strncpy( g_szPrelocalisedMenuString, READ_STRING(), MAX_MENU_STRING );
|
||||
}
|
||||
else
|
||||
{ // append to the current menu string
|
||||
strncat( g_szPrelocalisedMenuString, READ_STRING(), MAX_MENU_STRING - strlen(g_szPrelocalisedMenuString) );
|
||||
{
|
||||
// append to the current menu string
|
||||
strncat( g_szPrelocalisedMenuString, READ_STRING(), MAX_MENU_STRING - strlen( g_szPrelocalisedMenuString ) );
|
||||
}
|
||||
g_szPrelocalisedMenuString[MAX_MENU_STRING-1] = 0; // ensure null termination (strncat/strncpy does not)
|
||||
g_szPrelocalisedMenuString[MAX_MENU_STRING - 1] = 0; // ensure null termination (strncat/strncpy does not)
|
||||
|
||||
if ( !NeedMore )
|
||||
{ // we have the whole string, so we can localise it now
|
||||
if( !NeedMore )
|
||||
{
|
||||
// we have the whole string, so we can localise it now
|
||||
strcpy( g_szMenuString, gHUD.m_TextMessage.BufferedLocaliseTextString( g_szPrelocalisedMenuString ) );
|
||||
|
||||
// Swap in characters
|
||||
if ( KB_ConvertString( g_szMenuString, &temp ) )
|
||||
if( KB_ConvertString( g_szMenuString, &temp ) )
|
||||
{
|
||||
strcpy( g_szMenuString, temp );
|
||||
free( temp );
|
||||
|
|
|
@ -32,17 +32,17 @@ client_textmessage_t g_pCustomMessage;
|
|||
char *g_pCustomName = "Custom";
|
||||
char g_pCustomText[1024];
|
||||
|
||||
int CHudMessage::Init(void)
|
||||
int CHudMessage::Init( void )
|
||||
{
|
||||
HOOK_MESSAGE( HudText );
|
||||
HOOK_MESSAGE( GameTitle );
|
||||
|
||||
gHUD.AddHudElem(this);
|
||||
gHUD.AddHudElem( this );
|
||||
|
||||
Reset();
|
||||
|
||||
return 1;
|
||||
};
|
||||
}
|
||||
|
||||
int CHudMessage::VidInit( void )
|
||||
{
|
||||
|
@ -50,35 +50,33 @@ int CHudMessage::VidInit( void )
|
|||
m_HUD_title_life = gHUD.GetSpriteIndex( "title_life" );
|
||||
|
||||
return 1;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
void CHudMessage::Reset( void )
|
||||
{
|
||||
memset( m_pMessages, 0, sizeof( m_pMessages[0] ) * maxHUDMessages );
|
||||
memset( m_startTime, 0, sizeof( m_startTime[0] ) * maxHUDMessages );
|
||||
|
||||
memset( m_pMessages, 0, sizeof(m_pMessages[0]) * maxHUDMessages );
|
||||
memset( m_startTime, 0, sizeof(m_startTime[0]) * maxHUDMessages );
|
||||
|
||||
m_gameTitleTime = 0;
|
||||
m_pGameTitle = NULL;
|
||||
}
|
||||
|
||||
|
||||
float CHudMessage::FadeBlend( float fadein, float fadeout, float hold, float localTime )
|
||||
{
|
||||
float fadeTime = fadein + hold;
|
||||
float fadeBlend;
|
||||
|
||||
if ( localTime < 0 )
|
||||
if( localTime < 0 )
|
||||
return 0;
|
||||
|
||||
if ( localTime < fadein )
|
||||
if( localTime < fadein )
|
||||
{
|
||||
fadeBlend = 1 - ((fadein - localTime) / fadein);
|
||||
fadeBlend = 1 - ( ( fadein - localTime ) / fadein );
|
||||
}
|
||||
else if ( localTime > fadeTime )
|
||||
else if( localTime > fadeTime )
|
||||
{
|
||||
if ( fadeout > 0 )
|
||||
fadeBlend = 1 - ((localTime - fadeTime) / fadeout);
|
||||
if( fadeout > 0 )
|
||||
fadeBlend = 1 - ( ( localTime - fadeTime ) / fadeout );
|
||||
else
|
||||
fadeBlend = 0;
|
||||
}
|
||||
|
@ -89,42 +87,41 @@ float CHudMessage::FadeBlend( float fadein, float fadeout, float hold, float loc
|
|||
}
|
||||
|
||||
|
||||
int CHudMessage::XPosition( float x, int width, int totalWidth )
|
||||
int CHudMessage::XPosition( float x, int width, int totalWidth )
|
||||
{
|
||||
int xPos;
|
||||
|
||||
if ( x == -1 )
|
||||
if( x == -1 )
|
||||
{
|
||||
xPos = (ScreenWidth - width) / 2;
|
||||
xPos = ( ScreenWidth - width ) / 2;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( x < 0 )
|
||||
xPos = (1.0 + x) * ScreenWidth - totalWidth; // Alight right
|
||||
if( x < 0 )
|
||||
xPos = ( 1.0 + x ) * ScreenWidth - totalWidth; // Alight right
|
||||
else
|
||||
xPos = x * ScreenWidth;
|
||||
}
|
||||
|
||||
if ( xPos + width > ScreenWidth )
|
||||
if( xPos + width > ScreenWidth )
|
||||
xPos = ScreenWidth - width;
|
||||
else if ( xPos < 0 )
|
||||
else if( xPos < 0 )
|
||||
xPos = 0;
|
||||
|
||||
return xPos;
|
||||
}
|
||||
|
||||
|
||||
int CHudMessage::YPosition( float y, int height )
|
||||
{
|
||||
int yPos;
|
||||
|
||||
if ( y == -1 ) // Centered?
|
||||
yPos = (ScreenHeight - height) * 0.5;
|
||||
if( y == -1 ) // Centered?
|
||||
yPos = ( ScreenHeight - height ) * 0.5;
|
||||
else
|
||||
{
|
||||
// Alight bottom?
|
||||
if ( y < 0 )
|
||||
yPos = (1.0 + y) * ScreenHeight - height; // Alight bottom
|
||||
yPos = ( 1.0 + y ) * ScreenHeight - height; // Alight bottom
|
||||
else // align top
|
||||
yPos = y * ScreenHeight;
|
||||
}
|
||||
|
@ -137,7 +134,6 @@ int CHudMessage::YPosition( float y, int height )
|
|||
return yPos;
|
||||
}
|
||||
|
||||
|
||||
void CHudMessage::MessageScanNextChar( void )
|
||||
{
|
||||
int srcRed, srcGreen, srcBlue, destRed = 0, destGreen = 0, destBlue = 0;
|
||||
|
@ -156,10 +152,9 @@ void CHudMessage::MessageScanNextChar( void )
|
|||
destRed = destGreen = destBlue = 0;
|
||||
blend = m_parms.fadeBlend;
|
||||
break;
|
||||
|
||||
case 2:
|
||||
m_parms.charTime += m_parms.pMessage->fadein;
|
||||
if ( m_parms.charTime > m_parms.time )
|
||||
if( m_parms.charTime > m_parms.time )
|
||||
{
|
||||
srcRed = srcGreen = srcBlue = 0;
|
||||
blend = 0; // pure source
|
||||
|
@ -185,23 +180,22 @@ void CHudMessage::MessageScanNextChar( void )
|
|||
}
|
||||
break;
|
||||
}
|
||||
if ( blend > 255 )
|
||||
if( blend > 255 )
|
||||
blend = 255;
|
||||
else if ( blend < 0 )
|
||||
else if( blend < 0 )
|
||||
blend = 0;
|
||||
|
||||
m_parms.r = ((srcRed * (255-blend)) + (destRed * blend)) >> 8;
|
||||
m_parms.g = ((srcGreen * (255-blend)) + (destGreen * blend)) >> 8;
|
||||
m_parms.b = ((srcBlue * (255-blend)) + (destBlue * blend)) >> 8;
|
||||
m_parms.r = ( ( srcRed * ( 255 - blend ) ) + ( destRed * blend ) ) >> 8;
|
||||
m_parms.g = ( ( srcGreen * (255 - blend ) ) + ( destGreen * blend ) ) >> 8;
|
||||
m_parms.b = ( ( srcBlue * ( 255 - blend ) ) + ( destBlue * blend ) ) >> 8;
|
||||
|
||||
if ( m_parms.pMessage->effect == 1 && m_parms.charTime != 0 )
|
||||
if( m_parms.pMessage->effect == 1 && m_parms.charTime != 0 )
|
||||
{
|
||||
if ( m_parms.x >= 0 && m_parms.y >= 0 && (m_parms.x + gHUD.m_scrinfo.charWidths[ m_parms.text ]) <= ScreenWidth )
|
||||
if( m_parms.x >= 0 && m_parms.y >= 0 && ( m_parms.x + gHUD.m_scrinfo.charWidths[m_parms.text] ) <= ScreenWidth )
|
||||
TextMessageDrawChar( m_parms.x, m_parms.y, m_parms.text, m_parms.pMessage->r2, m_parms.pMessage->g2, m_parms.pMessage->b2 );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CHudMessage::MessageScanStart( void )
|
||||
{
|
||||
switch( m_parms.pMessage->effect )
|
||||
|
@ -212,14 +206,14 @@ void CHudMessage::MessageScanStart( void )
|
|||
m_parms.fadeTime = m_parms.pMessage->fadein + m_parms.pMessage->holdtime;
|
||||
|
||||
|
||||
if ( m_parms.time < m_parms.pMessage->fadein )
|
||||
if( m_parms.time < m_parms.pMessage->fadein )
|
||||
{
|
||||
m_parms.fadeBlend = ((m_parms.pMessage->fadein - m_parms.time) * (1.0/m_parms.pMessage->fadein) * 255);
|
||||
m_parms.fadeBlend = ( ( m_parms.pMessage->fadein - m_parms.time ) * ( 1.0 / m_parms.pMessage->fadein ) * 255 );
|
||||
}
|
||||
else if ( m_parms.time > m_parms.fadeTime )
|
||||
else if( m_parms.time > m_parms.fadeTime )
|
||||
{
|
||||
if ( m_parms.pMessage->fadeout > 0 )
|
||||
m_parms.fadeBlend = (((m_parms.time - m_parms.fadeTime) / m_parms.pMessage->fadeout) * 255);
|
||||
if( m_parms.pMessage->fadeout > 0 )
|
||||
m_parms.fadeBlend = ( ( ( m_parms.time - m_parms.fadeTime ) / m_parms.pMessage->fadeout) * 255);
|
||||
else
|
||||
m_parms.fadeBlend = 255; // Pure dest (off)
|
||||
}
|
||||
|
@ -227,15 +221,14 @@ void CHudMessage::MessageScanStart( void )
|
|||
m_parms.fadeBlend = 0; // Pure source (on)
|
||||
m_parms.charTime = 0;
|
||||
|
||||
if ( m_parms.pMessage->effect == 1 && (rand()%100) < 10 )
|
||||
if( m_parms.pMessage->effect == 1 && ( rand() % 100 ) < 10 )
|
||||
m_parms.charTime = 1;
|
||||
break;
|
||||
|
||||
case 2:
|
||||
m_parms.fadeTime = (m_parms.pMessage->fadein * m_parms.length) + m_parms.pMessage->holdtime;
|
||||
|
||||
if ( m_parms.time > m_parms.fadeTime && m_parms.pMessage->fadeout > 0 )
|
||||
m_parms.fadeBlend = (((m_parms.time - m_parms.fadeTime) / m_parms.pMessage->fadeout) * 255);
|
||||
m_parms.fadeBlend = ( ( ( m_parms.time - m_parms.fadeTime ) / m_parms.pMessage->fadeout ) * 255 );
|
||||
else
|
||||
m_parms.fadeBlend = 0;
|
||||
break;
|
||||
|
@ -257,12 +250,12 @@ void CHudMessage::MessageDrawScan( client_textmessage_t *pMessage, float time )
|
|||
length = 0;
|
||||
width = 0;
|
||||
m_parms.totalWidth = 0;
|
||||
while ( *pText )
|
||||
while( *pText )
|
||||
{
|
||||
if ( *pText == '\n' )
|
||||
if( *pText == '\n' )
|
||||
{
|
||||
m_parms.lines++;
|
||||
if ( width > m_parms.totalWidth )
|
||||
if( width > m_parms.totalWidth )
|
||||
m_parms.totalWidth = width;
|
||||
width = 0;
|
||||
}
|
||||
|
@ -272,8 +265,7 @@ void CHudMessage::MessageDrawScan( client_textmessage_t *pMessage, float time )
|
|||
length++;
|
||||
}
|
||||
m_parms.length = length;
|
||||
m_parms.totalHeight = (m_parms.lines * gHUD.m_scrinfo.iCharHeight);
|
||||
|
||||
m_parms.totalHeight = ( m_parms.lines * gHUD.m_scrinfo.iCharHeight );
|
||||
|
||||
m_parms.y = YPosition( pMessage->y, m_parms.totalHeight );
|
||||
pText = pMessage->pMessage;
|
||||
|
@ -282,11 +274,11 @@ void CHudMessage::MessageDrawScan( client_textmessage_t *pMessage, float time )
|
|||
|
||||
MessageScanStart();
|
||||
|
||||
for ( i = 0; i < m_parms.lines; i++ )
|
||||
for( i = 0; i < m_parms.lines; i++ )
|
||||
{
|
||||
m_parms.lineLength = 0;
|
||||
m_parms.width = 0;
|
||||
while ( *pText && *pText != '\n' )
|
||||
while( *pText && *pText != '\n' )
|
||||
{
|
||||
unsigned char c = *pText;
|
||||
line[m_parms.lineLength] = c;
|
||||
|
@ -299,13 +291,13 @@ void CHudMessage::MessageDrawScan( client_textmessage_t *pMessage, float time )
|
|||
|
||||
m_parms.x = XPosition( pMessage->x, m_parms.width, m_parms.totalWidth );
|
||||
|
||||
for ( j = 0; j < m_parms.lineLength; j++ )
|
||||
for( j = 0; j < m_parms.lineLength; j++ )
|
||||
{
|
||||
m_parms.text = line[j];
|
||||
int next = m_parms.x + gHUD.m_scrinfo.charWidths[ m_parms.text ];
|
||||
int next = m_parms.x + gHUD.m_scrinfo.charWidths[m_parms.text];
|
||||
MessageScanNextChar();
|
||||
|
||||
if ( m_parms.x >= 0 && m_parms.y >= 0 && next <= ScreenWidth )
|
||||
|
||||
if( m_parms.x >= 0 && m_parms.y >= 0 && next <= ScreenWidth )
|
||||
TextMessageDrawChar( m_parms.x, m_parms.y, m_parms.text, m_parms.r, m_parms.g, m_parms.b );
|
||||
m_parms.x = next;
|
||||
}
|
||||
|
@ -314,7 +306,6 @@ void CHudMessage::MessageDrawScan( client_textmessage_t *pMessage, float time )
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
int CHudMessage::Draw( float fTime )
|
||||
{
|
||||
int i, drawn;
|
||||
|
@ -323,53 +314,52 @@ int CHudMessage::Draw( float fTime )
|
|||
|
||||
drawn = 0;
|
||||
|
||||
if ( m_gameTitleTime > 0 )
|
||||
if( m_gameTitleTime > 0 )
|
||||
{
|
||||
float localTime = gHUD.m_flTime - m_gameTitleTime;
|
||||
float brightness;
|
||||
|
||||
// Maybe timer isn't set yet
|
||||
if ( m_gameTitleTime > gHUD.m_flTime )
|
||||
if( m_gameTitleTime > gHUD.m_flTime )
|
||||
m_gameTitleTime = gHUD.m_flTime;
|
||||
|
||||
if ( localTime > (m_pGameTitle->fadein + m_pGameTitle->holdtime + m_pGameTitle->fadeout) )
|
||||
if( localTime > ( m_pGameTitle->fadein + m_pGameTitle->holdtime + m_pGameTitle->fadeout ) )
|
||||
m_gameTitleTime = 0;
|
||||
else
|
||||
{
|
||||
brightness = FadeBlend( m_pGameTitle->fadein, m_pGameTitle->fadeout, m_pGameTitle->holdtime, localTime );
|
||||
|
||||
int halfWidth = gHUD.GetSpriteRect(m_HUD_title_half).right - gHUD.GetSpriteRect(m_HUD_title_half).left;
|
||||
int fullWidth = halfWidth + gHUD.GetSpriteRect(m_HUD_title_life).right - gHUD.GetSpriteRect(m_HUD_title_life).left;
|
||||
int fullHeight = gHUD.GetSpriteRect(m_HUD_title_half).bottom - gHUD.GetSpriteRect(m_HUD_title_half).top;
|
||||
int halfWidth = gHUD.GetSpriteRect( m_HUD_title_half ).right - gHUD.GetSpriteRect( m_HUD_title_half ).left;
|
||||
int fullWidth = halfWidth + gHUD.GetSpriteRect( m_HUD_title_life ).right - gHUD.GetSpriteRect( m_HUD_title_life ).left;
|
||||
int fullHeight = gHUD.GetSpriteRect( m_HUD_title_half ).bottom - gHUD.GetSpriteRect( m_HUD_title_half ).top;
|
||||
|
||||
int x = XPosition( m_pGameTitle->x, fullWidth, fullWidth );
|
||||
int y = YPosition( m_pGameTitle->y, fullHeight );
|
||||
|
||||
SPR_Set( gHUD.GetSprite( m_HUD_title_half ), brightness * m_pGameTitle->r1, brightness * m_pGameTitle->g1, brightness * m_pGameTitle->b1 );
|
||||
SPR_DrawAdditive( 0, x, y, &gHUD.GetSpriteRect( m_HUD_title_half ) );
|
||||
|
||||
SPR_Set( gHUD.GetSprite(m_HUD_title_half), brightness * m_pGameTitle->r1, brightness * m_pGameTitle->g1, brightness * m_pGameTitle->b1 );
|
||||
SPR_DrawAdditive( 0, x, y, &gHUD.GetSpriteRect(m_HUD_title_half) );
|
||||
|
||||
SPR_Set( gHUD.GetSprite(m_HUD_title_life), brightness * m_pGameTitle->r1, brightness * m_pGameTitle->g1, brightness * m_pGameTitle->b1 );
|
||||
SPR_DrawAdditive( 0, x + halfWidth, y, &gHUD.GetSpriteRect(m_HUD_title_life) );
|
||||
SPR_Set( gHUD.GetSprite( m_HUD_title_life ), brightness * m_pGameTitle->r1, brightness * m_pGameTitle->g1, brightness * m_pGameTitle->b1 );
|
||||
SPR_DrawAdditive( 0, x + halfWidth, y, &gHUD.GetSpriteRect( m_HUD_title_life ) );
|
||||
|
||||
drawn = 1;
|
||||
}
|
||||
}
|
||||
// Fixup level transitions
|
||||
for ( i = 0; i < maxHUDMessages; i++ )
|
||||
for( i = 0; i < maxHUDMessages; i++ )
|
||||
{
|
||||
// Assume m_parms.time contains last time
|
||||
if ( m_pMessages[i] )
|
||||
if( m_pMessages[i] )
|
||||
{
|
||||
pMessage = m_pMessages[i];
|
||||
if ( m_startTime[i] > gHUD.m_flTime )
|
||||
if( m_startTime[i] > gHUD.m_flTime )
|
||||
m_startTime[i] = gHUD.m_flTime + m_parms.time - m_startTime[i] + 0.2; // Server takes 0.2 seconds to spawn, adjust for this
|
||||
}
|
||||
}
|
||||
|
||||
for ( i = 0; i < maxHUDMessages; i++ )
|
||||
for( i = 0; i < maxHUDMessages; i++ )
|
||||
{
|
||||
if ( m_pMessages[i] )
|
||||
if( m_pMessages[i] )
|
||||
{
|
||||
pMessage = m_pMessages[i];
|
||||
|
||||
|
@ -380,14 +370,14 @@ int CHudMessage::Draw( float fTime )
|
|||
case 1:
|
||||
endTime = m_startTime[i] + pMessage->fadein + pMessage->fadeout + pMessage->holdtime;
|
||||
break;
|
||||
|
||||
|
||||
// Fade in is per character in scanning messages
|
||||
case 2:
|
||||
endTime = m_startTime[i] + (pMessage->fadein * strlen( pMessage->pMessage )) + pMessage->fadeout + pMessage->holdtime;
|
||||
endTime = m_startTime[i] + ( pMessage->fadein * strlen( pMessage->pMessage ) ) + pMessage->fadeout + pMessage->holdtime;
|
||||
break;
|
||||
}
|
||||
|
||||
if ( fTime <= endTime )
|
||||
if( fTime <= endTime )
|
||||
{
|
||||
float messageTime = fTime - m_startTime[i];
|
||||
|
||||
|
@ -410,29 +400,28 @@ int CHudMessage::Draw( float fTime )
|
|||
// Remember the time -- to fix up level transitions
|
||||
m_parms.time = gHUD.m_flTime;
|
||||
// Don't call until we get another message
|
||||
if ( !drawn )
|
||||
if( !drawn )
|
||||
m_iFlags &= ~HUD_ACTIVE;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
void CHudMessage::MessageAdd( const char *pName, float time )
|
||||
{
|
||||
int i,j;
|
||||
int i, j;
|
||||
client_textmessage_t *tempMessage;
|
||||
|
||||
for ( i = 0; i < maxHUDMessages; i++ )
|
||||
for( i = 0; i < maxHUDMessages; i++ )
|
||||
{
|
||||
if ( !m_pMessages[i] )
|
||||
if( !m_pMessages[i] )
|
||||
{
|
||||
// Trim off a leading # if it's there
|
||||
if ( pName[0] == '#' )
|
||||
tempMessage = TextMessageGet( pName+1 );
|
||||
if( pName[0] == '#' )
|
||||
tempMessage = TextMessageGet( pName + 1 );
|
||||
else
|
||||
tempMessage = TextMessageGet( pName );
|
||||
// If we couldnt find it in the titles.txt, just create it
|
||||
if ( !tempMessage )
|
||||
if( !tempMessage )
|
||||
{
|
||||
g_pCustomMessage.effect = 2;
|
||||
g_pCustomMessage.r1 = g_pCustomMessage.g1 = g_pCustomMessage.b1 = g_pCustomMessage.a1 = 100;
|
||||
|
@ -453,18 +442,18 @@ void CHudMessage::MessageAdd( const char *pName, float time )
|
|||
tempMessage = &g_pCustomMessage;
|
||||
}
|
||||
|
||||
for ( j = 0; j < maxHUDMessages; j++ )
|
||||
for( j = 0; j < maxHUDMessages; j++ )
|
||||
{
|
||||
if ( m_pMessages[j] )
|
||||
if( m_pMessages[j] )
|
||||
{
|
||||
// is this message already in the list
|
||||
if ( !strcmp( tempMessage->pMessage, m_pMessages[j]->pMessage ) )
|
||||
if( !strcmp( tempMessage->pMessage, m_pMessages[j]->pMessage ) )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// get rid of any other messages in same location (only one displays at a time)
|
||||
if ( fabs( tempMessage->y - m_pMessages[j]->y ) < 0.0001 )
|
||||
if( fabs( tempMessage->y - m_pMessages[j]->y ) < 0.0001 )
|
||||
{
|
||||
if ( fabs( tempMessage->x - m_pMessages[j]->x ) < 0.0001 )
|
||||
{
|
||||
|
@ -481,7 +470,6 @@ void CHudMessage::MessageAdd( const char *pName, float time )
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
int CHudMessage::MsgFunc_HudText( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
@ -489,48 +477,47 @@ int CHudMessage::MsgFunc_HudText( const char *pszName, int iSize, void *pbuf )
|
|||
char *pString = READ_STRING();
|
||||
|
||||
MessageAdd( pString, gHUD.m_flTime );
|
||||
|
||||
// Remember the time -- to fix up level transitions
|
||||
m_parms.time = gHUD.m_flTime;
|
||||
|
||||
// Turn on drawing
|
||||
if ( !(m_iFlags & HUD_ACTIVE) )
|
||||
if( !( m_iFlags & HUD_ACTIVE ) )
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int CHudMessage::MsgFunc_GameTitle( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
m_pGameTitle = TextMessageGet( "GAMETITLE" );
|
||||
if ( m_pGameTitle != NULL )
|
||||
if( m_pGameTitle != NULL )
|
||||
{
|
||||
m_gameTitleTime = gHUD.m_flTime;
|
||||
|
||||
// Turn on drawing
|
||||
if ( !(m_iFlags & HUD_ACTIVE) )
|
||||
if( !( m_iFlags & HUD_ACTIVE ) )
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void CHudMessage::MessageAdd(client_textmessage_t * newMessage )
|
||||
void CHudMessage::MessageAdd( client_textmessage_t * newMessage )
|
||||
{
|
||||
m_parms.time = gHUD.m_flTime;
|
||||
|
||||
// Turn on drawing
|
||||
if ( !(m_iFlags & HUD_ACTIVE) )
|
||||
if( !( m_iFlags & HUD_ACTIVE ) )
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
|
||||
for ( int i = 0; i < maxHUDMessages; i++ )
|
||||
|
||||
for( int i = 0; i < maxHUDMessages; i++ )
|
||||
{
|
||||
if ( !m_pMessages[i] )
|
||||
if( !m_pMessages[i] )
|
||||
{
|
||||
m_pMessages[i] = newMessage;
|
||||
m_startTime[i] = gHUD.m_flTime;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -34,8 +34,8 @@ int CHudOverview::Init()
|
|||
//-----------------------------------------------------------------------------
|
||||
int CHudOverview::VidInit()
|
||||
{
|
||||
m_hsprPlayer = gEngfuncs.pfnSPR_Load("sprites/ring.spr");
|
||||
m_hsprViewcone = gEngfuncs.pfnSPR_Load("sprites/camera.spr");
|
||||
m_hsprPlayer = gEngfuncs.pfnSPR_Load( "sprites/ring.spr" );
|
||||
m_hsprViewcone = gEngfuncs.pfnSPR_Load( "sprites/camera.spr" );
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
@ -45,42 +45,42 @@ int CHudOverview::VidInit()
|
|||
// Input : flTime -
|
||||
// intermission -
|
||||
//-----------------------------------------------------------------------------
|
||||
int CHudOverview::Draw(float flTime)
|
||||
int CHudOverview::Draw( float flTime )
|
||||
{
|
||||
#if 0
|
||||
// only draw in overview mode
|
||||
if (!gEngfuncs.Overview_GetOverviewState())
|
||||
if( !gEngfuncs.Overview_GetOverviewState() )
|
||||
return 1;
|
||||
|
||||
// make sure we have player info
|
||||
// gViewPort->GetAllPlayersInfo();
|
||||
//gViewPort->GetAllPlayersInfo();
|
||||
gHUD.m_Scoreboard.GetAllPlayersInfo();
|
||||
|
||||
// calculate player size on the overview
|
||||
int x1, y1, x2, y2;
|
||||
float v0[3]={0,0,0}, v1[3]={64,64,0};
|
||||
gEngfuncs.Overview_WorldToScreen(v0, &x1, &y1);
|
||||
gEngfuncs.Overview_WorldToScreen(v1, &x2, &y2);
|
||||
float scale = abs(x2 - x1);
|
||||
float v0[3] = { 0.0f }, v1[3] = { 64.0f, 64.0f };
|
||||
gEngfuncs.Overview_WorldToScreen( v0, &x1, &y1 );
|
||||
gEngfuncs.Overview_WorldToScreen( v1, &x2, &y2 );
|
||||
float scale = abs( x2 - x1 );
|
||||
|
||||
// loop through all the players and draw them on the map
|
||||
for (int i = 1; i < MAX_PLAYERS; i++)
|
||||
for( int i = 1; i < MAX_PLAYERS; i++ )
|
||||
{
|
||||
cl_entity_t *pl = gEngfuncs.GetEntityByIndex(i);
|
||||
cl_entity_t *pl = gEngfuncs.GetEntityByIndex( i );
|
||||
|
||||
if (pl && pl->player && pl->curstate.health > 0 && pl->curstate.solid != SOLID_NOT)
|
||||
if( pl && pl->player && pl->curstate.health > 0 && pl->curstate.solid != SOLID_NOT )
|
||||
{
|
||||
int x, y, z = 0;
|
||||
float v[3]={pl->origin[0], pl->origin[1], 0};
|
||||
gEngfuncs.Overview_WorldToScreen(v, &x, &y);
|
||||
float v[3] = { pl->origin[0], pl->origin[1], 0 };
|
||||
gEngfuncs.Overview_WorldToScreen( v, &x, &y );
|
||||
|
||||
// hack in some team colors
|
||||
float r, g, bc;
|
||||
if (g_PlayerExtraInfo[i].teamnumber == 1)
|
||||
if( g_PlayerExtraInfo[i].teamnumber == 1 )
|
||||
{
|
||||
r = 0.0f; g = 0.0f; bc = 1.0f;
|
||||
}
|
||||
else if (g_PlayerExtraInfo[i].teamnumber == 2)
|
||||
else if( g_PlayerExtraInfo[i].teamnumber == 2 )
|
||||
{
|
||||
r = 1.0f; g = 0.0f; bc = 0.0f;
|
||||
}
|
||||
|
@ -91,50 +91,50 @@ int CHudOverview::Draw(float flTime)
|
|||
}
|
||||
|
||||
// set the current texture
|
||||
gEngfuncs.pTriAPI->SpriteTexture((struct model_s *)gEngfuncs.GetSpritePointer(m_hsprPlayer), 0);
|
||||
gEngfuncs.pTriAPI->SpriteTexture( (struct model_s *)gEngfuncs.GetSpritePointer( m_hsprPlayer ), 0 );
|
||||
|
||||
// additive render mode
|
||||
gEngfuncs.pTriAPI->RenderMode(kRenderTransAdd);
|
||||
gEngfuncs.pTriAPI->RenderMode( kRenderTransAdd );
|
||||
|
||||
// no culling
|
||||
gEngfuncs.pTriAPI->CullFace(TRI_NONE);
|
||||
gEngfuncs.pTriAPI->CullFace( TRI_NONE );
|
||||
|
||||
// draw a square
|
||||
gEngfuncs.pTriAPI->Begin(TRI_QUADS);
|
||||
gEngfuncs.pTriAPI->Begin( TRI_QUADS );
|
||||
|
||||
// set the color to be that of the team
|
||||
gEngfuncs.pTriAPI->Color4f(r, g, bc, 1.0f);
|
||||
gEngfuncs.pTriAPI->Color4f( r, g, bc, 1.0f );
|
||||
|
||||
// calculate rotational matrix
|
||||
vec3_t a, b, angles;
|
||||
float rmatrix[3][4]; // transformation matrix
|
||||
VectorCopy(pl->angles, angles);
|
||||
VectorCopy( pl->angles, angles );
|
||||
angles[0] = 0.0f;
|
||||
angles[1] += 90.f;
|
||||
angles[1] = -angles[1];
|
||||
angles[2] = 0.0f;
|
||||
AngleMatrix(angles, rmatrix);
|
||||
AngleMatrix( angles, rmatrix );
|
||||
a[2] = 0;
|
||||
|
||||
a[0] = -scale; a[1] = -scale;
|
||||
VectorTransform(a, rmatrix , b );
|
||||
VectorTransform( a, rmatrix, b );
|
||||
gEngfuncs.pTriAPI->TexCoord2f( 0, 0 );
|
||||
gEngfuncs.pTriAPI->Vertex3f(x + b[0], y + b[1], z);
|
||||
gEngfuncs.pTriAPI->Vertex3f( x + b[0], y + b[1], z );
|
||||
|
||||
a[0]=-scale; a[1] = scale;
|
||||
VectorTransform(a, rmatrix , b );
|
||||
a[0] = -scale; a[1] = scale;
|
||||
VectorTransform( a, rmatrix, b );
|
||||
gEngfuncs.pTriAPI->TexCoord2f( 0, 1 );
|
||||
gEngfuncs.pTriAPI->Vertex3f (x + b[0], y + b[1], z);
|
||||
|
||||
a[0]=scale; a[1] = scale;
|
||||
VectorTransform(a, rmatrix , b );
|
||||
gEngfuncs.pTriAPI->TexCoord2f( 1, 1 );
|
||||
gEngfuncs.pTriAPI->Vertex3f (x + b[0], y + b[1], z);
|
||||
gEngfuncs.pTriAPI->Vertex3f( x + b[0], y + b[1], z );
|
||||
|
||||
a[0]=scale; a[1] = -scale;
|
||||
VectorTransform(a, rmatrix , b );
|
||||
a[0] = scale; a[1] = scale;
|
||||
VectorTransform( a, rmatrix, b );
|
||||
gEngfuncs.pTriAPI->TexCoord2f( 1, 1 );
|
||||
gEngfuncs.pTriAPI->Vertex3f( x + b[0], y + b[1], z );
|
||||
|
||||
a[0] = scale; a[1] = -scale;
|
||||
VectorTransform( a, rmatrix, b );
|
||||
gEngfuncs.pTriAPI->TexCoord2f( 1, 0 );
|
||||
gEngfuncs.pTriAPI->Vertex3f (x + b[0], y + b[1], z);
|
||||
gEngfuncs.pTriAPI->Vertex3f( x + b[0], y + b[1], z );
|
||||
|
||||
// finish up
|
||||
gEngfuncs.pTriAPI->End();
|
||||
|
@ -142,11 +142,10 @@ int CHudOverview::Draw(float flTime)
|
|||
|
||||
// draw the players name and health underneath
|
||||
char string[256];
|
||||
sprintf(string, "%s (%i%%)", g_PlayerInfoList[i].name, pl->curstate.health);
|
||||
DrawConsoleString(x, y + (1.1 * scale), string);
|
||||
sprintf( string, "%s (%i%%)", g_PlayerInfoList[i].name, pl->curstate.health );
|
||||
DrawConsoleString( x, y + ( 1.1 * scale ), string );
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
return 1;
|
||||
}
|
||||
|
@ -156,8 +155,7 @@ int CHudOverview::Draw(float flTime)
|
|||
//-----------------------------------------------------------------------------
|
||||
void CHudOverview::InitHUDData()
|
||||
{
|
||||
// this block would force the spectator view to be on
|
||||
// gEngfuncs.Overview_SetDrawOverview( 1 );
|
||||
// gEngfuncs.Overview_SetDrawInset( 0 );
|
||||
//this block would force the spectator view to be on
|
||||
//gEngfuncs.Overview_SetDrawOverview( 1 );
|
||||
//gEngfuncs.Overview_SetDrawInset( 0 );
|
||||
}
|
||||
|
||||
|
|
|
@ -9,7 +9,6 @@
|
|||
#define OVERVIEW_H
|
||||
#pragma once
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Handles the drawing of the top-down map and all the things on it
|
||||
//-----------------------------------------------------------------------------
|
||||
|
@ -19,13 +18,11 @@ public:
|
|||
int Init();
|
||||
int VidInit();
|
||||
|
||||
int Draw(float flTime);
|
||||
int Draw( float flTime );
|
||||
void InitHUDData( void );
|
||||
|
||||
private:
|
||||
HSPRITE m_hsprPlayer;
|
||||
HSPRITE m_hsprViewcone;
|
||||
};
|
||||
|
||||
|
||||
#endif // OVERVIEW_H
|
||||
|
|
|
@ -15,6 +15,7 @@
|
|||
//
|
||||
// parsemsg.cpp
|
||||
//
|
||||
|
||||
typedef unsigned char byte;
|
||||
#define true 1
|
||||
|
||||
|
@ -31,28 +32,27 @@ void BEGIN_READ( void *buf, int size )
|
|||
gpBuf = (byte*)buf;
|
||||
}
|
||||
|
||||
|
||||
int READ_CHAR( void )
|
||||
{
|
||||
int c;
|
||||
|
||||
if (giRead + 1 > giSize)
|
||||
int c;
|
||||
|
||||
if( giRead + 1 > giSize )
|
||||
{
|
||||
giBadRead = true;
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
c = (signed char)gpBuf[giRead];
|
||||
giRead++;
|
||||
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
int READ_BYTE( void )
|
||||
{
|
||||
int c;
|
||||
|
||||
if (giRead+1 > giSize)
|
||||
int c;
|
||||
|
||||
if( giRead + 1 > giSize )
|
||||
{
|
||||
giBadRead = true;
|
||||
return -1;
|
||||
|
@ -66,18 +66,18 @@ int READ_BYTE( void )
|
|||
|
||||
int READ_SHORT( void )
|
||||
{
|
||||
int c;
|
||||
|
||||
if (giRead+2 > giSize)
|
||||
int c;
|
||||
|
||||
if( giRead + 2 > giSize )
|
||||
{
|
||||
giBadRead = true;
|
||||
return -1;
|
||||
}
|
||||
|
||||
c = (short)( gpBuf[giRead] + ( gpBuf[giRead+1] << 8 ) );
|
||||
|
||||
|
||||
c = (short)( gpBuf[giRead] + ( gpBuf[giRead + 1] << 8 ) );
|
||||
|
||||
giRead += 2;
|
||||
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
|
@ -86,21 +86,20 @@ int READ_WORD( void )
|
|||
return READ_SHORT();
|
||||
}
|
||||
|
||||
|
||||
int READ_LONG( void )
|
||||
{
|
||||
int c;
|
||||
|
||||
if (giRead+4 > giSize)
|
||||
int c;
|
||||
|
||||
if( giRead + 4 > giSize )
|
||||
{
|
||||
giBadRead = true;
|
||||
return -1;
|
||||
}
|
||||
|
||||
c = gpBuf[giRead] + (gpBuf[giRead + 1] << 8) + (gpBuf[giRead + 2] << 16) + (gpBuf[giRead + 3] << 24);
|
||||
|
||||
|
||||
c = gpBuf[giRead] + ( gpBuf[giRead + 1] << 8 ) + ( gpBuf[giRead + 2] << 16 ) + ( gpBuf[giRead + 3] << 24 );
|
||||
|
||||
giRead += 4;
|
||||
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
|
@ -108,59 +107,58 @@ float READ_FLOAT( void )
|
|||
{
|
||||
union
|
||||
{
|
||||
byte b[4];
|
||||
float f;
|
||||
int l;
|
||||
byte b[4];
|
||||
float f;
|
||||
int l;
|
||||
} dat;
|
||||
|
||||
dat.b[0] = gpBuf[giRead];
|
||||
dat.b[1] = gpBuf[giRead+1];
|
||||
dat.b[2] = gpBuf[giRead+2];
|
||||
dat.b[3] = gpBuf[giRead+3];
|
||||
giRead += 4;
|
||||
|
||||
// dat.l = LittleLong (dat.l);
|
||||
|
||||
return dat.f;
|
||||
dat.b[0] = gpBuf[giRead];
|
||||
dat.b[1] = gpBuf[giRead + 1];
|
||||
dat.b[2] = gpBuf[giRead + 2];
|
||||
dat.b[3] = gpBuf[giRead + 3];
|
||||
giRead += 4;
|
||||
|
||||
//dat.l = LittleLong( dat.l );
|
||||
|
||||
return dat.f;
|
||||
}
|
||||
|
||||
char* READ_STRING( void )
|
||||
{
|
||||
static char string[2048];
|
||||
int l,c;
|
||||
static char string[2048];
|
||||
int l, c;
|
||||
|
||||
string[0] = 0;
|
||||
|
||||
l = 0;
|
||||
do
|
||||
{
|
||||
if ( giRead+1 > giSize )
|
||||
if( giRead+1 > giSize )
|
||||
break; // no more characters
|
||||
|
||||
c = READ_BYTE();
|
||||
if (c == -1 || c == 0)
|
||||
if( c == -1 || c == 0 )
|
||||
break;
|
||||
string[l] = c;
|
||||
l++;
|
||||
} while (l < sizeof(string)-1);
|
||||
|
||||
}while( l < sizeof(string) - 1 );
|
||||
|
||||
string[l] = 0;
|
||||
|
||||
|
||||
return string;
|
||||
}
|
||||
|
||||
float READ_COORD( void )
|
||||
{
|
||||
return (float)(READ_SHORT() * (1.0/8));
|
||||
return (float)( READ_SHORT() * ( 1.0 / 8 ) );
|
||||
}
|
||||
|
||||
float READ_ANGLE( void )
|
||||
{
|
||||
return (float)(READ_CHAR() * (360.0/256));
|
||||
return (float)( READ_CHAR() * ( 360.0 / 256 ) );
|
||||
}
|
||||
|
||||
float READ_HIRESANGLE( void )
|
||||
{
|
||||
return (float)(READ_SHORT() * (360.0/65536));
|
||||
return (float)( READ_SHORT() * ( 360.0 / 65536 ) );
|
||||
}
|
||||
|
||||
|
|
|
@ -25,7 +25,6 @@
|
|||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
|
||||
extern float *GetClientColor( int clientIndex );
|
||||
|
||||
#define MAX_LINES 5
|
||||
|
@ -36,17 +35,17 @@ extern float *GetClientColor( int clientIndex );
|
|||
#define LINE_START 10
|
||||
static float SCROLL_SPEED = 5;
|
||||
|
||||
static char g_szLineBuffer[ MAX_LINES + 1 ][ MAX_CHARS_PER_LINE ];
|
||||
static float *g_pflNameColors[ MAX_LINES + 1 ];
|
||||
static int g_iNameLengths[ MAX_LINES + 1 ];
|
||||
static char g_szLineBuffer[MAX_LINES + 1][MAX_CHARS_PER_LINE];
|
||||
static float *g_pflNameColors[MAX_LINES + 1];
|
||||
static int g_iNameLengths[MAX_LINES + 1];
|
||||
static float flScrollTime = 0; // the time at which the lines next scroll up
|
||||
|
||||
static int Y_START = 0;
|
||||
static int line_height = 0;
|
||||
|
||||
DECLARE_MESSAGE( m_SayText, SayText );
|
||||
DECLARE_MESSAGE( m_SayText, SayText )
|
||||
|
||||
int CHudSayText :: Init( void )
|
||||
int CHudSayText::Init( void )
|
||||
{
|
||||
gHUD.AddHudElem( this );
|
||||
|
||||
|
@ -54,7 +53,7 @@ int CHudSayText :: Init( void )
|
|||
|
||||
InitHUDData();
|
||||
|
||||
m_HUD_saytext = gEngfuncs.pfnRegisterVariable( "hud_saytext", "1", 0 );
|
||||
m_HUD_saytext = gEngfuncs.pfnRegisterVariable( "hud_saytext", "1", 0 );
|
||||
m_HUD_saytext_time = gEngfuncs.pfnRegisterVariable( "hud_saytext_time", "5", 0 );
|
||||
|
||||
m_iFlags |= HUD_INTERMISSION; // is always drawn during an intermission
|
||||
|
@ -62,20 +61,18 @@ int CHudSayText :: Init( void )
|
|||
return 1;
|
||||
}
|
||||
|
||||
|
||||
void CHudSayText :: InitHUDData( void )
|
||||
void CHudSayText::InitHUDData( void )
|
||||
{
|
||||
memset( g_szLineBuffer, 0, sizeof g_szLineBuffer );
|
||||
memset( g_pflNameColors, 0, sizeof g_pflNameColors );
|
||||
memset( g_iNameLengths, 0, sizeof g_iNameLengths );
|
||||
}
|
||||
|
||||
int CHudSayText :: VidInit( void )
|
||||
int CHudSayText::VidInit( void )
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int ScrollTextUp( void )
|
||||
{
|
||||
ConsolePrint( g_szLineBuffer[0] ); // move the first line into the console buffer
|
||||
|
@ -85,7 +82,7 @@ int ScrollTextUp( void )
|
|||
memmove( &g_iNameLengths[0], &g_iNameLengths[1], sizeof(g_iNameLengths) - sizeof(g_iNameLengths[0]) );
|
||||
g_szLineBuffer[MAX_LINES-1][0] = 0;
|
||||
|
||||
if ( g_szLineBuffer[0][0] == ' ' ) // also scroll up following lines
|
||||
if( g_szLineBuffer[0][0] == ' ' ) // also scroll up following lines
|
||||
{
|
||||
g_szLineBuffer[0][0] = 2;
|
||||
return 1 + ScrollTextUp();
|
||||
|
@ -94,7 +91,7 @@ int ScrollTextUp( void )
|
|||
return 1;
|
||||
}
|
||||
|
||||
int CHudSayText :: Draw( float flTime )
|
||||
int CHudSayText::Draw( float flTime )
|
||||
{
|
||||
int y = Y_START;
|
||||
|
||||
|
@ -104,32 +101,33 @@ int CHudSayText :: Draw( float flTime )
|
|||
// make sure the scrolltime is within reasonable bounds, to guard against the clock being reset
|
||||
flScrollTime = min( flScrollTime, flTime + m_HUD_saytext_time->value );
|
||||
|
||||
if ( flScrollTime <= flTime )
|
||||
if( flScrollTime <= flTime )
|
||||
{
|
||||
if ( *g_szLineBuffer[0] )
|
||||
if( *g_szLineBuffer[0] )
|
||||
{
|
||||
flScrollTime = flTime + m_HUD_saytext_time->value;
|
||||
// push the console up
|
||||
ScrollTextUp();
|
||||
}
|
||||
else
|
||||
{ // buffer is empty, just disable drawing of this section
|
||||
{
|
||||
// buffer is empty, just disable drawing of this section
|
||||
m_iFlags &= ~HUD_ACTIVE;
|
||||
}
|
||||
}
|
||||
|
||||
for ( int i = 0; i < MAX_LINES; i++ )
|
||||
for( int i = 0; i < MAX_LINES; i++ )
|
||||
{
|
||||
if ( *g_szLineBuffer[i] )
|
||||
if( *g_szLineBuffer[i] )
|
||||
{
|
||||
if ( *g_szLineBuffer[i] == 2 && g_pflNameColors[i] )
|
||||
if( *g_szLineBuffer[i] == 2 && g_pflNameColors[i] )
|
||||
{
|
||||
// it's a saytext string
|
||||
static char buf[MAX_PLAYER_NAME_LENGTH+32];
|
||||
static char buf[MAX_PLAYER_NAME_LENGTH + 32];
|
||||
|
||||
// draw the first x characters in the player color
|
||||
strncpy( buf, g_szLineBuffer[i], min(g_iNameLengths[i], MAX_PLAYER_NAME_LENGTH+32) );
|
||||
buf[ min(g_iNameLengths[i], MAX_PLAYER_NAME_LENGTH+31) ] = 0;
|
||||
strncpy( buf, g_szLineBuffer[i], min(g_iNameLengths[i], MAX_PLAYER_NAME_LENGTH + 32 ) );
|
||||
buf[min( g_iNameLengths[i], MAX_PLAYER_NAME_LENGTH + 31 )] = 0;
|
||||
DrawSetTextColor( g_pflNameColors[i][0], g_pflNameColors[i][1], g_pflNameColors[i][2] );
|
||||
int x = DrawConsoleString( LINE_START, y, buf );
|
||||
|
||||
|
@ -146,32 +144,31 @@ int CHudSayText :: Draw( float flTime )
|
|||
y += line_height;
|
||||
}
|
||||
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudSayText :: MsgFunc_SayText( const char *pszName, int iSize, void *pbuf )
|
||||
int CHudSayText::MsgFunc_SayText( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
int client_index = READ_BYTE(); // the client who spoke the message
|
||||
SayTextPrint( READ_STRING(), iSize - 1, client_index );
|
||||
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void CHudSayText :: SayTextPrint( const char *pszBuf, int iBufSize, int clientIndex )
|
||||
void CHudSayText::SayTextPrint( const char *pszBuf, int iBufSize, int clientIndex )
|
||||
{
|
||||
int i;
|
||||
ConsolePrint( pszBuf );
|
||||
|
||||
// find an empty string slot
|
||||
for ( i = 0; i < MAX_LINES; i++ )
|
||||
for( i = 0; i < MAX_LINES; i++ )
|
||||
{
|
||||
if ( ! *g_szLineBuffer[i] )
|
||||
if( !( *g_szLineBuffer[i] ) )
|
||||
break;
|
||||
}
|
||||
if ( i == MAX_LINES )
|
||||
if( i == MAX_LINES )
|
||||
{
|
||||
// force scroll buffer up
|
||||
ScrollTextUp();
|
||||
|
@ -182,30 +179,30 @@ void CHudSayText :: SayTextPrint( const char *pszBuf, int iBufSize, int clientIn
|
|||
g_pflNameColors[i] = NULL;
|
||||
|
||||
// if it's a say message, search for the players name in the string
|
||||
if ( *pszBuf == 2 && clientIndex > 0 )
|
||||
if( *pszBuf == 2 && clientIndex > 0 )
|
||||
{
|
||||
GetPlayerInfo( clientIndex, &g_PlayerInfoList[clientIndex] );
|
||||
const char *pName = g_PlayerInfoList[clientIndex].name;
|
||||
|
||||
if ( pName )
|
||||
if( pName )
|
||||
{
|
||||
const char *nameInString = strstr( pszBuf, pName );
|
||||
|
||||
if ( nameInString )
|
||||
if( nameInString )
|
||||
{
|
||||
g_iNameLengths[i] = strlen( pName ) + (nameInString - pszBuf);
|
||||
g_iNameLengths[i] = strlen( pName ) + ( nameInString - pszBuf );
|
||||
g_pflNameColors[i] = GetClientColor( clientIndex );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
strncpy( g_szLineBuffer[i], pszBuf, max(iBufSize -1, MAX_CHARS_PER_LINE-1) );
|
||||
strncpy( g_szLineBuffer[i], pszBuf, max( iBufSize - 1, MAX_CHARS_PER_LINE - 1 ) );
|
||||
|
||||
// make sure the text fits in one line
|
||||
EnsureTextFitsInOneLineAndWrapIfHaveTo( i );
|
||||
|
||||
// Set scroll time
|
||||
if ( i == 0 )
|
||||
if( i == 0 )
|
||||
{
|
||||
flScrollTime = gHUD.m_flTime + m_HUD_saytext_time->value;
|
||||
}
|
||||
|
@ -213,56 +210,57 @@ void CHudSayText :: SayTextPrint( const char *pszBuf, int iBufSize, int clientIn
|
|||
m_iFlags |= HUD_ACTIVE;
|
||||
PlaySound( "misc/talk.wav", 1 );
|
||||
|
||||
if ( ScreenHeight >= 480 )
|
||||
if( ScreenHeight >= 480 )
|
||||
Y_START = ScreenHeight - 60;
|
||||
else
|
||||
Y_START = ScreenHeight - 45;
|
||||
Y_START -= (line_height * (MAX_LINES+1));
|
||||
|
||||
Y_START -= ( line_height * ( MAX_LINES + 1 ) );
|
||||
}
|
||||
|
||||
void CHudSayText :: EnsureTextFitsInOneLineAndWrapIfHaveTo( int line )
|
||||
void CHudSayText::EnsureTextFitsInOneLineAndWrapIfHaveTo( int line )
|
||||
{
|
||||
int line_width = 0;
|
||||
GetConsoleStringSize( g_szLineBuffer[line], &line_width, &line_height );
|
||||
|
||||
if ( (line_width + LINE_START) > MAX_LINE_WIDTH )
|
||||
{ // string is too long to fit on line
|
||||
if( ( line_width + LINE_START ) > MAX_LINE_WIDTH )
|
||||
{
|
||||
// string is too long to fit on line
|
||||
// scan the string until we find what word is too long, and wrap the end of the sentence after the word
|
||||
int length = LINE_START;
|
||||
int tmp_len = 0;
|
||||
char *last_break = NULL;
|
||||
for ( char *x = g_szLineBuffer[line]; *x != 0; x++ )
|
||||
for( char *x = g_szLineBuffer[line]; *x != 0; x++ )
|
||||
{
|
||||
// check for a color change, if so skip past it
|
||||
if ( x[0] == '/' && x[1] == '(' )
|
||||
if( x[0] == '/' && x[1] == '(' )
|
||||
{
|
||||
x += 2;
|
||||
// skip forward until past mode specifier
|
||||
while ( *x != 0 && *x != ')' )
|
||||
x++;
|
||||
|
||||
if ( *x != 0 )
|
||||
if( *x != 0 )
|
||||
x++;
|
||||
|
||||
if ( *x == 0 )
|
||||
if( *x == 0 )
|
||||
break;
|
||||
}
|
||||
|
||||
char buf[2];
|
||||
buf[1] = 0;
|
||||
|
||||
if ( *x == ' ' && x != g_szLineBuffer[line] ) // store each line break, except for the very first character
|
||||
if( *x == ' ' && x != g_szLineBuffer[line] ) // store each line break, except for the very first character
|
||||
last_break = x;
|
||||
|
||||
buf[0] = *x; // get the length of the current character
|
||||
GetConsoleStringSize( buf, &tmp_len, &line_height );
|
||||
length += tmp_len;
|
||||
|
||||
if ( length > MAX_LINE_WIDTH )
|
||||
{ // needs to be broken up
|
||||
if ( !last_break )
|
||||
last_break = x-1;
|
||||
if( length > MAX_LINE_WIDTH )
|
||||
{
|
||||
// needs to be broken up
|
||||
if( !last_break )
|
||||
last_break = x - 1;
|
||||
|
||||
x = last_break;
|
||||
|
||||
|
@ -270,33 +268,33 @@ void CHudSayText :: EnsureTextFitsInOneLineAndWrapIfHaveTo( int line )
|
|||
int j;
|
||||
do
|
||||
{
|
||||
for ( j = 0; j < MAX_LINES; j++ )
|
||||
for( j = 0; j < MAX_LINES; j++ )
|
||||
{
|
||||
if ( ! *g_szLineBuffer[j] )
|
||||
if( !( *g_szLineBuffer[j] ) )
|
||||
break;
|
||||
}
|
||||
if ( j == MAX_LINES )
|
||||
if( j == MAX_LINES )
|
||||
{
|
||||
// need to make more room to display text, scroll stuff up then fix the pointers
|
||||
int linesmoved = ScrollTextUp();
|
||||
line -= linesmoved;
|
||||
last_break = last_break - (sizeof(g_szLineBuffer[0]) * linesmoved);
|
||||
last_break = last_break - ( sizeof(g_szLineBuffer[0]) * linesmoved );
|
||||
}
|
||||
}
|
||||
while ( j == MAX_LINES );
|
||||
while( j == MAX_LINES );
|
||||
|
||||
// copy remaining string into next buffer, making sure it starts with a space character
|
||||
if ( (char)*last_break == (char)' ' )
|
||||
if( (char)*last_break == (char)' ' )
|
||||
{
|
||||
int linelen = strlen(g_szLineBuffer[j]);
|
||||
int remaininglen = strlen(last_break);
|
||||
int linelen = strlen( g_szLineBuffer[j] );
|
||||
int remaininglen = strlen( last_break );
|
||||
|
||||
if ( (linelen - remaininglen) <= MAX_CHARS_PER_LINE )
|
||||
if( ( linelen - remaininglen ) <= MAX_CHARS_PER_LINE )
|
||||
strcat( g_szLineBuffer[j], last_break );
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( (strlen(g_szLineBuffer[j]) - strlen(last_break) - 2) < MAX_CHARS_PER_LINE )
|
||||
if ( ( strlen( g_szLineBuffer[j] ) - strlen( last_break ) - 2 ) < MAX_CHARS_PER_LINE )
|
||||
{
|
||||
strcat( g_szLineBuffer[j], " " );
|
||||
strcat( g_szLineBuffer[j], last_break );
|
||||
|
|
|
@ -27,9 +27,9 @@
|
|||
#include <stdio.h>
|
||||
|
||||
cvar_t *cl_showpacketloss;
|
||||
hud_player_info_t g_PlayerInfoList[MAX_PLAYERS+1]; // player info from the engine
|
||||
extra_player_info_t g_PlayerExtraInfo[MAX_PLAYERS+1]; // additional player info sent directly to the client dll
|
||||
team_info_t g_TeamInfo[MAX_TEAMS+1];
|
||||
hud_player_info_t g_PlayerInfoList[MAX_PLAYERS + 1]; // player info from the engine
|
||||
extra_player_info_t g_PlayerExtraInfo[MAX_PLAYERS + 1]; // additional player info sent directly to the client dll
|
||||
team_info_t g_TeamInfo[MAX_TEAMS + 1];
|
||||
int g_iUser1;
|
||||
int g_iUser2;
|
||||
int g_iUser3;
|
||||
|
@ -38,14 +38,14 @@ int g_iPlayerClass;
|
|||
|
||||
//#include "vgui_TeamFortressViewport.h"
|
||||
|
||||
DECLARE_COMMAND( m_Scoreboard, ShowScores );
|
||||
DECLARE_COMMAND( m_Scoreboard, HideScores );
|
||||
DECLARE_COMMAND( m_Scoreboard, ShowScores )
|
||||
DECLARE_COMMAND( m_Scoreboard, HideScores )
|
||||
|
||||
DECLARE_MESSAGE( m_Scoreboard, ScoreInfo );
|
||||
DECLARE_MESSAGE( m_Scoreboard, TeamInfo );
|
||||
DECLARE_MESSAGE( m_Scoreboard, TeamScore );
|
||||
DECLARE_MESSAGE( m_Scoreboard, ScoreInfo )
|
||||
DECLARE_MESSAGE( m_Scoreboard, TeamInfo )
|
||||
DECLARE_MESSAGE( m_Scoreboard, TeamScore )
|
||||
|
||||
int CHudScoreboard :: Init( void )
|
||||
int CHudScoreboard::Init( void )
|
||||
{
|
||||
gHUD.AddHudElem( this );
|
||||
|
||||
|
@ -64,14 +64,13 @@ int CHudScoreboard :: Init( void )
|
|||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int CHudScoreboard :: VidInit( void )
|
||||
int CHudScoreboard::VidInit( void )
|
||||
{
|
||||
// Load sprites here
|
||||
return 1;
|
||||
}
|
||||
|
||||
void CHudScoreboard :: InitHUDData( void )
|
||||
void CHudScoreboard::InitHUDData( void )
|
||||
{
|
||||
memset( g_PlayerExtraInfo, 0, sizeof g_PlayerExtraInfo );
|
||||
m_iLastKilledBy = 0;
|
||||
|
@ -104,20 +103,19 @@ We have a minimum width of 1-320 - we could have the field widths scale with it?
|
|||
#define PL_RANGE_MAX 375
|
||||
|
||||
int SCOREBOARD_WIDTH = 320;
|
||||
|
||||
|
||||
// Y positions
|
||||
#define ROW_GAP 13
|
||||
#define ROW_RANGE_MIN 15
|
||||
#define ROW_RANGE_MAX ( ScreenHeight - 50 )
|
||||
|
||||
int CHudScoreboard :: Draw( float fTime )
|
||||
int CHudScoreboard::Draw( float fTime )
|
||||
{
|
||||
int i, j, can_show_packetloss = 0;
|
||||
int FAR_RIGHT;
|
||||
gHUD.m_iNoConsolePrint &= ~( 1 << 0 );
|
||||
|
||||
if ( !m_iShowscoresHeld && gHUD.m_Health.m_iHealth > 0 && !gHUD.m_iIntermission )
|
||||
if( !m_iShowscoresHeld && gHUD.m_Health.m_iHealth > 0 && !gHUD.m_iIntermission )
|
||||
return 1;
|
||||
|
||||
gHUD.m_iNoConsolePrint |= 1 << 0;
|
||||
|
@ -125,7 +123,7 @@ int CHudScoreboard :: Draw( float fTime )
|
|||
GetAllPlayersInfo();
|
||||
|
||||
// Packetloss removed on Kelly 'shipping nazi' Bailey's orders
|
||||
if ( cl_showpacketloss && cl_showpacketloss->value && ( ScreenWidth >= 400 ) )
|
||||
if( cl_showpacketloss && cl_showpacketloss->value && ( ScreenWidth >= 400 ) )
|
||||
{
|
||||
can_show_packetloss = 1;
|
||||
SCOREBOARD_WIDTH = 400;
|
||||
|
@ -138,16 +136,16 @@ int CHudScoreboard :: Draw( float fTime )
|
|||
// just sort the list on the fly
|
||||
// list is sorted first by frags, then by deaths
|
||||
float list_slot = 0;
|
||||
int xpos_rel = (ScreenWidth - SCOREBOARD_WIDTH) / 2;
|
||||
int xpos_rel = ( ScreenWidth - SCOREBOARD_WIDTH ) / 2;
|
||||
|
||||
// print the heading line
|
||||
int ypos = ROW_RANGE_MIN + (list_slot * ROW_GAP);
|
||||
int xpos = NAME_RANGE_MIN + xpos_rel;
|
||||
int ypos = ROW_RANGE_MIN + ( list_slot * ROW_GAP );
|
||||
int xpos = NAME_RANGE_MIN + xpos_rel;
|
||||
|
||||
FAR_RIGHT = can_show_packetloss ? PL_RANGE_MAX : PING_RANGE_MAX;
|
||||
FAR_RIGHT += 5;
|
||||
gHUD.DrawDarkRectangle(xpos - 5, ypos - 5, FAR_RIGHT, ROW_RANGE_MAX);
|
||||
if ( !gHUD.m_Teamplay )
|
||||
gHUD.DrawDarkRectangle( xpos - 5, ypos - 5, FAR_RIGHT, ROW_RANGE_MAX );
|
||||
if( !gHUD.m_Teamplay )
|
||||
gHUD.DrawHudString( xpos, ypos, NAME_RANGE_MAX + xpos_rel, "Player", 255, 140, 0 );
|
||||
else
|
||||
gHUD.DrawHudString( xpos, ypos, NAME_RANGE_MAX + xpos_rel, "Teams", 255, 140, 0 );
|
||||
|
@ -157,20 +155,19 @@ int CHudScoreboard :: Draw( float fTime )
|
|||
gHUD.DrawHudString( DEATHS_RANGE_MIN + xpos_rel + 5, ypos, ScreenWidth, "deaths", 255, 140, 0 );
|
||||
gHUD.DrawHudString( PING_RANGE_MAX + xpos_rel - 35, ypos, ScreenWidth, "latency", 255, 140, 0 );
|
||||
|
||||
if ( can_show_packetloss )
|
||||
if( can_show_packetloss )
|
||||
{
|
||||
gHUD.DrawHudString( PL_RANGE_MAX + xpos_rel - 35, ypos, ScreenWidth, "pkt loss", 255, 140, 0 );
|
||||
}
|
||||
|
||||
|
||||
list_slot += 1.2;
|
||||
ypos = ROW_RANGE_MIN + (list_slot * ROW_GAP);
|
||||
ypos = ROW_RANGE_MIN + ( list_slot * ROW_GAP );
|
||||
xpos = NAME_RANGE_MIN + xpos_rel;
|
||||
FillRGBA( xpos - 4, ypos, FAR_RIGHT -2, 1, 255, 140, 0, 255); // draw the seperator line
|
||||
|
||||
FillRGBA( xpos - 4, ypos, FAR_RIGHT -2, 1, 255, 140, 0, 255 ); // draw the seperator line
|
||||
|
||||
list_slot += 0.8;
|
||||
|
||||
if ( !gHUD.m_Teamplay )
|
||||
if( !gHUD.m_Teamplay )
|
||||
{
|
||||
// it's not teamplay, so just draw a simple player list
|
||||
DrawPlayers( xpos_rel, list_slot );
|
||||
|
@ -178,32 +175,32 @@ int CHudScoreboard :: Draw( float fTime )
|
|||
}
|
||||
|
||||
// clear out team scores
|
||||
for ( i = 1; i <= m_iNumTeams; i++ )
|
||||
for( i = 1; i <= m_iNumTeams; i++ )
|
||||
{
|
||||
if ( !g_TeamInfo[i].scores_overriden )
|
||||
if( !g_TeamInfo[i].scores_overriden )
|
||||
g_TeamInfo[i].frags = g_TeamInfo[i].deaths = 0;
|
||||
g_TeamInfo[i].ping = g_TeamInfo[i].packetloss = 0;
|
||||
}
|
||||
|
||||
// recalc the team scores, then draw them
|
||||
for ( i = 1; i < MAX_PLAYERS; i++ )
|
||||
for( i = 1; i < MAX_PLAYERS; i++ )
|
||||
{
|
||||
//if ( g_PlayerInfoList[i].name == NULL )
|
||||
//if( g_PlayerInfoList[i].name == NULL )
|
||||
// continue; // empty player slot, skip
|
||||
|
||||
if ( g_PlayerExtraInfo[i].teamname[0] == 0 )
|
||||
if( g_PlayerExtraInfo[i].teamname[0] == 0 )
|
||||
continue; // skip over players who are not in a team
|
||||
|
||||
// find what team this player is in
|
||||
for ( j = 1; j <= m_iNumTeams; j++ )
|
||||
for( j = 1; j <= m_iNumTeams; j++ )
|
||||
{
|
||||
if ( !stricmp( g_PlayerExtraInfo[i].teamname, g_TeamInfo[j].name ) )
|
||||
if( !stricmp( g_PlayerExtraInfo[i].teamname, g_TeamInfo[j].name ) )
|
||||
break;
|
||||
}
|
||||
if ( j > m_iNumTeams ) // player is not in a team, skip to the next guy
|
||||
if( j > m_iNumTeams ) // player is not in a team, skip to the next guy
|
||||
continue;
|
||||
|
||||
if ( !g_TeamInfo[j].scores_overriden )
|
||||
if( !g_TeamInfo[j].scores_overriden )
|
||||
{
|
||||
g_TeamInfo[j].frags += g_PlayerExtraInfo[i].frags;
|
||||
g_TeamInfo[j].deaths += g_PlayerExtraInfo[i].deaths;
|
||||
|
@ -212,18 +209,18 @@ int CHudScoreboard :: Draw( float fTime )
|
|||
g_TeamInfo[j].ping += g_PlayerInfoList[i].ping;
|
||||
g_TeamInfo[j].packetloss += g_PlayerInfoList[i].packetloss;
|
||||
|
||||
if ( g_PlayerInfoList[i].thisplayer )
|
||||
if( g_PlayerInfoList[i].thisplayer )
|
||||
g_TeamInfo[j].ownteam = TRUE;
|
||||
else
|
||||
g_TeamInfo[j].ownteam = FALSE;
|
||||
}
|
||||
|
||||
// find team ping/packetloss averages
|
||||
for ( i = 1; i <= m_iNumTeams; i++ )
|
||||
for( i = 1; i <= m_iNumTeams; i++ )
|
||||
{
|
||||
g_TeamInfo[i].already_drawn = FALSE;
|
||||
|
||||
if ( g_TeamInfo[i].players > 0 )
|
||||
if( g_TeamInfo[i].players > 0 )
|
||||
{
|
||||
g_TeamInfo[i].ping /= g_TeamInfo[i].players; // use the average ping of all the players in the team as the teams ping
|
||||
g_TeamInfo[i].packetloss /= g_TeamInfo[i].players; // use the average ping of all the players in the team as the teams ping
|
||||
|
@ -231,19 +228,19 @@ int CHudScoreboard :: Draw( float fTime )
|
|||
}
|
||||
|
||||
// Draw the teams
|
||||
while ( 1 )
|
||||
while( 1 )
|
||||
{
|
||||
int highest_frags = -99999; int lowest_deaths = 99999;
|
||||
int best_team = 0;
|
||||
|
||||
for ( i = 1; i <= m_iNumTeams; i++ )
|
||||
for( i = 1; i <= m_iNumTeams; i++ )
|
||||
{
|
||||
if ( g_TeamInfo[i].players < 0 )
|
||||
if( g_TeamInfo[i].players < 0 )
|
||||
continue;
|
||||
|
||||
if ( !g_TeamInfo[i].already_drawn && g_TeamInfo[i].frags >= highest_frags )
|
||||
if( !g_TeamInfo[i].already_drawn && g_TeamInfo[i].frags >= highest_frags )
|
||||
{
|
||||
if ( g_TeamInfo[i].frags > highest_frags || g_TeamInfo[i].deaths < lowest_deaths )
|
||||
if( g_TeamInfo[i].frags > highest_frags || g_TeamInfo[i].deaths < lowest_deaths )
|
||||
{
|
||||
best_team = i;
|
||||
lowest_deaths = g_TeamInfo[i].deaths;
|
||||
|
@ -253,22 +250,22 @@ int CHudScoreboard :: Draw( float fTime )
|
|||
}
|
||||
|
||||
// draw the best team on the scoreboard
|
||||
if ( !best_team )
|
||||
if( !best_team )
|
||||
break;
|
||||
|
||||
// draw out the best team
|
||||
team_info_t *team_info = &g_TeamInfo[best_team];
|
||||
|
||||
ypos = ROW_RANGE_MIN + (list_slot * ROW_GAP);
|
||||
ypos = ROW_RANGE_MIN + ( list_slot * ROW_GAP );
|
||||
|
||||
// check we haven't drawn too far down
|
||||
if ( ypos > ROW_RANGE_MAX ) // don't draw to close to the lower border
|
||||
if( ypos > ROW_RANGE_MAX ) // don't draw to close to the lower border
|
||||
break;
|
||||
|
||||
xpos = NAME_RANGE_MIN + xpos_rel;
|
||||
int r = 255, g = 225, b = 55; // draw the stuff kinda yellowish
|
||||
|
||||
if ( team_info->ownteam ) // if it is their team, draw the background different color
|
||||
|
||||
if( team_info->ownteam ) // if it is their team, draw the background different color
|
||||
{
|
||||
// overlay the background in blue, then draw the score text over it
|
||||
FillRGBA( NAME_RANGE_MIN + xpos_rel - 5, ypos, FAR_RIGHT, ROW_GAP, 0, 0, 255, 70 );
|
||||
|
@ -293,15 +290,15 @@ int CHudScoreboard :: Draw( float fTime )
|
|||
// draw ping & packetloss
|
||||
static char buf[64];
|
||||
sprintf( buf, "%d", team_info->ping );
|
||||
xpos = ((PING_RANGE_MAX - PING_RANGE_MIN) / 2) + PING_RANGE_MIN + xpos_rel + 25;
|
||||
xpos = ( ( PING_RANGE_MAX - PING_RANGE_MIN ) / 2) + PING_RANGE_MIN + xpos_rel + 25;
|
||||
UnpackRGB( r, g, b, RGB_YELLOWISH );
|
||||
gHUD.DrawHudStringReverse( xpos, ypos, xpos - 50, buf, r, g, b );
|
||||
|
||||
// Packetloss removed on Kelly 'shipping nazi' Bailey's orders
|
||||
if ( can_show_packetloss )
|
||||
// Packetloss removed on Kelly 'shipping nazi' Bailey's orders
|
||||
if( can_show_packetloss )
|
||||
{
|
||||
xpos = ((PL_RANGE_MAX - PL_RANGE_MIN) / 2) + PL_RANGE_MIN + xpos_rel + 25;
|
||||
|
||||
xpos = ( ( PL_RANGE_MAX - PL_RANGE_MIN ) / 2) + PL_RANGE_MIN + xpos_rel + 25;
|
||||
|
||||
sprintf( buf, " %d", team_info->packetloss );
|
||||
gHUD.DrawHudString( xpos, ypos, xpos+50, buf, r, g, b );
|
||||
}
|
||||
|
@ -319,15 +316,17 @@ int CHudScoreboard :: Draw( float fTime )
|
|||
|
||||
return 1;
|
||||
}
|
||||
|
||||
extern float *GetClientColor( int client );
|
||||
|
||||
// returns the ypos where it finishes drawing
|
||||
int CHudScoreboard :: DrawPlayers( int xpos_rel, float list_slot, int nameoffset, char *team )
|
||||
int CHudScoreboard::DrawPlayers( int xpos_rel, float list_slot, int nameoffset, char *team )
|
||||
{
|
||||
int can_show_packetloss = 0;
|
||||
int FAR_RIGHT;
|
||||
|
||||
// Packetloss removed on Kelly 'shipping nazi' Bailey's orders
|
||||
if ( cl_showpacketloss && cl_showpacketloss->value && ( ScreenWidth >= 400 ) )
|
||||
if( cl_showpacketloss && cl_showpacketloss->value && ( ScreenWidth >= 400 ) )
|
||||
{
|
||||
can_show_packetloss = 1;
|
||||
SCOREBOARD_WIDTH = 400;
|
||||
|
@ -341,20 +340,21 @@ int CHudScoreboard :: DrawPlayers( int xpos_rel, float list_slot, int nameoffset
|
|||
FAR_RIGHT += 5;
|
||||
|
||||
// draw the players, in order, and restricted to team if set
|
||||
while ( 1 )
|
||||
while( 1 )
|
||||
{
|
||||
// Find the top ranking player
|
||||
int highest_frags = -99999; int lowest_deaths = 99999;
|
||||
int highest_frags = -99999;
|
||||
int lowest_deaths = 99999;
|
||||
int best_player = 0;
|
||||
|
||||
for ( int i = 1; i < MAX_PLAYERS; i++ )
|
||||
for( int i = 1; i < MAX_PLAYERS; i++ )
|
||||
{
|
||||
if ( g_PlayerInfoList[i].name && g_PlayerExtraInfo[i].frags >= highest_frags )
|
||||
if( g_PlayerInfoList[i].name && g_PlayerExtraInfo[i].frags >= highest_frags )
|
||||
{
|
||||
if ( !(team && stricmp(g_PlayerExtraInfo[i].teamname, team)) ) // make sure it is the specified team
|
||||
if( !( team && stricmp( g_PlayerExtraInfo[i].teamname, team ) ) ) // make sure it is the specified team
|
||||
{
|
||||
extra_player_info_t *pl_info = &g_PlayerExtraInfo[i];
|
||||
if ( pl_info->frags > highest_frags || pl_info->deaths < lowest_deaths )
|
||||
if( pl_info->frags > highest_frags || pl_info->deaths < lowest_deaths )
|
||||
{
|
||||
best_player = i;
|
||||
lowest_deaths = pl_info->deaths;
|
||||
|
@ -364,34 +364,36 @@ int CHudScoreboard :: DrawPlayers( int xpos_rel, float list_slot, int nameoffset
|
|||
}
|
||||
}
|
||||
|
||||
if ( !best_player )
|
||||
if( !best_player )
|
||||
break;
|
||||
|
||||
// draw out the best player
|
||||
hud_player_info_t *pl_info = &g_PlayerInfoList[best_player];
|
||||
|
||||
int ypos = ROW_RANGE_MIN + (list_slot * ROW_GAP);
|
||||
int ypos = ROW_RANGE_MIN + ( list_slot * ROW_GAP );
|
||||
|
||||
// check we haven't drawn too far down
|
||||
if ( ypos > ROW_RANGE_MAX ) // don't draw to close to the lower border
|
||||
if( ypos > ROW_RANGE_MAX ) // don't draw to close to the lower border
|
||||
break;
|
||||
|
||||
int xpos = NAME_RANGE_MIN + xpos_rel;
|
||||
int r = 255, g = 255, b = 255;
|
||||
float *colors = GetClientColor( best_player );
|
||||
r *= colors[0], g *= colors[1], b *= colors[2];
|
||||
if ( best_player == m_iLastKilledBy && m_fLastKillTime && m_fLastKillTime > gHUD.m_flTime )
|
||||
if( best_player == m_iLastKilledBy && m_fLastKillTime && m_fLastKillTime > gHUD.m_flTime )
|
||||
{
|
||||
if ( pl_info->thisplayer )
|
||||
{ // green is the suicide color? i wish this could do grey...
|
||||
if( pl_info->thisplayer )
|
||||
{
|
||||
// green is the suicide color? i wish this could do grey...
|
||||
FillRGBA( NAME_RANGE_MIN + xpos_rel - 5, ypos, FAR_RIGHT, ROW_GAP, 80, 155, 0, 70 );
|
||||
}
|
||||
else
|
||||
{ // Highlight the killers name - overlay the background in red, then draw the score text over it
|
||||
FillRGBA( NAME_RANGE_MIN + xpos_rel - 5, ypos, FAR_RIGHT, ROW_GAP, 255, 0, 0, ((float)15 * (float)(m_fLastKillTime - gHUD.m_flTime)) );
|
||||
{
|
||||
// Highlight the killers name - overlay the background in red, then draw the score text over it
|
||||
FillRGBA( NAME_RANGE_MIN + xpos_rel - 5, ypos, FAR_RIGHT, ROW_GAP, 255, 0, 0, ( (float)15 * (float)( m_fLastKillTime - gHUD.m_flTime ) ) );
|
||||
}
|
||||
}
|
||||
else if ( pl_info->thisplayer ) // if it is their name, draw it a different color
|
||||
else if( pl_info->thisplayer ) // if it is their name, draw it a different color
|
||||
{
|
||||
// overlay the background in blue, then draw the score text over it
|
||||
FillRGBA( NAME_RANGE_MIN + xpos_rel - 5, ypos, FAR_RIGHT, ROW_GAP, 0, 0, 255, 70 );
|
||||
|
@ -415,13 +417,13 @@ int CHudScoreboard :: DrawPlayers( int xpos_rel, float list_slot, int nameoffset
|
|||
// draw ping & packetloss
|
||||
static char buf[64];
|
||||
sprintf( buf, "%d", g_PlayerInfoList[best_player].ping );
|
||||
xpos = ((PING_RANGE_MAX - PING_RANGE_MIN) / 2) + PING_RANGE_MIN + xpos_rel + 25;
|
||||
xpos = ( ( PING_RANGE_MAX - PING_RANGE_MIN ) / 2 ) + PING_RANGE_MIN + xpos_rel + 25;
|
||||
gHUD.DrawHudStringReverse( xpos, ypos, xpos - 50, buf, r, g, b );
|
||||
|
||||
// Packetloss removed on Kelly 'shipping nazi' Bailey's orders
|
||||
if ( can_show_packetloss )
|
||||
if( can_show_packetloss )
|
||||
{
|
||||
if ( g_PlayerInfoList[best_player].packetloss >= 63 )
|
||||
if( g_PlayerInfoList[best_player].packetloss >= 63 )
|
||||
{
|
||||
UnpackRGB( r, g, b, RGB_REDISH );
|
||||
sprintf( buf, " !!!!" );
|
||||
|
@ -431,11 +433,11 @@ int CHudScoreboard :: DrawPlayers( int xpos_rel, float list_slot, int nameoffset
|
|||
sprintf( buf, " %d", g_PlayerInfoList[best_player].packetloss );
|
||||
}
|
||||
|
||||
xpos = ((PL_RANGE_MAX - PL_RANGE_MIN) / 2) + PL_RANGE_MIN + xpos_rel + 25;
|
||||
|
||||
xpos = ( ( PL_RANGE_MAX - PL_RANGE_MIN ) / 2 ) + PL_RANGE_MIN + xpos_rel + 25;
|
||||
|
||||
gHUD.DrawHudString( xpos, ypos, xpos+50, buf, r, g, b );
|
||||
}
|
||||
|
||||
|
||||
pl_info->name = NULL; // set the name to be NULL, so this client won't get drawn again
|
||||
list_slot++;
|
||||
}
|
||||
|
@ -443,19 +445,18 @@ int CHudScoreboard :: DrawPlayers( int xpos_rel, float list_slot, int nameoffset
|
|||
return list_slot;
|
||||
}
|
||||
|
||||
|
||||
void CHudScoreboard :: GetAllPlayersInfo( void )
|
||||
void CHudScoreboard::GetAllPlayersInfo( void )
|
||||
{
|
||||
for ( int i = 1; i < MAX_PLAYERS; i++ )
|
||||
for( int i = 1; i < MAX_PLAYERS; i++ )
|
||||
{
|
||||
GetPlayerInfo( i, &g_PlayerInfoList[i] );
|
||||
|
||||
if ( g_PlayerInfoList[i].thisplayer )
|
||||
if( g_PlayerInfoList[i].thisplayer )
|
||||
m_iPlayerNum = i; // !!!HACK: this should be initialized elsewhere... maybe gotten from the engine
|
||||
}
|
||||
}
|
||||
|
||||
int CHudScoreboard :: MsgFunc_ScoreInfo( const char *pszName, int iSize, void *pbuf )
|
||||
int CHudScoreboard::MsgFunc_ScoreInfo( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
|
||||
|
@ -466,7 +467,7 @@ int CHudScoreboard :: MsgFunc_ScoreInfo( const char *pszName, int iSize, void *p
|
|||
short playerclass = READ_SHORT();
|
||||
short teamnumber = READ_SHORT();
|
||||
|
||||
if ( cl > 0 && cl <= MAX_PLAYERS )
|
||||
if( cl > 0 && cl <= MAX_PLAYERS )
|
||||
{
|
||||
g_PlayerExtraInfo[cl].frags = frags;
|
||||
g_PlayerExtraInfo[cl].deaths = deaths;
|
||||
|
@ -483,21 +484,21 @@ int CHudScoreboard :: MsgFunc_ScoreInfo( const char *pszName, int iSize, void *p
|
|||
// accepts two values:
|
||||
// byte: client number
|
||||
// string: client team name
|
||||
int CHudScoreboard :: MsgFunc_TeamInfo( const char *pszName, int iSize, void *pbuf )
|
||||
int CHudScoreboard::MsgFunc_TeamInfo( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
int i, j;
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
short cl = READ_BYTE();
|
||||
|
||||
if ( cl > 0 && cl <= MAX_PLAYERS )
|
||||
{ // set the players team
|
||||
|
||||
if( cl > 0 && cl <= MAX_PLAYERS )
|
||||
{
|
||||
// set the players team
|
||||
strncpy( g_PlayerExtraInfo[cl].teamname, READ_STRING(), MAX_TEAM_NAME );
|
||||
}
|
||||
|
||||
// rebuild the list of teams
|
||||
|
||||
// clear out player counts from teams
|
||||
for ( i = 1; i <= m_iNumTeams; i++ )
|
||||
for( i = 1; i <= m_iNumTeams; i++ )
|
||||
{
|
||||
g_TeamInfo[i].players = 0;
|
||||
}
|
||||
|
@ -505,30 +506,31 @@ int CHudScoreboard :: MsgFunc_TeamInfo( const char *pszName, int iSize, void *pb
|
|||
// rebuild the team list
|
||||
GetAllPlayersInfo();
|
||||
m_iNumTeams = 0;
|
||||
for ( i = 1; i < MAX_PLAYERS; i++ )
|
||||
for( i = 1; i < MAX_PLAYERS; i++ )
|
||||
{
|
||||
//if ( g_PlayerInfoList[i].name == NULL )
|
||||
// continue;
|
||||
|
||||
if ( g_PlayerExtraInfo[i].teamname[0] == 0 )
|
||||
if( g_PlayerExtraInfo[i].teamname[0] == 0 )
|
||||
continue; // skip over players who are not in a team
|
||||
|
||||
// is this player in an existing team?
|
||||
for ( j = 1; j <= m_iNumTeams; j++ )
|
||||
for( j = 1; j <= m_iNumTeams; j++ )
|
||||
{
|
||||
if ( g_TeamInfo[j].name[0] == '\0' )
|
||||
if( g_TeamInfo[j].name[0] == '\0' )
|
||||
break;
|
||||
|
||||
if ( !stricmp( g_PlayerExtraInfo[i].teamname, g_TeamInfo[j].name ) )
|
||||
if( !stricmp( g_PlayerExtraInfo[i].teamname, g_TeamInfo[j].name ) )
|
||||
break;
|
||||
}
|
||||
|
||||
if ( j > m_iNumTeams )
|
||||
{ // they aren't in a listed team, so make a new one
|
||||
if( j > m_iNumTeams )
|
||||
{
|
||||
// they aren't in a listed team, so make a new one
|
||||
// search through for an empty team slot
|
||||
for ( j = 1; j <= m_iNumTeams; j++ )
|
||||
for( j = 1; j <= m_iNumTeams; j++ )
|
||||
{
|
||||
if ( g_TeamInfo[j].name[0] == '\0' )
|
||||
if( g_TeamInfo[j].name[0] == '\0' )
|
||||
break;
|
||||
}
|
||||
m_iNumTeams = max( j, m_iNumTeams );
|
||||
|
@ -541,9 +543,9 @@ int CHudScoreboard :: MsgFunc_TeamInfo( const char *pszName, int iSize, void *pb
|
|||
}
|
||||
|
||||
// clear out any empty teams
|
||||
for ( i = 1; i <= m_iNumTeams; i++ )
|
||||
for( i = 1; i <= m_iNumTeams; i++ )
|
||||
{
|
||||
if ( g_TeamInfo[i].players < 1 )
|
||||
if( g_TeamInfo[i].players < 1 )
|
||||
memset( &g_TeamInfo[i], 0, sizeof(team_info_t) );
|
||||
}
|
||||
|
||||
|
@ -556,50 +558,48 @@ int CHudScoreboard :: MsgFunc_TeamInfo( const char *pszName, int iSize, void *pb
|
|||
// short: teams kills
|
||||
// short: teams deaths
|
||||
// if this message is never received, then scores will simply be the combined totals of the players.
|
||||
int CHudScoreboard :: MsgFunc_TeamScore( const char *pszName, int iSize, void *pbuf )
|
||||
int CHudScoreboard::MsgFunc_TeamScore( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
char *TeamName = READ_STRING();
|
||||
int i;
|
||||
|
||||
// find the team matching the name
|
||||
for ( i = 1; i <= m_iNumTeams; i++ )
|
||||
for( i = 1; i <= m_iNumTeams; i++ )
|
||||
{
|
||||
if ( !stricmp( TeamName, g_TeamInfo[i].name ) )
|
||||
if( !stricmp( TeamName, g_TeamInfo[i].name ) )
|
||||
break;
|
||||
}
|
||||
if ( i > m_iNumTeams )
|
||||
if( i > m_iNumTeams )
|
||||
return 1;
|
||||
|
||||
// use this new score data instead of combined player scores
|
||||
g_TeamInfo[i].scores_overriden = TRUE;
|
||||
g_TeamInfo[i].frags = READ_SHORT();
|
||||
g_TeamInfo[i].deaths = READ_SHORT();
|
||||
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void CHudScoreboard :: DeathMsg( int killer, int victim )
|
||||
void CHudScoreboard::DeathMsg( int killer, int victim )
|
||||
{
|
||||
// if we were the one killed, or the world killed us, set the scoreboard to indicate suicide
|
||||
if ( victim == m_iPlayerNum || killer == 0 )
|
||||
if( victim == m_iPlayerNum || killer == 0 )
|
||||
{
|
||||
m_iLastKilledBy = killer ? killer : m_iPlayerNum;
|
||||
m_fLastKillTime = gHUD.m_flTime + 10; // display who we were killed by for 10 seconds
|
||||
|
||||
if ( killer == m_iPlayerNum )
|
||||
if( killer == m_iPlayerNum )
|
||||
m_iLastKilledBy = m_iPlayerNum;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void CHudScoreboard :: UserCmd_ShowScores( void )
|
||||
void CHudScoreboard::UserCmd_ShowScores( void )
|
||||
{
|
||||
m_iShowscoresHeld = TRUE;
|
||||
}
|
||||
|
||||
void CHudScoreboard :: UserCmd_HideScores( void )
|
||||
void CHudScoreboard::UserCmd_HideScores( void )
|
||||
{
|
||||
m_iShowscoresHeld = FALSE;
|
||||
}
|
||||
|
|
|
@ -15,6 +15,7 @@
|
|||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#include <windows.h>
|
||||
#include <dsound.h>
|
||||
#include <mmsystem.h>
|
||||
|
@ -28,9 +29,9 @@ extern engine_studio_api_t IEngineStudio;
|
|||
|
||||
#define ENGINE_LAUNCHER_API_VERSION 1
|
||||
|
||||
LPDIRECTSOUND lpDS = NULL;
|
||||
LPDIRECTSOUNDBUFFER lpDSBuf = NULL;
|
||||
LPHWAVEOUT lpHW = NULL;
|
||||
LPDIRECTSOUND lpDS = NULL;
|
||||
LPDIRECTSOUNDBUFFER lpDSBuf = NULL;
|
||||
LPHWAVEOUT lpHW = NULL;
|
||||
|
||||
static HMODULE hEngine = 0;
|
||||
|
||||
|
@ -116,10 +117,10 @@ int Eng_LoadFunctions( HMODULE hMod )
|
|||
engine_api_func pfnEngineAPI;
|
||||
|
||||
pfnEngineAPI = ( engine_api_func )GetProcAddress( hMod, "Sys_EngineAPI" );
|
||||
if ( !pfnEngineAPI )
|
||||
if( !pfnEngineAPI )
|
||||
return 0;
|
||||
|
||||
if ( !(*pfnEngineAPI)( ENGINE_LAUNCHER_API_VERSION, sizeof( engine_api_t ), &engineapi ) )
|
||||
if( !(*pfnEngineAPI)( ENGINE_LAUNCHER_API_VERSION, sizeof( engine_api_t ), &engineapi ) )
|
||||
return 0;
|
||||
|
||||
// All is okay
|
||||
|
@ -132,11 +133,11 @@ int Eng_LoadFunctions( HMODULE hMod )
|
|||
void LoadSoundAPIs( void )
|
||||
{
|
||||
hEngine = ::LoadLibrary( IEngineStudio.IsHardware() ? "hw.dll" : "sw.dll" );
|
||||
if ( hEngine )
|
||||
if( hEngine )
|
||||
{
|
||||
if ( Eng_LoadFunctions( hEngine ) )
|
||||
if( Eng_LoadFunctions( hEngine ) )
|
||||
{
|
||||
if ( engineapi.S_GetDSPointer && engineapi.S_GetWAVPointer )
|
||||
if( engineapi.S_GetDSPointer && engineapi.S_GetWAVPointer )
|
||||
{
|
||||
engineapi.S_GetDSPointer(&lpDS, &lpDSBuf);
|
||||
lpHW = (HWAVEOUT FAR *)engineapi.S_GetWAVPointer();
|
||||
|
@ -155,7 +156,7 @@ void ShutdownSoundAPIs( void )
|
|||
FreeLibrary( hEngine );
|
||||
hEngine = 0;
|
||||
}
|
||||
|
||||
|
||||
lpDS = 0;
|
||||
lpDSBuf = 0;
|
||||
lpHW = 0;
|
||||
|
|
|
@ -15,6 +15,7 @@
|
|||
//
|
||||
// status_icons.cpp
|
||||
//
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "const.h"
|
||||
|
@ -25,7 +26,7 @@
|
|||
#include "parsemsg.h"
|
||||
#include "event_api.h"
|
||||
|
||||
DECLARE_MESSAGE( m_StatusIcons, StatusIcon );
|
||||
DECLARE_MESSAGE( m_StatusIcons, StatusIcon )
|
||||
|
||||
int CHudStatusIcons::Init( void )
|
||||
{
|
||||
|
@ -40,7 +41,6 @@ int CHudStatusIcons::Init( void )
|
|||
|
||||
int CHudStatusIcons::VidInit( void )
|
||||
{
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
@ -53,24 +53,24 @@ void CHudStatusIcons::Reset( void )
|
|||
// Draw status icons along the left-hand side of the screen
|
||||
int CHudStatusIcons::Draw( float flTime )
|
||||
{
|
||||
if (gEngfuncs.IsSpectateOnly())
|
||||
if( gEngfuncs.IsSpectateOnly() )
|
||||
return 1;
|
||||
// find starting position to draw from, along right-hand side of screen
|
||||
int x = 5;
|
||||
int y = ScreenHeight / 2;
|
||||
|
||||
// loop through icon list, and draw any valid icons drawing up from the middle of screen
|
||||
for ( int i = 0; i < MAX_ICONSPRITES; i++ )
|
||||
for( int i = 0; i < MAX_ICONSPRITES; i++ )
|
||||
{
|
||||
if ( m_IconList[i].spr )
|
||||
if( m_IconList[i].spr )
|
||||
{
|
||||
y -= ( m_IconList[i].rc.bottom - m_IconList[i].rc.top ) + 5;
|
||||
|
||||
|
||||
SPR_Set( m_IconList[i].spr, m_IconList[i].r, m_IconList[i].g, m_IconList[i].b );
|
||||
SPR_DrawAdditive( 0, x, y, &m_IconList[i].rc );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
@ -87,7 +87,7 @@ int CHudStatusIcons::MsgFunc_StatusIcon( const char *pszName, int iSize, void *p
|
|||
|
||||
int ShouldEnable = READ_BYTE();
|
||||
char *pszIconName = READ_STRING();
|
||||
if ( ShouldEnable )
|
||||
if( ShouldEnable )
|
||||
{
|
||||
int r = READ_BYTE();
|
||||
int g = READ_BYTE();
|
||||
|
@ -109,24 +109,24 @@ void CHudStatusIcons::EnableIcon( char *pszIconName, unsigned char red, unsigned
|
|||
int i;
|
||||
|
||||
// check to see if the sprite is in the current list
|
||||
for ( i = 0; i < MAX_ICONSPRITES; i++ )
|
||||
for( i = 0; i < MAX_ICONSPRITES; i++ )
|
||||
{
|
||||
if ( !stricmp( m_IconList[i].szSpriteName, pszIconName ) )
|
||||
if( !stricmp( m_IconList[i].szSpriteName, pszIconName ) )
|
||||
break;
|
||||
}
|
||||
|
||||
if ( i == MAX_ICONSPRITES )
|
||||
if( i == MAX_ICONSPRITES )
|
||||
{
|
||||
// icon not in list, so find an empty slot to add to
|
||||
for ( i = 0; i < MAX_ICONSPRITES; i++ )
|
||||
for( i = 0; i < MAX_ICONSPRITES; i++ )
|
||||
{
|
||||
if ( !m_IconList[i].spr )
|
||||
if( !m_IconList[i].spr )
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// if we've run out of space in the list, overwrite the first icon
|
||||
if ( i == MAX_ICONSPRITES )
|
||||
if( i == MAX_ICONSPRITES )
|
||||
{
|
||||
i = 0;
|
||||
}
|
||||
|
@ -142,7 +142,7 @@ void CHudStatusIcons::EnableIcon( char *pszIconName, unsigned char red, unsigned
|
|||
strcpy( m_IconList[i].szSpriteName, pszIconName );
|
||||
|
||||
// Hack: Play Timer sound when a grenade icon is played (in 0.8 seconds)
|
||||
if ( strstr(m_IconList[i].szSpriteName, "grenade") )
|
||||
if( strstr(m_IconList[i].szSpriteName, "grenade") )
|
||||
{
|
||||
cl_entity_t *pthisplayer = gEngfuncs.GetLocalPlayer();
|
||||
gEngfuncs.pEventAPI->EV_PlaySound( pthisplayer->index, pthisplayer->origin, CHAN_STATIC, "weapons/timer.wav", 1.0, ATTN_NORM, 0, PITCH_NORM );
|
||||
|
@ -152,12 +152,12 @@ void CHudStatusIcons::EnableIcon( char *pszIconName, unsigned char red, unsigned
|
|||
void CHudStatusIcons::DisableIcon( char *pszIconName )
|
||||
{
|
||||
// find the sprite is in the current list
|
||||
for ( int i = 0; i < MAX_ICONSPRITES; i++ )
|
||||
for( int i = 0; i < MAX_ICONSPRITES; i++ )
|
||||
{
|
||||
if ( !stricmp( m_IconList[i].szSpriteName, pszIconName ) )
|
||||
if( !stricmp( m_IconList[i].szSpriteName, pszIconName ) )
|
||||
{
|
||||
// clear the item from the list
|
||||
memset( &m_IconList[i], 0, sizeof( icon_sprite_t ) );
|
||||
memset( &m_IconList[i], 0, sizeof(icon_sprite_t) );
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -26,15 +26,15 @@
|
|||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
DECLARE_MESSAGE( m_StatusBar, StatusText );
|
||||
DECLARE_MESSAGE( m_StatusBar, StatusValue );
|
||||
DECLARE_MESSAGE( m_StatusBar, StatusText )
|
||||
DECLARE_MESSAGE( m_StatusBar, StatusValue )
|
||||
|
||||
#define STATUSBAR_ID_LINE 1
|
||||
|
||||
float *GetClientColor( int clientIndex );
|
||||
extern float g_ColorYellow[3];
|
||||
|
||||
int CHudStatusBar :: Init( void )
|
||||
int CHudStatusBar::Init( void )
|
||||
{
|
||||
gHUD.AddHudElem( this );
|
||||
|
||||
|
@ -48,19 +48,18 @@ int CHudStatusBar :: Init( void )
|
|||
return 1;
|
||||
}
|
||||
|
||||
int CHudStatusBar :: VidInit( void )
|
||||
int CHudStatusBar::VidInit( void )
|
||||
{
|
||||
// Load sprites here
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void CHudStatusBar :: Reset( void )
|
||||
void CHudStatusBar::Reset( void )
|
||||
{
|
||||
int i = 0;
|
||||
|
||||
m_iFlags &= ~HUD_ACTIVE; // start out inactive
|
||||
for ( i = 0; i < MAX_STATUSBAR_LINES; i++ )
|
||||
for( i = 0; i < MAX_STATUSBAR_LINES; i++ )
|
||||
m_szStatusText[i][0] = 0;
|
||||
memset( m_iStatusValues, 0, sizeof m_iStatusValues );
|
||||
|
||||
|
@ -71,11 +70,10 @@ void CHudStatusBar :: Reset( void )
|
|||
m_pflNameColors[i] = g_ColorYellow;
|
||||
}
|
||||
|
||||
void CHudStatusBar :: ParseStatusString( int line_num )
|
||||
void CHudStatusBar::ParseStatusString( int line_num )
|
||||
{
|
||||
// localise string first
|
||||
char szBuffer[MAX_STATUSTEXT_LENGTH];
|
||||
memset( szBuffer, 0, sizeof szBuffer );
|
||||
char szBuffer[MAX_STATUSTEXT_LENGTH] = {0};
|
||||
gHUD.m_TextMessage.LocaliseTextString( m_szStatusText[line_num], szBuffer, MAX_STATUSTEXT_LENGTH );
|
||||
|
||||
// parse m_szStatusText & m_iStatusValues into m_szStatusBar
|
||||
|
@ -85,29 +83,31 @@ void CHudStatusBar :: ParseStatusString( int line_num )
|
|||
|
||||
char *src_start = src, *dst_start = dst;
|
||||
|
||||
while ( *src != 0 )
|
||||
while( *src != 0 )
|
||||
{
|
||||
while ( *src == '\n' )
|
||||
while( *src == '\n' )
|
||||
src++; // skip over any newlines
|
||||
|
||||
if ( ((src - src_start) >= MAX_STATUSTEXT_LENGTH) || ((dst - dst_start) >= MAX_STATUSTEXT_LENGTH) )
|
||||
if( ( ( src - src_start ) >= MAX_STATUSTEXT_LENGTH ) || ( ( dst - dst_start ) >= MAX_STATUSTEXT_LENGTH ) )
|
||||
break;
|
||||
|
||||
int index = atoi( src );
|
||||
// should we draw this line?
|
||||
if ( (index >= 0 && index < MAX_STATUSBAR_VALUES) && (m_iStatusValues[index] != 0) )
|
||||
{ // parse this line and append result to the status bar
|
||||
if( ( index >= 0 && index < MAX_STATUSBAR_VALUES ) && ( m_iStatusValues[index] != 0 ) )
|
||||
{
|
||||
// parse this line and append result to the status bar
|
||||
while ( *src >= '0' && *src <= '9' )
|
||||
src++;
|
||||
|
||||
if ( *src == '\n' || *src == 0 )
|
||||
if( *src == '\n' || *src == 0 )
|
||||
continue; // no more left in this text line
|
||||
|
||||
// copy the text, char by char, until we hit a % or a \n
|
||||
while ( *src != '\n' && *src != 0 )
|
||||
while( *src != '\n' && *src != 0 )
|
||||
{
|
||||
if ( *src != '%' )
|
||||
{ // just copy the character
|
||||
if( *src != '%' )
|
||||
{
|
||||
// just copy the character
|
||||
*dst = *src;
|
||||
dst++, src++;
|
||||
}
|
||||
|
@ -126,20 +126,20 @@ void CHudStatusBar :: ParseStatusString( int line_num )
|
|||
|
||||
// move over descriptor, then get and move over the index
|
||||
index = atoi( ++src );
|
||||
while ( *src >= '0' && *src <= '9' )
|
||||
while( *src >= '0' && *src <= '9' )
|
||||
src++;
|
||||
|
||||
if ( index >= 0 && index < MAX_STATUSBAR_VALUES )
|
||||
if( index >= 0 && index < MAX_STATUSBAR_VALUES )
|
||||
{
|
||||
int indexval = m_iStatusValues[index];
|
||||
|
||||
// get the string to substitute in place of the %XX
|
||||
char szRepString[MAX_PLAYER_NAME_LENGTH];
|
||||
switch ( valtype )
|
||||
switch( valtype )
|
||||
{
|
||||
case 'p': // player name
|
||||
GetPlayerInfo( indexval, &g_PlayerInfoList[indexval] );
|
||||
if ( g_PlayerInfoList[indexval].name != NULL )
|
||||
if( g_PlayerInfoList[indexval].name != NULL )
|
||||
{
|
||||
strncpy( szRepString, g_PlayerInfoList[indexval].name, MAX_PLAYER_NAME_LENGTH );
|
||||
m_pflNameColors[line_num] = GetClientColor( indexval );
|
||||
|
@ -148,7 +148,6 @@ void CHudStatusBar :: ParseStatusString( int line_num )
|
|||
{
|
||||
strcpy( szRepString, "******" );
|
||||
}
|
||||
|
||||
break;
|
||||
case 'i': // number
|
||||
sprintf( szRepString, "%d", indexval );
|
||||
|
@ -157,7 +156,7 @@ void CHudStatusBar :: ParseStatusString( int line_num )
|
|||
szRepString[0] = 0;
|
||||
}
|
||||
|
||||
for ( char *cp = szRepString; *cp != 0 && ((dst - dst_start) < MAX_STATUSTEXT_LENGTH); cp++, dst++ )
|
||||
for( char *cp = szRepString; *cp != 0 && ( ( dst - dst_start ) < MAX_STATUSTEXT_LENGTH ); cp++, dst++ )
|
||||
*dst = *cp;
|
||||
}
|
||||
}
|
||||
|
@ -166,17 +165,17 @@ void CHudStatusBar :: ParseStatusString( int line_num )
|
|||
else
|
||||
{
|
||||
// skip to next line of text
|
||||
while ( *src != 0 && *src != '\n' )
|
||||
while( *src != 0 && *src != '\n' )
|
||||
src++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int CHudStatusBar :: Draw( float fTime )
|
||||
int CHudStatusBar::Draw( float fTime )
|
||||
{
|
||||
if ( m_bReparseString )
|
||||
if( m_bReparseString )
|
||||
{
|
||||
for ( int i = 0; i < MAX_STATUSBAR_LINES; i++ )
|
||||
for( int i = 0; i < MAX_STATUSBAR_LINES; i++ )
|
||||
{
|
||||
m_pflNameColors[i] = g_ColorYellow;
|
||||
ParseStatusString( i );
|
||||
|
@ -184,10 +183,10 @@ int CHudStatusBar :: Draw( float fTime )
|
|||
m_bReparseString = FALSE;
|
||||
}
|
||||
|
||||
int Y_START = ScreenHeight - YRES(32 + 4);
|
||||
int Y_START = ScreenHeight - YRES( 32 + 4 );
|
||||
|
||||
// Draw the status bar lines
|
||||
for ( int i = 0; i < MAX_STATUSBAR_LINES; i++ )
|
||||
for( int i = 0; i < MAX_STATUSBAR_LINES; i++ )
|
||||
{
|
||||
int TextHeight, TextWidth;
|
||||
GetConsoleStringSize( m_szStatusBar[i], &TextWidth, &TextHeight );
|
||||
|
@ -196,13 +195,13 @@ int CHudStatusBar :: Draw( float fTime )
|
|||
int y = Y_START - ( 4 + TextHeight * i ); // draw along bottom of screen
|
||||
|
||||
// let user set status ID bar centering
|
||||
if ( (i == STATUSBAR_ID_LINE) && CVAR_GET_FLOAT("hud_centerid") )
|
||||
if( ( i == STATUSBAR_ID_LINE ) && CVAR_GET_FLOAT( "hud_centerid" ) )
|
||||
{
|
||||
x = max( 0, max(2, (ScreenWidth - TextWidth)) / 2 );
|
||||
y = (ScreenHeight / 2) + (TextHeight*CVAR_GET_FLOAT("hud_centerid"));
|
||||
x = max( 0, max( 2, ( ScreenWidth - TextWidth ) ) / 2 );
|
||||
y = ( ScreenHeight / 2 ) + ( TextHeight * CVAR_GET_FLOAT( "hud_centerid" ) );
|
||||
}
|
||||
|
||||
if ( m_pflNameColors[i] )
|
||||
if( m_pflNameColors[i] )
|
||||
DrawSetTextColor( m_pflNameColors[i][0], m_pflNameColors[i][1], m_pflNameColors[i][2] );
|
||||
|
||||
DrawConsoleString( x, y, m_szStatusBar[i] );
|
||||
|
@ -223,19 +222,19 @@ int CHudStatusBar :: Draw( float fTime )
|
|||
// if StatusValue[slotnum] != 0, the following string is drawn, upto the next newline - otherwise the text is skipped upto next newline
|
||||
// %pX, where X is an integer, will substitute a player name here, getting the player index from StatusValue[X]
|
||||
// %iX, where X is an integer, will substitute a number here, getting the number from StatusValue[X]
|
||||
int CHudStatusBar :: MsgFunc_StatusText( const char *pszName, int iSize, void *pbuf )
|
||||
int CHudStatusBar::MsgFunc_StatusText( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
int line = READ_BYTE();
|
||||
|
||||
if ( line < 0 || line >= MAX_STATUSBAR_LINES )
|
||||
if( line < 0 || line >= MAX_STATUSBAR_LINES )
|
||||
return 1;
|
||||
|
||||
strncpy( m_szStatusText[line], READ_STRING(), MAX_STATUSTEXT_LENGTH );
|
||||
m_szStatusText[line][MAX_STATUSTEXT_LENGTH-1] = 0; // ensure it's null terminated ( strncpy() won't null terminate if read string too long)
|
||||
m_szStatusText[line][MAX_STATUSTEXT_LENGTH - 1] = 0; // ensure it's null terminated ( strncpy() won't null terminate if read string too long)
|
||||
|
||||
if ( m_szStatusText[0] == 0 )
|
||||
if( m_szStatusText[0] == 0 )
|
||||
m_iFlags &= ~HUD_ACTIVE;
|
||||
else
|
||||
m_iFlags |= HUD_ACTIVE; // we have status text, so turn on the status bar
|
||||
|
@ -249,17 +248,17 @@ int CHudStatusBar :: MsgFunc_StatusText( const char *pszName, int iSize, void *p
|
|||
// accepts two values:
|
||||
// byte: index into the status value array
|
||||
// short: value to store
|
||||
int CHudStatusBar :: MsgFunc_StatusValue( const char *pszName, int iSize, void *pbuf )
|
||||
int CHudStatusBar::MsgFunc_StatusValue( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
int index = READ_BYTE();
|
||||
if ( index < 1 || index >= MAX_STATUSBAR_VALUES )
|
||||
if( index < 1 || index >= MAX_STATUSBAR_VALUES )
|
||||
return 1; // index out of range
|
||||
|
||||
m_iStatusValues[index] = READ_SHORT();
|
||||
|
||||
m_bReparseString = TRUE;
|
||||
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
|
|
@ -18,31 +18,31 @@ AngleMatrix
|
|||
|
||||
====================
|
||||
*/
|
||||
void AngleMatrix (const float *angles, float (*matrix)[4] )
|
||||
void AngleMatrix( const float *angles, float (*matrix)[4] )
|
||||
{
|
||||
float angle;
|
||||
float sr, sp, sy, cr, cp, cy;
|
||||
|
||||
angle = angles[YAW] * (M_PI*2 / 360);
|
||||
sy = sin(angle);
|
||||
cy = cos(angle);
|
||||
angle = angles[PITCH] * (M_PI*2 / 360);
|
||||
sp = sin(angle);
|
||||
cp = cos(angle);
|
||||
angle = angles[ROLL] * (M_PI*2 / 360);
|
||||
sr = sin(angle);
|
||||
cr = cos(angle);
|
||||
float angle;
|
||||
float sr, sp, sy, cr, cp, cy;
|
||||
|
||||
angle = angles[YAW] * ( M_PI*2 / 360 );
|
||||
sy = sin( angle );
|
||||
cy = cos( angle );
|
||||
angle = angles[PITCH] * ( M_PI*2 / 360 );
|
||||
sp = sin( angle );
|
||||
cp = cos( angle );
|
||||
angle = angles[ROLL] * ( M_PI*2 / 360 );
|
||||
sr = sin( angle );
|
||||
cr = cos( angle );
|
||||
|
||||
// matrix = (YAW * PITCH) * ROLL
|
||||
matrix[0][0] = cp*cy;
|
||||
matrix[1][0] = cp*sy;
|
||||
matrix[0][0] = cp * cy;
|
||||
matrix[1][0] = cp * sy;
|
||||
matrix[2][0] = -sp;
|
||||
matrix[0][1] = sr*sp*cy+cr*-sy;
|
||||
matrix[1][1] = sr*sp*sy+cr*cy;
|
||||
matrix[2][1] = sr*cp;
|
||||
matrix[0][2] = (cr*sp*cy+-sr*-sy);
|
||||
matrix[1][2] = (cr*sp*sy+-sr*cy);
|
||||
matrix[2][2] = cr*cp;
|
||||
matrix[0][1] = sr * sp * cy + cr * -sy;
|
||||
matrix[1][1] = sr * sp * sy + cr * cy;
|
||||
matrix[2][1] = sr * cp;
|
||||
matrix[0][2] = (cr * sp * cy + -sr * -sy);
|
||||
matrix[1][2] = (cr * sp * sy + -sr* cy);
|
||||
matrix[2][2] = cr * cp;
|
||||
matrix[0][3] = 0.0;
|
||||
matrix[1][3] = 0.0;
|
||||
matrix[2][3] = 0.0;
|
||||
|
@ -54,14 +54,14 @@ VectorCompare
|
|||
|
||||
====================
|
||||
*/
|
||||
int VectorCompare (const float *v1, const float *v2)
|
||||
int VectorCompare( const float *v1, const float *v2 )
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i=0 ; i<3 ; i++)
|
||||
if (v1[i] != v2[i])
|
||||
int i;
|
||||
|
||||
for( i = 0; i < 3; i++ )
|
||||
if( v1[i] != v2[i] )
|
||||
return 0;
|
||||
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
@ -71,7 +71,7 @@ CrossProduct
|
|||
|
||||
====================
|
||||
*/
|
||||
void CrossProduct (const float *v1, const float *v2, float *cross)
|
||||
void CrossProduct( const float *v1, const float *v2, float *cross )
|
||||
{
|
||||
cross[0] = v1[1]*v2[2] - v1[2]*v2[1];
|
||||
cross[1] = v1[2]*v2[0] - v1[0]*v2[2];
|
||||
|
@ -84,7 +84,7 @@ VectorTransform
|
|||
|
||||
====================
|
||||
*/
|
||||
void VectorTransform (const float *in1, float in2[3][4], float *out)
|
||||
void VectorTransform( const float *in1, float in2[3][4], float *out )
|
||||
{
|
||||
out[0] = DotProduct(in1, in2[0]) + in2[0][3];
|
||||
out[1] = DotProduct(in1, in2[1]) + in2[1][3];
|
||||
|
@ -97,7 +97,7 @@ ConcatTransforms
|
|||
|
||||
================
|
||||
*/
|
||||
void ConcatTransforms (float in1[3][4], float in2[3][4], float out[3][4])
|
||||
void ConcatTransforms( float in1[3][4], float in2[3][4], float out[3][4] )
|
||||
{
|
||||
out[0][0] = in1[0][0] * in2[0][0] + in1[0][1] * in2[1][0] +
|
||||
in1[0][2] * in2[2][0];
|
||||
|
@ -135,24 +135,24 @@ AngleQuaternion
|
|||
*/
|
||||
void AngleQuaternion( float *angles, vec4_t quaternion )
|
||||
{
|
||||
float angle;
|
||||
float sr, sp, sy, cr, cp, cy;
|
||||
float angle;
|
||||
float sr, sp, sy, cr, cp, cy;
|
||||
|
||||
// FIXME: rescale the inputs to 1/2 angle
|
||||
angle = angles[2] * 0.5;
|
||||
sy = sin(angle);
|
||||
cy = cos(angle);
|
||||
sy = sin( angle );
|
||||
cy = cos( angle );
|
||||
angle = angles[1] * 0.5;
|
||||
sp = sin(angle);
|
||||
cp = cos(angle);
|
||||
sp = sin( angle );
|
||||
cp = cos( angle );
|
||||
angle = angles[0] * 0.5;
|
||||
sr = sin(angle);
|
||||
cr = cos(angle);
|
||||
sr = sin( angle );
|
||||
cr = cos( angle );
|
||||
|
||||
quaternion[0] = sr*cp*cy-cr*sp*sy; // X
|
||||
quaternion[1] = cr*sp*cy+sr*cp*sy; // Y
|
||||
quaternion[2] = cr*cp*sy-sr*sp*cy; // Z
|
||||
quaternion[3] = cr*cp*cy+sr*sp*sy; // W
|
||||
quaternion[0] = sr * cp * cy - cr * sp * sy; // X
|
||||
quaternion[1] = cr * sp * cy + sr * cp * sy; // Y
|
||||
quaternion[2] = cr * cp * sy - sr * sp * cy; // Z
|
||||
quaternion[3] = cr * cp * cy + sr * sp * sy; // W
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -164,42 +164,43 @@ QuaternionSlerp
|
|||
void QuaternionSlerp( vec4_t p, vec4_t q, float t, vec4_t qt )
|
||||
{
|
||||
int i;
|
||||
float omega, cosom, sinom, sclp, sclq;
|
||||
float omega, cosom, sinom, sclp, sclq;
|
||||
|
||||
// decide if one of the quaternions is backwards
|
||||
float a = 0;
|
||||
float b = 0;
|
||||
|
||||
for (i = 0; i < 4; i++)
|
||||
for( i = 0; i < 4; i++ )
|
||||
{
|
||||
a += (p[i]-q[i])*(p[i]-q[i]);
|
||||
b += (p[i]+q[i])*(p[i]+q[i]);
|
||||
a += ( p[i] - q[i] ) * ( p[i] - q[i] );
|
||||
b += ( p[i] + q[i] ) * ( p[i] + q[i] );
|
||||
}
|
||||
if (a > b)
|
||||
if(a > b)
|
||||
{
|
||||
for (i = 0; i < 4; i++)
|
||||
for( i = 0; i < 4; i++ )
|
||||
{
|
||||
q[i] = -q[i];
|
||||
}
|
||||
}
|
||||
|
||||
cosom = p[0]*q[0] + p[1]*q[1] + p[2]*q[2] + p[3]*q[3];
|
||||
cosom = p[0] * q[0] + p[1] * q[1] + p[2] * q[2] + p[3] * q[3];
|
||||
|
||||
if ((1.0 + cosom) > 0.000001)
|
||||
if( ( 1.0 + cosom ) > 0.000001 )
|
||||
{
|
||||
if ((1.0 - cosom) > 0.000001)
|
||||
if( ( 1.0 - cosom ) > 0.000001 )
|
||||
{
|
||||
omega = acos( cosom );
|
||||
sinom = sin( omega );
|
||||
sclp = sin( (1.0 - t)*omega) / sinom;
|
||||
sclq = sin( t*omega ) / sinom;
|
||||
sclp = sin( ( 1.0 - t ) * omega ) / sinom;
|
||||
sclq = sin( t * omega ) / sinom;
|
||||
}
|
||||
else
|
||||
{
|
||||
sclp = 1.0 - t;
|
||||
sclq = t;
|
||||
}
|
||||
for (i = 0; i < 4; i++) {
|
||||
for( i = 0; i < 4; i++ )
|
||||
{
|
||||
qt[i] = sclp * p[i] + sclq * q[i];
|
||||
}
|
||||
}
|
||||
|
@ -209,9 +210,9 @@ void QuaternionSlerp( vec4_t p, vec4_t q, float t, vec4_t qt )
|
|||
qt[1] = q[0];
|
||||
qt[2] = -q[3];
|
||||
qt[3] = q[2];
|
||||
sclp = sin( (1.0 - t) * (0.5 * M_PI));
|
||||
sclq = sin( t * (0.5 * M_PI));
|
||||
for (i = 0; i < 3; i++)
|
||||
sclp = sin( ( 1.0 - t ) * ( 0.5 * M_PI ) );
|
||||
sclq = sin( t * ( 0.5 * M_PI ) );
|
||||
for( i = 0; i < 3; i++ )
|
||||
{
|
||||
qt[i] = sclp * p[i] + sclq * qt[i];
|
||||
}
|
||||
|
@ -248,4 +249,4 @@ MatrixCopy
|
|||
void MatrixCopy( float in[3][4], float out[3][4] )
|
||||
{
|
||||
memcpy( out, in, sizeof( float ) * 3 * 4 );
|
||||
}
|
||||
}
|
||||
|
|
|
@ -25,16 +25,15 @@
|
|||
#define ROLL 2
|
||||
#endif
|
||||
|
||||
#define FDotProduct( a, b ) (fabs((a[0])*(b[0])) + fabs((a[1])*(b[1])) + fabs((a[2])*(b[2])))
|
||||
#define FDotProduct( a, b ) ( fabs( ( a[0] ) * ( b[0] ) ) + fabs( ( a[1] ) * ( b[1] ) ) + fabs( ( a[2] ) * ( b[2] ) ) )
|
||||
|
||||
void AngleMatrix (const float *angles, float (*matrix)[4] );
|
||||
int VectorCompare (const float *v1, const float *v2);
|
||||
void CrossProduct (const float *v1, const float *v2, float *cross);
|
||||
void VectorTransform (const float *in1, float in2[3][4], float *out);
|
||||
void ConcatTransforms (float in1[3][4], float in2[3][4], float out[3][4]);
|
||||
void AngleMatrix( const float *angles, float (*matrix)[4] );
|
||||
int VectorCompare( const float *v1, const float *v2 );
|
||||
void CrossProduct( const float *v1, const float *v2, float *cross );
|
||||
void VectorTransform( const float *in1, float in2[3][4], float *out );
|
||||
void ConcatTransforms( float in1[3][4], float in2[3][4], float out[3][4] );
|
||||
void MatrixCopy( float in[3][4], float out[3][4] );
|
||||
void QuaternionMatrix( vec4_t quaternion, float (*matrix)[4] );
|
||||
void QuaternionSlerp( vec4_t p, vec4_t q, float t, vec4_t qt );
|
||||
void AngleQuaternion( float *angles, vec4_t quaternion );
|
||||
|
||||
#endif // STUDIO_UTIL_H
|
||||
#endif // STUDIO_UTIL_H
|
||||
|
|
|
@ -26,10 +26,9 @@
|
|||
#include <stdio.h>
|
||||
#include "parsemsg.h"
|
||||
|
||||
DECLARE_MESSAGE( m_TextMessage, TextMsg )
|
||||
|
||||
DECLARE_MESSAGE( m_TextMessage, TextMsg );
|
||||
|
||||
int CHudTextMessage::Init(void)
|
||||
int CHudTextMessage::Init( void )
|
||||
{
|
||||
HOOK_MESSAGE( TextMsg );
|
||||
|
||||
|
@ -38,7 +37,7 @@ int CHudTextMessage::Init(void)
|
|||
Reset();
|
||||
|
||||
return 1;
|
||||
};
|
||||
}
|
||||
|
||||
// Searches through the string for any msg names (indicated by a '#')
|
||||
// any found are looked up in titles.txt and the new message substituted
|
||||
|
@ -46,14 +45,14 @@ int CHudTextMessage::Init(void)
|
|||
char *CHudTextMessage::LocaliseTextString( const char *msg, char *dst_buffer, int buffer_size )
|
||||
{
|
||||
char *dst = dst_buffer;
|
||||
for ( char *src = (char*)msg; *src != 0 && buffer_size > 0; buffer_size-- )
|
||||
for( char *src = (char*)msg; *src != 0 && buffer_size > 0; buffer_size-- )
|
||||
{
|
||||
if ( *src == '#' )
|
||||
if( *src == '#' )
|
||||
{
|
||||
// cut msg name out of string
|
||||
static char word_buf[255];
|
||||
char *wdst = word_buf, *word_start = src;
|
||||
for ( ++src ; (*src >= 'A' && *src <= 'z') || (*src >= '0' && *src <= '9'); wdst++, src++ )
|
||||
for( ++src; ( *src >= 'A' && *src <= 'z' ) || ( *src >= '0' && *src <= '9' ); wdst++, src++ )
|
||||
{
|
||||
*wdst = *src;
|
||||
}
|
||||
|
@ -61,7 +60,7 @@ char *CHudTextMessage::LocaliseTextString( const char *msg, char *dst_buffer, in
|
|||
|
||||
// lookup msg name in titles.txt
|
||||
client_textmessage_t *clmsg = TextMessageGet( word_buf );
|
||||
if ( !clmsg || !(clmsg->pMessage) )
|
||||
if( !clmsg || !( clmsg->pMessage ) )
|
||||
{
|
||||
src = word_start;
|
||||
*dst = *src;
|
||||
|
@ -70,7 +69,7 @@ char *CHudTextMessage::LocaliseTextString( const char *msg, char *dst_buffer, in
|
|||
}
|
||||
|
||||
// copy string into message over the msg name
|
||||
for ( char *wsrc = (char*)clmsg->pMessage; *wsrc != 0; wsrc++, dst++ )
|
||||
for( char *wsrc = (char*)clmsg->pMessage; *wsrc != 0; wsrc++, dst++ )
|
||||
{
|
||||
*dst = *wsrc;
|
||||
}
|
||||
|
@ -84,7 +83,7 @@ char *CHudTextMessage::LocaliseTextString( const char *msg, char *dst_buffer, in
|
|||
}
|
||||
}
|
||||
|
||||
dst_buffer[buffer_size-1] = 0; // ensure null termination
|
||||
dst_buffer[buffer_size - 1] = 0; // ensure null termination
|
||||
return dst_buffer;
|
||||
}
|
||||
|
||||
|
@ -99,30 +98,31 @@ char *CHudTextMessage::BufferedLocaliseTextString( const char *msg )
|
|||
// Simplified version of LocaliseTextString; assumes string is only one word
|
||||
char *CHudTextMessage::LookupString( const char *msg, int *msg_dest )
|
||||
{
|
||||
if ( !msg )
|
||||
if( !msg )
|
||||
return "";
|
||||
|
||||
// '#' character indicates this is a reference to a string in titles.txt, and not the string itself
|
||||
if ( msg[0] == '#' )
|
||||
if( msg[0] == '#' )
|
||||
{
|
||||
// this is a message name, so look up the real message
|
||||
client_textmessage_t *clmsg = TextMessageGet( msg+1 );
|
||||
client_textmessage_t *clmsg = TextMessageGet( msg + 1 );
|
||||
|
||||
if ( !clmsg || !(clmsg->pMessage) )
|
||||
if( !clmsg || !(clmsg->pMessage) )
|
||||
return (char*)msg; // lookup failed, so return the original string
|
||||
|
||||
if ( msg_dest )
|
||||
|
||||
if( msg_dest )
|
||||
{
|
||||
// check to see if titles.txt info overrides msg destination
|
||||
// if clmsg->effect is less than 0, then clmsg->effect holds -1 * message_destination
|
||||
if ( clmsg->effect < 0 ) //
|
||||
if( clmsg->effect < 0 ) //
|
||||
*msg_dest = -clmsg->effect;
|
||||
}
|
||||
|
||||
return (char*)clmsg->pMessage;
|
||||
}
|
||||
else
|
||||
{ // nothing special about this message, so just return the same string
|
||||
{
|
||||
// nothing special about this message, so just return the same string
|
||||
return (char*)msg;
|
||||
}
|
||||
}
|
||||
|
@ -130,7 +130,7 @@ char *CHudTextMessage::LookupString( const char *msg, int *msg_dest )
|
|||
void StripEndNewlineFromString( char *str )
|
||||
{
|
||||
int s = strlen( str ) - 1;
|
||||
if ( str[s] == '\n' || str[s] == '\r' )
|
||||
if( str[s] == '\n' || str[s] == '\r' )
|
||||
str[s] = 0;
|
||||
}
|
||||
|
||||
|
@ -138,8 +138,8 @@ void StripEndNewlineFromString( char *str )
|
|||
// returns a pointer to str
|
||||
char* ConvertCRtoNL( char *str )
|
||||
{
|
||||
for ( char *ch = str; *ch != 0; ch++ )
|
||||
if ( *ch == '\r' )
|
||||
for( char *ch = str; *ch != 0; ch++ )
|
||||
if( *ch == '\r' )
|
||||
*ch = '\n';
|
||||
return str;
|
||||
}
|
||||
|
@ -181,24 +181,21 @@ int CHudTextMessage::MsgFunc_TextMsg( const char *pszName, int iSize, void *pbuf
|
|||
StripEndNewlineFromString( sstr4 );
|
||||
char *psz = szBuf[5];
|
||||
|
||||
switch ( msg_dest )
|
||||
switch( msg_dest )
|
||||
{
|
||||
case HUD_PRINTCENTER:
|
||||
sprintf( psz, msg_text, sstr1, sstr2, sstr3, sstr4 );
|
||||
CenterPrint( ConvertCRtoNL( psz ) );
|
||||
break;
|
||||
|
||||
case HUD_PRINTNOTIFY:
|
||||
psz[0] = 1; // mark this message to go into the notify buffer
|
||||
sprintf( psz+1, msg_text, sstr1, sstr2, sstr3, sstr4 );
|
||||
sprintf( psz + 1, msg_text, sstr1, sstr2, sstr3, sstr4 );
|
||||
ConsolePrint( ConvertCRtoNL( psz ) );
|
||||
break;
|
||||
|
||||
case HUD_PRINTTALK:
|
||||
sprintf( psz, msg_text, sstr1, sstr2, sstr3, sstr4 );
|
||||
gHUD.m_SayText.SayTextPrint( ConvertCRtoNL( psz ), 128 );
|
||||
break;
|
||||
|
||||
case HUD_PRINTCONSOLE:
|
||||
sprintf( psz, msg_text, sstr1, sstr2, sstr3, sstr4 );
|
||||
ConsolePrint( ConvertCRtoNL( psz ) );
|
||||
|
|
|
@ -362,7 +362,6 @@ enum
|
|||
// Silent Spy Feign
|
||||
#define TF_SPY_SILENTDIE 199
|
||||
|
||||
|
||||
/*==================================================*/
|
||||
/* Defines for the ENGINEER's Building ability */
|
||||
/*==================================================*/
|
||||
|
@ -458,28 +457,28 @@ enum
|
|||
|
||||
// HL-compatible weapon numbers
|
||||
#define WEAPON_HOOK 1
|
||||
#define WEAPON_BIOWEAPON (WEAPON_HOOK+1)
|
||||
#define WEAPON_MEDIKIT (WEAPON_HOOK+2)
|
||||
#define WEAPON_SPANNER (WEAPON_HOOK+3)
|
||||
#define WEAPON_AXE (WEAPON_HOOK+4)
|
||||
#define WEAPON_SNIPER_RIFLE (WEAPON_HOOK+5)
|
||||
#define WEAPON_AUTO_RIFLE (WEAPON_HOOK+6)
|
||||
#define WEAPON_TF_SHOTGUN (WEAPON_HOOK+7)
|
||||
#define WEAPON_SUPER_SHOTGUN (WEAPON_HOOK+8)
|
||||
#define WEAPON_NAILGUN (WEAPON_HOOK+9)
|
||||
#define WEAPON_SUPER_NAILGUN (WEAPON_HOOK+10)
|
||||
#define WEAPON_GRENADE_LAUNCHER (WEAPON_HOOK+11)
|
||||
#define WEAPON_FLAMETHROWER (WEAPON_HOOK+12)
|
||||
#define WEAPON_ROCKET_LAUNCHER (WEAPON_HOOK+13)
|
||||
#define WEAPON_INCENDIARY (WEAPON_HOOK+14)
|
||||
#define WEAPON_ASSAULT_CANNON (WEAPON_HOOK+16)
|
||||
#define WEAPON_LIGHTNING (WEAPON_HOOK+17)
|
||||
#define WEAPON_DETPACK (WEAPON_HOOK+18)
|
||||
#define WEAPON_TRANQ (WEAPON_HOOK+19)
|
||||
#define WEAPON_LASER (WEAPON_HOOK+20)
|
||||
#define WEAPON_PIPEBOMB_LAUNCHER (WEAPON_HOOK+21)
|
||||
#define WEAPON_KNIFE (WEAPON_HOOK+22)
|
||||
#define WEAPON_BENCHMARK (WEAPON_HOOK+23)
|
||||
#define WEAPON_BIOWEAPON (WEAPON_HOOK + 1)
|
||||
#define WEAPON_MEDIKIT (WEAPON_HOOK + 2)
|
||||
#define WEAPON_SPANNER (WEAPON_HOOK + 3)
|
||||
#define WEAPON_AXE (WEAPON_HOOK + 4)
|
||||
#define WEAPON_SNIPER_RIFLE (WEAPON_HOOK + 5)
|
||||
#define WEAPON_AUTO_RIFLE (WEAPON_HOOK + 6)
|
||||
#define WEAPON_TF_SHOTGUN (WEAPON_HOOK + 7)
|
||||
#define WEAPON_SUPER_SHOTGUN (WEAPON_HOOK + 8)
|
||||
#define WEAPON_NAILGUN (WEAPON_HOOK + 9)
|
||||
#define WEAPON_SUPER_NAILGUN (WEAPON_HOOK + 10)
|
||||
#define WEAPON_GRENADE_LAUNCHER (WEAPON_HOOK + 11)
|
||||
#define WEAPON_FLAMETHROWER (WEAPON_HOOK + 12)
|
||||
#define WEAPON_ROCKET_LAUNCHER (WEAPON_HOOK + 13)
|
||||
#define WEAPON_INCENDIARY (WEAPON_HOOK + 14)
|
||||
#define WEAPON_ASSAULT_CANNON (WEAPON_HOOK + 16)
|
||||
#define WEAPON_LIGHTNING (WEAPON_HOOK + 17)
|
||||
#define WEAPON_DETPACK (WEAPON_HOOK + 18)
|
||||
#define WEAPON_TRANQ (WEAPON_HOOK + 19)
|
||||
#define WEAPON_LASER (WEAPON_HOOK + 20)
|
||||
#define WEAPON_PIPEBOMB_LAUNCHER (WEAPON_HOOK + 21)
|
||||
#define WEAPON_KNIFE (WEAPON_HOOK + 22)
|
||||
#define WEAPON_BENCHMARK (WEAPON_HOOK + 23)
|
||||
|
||||
/*==================================================*/
|
||||
/* New Weapon Related Defines */
|
||||
|
@ -509,7 +508,7 @@ enum
|
|||
// Detpack
|
||||
#define WEAP_DETPACK_DISARMTIME 3 // Time it takes to disarm a Detpack
|
||||
#define WEAP_DETPACK_SETTIME 3 // Time it takes to set a Detpack
|
||||
#define WEAP_DETPACK_SIZE 700 // Explosion Size
|
||||
#define WEAP_DETPACK_SIZE 700 // Explosion Size
|
||||
#define WEAP_DETPACK_GOAL_SIZE 1500 // Explosion Size for goal triggering
|
||||
#define WEAP_DETPACK_BITS_NO 12 // Bits that detpack explodes into
|
||||
|
||||
|
@ -519,15 +518,15 @@ enum
|
|||
// Grenades
|
||||
#define GR_PRIMETIME 3
|
||||
#define GR_CALTROP_PRIME 0.5
|
||||
#define GR_TYPE_NONE 0
|
||||
#define GR_TYPE_NORMAL 1
|
||||
#define GR_TYPE_CONCUSSION 2
|
||||
#define GR_TYPE_NAIL 3
|
||||
#define GR_TYPE_MIRV 4
|
||||
#define GR_TYPE_NAPALM 5
|
||||
//#define GR_TYPE_FLARE 6
|
||||
#define GR_TYPE_GAS 7
|
||||
#define GR_TYPE_EMP 8
|
||||
#define GR_TYPE_NONE 0
|
||||
#define GR_TYPE_NORMAL 1
|
||||
#define GR_TYPE_CONCUSSION 2
|
||||
#define GR_TYPE_NAIL 3
|
||||
#define GR_TYPE_MIRV 4
|
||||
#define GR_TYPE_NAPALM 5
|
||||
//#define GR_TYPE_FLARE 6
|
||||
#define GR_TYPE_GAS 7
|
||||
#define GR_TYPE_EMP 8
|
||||
#define GR_TYPE_CALTROP 9
|
||||
//#define GR_TYPE_FLASH 10
|
||||
|
||||
|
@ -542,8 +541,8 @@ enum
|
|||
// Defines for Concussion Grenade
|
||||
#define GR_CONCUSS_TIME 0.25
|
||||
#define GR_CONCUSS_DEC 10
|
||||
#define MEDIUM_PING 150
|
||||
#define HIGH_PING 200
|
||||
#define MEDIUM_PING 150
|
||||
#define HIGH_PING 200
|
||||
|
||||
// Defines for the Gas Grenade
|
||||
#define GR_HALLU_TIME 0.3
|
||||
|
@ -551,7 +550,7 @@ enum
|
|||
#define GR_HALLU_DEC 2.5
|
||||
|
||||
// Defines for the BioInfection
|
||||
#define BIO_JUMP_RADIUS 128 // The distance the bioinfection can jump between players
|
||||
#define BIO_JUMP_RADIUS 128 // The distance the bioinfection can jump between players
|
||||
|
||||
/*==================================================*/
|
||||
/* New Items */
|
||||
|
@ -1382,8 +1381,5 @@ public:
|
|||
void Spawn( void );
|
||||
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
|
||||
};
|
||||
|
||||
#endif // TF_DEFS_ONLY
|
||||
#endif // __TF_DEFS_H
|
||||
|
||||
|
||||
|
|
|
@ -24,59 +24,56 @@
|
|||
#include <stdio.h>
|
||||
#include "parsemsg.h"
|
||||
|
||||
DECLARE_MESSAGE(m_Train, Train )
|
||||
DECLARE_MESSAGE( m_Train, Train )
|
||||
|
||||
|
||||
int CHudTrain::Init(void)
|
||||
int CHudTrain::Init( void )
|
||||
{
|
||||
HOOK_MESSAGE( Train );
|
||||
|
||||
m_iPos = 0;
|
||||
m_iFlags = 0;
|
||||
gHUD.AddHudElem(this);
|
||||
gHUD.AddHudElem( this );
|
||||
|
||||
return 1;
|
||||
};
|
||||
}
|
||||
|
||||
int CHudTrain::VidInit(void)
|
||||
int CHudTrain::VidInit( void )
|
||||
{
|
||||
m_hSprite = 0;
|
||||
|
||||
return 1;
|
||||
};
|
||||
}
|
||||
|
||||
int CHudTrain::Draw(float fTime)
|
||||
int CHudTrain::Draw( float fTime )
|
||||
{
|
||||
if ( !m_hSprite )
|
||||
m_hSprite = LoadSprite("sprites/%d_train.spr");
|
||||
if( !m_hSprite )
|
||||
m_hSprite = LoadSprite( "sprites/%d_train.spr" );
|
||||
|
||||
if (m_iPos)
|
||||
if( m_iPos )
|
||||
{
|
||||
int r, g, b, x, y;
|
||||
|
||||
UnpackRGB(r,g,b, RGB_YELLOWISH);
|
||||
SPR_Set(m_hSprite, r, g, b );
|
||||
UnpackRGB( r, g, b, RGB_YELLOWISH );
|
||||
SPR_Set( m_hSprite, r, g, b );
|
||||
|
||||
// This should show up to the right and part way up the armor number
|
||||
y = ScreenHeight - SPR_Height(m_hSprite,0) - gHUD.m_iFontHeight;
|
||||
x = ScreenWidth/3 + SPR_Width(m_hSprite,0)/4;
|
||||
|
||||
SPR_DrawAdditive( m_iPos - 1, x, y, NULL);
|
||||
y = ScreenHeight - SPR_Height( m_hSprite, 0 ) - gHUD.m_iFontHeight;
|
||||
x = ScreenWidth / 3 + SPR_Width( m_hSprite, 0 ) / 4;
|
||||
|
||||
SPR_DrawAdditive( m_iPos - 1, x, y, NULL );
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int CHudTrain::MsgFunc_Train(const char *pszName, int iSize, void *pbuf)
|
||||
int CHudTrain::MsgFunc_Train( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
// update Train data
|
||||
m_iPos = READ_BYTE();
|
||||
|
||||
if (m_iPos)
|
||||
if( m_iPos )
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
else
|
||||
m_iFlags &= ~HUD_ACTIVE;
|
||||
|
|
|
@ -21,7 +21,7 @@ extern "C"
|
|||
{
|
||||
void DLLEXPORT HUD_DrawNormalTriangles( void );
|
||||
void DLLEXPORT HUD_DrawTransparentTriangles( void );
|
||||
};
|
||||
}
|
||||
|
||||
//#define TEST_IT
|
||||
#if defined( TEST_IT )
|
||||
|
@ -40,7 +40,7 @@ void Draw_Triangles( void )
|
|||
|
||||
// Load it up with some bogus data
|
||||
player = gEngfuncs.GetLocalPlayer();
|
||||
if ( !player )
|
||||
if( !player )
|
||||
return;
|
||||
|
||||
org = player->origin;
|
||||
|
@ -48,18 +48,18 @@ void Draw_Triangles( void )
|
|||
org.x += 50;
|
||||
org.y += 50;
|
||||
|
||||
if (gHUD.m_hsprCursor == 0)
|
||||
if( gHUD.m_hsprCursor == 0 )
|
||||
{
|
||||
char sz[256];
|
||||
sprintf( sz, "sprites/cursor.spr" );
|
||||
gHUD.m_hsprCursor = SPR_Load( sz );
|
||||
}
|
||||
|
||||
if ( !gEngfuncs.pTriAPI->SpriteTexture( (struct model_s *)gEngfuncs.GetSpritePointer( gHUD.m_hsprCursor ), 0 ))
|
||||
if( !gEngfuncs.pTriAPI->SpriteTexture( (struct model_s *)gEngfuncs.GetSpritePointer( gHUD.m_hsprCursor ), 0 ) )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
// Create a triangle, sigh
|
||||
gEngfuncs.pTriAPI->RenderMode( kRenderNormal );
|
||||
gEngfuncs.pTriAPI->CullFace( TRI_NONE );
|
||||
|
@ -86,7 +86,6 @@ void Draw_Triangles( void )
|
|||
gEngfuncs.pTriAPI->End();
|
||||
gEngfuncs.pTriAPI->RenderMode( kRenderNormal );
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
/*
|
||||
|
@ -98,9 +97,7 @@ Non-transparent triangles-- add them here
|
|||
*/
|
||||
void DLLEXPORT HUD_DrawNormalTriangles( void )
|
||||
{
|
||||
|
||||
gHUD.m_Spectator.DrawOverview();
|
||||
|
||||
#if defined( TEST_IT )
|
||||
// Draw_Triangles();
|
||||
#endif
|
||||
|
@ -115,7 +112,6 @@ Render any triangles with transparent rendermode needs here
|
|||
*/
|
||||
void DLLEXPORT HUD_DrawTransparentTriangles( void )
|
||||
{
|
||||
|
||||
#if defined( TEST_IT )
|
||||
// Draw_Triangles();
|
||||
#endif
|
||||
|
|
|
@ -32,102 +32,100 @@
|
|||
|
||||
extern vec3_t vec3_origin;
|
||||
|
||||
double sqrt(double x);
|
||||
double sqrt( double x );
|
||||
|
||||
float Length(const float *v)
|
||||
float Length( const float *v )
|
||||
{
|
||||
int i;
|
||||
int i;
|
||||
float length;
|
||||
|
||||
|
||||
length = 0;
|
||||
for (i=0 ; i< 3 ; i++)
|
||||
length += v[i]*v[i];
|
||||
length = sqrt (length); // FIXME
|
||||
for( i = 0; i < 3; i++ )
|
||||
length += v[i] * v[i];
|
||||
length = sqrt( length ); // FIXME
|
||||
|
||||
return length;
|
||||
}
|
||||
|
||||
void VectorAngles( const float *forward, float *angles )
|
||||
{
|
||||
float tmp, yaw, pitch;
|
||||
|
||||
if (forward[1] == 0 && forward[0] == 0)
|
||||
float tmp, yaw, pitch;
|
||||
|
||||
if( forward[1] == 0 && forward[0] == 0 )
|
||||
{
|
||||
yaw = 0;
|
||||
if (forward[2] > 0)
|
||||
if( forward[2] > 0 )
|
||||
pitch = 90;
|
||||
else
|
||||
pitch = 270;
|
||||
}
|
||||
else
|
||||
{
|
||||
yaw = (atan2(forward[1], forward[0]) * 180 / M_PI);
|
||||
if (yaw < 0)
|
||||
yaw = ( atan2( forward[1], forward[0]) * 180 / M_PI );
|
||||
if( yaw < 0 )
|
||||
yaw += 360;
|
||||
|
||||
tmp = sqrt (forward[0]*forward[0] + forward[1]*forward[1]);
|
||||
pitch = (atan2(forward[2], tmp) * 180 / M_PI);
|
||||
if (pitch < 0)
|
||||
tmp = sqrt( forward[0] * forward[0] + forward[1] * forward[1] );
|
||||
pitch = ( atan2( forward[2], tmp ) * 180 / M_PI );
|
||||
if( pitch < 0 )
|
||||
pitch += 360;
|
||||
}
|
||||
|
||||
|
||||
angles[0] = pitch;
|
||||
angles[1] = yaw;
|
||||
angles[2] = 0;
|
||||
}
|
||||
|
||||
float VectorNormalize (float *v)
|
||||
float VectorNormalize( float *v )
|
||||
{
|
||||
float length, ilength;
|
||||
float length, ilength;
|
||||
|
||||
length = v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
|
||||
length = sqrt (length); // FIXME
|
||||
length = v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
|
||||
length = sqrt( length ); // FIXME
|
||||
|
||||
if (length)
|
||||
if( length )
|
||||
{
|
||||
ilength = 1/length;
|
||||
ilength = 1 / length;
|
||||
v[0] *= ilength;
|
||||
v[1] *= ilength;
|
||||
v[2] *= ilength;
|
||||
}
|
||||
|
||||
return length;
|
||||
|
||||
return length;
|
||||
}
|
||||
|
||||
void VectorInverse ( float *v )
|
||||
void VectorInverse( float *v )
|
||||
{
|
||||
v[0] = -v[0];
|
||||
v[1] = -v[1];
|
||||
v[2] = -v[2];
|
||||
}
|
||||
|
||||
void VectorScale (const float *in, float scale, float *out)
|
||||
void VectorScale( const float *in, float scale, float *out )
|
||||
{
|
||||
out[0] = in[0]*scale;
|
||||
out[1] = in[1]*scale;
|
||||
out[2] = in[2]*scale;
|
||||
out[0] = in[0] * scale;
|
||||
out[1] = in[1] * scale;
|
||||
out[2] = in[2] * scale;
|
||||
}
|
||||
|
||||
void VectorMA (const float *veca, float scale, const float *vecb, float *vecc)
|
||||
void VectorMA( const float *veca, float scale, const float *vecb, float *vecc )
|
||||
{
|
||||
vecc[0] = veca[0] + scale*vecb[0];
|
||||
vecc[1] = veca[1] + scale*vecb[1];
|
||||
vecc[2] = veca[2] + scale*vecb[2];
|
||||
vecc[0] = veca[0] + scale * vecb[0];
|
||||
vecc[1] = veca[1] + scale * vecb[1];
|
||||
vecc[2] = veca[2] + scale * vecb[2];
|
||||
}
|
||||
|
||||
HSPRITE LoadSprite(const char *pszName)
|
||||
HSPRITE LoadSprite( const char *pszName )
|
||||
{
|
||||
int i;
|
||||
char sz[256];
|
||||
char sz[256];
|
||||
|
||||
if (ScreenWidth < 640)
|
||||
if( ScreenWidth < 640 )
|
||||
i = 320;
|
||||
else
|
||||
i = 640;
|
||||
|
||||
sprintf(sz, pszName, i);
|
||||
sprintf( sz, pszName, i );
|
||||
|
||||
return SPR_Load(sz);
|
||||
return SPR_Load( sz );
|
||||
}
|
||||
|
||||
|
|
|
@ -22,8 +22,8 @@
|
|||
#include "math.h"
|
||||
|
||||
// Header file containing definition of globalvars_t and entvars_t
|
||||
typedef unsigned int func_t; //
|
||||
typedef unsigned int string_t; // from engine's pr_comp.h;
|
||||
typedef unsigned int func_t; //
|
||||
typedef unsigned int string_t; // from engine's pr_comp.h;
|
||||
typedef float vec_t; // needed before including progdefs.h
|
||||
|
||||
//=========================================================
|
||||
|
@ -33,21 +33,21 @@ typedef float vec_t; // needed before including progdefs.h
|
|||
class Vector2D
|
||||
{
|
||||
public:
|
||||
inline Vector2D(void) { }
|
||||
inline Vector2D(float X, float Y) { x = X; y = Y; }
|
||||
inline Vector2D operator+(const Vector2D& v) const { return Vector2D(x+v.x, y+v.y); }
|
||||
inline Vector2D operator-(const Vector2D& v) const { return Vector2D(x-v.x, y-v.y); }
|
||||
inline Vector2D operator*(float fl) const { return Vector2D(x*fl, y*fl); }
|
||||
inline Vector2D operator/(float fl) const { return Vector2D(x/fl, y/fl); }
|
||||
|
||||
inline float Length(void) const { return (float)sqrt(x*x + y*y ); }
|
||||
inline Vector2D( void ) { }
|
||||
inline Vector2D( float X, float Y ) { x = X; y = Y; }
|
||||
inline Vector2D operator+( const Vector2D& v ) const { return Vector2D(x+v.x, y+v.y); }
|
||||
inline Vector2D operator-( const Vector2D& v ) const { return Vector2D(x-v.x, y-v.y); }
|
||||
inline Vector2D operator*( float fl ) const { return Vector2D(x*fl, y*fl); }
|
||||
inline Vector2D operator/( float fl ) const { return Vector2D(x/fl, y/fl); }
|
||||
|
||||
inline Vector2D Normalize ( void ) const
|
||||
inline float Length( void ) const { return (float)sqrt(x*x + y*y ); }
|
||||
|
||||
inline Vector2D Normalize( void ) const
|
||||
{
|
||||
Vector2D vec2;
|
||||
|
||||
float flLen = Length();
|
||||
if ( flLen == 0 )
|
||||
if( flLen == 0 )
|
||||
{
|
||||
return Vector2D( (float)0, (float)0 );
|
||||
}
|
||||
|
@ -61,61 +61,66 @@ public:
|
|||
vec_t x, y;
|
||||
};
|
||||
|
||||
inline float DotProduct(const Vector2D& a, const Vector2D& b) { return( a.x*b.x + a.y*b.y ); }
|
||||
inline Vector2D operator*(float fl, const Vector2D& v) { return v * fl; }
|
||||
inline float DotProduct( const Vector2D& a, const Vector2D& b ) { return( a.x * b.x + a.y * b.y ); }
|
||||
inline Vector2D operator*( float fl, const Vector2D& v ) { return v * fl; }
|
||||
|
||||
//=========================================================
|
||||
// 3D Vector
|
||||
//=========================================================
|
||||
class Vector // same data-layout as engine's vec3_t,
|
||||
{ // which is a vec_t[3]
|
||||
{ //which is a vec_t[3]
|
||||
public:
|
||||
// Construction/destruction
|
||||
inline Vector(void) { }
|
||||
inline Vector(float X, float Y, float Z) { x = X; y = Y; z = Z; }
|
||||
inline Vector(double X, double Y, double Z) { x = (float)X; y = (float)Y; z = (float)Z; }
|
||||
inline Vector(int X, int Y, int Z) { x = (float)X; y = (float)Y; z = (float)Z; }
|
||||
inline Vector(const Vector& v) { x = v.x; y = v.y; z = v.z; }
|
||||
inline Vector(float rgfl[3]) { x = rgfl[0]; y = rgfl[1]; z = rgfl[2]; }
|
||||
inline Vector( void ) { }
|
||||
inline Vector( float X, float Y, float Z ) { x = X; y = Y; z = Z; }
|
||||
inline Vector( double X, double Y, double Z ) { x = (float)X; y = (float)Y; z = (float)Z; }
|
||||
inline Vector( int X, int Y, int Z ) { x = (float)X; y = (float)Y; z = (float)Z; }
|
||||
inline Vector( const Vector& v ) { x = v.x; y = v.y; z = v.z; }
|
||||
inline Vector( float rgfl[3] ) { x = rgfl[0]; y = rgfl[1]; z = rgfl[2]; }
|
||||
|
||||
// Operators
|
||||
inline Vector operator-(void) const { return Vector(-x,-y,-z); }
|
||||
inline int operator==(const Vector& v) const { return x==v.x && y==v.y && z==v.z; }
|
||||
inline int operator!=(const Vector& v) const { return !(*this==v); }
|
||||
inline Vector operator+(const Vector& v) const { return Vector(x+v.x, y+v.y, z+v.z); }
|
||||
inline Vector operator-(const Vector& v) const { return Vector(x-v.x, y-v.y, z-v.z); }
|
||||
inline Vector operator*(float fl) const { return Vector(x*fl, y*fl, z*fl); }
|
||||
inline Vector operator/(float fl) const { return Vector(x/fl, y/fl, z/fl); }
|
||||
inline Vector operator-( void ) const { return Vector( -x, -y, -z ); }
|
||||
inline int operator==( const Vector& v ) const { return x == v.x && y == v.y && z == v.z; }
|
||||
inline int operator!=( const Vector& v ) const { return !( *this == v ); }
|
||||
inline Vector operator+( const Vector& v ) const { return Vector( x + v.x, y + v.y, z + v.z ); }
|
||||
inline Vector operator-( const Vector& v ) const { return Vector( x - v.x, y - v.y, z - v.z ); }
|
||||
inline Vector operator*( float fl ) const { return Vector( x * fl, y * fl, z * fl ); }
|
||||
inline Vector operator/( float fl ) const { return Vector( x / fl, y / fl, z / fl ); }
|
||||
|
||||
// Methods
|
||||
inline void CopyToArray(float* rgfl) const { rgfl[0] = x, rgfl[1] = y, rgfl[2] = z; }
|
||||
inline float Length(void) const { return (float)sqrt(x*x + y*y + z*z); }
|
||||
operator float *() { return &x; } // Vectors will now automatically convert to float * when needed
|
||||
operator const float *() const { return &x; } // Vectors will now automatically convert to float * when needed
|
||||
inline Vector Normalize(void) const
|
||||
inline void CopyToArray( float* rgfl ) const { rgfl[0] = x, rgfl[1] = y, rgfl[2] = z; }
|
||||
inline float Length( void ) const { return (float)sqrt( x * x + y * y + z * z); }
|
||||
operator float *() { return &x; } // Vectors will now automatically convert to float * when needed
|
||||
operator const float *() const { return &x; } // Vectors will now automatically convert to float * when needed
|
||||
inline Vector Normalize( void ) const
|
||||
{
|
||||
float flLen = Length();
|
||||
if (flLen == 0) return Vector(0,0,1); // ????
|
||||
if( flLen == 0 ) return Vector( 0, 0, 1); // ????
|
||||
flLen = 1 / flLen;
|
||||
return Vector(x * flLen, y * flLen, z * flLen);
|
||||
return Vector( x * flLen, y * flLen, z * flLen );
|
||||
}
|
||||
|
||||
inline Vector2D Make2D ( void ) const
|
||||
inline Vector2D Make2D( void ) const
|
||||
{
|
||||
Vector2D Vec2;
|
||||
Vector2D Vec2;
|
||||
|
||||
Vec2.x = x;
|
||||
Vec2.y = y;
|
||||
|
||||
return Vec2;
|
||||
}
|
||||
inline float Length2D(void) const { return (float)sqrt(x*x + y*y); }
|
||||
|
||||
inline float Length2D( void ) const
|
||||
{
|
||||
return (float)sqrt( x * x + y * y );
|
||||
}
|
||||
|
||||
// Members
|
||||
vec_t x, y, z;
|
||||
};
|
||||
inline Vector operator*(float fl, const Vector& v) { return v * fl; }
|
||||
inline float DotProduct(const Vector& a, const Vector& b) { return(a.x*b.x+a.y*b.y+a.z*b.z); }
|
||||
inline Vector CrossProduct(const Vector& a, const Vector& b) { return Vector( a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y - a.y*b.x ); }
|
||||
|
||||
inline Vector operator*( float fl, const Vector& v ) { return v * fl; }
|
||||
inline float DotProduct( const Vector& a, const Vector& b) { return( a.x * b.x + a.y * b.y + a.z * b.z ); }
|
||||
inline Vector CrossProduct(const Vector& a, const Vector& b) { return Vector( a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x ); }
|
||||
|
||||
#define vec3_t Vector
|
||||
|
|
1020
cl_dll/view.cpp
1020
cl_dll/view.cpp
File diff suppressed because it is too large
Load Diff
|
@ -11,5 +11,4 @@
|
|||
|
||||
void V_StartPitchDrift( void );
|
||||
void V_StopPitchDrift( void );
|
||||
|
||||
#endif // !VIEWH
|
||||
#endif // !VIEWH
|
||||
|
|
|
@ -119,7 +119,7 @@ enum
|
|||
AMBIENT_SKY, // wind
|
||||
AMBIENT_SLIME, // never used in quake
|
||||
AMBIENT_LAVA, // never used in quake
|
||||
NUM_AMBIENTS, // automatic ambient sounds
|
||||
NUM_AMBIENTS // automatic ambient sounds
|
||||
};
|
||||
|
||||
//
|
||||
|
@ -243,4 +243,4 @@ typedef struct
|
|||
int lightofs; // start of [numstyles*surfsize] samples
|
||||
} dface_t;
|
||||
|
||||
#endif//BSPFILE_H
|
||||
#endif//BSPFILE_H
|
||||
|
|
|
@ -699,7 +699,7 @@ enum
|
|||
kRenderGlow, // src*a+dest -- No Z buffer checks
|
||||
kRenderTransAlpha, // src*srca+dest*(1-srca)
|
||||
kRenderTransAdd, // src*a+dest
|
||||
kRenderWorldGlow, // Same as kRenderGlow but not fixed size in screen space
|
||||
kRenderWorldGlow // Same as kRenderGlow but not fixed size in screen space
|
||||
};
|
||||
|
||||
enum
|
||||
|
@ -724,7 +724,7 @@ enum
|
|||
kRenderFxDeadPlayer, // kRenderAmt is the player index
|
||||
kRenderFxExplode, // Scale up really big!
|
||||
kRenderFxGlowShell, // Glowing Shell
|
||||
kRenderFxClampMinScale, // Keep this sprite from getting very small (SPRITES only!)
|
||||
kRenderFxClampMinScale // Keep this sprite from getting very small (SPRITES only!)
|
||||
};
|
||||
|
||||
typedef unsigned int func_t;
|
||||
|
@ -777,4 +777,4 @@ typedef struct
|
|||
int hitgroup; // 0 == generic, non zero is specific body part
|
||||
} trace_t;
|
||||
|
||||
#endif//CONST_H
|
||||
#endif//CONST_H
|
||||
|
|
|
@ -19,7 +19,7 @@
|
|||
typedef enum
|
||||
{
|
||||
TRI_FRONT = 0,
|
||||
TRI_NONE = 1,
|
||||
TRI_NONE = 1
|
||||
} TRICULLSTYLE;
|
||||
|
||||
#define TRI_API_VERSION 1
|
||||
|
@ -59,4 +59,4 @@ typedef struct triangleapi_s
|
|||
void (*FogParams)( float flDensity, int iFogSkybox );
|
||||
} triangleapi_t;
|
||||
|
||||
#endif//TRIANGLEAPI_H
|
||||
#endif//TRIANGLEAPI_H
|
||||
|
|
|
@ -65,8 +65,8 @@ LOCAL_SRC_FILES := agrunt.cpp airtank.cpp \
|
|||
gman.cpp \
|
||||
h_ai.cpp \
|
||||
h_battery.cpp \
|
||||
h_cine.cpp \
|
||||
h_cycler.cpp \
|
||||
h_cine.cpp \
|
||||
h_export.cpp \
|
||||
handgrenade.cpp \
|
||||
hassassin.cpp \
|
||||
|
@ -114,8 +114,8 @@ LOCAL_SRC_FILES := agrunt.cpp airtank.cpp \
|
|||
subs.cpp \
|
||||
talkmonster.cpp \
|
||||
teamplay_gamerules.cpp \
|
||||
tempmonster.cpp \
|
||||
tentacle.cpp \
|
||||
tempentity.cpp \
|
||||
triggers.cpp \
|
||||
tripmine.cpp \
|
||||
turret.cpp \
|
||||
|
|
|
@ -16,7 +16,6 @@
|
|||
#ifndef ACTIVITY_H
|
||||
#define ACTIVITY_H
|
||||
|
||||
|
||||
typedef enum {
|
||||
ACT_RESET = 0, // Set m_Activity to this invalid value to force a reset to m_IdealActivity
|
||||
ACT_IDLE = 1,
|
||||
|
@ -94,16 +93,14 @@ typedef enum {
|
|||
ACT_FLINCH_LEFTARM,
|
||||
ACT_FLINCH_RIGHTARM,
|
||||
ACT_FLINCH_LEFTLEG,
|
||||
ACT_FLINCH_RIGHTLEG,
|
||||
ACT_FLINCH_RIGHTLEG
|
||||
} Activity;
|
||||
|
||||
|
||||
typedef struct {
|
||||
int type;
|
||||
typedef struct
|
||||
{
|
||||
int type;
|
||||
char *name;
|
||||
} activity_map_t;
|
||||
|
||||
extern activity_map_t activity_map[];
|
||||
|
||||
|
||||
#endif //ACTIVITY_H
|
||||
|
|
445
dlls/aflock.cpp
445
dlls/aflock.cpp
|
@ -14,13 +14,14 @@
|
|||
****/
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
|
||||
#include "extdll.h"
|
||||
#include "util.h"
|
||||
#include "cbase.h"
|
||||
#include "monsters.h"
|
||||
#include "squadmonster.h"
|
||||
|
||||
#define AFLOCK_MAX_RECRUIT_RADIUS 1024
|
||||
#define AFLOCK_MAX_RECRUIT_RADIUS 1024
|
||||
#define AFLOCK_FLY_SPEED 125
|
||||
#define AFLOCK_TURN_RATE 75
|
||||
#define AFLOCK_ACCELERATE 10
|
||||
|
@ -38,24 +39,24 @@ public:
|
|||
void KeyValue( KeyValueData *pkvd );
|
||||
void SpawnFlock( void );
|
||||
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
static TYPEDESCRIPTION m_SaveData[];
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
static TYPEDESCRIPTION m_SaveData[];
|
||||
|
||||
// Sounds are shared by the flock
|
||||
static void PrecacheFlockSounds( void );
|
||||
static void PrecacheFlockSounds( void );
|
||||
|
||||
int m_cFlockSize;
|
||||
float m_flFlockRadius;
|
||||
int m_cFlockSize;
|
||||
float m_flFlockRadius;
|
||||
};
|
||||
|
||||
TYPEDESCRIPTION CFlockingFlyerFlock::m_SaveData[] =
|
||||
TYPEDESCRIPTION CFlockingFlyerFlock::m_SaveData[] =
|
||||
{
|
||||
DEFINE_FIELD( CFlockingFlyerFlock, m_cFlockSize, FIELD_INTEGER ),
|
||||
DEFINE_FIELD( CFlockingFlyerFlock, m_flFlockRadius, FIELD_FLOAT ),
|
||||
};
|
||||
|
||||
IMPLEMENT_SAVERESTORE( CFlockingFlyerFlock, CBaseMonster );
|
||||
IMPLEMENT_SAVERESTORE( CFlockingFlyerFlock, CBaseMonster )
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
|
@ -81,13 +82,13 @@ public:
|
|||
BOOL FPathBlocked( void );
|
||||
//void KeyValue( KeyValueData *pkvd );
|
||||
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
static TYPEDESCRIPTION m_SaveData[];
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
static TYPEDESCRIPTION m_SaveData[];
|
||||
|
||||
int IsLeader( void ) { return m_pSquadLeader == this; }
|
||||
int InSquad( void ) { return m_pSquadLeader != NULL; }
|
||||
int SquadCount( void );
|
||||
int InSquad( void ) { return m_pSquadLeader != NULL; }
|
||||
int SquadCount( void );
|
||||
void SquadRemove( CFlockingFlyer *pRemove );
|
||||
void SquadUnlink( void );
|
||||
void SquadAdd( CFlockingFlyer *pAdd );
|
||||
|
@ -95,21 +96,22 @@ public:
|
|||
|
||||
CFlockingFlyer *m_pSquadLeader;
|
||||
CFlockingFlyer *m_pSquadNext;
|
||||
BOOL m_fTurning;// is this boid turning?
|
||||
BOOL m_fCourseAdjust;// followers set this flag TRUE to override flocking while they avoid something
|
||||
BOOL m_fPathBlocked;// TRUE if there is an obstacle ahead
|
||||
Vector m_vecReferencePoint;// last place we saw leader
|
||||
Vector m_vecAdjustedVelocity;// adjusted velocity (used when fCourseAdjust is TRUE)
|
||||
float m_flGoalSpeed;
|
||||
float m_flLastBlockedTime;
|
||||
float m_flFakeBlockedTime;
|
||||
float m_flAlertTime;
|
||||
float m_flFlockNextSoundTime;
|
||||
BOOL m_fTurning;// is this boid turning?
|
||||
BOOL m_fCourseAdjust;// followers set this flag TRUE to override flocking while they avoid something
|
||||
BOOL m_fPathBlocked;// TRUE if there is an obstacle ahead
|
||||
Vector m_vecReferencePoint;// last place we saw leader
|
||||
Vector m_vecAdjustedVelocity;// adjusted velocity (used when fCourseAdjust is TRUE)
|
||||
float m_flGoalSpeed;
|
||||
float m_flLastBlockedTime;
|
||||
float m_flFakeBlockedTime;
|
||||
float m_flAlertTime;
|
||||
float m_flFlockNextSoundTime;
|
||||
};
|
||||
LINK_ENTITY_TO_CLASS( monster_flyer, CFlockingFlyer );
|
||||
LINK_ENTITY_TO_CLASS( monster_flyer_flock, CFlockingFlyerFlock );
|
||||
|
||||
TYPEDESCRIPTION CFlockingFlyer::m_SaveData[] =
|
||||
LINK_ENTITY_TO_CLASS( monster_flyer, CFlockingFlyer )
|
||||
LINK_ENTITY_TO_CLASS( monster_flyer_flock, CFlockingFlyerFlock )
|
||||
|
||||
TYPEDESCRIPTION CFlockingFlyer::m_SaveData[] =
|
||||
{
|
||||
DEFINE_FIELD( CFlockingFlyer, m_pSquadLeader, FIELD_CLASSPTR ),
|
||||
DEFINE_FIELD( CFlockingFlyer, m_pSquadNext, FIELD_CLASSPTR ),
|
||||
|
@ -122,60 +124,59 @@ TYPEDESCRIPTION CFlockingFlyer::m_SaveData[] =
|
|||
DEFINE_FIELD( CFlockingFlyer, m_flLastBlockedTime, FIELD_TIME ),
|
||||
DEFINE_FIELD( CFlockingFlyer, m_flFakeBlockedTime, FIELD_TIME ),
|
||||
DEFINE_FIELD( CFlockingFlyer, m_flAlertTime, FIELD_TIME ),
|
||||
// DEFINE_FIELD( CFlockingFlyer, m_flFlockNextSoundTime, FIELD_TIME ), // don't need to save
|
||||
//DEFINE_FIELD( CFlockingFlyer, m_flFlockNextSoundTime, FIELD_TIME ), // don't need to save
|
||||
};
|
||||
|
||||
IMPLEMENT_SAVERESTORE( CFlockingFlyer, CBaseMonster );
|
||||
IMPLEMENT_SAVERESTORE( CFlockingFlyer, CBaseMonster )
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CFlockingFlyerFlock :: KeyValue( KeyValueData *pkvd )
|
||||
void CFlockingFlyerFlock::KeyValue( KeyValueData *pkvd )
|
||||
{
|
||||
if (FStrEq(pkvd->szKeyName, "iFlockSize"))
|
||||
if( FStrEq( pkvd->szKeyName, "iFlockSize" ) )
|
||||
{
|
||||
m_cFlockSize = atoi(pkvd->szValue);
|
||||
m_cFlockSize = atoi( pkvd->szValue );
|
||||
pkvd->fHandled = TRUE;
|
||||
}
|
||||
else if (FStrEq(pkvd->szKeyName, "flFlockRadius"))
|
||||
else if( FStrEq( pkvd->szKeyName, "flFlockRadius" ) )
|
||||
{
|
||||
m_flFlockRadius = atof(pkvd->szValue);
|
||||
m_flFlockRadius = atof( pkvd->szValue );
|
||||
pkvd->fHandled = TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CFlockingFlyerFlock :: Spawn( )
|
||||
void CFlockingFlyerFlock::Spawn()
|
||||
{
|
||||
Precache( );
|
||||
Precache();
|
||||
SpawnFlock();
|
||||
|
||||
REMOVE_ENTITY(ENT(pev)); // dump the spawn ent
|
||||
REMOVE_ENTITY( ENT( pev ) ); // dump the spawn ent
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CFlockingFlyerFlock :: Precache( )
|
||||
void CFlockingFlyerFlock::Precache()
|
||||
{
|
||||
//PRECACHE_MODEL("models/aflock.mdl");
|
||||
PRECACHE_MODEL("models/boid.mdl");
|
||||
//PRECACHE_MODEL( "models/aflock.mdl" );
|
||||
PRECACHE_MODEL( "models/boid.mdl ");
|
||||
|
||||
PrecacheFlockSounds();
|
||||
}
|
||||
|
||||
|
||||
void CFlockingFlyerFlock :: PrecacheFlockSounds( void )
|
||||
void CFlockingFlyerFlock::PrecacheFlockSounds( void )
|
||||
{
|
||||
PRECACHE_SOUND("boid/boid_alert1.wav" );
|
||||
PRECACHE_SOUND("boid/boid_alert2.wav" );
|
||||
PRECACHE_SOUND( "boid/boid_alert1.wav" );
|
||||
PRECACHE_SOUND( "boid/boid_alert2.wav" );
|
||||
|
||||
PRECACHE_SOUND("boid/boid_idle1.wav" );
|
||||
PRECACHE_SOUND("boid/boid_idle2.wav" );
|
||||
PRECACHE_SOUND( "boid/boid_idle1.wav" );
|
||||
PRECACHE_SOUND( "boid/boid_idle2.wav" );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CFlockingFlyerFlock :: SpawnFlock( void )
|
||||
void CFlockingFlyerFlock::SpawnFlock( void )
|
||||
{
|
||||
float R = m_flFlockRadius;
|
||||
int iCount;
|
||||
|
@ -184,15 +185,15 @@ void CFlockingFlyerFlock :: SpawnFlock( void )
|
|||
|
||||
pLeader = pBoid = NULL;
|
||||
|
||||
for ( iCount = 0 ; iCount < m_cFlockSize ; iCount++ )
|
||||
for( iCount = 0; iCount < m_cFlockSize; iCount++ )
|
||||
{
|
||||
pBoid = GetClassPtr( (CFlockingFlyer *)NULL );
|
||||
|
||||
if ( !pLeader )
|
||||
if( !pLeader )
|
||||
{
|
||||
// make this guy the leader.
|
||||
pLeader = pBoid;
|
||||
|
||||
|
||||
pLeader->m_pSquadLeader = pLeader;
|
||||
pLeader->m_pSquadNext = NULL;
|
||||
}
|
||||
|
@ -202,18 +203,18 @@ void CFlockingFlyerFlock :: SpawnFlock( void )
|
|||
vecSpot.z = RANDOM_FLOAT( 0, 16 );
|
||||
vecSpot = pev->origin + vecSpot;
|
||||
|
||||
UTIL_SetOrigin(pBoid->pev, vecSpot);
|
||||
UTIL_SetOrigin( pBoid->pev, vecSpot );
|
||||
pBoid->pev->movetype = MOVETYPE_FLY;
|
||||
pBoid->SpawnCommonCode();
|
||||
pBoid->pev->flags &= ~FL_ONGROUND;
|
||||
pBoid->pev->velocity = g_vecZero;
|
||||
pBoid->pev->angles = pev->angles;
|
||||
|
||||
pBoid->pev->angles = pev->angles;
|
||||
|
||||
pBoid->pev->frame = 0;
|
||||
pBoid->pev->nextthink = gpGlobals->time + 0.2;
|
||||
pBoid->SetThink( &CFlockingFlyer :: IdleThink );
|
||||
pBoid->SetThink( &CFlockingFlyer::IdleThink );
|
||||
|
||||
if ( pBoid != pLeader )
|
||||
if( pBoid != pLeader )
|
||||
{
|
||||
pLeader->SquadAdd( pBoid );
|
||||
}
|
||||
|
@ -222,11 +223,11 @@ void CFlockingFlyerFlock :: SpawnFlock( void )
|
|||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CFlockingFlyer :: Spawn( )
|
||||
void CFlockingFlyer::Spawn()
|
||||
{
|
||||
Precache( );
|
||||
Precache();
|
||||
SpawnCommonCode();
|
||||
|
||||
|
||||
pev->frame = 0;
|
||||
pev->nextthink = gpGlobals->time + 0.1;
|
||||
SetThink( &CFlockingFlyer::IdleThink );
|
||||
|
@ -234,52 +235,60 @@ void CFlockingFlyer :: Spawn( )
|
|||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CFlockingFlyer :: Precache( )
|
||||
void CFlockingFlyer::Precache()
|
||||
{
|
||||
//PRECACHE_MODEL("models/aflock.mdl");
|
||||
PRECACHE_MODEL("models/boid.mdl");
|
||||
//PRECACHE_MODEL( "models/aflock.mdl" );
|
||||
PRECACHE_MODEL( "models/boid.mdl" );
|
||||
CFlockingFlyerFlock::PrecacheFlockSounds();
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CFlockingFlyer :: MakeSound( void )
|
||||
void CFlockingFlyer::MakeSound( void )
|
||||
{
|
||||
if ( m_flAlertTime > gpGlobals->time )
|
||||
if( m_flAlertTime > gpGlobals->time )
|
||||
{
|
||||
// make agitated sounds
|
||||
switch ( RANDOM_LONG( 0, 1 ) )
|
||||
{
|
||||
case 0: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "boid/boid_alert1.wav", 1, ATTN_NORM ); break;
|
||||
case 1: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "boid/boid_alert2.wav", 1, ATTN_NORM ); break;
|
||||
case 0:
|
||||
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "boid/boid_alert1.wav", 1, ATTN_NORM );
|
||||
break;
|
||||
case 1:
|
||||
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "boid/boid_alert2.wav", 1, ATTN_NORM );
|
||||
break;
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
// make normal sound
|
||||
switch ( RANDOM_LONG( 0, 1 ) )
|
||||
switch( RANDOM_LONG( 0, 1 ) )
|
||||
{
|
||||
case 0: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "boid/boid_idle1.wav", 1, ATTN_NORM ); break;
|
||||
case 1: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "boid/boid_idle2.wav", 1, ATTN_NORM ); break;
|
||||
case 0:
|
||||
EMIT_SOUND( ENT(pev), CHAN_WEAPON, "boid/boid_idle1.wav", 1, ATTN_NORM );
|
||||
break;
|
||||
case 1:
|
||||
EMIT_SOUND( ENT(pev), CHAN_WEAPON, "boid/boid_idle2.wav", 1, ATTN_NORM );
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CFlockingFlyer :: Killed( entvars_t *pevAttacker, int iGib )
|
||||
void CFlockingFlyer::Killed( entvars_t *pevAttacker, int iGib )
|
||||
{
|
||||
CFlockingFlyer *pSquad;
|
||||
|
||||
|
||||
pSquad = (CFlockingFlyer *)m_pSquadLeader;
|
||||
|
||||
while ( pSquad )
|
||||
while( pSquad )
|
||||
{
|
||||
pSquad->m_flAlertTime = gpGlobals->time + 15;
|
||||
pSquad = (CFlockingFlyer *)pSquad->m_pSquadNext;
|
||||
}
|
||||
|
||||
if ( m_pSquadLeader )
|
||||
if( m_pSquadLeader )
|
||||
{
|
||||
m_pSquadLeader->SquadRemove( this );
|
||||
}
|
||||
|
@ -289,18 +298,18 @@ void CFlockingFlyer :: Killed( entvars_t *pevAttacker, int iGib )
|
|||
pev->framerate = 0;
|
||||
pev->effects = EF_NOINTERP;
|
||||
|
||||
UTIL_SetSize( pev, Vector(0,0,0), Vector(0,0,0) );
|
||||
UTIL_SetSize( pev, Vector( 0, 0, 0 ), Vector( 0, 0, 0 ) );
|
||||
pev->movetype = MOVETYPE_TOSS;
|
||||
|
||||
SetThink( &CFlockingFlyer::FallHack );
|
||||
pev->nextthink = gpGlobals->time + 0.1;
|
||||
}
|
||||
|
||||
void CFlockingFlyer :: FallHack( void )
|
||||
void CFlockingFlyer::FallHack( void )
|
||||
{
|
||||
if ( pev->flags & FL_ONGROUND )
|
||||
if( pev->flags & FL_ONGROUND )
|
||||
{
|
||||
if ( !FClassnameIs ( pev->groundentity, "worldspawn" ) )
|
||||
if( !FClassnameIs ( pev->groundentity, "worldspawn" ) )
|
||||
{
|
||||
pev->flags &= ~FL_ONGROUND;
|
||||
pev->nextthink = gpGlobals->time + 0.1;
|
||||
|
@ -315,56 +324,59 @@ void CFlockingFlyer :: FallHack( void )
|
|||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CFlockingFlyer :: SpawnCommonCode( )
|
||||
void CFlockingFlyer::SpawnCommonCode()
|
||||
{
|
||||
pev->deadflag = DEAD_NO;
|
||||
pev->classname = MAKE_STRING("monster_flyer");
|
||||
pev->solid = SOLID_SLIDEBOX;
|
||||
pev->movetype = MOVETYPE_FLY;
|
||||
pev->deadflag = DEAD_NO;
|
||||
pev->classname = MAKE_STRING( "monster_flyer" );
|
||||
pev->solid = SOLID_SLIDEBOX;
|
||||
pev->movetype = MOVETYPE_FLY;
|
||||
pev->takedamage = DAMAGE_NO;
|
||||
pev->health = 1;
|
||||
pev->health = 1;
|
||||
|
||||
m_fPathBlocked = FALSE;// obstacles will be detected
|
||||
m_flFieldOfView = 0.2;
|
||||
|
||||
//SET_MODEL(ENT(pev), "models/aflock.mdl");
|
||||
SET_MODEL(ENT(pev), "models/boid.mdl");
|
||||
//SET_MODEL( ENT( pev ), "models/aflock.mdl" );
|
||||
SET_MODEL( ENT( pev ), "models/boid.mdl" );
|
||||
|
||||
// UTIL_SetSize(pev, Vector(0,0,0), Vector(0,0,0));
|
||||
UTIL_SetSize(pev, Vector(-5,-5,0), Vector(5,5,2));
|
||||
//UTIL_SetSize( pev, Vector( 0, 0, 0 ), Vector( 0, 0, 0 ) );
|
||||
UTIL_SetSize( pev, Vector( -5, -5, 0 ), Vector( 5, 5, 2 ) );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CFlockingFlyer :: BoidAdvanceFrame ( )
|
||||
void CFlockingFlyer::BoidAdvanceFrame()
|
||||
{
|
||||
float flapspeed = (pev->speed - pev->armorvalue) / AFLOCK_ACCELERATE;
|
||||
float flapspeed = ( pev->speed - pev->armorvalue ) / AFLOCK_ACCELERATE;
|
||||
pev->armorvalue = pev->armorvalue * .8 + pev->speed * .2;
|
||||
|
||||
if (flapspeed < 0) flapspeed = -flapspeed;
|
||||
if (flapspeed < 0.25) flapspeed = 0.25;
|
||||
if (flapspeed > 1.9) flapspeed = 1.9;
|
||||
if( flapspeed < 0 )
|
||||
flapspeed = -flapspeed;
|
||||
if( flapspeed < 0.25 )
|
||||
flapspeed = 0.25;
|
||||
if( flapspeed > 1.9 )
|
||||
flapspeed = 1.9;
|
||||
|
||||
pev->framerate = flapspeed;
|
||||
|
||||
// lean
|
||||
pev->avelocity.x = - (pev->angles.x + flapspeed * 5);
|
||||
pev->avelocity.x = -( pev->angles.x + flapspeed * 5 );
|
||||
|
||||
// bank
|
||||
pev->avelocity.z = - (pev->angles.z + pev->avelocity.y);
|
||||
pev->avelocity.z = -( pev->angles.z + pev->avelocity.y );
|
||||
|
||||
// pev->framerate = flapspeed;
|
||||
// pev->framerate = flapspeed;
|
||||
StudioFrameAdvance( 0.1 );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CFlockingFlyer :: IdleThink( void )
|
||||
void CFlockingFlyer::IdleThink( void )
|
||||
{
|
||||
pev->nextthink = gpGlobals->time + 0.2;
|
||||
|
||||
// see if there's a client in the same pvs as the monster
|
||||
if ( !FNullEnt( FIND_CLIENT_IN_PVS( edict() ) ) )
|
||||
if( !FNullEnt( FIND_CLIENT_IN_PVS( edict() ) ) )
|
||||
{
|
||||
SetThink( &CFlockingFlyer::Start );
|
||||
pev->nextthink = gpGlobals->time + 0.1;
|
||||
|
@ -374,11 +386,11 @@ void CFlockingFlyer :: IdleThink( void )
|
|||
//=========================================================
|
||||
// Start - player enters the pvs, so get things going.
|
||||
//=========================================================
|
||||
void CFlockingFlyer :: Start( void )
|
||||
void CFlockingFlyer::Start( void )
|
||||
{
|
||||
pev->nextthink = gpGlobals->time + 0.1;
|
||||
|
||||
if ( IsLeader() )
|
||||
if( IsLeader() )
|
||||
{
|
||||
SetThink( &CFlockingFlyer::FlockLeaderThink );
|
||||
}
|
||||
|
@ -386,24 +398,22 @@ void CFlockingFlyer :: Start( void )
|
|||
{
|
||||
SetThink( &CFlockingFlyer::FlockFollowerThink );
|
||||
}
|
||||
|
||||
/*
|
||||
Vector vecTakeOff;
|
||||
vecTakeOff = Vector ( 0 , 0 , 0 );
|
||||
Vector vecTakeOff;
|
||||
vecTakeOff = Vector( 0, 0, 0 );
|
||||
|
||||
vecTakeOff.z = 50 + RANDOM_FLOAT ( 0, 100 );
|
||||
vecTakeOff.x = 20 - RANDOM_FLOAT ( 0, 40);
|
||||
vecTakeOff.y = 20 - RANDOM_FLOAT ( 0, 40);
|
||||
vecTakeOff.z = 50 + RANDOM_FLOAT( 0, 100 );
|
||||
vecTakeOff.x = 20 - RANDOM_FLOAT( 0, 40 );
|
||||
vecTakeOff.y = 20 - RANDOM_FLOAT( 0, 40 );
|
||||
|
||||
pev->velocity = vecTakeOff;
|
||||
|
||||
|
||||
pev->speed = pev->velocity.Length();
|
||||
pev->sequence = 0;
|
||||
*/
|
||||
SetActivity ( ACT_FLY );
|
||||
ResetSequenceInfo( );
|
||||
BoidAdvanceFrame( );
|
||||
SetActivity( ACT_FLY );
|
||||
ResetSequenceInfo();
|
||||
BoidAdvanceFrame();
|
||||
|
||||
pev->speed = AFLOCK_FLY_SPEED;// no delay!
|
||||
}
|
||||
|
@ -411,9 +421,9 @@ void CFlockingFlyer :: Start( void )
|
|||
//=========================================================
|
||||
// Leader boid calls this to form a flock from surrounding boids
|
||||
//=========================================================
|
||||
void CFlockingFlyer :: FormFlock( void )
|
||||
void CFlockingFlyer::FormFlock( void )
|
||||
{
|
||||
if ( !InSquad() )
|
||||
if( !InSquad() )
|
||||
{
|
||||
// I am my own leader
|
||||
m_pSquadLeader = this;
|
||||
|
@ -421,15 +431,15 @@ void CFlockingFlyer :: FormFlock( void )
|
|||
int squadCount = 1;
|
||||
|
||||
CBaseEntity *pEntity = NULL;
|
||||
|
||||
while ((pEntity = UTIL_FindEntityInSphere( pEntity, pev->origin, AFLOCK_MAX_RECRUIT_RADIUS )) != NULL)
|
||||
{
|
||||
CBaseMonster *pRecruit = pEntity->MyMonsterPointer( );
|
||||
|
||||
if ( pRecruit && pRecruit != this && pRecruit->IsAlive() && !pRecruit->m_pCine )
|
||||
while( ( pEntity = UTIL_FindEntityInSphere( pEntity, pev->origin, AFLOCK_MAX_RECRUIT_RADIUS ) ) != NULL )
|
||||
{
|
||||
CBaseMonster *pRecruit = pEntity->MyMonsterPointer();
|
||||
|
||||
if( pRecruit && pRecruit != this && pRecruit->IsAlive() && !pRecruit->m_pCine )
|
||||
{
|
||||
// Can we recruit this guy?
|
||||
if ( FClassnameIs ( pRecruit->pev, "monster_flyer" ) )
|
||||
if( FClassnameIs ( pRecruit->pev, "monster_flyer" ) )
|
||||
{
|
||||
squadCount++;
|
||||
SquadAdd( (CFlockingFlyer *)pRecruit );
|
||||
|
@ -445,18 +455,18 @@ void CFlockingFlyer :: FormFlock( void )
|
|||
//=========================================================
|
||||
// Searches for boids that are too close and pushes them away
|
||||
//=========================================================
|
||||
void CFlockingFlyer :: SpreadFlock( )
|
||||
void CFlockingFlyer::SpreadFlock()
|
||||
{
|
||||
Vector vecDir;
|
||||
float flSpeed;// holds vector magnitude while we fiddle with the direction
|
||||
|
||||
Vector vecDir;
|
||||
float flSpeed;// holds vector magnitude while we fiddle with the direction
|
||||
|
||||
CFlockingFlyer *pList = m_pSquadLeader;
|
||||
while ( pList )
|
||||
while( pList )
|
||||
{
|
||||
if ( pList != this && ( pev->origin - pList->pev->origin ).Length() <= AFLOCK_TOO_CLOSE )
|
||||
if( pList != this && ( pev->origin - pList->pev->origin ).Length() <= AFLOCK_TOO_CLOSE )
|
||||
{
|
||||
// push the other away
|
||||
vecDir = ( pList->pev->origin - pev->origin );
|
||||
vecDir = pList->pev->origin - pev->origin;
|
||||
vecDir = vecDir.Normalize();
|
||||
|
||||
// store the magnitude of the other boid's velocity, and normalize it so we
|
||||
|
@ -476,19 +486,19 @@ void CFlockingFlyer :: SpreadFlock( )
|
|||
//
|
||||
// This function should **ONLY** be called when Caller's velocity is normalized!!
|
||||
//=========================================================
|
||||
void CFlockingFlyer :: SpreadFlock2 ( )
|
||||
void CFlockingFlyer::SpreadFlock2()
|
||||
{
|
||||
Vector vecDir;
|
||||
|
||||
Vector vecDir;
|
||||
|
||||
CFlockingFlyer *pList = m_pSquadLeader;
|
||||
while ( pList )
|
||||
while( pList )
|
||||
{
|
||||
if ( pList != this && ( pev->origin - pList->pev->origin ).Length() <= AFLOCK_TOO_CLOSE )
|
||||
if( pList != this && ( pev->origin - pList->pev->origin ).Length() <= AFLOCK_TOO_CLOSE )
|
||||
{
|
||||
vecDir = ( pev->origin - pList->pev->origin );
|
||||
vecDir = pev->origin - pList->pev->origin;
|
||||
vecDir = vecDir.Normalize();
|
||||
|
||||
pev->velocity = (pev->velocity + vecDir);
|
||||
pev->velocity = pev->velocity + vecDir;
|
||||
}
|
||||
|
||||
pList = pList->m_pSquadNext;
|
||||
|
@ -498,14 +508,14 @@ void CFlockingFlyer :: SpreadFlock2 ( )
|
|||
//=========================================================
|
||||
// FBoidPathBlocked - returns TRUE if there is an obstacle ahead
|
||||
//=========================================================
|
||||
BOOL CFlockingFlyer :: FPathBlocked( )
|
||||
BOOL CFlockingFlyer::FPathBlocked()
|
||||
{
|
||||
TraceResult tr;
|
||||
Vector vecDist;// used for general measurements
|
||||
Vector vecDir;// used for general measurements
|
||||
BOOL fBlocked;
|
||||
TraceResult tr;
|
||||
Vector vecDist;// used for general measurements
|
||||
Vector vecDir;// used for general measurements
|
||||
BOOL fBlocked;
|
||||
|
||||
if ( m_flFakeBlockedTime > gpGlobals->time )
|
||||
if( m_flFakeBlockedTime > gpGlobals->time )
|
||||
{
|
||||
m_flLastBlockedTime = gpGlobals->time;
|
||||
return TRUE;
|
||||
|
@ -518,60 +528,58 @@ BOOL CFlockingFlyer :: FPathBlocked( )
|
|||
fBlocked = FALSE;// assume the way ahead is clear
|
||||
|
||||
// check for obstacle ahead
|
||||
UTIL_TraceLine(pev->origin, pev->origin + gpGlobals->v_forward * AFLOCK_CHECK_DIST, ignore_monsters, ENT(pev), &tr);
|
||||
if (tr.flFraction != 1.0)
|
||||
UTIL_TraceLine( pev->origin, pev->origin + gpGlobals->v_forward * AFLOCK_CHECK_DIST, ignore_monsters, ENT( pev ), &tr );
|
||||
if( tr.flFraction != 1.0 )
|
||||
{
|
||||
m_flLastBlockedTime = gpGlobals->time;
|
||||
fBlocked = TRUE;
|
||||
}
|
||||
|
||||
// extra wide checks
|
||||
UTIL_TraceLine(pev->origin + gpGlobals->v_right * 12, pev->origin + gpGlobals->v_right * 12 + gpGlobals->v_forward * AFLOCK_CHECK_DIST, ignore_monsters, ENT(pev), &tr);
|
||||
if (tr.flFraction != 1.0)
|
||||
UTIL_TraceLine( pev->origin + gpGlobals->v_right * 12, pev->origin + gpGlobals->v_right * 12 + gpGlobals->v_forward * AFLOCK_CHECK_DIST, ignore_monsters, ENT( pev ), &tr );
|
||||
if( tr.flFraction != 1.0 )
|
||||
{
|
||||
m_flLastBlockedTime = gpGlobals->time;
|
||||
fBlocked = TRUE;
|
||||
}
|
||||
|
||||
UTIL_TraceLine(pev->origin - gpGlobals->v_right * 12, pev->origin - gpGlobals->v_right * 12 + gpGlobals->v_forward * AFLOCK_CHECK_DIST, ignore_monsters, ENT(pev), &tr);
|
||||
if (tr.flFraction != 1.0)
|
||||
UTIL_TraceLine( pev->origin - gpGlobals->v_right * 12, pev->origin - gpGlobals->v_right * 12 + gpGlobals->v_forward * AFLOCK_CHECK_DIST, ignore_monsters, ENT( pev ), &tr );
|
||||
if( tr.flFraction != 1.0 )
|
||||
{
|
||||
m_flLastBlockedTime = gpGlobals->time;
|
||||
fBlocked = TRUE;
|
||||
}
|
||||
|
||||
if ( !fBlocked && gpGlobals->time - m_flLastBlockedTime > 6 )
|
||||
if( !fBlocked && gpGlobals->time - m_flLastBlockedTime > 6 )
|
||||
{
|
||||
// not blocked, and it's been a few seconds since we've actually been blocked.
|
||||
m_flFakeBlockedTime = gpGlobals->time + RANDOM_LONG(1, 3);
|
||||
m_flFakeBlockedTime = gpGlobals->time + RANDOM_LONG( 1, 3 );
|
||||
}
|
||||
|
||||
return fBlocked;
|
||||
}
|
||||
|
||||
|
||||
//=========================================================
|
||||
// Leader boids use this think every tenth
|
||||
//=========================================================
|
||||
void CFlockingFlyer :: FlockLeaderThink( void )
|
||||
void CFlockingFlyer::FlockLeaderThink( void )
|
||||
{
|
||||
TraceResult tr;
|
||||
Vector vecDist;// used for general measurements
|
||||
Vector vecDir;// used for general measurements
|
||||
int cProcessed = 0;// keep track of how many other boids we've processed
|
||||
float flLeftSide;
|
||||
float flRightSide;
|
||||
|
||||
TraceResult tr;
|
||||
Vector vecDist;// used for general measurements
|
||||
Vector vecDir;// used for general measurements
|
||||
int cProcessed = 0;// keep track of how many other boids we've processed
|
||||
float flLeftSide;
|
||||
float flRightSide;
|
||||
|
||||
pev->nextthink = gpGlobals->time + 0.1;
|
||||
|
||||
UTIL_MakeVectors ( pev->angles );
|
||||
|
||||
UTIL_MakeVectors( pev->angles );
|
||||
|
||||
// is the way ahead clear?
|
||||
if ( !FPathBlocked () )
|
||||
if( !FPathBlocked () )
|
||||
{
|
||||
// if the boid is turning, stop the trend.
|
||||
if ( m_fTurning )
|
||||
if( m_fTurning )
|
||||
{
|
||||
m_fTurning = FALSE;
|
||||
pev->avelocity.y = 0;
|
||||
|
@ -579,12 +587,12 @@ void CFlockingFlyer :: FlockLeaderThink( void )
|
|||
|
||||
m_fPathBlocked = FALSE;
|
||||
|
||||
if (pev->speed <= AFLOCK_FLY_SPEED )
|
||||
pev->speed+= 5;
|
||||
if( pev->speed <= AFLOCK_FLY_SPEED )
|
||||
pev->speed += 5;
|
||||
|
||||
pev->velocity = gpGlobals->v_forward * pev->speed;
|
||||
|
||||
BoidAdvanceFrame( );
|
||||
BoidAdvanceFrame();
|
||||
|
||||
return;
|
||||
}
|
||||
|
@ -592,25 +600,25 @@ void CFlockingFlyer :: FlockLeaderThink( void )
|
|||
// IF we get this far in the function, the leader's path is blocked!
|
||||
m_fPathBlocked = TRUE;
|
||||
|
||||
if ( !m_fTurning)// something in the way and boid is not already turning to avoid
|
||||
if( !m_fTurning )// something in the way and boid is not already turning to avoid
|
||||
{
|
||||
// measure clearance on left and right to pick the best dir to turn
|
||||
UTIL_TraceLine(pev->origin, pev->origin + gpGlobals->v_right * AFLOCK_CHECK_DIST, ignore_monsters, ENT(pev), &tr);
|
||||
vecDist = (tr.vecEndPos - pev->origin);
|
||||
UTIL_TraceLine( pev->origin, pev->origin + gpGlobals->v_right * AFLOCK_CHECK_DIST, ignore_monsters, ENT( pev ), &tr );
|
||||
vecDist = ( tr.vecEndPos - pev->origin );
|
||||
flRightSide = vecDist.Length();
|
||||
|
||||
UTIL_TraceLine(pev->origin, pev->origin - gpGlobals->v_right * AFLOCK_CHECK_DIST, ignore_monsters, ENT(pev), &tr);
|
||||
vecDist = (tr.vecEndPos - pev->origin);
|
||||
UTIL_TraceLine( pev->origin, pev->origin - gpGlobals->v_right * AFLOCK_CHECK_DIST, ignore_monsters, ENT( pev ), &tr );
|
||||
vecDist = tr.vecEndPos - pev->origin;
|
||||
flLeftSide = vecDist.Length();
|
||||
|
||||
// turn right if more clearance on right side
|
||||
if ( flRightSide > flLeftSide )
|
||||
if( flRightSide > flLeftSide )
|
||||
{
|
||||
pev->avelocity.y = -AFLOCK_TURN_RATE;
|
||||
m_fTurning = TRUE;
|
||||
}
|
||||
// default to left turn :)
|
||||
else if ( flLeftSide > flRightSide )
|
||||
else if( flLeftSide > flRightSide )
|
||||
{
|
||||
pev->avelocity.y = AFLOCK_TURN_RATE;
|
||||
m_fTurning = TRUE;
|
||||
|
@ -620,7 +628,7 @@ void CFlockingFlyer :: FlockLeaderThink( void )
|
|||
// equidistant. Pick randomly between left and right.
|
||||
m_fTurning = TRUE;
|
||||
|
||||
if ( RANDOM_LONG( 0, 1 ) == 0 )
|
||||
if( RANDOM_LONG( 0, 1 ) == 0 )
|
||||
{
|
||||
pev->avelocity.y = AFLOCK_TURN_RATE;
|
||||
}
|
||||
|
@ -630,47 +638,47 @@ void CFlockingFlyer :: FlockLeaderThink( void )
|
|||
}
|
||||
}
|
||||
}
|
||||
SpreadFlock( );
|
||||
SpreadFlock();
|
||||
|
||||
pev->velocity = gpGlobals->v_forward * pev->speed;
|
||||
|
||||
|
||||
// check and make sure we aren't about to plow into the ground, don't let it happen
|
||||
UTIL_TraceLine(pev->origin, pev->origin - gpGlobals->v_up * 16, ignore_monsters, ENT(pev), &tr);
|
||||
if (tr.flFraction != 1.0 && pev->velocity.z < 0 )
|
||||
UTIL_TraceLine( pev->origin, pev->origin - gpGlobals->v_up * 16, ignore_monsters, ENT( pev ), &tr );
|
||||
if( tr.flFraction != 1.0 && pev->velocity.z < 0 )
|
||||
pev->velocity.z = 0;
|
||||
|
||||
// maybe it did, though.
|
||||
if ( FBitSet (pev->flags, FL_ONGROUND) )
|
||||
if( FBitSet( pev->flags, FL_ONGROUND ) )
|
||||
{
|
||||
UTIL_SetOrigin (pev, pev->origin + Vector ( 0 , 0 , 1 ) );
|
||||
UTIL_SetOrigin( pev, pev->origin + Vector( 0, 0, 1 ) );
|
||||
pev->velocity.z = 0;
|
||||
}
|
||||
|
||||
if ( m_flFlockNextSoundTime < gpGlobals->time )
|
||||
if( m_flFlockNextSoundTime < gpGlobals->time )
|
||||
{
|
||||
MakeSound();
|
||||
m_flFlockNextSoundTime = gpGlobals->time + RANDOM_FLOAT( 1, 3 );
|
||||
}
|
||||
|
||||
BoidAdvanceFrame( );
|
||||
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
// follower boids execute this code when flocking
|
||||
//=========================================================
|
||||
void CFlockingFlyer :: FlockFollowerThink( void )
|
||||
void CFlockingFlyer::FlockFollowerThink( void )
|
||||
{
|
||||
TraceResult tr;
|
||||
Vector vecDist;
|
||||
Vector vecDir;
|
||||
Vector vecDirToLeader;
|
||||
float flDistToLeader;
|
||||
TraceResult tr;
|
||||
Vector vecDist;
|
||||
Vector vecDir;
|
||||
Vector vecDirToLeader;
|
||||
float flDistToLeader;
|
||||
|
||||
pev->nextthink = gpGlobals->time + 0.1;
|
||||
|
||||
if ( IsLeader() || !InSquad() )
|
||||
if( IsLeader() || !InSquad() )
|
||||
{
|
||||
// the leader has been killed and this flyer suddenly finds himself the leader.
|
||||
SetThink( &CFlockingFlyer::FlockLeaderThink );
|
||||
|
@ -686,16 +694,16 @@ void CFlockingFlyer :: FlockFollowerThink( void )
|
|||
//
|
||||
// We can see the leader, so try to catch up to it
|
||||
//
|
||||
if ( FInViewCone ( m_pSquadLeader ) )
|
||||
if( FInViewCone ( m_pSquadLeader ) )
|
||||
{
|
||||
// if we're too far away, speed up
|
||||
if ( flDistToLeader > AFLOCK_TOO_FAR )
|
||||
if( flDistToLeader > AFLOCK_TOO_FAR )
|
||||
{
|
||||
m_flGoalSpeed = m_pSquadLeader->pev->velocity.Length() * 1.5;
|
||||
}
|
||||
|
||||
// if we're too close, slow down
|
||||
else if ( flDistToLeader < AFLOCK_TOO_CLOSE )
|
||||
else if( flDistToLeader < AFLOCK_TOO_CLOSE )
|
||||
{
|
||||
m_flGoalSpeed = m_pSquadLeader->pev->velocity.Length() * 0.5;
|
||||
}
|
||||
|
@ -712,23 +720,23 @@ void CFlockingFlyer :: FlockFollowerThink( void )
|
|||
pev->velocity = pev->velocity.Normalize();
|
||||
|
||||
// if we are too far from leader, average a vector towards it into our current velocity
|
||||
if ( flDistToLeader > AFLOCK_TOO_FAR )
|
||||
if( flDistToLeader > AFLOCK_TOO_FAR )
|
||||
{
|
||||
vecDirToLeader = vecDirToLeader.Normalize();
|
||||
pev->velocity = (pev->velocity + vecDirToLeader) * 0.5;
|
||||
}
|
||||
|
||||
// clamp speeds and handle acceleration
|
||||
if ( m_flGoalSpeed > AFLOCK_FLY_SPEED * 2 )
|
||||
if( m_flGoalSpeed > AFLOCK_FLY_SPEED * 2 )
|
||||
{
|
||||
m_flGoalSpeed = AFLOCK_FLY_SPEED * 2;
|
||||
}
|
||||
|
||||
if ( pev->speed < m_flGoalSpeed )
|
||||
if( pev->speed < m_flGoalSpeed )
|
||||
{
|
||||
pev->speed += AFLOCK_ACCELERATE;
|
||||
}
|
||||
else if ( pev->speed > m_flGoalSpeed )
|
||||
else if( pev->speed > m_flGoalSpeed )
|
||||
{
|
||||
pev->speed -= AFLOCK_ACCELERATE;
|
||||
}
|
||||
|
@ -738,13 +746,13 @@ void CFlockingFlyer :: FlockFollowerThink( void )
|
|||
BoidAdvanceFrame( );
|
||||
}
|
||||
|
||||
/*
|
||||
/*
|
||||
// Is this boid's course blocked?
|
||||
if ( FBoidPathBlocked (pev) )
|
||||
if( FBoidPathBlocked( pev ) )
|
||||
{
|
||||
// course is still blocked from last time. Just keep flying along adjusted
|
||||
// velocity
|
||||
if ( m_fCourseAdjust )
|
||||
if( m_fCourseAdjust )
|
||||
{
|
||||
pev->velocity = m_vecAdjustedVelocity * pev->speed;
|
||||
return;
|
||||
|
@ -752,24 +760,24 @@ void CFlockingFlyer :: FlockFollowerThink( void )
|
|||
else // set course adjust flag and calculate adjusted velocity
|
||||
{
|
||||
m_fCourseAdjust = TRUE;
|
||||
|
||||
|
||||
// use VELOCITY, not angles, not all boids point the direction they are flying
|
||||
//vecDir = UTIL_VecToAngles( pev->velocity );
|
||||
//UTIL_MakeVectors ( vecDir );
|
||||
//UTIL_MakeVectors( vecDir );
|
||||
|
||||
UTIL_MakeVectors ( pev->angles );
|
||||
UTIL_MakeVectors( pev->angles );
|
||||
|
||||
// measure clearance on left and right to pick the best dir to turn
|
||||
UTIL_TraceLine(pev->origin, pev->origin + gpGlobals->v_right * AFLOCK_CHECK_DIST, ignore_monsters, ENT(pev), &tr);
|
||||
vecDist = (tr.vecEndPos - pev->origin);
|
||||
UTIL_TraceLine( pev->origin, pev->origin + gpGlobals->v_right * AFLOCK_CHECK_DIST, ignore_monsters, ENT( pev ), &tr );
|
||||
vecDist = tr.vecEndPos - pev->origin;
|
||||
flRightSide = vecDist.Length();
|
||||
|
||||
UTIL_TraceLine(pev->origin, pev->origin - gpGlobals->v_right * AFLOCK_CHECK_DIST, ignore_monsters, ENT(pev), &tr);
|
||||
vecDist = (tr.vecEndPos - pev->origin);
|
||||
UTIL_TraceLine( pev->origin, pev->origin - gpGlobals->v_right * AFLOCK_CHECK_DIST, ignore_monsters, ENT( pev ), &tr );
|
||||
vecDist = tr.vecEndPos - pev->origin;
|
||||
flLeftSide = vecDist.Length();
|
||||
|
||||
// slide right if more clearance on right side
|
||||
if ( flRightSide > flLeftSide )
|
||||
if( flRightSide > flLeftSide )
|
||||
{
|
||||
m_vecAdjustedVelocity = gpGlobals->v_right;
|
||||
}
|
||||
|
@ -785,17 +793,16 @@ void CFlockingFlyer :: FlockFollowerThink( void )
|
|||
// if we make it this far, boids path is CLEAR!
|
||||
m_fCourseAdjust = FALSE;
|
||||
*/
|
||||
|
||||
|
||||
//=========================================================
|
||||
//
|
||||
// SquadUnlink(), Unlink the squad pointers.
|
||||
//
|
||||
//=========================================================
|
||||
void CFlockingFlyer :: SquadUnlink( void )
|
||||
void CFlockingFlyer::SquadUnlink( void )
|
||||
{
|
||||
m_pSquadLeader = NULL;
|
||||
m_pSquadNext = NULL;
|
||||
m_pSquadNext = NULL;
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
|
@ -803,9 +810,9 @@ void CFlockingFlyer :: SquadUnlink( void )
|
|||
// SquadAdd(), add pAdd to my squad
|
||||
//
|
||||
//=========================================================
|
||||
void CFlockingFlyer :: SquadAdd( CFlockingFlyer *pAdd )
|
||||
void CFlockingFlyer::SquadAdd( CFlockingFlyer *pAdd )
|
||||
{
|
||||
ASSERT( pAdd!=NULL );
|
||||
ASSERT( pAdd != NULL );
|
||||
ASSERT( !pAdd->InSquad() );
|
||||
ASSERT( this->IsLeader() );
|
||||
|
||||
|
@ -813,33 +820,34 @@ void CFlockingFlyer :: SquadAdd( CFlockingFlyer *pAdd )
|
|||
m_pSquadNext = pAdd;
|
||||
pAdd->m_pSquadLeader = this;
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//
|
||||
// SquadRemove(), remove pRemove from my squad.
|
||||
// If I am pRemove, promote m_pSquadNext to leader
|
||||
//
|
||||
//=========================================================
|
||||
void CFlockingFlyer :: SquadRemove( CFlockingFlyer *pRemove )
|
||||
void CFlockingFlyer::SquadRemove( CFlockingFlyer *pRemove )
|
||||
{
|
||||
ASSERT( pRemove!=NULL );
|
||||
ASSERT( pRemove != NULL );
|
||||
ASSERT( this->IsLeader() );
|
||||
ASSERT( pRemove->m_pSquadLeader == this );
|
||||
|
||||
if ( SquadCount() > 2 )
|
||||
if( SquadCount() > 2 )
|
||||
{
|
||||
// Removing the leader, promote m_pSquadNext to leader
|
||||
if ( pRemove == this )
|
||||
if( pRemove == this )
|
||||
{
|
||||
CFlockingFlyer *pLeader = m_pSquadNext;
|
||||
|
||||
|
||||
// copy the enemy LKP to the new leader
|
||||
pLeader->m_vecEnemyLKP = m_vecEnemyLKP;
|
||||
|
||||
if ( pLeader )
|
||||
if( pLeader )
|
||||
{
|
||||
CFlockingFlyer *pList = pLeader;
|
||||
|
||||
while ( pList )
|
||||
while( pList )
|
||||
{
|
||||
pList->m_pSquadLeader = pLeader;
|
||||
pList = pList->m_pSquadNext;
|
||||
|
@ -853,7 +861,7 @@ void CFlockingFlyer :: SquadRemove( CFlockingFlyer *pRemove )
|
|||
CFlockingFlyer *pList = this;
|
||||
|
||||
// Find the node before pRemove
|
||||
while ( pList->m_pSquadNext != pRemove )
|
||||
while( pList->m_pSquadNext != pRemove )
|
||||
{
|
||||
// assert to test valid list construction
|
||||
ASSERT( pList->m_pSquadNext != NULL );
|
||||
|
@ -872,17 +880,18 @@ void CFlockingFlyer :: SquadRemove( CFlockingFlyer *pRemove )
|
|||
else
|
||||
SquadDisband();
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//
|
||||
// SquadCount(), return the number of members of this squad
|
||||
// callable from leaders & followers
|
||||
//
|
||||
//=========================================================
|
||||
int CFlockingFlyer :: SquadCount( void )
|
||||
int CFlockingFlyer::SquadCount( void )
|
||||
{
|
||||
CFlockingFlyer *pList = m_pSquadLeader;
|
||||
int squadCount = 0;
|
||||
while ( pList )
|
||||
while( pList )
|
||||
{
|
||||
squadCount++;
|
||||
pList = pList->m_pSquadNext;
|
||||
|
@ -896,12 +905,12 @@ int CFlockingFlyer :: SquadCount( void )
|
|||
// SquadDisband(), Unlink all squad members
|
||||
//
|
||||
//=========================================================
|
||||
void CFlockingFlyer :: SquadDisband( void )
|
||||
void CFlockingFlyer::SquadDisband( void )
|
||||
{
|
||||
CFlockingFlyer *pList = m_pSquadLeader;
|
||||
CFlockingFlyer *pNext;
|
||||
|
||||
while ( pList )
|
||||
while( pList )
|
||||
{
|
||||
pNext = pList->m_pSquadNext;
|
||||
pList->SquadUnlink();
|
||||
|
|
654
dlls/agrunt.cpp
654
dlls/agrunt.cpp
File diff suppressed because it is too large
Load Diff
|
@ -26,56 +26,54 @@ class CAirtank : public CGrenade
|
|||
void Precache( void );
|
||||
void EXPORT TankThink( void );
|
||||
void EXPORT TankTouch( CBaseEntity *pOther );
|
||||
int BloodColor( void ) { return DONT_BLEED; };
|
||||
int BloodColor( void ) { return DONT_BLEED; };
|
||||
void Killed( entvars_t *pevAttacker, int iGib );
|
||||
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
|
||||
static TYPEDESCRIPTION m_SaveData[];
|
||||
|
||||
int m_state;
|
||||
int m_state;
|
||||
};
|
||||
|
||||
LINK_ENTITY_TO_CLASS( item_airtank, CAirtank )
|
||||
|
||||
LINK_ENTITY_TO_CLASS( item_airtank, CAirtank );
|
||||
TYPEDESCRIPTION CAirtank::m_SaveData[] =
|
||||
TYPEDESCRIPTION CAirtank::m_SaveData[] =
|
||||
{
|
||||
DEFINE_FIELD( CAirtank, m_state, FIELD_INTEGER ),
|
||||
};
|
||||
|
||||
IMPLEMENT_SAVERESTORE( CAirtank, CGrenade );
|
||||
IMPLEMENT_SAVERESTORE( CAirtank, CGrenade )
|
||||
|
||||
|
||||
void CAirtank :: Spawn( void )
|
||||
void CAirtank::Spawn( void )
|
||||
{
|
||||
Precache( );
|
||||
Precache();
|
||||
// motor
|
||||
pev->movetype = MOVETYPE_FLY;
|
||||
pev->solid = SOLID_BBOX;
|
||||
|
||||
SET_MODEL(ENT(pev), "models/w_oxygen.mdl");
|
||||
UTIL_SetSize(pev, Vector( -16, -16, 0), Vector(16, 16, 36));
|
||||
SET_MODEL( ENT( pev ), "models/w_oxygen.mdl" );
|
||||
UTIL_SetSize( pev, Vector( -16, -16, 0), Vector( 16, 16, 36 ) );
|
||||
UTIL_SetOrigin( pev, pev->origin );
|
||||
|
||||
SetTouch( &CAirtank::TankTouch );
|
||||
SetThink( &CAirtank::TankThink );
|
||||
|
||||
pev->flags |= FL_MONSTER;
|
||||
pev->takedamage = DAMAGE_YES;
|
||||
pev->health = 20;
|
||||
pev->dmg = 50;
|
||||
m_state = 1;
|
||||
pev->takedamage = DAMAGE_YES;
|
||||
pev->health = 20;
|
||||
pev->dmg = 50;
|
||||
m_state = 1;
|
||||
}
|
||||
|
||||
void CAirtank::Precache( void )
|
||||
{
|
||||
PRECACHE_MODEL("models/w_oxygen.mdl");
|
||||
PRECACHE_SOUND("doors/aliendoor3.wav");
|
||||
PRECACHE_MODEL( "models/w_oxygen.mdl" );
|
||||
PRECACHE_SOUND( "doors/aliendoor3.wav" );
|
||||
}
|
||||
|
||||
|
||||
void CAirtank :: Killed( entvars_t *pevAttacker, int iGib )
|
||||
void CAirtank::Killed( entvars_t *pevAttacker, int iGib )
|
||||
{
|
||||
pev->owner = ENT( pevAttacker );
|
||||
|
||||
|
@ -84,7 +82,6 @@ void CAirtank :: Killed( entvars_t *pevAttacker, int iGib )
|
|||
Explode( pev->origin, Vector( 0, 0, -1 ) );
|
||||
}
|
||||
|
||||
|
||||
void CAirtank::TankThink( void )
|
||||
{
|
||||
// Fire trigger
|
||||
|
@ -92,24 +89,23 @@ void CAirtank::TankThink( void )
|
|||
SUB_UseTargets( this, USE_TOGGLE, 0 );
|
||||
}
|
||||
|
||||
|
||||
void CAirtank::TankTouch( CBaseEntity *pOther )
|
||||
{
|
||||
if ( !pOther->IsPlayer() )
|
||||
if( !pOther->IsPlayer() )
|
||||
return;
|
||||
|
||||
if (!m_state)
|
||||
if( !m_state )
|
||||
{
|
||||
// "no oxygen" sound
|
||||
EMIT_SOUND( ENT(pev), CHAN_BODY, "player/pl_swim2.wav", 1.0, ATTN_NORM );
|
||||
EMIT_SOUND( ENT( pev ), CHAN_BODY, "player/pl_swim2.wav", 1.0, ATTN_NORM );
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
// give player 12 more seconds of air
|
||||
pOther->pev->air_finished = gpGlobals->time + 12;
|
||||
|
||||
// suit recharge sound
|
||||
EMIT_SOUND( ENT(pev), CHAN_VOICE, "doors/aliendoor3.wav", 1.0, ATTN_NORM );
|
||||
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "doors/aliendoor3.wav", 1.0, ATTN_NORM );
|
||||
|
||||
// recharge airtank in 30 seconds
|
||||
pev->nextthink = gpGlobals->time + 30;
|
||||
|
|
|
@ -26,7 +26,7 @@
|
|||
#include "animation.h"
|
||||
#include "saverestore.h"
|
||||
|
||||
TYPEDESCRIPTION CBaseAnimating::m_SaveData[] =
|
||||
TYPEDESCRIPTION CBaseAnimating::m_SaveData[] =
|
||||
{
|
||||
DEFINE_FIELD( CBaseMonster, m_flFrameRate, FIELD_FLOAT ),
|
||||
DEFINE_FIELD( CBaseMonster, m_flGroundSpeed, FIELD_FLOAT ),
|
||||
|
@ -35,36 +35,35 @@ TYPEDESCRIPTION CBaseAnimating::m_SaveData[] =
|
|||
DEFINE_FIELD( CBaseMonster, m_fSequenceLoops, FIELD_BOOLEAN ),
|
||||
};
|
||||
|
||||
IMPLEMENT_SAVERESTORE( CBaseAnimating, CBaseDelay );
|
||||
|
||||
IMPLEMENT_SAVERESTORE( CBaseAnimating, CBaseDelay )
|
||||
|
||||
//=========================================================
|
||||
// StudioFrameAdvance - advance the animation frame up to the current time
|
||||
// if an flInterval is passed in, only advance animation that number of seconds
|
||||
//=========================================================
|
||||
float CBaseAnimating :: StudioFrameAdvance ( float flInterval )
|
||||
float CBaseAnimating::StudioFrameAdvance( float flInterval )
|
||||
{
|
||||
if (flInterval == 0.0)
|
||||
if( flInterval == 0.0 )
|
||||
{
|
||||
flInterval = (gpGlobals->time - pev->animtime);
|
||||
if (flInterval <= 0.001)
|
||||
flInterval = gpGlobals->time - pev->animtime;
|
||||
if( flInterval <= 0.001 )
|
||||
{
|
||||
pev->animtime = gpGlobals->time;
|
||||
return 0.0;
|
||||
}
|
||||
}
|
||||
if (! pev->animtime)
|
||||
if( !pev->animtime )
|
||||
flInterval = 0.0;
|
||||
|
||||
|
||||
pev->frame += flInterval * m_flFrameRate * pev->framerate;
|
||||
pev->animtime = gpGlobals->time;
|
||||
|
||||
if (pev->frame < 0.0 || pev->frame >= 256.0)
|
||||
if( pev->frame < 0.0 || pev->frame >= 256.0 )
|
||||
{
|
||||
if (m_fSequenceLoops)
|
||||
pev->frame -= (int)(pev->frame / 256.0) * 256.0;
|
||||
if( m_fSequenceLoops )
|
||||
pev->frame -= (int)( pev->frame / 256.0 ) * 256.0;
|
||||
else
|
||||
pev->frame = (pev->frame < 0.0) ? 0 : 255;
|
||||
pev->frame = ( pev->frame < 0.0 ) ? 0 : 255;
|
||||
m_fSequenceFinished = TRUE; // just in case it wasn't caught in GetEvents
|
||||
}
|
||||
|
||||
|
@ -74,10 +73,10 @@ float CBaseAnimating :: StudioFrameAdvance ( float flInterval )
|
|||
//=========================================================
|
||||
// LookupActivity
|
||||
//=========================================================
|
||||
int CBaseAnimating :: LookupActivity ( int activity )
|
||||
int CBaseAnimating::LookupActivity( int activity )
|
||||
{
|
||||
ASSERT( activity != 0 );
|
||||
void *pmodel = GET_MODEL_PTR( ENT(pev) );
|
||||
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
|
||||
|
||||
return ::LookupActivity( pmodel, pev, activity );
|
||||
}
|
||||
|
@ -88,44 +87,41 @@ int CBaseAnimating :: LookupActivity ( int activity )
|
|||
// Get activity with highest 'weight'
|
||||
//
|
||||
//=========================================================
|
||||
int CBaseAnimating :: LookupActivityHeaviest ( int activity )
|
||||
int CBaseAnimating::LookupActivityHeaviest( int activity )
|
||||
{
|
||||
void *pmodel = GET_MODEL_PTR( ENT(pev) );
|
||||
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
|
||||
|
||||
return ::LookupActivityHeaviest( pmodel, pev, activity );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
int CBaseAnimating :: LookupSequence ( const char *label )
|
||||
int CBaseAnimating::LookupSequence( const char *label )
|
||||
{
|
||||
void *pmodel = GET_MODEL_PTR( ENT(pev) );
|
||||
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
|
||||
|
||||
return ::LookupSequence( pmodel, label );
|
||||
}
|
||||
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CBaseAnimating :: ResetSequenceInfo ( )
|
||||
void CBaseAnimating::ResetSequenceInfo()
|
||||
{
|
||||
void *pmodel = GET_MODEL_PTR( ENT(pev) );
|
||||
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
|
||||
|
||||
GetSequenceInfo( pmodel, pev, &m_flFrameRate, &m_flGroundSpeed );
|
||||
m_fSequenceLoops = ((GetSequenceFlags() & STUDIO_LOOPING) != 0);
|
||||
m_fSequenceLoops = ( ( GetSequenceFlags() & STUDIO_LOOPING ) != 0 );
|
||||
pev->animtime = gpGlobals->time;
|
||||
pev->framerate = 1.0;
|
||||
m_fSequenceFinished = FALSE;
|
||||
m_flLastEventCheck = gpGlobals->time;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
BOOL CBaseAnimating :: GetSequenceFlags( )
|
||||
BOOL CBaseAnimating::GetSequenceFlags()
|
||||
{
|
||||
void *pmodel = GET_MODEL_PTR( ENT(pev) );
|
||||
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
|
||||
|
||||
return ::GetSequenceFlags( pmodel, pev );
|
||||
}
|
||||
|
@ -133,13 +129,13 @@ BOOL CBaseAnimating :: GetSequenceFlags( )
|
|||
//=========================================================
|
||||
// DispatchAnimEvents
|
||||
//=========================================================
|
||||
void CBaseAnimating :: DispatchAnimEvents ( float flInterval )
|
||||
void CBaseAnimating::DispatchAnimEvents( float flInterval )
|
||||
{
|
||||
MonsterEvent_t event;
|
||||
|
||||
void *pmodel = GET_MODEL_PTR( ENT(pev) );
|
||||
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
|
||||
|
||||
if ( !pmodel )
|
||||
if( !pmodel )
|
||||
{
|
||||
ALERT( at_aiconsole, "Gibbed monster is thinking!\n" );
|
||||
return;
|
||||
|
@ -149,37 +145,36 @@ void CBaseAnimating :: DispatchAnimEvents ( float flInterval )
|
|||
flInterval = 0.1;
|
||||
|
||||
// FIX: this still sometimes hits events twice
|
||||
float flStart = pev->frame + (m_flLastEventCheck - pev->animtime) * m_flFrameRate * pev->framerate;
|
||||
float flStart = pev->frame + ( m_flLastEventCheck - pev->animtime ) * m_flFrameRate * pev->framerate;
|
||||
float flEnd = pev->frame + flInterval * m_flFrameRate * pev->framerate;
|
||||
m_flLastEventCheck = pev->animtime + flInterval;
|
||||
|
||||
m_fSequenceFinished = FALSE;
|
||||
if (flEnd >= 256 || flEnd <= 0.0)
|
||||
if( flEnd >= 256 || flEnd <= 0.0 )
|
||||
m_fSequenceFinished = TRUE;
|
||||
|
||||
int index = 0;
|
||||
|
||||
while ( (index = GetAnimationEvent( pmodel, pev, &event, flStart, flEnd, index ) ) != 0 )
|
||||
while( ( index = GetAnimationEvent( pmodel, pev, &event, flStart, flEnd, index ) ) != 0 )
|
||||
{
|
||||
HandleAnimEvent( &event );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
float CBaseAnimating :: SetBoneController ( int iController, float flValue )
|
||||
float CBaseAnimating::SetBoneController( int iController, float flValue )
|
||||
{
|
||||
void *pmodel = GET_MODEL_PTR( ENT(pev) );
|
||||
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
|
||||
|
||||
return SetController( pmodel, pev, iController, flValue );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CBaseAnimating :: InitBoneControllers ( void )
|
||||
void CBaseAnimating::InitBoneControllers( void )
|
||||
{
|
||||
void *pmodel = GET_MODEL_PTR( ENT(pev) );
|
||||
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
|
||||
|
||||
SetController( pmodel, pev, 0, 0.0 );
|
||||
SetController( pmodel, pev, 1, 0.0 );
|
||||
|
@ -189,38 +184,38 @@ void CBaseAnimating :: InitBoneControllers ( void )
|
|||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
float CBaseAnimating :: SetBlending ( int iBlender, float flValue )
|
||||
float CBaseAnimating::SetBlending( int iBlender, float flValue )
|
||||
{
|
||||
void *pmodel = GET_MODEL_PTR( ENT(pev) );
|
||||
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
|
||||
|
||||
return ::SetBlending( pmodel, pev, iBlender, flValue );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CBaseAnimating :: GetBonePosition ( int iBone, Vector &origin, Vector &angles )
|
||||
void CBaseAnimating::GetBonePosition( int iBone, Vector &origin, Vector &angles )
|
||||
{
|
||||
GET_BONE_POSITION( ENT(pev), iBone, origin, angles );
|
||||
GET_BONE_POSITION( ENT( pev ), iBone, origin, angles );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CBaseAnimating :: GetAttachment ( int iAttachment, Vector &origin, Vector &angles )
|
||||
void CBaseAnimating::GetAttachment( int iAttachment, Vector &origin, Vector &angles )
|
||||
{
|
||||
GET_ATTACHMENT( ENT(pev), iAttachment, origin, angles );
|
||||
GET_ATTACHMENT( ENT( pev ), iAttachment, origin, angles );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
int CBaseAnimating :: FindTransition( int iEndingSequence, int iGoalSequence, int *piDir )
|
||||
int CBaseAnimating::FindTransition( int iEndingSequence, int iGoalSequence, int *piDir )
|
||||
{
|
||||
void *pmodel = GET_MODEL_PTR( ENT(pev) );
|
||||
|
||||
if (piDir == NULL)
|
||||
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
|
||||
|
||||
if( piDir == NULL )
|
||||
{
|
||||
int iDir;
|
||||
int sequence = ::FindTransition( pmodel, iEndingSequence, iGoalSequence, &iDir );
|
||||
if (iDir != 1)
|
||||
if( iDir != 1 )
|
||||
return -1;
|
||||
else
|
||||
return sequence;
|
||||
|
@ -231,81 +226,80 @@ int CBaseAnimating :: FindTransition( int iEndingSequence, int iGoalSequence, in
|
|||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CBaseAnimating :: GetAutomovement( Vector &origin, Vector &angles, float flInterval )
|
||||
void CBaseAnimating::GetAutomovement( Vector &origin, Vector &angles, float flInterval )
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void CBaseAnimating :: SetBodygroup( int iGroup, int iValue )
|
||||
void CBaseAnimating::SetBodygroup( int iGroup, int iValue )
|
||||
{
|
||||
::SetBodygroup( GET_MODEL_PTR( ENT(pev) ), pev, iGroup, iValue );
|
||||
::SetBodygroup( GET_MODEL_PTR( ENT( pev ) ), pev, iGroup, iValue );
|
||||
}
|
||||
|
||||
int CBaseAnimating :: GetBodygroup( int iGroup )
|
||||
int CBaseAnimating::GetBodygroup( int iGroup )
|
||||
{
|
||||
return ::GetBodygroup( GET_MODEL_PTR( ENT(pev) ), pev, iGroup );
|
||||
return ::GetBodygroup( GET_MODEL_PTR( ENT( pev ) ), pev, iGroup );
|
||||
}
|
||||
|
||||
|
||||
int CBaseAnimating :: ExtractBbox( int sequence, float *mins, float *maxs )
|
||||
int CBaseAnimating::ExtractBbox( int sequence, float *mins, float *maxs )
|
||||
{
|
||||
return ::ExtractBbox( GET_MODEL_PTR( ENT(pev) ), sequence, mins, maxs );
|
||||
return ::ExtractBbox( GET_MODEL_PTR( ENT( pev ) ), sequence, mins, maxs );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
|
||||
void CBaseAnimating :: SetSequenceBox( void )
|
||||
void CBaseAnimating::SetSequenceBox( void )
|
||||
{
|
||||
Vector mins, maxs;
|
||||
|
||||
// Get sequence bbox
|
||||
if ( ExtractBbox( pev->sequence, mins, maxs ) )
|
||||
if( ExtractBbox( pev->sequence, mins, maxs ) )
|
||||
{
|
||||
// expand box for rotation
|
||||
// find min / max for rotations
|
||||
float yaw = pev->angles.y * (M_PI / 180.0);
|
||||
|
||||
float yaw = pev->angles.y * ( M_PI / 180.0 );
|
||||
|
||||
Vector xvector, yvector;
|
||||
xvector.x = cos(yaw);
|
||||
xvector.y = sin(yaw);
|
||||
yvector.x = -sin(yaw);
|
||||
yvector.y = cos(yaw);
|
||||
xvector.x = cos( yaw );
|
||||
xvector.y = sin( yaw );
|
||||
yvector.x = -sin( yaw );
|
||||
yvector.y = cos( yaw );
|
||||
Vector bounds[2];
|
||||
|
||||
bounds[0] = mins;
|
||||
bounds[1] = maxs;
|
||||
|
||||
|
||||
Vector rmin( 9999, 9999, 9999 );
|
||||
Vector rmax( -9999, -9999, -9999 );
|
||||
Vector base, transformed;
|
||||
|
||||
for (int i = 0; i <= 1; i++ )
|
||||
for( int i = 0; i <= 1; i++ )
|
||||
{
|
||||
base.x = bounds[i].x;
|
||||
for ( int j = 0; j <= 1; j++ )
|
||||
for( int j = 0; j <= 1; j++ )
|
||||
{
|
||||
base.y = bounds[j].y;
|
||||
for ( int k = 0; k <= 1; k++ )
|
||||
for( int k = 0; k <= 1; k++ )
|
||||
{
|
||||
base.z = bounds[k].z;
|
||||
|
||||
// transform the point
|
||||
transformed.x = xvector.x*base.x + yvector.x*base.y;
|
||||
transformed.y = xvector.y*base.x + yvector.y*base.y;
|
||||
|
||||
// transform the point
|
||||
transformed.x = xvector.x * base.x + yvector.x * base.y;
|
||||
transformed.y = xvector.y * base.x + yvector.y * base.y;
|
||||
transformed.z = base.z;
|
||||
|
||||
if (transformed.x < rmin.x)
|
||||
|
||||
if( transformed.x < rmin.x )
|
||||
rmin.x = transformed.x;
|
||||
if (transformed.x > rmax.x)
|
||||
if( transformed.x > rmax.x )
|
||||
rmax.x = transformed.x;
|
||||
if (transformed.y < rmin.y)
|
||||
if( transformed.y < rmin.y )
|
||||
rmin.y = transformed.y;
|
||||
if (transformed.y > rmax.y)
|
||||
if( transformed.y > rmax.y )
|
||||
rmax.y = transformed.y;
|
||||
if (transformed.z < rmin.z)
|
||||
if( transformed.z < rmin.z )
|
||||
rmin.z = transformed.z;
|
||||
if (transformed.z > rmax.z)
|
||||
if( transformed.z > rmax.z )
|
||||
rmax.z = transformed.z;
|
||||
}
|
||||
}
|
||||
|
@ -315,4 +309,3 @@ void CBaseAnimating :: SetSequenceBox( void )
|
|||
UTIL_SetSize( pev, rmin, rmax );
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -12,12 +12,13 @@
|
|||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
typedef int BOOL;
|
||||
#define TRUE 1
|
||||
#define TRUE 1
|
||||
#define FALSE 0
|
||||
|
||||
// hack into header files that we can ship
|
||||
|
@ -53,52 +54,49 @@ extern globalvars_t *gpGlobals;
|
|||
|
||||
#pragma warning( disable : 4244 )
|
||||
|
||||
|
||||
|
||||
int ExtractBbox( void *pmodel, int sequence, float *mins, float *maxs )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if (! pstudiohdr)
|
||||
if( !pstudiohdr )
|
||||
return 0;
|
||||
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
|
||||
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
|
||||
|
||||
mins[0] = pseqdesc[ sequence ].bbmin[0];
|
||||
mins[1] = pseqdesc[ sequence ].bbmin[1];
|
||||
mins[2] = pseqdesc[ sequence ].bbmin[2];
|
||||
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex );
|
||||
|
||||
maxs[0] = pseqdesc[ sequence ].bbmax[0];
|
||||
maxs[1] = pseqdesc[ sequence ].bbmax[1];
|
||||
maxs[2] = pseqdesc[ sequence ].bbmax[2];
|
||||
mins[0] = pseqdesc[sequence].bbmin[0];
|
||||
mins[1] = pseqdesc[sequence].bbmin[1];
|
||||
mins[2] = pseqdesc[sequence].bbmin[2];
|
||||
|
||||
maxs[0] = pseqdesc[sequence].bbmax[0];
|
||||
maxs[1] = pseqdesc[sequence].bbmax[1];
|
||||
maxs[2] = pseqdesc[sequence].bbmax[2];
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int LookupActivity( void *pmodel, entvars_t *pev, int activity )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if (! pstudiohdr)
|
||||
if( !pstudiohdr )
|
||||
return 0;
|
||||
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
|
||||
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
|
||||
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex );
|
||||
|
||||
int weighttotal = 0;
|
||||
int seq = ACTIVITY_NOT_AVAILABLE;
|
||||
for (int i = 0; i < pstudiohdr->numseq; i++)
|
||||
for( int i = 0; i < pstudiohdr->numseq; i++ )
|
||||
{
|
||||
if (pseqdesc[i].activity == activity)
|
||||
if( pseqdesc[i].activity == activity )
|
||||
{
|
||||
weighttotal += pseqdesc[i].actweight;
|
||||
if (!weighttotal || RANDOM_LONG(0,weighttotal-1) < pseqdesc[i].actweight)
|
||||
if( !weighttotal || RANDOM_LONG( 0, weighttotal - 1 ) < pseqdesc[i].actweight )
|
||||
seq = i;
|
||||
}
|
||||
}
|
||||
|
@ -106,26 +104,25 @@ int LookupActivity( void *pmodel, entvars_t *pev, int activity )
|
|||
return seq;
|
||||
}
|
||||
|
||||
|
||||
int LookupActivityHeaviest( void *pmodel, entvars_t *pev, int activity )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if ( !pstudiohdr )
|
||||
if( !pstudiohdr )
|
||||
return 0;
|
||||
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
|
||||
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
|
||||
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex );
|
||||
|
||||
int weight = 0;
|
||||
int seq = ACTIVITY_NOT_AVAILABLE;
|
||||
for (int i = 0; i < pstudiohdr->numseq; i++)
|
||||
for( int i = 0; i < pstudiohdr->numseq; i++ )
|
||||
{
|
||||
if (pseqdesc[i].activity == activity)
|
||||
if( pseqdesc[i].activity == activity )
|
||||
{
|
||||
if ( pseqdesc[i].actweight > weight )
|
||||
if( pseqdesc[i].actweight > weight )
|
||||
{
|
||||
weight = pseqdesc[i].actweight;
|
||||
seq = i;
|
||||
|
@ -136,115 +133,111 @@ int LookupActivityHeaviest( void *pmodel, entvars_t *pev, int activity )
|
|||
return seq;
|
||||
}
|
||||
|
||||
void GetEyePosition ( void *pmodel, float *vecEyePosition )
|
||||
void GetEyePosition( void *pmodel, float *vecEyePosition )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
|
||||
if ( !pstudiohdr )
|
||||
if( !pstudiohdr )
|
||||
{
|
||||
ALERT ( at_console, "GetEyePosition() Can't get pstudiohdr ptr!\n" );
|
||||
ALERT( at_console, "GetEyePosition() Can't get pstudiohdr ptr!\n" );
|
||||
return;
|
||||
}
|
||||
|
||||
VectorCopy ( pstudiohdr->eyeposition, vecEyePosition );
|
||||
VectorCopy( pstudiohdr->eyeposition, vecEyePosition );
|
||||
}
|
||||
|
||||
int LookupSequence( void *pmodel, const char *label )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if (! pstudiohdr)
|
||||
if( !pstudiohdr )
|
||||
return 0;
|
||||
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
|
||||
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
|
||||
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex );
|
||||
|
||||
for (int i = 0; i < pstudiohdr->numseq; i++)
|
||||
for( int i = 0; i < pstudiohdr->numseq; i++ )
|
||||
{
|
||||
if (stricmp( pseqdesc[i].label, label ) == 0)
|
||||
if( stricmp( pseqdesc[i].label, label ) == 0 )
|
||||
return i;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
int IsSoundEvent( int eventNumber )
|
||||
{
|
||||
if ( eventNumber == SCRIPT_EVENT_SOUND || eventNumber == SCRIPT_EVENT_SOUND_VOICE )
|
||||
if( eventNumber == SCRIPT_EVENT_SOUND || eventNumber == SCRIPT_EVENT_SOUND_VOICE )
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
void SequencePrecache( void *pmodel, const char *pSequenceName )
|
||||
{
|
||||
int index = LookupSequence( pmodel, pSequenceName );
|
||||
if ( index >= 0 )
|
||||
if( index >= 0 )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if ( !pstudiohdr || index >= pstudiohdr->numseq )
|
||||
if( !pstudiohdr || index >= pstudiohdr->numseq )
|
||||
return;
|
||||
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
mstudioevent_t *pevent;
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
mstudioevent_t *pevent;
|
||||
|
||||
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + index;
|
||||
pevent = (mstudioevent_t *)((byte *)pstudiohdr + pseqdesc->eventindex);
|
||||
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex ) + index;
|
||||
pevent = (mstudioevent_t *)( (byte *)pstudiohdr + pseqdesc->eventindex );
|
||||
|
||||
for (int i = 0; i < pseqdesc->numevents; i++)
|
||||
for( int i = 0; i < pseqdesc->numevents; i++ )
|
||||
{
|
||||
// Don't send client-side events to the server AI
|
||||
if ( pevent[i].event >= EVENT_CLIENT )
|
||||
if( pevent[i].event >= EVENT_CLIENT )
|
||||
continue;
|
||||
|
||||
// UNDONE: Add a callback to check to see if a sound is precached yet and don't allocate a copy
|
||||
// of it's name if it is.
|
||||
if ( IsSoundEvent( pevent[i].event ) )
|
||||
if( IsSoundEvent( pevent[i].event ) )
|
||||
{
|
||||
if ( !strlen(pevent[i].options) )
|
||||
if( !strlen( pevent[i].options ) )
|
||||
{
|
||||
ALERT( at_error, "Bad sound event %d in sequence %s :: %s (sound is \"%s\")\n", pevent[i].event, pstudiohdr->name, pSequenceName, pevent[i].options );
|
||||
}
|
||||
|
||||
PRECACHE_SOUND( (char *)(gpGlobals->pStringBase + ALLOC_STRING(pevent[i].options) ) );
|
||||
PRECACHE_SOUND( (char *)( gpGlobals->pStringBase + ALLOC_STRING( pevent[i].options ) ) );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void GetSequenceInfo( void *pmodel, entvars_t *pev, float *pflFrameRate, float *pflGroundSpeed )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if (! pstudiohdr)
|
||||
if( !pstudiohdr )
|
||||
return;
|
||||
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
|
||||
if (pev->sequence >= pstudiohdr->numseq)
|
||||
if( pev->sequence >= pstudiohdr->numseq )
|
||||
{
|
||||
*pflFrameRate = 0.0;
|
||||
*pflGroundSpeed = 0.0;
|
||||
return;
|
||||
}
|
||||
|
||||
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
|
||||
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex ) + (int)pev->sequence;
|
||||
|
||||
if (pseqdesc->numframes > 1)
|
||||
if( pseqdesc->numframes > 1 )
|
||||
{
|
||||
*pflFrameRate = 256 * pseqdesc->fps / (pseqdesc->numframes - 1);
|
||||
*pflGroundSpeed = sqrt( pseqdesc->linearmovement[0]*pseqdesc->linearmovement[0]+ pseqdesc->linearmovement[1]*pseqdesc->linearmovement[1]+ pseqdesc->linearmovement[2]*pseqdesc->linearmovement[2] );
|
||||
*pflGroundSpeed = *pflGroundSpeed * pseqdesc->fps / (pseqdesc->numframes - 1);
|
||||
*pflFrameRate = 256 * pseqdesc->fps / ( pseqdesc->numframes - 1 );
|
||||
*pflGroundSpeed = sqrt( pseqdesc->linearmovement[0] * pseqdesc->linearmovement[0] + pseqdesc->linearmovement[1] * pseqdesc->linearmovement[1] + pseqdesc->linearmovement[2] * pseqdesc->linearmovement[2] );
|
||||
*pflGroundSpeed = *pflGroundSpeed * pseqdesc->fps / ( pseqdesc->numframes - 1 );
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -253,44 +246,42 @@ void GetSequenceInfo( void *pmodel, entvars_t *pev, float *pflFrameRate, float *
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
int GetSequenceFlags( void *pmodel, entvars_t *pev )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if ( !pstudiohdr || pev->sequence >= pstudiohdr->numseq )
|
||||
if( !pstudiohdr || pev->sequence >= pstudiohdr->numseq )
|
||||
return 0;
|
||||
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex ) + (int)pev->sequence;
|
||||
|
||||
return pseqdesc->flags;
|
||||
}
|
||||
|
||||
|
||||
int GetAnimationEvent( void *pmodel, entvars_t *pev, MonsterEvent_t *pMonsterEvent, float flStart, float flEnd, int index )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if ( !pstudiohdr || pev->sequence >= pstudiohdr->numseq || !pMonsterEvent )
|
||||
if( !pstudiohdr || pev->sequence >= pstudiohdr->numseq || !pMonsterEvent )
|
||||
return 0;
|
||||
|
||||
int events = 0;
|
||||
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
mstudioevent_t *pevent;
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
mstudioevent_t *pevent;
|
||||
|
||||
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
|
||||
pevent = (mstudioevent_t *)((byte *)pstudiohdr + pseqdesc->eventindex);
|
||||
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex ) + (int)pev->sequence;
|
||||
pevent = (mstudioevent_t *)( (byte *)pstudiohdr + pseqdesc->eventindex );
|
||||
|
||||
if (pseqdesc->numevents == 0 || index > pseqdesc->numevents )
|
||||
if( pseqdesc->numevents == 0 || index > pseqdesc->numevents )
|
||||
return 0;
|
||||
|
||||
if (pseqdesc->numframes > 1)
|
||||
if( pseqdesc->numframes > 1 )
|
||||
{
|
||||
flStart *= (pseqdesc->numframes - 1) / 256.0;
|
||||
flStart *= ( pseqdesc->numframes - 1 ) / 256.0;
|
||||
flEnd *= (pseqdesc->numframes - 1) / 256.0;
|
||||
}
|
||||
else
|
||||
|
@ -299,14 +290,14 @@ int GetAnimationEvent( void *pmodel, entvars_t *pev, MonsterEvent_t *pMonsterEve
|
|||
flEnd = 1.0;
|
||||
}
|
||||
|
||||
for (; index < pseqdesc->numevents; index++)
|
||||
for( ; index < pseqdesc->numevents; index++ )
|
||||
{
|
||||
// Don't send client-side events to the server AI
|
||||
if ( pevent[index].event >= EVENT_CLIENT )
|
||||
if( pevent[index].event >= EVENT_CLIENT )
|
||||
continue;
|
||||
|
||||
if ( (pevent[index].frame >= flStart && pevent[index].frame < flEnd) ||
|
||||
((pseqdesc->flags & STUDIO_LOOPING) && flEnd >= pseqdesc->numframes - 1 && pevent[index].frame < flEnd - pseqdesc->numframes + 1) )
|
||||
if( ( pevent[index].frame >= flStart && pevent[index].frame < flEnd ) ||
|
||||
( ( pseqdesc->flags & STUDIO_LOOPING ) && flEnd >= pseqdesc->numframes - 1 && pevent[index].frame < flEnd - pseqdesc->numframes + 1 ) )
|
||||
{
|
||||
pMonsterEvent->event = pevent[index].event;
|
||||
pMonsterEvent->options = pevent[index].options;
|
||||
|
@ -320,123 +311,122 @@ float SetController( void *pmodel, entvars_t *pev, int iController, float flValu
|
|||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
int i;
|
||||
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if (! pstudiohdr)
|
||||
if( !pstudiohdr )
|
||||
return flValue;
|
||||
|
||||
mstudiobonecontroller_t *pbonecontroller = (mstudiobonecontroller_t *)((byte *)pstudiohdr + pstudiohdr->bonecontrollerindex);
|
||||
mstudiobonecontroller_t *pbonecontroller = (mstudiobonecontroller_t *)( (byte *)pstudiohdr + pstudiohdr->bonecontrollerindex );
|
||||
|
||||
// find first controller that matches the index
|
||||
for (i = 0; i < pstudiohdr->numbonecontrollers; i++, pbonecontroller++)
|
||||
for( i = 0; i < pstudiohdr->numbonecontrollers; i++, pbonecontroller++ )
|
||||
{
|
||||
if (pbonecontroller->index == iController)
|
||||
if( pbonecontroller->index == iController )
|
||||
break;
|
||||
}
|
||||
if (i >= pstudiohdr->numbonecontrollers)
|
||||
if( i >= pstudiohdr->numbonecontrollers )
|
||||
return flValue;
|
||||
|
||||
// wrap 0..360 if it's a rotational controller
|
||||
|
||||
if (pbonecontroller->type & (STUDIO_XR | STUDIO_YR | STUDIO_ZR))
|
||||
if( pbonecontroller->type & ( STUDIO_XR | STUDIO_YR | STUDIO_ZR ) )
|
||||
{
|
||||
// ugly hack, invert value if end < start
|
||||
if (pbonecontroller->end < pbonecontroller->start)
|
||||
if( pbonecontroller->end < pbonecontroller->start )
|
||||
flValue = -flValue;
|
||||
|
||||
// does the controller not wrap?
|
||||
if (pbonecontroller->start + 359.0 >= pbonecontroller->end)
|
||||
if( pbonecontroller->start + 359.0 >= pbonecontroller->end )
|
||||
{
|
||||
if (flValue > ((pbonecontroller->start + pbonecontroller->end) / 2.0) + 180)
|
||||
if( flValue > ( ( pbonecontroller->start + pbonecontroller->end ) / 2.0 ) + 180 )
|
||||
flValue = flValue - 360;
|
||||
if (flValue < ((pbonecontroller->start + pbonecontroller->end) / 2.0) - 180)
|
||||
if( flValue < ( ( pbonecontroller->start + pbonecontroller->end) / 2.0 ) - 180 )
|
||||
flValue = flValue + 360;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (flValue > 360)
|
||||
flValue = flValue - (int)(flValue / 360.0) * 360.0;
|
||||
else if (flValue < 0)
|
||||
flValue = flValue + (int)((flValue / -360.0) + 1) * 360.0;
|
||||
if( flValue > 360 )
|
||||
flValue = flValue - (int)( flValue / 360.0 ) * 360.0;
|
||||
else if( flValue < 0 )
|
||||
flValue = flValue + (int)( ( flValue / -360.0 ) + 1 ) * 360.0;
|
||||
}
|
||||
}
|
||||
|
||||
int setting = 255 * (flValue - pbonecontroller->start) / (pbonecontroller->end - pbonecontroller->start);
|
||||
int setting = 255 * ( flValue - pbonecontroller->start ) / ( pbonecontroller->end - pbonecontroller->start );
|
||||
|
||||
if (setting < 0) setting = 0;
|
||||
if (setting > 255) setting = 255;
|
||||
if( setting < 0 )
|
||||
setting = 0;
|
||||
if( setting > 255 )
|
||||
setting = 255;
|
||||
pev->controller[iController] = setting;
|
||||
|
||||
return setting * (1.0 / 255.0) * (pbonecontroller->end - pbonecontroller->start) + pbonecontroller->start;
|
||||
return setting * ( 1.0 / 255.0 ) * (pbonecontroller->end - pbonecontroller->start ) + pbonecontroller->start;
|
||||
}
|
||||
|
||||
|
||||
float SetBlending( void *pmodel, entvars_t *pev, int iBlender, float flValue )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if (! pstudiohdr)
|
||||
if( !pstudiohdr )
|
||||
return flValue;
|
||||
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
|
||||
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
|
||||
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex ) + (int)pev->sequence;
|
||||
|
||||
if (pseqdesc->blendtype[iBlender] == 0)
|
||||
if( pseqdesc->blendtype[iBlender] == 0 )
|
||||
return flValue;
|
||||
|
||||
if (pseqdesc->blendtype[iBlender] & (STUDIO_XR | STUDIO_YR | STUDIO_ZR))
|
||||
if( pseqdesc->blendtype[iBlender] & ( STUDIO_XR | STUDIO_YR | STUDIO_ZR ) )
|
||||
{
|
||||
// ugly hack, invert value if end < start
|
||||
if (pseqdesc->blendend[iBlender] < pseqdesc->blendstart[iBlender])
|
||||
if( pseqdesc->blendend[iBlender] < pseqdesc->blendstart[iBlender] )
|
||||
flValue = -flValue;
|
||||
|
||||
// does the controller not wrap?
|
||||
if (pseqdesc->blendstart[iBlender] + 359.0 >= pseqdesc->blendend[iBlender])
|
||||
if( pseqdesc->blendstart[iBlender] + 359.0 >= pseqdesc->blendend[iBlender] )
|
||||
{
|
||||
if (flValue > ((pseqdesc->blendstart[iBlender] + pseqdesc->blendend[iBlender]) / 2.0) + 180)
|
||||
if( flValue > ( ( pseqdesc->blendstart[iBlender] + pseqdesc->blendend[iBlender] ) / 2.0 ) + 180 )
|
||||
flValue = flValue - 360;
|
||||
if (flValue < ((pseqdesc->blendstart[iBlender] + pseqdesc->blendend[iBlender]) / 2.0) - 180)
|
||||
if( flValue < ( ( pseqdesc->blendstart[iBlender] + pseqdesc->blendend[iBlender] ) / 2.0 ) - 180 )
|
||||
flValue = flValue + 360;
|
||||
}
|
||||
}
|
||||
|
||||
int setting = 255 * (flValue - pseqdesc->blendstart[iBlender]) / (pseqdesc->blendend[iBlender] - pseqdesc->blendstart[iBlender]);
|
||||
int setting = 255 * ( flValue - pseqdesc->blendstart[iBlender] ) / ( pseqdesc->blendend[iBlender] - pseqdesc->blendstart[iBlender] );
|
||||
|
||||
if (setting < 0) setting = 0;
|
||||
if (setting > 255) setting = 255;
|
||||
if( setting < 0 )
|
||||
setting = 0;
|
||||
if(setting > 255)
|
||||
setting = 255;
|
||||
|
||||
pev->blending[iBlender] = setting;
|
||||
|
||||
return setting * (1.0 / 255.0) * (pseqdesc->blendend[iBlender] - pseqdesc->blendstart[iBlender]) + pseqdesc->blendstart[iBlender];
|
||||
return setting * ( 1.0 / 255.0 ) * ( pseqdesc->blendend[iBlender] - pseqdesc->blendstart[iBlender] ) + pseqdesc->blendstart[iBlender];
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
int FindTransition( void *pmodel, int iEndingAnim, int iGoalAnim, int *piDir )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if (! pstudiohdr)
|
||||
if( !pstudiohdr )
|
||||
return iGoalAnim;
|
||||
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex );
|
||||
|
||||
// bail if we're going to or from a node 0
|
||||
if (pseqdesc[iEndingAnim].entrynode == 0 || pseqdesc[iGoalAnim].entrynode == 0)
|
||||
if( pseqdesc[iEndingAnim].entrynode == 0 || pseqdesc[iGoalAnim].entrynode == 0 )
|
||||
{
|
||||
return iGoalAnim;
|
||||
}
|
||||
|
||||
int iEndNode;
|
||||
int iEndNode;
|
||||
|
||||
// ALERT( at_console, "from %d to %d: ", pEndNode->iEndNode, pGoalNode->iStartNode );
|
||||
|
||||
if (*piDir > 0)
|
||||
if( *piDir > 0 )
|
||||
{
|
||||
iEndNode = pseqdesc[iEndingAnim].exitnode;
|
||||
}
|
||||
|
@ -445,32 +435,32 @@ int FindTransition( void *pmodel, int iEndingAnim, int iGoalAnim, int *piDir )
|
|||
iEndNode = pseqdesc[iEndingAnim].entrynode;
|
||||
}
|
||||
|
||||
if (iEndNode == pseqdesc[iGoalAnim].entrynode)
|
||||
if( iEndNode == pseqdesc[iGoalAnim].entrynode )
|
||||
{
|
||||
*piDir = 1;
|
||||
return iGoalAnim;
|
||||
}
|
||||
|
||||
byte *pTransition = ((byte *)pstudiohdr + pstudiohdr->transitionindex);
|
||||
byte *pTransition = ( (byte *)pstudiohdr + pstudiohdr->transitionindex );
|
||||
|
||||
int iInternNode = pTransition[(iEndNode-1)*pstudiohdr->numtransitions + (pseqdesc[iGoalAnim].entrynode-1)];
|
||||
int iInternNode = pTransition[( iEndNode - 1 ) * pstudiohdr->numtransitions + ( pseqdesc[iGoalAnim].entrynode - 1 )];
|
||||
|
||||
if (iInternNode == 0)
|
||||
if( iInternNode == 0 )
|
||||
return iGoalAnim;
|
||||
|
||||
int i;
|
||||
|
||||
// look for someone going
|
||||
for (i = 0; i < pstudiohdr->numseq; i++)
|
||||
for( i = 0; i < pstudiohdr->numseq; i++ )
|
||||
{
|
||||
if (pseqdesc[i].entrynode == iEndNode && pseqdesc[i].exitnode == iInternNode)
|
||||
if( pseqdesc[i].entrynode == iEndNode && pseqdesc[i].exitnode == iInternNode )
|
||||
{
|
||||
*piDir = 1;
|
||||
return i;
|
||||
}
|
||||
if (pseqdesc[i].nodeflags)
|
||||
if( pseqdesc[i].nodeflags )
|
||||
{
|
||||
if (pseqdesc[i].exitnode == iEndNode && pseqdesc[i].entrynode == iInternNode)
|
||||
if( pseqdesc[i].exitnode == iEndNode && pseqdesc[i].entrynode == iInternNode )
|
||||
{
|
||||
*piDir = -1;
|
||||
return i;
|
||||
|
@ -485,42 +475,41 @@ int FindTransition( void *pmodel, int iEndingAnim, int iGoalAnim, int *piDir )
|
|||
void SetBodygroup( void *pmodel, entvars_t *pev, int iGroup, int iValue )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if (! pstudiohdr)
|
||||
if( !pstudiohdr )
|
||||
return;
|
||||
|
||||
if (iGroup > pstudiohdr->numbodyparts)
|
||||
if( iGroup > pstudiohdr->numbodyparts )
|
||||
return;
|
||||
|
||||
mstudiobodyparts_t *pbodypart = (mstudiobodyparts_t *)((byte *)pstudiohdr + pstudiohdr->bodypartindex) + iGroup;
|
||||
mstudiobodyparts_t *pbodypart = (mstudiobodyparts_t *)( (byte *)pstudiohdr + pstudiohdr->bodypartindex ) + iGroup;
|
||||
|
||||
if (iValue >= pbodypart->nummodels)
|
||||
if( iValue >= pbodypart->nummodels )
|
||||
return;
|
||||
|
||||
int iCurrent = (pev->body / pbodypart->base) % pbodypart->nummodels;
|
||||
int iCurrent = ( pev->body / pbodypart->base ) % pbodypart->nummodels;
|
||||
|
||||
pev->body = (pev->body - (iCurrent * pbodypart->base) + (iValue * pbodypart->base));
|
||||
pev->body = ( pev->body - ( iCurrent * pbodypart->base ) + ( iValue * pbodypart->base ) );
|
||||
}
|
||||
|
||||
|
||||
int GetBodygroup( void *pmodel, entvars_t *pev, int iGroup )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if (! pstudiohdr)
|
||||
if( !pstudiohdr )
|
||||
return 0;
|
||||
|
||||
if (iGroup > pstudiohdr->numbodyparts)
|
||||
if( iGroup > pstudiohdr->numbodyparts )
|
||||
return 0;
|
||||
|
||||
mstudiobodyparts_t *pbodypart = (mstudiobodyparts_t *)((byte *)pstudiohdr + pstudiohdr->bodypartindex) + iGroup;
|
||||
mstudiobodyparts_t *pbodypart = (mstudiobodyparts_t *)( (byte *)pstudiohdr + pstudiohdr->bodypartindex ) + iGroup;
|
||||
|
||||
if (pbodypart->nummodels <= 1)
|
||||
if( pbodypart->nummodels <= 1 )
|
||||
return 0;
|
||||
|
||||
int iCurrent = (pev->body / pbodypart->base) % pbodypart->nummodels;
|
||||
int iCurrent = ( pev->body / pbodypart->base ) % pbodypart->nummodels;
|
||||
|
||||
return iCurrent;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -42,6 +42,4 @@ int ExtractBbox( void *pmodel, int sequence, float *mins, float *maxs );
|
|||
|
||||
// From /engine/studio.h
|
||||
#define STUDIO_LOOPING 0x0001
|
||||
|
||||
|
||||
#endif //ANIMATION_H
|
||||
|
|
484
dlls/apache.cpp
484
dlls/apache.cpp
File diff suppressed because it is too large
Load Diff
|
@ -36,23 +36,23 @@ class CBarnacle : public CBaseMonster
|
|||
public:
|
||||
void Spawn( void );
|
||||
void Precache( void );
|
||||
CBaseEntity *TongueTouchEnt ( float *pflLength );
|
||||
int Classify ( void );
|
||||
CBaseEntity *TongueTouchEnt( float *pflLength );
|
||||
int Classify( void );
|
||||
void HandleAnimEvent( MonsterEvent_t *pEvent );
|
||||
void EXPORT BarnacleThink ( void );
|
||||
void EXPORT WaitTillDead ( void );
|
||||
void EXPORT BarnacleThink( void );
|
||||
void EXPORT WaitTillDead( void );
|
||||
void Killed( entvars_t *pevAttacker, int iGib );
|
||||
int TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
static TYPEDESCRIPTION m_SaveData[];
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
static TYPEDESCRIPTION m_SaveData[];
|
||||
|
||||
float m_flAltitude;
|
||||
float m_flCachedLength; // tongue cached length
|
||||
float m_flKillVictimTime;
|
||||
int m_cGibs; // barnacle loads up on gibs each time it kills something.
|
||||
BOOL m_fTongueExtended;
|
||||
BOOL m_fLiftingPrey;
|
||||
int m_cGibs; // barnacle loads up on gibs each time it kills something.
|
||||
BOOL m_fTongueExtended;
|
||||
BOOL m_fLiftingPrey;
|
||||
float m_flTongueAdj;
|
||||
|
||||
// FIXME: need a custom barnacle model with non-generic hitgroup
|
||||
|
@ -65,9 +65,10 @@ public:
|
|||
}
|
||||
#endif
|
||||
};
|
||||
LINK_ENTITY_TO_CLASS( monster_barnacle, CBarnacle );
|
||||
|
||||
TYPEDESCRIPTION CBarnacle::m_SaveData[] =
|
||||
LINK_ENTITY_TO_CLASS( monster_barnacle, CBarnacle )
|
||||
|
||||
TYPEDESCRIPTION CBarnacle::m_SaveData[] =
|
||||
{
|
||||
DEFINE_FIELD( CBarnacle, m_flAltitude, FIELD_FLOAT ),
|
||||
DEFINE_FIELD( CBarnacle, m_flKillVictimTime, FIELD_TIME ),
|
||||
|
@ -78,16 +79,15 @@ TYPEDESCRIPTION CBarnacle::m_SaveData[] =
|
|||
DEFINE_FIELD( CBarnacle, m_flCachedLength, FIELD_FLOAT ),
|
||||
};
|
||||
|
||||
IMPLEMENT_SAVERESTORE( CBarnacle, CBaseMonster );
|
||||
|
||||
IMPLEMENT_SAVERESTORE( CBarnacle, CBaseMonster )
|
||||
|
||||
//=========================================================
|
||||
// Classify - indicates this monster's place in the
|
||||
// relationship table.
|
||||
//=========================================================
|
||||
int CBarnacle :: Classify ( void )
|
||||
int CBarnacle::Classify( void )
|
||||
{
|
||||
return CLASS_ALIEN_MONSTER;
|
||||
return CLASS_ALIEN_MONSTER;
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
|
@ -96,7 +96,7 @@ int CBarnacle :: Classify ( void )
|
|||
//
|
||||
// Returns number of events handled, 0 if none.
|
||||
//=========================================================
|
||||
void CBarnacle :: HandleAnimEvent( MonsterEvent_t *pEvent )
|
||||
void CBarnacle::HandleAnimEvent( MonsterEvent_t *pEvent )
|
||||
{
|
||||
switch( pEvent->event )
|
||||
{
|
||||
|
@ -112,40 +112,40 @@ void CBarnacle :: HandleAnimEvent( MonsterEvent_t *pEvent )
|
|||
//=========================================================
|
||||
// Spawn
|
||||
//=========================================================
|
||||
void CBarnacle :: Spawn()
|
||||
void CBarnacle::Spawn()
|
||||
{
|
||||
Precache( );
|
||||
Precache();
|
||||
|
||||
SET_MODEL(ENT(pev), "models/barnacle.mdl");
|
||||
UTIL_SetSize( pev, Vector(-16, -16, -32), Vector(16, 16, 0) );
|
||||
SET_MODEL( ENT( pev ), "models/barnacle.mdl" );
|
||||
UTIL_SetSize( pev, Vector( -16, -16, -32 ), Vector( 16, 16, 0 ) );
|
||||
|
||||
pev->solid = SOLID_SLIDEBOX;
|
||||
pev->movetype = MOVETYPE_NONE;
|
||||
pev->takedamage = DAMAGE_AIM;
|
||||
m_bloodColor = BLOOD_COLOR_RED;
|
||||
pev->effects = EF_INVLIGHT; // take light from the ceiling
|
||||
pev->health = 25;
|
||||
m_flFieldOfView = 0.5;// indicates the width of this monster's forward view cone ( as a dotproduct result )
|
||||
m_MonsterState = MONSTERSTATE_NONE;
|
||||
m_flKillVictimTime = 0;
|
||||
pev->solid = SOLID_SLIDEBOX;
|
||||
pev->movetype = MOVETYPE_NONE;
|
||||
pev->takedamage = DAMAGE_AIM;
|
||||
m_bloodColor = BLOOD_COLOR_RED;
|
||||
pev->effects = EF_INVLIGHT; // take light from the ceiling
|
||||
pev->health = 25;
|
||||
m_flFieldOfView = 0.5;// indicates the width of this monster's forward view cone ( as a dotproduct result )
|
||||
m_MonsterState = MONSTERSTATE_NONE;
|
||||
m_flKillVictimTime = 0;
|
||||
m_flCachedLength = 32; // mins.z
|
||||
m_cGibs = 0;
|
||||
m_fLiftingPrey = FALSE;
|
||||
m_flTongueAdj = -100;
|
||||
m_cGibs = 0;
|
||||
m_fLiftingPrey = FALSE;
|
||||
m_flTongueAdj = -100;
|
||||
|
||||
InitBoneControllers();
|
||||
|
||||
SetActivity ( ACT_IDLE );
|
||||
SetActivity( ACT_IDLE );
|
||||
|
||||
SetThink( &CBarnacle::BarnacleThink );
|
||||
pev->nextthink = gpGlobals->time + 0.5;
|
||||
|
||||
UTIL_SetOrigin ( pev, pev->origin );
|
||||
UTIL_SetOrigin( pev, pev->origin );
|
||||
}
|
||||
|
||||
int CBarnacle::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
|
||||
{
|
||||
if ( bitsDamageType & DMG_CLUB )
|
||||
if( bitsDamageType & DMG_CLUB )
|
||||
{
|
||||
flDamage = pev->health;
|
||||
}
|
||||
|
@ -155,27 +155,25 @@ int CBarnacle::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, floa
|
|||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CBarnacle :: BarnacleThink ( void )
|
||||
void CBarnacle::BarnacleThink( void )
|
||||
{
|
||||
CBaseEntity *pTouchEnt;
|
||||
CBaseMonster *pVictim;
|
||||
float flLength;
|
||||
|
||||
#ifdef BARNACLE_FIX_VISIBILITY
|
||||
if( m_flCachedLength != ( m_flAltitude + m_flTongueAdj ) || ( pev->absmin.z != pev->origin.z + -m_flCachedLength ))
|
||||
if( m_flCachedLength != ( m_flAltitude + m_flTongueAdj ) || ( pev->absmin.z != pev->origin.z + -m_flCachedLength ) )
|
||||
{
|
||||
// recalc collision box here to avoid barnacle disappears bug
|
||||
m_flCachedLength = (m_flAltitude + m_flTongueAdj);
|
||||
m_flCachedLength = m_flAltitude + m_flTongueAdj;
|
||||
UTIL_SetOrigin( pev, pev->origin );
|
||||
}
|
||||
#endif
|
||||
pev->nextthink = gpGlobals->time + 0.1;
|
||||
|
||||
if ( m_hEnemy != NULL )
|
||||
if( m_hEnemy != NULL )
|
||||
{
|
||||
// barnacle has prey.
|
||||
|
||||
if ( !m_hEnemy->IsAlive() )
|
||||
// barnacle has prey.
|
||||
if( !m_hEnemy->IsAlive() )
|
||||
{
|
||||
// someone (maybe even the barnacle) killed the prey. Reset barnacle.
|
||||
m_fLiftingPrey = FALSE;// indicate that we're not lifting prey.
|
||||
|
@ -183,9 +181,9 @@ void CBarnacle :: BarnacleThink ( void )
|
|||
return;
|
||||
}
|
||||
|
||||
if ( m_fLiftingPrey )
|
||||
if( m_fLiftingPrey )
|
||||
{
|
||||
if ( m_hEnemy != NULL && m_hEnemy->pev->deadflag != DEAD_NO )
|
||||
if( m_hEnemy != NULL && m_hEnemy->pev->deadflag != DEAD_NO )
|
||||
{
|
||||
// crap, someone killed the prey on the way up.
|
||||
m_hEnemy = NULL;
|
||||
|
@ -193,50 +191,49 @@ void CBarnacle :: BarnacleThink ( void )
|
|||
return;
|
||||
}
|
||||
|
||||
// still pulling prey.
|
||||
// still pulling prey.
|
||||
Vector vecNewEnemyOrigin = m_hEnemy->pev->origin;
|
||||
vecNewEnemyOrigin.x = pev->origin.x;
|
||||
vecNewEnemyOrigin.y = pev->origin.y;
|
||||
|
||||
// guess as to where their neck is
|
||||
vecNewEnemyOrigin.x -= 6 * cos(m_hEnemy->pev->angles.y * M_PI/180.0);
|
||||
vecNewEnemyOrigin.y -= 6 * sin(m_hEnemy->pev->angles.y * M_PI/180.0);
|
||||
vecNewEnemyOrigin.x -= 6 * cos( m_hEnemy->pev->angles.y * M_PI / 180.0 );
|
||||
vecNewEnemyOrigin.y -= 6 * sin( m_hEnemy->pev->angles.y * M_PI / 180.0 );
|
||||
|
||||
m_flAltitude -= BARNACLE_PULL_SPEED;
|
||||
vecNewEnemyOrigin.z += BARNACLE_PULL_SPEED;
|
||||
|
||||
if ( fabs( pev->origin.z - ( vecNewEnemyOrigin.z + m_hEnemy->pev->view_ofs.z - 8 ) ) < BARNACLE_BODY_HEIGHT )
|
||||
if( fabs( pev->origin.z - ( vecNewEnemyOrigin.z + m_hEnemy->pev->view_ofs.z - 8 ) ) < BARNACLE_BODY_HEIGHT )
|
||||
{
|
||||
// prey has just been lifted into position ( if the victim origin + eye height + 8 is higher than the bottom of the barnacle, it is assumed that the head is within barnacle's body )
|
||||
// prey has just been lifted into position ( if the victim origin + eye height + 8 is higher than the bottom of the barnacle, it is assumed that the head is within barnacle's body )
|
||||
m_fLiftingPrey = FALSE;
|
||||
|
||||
EMIT_SOUND( ENT(pev), CHAN_WEAPON, "barnacle/bcl_bite3.wav", 1, ATTN_NORM );
|
||||
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "barnacle/bcl_bite3.wav", 1, ATTN_NORM );
|
||||
|
||||
pVictim = m_hEnemy->MyMonsterPointer();
|
||||
|
||||
m_flKillVictimTime = gpGlobals->time + 10;// now that the victim is in place, the killing bite will be administered in 10 seconds.
|
||||
|
||||
if ( pVictim )
|
||||
if( pVictim )
|
||||
{
|
||||
pVictim->BarnacleVictimBitten( pev );
|
||||
SetActivity ( ACT_EAT );
|
||||
SetActivity( ACT_EAT );
|
||||
}
|
||||
}
|
||||
|
||||
UTIL_SetOrigin ( m_hEnemy->pev, vecNewEnemyOrigin );
|
||||
UTIL_SetOrigin( m_hEnemy->pev, vecNewEnemyOrigin );
|
||||
}
|
||||
else
|
||||
{
|
||||
// prey is lifted fully into feeding position and is dangling there.
|
||||
|
||||
// prey is lifted fully into feeding position and is dangling there.
|
||||
pVictim = m_hEnemy->MyMonsterPointer();
|
||||
|
||||
if ( m_flKillVictimTime != -1 && gpGlobals->time > m_flKillVictimTime )
|
||||
if( m_flKillVictimTime != -1 && gpGlobals->time > m_flKillVictimTime )
|
||||
{
|
||||
// kill!
|
||||
if ( pVictim )
|
||||
if( pVictim )
|
||||
{
|
||||
pVictim->TakeDamage ( pev, pev, pVictim->pev->health, DMG_SLASH | DMG_ALWAYSGIB );
|
||||
pVictim->TakeDamage( pev, pev, pVictim->pev->health, DMG_SLASH | DMG_ALWAYSGIB );
|
||||
m_cGibs = 3;
|
||||
}
|
||||
|
||||
|
@ -244,58 +241,69 @@ void CBarnacle :: BarnacleThink ( void )
|
|||
}
|
||||
|
||||
// bite prey every once in a while
|
||||
if ( pVictim && ( RANDOM_LONG(0,49) == 0 ) )
|
||||
if( pVictim && ( RANDOM_LONG( 0, 49 ) == 0 ) )
|
||||
{
|
||||
switch ( RANDOM_LONG(0,2) )
|
||||
switch( RANDOM_LONG( 0, 2 ) )
|
||||
{
|
||||
case 0: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "barnacle/bcl_chew1.wav", 1, ATTN_NORM ); break;
|
||||
case 1: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "barnacle/bcl_chew2.wav", 1, ATTN_NORM ); break;
|
||||
case 2: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "barnacle/bcl_chew3.wav", 1, ATTN_NORM ); break;
|
||||
case 0:
|
||||
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "barnacle/bcl_chew1.wav", 1, ATTN_NORM );
|
||||
break;
|
||||
case 1:
|
||||
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "barnacle/bcl_chew2.wav", 1, ATTN_NORM );
|
||||
break;
|
||||
case 2:
|
||||
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "barnacle/bcl_chew3.wav", 1, ATTN_NORM );
|
||||
break;
|
||||
}
|
||||
|
||||
pVictim->BarnacleVictimBitten( pev );
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// barnacle has no prey right now, so just idle and check to see if anything is touching the tongue.
|
||||
|
||||
// barnacle has no prey right now, so just idle and check to see if anything is touching the tongue.
|
||||
// If idle and no nearby client, don't think so often
|
||||
if ( FNullEnt( FIND_CLIENT_IN_PVS( edict() ) ) )
|
||||
pev->nextthink = gpGlobals->time + RANDOM_FLOAT(1,1.5); // Stagger a bit to keep barnacles from thinking on the same frame
|
||||
if( FNullEnt( FIND_CLIENT_IN_PVS( edict() ) ) )
|
||||
pev->nextthink = gpGlobals->time + RANDOM_FLOAT( 1, 1.5 ); // Stagger a bit to keep barnacles from thinking on the same frame
|
||||
|
||||
if ( m_fSequenceFinished )
|
||||
{// this is done so barnacle will fidget.
|
||||
if( m_fSequenceFinished )
|
||||
{
|
||||
// this is done so barnacle will fidget.
|
||||
SetActivity ( ACT_IDLE );
|
||||
m_flTongueAdj = -100;
|
||||
}
|
||||
|
||||
if ( m_cGibs && RANDOM_LONG(0,99) == 1 )
|
||||
if( m_cGibs && RANDOM_LONG( 0, 99 ) == 1 )
|
||||
{
|
||||
// cough up a gib.
|
||||
CGib::SpawnRandomGibs( pev, 1, 1 );
|
||||
m_cGibs--;
|
||||
|
||||
switch ( RANDOM_LONG(0,2) )
|
||||
switch ( RANDOM_LONG( 0, 2 ) )
|
||||
{
|
||||
case 0: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "barnacle/bcl_chew1.wav", 1, ATTN_NORM ); break;
|
||||
case 1: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "barnacle/bcl_chew2.wav", 1, ATTN_NORM ); break;
|
||||
case 2: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "barnacle/bcl_chew3.wav", 1, ATTN_NORM ); break;
|
||||
case 0:
|
||||
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "barnacle/bcl_chew1.wav", 1, ATTN_NORM );
|
||||
break;
|
||||
case 1:
|
||||
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "barnacle/bcl_chew2.wav", 1, ATTN_NORM );
|
||||
break;
|
||||
case 2:
|
||||
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "barnacle/bcl_chew3.wav", 1, ATTN_NORM );
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
pTouchEnt = TongueTouchEnt( &flLength );
|
||||
|
||||
if ( pTouchEnt != NULL && m_fTongueExtended )
|
||||
if( pTouchEnt != NULL && m_fTongueExtended )
|
||||
{
|
||||
// tongue is fully extended, and is touching someone.
|
||||
if ( pTouchEnt->FBecomeProne() )
|
||||
if( pTouchEnt->FBecomeProne() )
|
||||
{
|
||||
EMIT_SOUND( ENT(pev), CHAN_WEAPON, "barnacle/bcl_alert2.wav", 1, ATTN_NORM );
|
||||
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "barnacle/bcl_alert2.wav", 1, ATTN_NORM );
|
||||
|
||||
SetSequenceByName ( "attack1" );
|
||||
SetSequenceByName( "attack1" );
|
||||
m_flTongueAdj = -20;
|
||||
|
||||
m_hEnemy = pTouchEnt;
|
||||
|
@ -309,13 +317,13 @@ void CBarnacle :: BarnacleThink ( void )
|
|||
m_fLiftingPrey = TRUE;// indicate that we should be lifting prey.
|
||||
m_flKillVictimTime = -1;// set this to a bogus time while the victim is lifted.
|
||||
|
||||
m_flAltitude = (pev->origin.z - pTouchEnt->EyePosition().z);
|
||||
m_flAltitude = pev->origin.z - pTouchEnt->EyePosition().z;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// calculate a new length for the tongue to be clear of anything else that moves under it.
|
||||
if ( m_flAltitude < flLength )
|
||||
if( m_flAltitude < flLength )
|
||||
{
|
||||
// if tongue is higher than is should be, lower it kind of slowly.
|
||||
m_flAltitude += BARNACLE_PULL_SPEED;
|
||||
|
@ -326,45 +334,47 @@ void CBarnacle :: BarnacleThink ( void )
|
|||
m_flAltitude = flLength;
|
||||
m_fTongueExtended = TRUE;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// ALERT( at_console, "tounge %f\n", m_flAltitude + m_flTongueAdj );
|
||||
SetBoneController( 0, -(m_flAltitude + m_flTongueAdj) );
|
||||
SetBoneController( 0, -( m_flAltitude + m_flTongueAdj ) );
|
||||
StudioFrameAdvance( 0.1 );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
// Killed.
|
||||
//=========================================================
|
||||
void CBarnacle :: Killed( entvars_t *pevAttacker, int iGib )
|
||||
void CBarnacle::Killed( entvars_t *pevAttacker, int iGib )
|
||||
{
|
||||
CBaseMonster *pVictim;
|
||||
|
||||
pev->solid = SOLID_NOT;
|
||||
pev->takedamage = DAMAGE_NO;
|
||||
|
||||
if ( m_hEnemy != NULL )
|
||||
if( m_hEnemy != NULL )
|
||||
{
|
||||
pVictim = m_hEnemy->MyMonsterPointer();
|
||||
|
||||
if ( pVictim )
|
||||
if( pVictim )
|
||||
{
|
||||
pVictim->BarnacleVictimReleased();
|
||||
}
|
||||
}
|
||||
|
||||
// CGib::SpawnRandomGibs( pev, 4, 1 );
|
||||
//CGib::SpawnRandomGibs( pev, 4, 1 );
|
||||
|
||||
switch ( RANDOM_LONG ( 0, 1 ) )
|
||||
switch( RANDOM_LONG ( 0, 1 ) )
|
||||
{
|
||||
case 0: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "barnacle/bcl_die1.wav", 1, ATTN_NORM ); break;
|
||||
case 1: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "barnacle/bcl_die3.wav", 1, ATTN_NORM ); break;
|
||||
case 0:
|
||||
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "barnacle/bcl_die1.wav", 1, ATTN_NORM );
|
||||
break;
|
||||
case 1:
|
||||
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "barnacle/bcl_die3.wav", 1, ATTN_NORM );
|
||||
break;
|
||||
}
|
||||
|
||||
SetActivity ( ACT_DIESIMPLE );
|
||||
SetActivity( ACT_DIESIMPLE );
|
||||
SetBoneController( 0, 0 );
|
||||
|
||||
StudioFrameAdvance( 0.1 );
|
||||
|
@ -375,14 +385,14 @@ void CBarnacle :: Killed( entvars_t *pevAttacker, int iGib )
|
|||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CBarnacle :: WaitTillDead ( void )
|
||||
void CBarnacle::WaitTillDead( void )
|
||||
{
|
||||
pev->nextthink = gpGlobals->time + 0.1;
|
||||
|
||||
float flInterval = StudioFrameAdvance( 0.1 );
|
||||
DispatchAnimEvents ( flInterval );
|
||||
DispatchAnimEvents( flInterval );
|
||||
|
||||
if ( m_fSequenceFinished )
|
||||
if( m_fSequenceFinished )
|
||||
{
|
||||
// death anim finished.
|
||||
StopAnimation();
|
||||
|
@ -393,17 +403,17 @@ void CBarnacle :: WaitTillDead ( void )
|
|||
//=========================================================
|
||||
// Precache - precaches all resources this monster needs
|
||||
//=========================================================
|
||||
void CBarnacle :: Precache()
|
||||
void CBarnacle::Precache()
|
||||
{
|
||||
PRECACHE_MODEL("models/barnacle.mdl");
|
||||
PRECACHE_MODEL( "models/barnacle.mdl" );
|
||||
|
||||
PRECACHE_SOUND("barnacle/bcl_alert2.wav");//happy, lifting food up
|
||||
PRECACHE_SOUND("barnacle/bcl_bite3.wav");//just got food to mouth
|
||||
PRECACHE_SOUND("barnacle/bcl_chew1.wav");
|
||||
PRECACHE_SOUND("barnacle/bcl_chew2.wav");
|
||||
PRECACHE_SOUND("barnacle/bcl_chew3.wav");
|
||||
PRECACHE_SOUND("barnacle/bcl_die1.wav" );
|
||||
PRECACHE_SOUND("barnacle/bcl_die3.wav" );
|
||||
PRECACHE_SOUND( "barnacle/bcl_alert2.wav" );//happy, lifting food up
|
||||
PRECACHE_SOUND( "barnacle/bcl_bite3.wav" );//just got food to mouth
|
||||
PRECACHE_SOUND( "barnacle/bcl_chew1.wav" );
|
||||
PRECACHE_SOUND( "barnacle/bcl_chew2.wav" );
|
||||
PRECACHE_SOUND( "barnacle/bcl_chew3.wav" );
|
||||
PRECACHE_SOUND( "barnacle/bcl_die1.wav" );
|
||||
PRECACHE_SOUND( "barnacle/bcl_die3.wav" );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
|
@ -412,15 +422,15 @@ void CBarnacle :: Precache()
|
|||
// of the trace in the int pointer provided.
|
||||
//=========================================================
|
||||
#define BARNACLE_CHECK_SPACING 8
|
||||
CBaseEntity *CBarnacle :: TongueTouchEnt ( float *pflLength )
|
||||
CBaseEntity *CBarnacle::TongueTouchEnt( float *pflLength )
|
||||
{
|
||||
TraceResult tr;
|
||||
float length;
|
||||
TraceResult tr;
|
||||
float length;
|
||||
|
||||
// trace once to hit architecture and see if the tongue needs to change position.
|
||||
UTIL_TraceLine ( pev->origin, pev->origin - Vector ( 0 , 0 , 2048 ), ignore_monsters, ENT(pev), &tr );
|
||||
UTIL_TraceLine( pev->origin, pev->origin - Vector ( 0, 0, 2048 ), ignore_monsters, ENT( pev ), &tr );
|
||||
length = fabs( pev->origin.z - tr.vecEndPos.z );
|
||||
if ( pflLength )
|
||||
if( pflLength )
|
||||
{
|
||||
*pflLength = length;
|
||||
}
|
||||
|
@ -432,13 +442,13 @@ CBaseEntity *CBarnacle :: TongueTouchEnt ( float *pflLength )
|
|||
mins.z -= length;
|
||||
|
||||
CBaseEntity *pList[10];
|
||||
int count = UTIL_EntitiesInBox( pList, 10, mins, maxs, (FL_CLIENT|FL_MONSTER) );
|
||||
if ( count )
|
||||
int count = UTIL_EntitiesInBox( pList, 10, mins, maxs, ( FL_CLIENT | FL_MONSTER ) );
|
||||
if( count )
|
||||
{
|
||||
for ( int i = 0; i < count; i++ )
|
||||
for( int i = 0; i < count; i++ )
|
||||
{
|
||||
// only clients and monsters
|
||||
if ( pList[i] != this && IRelationship( pList[i] ) > R_NO && pList[ i ]->pev->deadflag == DEAD_NO ) // this ent is one of our enemies. Barnacle tries to eat it.
|
||||
if( pList[i] != this && IRelationship( pList[i] ) > R_NO && pList[ i ]->pev->deadflag == DEAD_NO ) // this ent is one of our enemies. Barnacle tries to eat it.
|
||||
{
|
||||
return pList[i];
|
||||
}
|
||||
|
|
483
dlls/barney.cpp
483
dlls/barney.cpp
|
@ -38,7 +38,7 @@
|
|||
|
||||
#define BARNEY_BODY_GUNHOLSTERED 0
|
||||
#define BARNEY_BODY_GUNDRAWN 1
|
||||
#define BARNEY_BODY_GUNGONE 2
|
||||
#define BARNEY_BODY_GUNGONE 2
|
||||
|
||||
class CBarney : public CTalkMonster
|
||||
{
|
||||
|
@ -46,51 +46,51 @@ public:
|
|||
void Spawn( void );
|
||||
void Precache( void );
|
||||
void SetYawSpeed( void );
|
||||
int ISoundMask( void );
|
||||
int ISoundMask( void );
|
||||
void BarneyFirePistol( void );
|
||||
void AlertSound( void );
|
||||
int Classify ( void );
|
||||
int Classify( void );
|
||||
void HandleAnimEvent( MonsterEvent_t *pEvent );
|
||||
|
||||
|
||||
void RunTask( Task_t *pTask );
|
||||
void StartTask( Task_t *pTask );
|
||||
virtual int ObjectCaps( void ) { return CTalkMonster :: ObjectCaps() | FCAP_IMPULSE_USE; }
|
||||
virtual int ObjectCaps( void ) { return CTalkMonster :: ObjectCaps() | FCAP_IMPULSE_USE; }
|
||||
int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType);
|
||||
BOOL CheckRangeAttack1 ( float flDot, float flDist );
|
||||
|
||||
BOOL CheckRangeAttack1( float flDot, float flDist );
|
||||
|
||||
void DeclineFollowing( void );
|
||||
|
||||
// Override these to set behavior
|
||||
Schedule_t *GetScheduleOfType ( int Type );
|
||||
Schedule_t *GetSchedule ( void );
|
||||
MONSTERSTATE GetIdealState ( void );
|
||||
Schedule_t *GetScheduleOfType( int Type );
|
||||
Schedule_t *GetSchedule( void );
|
||||
MONSTERSTATE GetIdealState( void );
|
||||
|
||||
void DeathSound( void );
|
||||
void PainSound( void );
|
||||
|
||||
|
||||
void TalkInit( void );
|
||||
|
||||
void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
|
||||
void Killed( entvars_t *pevAttacker, int iGib );
|
||||
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
static TYPEDESCRIPTION m_SaveData[];
|
||||
|
||||
BOOL m_fGunDrawn;
|
||||
float m_painTime;
|
||||
float m_checkAttackTime;
|
||||
BOOL m_lastAttackCheck;
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
static TYPEDESCRIPTION m_SaveData[];
|
||||
|
||||
BOOL m_fGunDrawn;
|
||||
float m_painTime;
|
||||
float m_checkAttackTime;
|
||||
BOOL m_lastAttackCheck;
|
||||
|
||||
// UNDONE: What is this for? It isn't used?
|
||||
float m_flPlayerDamage;// how much pain has the player inflicted on me?
|
||||
float m_flPlayerDamage;// how much pain has the player inflicted on me?
|
||||
|
||||
CUSTOM_SCHEDULES;
|
||||
CUSTOM_SCHEDULES
|
||||
};
|
||||
|
||||
LINK_ENTITY_TO_CLASS( monster_barney, CBarney );
|
||||
LINK_ENTITY_TO_CLASS( monster_barney, CBarney )
|
||||
|
||||
TYPEDESCRIPTION CBarney::m_SaveData[] =
|
||||
TYPEDESCRIPTION CBarney::m_SaveData[] =
|
||||
{
|
||||
DEFINE_FIELD( CBarney, m_fGunDrawn, FIELD_BOOLEAN ),
|
||||
DEFINE_FIELD( CBarney, m_painTime, FIELD_TIME ),
|
||||
|
@ -99,25 +99,25 @@ TYPEDESCRIPTION CBarney::m_SaveData[] =
|
|||
DEFINE_FIELD( CBarney, m_flPlayerDamage, FIELD_FLOAT ),
|
||||
};
|
||||
|
||||
IMPLEMENT_SAVERESTORE( CBarney, CTalkMonster );
|
||||
IMPLEMENT_SAVERESTORE( CBarney, CTalkMonster )
|
||||
|
||||
//=========================================================
|
||||
// AI Schedules Specific to this monster
|
||||
//=========================================================
|
||||
Task_t tlBaFollow[] =
|
||||
Task_t tlBaFollow[] =
|
||||
{
|
||||
{ TASK_MOVE_TO_TARGET_RANGE,(float)128 }, // Move within 128 of target ent (client)
|
||||
{ TASK_SET_SCHEDULE, (float)SCHED_TARGET_FACE },
|
||||
{ TASK_MOVE_TO_TARGET_RANGE, (float)128 }, // Move within 128 of target ent (client)
|
||||
{ TASK_SET_SCHEDULE, (float)SCHED_TARGET_FACE },
|
||||
};
|
||||
|
||||
Schedule_t slBaFollow[] =
|
||||
Schedule_t slBaFollow[] =
|
||||
{
|
||||
{
|
||||
tlBaFollow,
|
||||
ARRAYSIZE ( tlBaFollow ),
|
||||
bits_COND_NEW_ENEMY |
|
||||
bits_COND_LIGHT_DAMAGE |
|
||||
bits_COND_HEAVY_DAMAGE |
|
||||
ARRAYSIZE( tlBaFollow ),
|
||||
bits_COND_NEW_ENEMY |
|
||||
bits_COND_LIGHT_DAMAGE |
|
||||
bits_COND_HEAVY_DAMAGE |
|
||||
bits_COND_HEAR_SOUND |
|
||||
bits_COND_PROVOKED,
|
||||
bits_SOUND_DANGER,
|
||||
|
@ -126,44 +126,44 @@ Schedule_t slBaFollow[] =
|
|||
};
|
||||
|
||||
//=========================================================
|
||||
// BarneyDraw- much better looking draw schedule for when
|
||||
// BarneyDraw - much better looking draw schedule for when
|
||||
// barney knows who he's gonna attack.
|
||||
//=========================================================
|
||||
Task_t tlBarneyEnemyDraw[] =
|
||||
Task_t tlBarneyEnemyDraw[] =
|
||||
{
|
||||
{ TASK_STOP_MOVING, 0 },
|
||||
{ TASK_FACE_ENEMY, 0 },
|
||||
{ TASK_PLAY_SEQUENCE_FACE_ENEMY, (float) ACT_ARM },
|
||||
{ TASK_STOP_MOVING, 0 },
|
||||
{ TASK_FACE_ENEMY, 0 },
|
||||
{ TASK_PLAY_SEQUENCE_FACE_ENEMY, (float) ACT_ARM },
|
||||
};
|
||||
|
||||
Schedule_t slBarneyEnemyDraw[] =
|
||||
Schedule_t slBarneyEnemyDraw[] =
|
||||
{
|
||||
{
|
||||
tlBarneyEnemyDraw,
|
||||
ARRAYSIZE ( tlBarneyEnemyDraw ),
|
||||
ARRAYSIZE( tlBarneyEnemyDraw ),
|
||||
0,
|
||||
0,
|
||||
"Barney Enemy Draw"
|
||||
}
|
||||
};
|
||||
|
||||
Task_t tlBaFaceTarget[] =
|
||||
Task_t tlBaFaceTarget[] =
|
||||
{
|
||||
{ TASK_SET_ACTIVITY, (float)ACT_IDLE },
|
||||
{ TASK_FACE_TARGET, (float)0 },
|
||||
{ TASK_SET_ACTIVITY, (float)ACT_IDLE },
|
||||
{ TASK_SET_SCHEDULE, (float)SCHED_TARGET_CHASE },
|
||||
{ TASK_SET_ACTIVITY, (float)ACT_IDLE },
|
||||
{ TASK_FACE_TARGET, (float)0 },
|
||||
{ TASK_SET_ACTIVITY, (float)ACT_IDLE },
|
||||
{ TASK_SET_SCHEDULE, (float)SCHED_TARGET_CHASE },
|
||||
};
|
||||
|
||||
Schedule_t slBaFaceTarget[] =
|
||||
Schedule_t slBaFaceTarget[] =
|
||||
{
|
||||
{
|
||||
tlBaFaceTarget,
|
||||
ARRAYSIZE ( tlBaFaceTarget ),
|
||||
bits_COND_CLIENT_PUSH |
|
||||
bits_COND_NEW_ENEMY |
|
||||
bits_COND_LIGHT_DAMAGE |
|
||||
bits_COND_HEAVY_DAMAGE |
|
||||
ARRAYSIZE( tlBaFaceTarget ),
|
||||
bits_COND_CLIENT_PUSH |
|
||||
bits_COND_NEW_ENEMY |
|
||||
bits_COND_LIGHT_DAMAGE |
|
||||
bits_COND_HEAVY_DAMAGE |
|
||||
bits_COND_HEAR_SOUND |
|
||||
bits_COND_PROVOKED,
|
||||
bits_SOUND_DANGER,
|
||||
|
@ -171,34 +171,31 @@ Schedule_t slBaFaceTarget[] =
|
|||
},
|
||||
};
|
||||
|
||||
|
||||
Task_t tlIdleBaStand[] =
|
||||
Task_t tlIdleBaStand[] =
|
||||
{
|
||||
{ TASK_STOP_MOVING, 0 },
|
||||
{ TASK_SET_ACTIVITY, (float)ACT_IDLE },
|
||||
{ TASK_WAIT, (float)2 }, // repick IDLESTAND every two seconds.
|
||||
{ TASK_TLK_HEADRESET, (float)0 }, // reset head position
|
||||
{ TASK_STOP_MOVING, 0 },
|
||||
{ TASK_SET_ACTIVITY, (float)ACT_IDLE },
|
||||
{ TASK_WAIT, (float)2 }, // repick IDLESTAND every two seconds.
|
||||
{ TASK_TLK_HEADRESET, (float)0 }, // reset head position
|
||||
};
|
||||
|
||||
Schedule_t slIdleBaStand[] =
|
||||
Schedule_t slIdleBaStand[] =
|
||||
{
|
||||
{
|
||||
{
|
||||
tlIdleBaStand,
|
||||
ARRAYSIZE ( tlIdleBaStand ),
|
||||
bits_COND_NEW_ENEMY |
|
||||
bits_COND_LIGHT_DAMAGE |
|
||||
bits_COND_HEAVY_DAMAGE |
|
||||
bits_COND_HEAR_SOUND |
|
||||
bits_COND_SMELL |
|
||||
ARRAYSIZE( tlIdleBaStand ),
|
||||
bits_COND_NEW_ENEMY |
|
||||
bits_COND_LIGHT_DAMAGE |
|
||||
bits_COND_HEAVY_DAMAGE |
|
||||
bits_COND_HEAR_SOUND |
|
||||
bits_COND_SMELL |
|
||||
bits_COND_PROVOKED,
|
||||
|
||||
bits_SOUND_COMBAT |// sound flags - change these, and you'll break the talking code.
|
||||
//bits_SOUND_PLAYER |
|
||||
//bits_SOUND_WORLD |
|
||||
|
||||
bits_SOUND_DANGER |
|
||||
bits_SOUND_MEAT |// scents
|
||||
bits_SOUND_CARCASS |
|
||||
bits_SOUND_COMBAT |// sound flags - change these, and you'll break the talking code.
|
||||
//bits_SOUND_PLAYER |
|
||||
//bits_SOUND_WORLD |
|
||||
bits_SOUND_DANGER |
|
||||
bits_SOUND_MEAT |// scents
|
||||
bits_SOUND_CARCASS |
|
||||
bits_SOUND_GARBAGE,
|
||||
"IdleStand"
|
||||
},
|
||||
|
@ -212,20 +209,19 @@ DEFINE_CUSTOM_SCHEDULES( CBarney )
|
|||
slIdleBaStand,
|
||||
};
|
||||
|
||||
IMPLEMENT_CUSTOM_SCHEDULES( CBarney, CTalkMonster )
|
||||
|
||||
IMPLEMENT_CUSTOM_SCHEDULES( CBarney, CTalkMonster );
|
||||
|
||||
void CBarney :: StartTask( Task_t *pTask )
|
||||
void CBarney::StartTask( Task_t *pTask )
|
||||
{
|
||||
CTalkMonster::StartTask( pTask );
|
||||
}
|
||||
|
||||
void CBarney :: RunTask( Task_t *pTask )
|
||||
void CBarney::RunTask( Task_t *pTask )
|
||||
{
|
||||
switch ( pTask->iTask )
|
||||
switch( pTask->iTask )
|
||||
{
|
||||
case TASK_RANGE_ATTACK1:
|
||||
if (m_hEnemy != NULL && (m_hEnemy->IsPlayer()))
|
||||
if( m_hEnemy != NULL && ( m_hEnemy->IsPlayer() ) )
|
||||
{
|
||||
pev->framerate = 1.5;
|
||||
}
|
||||
|
@ -237,21 +233,18 @@ void CBarney :: RunTask( Task_t *pTask )
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//=========================================================
|
||||
// ISoundMask - returns a bit mask indicating which types
|
||||
// of sounds this monster regards.
|
||||
//=========================================================
|
||||
int CBarney :: ISoundMask ( void)
|
||||
int CBarney::ISoundMask( void)
|
||||
{
|
||||
return bits_SOUND_WORLD |
|
||||
bits_SOUND_COMBAT |
|
||||
bits_SOUND_CARCASS |
|
||||
bits_SOUND_MEAT |
|
||||
bits_SOUND_GARBAGE |
|
||||
bits_SOUND_DANGER |
|
||||
return bits_SOUND_WORLD |
|
||||
bits_SOUND_COMBAT |
|
||||
bits_SOUND_CARCASS |
|
||||
bits_SOUND_MEAT |
|
||||
bits_SOUND_GARBAGE |
|
||||
bits_SOUND_DANGER |
|
||||
bits_SOUND_PLAYER;
|
||||
}
|
||||
|
||||
|
@ -259,30 +252,30 @@ int CBarney :: ISoundMask ( void)
|
|||
// Classify - indicates this monster's place in the
|
||||
// relationship table.
|
||||
//=========================================================
|
||||
int CBarney :: Classify ( void )
|
||||
int CBarney::Classify( void )
|
||||
{
|
||||
return CLASS_PLAYER_ALLY;
|
||||
return CLASS_PLAYER_ALLY;
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
// ALertSound - barney says "Freeze!"
|
||||
//=========================================================
|
||||
void CBarney :: AlertSound( void )
|
||||
void CBarney::AlertSound( void )
|
||||
{
|
||||
if ( m_hEnemy != NULL )
|
||||
if( m_hEnemy != NULL )
|
||||
{
|
||||
if ( FOkToSpeak() )
|
||||
if( FOkToSpeak() )
|
||||
{
|
||||
PlaySentence( "BA_ATTACK", RANDOM_FLOAT(2.8, 3.2), VOL_NORM, ATTN_IDLE );
|
||||
PlaySentence( "BA_ATTACK", RANDOM_FLOAT( 2.8, 3.2 ), VOL_NORM, ATTN_IDLE );
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
// SetYawSpeed - allows each sequence to have a different
|
||||
// turn rate associated with it.
|
||||
//=========================================================
|
||||
void CBarney :: SetYawSpeed ( void )
|
||||
void CBarney::SetYawSpeed( void )
|
||||
{
|
||||
int ys;
|
||||
|
||||
|
@ -307,24 +300,23 @@ void CBarney :: SetYawSpeed ( void )
|
|||
pev->yaw_speed = ys;
|
||||
}
|
||||
|
||||
|
||||
//=========================================================
|
||||
// CheckRangeAttack1
|
||||
//=========================================================
|
||||
BOOL CBarney :: CheckRangeAttack1 ( float flDot, float flDist )
|
||||
BOOL CBarney::CheckRangeAttack1( float flDot, float flDist )
|
||||
{
|
||||
if ( flDist <= 1024 && flDot >= 0.5 )
|
||||
if( flDist <= 1024 && flDot >= 0.5 )
|
||||
{
|
||||
if ( gpGlobals->time > m_checkAttackTime )
|
||||
if( gpGlobals->time > m_checkAttackTime )
|
||||
{
|
||||
TraceResult tr;
|
||||
|
||||
|
||||
Vector shootOrigin = pev->origin + Vector( 0, 0, 55 );
|
||||
CBaseEntity *pEnemy = m_hEnemy;
|
||||
Vector shootTarget = ( (pEnemy->BodyTarget( shootOrigin ) - pEnemy->pev->origin) + m_vecEnemyLKP );
|
||||
UTIL_TraceLine( shootOrigin, shootTarget, dont_ignore_monsters, ENT(pev), &tr );
|
||||
Vector shootTarget = ( ( pEnemy->BodyTarget( shootOrigin ) - pEnemy->pev->origin ) + m_vecEnemyLKP );
|
||||
UTIL_TraceLine( shootOrigin, shootTarget, dont_ignore_monsters, ENT( pev ), &tr );
|
||||
m_checkAttackTime = gpGlobals->time + 1;
|
||||
if ( tr.flFraction == 1.0 || (tr.pHit != NULL && CBaseEntity::Instance(tr.pHit) == pEnemy) )
|
||||
if( tr.flFraction == 1.0 || ( tr.pHit != NULL && CBaseEntity::Instance( tr.pHit ) == pEnemy ) )
|
||||
m_lastAttackCheck = TRUE;
|
||||
else
|
||||
m_lastAttackCheck = FALSE;
|
||||
|
@ -335,16 +327,15 @@ BOOL CBarney :: CheckRangeAttack1 ( float flDot, float flDist )
|
|||
return FALSE;
|
||||
}
|
||||
|
||||
|
||||
//=========================================================
|
||||
// BarneyFirePistol - shoots one round from the pistol at
|
||||
// the enemy barney is facing.
|
||||
//=========================================================
|
||||
void CBarney :: BarneyFirePistol ( void )
|
||||
void CBarney::BarneyFirePistol( void )
|
||||
{
|
||||
Vector vecShootOrigin;
|
||||
|
||||
UTIL_MakeVectors(pev->angles);
|
||||
UTIL_MakeVectors( pev->angles );
|
||||
vecShootOrigin = pev->origin + Vector( 0, 0, 55 );
|
||||
Vector vecShootDir = ShootAtEnemy( vecShootOrigin );
|
||||
|
||||
|
@ -352,49 +343,46 @@ void CBarney :: BarneyFirePistol ( void )
|
|||
SetBlending( 0, angDir.x );
|
||||
pev->effects = EF_MUZZLEFLASH;
|
||||
|
||||
FireBullets(1, vecShootOrigin, vecShootDir, VECTOR_CONE_2DEGREES, 1024, BULLET_MONSTER_9MM );
|
||||
|
||||
FireBullets( 1, vecShootOrigin, vecShootDir, VECTOR_CONE_2DEGREES, 1024, BULLET_MONSTER_9MM );
|
||||
|
||||
int pitchShift = RANDOM_LONG( 0, 20 );
|
||||
|
||||
// Only shift about half the time
|
||||
if ( pitchShift > 10 )
|
||||
if( pitchShift > 10 )
|
||||
pitchShift = 0;
|
||||
else
|
||||
pitchShift -= 5;
|
||||
EMIT_SOUND_DYN( ENT(pev), CHAN_WEAPON, "barney/ba_attack2.wav", 1, ATTN_NORM, 0, 100 + pitchShift );
|
||||
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, "barney/ba_attack2.wav", 1, ATTN_NORM, 0, 100 + pitchShift );
|
||||
|
||||
CSoundEnt::InsertSound ( bits_SOUND_COMBAT, pev->origin, 384, 0.3 );
|
||||
CSoundEnt::InsertSound( bits_SOUND_COMBAT, pev->origin, 384, 0.3 );
|
||||
|
||||
// UNDONE: Reload?
|
||||
m_cAmmoLoaded--;// take away a bullet!
|
||||
}
|
||||
|
||||
|
||||
//=========================================================
|
||||
// HandleAnimEvent - catches the monster-specific messages
|
||||
// that occur when tagged animation frames are played.
|
||||
//
|
||||
// Returns number of events handled, 0 if none.
|
||||
//=========================================================
|
||||
void CBarney :: HandleAnimEvent( MonsterEvent_t *pEvent )
|
||||
void CBarney::HandleAnimEvent( MonsterEvent_t *pEvent )
|
||||
{
|
||||
switch( pEvent->event )
|
||||
{
|
||||
case BARNEY_AE_SHOOT:
|
||||
BarneyFirePistol();
|
||||
break;
|
||||
|
||||
case BARNEY_AE_DRAW:
|
||||
// barney's bodygroup switches here so he can pull gun from holster
|
||||
pev->body = BARNEY_BODY_GUNDRAWN;
|
||||
m_fGunDrawn = TRUE;
|
||||
break;
|
||||
|
||||
case BARNEY_AE_HOLSTER:
|
||||
// change bodygroup to replace gun in holster
|
||||
pev->body = BARNEY_BODY_GUNHOLSTERED;
|
||||
m_fGunDrawn = FALSE;
|
||||
break;
|
||||
|
||||
default:
|
||||
CTalkMonster::HandleAnimEvent( pEvent );
|
||||
}
|
||||
|
@ -403,25 +391,25 @@ void CBarney :: HandleAnimEvent( MonsterEvent_t *pEvent )
|
|||
//=========================================================
|
||||
// Spawn
|
||||
//=========================================================
|
||||
void CBarney :: Spawn()
|
||||
void CBarney::Spawn()
|
||||
{
|
||||
Precache( );
|
||||
Precache();
|
||||
|
||||
SET_MODEL(ENT(pev), "models/barney.mdl");
|
||||
UTIL_SetSize(pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX);
|
||||
SET_MODEL( ENT( pev ), "models/barney.mdl" );
|
||||
UTIL_SetSize( pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX );
|
||||
|
||||
pev->solid = SOLID_SLIDEBOX;
|
||||
pev->movetype = MOVETYPE_STEP;
|
||||
m_bloodColor = BLOOD_COLOR_RED;
|
||||
pev->health = gSkillData.barneyHealth;
|
||||
pev->view_ofs = Vector ( 0, 0, 50 );// position of the eyes relative to monster's origin.
|
||||
m_flFieldOfView = VIEW_FIELD_WIDE; // NOTE: we need a wide field of view so npc will notice player and say hello
|
||||
m_MonsterState = MONSTERSTATE_NONE;
|
||||
pev->solid = SOLID_SLIDEBOX;
|
||||
pev->movetype = MOVETYPE_STEP;
|
||||
m_bloodColor = BLOOD_COLOR_RED;
|
||||
pev->health = gSkillData.barneyHealth;
|
||||
pev->view_ofs = Vector ( 0, 0, 50 );// position of the eyes relative to monster's origin.
|
||||
m_flFieldOfView = VIEW_FIELD_WIDE; // NOTE: we need a wide field of view so npc will notice player and say hello
|
||||
m_MonsterState = MONSTERSTATE_NONE;
|
||||
|
||||
pev->body = 0; // gun in holster
|
||||
m_fGunDrawn = FALSE;
|
||||
pev->body = 0; // gun in holster
|
||||
m_fGunDrawn = FALSE;
|
||||
|
||||
m_afCapability = bits_CAP_HEAR | bits_CAP_TURN_HEAD | bits_CAP_DOORS_GROUP;
|
||||
m_afCapability = bits_CAP_HEAR | bits_CAP_TURN_HEAD | bits_CAP_DOORS_GROUP;
|
||||
|
||||
MonsterInit();
|
||||
SetUse( &CTalkMonster::FollowerUse );
|
||||
|
@ -430,21 +418,21 @@ void CBarney :: Spawn()
|
|||
//=========================================================
|
||||
// Precache - precaches all resources this monster needs
|
||||
//=========================================================
|
||||
void CBarney :: Precache()
|
||||
void CBarney::Precache()
|
||||
{
|
||||
PRECACHE_MODEL("models/barney.mdl");
|
||||
PRECACHE_MODEL( "models/barney.mdl" );
|
||||
|
||||
PRECACHE_SOUND("barney/ba_attack1.wav" );
|
||||
PRECACHE_SOUND("barney/ba_attack2.wav" );
|
||||
PRECACHE_SOUND( "barney/ba_attack1.wav" );
|
||||
PRECACHE_SOUND( "barney/ba_attack2.wav" );
|
||||
|
||||
PRECACHE_SOUND("barney/ba_pain1.wav");
|
||||
PRECACHE_SOUND("barney/ba_pain2.wav");
|
||||
PRECACHE_SOUND("barney/ba_pain3.wav");
|
||||
PRECACHE_SOUND( "barney/ba_pain1.wav" );
|
||||
PRECACHE_SOUND( "barney/ba_pain2.wav" );
|
||||
PRECACHE_SOUND( "barney/ba_pain3.wav" );
|
||||
|
||||
PRECACHE_SOUND( "barney/ba_die1.wav" );
|
||||
PRECACHE_SOUND( "barney/ba_die2.wav" );
|
||||
PRECACHE_SOUND( "barney/ba_die3.wav" );
|
||||
|
||||
PRECACHE_SOUND("barney/ba_die1.wav");
|
||||
PRECACHE_SOUND("barney/ba_die2.wav");
|
||||
PRECACHE_SOUND("barney/ba_die3.wav");
|
||||
|
||||
// every new barney must call this, otherwise
|
||||
// when a level is loaded, nobody will talk (time is reset to 0)
|
||||
TalkInit();
|
||||
|
@ -452,77 +440,74 @@ void CBarney :: Precache()
|
|||
}
|
||||
|
||||
// Init talk data
|
||||
void CBarney :: TalkInit()
|
||||
void CBarney::TalkInit()
|
||||
{
|
||||
|
||||
CTalkMonster::TalkInit();
|
||||
|
||||
// scientists speach group names (group names are in sentences.txt)
|
||||
|
||||
m_szGrp[TLK_ANSWER] = "BA_ANSWER";
|
||||
m_szGrp[TLK_ANSWER] = "BA_ANSWER";
|
||||
m_szGrp[TLK_QUESTION] = "BA_QUESTION";
|
||||
m_szGrp[TLK_IDLE] = "BA_IDLE";
|
||||
m_szGrp[TLK_STARE] = "BA_STARE";
|
||||
m_szGrp[TLK_USE] = "BA_OK";
|
||||
m_szGrp[TLK_UNUSE] = "BA_WAIT";
|
||||
m_szGrp[TLK_STOP] = "BA_STOP";
|
||||
m_szGrp[TLK_IDLE] = "BA_IDLE";
|
||||
m_szGrp[TLK_STARE] = "BA_STARE";
|
||||
m_szGrp[TLK_USE] = "BA_OK";
|
||||
m_szGrp[TLK_UNUSE] = "BA_WAIT";
|
||||
m_szGrp[TLK_STOP] = "BA_STOP";
|
||||
|
||||
m_szGrp[TLK_NOSHOOT] = "BA_SCARED";
|
||||
m_szGrp[TLK_HELLO] = "BA_HELLO";
|
||||
m_szGrp[TLK_NOSHOOT] = "BA_SCARED";
|
||||
m_szGrp[TLK_HELLO] = "BA_HELLO";
|
||||
|
||||
m_szGrp[TLK_PLHURT1] = "!BA_CUREA";
|
||||
m_szGrp[TLK_PLHURT2] = "!BA_CUREB";
|
||||
m_szGrp[TLK_PLHURT3] = "!BA_CUREC";
|
||||
m_szGrp[TLK_PLHURT1] = "!BA_CUREA";
|
||||
m_szGrp[TLK_PLHURT2] = "!BA_CUREB";
|
||||
m_szGrp[TLK_PLHURT3] = "!BA_CUREC";
|
||||
|
||||
m_szGrp[TLK_PHELLO] = NULL; //"BA_PHELLO"; // UNDONE
|
||||
m_szGrp[TLK_PIDLE] = NULL; //"BA_PIDLE"; // UNDONE
|
||||
m_szGrp[TLK_PHELLO] = NULL; //"BA_PHELLO"; // UNDONE
|
||||
m_szGrp[TLK_PIDLE] = NULL; //"BA_PIDLE"; // UNDONE
|
||||
m_szGrp[TLK_PQUESTION] = "BA_PQUEST"; // UNDONE
|
||||
|
||||
m_szGrp[TLK_SMELL] = "BA_SMELL";
|
||||
m_szGrp[TLK_SMELL] = "BA_SMELL";
|
||||
|
||||
m_szGrp[TLK_WOUND] = "BA_WOUND";
|
||||
m_szGrp[TLK_MORTAL] = "BA_MORTAL";
|
||||
m_szGrp[TLK_WOUND] = "BA_WOUND";
|
||||
m_szGrp[TLK_MORTAL] = "BA_MORTAL";
|
||||
|
||||
// get voice for head - just one barney voice for now
|
||||
m_voicePitch = 100;
|
||||
}
|
||||
|
||||
|
||||
static BOOL IsFacing( entvars_t *pevTest, const Vector &reference )
|
||||
{
|
||||
Vector vecDir = (reference - pevTest->origin);
|
||||
Vector vecDir = reference - pevTest->origin;
|
||||
vecDir.z = 0;
|
||||
vecDir = vecDir.Normalize();
|
||||
Vector forward, angle;
|
||||
angle = pevTest->v_angle;
|
||||
angle.x = 0;
|
||||
UTIL_MakeVectorsPrivate( angle, forward, NULL, NULL );
|
||||
|
||||
// He's facing me, he meant it
|
||||
if ( DotProduct( forward, vecDir ) > 0.96 ) // +/- 15 degrees or so
|
||||
if( DotProduct( forward, vecDir ) > 0.96 ) // +/- 15 degrees or so
|
||||
{
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
|
||||
int CBarney :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType)
|
||||
int CBarney::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
|
||||
{
|
||||
// make sure friends talk about it if player hurts talkmonsters...
|
||||
int ret = CTalkMonster::TakeDamage(pevInflictor, pevAttacker, flDamage, bitsDamageType);
|
||||
if ( !IsAlive() || pev->deadflag == DEAD_DYING )
|
||||
int ret = CTalkMonster::TakeDamage( pevInflictor, pevAttacker, flDamage, bitsDamageType );
|
||||
if( !IsAlive() || pev->deadflag == DEAD_DYING )
|
||||
return ret;
|
||||
|
||||
if ( m_MonsterState != MONSTERSTATE_PRONE && (pevAttacker->flags & FL_CLIENT) )
|
||||
if( m_MonsterState != MONSTERSTATE_PRONE && ( pevAttacker->flags & FL_CLIENT ) )
|
||||
{
|
||||
m_flPlayerDamage += flDamage;
|
||||
|
||||
// This is a heurstic to determine if the player intended to harm me
|
||||
// If I have an enemy, we can't establish intent (may just be crossfire)
|
||||
if ( m_hEnemy == NULL )
|
||||
if( m_hEnemy == NULL )
|
||||
{
|
||||
// If the player was facing directly at me, or I'm already suspicious, get mad
|
||||
if ( (m_afMemory & bits_MEMORY_SUSPICIOUS) || IsFacing( pevAttacker, pev->origin ) )
|
||||
if( ( m_afMemory & bits_MEMORY_SUSPICIOUS ) || IsFacing( pevAttacker, pev->origin ) )
|
||||
{
|
||||
// Alright, now I'm pissed!
|
||||
PlaySentence( "BA_MAD", 4, VOL_NORM, ATTN_NORM );
|
||||
|
@ -537,7 +522,7 @@ int CBarney :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, floa
|
|||
Remember( bits_MEMORY_SUSPICIOUS );
|
||||
}
|
||||
}
|
||||
else if ( !(m_hEnemy->IsPlayer()) && pev->deadflag == DEAD_NO )
|
||||
else if( !( m_hEnemy->IsPlayer()) && pev->deadflag == DEAD_NO )
|
||||
{
|
||||
PlaySentence( "BA_SHOT", 4, VOL_NORM, ATTN_NORM );
|
||||
}
|
||||
|
@ -546,60 +531,71 @@ int CBarney :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, floa
|
|||
return ret;
|
||||
}
|
||||
|
||||
|
||||
//=========================================================
|
||||
// PainSound
|
||||
//=========================================================
|
||||
void CBarney :: PainSound ( void )
|
||||
void CBarney::PainSound( void )
|
||||
{
|
||||
if (gpGlobals->time < m_painTime)
|
||||
if( gpGlobals->time < m_painTime )
|
||||
return;
|
||||
|
||||
m_painTime = gpGlobals->time + RANDOM_FLOAT(0.5, 0.75);
|
||||
|
||||
switch (RANDOM_LONG(0,2))
|
||||
m_painTime = gpGlobals->time + RANDOM_FLOAT( 0.5, 0.75 );
|
||||
|
||||
switch( RANDOM_LONG( 0, 2 ) )
|
||||
{
|
||||
case 0: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "barney/ba_pain1.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
|
||||
case 1: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "barney/ba_pain2.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
|
||||
case 2: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "barney/ba_pain3.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
|
||||
case 0:
|
||||
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "barney/ba_pain1.wav", 1, ATTN_NORM, 0, GetVoicePitch() );
|
||||
break;
|
||||
case 1:
|
||||
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "barney/ba_pain2.wav", 1, ATTN_NORM, 0, GetVoicePitch() );
|
||||
break;
|
||||
case 2:
|
||||
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "barney/ba_pain3.wav", 1, ATTN_NORM, 0, GetVoicePitch() );
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
// DeathSound
|
||||
//=========================================================
|
||||
void CBarney :: DeathSound ( void )
|
||||
void CBarney::DeathSound( void )
|
||||
{
|
||||
switch (RANDOM_LONG(0,2))
|
||||
switch( RANDOM_LONG( 0, 2 ) )
|
||||
{
|
||||
case 0: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "barney/ba_die1.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
|
||||
case 1: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "barney/ba_die2.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
|
||||
case 2: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "barney/ba_die3.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
|
||||
case 0:
|
||||
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "barney/ba_die1.wav", 1, ATTN_NORM, 0, GetVoicePitch() );
|
||||
break;
|
||||
case 1:
|
||||
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "barney/ba_die2.wav", 1, ATTN_NORM, 0, GetVoicePitch() );
|
||||
break;
|
||||
case 2:
|
||||
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "barney/ba_die3.wav", 1, ATTN_NORM, 0, GetVoicePitch() );
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CBarney::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType)
|
||||
void CBarney::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType )
|
||||
{
|
||||
switch( ptr->iHitgroup)
|
||||
switch( ptr->iHitgroup )
|
||||
{
|
||||
case HITGROUP_CHEST:
|
||||
case HITGROUP_STOMACH:
|
||||
if (bitsDamageType & (DMG_BULLET | DMG_SLASH | DMG_BLAST))
|
||||
if (bitsDamageType & ( DMG_BULLET | DMG_SLASH | DMG_BLAST ) )
|
||||
{
|
||||
flDamage = flDamage / 2;
|
||||
}
|
||||
break;
|
||||
case 10:
|
||||
if (bitsDamageType & (DMG_BULLET | DMG_SLASH | DMG_CLUB))
|
||||
if( bitsDamageType & ( DMG_BULLET | DMG_SLASH | DMG_CLUB ) )
|
||||
{
|
||||
flDamage -= 20;
|
||||
if (flDamage <= 0)
|
||||
if( flDamage <= 0 )
|
||||
{
|
||||
UTIL_Ricochet( ptr->vecEndPos, 1.0 );
|
||||
flDamage = 0.01;
|
||||
}
|
||||
}
|
||||
|
||||
// always a head shot
|
||||
ptr->iHitgroup = HITGROUP_HEAD;
|
||||
break;
|
||||
|
@ -608,18 +604,18 @@ void CBarney::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir
|
|||
CTalkMonster::TraceAttack( pevAttacker, flDamage, vecDir, ptr, bitsDamageType );
|
||||
}
|
||||
|
||||
|
||||
void CBarney::Killed( entvars_t *pevAttacker, int iGib )
|
||||
{
|
||||
if ( pev->body < BARNEY_BODY_GUNGONE )
|
||||
{// drop the gun!
|
||||
if( pev->body < BARNEY_BODY_GUNGONE )
|
||||
{
|
||||
// drop the gun!
|
||||
Vector vecGunPos;
|
||||
Vector vecGunAngles;
|
||||
|
||||
pev->body = BARNEY_BODY_GUNGONE;
|
||||
|
||||
GetAttachment( 0, vecGunPos, vecGunAngles );
|
||||
|
||||
|
||||
CBaseEntity *pGun = DropItem( "weapon_9mmhandgun", vecGunPos, vecGunAngles );
|
||||
}
|
||||
|
||||
|
@ -630,41 +626,37 @@ void CBarney::Killed( entvars_t *pevAttacker, int iGib )
|
|||
//=========================================================
|
||||
// AI Schedules Specific to this monster
|
||||
//=========================================================
|
||||
|
||||
Schedule_t* CBarney :: GetScheduleOfType ( int Type )
|
||||
Schedule_t *CBarney::GetScheduleOfType( int Type )
|
||||
{
|
||||
Schedule_t *psched;
|
||||
|
||||
switch( Type )
|
||||
{
|
||||
case SCHED_ARM_WEAPON:
|
||||
if ( m_hEnemy != NULL )
|
||||
if( m_hEnemy != NULL )
|
||||
{
|
||||
// face enemy, then draw.
|
||||
return slBarneyEnemyDraw;
|
||||
}
|
||||
break;
|
||||
|
||||
// Hook these to make a looping schedule
|
||||
case SCHED_TARGET_FACE:
|
||||
// call base class default so that barney will talk
|
||||
// when 'used'
|
||||
psched = CTalkMonster::GetScheduleOfType(Type);
|
||||
psched = CTalkMonster::GetScheduleOfType( Type );
|
||||
|
||||
if (psched == slIdleStand)
|
||||
if( psched == slIdleStand )
|
||||
return slBaFaceTarget; // override this for different target face behavior
|
||||
else
|
||||
return psched;
|
||||
|
||||
case SCHED_TARGET_CHASE:
|
||||
return slBaFollow;
|
||||
|
||||
case SCHED_IDLE_STAND:
|
||||
// call base class default so that scientist will talk
|
||||
// when standing during idle
|
||||
psched = CTalkMonster::GetScheduleOfType(Type);
|
||||
psched = CTalkMonster::GetScheduleOfType( Type );
|
||||
|
||||
if (psched == slIdleStand)
|
||||
if( psched == slIdleStand )
|
||||
{
|
||||
// just look straight ahead.
|
||||
return slIdleBaStand;
|
||||
|
@ -682,18 +674,18 @@ Schedule_t* CBarney :: GetScheduleOfType ( int Type )
|
|||
// monster's member function to get a pointer to a schedule
|
||||
// of the proper type.
|
||||
//=========================================================
|
||||
Schedule_t *CBarney :: GetSchedule ( void )
|
||||
Schedule_t *CBarney::GetSchedule( void )
|
||||
{
|
||||
if ( HasConditions( bits_COND_HEAR_SOUND ) )
|
||||
if( HasConditions( bits_COND_HEAR_SOUND ) )
|
||||
{
|
||||
CSound *pSound;
|
||||
pSound = PBestSound();
|
||||
|
||||
ASSERT( pSound != NULL );
|
||||
if ( pSound && (pSound->m_iType & bits_SOUND_DANGER) )
|
||||
if( pSound && (pSound->m_iType & bits_SOUND_DANGER) )
|
||||
return GetScheduleOfType( SCHED_TAKE_COVER_FROM_BEST_SOUND );
|
||||
}
|
||||
if ( HasConditions( bits_COND_ENEMY_DEAD ) && FOkToSpeak() )
|
||||
if( HasConditions( bits_COND_ENEMY_DEAD ) && FOkToSpeak() )
|
||||
{
|
||||
PlaySentence( "BA_KILL", 4, VOL_NORM, ATTN_NORM );
|
||||
}
|
||||
|
@ -702,37 +694,36 @@ Schedule_t *CBarney :: GetSchedule ( void )
|
|||
{
|
||||
case MONSTERSTATE_COMBAT:
|
||||
{
|
||||
// dead enemy
|
||||
if ( HasConditions( bits_COND_ENEMY_DEAD ) )
|
||||
// dead enemy
|
||||
if( HasConditions( bits_COND_ENEMY_DEAD ) )
|
||||
{
|
||||
// call base class, all code to handle dead enemies is centralized there.
|
||||
return CBaseMonster :: GetSchedule();
|
||||
return CBaseMonster::GetSchedule();
|
||||
}
|
||||
|
||||
// always act surprized with a new enemy
|
||||
if ( HasConditions( bits_COND_NEW_ENEMY ) && HasConditions( bits_COND_LIGHT_DAMAGE) )
|
||||
if( HasConditions( bits_COND_NEW_ENEMY ) && HasConditions( bits_COND_LIGHT_DAMAGE ) )
|
||||
return GetScheduleOfType( SCHED_SMALL_FLINCH );
|
||||
|
||||
|
||||
// wait for one schedule to draw gun
|
||||
if (!m_fGunDrawn )
|
||||
if( !m_fGunDrawn )
|
||||
return GetScheduleOfType( SCHED_ARM_WEAPON );
|
||||
|
||||
if ( HasConditions( bits_COND_HEAVY_DAMAGE ) )
|
||||
if( HasConditions( bits_COND_HEAVY_DAMAGE ) )
|
||||
return GetScheduleOfType( SCHED_TAKE_COVER_FROM_ENEMY );
|
||||
}
|
||||
break;
|
||||
|
||||
case MONSTERSTATE_ALERT:
|
||||
case MONSTERSTATE_IDLE:
|
||||
if ( HasConditions(bits_COND_LIGHT_DAMAGE | bits_COND_HEAVY_DAMAGE))
|
||||
if( HasConditions( bits_COND_LIGHT_DAMAGE | bits_COND_HEAVY_DAMAGE ) )
|
||||
{
|
||||
// flinch if hurt
|
||||
return GetScheduleOfType( SCHED_SMALL_FLINCH );
|
||||
}
|
||||
|
||||
if ( m_hEnemy == NULL && IsFollowing() )
|
||||
if( m_hEnemy == NULL && IsFollowing() )
|
||||
{
|
||||
if ( !m_hTargetEnt->IsAlive() )
|
||||
if( !m_hTargetEnt->IsAlive() )
|
||||
{
|
||||
// UNDONE: Comment about the recently dead player here?
|
||||
StopFollowing( FALSE );
|
||||
|
@ -740,7 +731,7 @@ Schedule_t *CBarney :: GetSchedule ( void )
|
|||
}
|
||||
else
|
||||
{
|
||||
if ( HasConditions( bits_COND_CLIENT_PUSH ) )
|
||||
if( HasConditions( bits_COND_CLIENT_PUSH ) )
|
||||
{
|
||||
return GetScheduleOfType( SCHED_MOVE_AWAY_FOLLOW );
|
||||
}
|
||||
|
@ -748,7 +739,7 @@ Schedule_t *CBarney :: GetSchedule ( void )
|
|||
}
|
||||
}
|
||||
|
||||
if ( HasConditions( bits_COND_CLIENT_PUSH ) )
|
||||
if( HasConditions( bits_COND_CLIENT_PUSH ) )
|
||||
{
|
||||
return GetScheduleOfType( SCHED_MOVE_AWAY );
|
||||
}
|
||||
|
@ -756,27 +747,23 @@ Schedule_t *CBarney :: GetSchedule ( void )
|
|||
// try to say something about smells
|
||||
TrySmellTalk();
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
return CTalkMonster::GetSchedule();
|
||||
}
|
||||
|
||||
MONSTERSTATE CBarney :: GetIdealState ( void )
|
||||
MONSTERSTATE CBarney::GetIdealState( void )
|
||||
{
|
||||
return CTalkMonster::GetIdealState();
|
||||
}
|
||||
|
||||
|
||||
|
||||
void CBarney::DeclineFollowing( void )
|
||||
{
|
||||
PlaySentence( "BA_POK", 2, VOL_NORM, ATTN_NORM );
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
//=========================================================
|
||||
// DEAD BARNEY PROP
|
||||
//
|
||||
|
@ -791,11 +778,11 @@ class CDeadBarney : public CBaseMonster
|
|||
{
|
||||
public:
|
||||
void Spawn( void );
|
||||
int Classify ( void ) { return CLASS_PLAYER_ALLY; }
|
||||
int Classify( void ) { return CLASS_PLAYER_ALLY; }
|
||||
|
||||
void KeyValue( KeyValueData *pkvd );
|
||||
|
||||
int m_iPose;// which sequence to display -- temporary, don't need to save
|
||||
int m_iPose;// which sequence to display -- temporary, don't need to save
|
||||
static char *m_szPoses[3];
|
||||
};
|
||||
|
||||
|
@ -803,39 +790,37 @@ char *CDeadBarney::m_szPoses[] = { "lying_on_back", "lying_on_side", "lying_on_s
|
|||
|
||||
void CDeadBarney::KeyValue( KeyValueData *pkvd )
|
||||
{
|
||||
if (FStrEq(pkvd->szKeyName, "pose"))
|
||||
if( FStrEq( pkvd->szKeyName, "pose" ) )
|
||||
{
|
||||
m_iPose = atoi(pkvd->szValue);
|
||||
m_iPose = atoi( pkvd->szValue );
|
||||
pkvd->fHandled = TRUE;
|
||||
}
|
||||
else
|
||||
else
|
||||
CBaseMonster::KeyValue( pkvd );
|
||||
}
|
||||
|
||||
LINK_ENTITY_TO_CLASS( monster_barney_dead, CDeadBarney );
|
||||
LINK_ENTITY_TO_CLASS( monster_barney_dead, CDeadBarney )
|
||||
|
||||
//=========================================================
|
||||
// ********** DeadBarney SPAWN **********
|
||||
//=========================================================
|
||||
void CDeadBarney :: Spawn( )
|
||||
void CDeadBarney::Spawn()
|
||||
{
|
||||
PRECACHE_MODEL("models/barney.mdl");
|
||||
SET_MODEL(ENT(pev), "models/barney.mdl");
|
||||
PRECACHE_MODEL( "models/barney.mdl" );
|
||||
SET_MODEL( ENT( pev ), "models/barney.mdl" );
|
||||
|
||||
pev->effects = 0;
|
||||
pev->yaw_speed = 8;
|
||||
pev->sequence = 0;
|
||||
m_bloodColor = BLOOD_COLOR_RED;
|
||||
pev->effects = 0;
|
||||
pev->yaw_speed = 8;
|
||||
pev->sequence = 0;
|
||||
m_bloodColor = BLOOD_COLOR_RED;
|
||||
|
||||
pev->sequence = LookupSequence( m_szPoses[m_iPose] );
|
||||
if (pev->sequence == -1)
|
||||
if( pev->sequence == -1 )
|
||||
{
|
||||
ALERT ( at_console, "Dead barney with bad pose\n" );
|
||||
ALERT( at_console, "Dead barney with bad pose\n" );
|
||||
}
|
||||
// Corpses have less health
|
||||
pev->health = 8;//gSkillData.barneyHealth;
|
||||
pev->health = 8;//gSkillData.barneyHealth;
|
||||
|
||||
MonsterInitDead();
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -22,318 +22,311 @@
|
|||
class CBaseMonster : public CBaseToggle
|
||||
{
|
||||
private:
|
||||
int m_afConditions;
|
||||
int m_afConditions;
|
||||
|
||||
public:
|
||||
typedef enum
|
||||
{
|
||||
SCRIPT_PLAYING = 0, // Playing the sequence
|
||||
SCRIPT_WAIT, // Waiting on everyone in the script to be ready
|
||||
SCRIPT_CLEANUP, // Cancelling the script / cleaning up
|
||||
SCRIPT_WALK_TO_MARK,
|
||||
SCRIPT_RUN_TO_MARK,
|
||||
} SCRIPTSTATE;
|
||||
typedef enum
|
||||
{
|
||||
SCRIPT_PLAYING = 0, // Playing the sequence
|
||||
SCRIPT_WAIT, // Waiting on everyone in the script to be ready
|
||||
SCRIPT_CLEANUP, // Cancelling the script / cleaning up
|
||||
SCRIPT_WALK_TO_MARK,
|
||||
SCRIPT_RUN_TO_MARK
|
||||
} SCRIPTSTATE;
|
||||
|
||||
// these fields have been added in the process of reworking the state machine. (sjb)
|
||||
EHANDLE m_hEnemy; // the entity that the monster is fighting.
|
||||
EHANDLE m_hTargetEnt; // the entity that the monster is trying to reach
|
||||
EHANDLE m_hOldEnemy[MAX_OLD_ENEMIES];
|
||||
Vector m_vecOldEnemy[MAX_OLD_ENEMIES];
|
||||
|
||||
|
||||
// these fields have been added in the process of reworking the state machine. (sjb)
|
||||
EHANDLE m_hEnemy; // the entity that the monster is fighting.
|
||||
EHANDLE m_hTargetEnt; // the entity that the monster is trying to reach
|
||||
EHANDLE m_hOldEnemy[ MAX_OLD_ENEMIES ];
|
||||
Vector m_vecOldEnemy[ MAX_OLD_ENEMIES ];
|
||||
float m_flFieldOfView;// width of monster's field of view ( dot product )
|
||||
float m_flWaitFinished;// if we're told to wait, this is the time that the wait will be over.
|
||||
float m_flMoveWaitFinished;
|
||||
|
||||
float m_flFieldOfView;// width of monster's field of view ( dot product )
|
||||
float m_flWaitFinished;// if we're told to wait, this is the time that the wait will be over.
|
||||
float m_flMoveWaitFinished;
|
||||
Activity m_Activity;// what the monster is doing (animation)
|
||||
Activity m_IdealActivity;// monster should switch to this activity
|
||||
|
||||
Activity m_Activity;// what the monster is doing (animation)
|
||||
Activity m_IdealActivity;// monster should switch to this activity
|
||||
|
||||
int m_LastHitGroup; // the last body region that took damage
|
||||
|
||||
MONSTERSTATE m_MonsterState;// monster's current state
|
||||
MONSTERSTATE m_IdealMonsterState;// monster should change to this state
|
||||
|
||||
int m_iTaskStatus;
|
||||
Schedule_t *m_pSchedule;
|
||||
int m_iScheduleIndex;
|
||||
int m_LastHitGroup; // the last body region that took damage
|
||||
|
||||
WayPoint_t m_Route[ ROUTE_SIZE ]; // Positions of movement
|
||||
int m_movementGoal; // Goal that defines route
|
||||
int m_iRouteIndex; // index into m_Route[]
|
||||
float m_moveWaitTime; // How long I should wait for something to move
|
||||
MONSTERSTATE m_MonsterState;// monster's current state
|
||||
MONSTERSTATE m_IdealMonsterState;// monster should change to this state
|
||||
|
||||
Vector m_vecMoveGoal; // kept around for node graph moves, so we know our ultimate goal
|
||||
Activity m_movementActivity; // When moving, set this activity
|
||||
int m_iTaskStatus;
|
||||
Schedule_t *m_pSchedule;
|
||||
int m_iScheduleIndex;
|
||||
|
||||
int m_iAudibleList; // first index of a linked list of sounds that the monster can hear.
|
||||
int m_afSoundTypes;
|
||||
WayPoint_t m_Route[ROUTE_SIZE]; // Positions of movement
|
||||
int m_movementGoal; // Goal that defines route
|
||||
int m_iRouteIndex; // index into m_Route[]
|
||||
float m_moveWaitTime; // How long I should wait for something to move
|
||||
|
||||
Vector m_vecLastPosition;// monster sometimes wants to return to where it started after an operation.
|
||||
Vector m_vecMoveGoal; // kept around for node graph moves, so we know our ultimate goal
|
||||
Activity m_movementActivity; // When moving, set this activity
|
||||
|
||||
int m_iHintNode; // this is the hint node that the monster is moving towards or performing active idle on.
|
||||
int m_iAudibleList; // first index of a linked list of sounds that the monster can hear.
|
||||
int m_afSoundTypes;
|
||||
|
||||
int m_afMemory;
|
||||
Vector m_vecLastPosition;// monster sometimes wants to return to where it started after an operation.
|
||||
|
||||
int m_iMaxHealth;// keeps track of monster's maximum health value (for re-healing, etc)
|
||||
int m_iHintNode; // this is the hint node that the monster is moving towards or performing active idle on.
|
||||
|
||||
Vector m_vecEnemyLKP;// last known position of enemy. (enemy's origin)
|
||||
int m_afMemory;
|
||||
|
||||
int m_cAmmoLoaded; // how much ammo is in the weapon (used to trigger reload anim sequences)
|
||||
int m_iMaxHealth;// keeps track of monster's maximum health value (for re-healing, etc)
|
||||
|
||||
int m_afCapability;// tells us what a monster can/can't do.
|
||||
Vector m_vecEnemyLKP;// last known position of enemy. (enemy's origin)
|
||||
|
||||
float m_flNextAttack; // cannot attack again until this time
|
||||
int m_cAmmoLoaded; // how much ammo is in the weapon (used to trigger reload anim sequences)
|
||||
|
||||
int m_bitsDamageType; // what types of damage has monster (player) taken
|
||||
BYTE m_rgbTimeBasedDamage[CDMG_TIMEBASED];
|
||||
int m_afCapability;// tells us what a monster can/can't do.
|
||||
|
||||
int m_lastDamageAmount;// how much damage did monster (player) last take
|
||||
// time based damage counters, decr. 1 per 2 seconds
|
||||
int m_bloodColor; // color of blood particless
|
||||
float m_flNextAttack; // cannot attack again until this time
|
||||
|
||||
int m_failSchedule; // Schedule type to choose if current schedule fails
|
||||
int m_bitsDamageType; // what types of damage has monster (player) taken
|
||||
BYTE m_rgbTimeBasedDamage[CDMG_TIMEBASED];
|
||||
|
||||
float m_flHungryTime;// set this is a future time to stop the monster from eating for a while.
|
||||
int m_lastDamageAmount;// how much damage did monster (player) last take
|
||||
// time based damage counters, decr. 1 per 2 seconds
|
||||
int m_bloodColor; // color of blood particless
|
||||
|
||||
float m_flDistTooFar; // if enemy farther away than this, bits_COND_ENEMY_TOOFAR set in CheckEnemy
|
||||
float m_flDistLook; // distance monster sees (Default 2048)
|
||||
int m_failSchedule; // Schedule type to choose if current schedule fails
|
||||
|
||||
int m_iTriggerCondition;// for scripted AI, this is the condition that will cause the activation of the monster's TriggerTarget
|
||||
string_t m_iszTriggerTarget;// name of target that should be fired.
|
||||
float m_flHungryTime;// set this is a future time to stop the monster from eating for a while.
|
||||
|
||||
Vector m_HackedGunPos; // HACK until we can query end of gun
|
||||
float m_flDistTooFar; // if enemy farther away than this, bits_COND_ENEMY_TOOFAR set in CheckEnemy
|
||||
float m_flDistLook; // distance monster sees (Default 2048)
|
||||
|
||||
// Scripted sequence Info
|
||||
SCRIPTSTATE m_scriptState; // internal cinematic state
|
||||
CCineMonster *m_pCine;
|
||||
int m_iTriggerCondition;// for scripted AI, this is the condition that will cause the activation of the monster's TriggerTarget
|
||||
string_t m_iszTriggerTarget;// name of target that should be fired.
|
||||
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
|
||||
static TYPEDESCRIPTION m_SaveData[];
|
||||
Vector m_HackedGunPos; // HACK until we can query end of gun
|
||||
|
||||
// Scripted sequence Info
|
||||
SCRIPTSTATE m_scriptState; // internal cinematic state
|
||||
CCineMonster *m_pCine;
|
||||
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
static TYPEDESCRIPTION m_SaveData[];
|
||||
|
||||
void KeyValue( KeyValueData *pkvd );
|
||||
|
||||
// monster use function
|
||||
void EXPORT MonsterUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
|
||||
void EXPORT CorpseUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
|
||||
// monster use function
|
||||
void EXPORT MonsterUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
|
||||
void EXPORT CorpseUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
|
||||
|
||||
// overrideable Monster member functions
|
||||
|
||||
virtual int BloodColor( void ) { return m_bloodColor; }
|
||||
// overrideable Monster member functions
|
||||
virtual int BloodColor( void ) { return m_bloodColor; }
|
||||
|
||||
virtual CBaseMonster *MyMonsterPointer( void ) { return this; }
|
||||
virtual void Look ( int iDistance );// basic sight function for monsters
|
||||
virtual void RunAI ( void );// core ai function!
|
||||
void Listen ( void );
|
||||
virtual void Look( int iDistance );// basic sight function for monsters
|
||||
virtual void RunAI( void );// core ai function!
|
||||
void Listen( void );
|
||||
|
||||
virtual BOOL IsAlive( void ) { return (pev->deadflag != DEAD_DEAD); }
|
||||
virtual BOOL ShouldFadeOnDeath( void );
|
||||
virtual BOOL IsAlive( void ) { return ( pev->deadflag != DEAD_DEAD ); }
|
||||
virtual BOOL ShouldFadeOnDeath( void );
|
||||
|
||||
// Basic Monster AI functions
|
||||
virtual float ChangeYaw ( int speed );
|
||||
// Basic Monster AI functions
|
||||
virtual float ChangeYaw( int speed );
|
||||
float VecToYaw( Vector vecDir );
|
||||
float FlYawDiff ( void );
|
||||
float FlYawDiff( void );
|
||||
|
||||
float DamageForce( float damage );
|
||||
|
||||
// stuff written for new state machine
|
||||
virtual void MonsterThink( void );
|
||||
void EXPORT CallMonsterThink( void ) { this->MonsterThink(); }
|
||||
virtual int IRelationship ( CBaseEntity *pTarget );
|
||||
virtual void MonsterInit ( void );
|
||||
virtual void MonsterInitDead( void ); // Call after animation/pose is set up
|
||||
virtual void BecomeDead( void );
|
||||
void EXPORT CorpseFallThink( void );
|
||||
// stuff written for new state machine
|
||||
virtual void MonsterThink( void );
|
||||
void EXPORT CallMonsterThink( void ) { this->MonsterThink(); }
|
||||
virtual int IRelationship( CBaseEntity *pTarget );
|
||||
virtual void MonsterInit( void );
|
||||
virtual void MonsterInitDead( void ); // Call after animation/pose is set up
|
||||
virtual void BecomeDead( void );
|
||||
void EXPORT CorpseFallThink( void );
|
||||
|
||||
void EXPORT MonsterInitThink ( void );
|
||||
virtual void StartMonster ( void );
|
||||
virtual CBaseEntity* BestVisibleEnemy ( void );// finds best visible enemy for attack
|
||||
virtual BOOL FInViewCone ( CBaseEntity *pEntity );// see if pEntity is in monster's view cone
|
||||
virtual BOOL FInViewCone ( Vector *pOrigin );// see if given location is in monster's view cone
|
||||
virtual void HandleAnimEvent( MonsterEvent_t *pEvent );
|
||||
void EXPORT MonsterInitThink( void );
|
||||
virtual void StartMonster( void );
|
||||
virtual CBaseEntity *BestVisibleEnemy( void );// finds best visible enemy for attack
|
||||
virtual BOOL FInViewCone( CBaseEntity *pEntity );// see if pEntity is in monster's view cone
|
||||
virtual BOOL FInViewCone( Vector *pOrigin );// see if given location is in monster's view cone
|
||||
virtual void HandleAnimEvent( MonsterEvent_t *pEvent );
|
||||
|
||||
virtual int CheckLocalMove ( const Vector &vecStart, const Vector &vecEnd, CBaseEntity *pTarget, float *pflDist );// check validity of a straight move through space
|
||||
virtual void Move( float flInterval = 0.1 );
|
||||
virtual void MoveExecute( CBaseEntity *pTargetEnt, const Vector &vecDir, float flInterval );
|
||||
virtual BOOL ShouldAdvanceRoute( float flWaypointDist );
|
||||
virtual int CheckLocalMove ( const Vector &vecStart, const Vector &vecEnd, CBaseEntity *pTarget, float *pflDist );// check validity of a straight move through space
|
||||
virtual void Move( float flInterval = 0.1 );
|
||||
virtual void MoveExecute( CBaseEntity *pTargetEnt, const Vector &vecDir, float flInterval );
|
||||
virtual BOOL ShouldAdvanceRoute( float flWaypointDist );
|
||||
|
||||
virtual Activity GetStoppedActivity( void ) { return ACT_IDLE; }
|
||||
virtual void Stop( void ) { m_IdealActivity = GetStoppedActivity(); }
|
||||
virtual Activity GetStoppedActivity( void ) { return ACT_IDLE; }
|
||||
virtual void Stop( void ) { m_IdealActivity = GetStoppedActivity(); }
|
||||
|
||||
// This will stop animation until you call ResetSequenceInfo() at some point in the future
|
||||
inline void StopAnimation( void ) { pev->framerate = 0; }
|
||||
// This will stop animation until you call ResetSequenceInfo() at some point in the future
|
||||
inline void StopAnimation( void ) { pev->framerate = 0; }
|
||||
|
||||
// these functions will survey conditions and set appropriate conditions bits for attack types.
|
||||
virtual BOOL CheckRangeAttack1( float flDot, float flDist );
|
||||
virtual BOOL CheckRangeAttack2( float flDot, float flDist );
|
||||
virtual BOOL CheckMeleeAttack1( float flDot, float flDist );
|
||||
virtual BOOL CheckMeleeAttack2( float flDot, float flDist );
|
||||
// these functions will survey conditions and set appropriate conditions bits for attack types.
|
||||
virtual BOOL CheckRangeAttack1( float flDot, float flDist );
|
||||
virtual BOOL CheckRangeAttack2( float flDot, float flDist );
|
||||
virtual BOOL CheckMeleeAttack1( float flDot, float flDist );
|
||||
virtual BOOL CheckMeleeAttack2( float flDot, float flDist );
|
||||
|
||||
BOOL FHaveSchedule( void );
|
||||
BOOL FScheduleValid ( void );
|
||||
void ClearSchedule( void );
|
||||
BOOL FScheduleDone ( void );
|
||||
void ChangeSchedule ( Schedule_t *pNewSchedule );
|
||||
void NextScheduledTask ( void );
|
||||
Schedule_t *ScheduleInList( const char *pName, Schedule_t **pList, int listCount );
|
||||
BOOL FHaveSchedule( void );
|
||||
BOOL FScheduleValid( void );
|
||||
void ClearSchedule( void );
|
||||
BOOL FScheduleDone( void );
|
||||
void ChangeSchedule( Schedule_t *pNewSchedule );
|
||||
void NextScheduledTask( void );
|
||||
Schedule_t *ScheduleInList( const char *pName, Schedule_t **pList, int listCount );
|
||||
|
||||
virtual Schedule_t *ScheduleFromName( const char *pName );
|
||||
static Schedule_t *m_scheduleList[];
|
||||
|
||||
void MaintainSchedule ( void );
|
||||
virtual void StartTask ( Task_t *pTask );
|
||||
virtual void RunTask ( Task_t *pTask );
|
||||
virtual Schedule_t *GetScheduleOfType( int Type );
|
||||
virtual Schedule_t *GetSchedule( void );
|
||||
virtual void ScheduleChange( void ) {}
|
||||
// virtual int CanPlaySequence( void ) { return ((m_pCine == NULL) && (m_MonsterState == MONSTERSTATE_NONE || m_MonsterState == MONSTERSTATE_IDLE || m_IdealMonsterState == MONSTERSTATE_IDLE)); }
|
||||
virtual int CanPlaySequence( BOOL fDisregardState, int interruptLevel );
|
||||
virtual int CanPlaySentence( BOOL fDisregardState ) { return IsAlive(); }
|
||||
virtual void PlaySentence( const char *pszSentence, float duration, float volume, float attenuation );
|
||||
virtual void PlayScriptedSentence( const char *pszSentence, float duration, float volume, float attenuation, BOOL bConcurrent, CBaseEntity *pListener );
|
||||
virtual Schedule_t *ScheduleFromName( const char *pName );
|
||||
static Schedule_t *m_scheduleList[];
|
||||
|
||||
virtual void SentenceStop( void );
|
||||
void MaintainSchedule( void );
|
||||
virtual void StartTask( Task_t *pTask );
|
||||
virtual void RunTask( Task_t *pTask );
|
||||
virtual Schedule_t *GetScheduleOfType( int Type );
|
||||
virtual Schedule_t *GetSchedule( void );
|
||||
virtual void ScheduleChange( void ) {}
|
||||
// virtual int CanPlaySequence( void ) { return ((m_pCine == NULL) && (m_MonsterState == MONSTERSTATE_NONE || m_MonsterState == MONSTERSTATE_IDLE || m_IdealMonsterState == MONSTERSTATE_IDLE)); }
|
||||
virtual int CanPlaySequence( BOOL fDisregardState, int interruptLevel );
|
||||
virtual int CanPlaySentence( BOOL fDisregardState ) { return IsAlive(); }
|
||||
virtual void PlaySentence( const char *pszSentence, float duration, float volume, float attenuation );
|
||||
virtual void PlayScriptedSentence( const char *pszSentence, float duration, float volume, float attenuation, BOOL bConcurrent, CBaseEntity *pListener );
|
||||
|
||||
Task_t *GetTask ( void );
|
||||
virtual MONSTERSTATE GetIdealState ( void );
|
||||
virtual void SetActivity ( Activity NewActivity );
|
||||
void SetSequenceByName ( char *szSequence );
|
||||
void SetState ( MONSTERSTATE State );
|
||||
virtual void ReportAIState( void );
|
||||
virtual void SentenceStop( void );
|
||||
|
||||
void CheckAttacks ( CBaseEntity *pTarget, float flDist );
|
||||
virtual int CheckEnemy ( CBaseEntity *pEnemy );
|
||||
void PushEnemy( CBaseEntity *pEnemy, Vector &vecLastKnownPos );
|
||||
BOOL PopEnemy( void );
|
||||
Task_t *GetTask( void );
|
||||
virtual MONSTERSTATE GetIdealState( void );
|
||||
virtual void SetActivity( Activity NewActivity );
|
||||
void SetSequenceByName( char *szSequence );
|
||||
void SetState( MONSTERSTATE State );
|
||||
virtual void ReportAIState( void );
|
||||
|
||||
BOOL FGetNodeRoute ( Vector vecDest );
|
||||
|
||||
inline void TaskComplete( void ) { if ( !HasConditions(bits_COND_TASK_FAILED) ) m_iTaskStatus = TASKSTATUS_COMPLETE; }
|
||||
void MovementComplete( void );
|
||||
inline void TaskFail( void ) { SetConditions(bits_COND_TASK_FAILED); }
|
||||
inline void TaskBegin( void ) { m_iTaskStatus = TASKSTATUS_RUNNING; }
|
||||
int TaskIsRunning( void );
|
||||
inline int TaskIsComplete( void ) { return (m_iTaskStatus == TASKSTATUS_COMPLETE); }
|
||||
inline int MovementIsComplete( void ) { return (m_movementGoal == MOVEGOAL_NONE); }
|
||||
void CheckAttacks( CBaseEntity *pTarget, float flDist );
|
||||
virtual int CheckEnemy( CBaseEntity *pEnemy );
|
||||
void PushEnemy( CBaseEntity *pEnemy, Vector &vecLastKnownPos );
|
||||
BOOL PopEnemy( void );
|
||||
|
||||
int IScheduleFlags ( void );
|
||||
BOOL FRefreshRoute( void );
|
||||
BOOL FRouteClear ( void );
|
||||
void RouteSimplify( CBaseEntity *pTargetEnt );
|
||||
void AdvanceRoute ( float distance );
|
||||
virtual BOOL FTriangulate ( const Vector &vecStart , const Vector &vecEnd, float flDist, CBaseEntity *pTargetEnt, Vector *pApex );
|
||||
void MakeIdealYaw( Vector vecTarget );
|
||||
virtual void SetYawSpeed ( void ) { return; };// allows different yaw_speeds for each activity
|
||||
BOOL BuildRoute ( const Vector &vecGoal, int iMoveFlag, CBaseEntity *pTarget );
|
||||
virtual BOOL BuildNearestRoute ( Vector vecThreat, Vector vecViewOffset, float flMinDist, float flMaxDist );
|
||||
int RouteClassify( int iMoveFlag );
|
||||
void InsertWaypoint ( Vector vecLocation, int afMoveFlags );
|
||||
|
||||
BOOL FindLateralCover ( const Vector &vecThreat, const Vector &vecViewOffset );
|
||||
virtual BOOL FindCover ( Vector vecThreat, Vector vecViewOffset, float flMinDist, float flMaxDist );
|
||||
virtual BOOL FValidateCover ( const Vector &vecCoverLocation ) { return TRUE; };
|
||||
virtual float CoverRadius( void ) { return 784; } // Default cover radius
|
||||
BOOL FGetNodeRoute( Vector vecDest );
|
||||
|
||||
inline void TaskComplete( void ) { if ( !HasConditions( bits_COND_TASK_FAILED ) ) m_iTaskStatus = TASKSTATUS_COMPLETE; }
|
||||
void MovementComplete( void );
|
||||
inline void TaskFail( void ) { SetConditions( bits_COND_TASK_FAILED ); }
|
||||
inline void TaskBegin( void ) { m_iTaskStatus = TASKSTATUS_RUNNING; }
|
||||
int TaskIsRunning( void );
|
||||
inline int TaskIsComplete( void ) { return ( m_iTaskStatus == TASKSTATUS_COMPLETE ); }
|
||||
inline int MovementIsComplete( void ) { return ( m_movementGoal == MOVEGOAL_NONE ); }
|
||||
|
||||
virtual BOOL FCanCheckAttacks ( void );
|
||||
virtual void CheckAmmo( void ) { return; };
|
||||
virtual int IgnoreConditions ( void );
|
||||
|
||||
inline void SetConditions( int iConditions ) { m_afConditions |= iConditions; }
|
||||
inline void ClearConditions( int iConditions ) { m_afConditions &= ~iConditions; }
|
||||
inline BOOL HasConditions( int iConditions ) { if ( m_afConditions & iConditions ) return TRUE; return FALSE; }
|
||||
inline BOOL HasAllConditions( int iConditions ) { if ( (m_afConditions & iConditions) == iConditions ) return TRUE; return FALSE; }
|
||||
int IScheduleFlags( void );
|
||||
BOOL FRefreshRoute( void );
|
||||
BOOL FRouteClear( void );
|
||||
void RouteSimplify( CBaseEntity *pTargetEnt );
|
||||
void AdvanceRoute( float distance );
|
||||
virtual BOOL FTriangulate( const Vector &vecStart , const Vector &vecEnd, float flDist, CBaseEntity *pTargetEnt, Vector *pApex );
|
||||
void MakeIdealYaw( Vector vecTarget );
|
||||
virtual void SetYawSpeed( void ) { return; };// allows different yaw_speeds for each activity
|
||||
BOOL BuildRoute( const Vector &vecGoal, int iMoveFlag, CBaseEntity *pTarget );
|
||||
virtual BOOL BuildNearestRoute( Vector vecThreat, Vector vecViewOffset, float flMinDist, float flMaxDist );
|
||||
int RouteClassify( int iMoveFlag );
|
||||
void InsertWaypoint( Vector vecLocation, int afMoveFlags );
|
||||
|
||||
virtual BOOL FValidateHintType( short sHint );
|
||||
int FindHintNode ( void );
|
||||
virtual BOOL FCanActiveIdle ( void );
|
||||
void SetTurnActivity ( void );
|
||||
float FLSoundVolume ( CSound *pSound );
|
||||
BOOL FindLateralCover( const Vector &vecThreat, const Vector &vecViewOffset );
|
||||
virtual BOOL FindCover( Vector vecThreat, Vector vecViewOffset, float flMinDist, float flMaxDist );
|
||||
virtual BOOL FValidateCover( const Vector &vecCoverLocation ) { return TRUE; };
|
||||
virtual float CoverRadius( void ) { return 784; } // Default cover radius
|
||||
|
||||
BOOL MoveToNode( Activity movementAct, float waitTime, const Vector &goal );
|
||||
BOOL MoveToTarget( Activity movementAct, float waitTime );
|
||||
BOOL MoveToLocation( Activity movementAct, float waitTime, const Vector &goal );
|
||||
BOOL MoveToEnemy( Activity movementAct, float waitTime );
|
||||
virtual BOOL FCanCheckAttacks( void );
|
||||
virtual void CheckAmmo( void ) { return; };
|
||||
virtual int IgnoreConditions( void );
|
||||
|
||||
// Returns the time when the door will be open
|
||||
float OpenDoorAndWait( entvars_t *pevDoor );
|
||||
inline void SetConditions( int iConditions ) { m_afConditions |= iConditions; }
|
||||
inline void ClearConditions( int iConditions ) { m_afConditions &= ~iConditions; }
|
||||
inline BOOL HasConditions( int iConditions ) { if ( m_afConditions & iConditions ) return TRUE; return FALSE; }
|
||||
inline BOOL HasAllConditions( int iConditions ) { if ( (m_afConditions & iConditions) == iConditions ) return TRUE; return FALSE; }
|
||||
|
||||
virtual int ISoundMask( void );
|
||||
virtual CSound* PBestSound ( void );
|
||||
virtual CSound* PBestScent ( void );
|
||||
virtual float HearingSensitivity( void ) { return 1.0; };
|
||||
virtual BOOL FValidateHintType( short sHint );
|
||||
int FindHintNode( void );
|
||||
virtual BOOL FCanActiveIdle( void );
|
||||
void SetTurnActivity( void );
|
||||
float FLSoundVolume( CSound *pSound );
|
||||
|
||||
BOOL FBecomeProne ( void );
|
||||
virtual void BarnacleVictimBitten( entvars_t *pevBarnacle );
|
||||
virtual void BarnacleVictimReleased( void );
|
||||
BOOL MoveToNode( Activity movementAct, float waitTime, const Vector &goal );
|
||||
BOOL MoveToTarget( Activity movementAct, float waitTime );
|
||||
BOOL MoveToLocation( Activity movementAct, float waitTime, const Vector &goal );
|
||||
BOOL MoveToEnemy( Activity movementAct, float waitTime );
|
||||
|
||||
void SetEyePosition ( void );
|
||||
// Returns the time when the door will be open
|
||||
float OpenDoorAndWait( entvars_t *pevDoor );
|
||||
|
||||
BOOL FShouldEat( void );// see if a monster is 'hungry'
|
||||
void Eat ( float flFullDuration );// make the monster 'full' for a while.
|
||||
virtual int ISoundMask( void );
|
||||
virtual CSound* PBestSound( void );
|
||||
virtual CSound* PBestScent( void );
|
||||
virtual float HearingSensitivity( void ) { return 1.0; };
|
||||
|
||||
CBaseEntity *CheckTraceHullAttack( float flDist, int iDamage, int iDmgType );
|
||||
BOOL FacingIdeal( void );
|
||||
BOOL FBecomeProne( void );
|
||||
virtual void BarnacleVictimBitten( entvars_t *pevBarnacle );
|
||||
virtual void BarnacleVictimReleased( void );
|
||||
|
||||
BOOL FCheckAITrigger( void );// checks and, if necessary, fires the monster's trigger target.
|
||||
BOOL NoFriendlyFire( void );
|
||||
void SetEyePosition( void );
|
||||
|
||||
BOOL BBoxFlat( void );
|
||||
BOOL FShouldEat( void );// see if a monster is 'hungry'
|
||||
void Eat( float flFullDuration );// make the monster 'full' for a while.
|
||||
|
||||
// PrescheduleThink
|
||||
virtual void PrescheduleThink( void ) { return; };
|
||||
CBaseEntity *CheckTraceHullAttack( float flDist, int iDamage, int iDmgType );
|
||||
BOOL FacingIdeal( void );
|
||||
|
||||
BOOL GetEnemy ( void );
|
||||
void MakeDamageBloodDecal ( int cCount, float flNoise, TraceResult *ptr, const Vector &vecDir );
|
||||
void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
|
||||
BOOL FCheckAITrigger( void );// checks and, if necessary, fires the monster's trigger target.
|
||||
BOOL NoFriendlyFire( void );
|
||||
|
||||
BOOL BBoxFlat( void );
|
||||
|
||||
// PrescheduleThink
|
||||
virtual void PrescheduleThink( void ) { return; };
|
||||
|
||||
BOOL GetEnemy( void );
|
||||
void MakeDamageBloodDecal( int cCount, float flNoise, TraceResult *ptr, const Vector &vecDir );
|
||||
void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
|
||||
|
||||
// combat functions
|
||||
float UpdateTarget ( entvars_t *pevTarget );
|
||||
virtual Activity GetDeathActivity ( void );
|
||||
float UpdateTarget( entvars_t *pevTarget );
|
||||
virtual Activity GetDeathActivity( void );
|
||||
Activity GetSmallFlinchActivity( void );
|
||||
virtual void Killed( entvars_t *pevAttacker, int iGib );
|
||||
virtual void GibMonster( void );
|
||||
BOOL ShouldGibMonster( int iGib );
|
||||
void CallGibMonster( void );
|
||||
virtual BOOL HasHumanGibs( void );
|
||||
virtual BOOL HasAlienGibs( void );
|
||||
virtual void FadeMonster( void ); // Called instead of GibMonster() when gibs are disabled
|
||||
BOOL ShouldGibMonster( int iGib );
|
||||
void CallGibMonster( void );
|
||||
virtual BOOL HasHumanGibs( void );
|
||||
virtual BOOL HasAlienGibs( void );
|
||||
virtual void FadeMonster( void ); // Called instead of GibMonster() when gibs are disabled
|
||||
|
||||
Vector ShootAtEnemy( const Vector &shootOrigin );
|
||||
virtual Vector BodyTarget( const Vector &posSrc ) { return Center( ) * 0.75 + EyePosition() * 0.25; }; // position to shoot at
|
||||
virtual Vector BodyTarget( const Vector &posSrc ) { return Center() * 0.75 + EyePosition() * 0.25; }; // position to shoot at
|
||||
|
||||
virtual Vector GetGunPosition( void );
|
||||
virtual Vector GetGunPosition( void );
|
||||
|
||||
virtual int TakeHealth( float flHealth, int bitsDamageType );
|
||||
virtual int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType);
|
||||
int DeadTakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
|
||||
virtual int TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType);
|
||||
int DeadTakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
|
||||
|
||||
void RadiusDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType );
|
||||
void RadiusDamage(Vector vecSrc, entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType );
|
||||
virtual int IsMoving( void ) { return m_movementGoal != MOVEGOAL_NONE; }
|
||||
void RadiusDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType );
|
||||
void RadiusDamage( Vector vecSrc, entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType );
|
||||
virtual int IsMoving( void ) { return m_movementGoal != MOVEGOAL_NONE; }
|
||||
|
||||
void RouteClear( void );
|
||||
void RouteNew( void );
|
||||
|
||||
virtual void DeathSound ( void ) { return; };
|
||||
virtual void AlertSound ( void ) { return; };
|
||||
virtual void IdleSound ( void ) { return; };
|
||||
virtual void PainSound ( void ) { return; };
|
||||
|
||||
|
||||
virtual void DeathSound( void ) { return; };
|
||||
virtual void AlertSound( void ) { return; };
|
||||
virtual void IdleSound( void ) { return; };
|
||||
virtual void PainSound( void ) { return; };
|
||||
|
||||
virtual void StopFollowing( BOOL clearSchedule ) {}
|
||||
|
||||
inline void Remember( int iMemory ) { m_afMemory |= iMemory; }
|
||||
inline void Forget( int iMemory ) { m_afMemory &= ~iMemory; }
|
||||
inline void Remember( int iMemory ) { m_afMemory |= iMemory; }
|
||||
inline void Forget( int iMemory ) { m_afMemory &= ~iMemory; }
|
||||
inline BOOL HasMemory( int iMemory ) { if ( m_afMemory & iMemory ) return TRUE; return FALSE; }
|
||||
inline BOOL HasAllMemories( int iMemory ) { if ( (m_afMemory & iMemory) == iMemory ) return TRUE; return FALSE; }
|
||||
|
||||
BOOL ExitScriptedSequence( );
|
||||
BOOL CineCleanup( );
|
||||
BOOL ExitScriptedSequence();
|
||||
BOOL CineCleanup();
|
||||
|
||||
CBaseEntity* DropItem ( char *pszItemName, const Vector &vecPos, const Vector &vecAng );// drop an item.
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif // BASEMONSTER_H
|
||||
|
|
File diff suppressed because it is too large
Load Diff
109
dlls/bloater.cpp
109
dlls/bloater.cpp
|
@ -22,20 +22,18 @@
|
|||
#include "monsters.h"
|
||||
#include "schedule.h"
|
||||
|
||||
|
||||
//=========================================================
|
||||
// Monster's Anim Events Go Here
|
||||
//=========================================================
|
||||
#define BLOATER_AE_ATTACK_MELEE1 0x01
|
||||
|
||||
|
||||
class CBloater : public CBaseMonster
|
||||
{
|
||||
public:
|
||||
void Spawn( void );
|
||||
void Precache( void );
|
||||
void SetYawSpeed( void );
|
||||
int Classify ( void );
|
||||
int Classify( void );
|
||||
void HandleAnimEvent( MonsterEvent_t *pEvent );
|
||||
|
||||
void PainSound( void );
|
||||
|
@ -44,59 +42,57 @@ public:
|
|||
void AttackSnd( void );
|
||||
|
||||
// No range attacks
|
||||
BOOL CheckRangeAttack1 ( float flDot, float flDist ) { return FALSE; }
|
||||
BOOL CheckRangeAttack2 ( float flDot, float flDist ) { return FALSE; }
|
||||
BOOL CheckRangeAttack1( float flDot, float flDist ) { return FALSE; }
|
||||
BOOL CheckRangeAttack2( float flDot, float flDist ) { return FALSE; }
|
||||
int TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
|
||||
};
|
||||
|
||||
LINK_ENTITY_TO_CLASS( monster_bloater, CBloater );
|
||||
LINK_ENTITY_TO_CLASS( monster_bloater, CBloater )
|
||||
|
||||
//=========================================================
|
||||
// Classify - indicates this monster's place in the
|
||||
// relationship table.
|
||||
//=========================================================
|
||||
int CBloater :: Classify ( void )
|
||||
int CBloater::Classify( void )
|
||||
{
|
||||
return CLASS_ALIEN_MONSTER;
|
||||
return CLASS_ALIEN_MONSTER;
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
// SetYawSpeed - allows each sequence to have a different
|
||||
// turn rate associated with it.
|
||||
//=========================================================
|
||||
void CBloater :: SetYawSpeed ( void )
|
||||
void CBloater::SetYawSpeed( void )
|
||||
{
|
||||
int ys;
|
||||
|
||||
ys = 120;
|
||||
|
||||
#if 0
|
||||
switch ( m_Activity )
|
||||
switch( m_Activity )
|
||||
{
|
||||
}
|
||||
#endif
|
||||
|
||||
pev->yaw_speed = ys;
|
||||
}
|
||||
|
||||
int CBloater :: TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
|
||||
int CBloater::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
|
||||
{
|
||||
PainSound();
|
||||
return CBaseMonster::TakeDamage( pevInflictor, pevAttacker, flDamage, bitsDamageType );
|
||||
}
|
||||
|
||||
void CBloater :: PainSound( void )
|
||||
void CBloater::PainSound( void )
|
||||
{
|
||||
#if 0
|
||||
int pitch = 95 + RANDOM_LONG(0,9);
|
||||
int pitch = 95 + RANDOM_LONG( 0, 9 );
|
||||
|
||||
switch (RANDOM_LONG(0,5))
|
||||
switch( RANDOM_LONG( 0, 5 ) )
|
||||
{
|
||||
case 0:
|
||||
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "zombie/zo_pain1.wav", 1.0, ATTN_NORM, 0, pitch);
|
||||
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "zombie/zo_pain1.wav", 1.0, ATTN_NORM, 0, pitch );
|
||||
break;
|
||||
case 1:
|
||||
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "zombie/zo_pain2.wav", 1.0, ATTN_NORM, 0, pitch);
|
||||
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "zombie/zo_pain2.wav", 1.0, ATTN_NORM, 0, pitch );
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
|
@ -104,79 +100,77 @@ void CBloater :: PainSound( void )
|
|||
#endif
|
||||
}
|
||||
|
||||
void CBloater :: AlertSound( void )
|
||||
void CBloater::AlertSound( void )
|
||||
{
|
||||
#if 0
|
||||
int pitch = 95 + RANDOM_LONG(0,9);
|
||||
int pitch = 95 + RANDOM_LONG( 0, 9 );
|
||||
|
||||
switch (RANDOM_LONG(0,2))
|
||||
switch( RANDOM_LONG( 0, 2 ) )
|
||||
{
|
||||
case 0:
|
||||
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "zombie/zo_alert10.wav", 1.0, ATTN_NORM, 0, pitch);
|
||||
break;
|
||||
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "zombie/zo_alert10.wav", 1.0, ATTN_NORM, 0, pitch );
|
||||
break;
|
||||
case 1:
|
||||
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "zombie/zo_alert20.wav", 1.0, ATTN_NORM, 0, pitch);
|
||||
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "zombie/zo_alert20.wav", 1.0, ATTN_NORM, 0, pitch );
|
||||
break;
|
||||
case 2:
|
||||
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "zombie/zo_alert30.wav", 1.0, ATTN_NORM, 0, pitch);
|
||||
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "zombie/zo_alert30.wav", 1.0, ATTN_NORM, 0, pitch );
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void CBloater :: IdleSound( void )
|
||||
void CBloater::IdleSound( void )
|
||||
{
|
||||
#if 0
|
||||
int pitch = 95 + RANDOM_LONG(0,9);
|
||||
int pitch = 95 + RANDOM_LONG( 0, 9 );
|
||||
|
||||
switch (RANDOM_LONG(0,2))
|
||||
switch( RANDOM_LONG( 0, 2 ) )
|
||||
{
|
||||
case 0:
|
||||
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "zombie/zo_idle1.wav", 1.0, ATTN_NORM, 0, pitch);
|
||||
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "zombie/zo_idle1.wav", 1.0, ATTN_NORM, 0, pitch );
|
||||
break;
|
||||
case 1:
|
||||
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "zombie/zo_idle2.wav", 1.0, ATTN_NORM, 0, pitch);
|
||||
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "zombie/zo_idle2.wav", 1.0, ATTN_NORM, 0, pitch );
|
||||
break;
|
||||
case 2:
|
||||
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "zombie/zo_idle3.wav", 1.0, ATTN_NORM, 0, pitch);
|
||||
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "zombie/zo_idle3.wav", 1.0, ATTN_NORM, 0, pitch );
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void CBloater :: AttackSnd( void )
|
||||
void CBloater::AttackSnd( void )
|
||||
{
|
||||
#if 0
|
||||
int pitch = 95 + RANDOM_LONG(0,9);
|
||||
int pitch = 95 + RANDOM_LONG( 0, 9 );
|
||||
|
||||
switch (RANDOM_LONG(0,1))
|
||||
switch( RANDOM_LONG( 0, 1 ) )
|
||||
{
|
||||
case 0:
|
||||
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "zombie/zo_attack1.wav", 1.0, ATTN_NORM, 0, pitch);
|
||||
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "zombie/zo_attack1.wav", 1.0, ATTN_NORM, 0, pitch );
|
||||
break;
|
||||
case 1:
|
||||
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "zombie/zo_attack2.wav", 1.0, ATTN_NORM, 0, pitch);
|
||||
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "zombie/zo_attack2.wav", 1.0, ATTN_NORM, 0, pitch );
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
//=========================================================
|
||||
// HandleAnimEvent - catches the monster-specific messages
|
||||
// that occur when tagged animation frames are played.
|
||||
//=========================================================
|
||||
void CBloater :: HandleAnimEvent( MonsterEvent_t *pEvent )
|
||||
void CBloater::HandleAnimEvent( MonsterEvent_t *pEvent )
|
||||
{
|
||||
switch( pEvent->event )
|
||||
{
|
||||
case BLOATER_AE_ATTACK_MELEE1:
|
||||
{
|
||||
// do stuff for this event.
|
||||
AttackSnd();
|
||||
}
|
||||
break;
|
||||
|
||||
{
|
||||
// do stuff for this event.
|
||||
AttackSnd();
|
||||
}
|
||||
break;
|
||||
default:
|
||||
CBaseMonster::HandleAnimEvent( pEvent );
|
||||
break;
|
||||
|
@ -186,21 +180,21 @@ void CBloater :: HandleAnimEvent( MonsterEvent_t *pEvent )
|
|||
//=========================================================
|
||||
// Spawn
|
||||
//=========================================================
|
||||
void CBloater :: Spawn()
|
||||
void CBloater::Spawn()
|
||||
{
|
||||
Precache( );
|
||||
Precache();
|
||||
|
||||
SET_MODEL(ENT(pev), "models/floater.mdl");
|
||||
SET_MODEL( ENT( pev ), "models/floater.mdl" );
|
||||
UTIL_SetSize( pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX );
|
||||
|
||||
pev->solid = SOLID_SLIDEBOX;
|
||||
pev->movetype = MOVETYPE_FLY;
|
||||
pev->spawnflags |= FL_FLY;
|
||||
m_bloodColor = BLOOD_COLOR_GREEN;
|
||||
pev->health = 40;
|
||||
pev->view_ofs = VEC_VIEW;// position of the eyes relative to monster's origin.
|
||||
m_flFieldOfView = 0.5;// indicates the width of this monster's forward view cone ( as a dotproduct result )
|
||||
m_MonsterState = MONSTERSTATE_NONE;
|
||||
pev->solid = SOLID_SLIDEBOX;
|
||||
pev->movetype = MOVETYPE_FLY;
|
||||
pev->spawnflags |= FL_FLY;
|
||||
m_bloodColor = BLOOD_COLOR_GREEN;
|
||||
pev->health = 40;
|
||||
pev->view_ofs = VEC_VIEW;// position of the eyes relative to monster's origin.
|
||||
m_flFieldOfView = 0.5;// indicates the width of this monster's forward view cone ( as a dotproduct result )
|
||||
m_MonsterState = MONSTERSTATE_NONE;
|
||||
|
||||
MonsterInit();
|
||||
}
|
||||
|
@ -208,12 +202,11 @@ void CBloater :: Spawn()
|
|||
//=========================================================
|
||||
// Precache - precaches all resources this monster needs
|
||||
//=========================================================
|
||||
void CBloater :: Precache()
|
||||
void CBloater::Precache()
|
||||
{
|
||||
PRECACHE_MODEL("models/floater.mdl");
|
||||
PRECACHE_MODEL( "models/floater.mdl" );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
// AI Schedules Specific to this monster
|
||||
//=========================================================
|
||||
|
||||
|
|
574
dlls/bmodels.cpp
574
dlls/bmodels.cpp
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
852
dlls/buttons.cpp
852
dlls/buttons.cpp
File diff suppressed because it is too large
Load Diff
383
dlls/cbase.cpp
383
dlls/cbase.cpp
|
@ -12,6 +12,7 @@
|
|||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
|
||||
#include "extdll.h"
|
||||
#include "util.h"
|
||||
#include "cbase.h"
|
||||
|
@ -28,10 +29,10 @@ extern "C" void PM_Init ( struct playermove_s *ppmove );
|
|||
extern "C" char PM_FindTextureType( char *name );
|
||||
|
||||
extern Vector VecBModelOrigin( entvars_t* pevBModel );
|
||||
extern DLL_GLOBAL Vector g_vecAttackDir;
|
||||
extern DLL_GLOBAL int g_iSkillLevel;
|
||||
extern DLL_GLOBAL Vector g_vecAttackDir;
|
||||
extern DLL_GLOBAL int g_iSkillLevel;
|
||||
|
||||
static DLL_FUNCTIONS gFunctionTable =
|
||||
static DLL_FUNCTIONS gFunctionTable =
|
||||
{
|
||||
GameDLLInit, //pfnGameInit
|
||||
DispatchSpawn, //pfnSpawn
|
||||
|
@ -79,7 +80,7 @@ static DLL_FUNCTIONS gFunctionTable =
|
|||
PM_Move, //pfnPM_Move
|
||||
PM_Init, //pfnPM_Init Server version of player movement initialization
|
||||
PM_FindTextureType, //pfnPM_FindTextureType
|
||||
|
||||
|
||||
SetupVisibility, //pfnSetupVisibility Set up PVS and PAS for networking for this client
|
||||
UpdateClientData, //pfnUpdateClientData Set up data sent only to specific client
|
||||
AddToFullPack, //pfnAddToFullPack
|
||||
|
@ -102,25 +103,25 @@ extern "C" {
|
|||
#endif
|
||||
int GetEntityAPI( DLL_FUNCTIONS *pFunctionTable, int interfaceVersion )
|
||||
{
|
||||
if ( !pFunctionTable || interfaceVersion != INTERFACE_VERSION )
|
||||
if( !pFunctionTable || interfaceVersion != INTERFACE_VERSION )
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
memcpy( pFunctionTable, &gFunctionTable, sizeof( DLL_FUNCTIONS ) );
|
||||
memcpy( pFunctionTable, &gFunctionTable, sizeof(DLL_FUNCTIONS) );
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
int GetEntityAPI2( DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion )
|
||||
{
|
||||
if ( !pFunctionTable || *interfaceVersion != INTERFACE_VERSION )
|
||||
if( !pFunctionTable || *interfaceVersion != INTERFACE_VERSION )
|
||||
{
|
||||
// Tell engine what version we had, so it can figure out who is out of date.
|
||||
*interfaceVersion = INTERFACE_VERSION;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
memcpy( pFunctionTable, &gFunctionTable, sizeof( DLL_FUNCTIONS ) );
|
||||
|
||||
memcpy( pFunctionTable, &gFunctionTable, sizeof(DLL_FUNCTIONS) );
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
@ -128,43 +129,41 @@ int GetEntityAPI2( DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion )
|
|||
}
|
||||
#endif
|
||||
|
||||
|
||||
int DispatchSpawn( edict_t *pent )
|
||||
{
|
||||
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pent);
|
||||
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE( pent );
|
||||
|
||||
if (pEntity)
|
||||
if( pEntity )
|
||||
{
|
||||
// Initialize these or entities who don't link to the world won't have anything in here
|
||||
pEntity->pev->absmin = pEntity->pev->origin - Vector(1,1,1);
|
||||
pEntity->pev->absmax = pEntity->pev->origin + Vector(1,1,1);
|
||||
pEntity->pev->absmin = pEntity->pev->origin - Vector( 1, 1, 1 );
|
||||
pEntity->pev->absmax = pEntity->pev->origin + Vector( 1, 1, 1 );
|
||||
|
||||
pEntity->Spawn();
|
||||
|
||||
// Try to get the pointer again, in case the spawn function deleted the entity.
|
||||
// UNDONE: Spawn() should really return a code to ask that the entity be deleted, but
|
||||
// that would touch too much code for me to do that right now.
|
||||
pEntity = (CBaseEntity *)GET_PRIVATE(pent);
|
||||
pEntity = (CBaseEntity *)GET_PRIVATE( pent );
|
||||
|
||||
if ( pEntity )
|
||||
if( pEntity )
|
||||
{
|
||||
if ( g_pGameRules && !g_pGameRules->IsAllowedToSpawn( pEntity ) )
|
||||
if( g_pGameRules && !g_pGameRules->IsAllowedToSpawn( pEntity ) )
|
||||
return -1; // return that this entity should be deleted
|
||||
if ( pEntity->pev->flags & FL_KILLME )
|
||||
if( pEntity->pev->flags & FL_KILLME )
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
// Handle global stuff here
|
||||
if ( pEntity && pEntity->pev->globalname )
|
||||
if( pEntity && pEntity->pev->globalname )
|
||||
{
|
||||
const globalentity_t *pGlobal = gGlobalState.EntityFromTable( pEntity->pev->globalname );
|
||||
if ( pGlobal )
|
||||
if( pGlobal )
|
||||
{
|
||||
// Already dead? delete
|
||||
if ( pGlobal->state == GLOBAL_DEAD )
|
||||
if( pGlobal->state == GLOBAL_DEAD )
|
||||
return -1;
|
||||
else if ( !FStrEq( STRING(gpGlobals->mapname), pGlobal->levelName ) )
|
||||
else if( !FStrEq( STRING( gpGlobals->mapname ), pGlobal->levelName ) )
|
||||
pEntity->MakeDormant(); // Hasn't been moved to this level yet, wait but stay alive
|
||||
// In this level & not dead, continue on as normal
|
||||
}
|
||||
|
@ -172,7 +171,7 @@ int DispatchSpawn( edict_t *pent )
|
|||
{
|
||||
// Spawned entities default to 'On'
|
||||
gGlobalState.EntityAdd( pEntity->pev->globalname, gpGlobals->mapname, GLOBAL_ON );
|
||||
// ALERT( at_console, "Added global entity %s (%s)\n", STRING(pEntity->pev->classname), STRING(pEntity->pev->globalname) );
|
||||
//ALERT( at_console, "Added global entity %s (%s)\n", STRING( pEntity->pev->classname ), STRING( pEntity->pev->globalname ) );
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -183,10 +182,10 @@ int DispatchSpawn( edict_t *pent )
|
|||
|
||||
void DispatchKeyValue( edict_t *pentKeyvalue, KeyValueData *pkvd )
|
||||
{
|
||||
if ( !pkvd || !pentKeyvalue )
|
||||
if( !pkvd || !pentKeyvalue )
|
||||
return;
|
||||
|
||||
EntvarsKeyvalue( VARS(pentKeyvalue), pkvd );
|
||||
EntvarsKeyvalue( VARS( pentKeyvalue ), pkvd );
|
||||
|
||||
// If the key was an entity variable, or there's no class set yet, don't look for the object, it may
|
||||
// not exist yet.
|
||||
|
@ -194,48 +193,47 @@ void DispatchKeyValue( edict_t *pentKeyvalue, KeyValueData *pkvd )
|
|||
return;
|
||||
|
||||
// Get the actualy entity object
|
||||
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pentKeyvalue);
|
||||
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE( pentKeyvalue );
|
||||
|
||||
if ( !pEntity )
|
||||
if( !pEntity )
|
||||
return;
|
||||
|
||||
pEntity->KeyValue( pkvd );
|
||||
}
|
||||
|
||||
|
||||
// HACKHACK -- this is a hack to keep the node graph entity from "touching" things (like triggers)
|
||||
// while it builds the graph
|
||||
BOOL gTouchDisabled = FALSE;
|
||||
|
||||
void DispatchTouch( edict_t *pentTouched, edict_t *pentOther )
|
||||
{
|
||||
if ( gTouchDisabled )
|
||||
if( gTouchDisabled )
|
||||
return;
|
||||
|
||||
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pentTouched);
|
||||
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE( pentTouched );
|
||||
CBaseEntity *pOther = (CBaseEntity *)GET_PRIVATE( pentOther );
|
||||
|
||||
if ( pEntity && pOther && ! ((pEntity->pev->flags | pOther->pev->flags) & FL_KILLME) )
|
||||
if( pEntity && pOther && ! ( ( pEntity->pev->flags | pOther->pev->flags ) & FL_KILLME ) )
|
||||
pEntity->Touch( pOther );
|
||||
}
|
||||
|
||||
|
||||
void DispatchUse( edict_t *pentUsed, edict_t *pentOther )
|
||||
{
|
||||
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pentUsed);
|
||||
CBaseEntity *pOther = (CBaseEntity *)GET_PRIVATE(pentOther);
|
||||
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE( pentUsed );
|
||||
CBaseEntity *pOther = (CBaseEntity *)GET_PRIVATE( pentOther );
|
||||
|
||||
if (pEntity && !(pEntity->pev->flags & FL_KILLME) )
|
||||
if( pEntity && !( pEntity->pev->flags & FL_KILLME ) )
|
||||
pEntity->Use( pOther, pOther, USE_TOGGLE, 0 );
|
||||
}
|
||||
|
||||
void DispatchThink( edict_t *pent )
|
||||
{
|
||||
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pent);
|
||||
if (pEntity)
|
||||
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE( pent );
|
||||
if( pEntity )
|
||||
{
|
||||
if ( FBitSet( pEntity->pev->flags, FL_DORMANT ) )
|
||||
ALERT( at_error, "Dormant entity %s is thinking!!\n", STRING(pEntity->pev->classname) );
|
||||
|
||||
if( FBitSet( pEntity->pev->flags, FL_DORMANT ) )
|
||||
ALERT( at_error, "Dormant entity %s is thinking!!\n", STRING( pEntity->pev->classname ) );
|
||||
|
||||
pEntity->Think();
|
||||
}
|
||||
}
|
||||
|
@ -245,26 +243,26 @@ void DispatchBlocked( edict_t *pentBlocked, edict_t *pentOther )
|
|||
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE( pentBlocked );
|
||||
CBaseEntity *pOther = (CBaseEntity *)GET_PRIVATE( pentOther );
|
||||
|
||||
if (pEntity)
|
||||
if( pEntity )
|
||||
pEntity->Blocked( pOther );
|
||||
}
|
||||
|
||||
void DispatchSave( edict_t *pent, SAVERESTOREDATA *pSaveData )
|
||||
{
|
||||
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pent);
|
||||
|
||||
if ( pEntity && pSaveData )
|
||||
{
|
||||
ENTITYTABLE *pTable = &pSaveData->pTable[ pSaveData->currentIndex ];
|
||||
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE( pent );
|
||||
|
||||
if ( pTable->pent != pent )
|
||||
if( pEntity && pSaveData )
|
||||
{
|
||||
ENTITYTABLE *pTable = &pSaveData->pTable[pSaveData->currentIndex];
|
||||
|
||||
if( pTable->pent != pent )
|
||||
ALERT( at_error, "ENTITY TABLE OR INDEX IS WRONG!!!!\n" );
|
||||
|
||||
if ( pEntity->ObjectCaps() & FCAP_DONT_SAVE )
|
||||
if( pEntity->ObjectCaps() & FCAP_DONT_SAVE )
|
||||
return;
|
||||
|
||||
// These don't use ltime & nextthink as times really, but we'll fudge around it.
|
||||
if ( pEntity->pev->movetype == MOVETYPE_PUSH )
|
||||
if( pEntity->pev->movetype == MOVETYPE_PUSH )
|
||||
{
|
||||
float delta = pEntity->pev->nextthink - pEntity->pev->ltime;
|
||||
pEntity->pev->ltime = gpGlobals->time;
|
||||
|
@ -281,18 +279,17 @@ void DispatchSave( edict_t *pent, SAVERESTOREDATA *pSaveData )
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
// Find the matching global entity. Spit out an error if the designer made entities of
|
||||
// different classes with the same global name
|
||||
CBaseEntity *FindGlobalEntity( string_t classname, string_t globalname )
|
||||
{
|
||||
edict_t *pent = FIND_ENTITY_BY_STRING( NULL, "globalname", STRING(globalname) );
|
||||
edict_t *pent = FIND_ENTITY_BY_STRING( NULL, "globalname", STRING( globalname ) );
|
||||
CBaseEntity *pReturn = CBaseEntity::Instance( pent );
|
||||
if ( pReturn )
|
||||
if( pReturn )
|
||||
{
|
||||
if ( !FClassnameIs( pReturn->pev, STRING(classname) ) )
|
||||
if( !FClassnameIs( pReturn->pev, STRING( classname ) ) )
|
||||
{
|
||||
ALERT( at_console, "Global entity found %s, wrong class %s\n", STRING(globalname), STRING(pReturn->pev->classname) );
|
||||
ALERT( at_console, "Global entity found %s, wrong class %s\n", STRING( globalname ), STRING( pReturn->pev->classname ) );
|
||||
pReturn = NULL;
|
||||
}
|
||||
}
|
||||
|
@ -300,18 +297,17 @@ CBaseEntity *FindGlobalEntity( string_t classname, string_t globalname )
|
|||
return pReturn;
|
||||
}
|
||||
|
||||
|
||||
int DispatchRestore( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity )
|
||||
{
|
||||
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pent);
|
||||
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE( pent );
|
||||
|
||||
if ( pEntity && pSaveData )
|
||||
if( pEntity && pSaveData )
|
||||
{
|
||||
entvars_t tmpVars;
|
||||
Vector oldOffset;
|
||||
|
||||
CRestore restoreHelper( pSaveData );
|
||||
if ( globalEntity )
|
||||
if( globalEntity )
|
||||
{
|
||||
CRestore tmpRestore( pSaveData );
|
||||
tmpRestore.PrecacheMode( 0 );
|
||||
|
@ -322,25 +318,24 @@ int DispatchRestore( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity
|
|||
pSaveData->pCurrentData = pSaveData->pBaseData + pSaveData->size;
|
||||
// -------------------
|
||||
|
||||
|
||||
const globalentity_t *pGlobal = gGlobalState.EntityFromTable( tmpVars.globalname );
|
||||
|
||||
|
||||
// Don't overlay any instance of the global that isn't the latest
|
||||
// pSaveData->szCurrentMapName is the level this entity is coming from
|
||||
// pGlobla->levelName is the last level the global entity was active in.
|
||||
// If they aren't the same, then this global update is out of date.
|
||||
if ( !FStrEq( pSaveData->szCurrentMapName, pGlobal->levelName ) )
|
||||
if( !FStrEq( pSaveData->szCurrentMapName, pGlobal->levelName ) )
|
||||
return 0;
|
||||
|
||||
// Compute the new global offset
|
||||
oldOffset = pSaveData->vecLandmarkOffset;
|
||||
CBaseEntity *pNewEntity = FindGlobalEntity( tmpVars.classname, tmpVars.globalname );
|
||||
if ( pNewEntity )
|
||||
if( pNewEntity )
|
||||
{
|
||||
// ALERT( at_console, "Overlay %s with %s\n", STRING(pNewEntity->pev->classname), STRING(tmpVars.classname) );
|
||||
//ALERT( at_console, "Overlay %s with %s\n", STRING( pNewEntity->pev->classname ), STRING( tmpVars.classname ) );
|
||||
// Tell the restore code we're overlaying a global entity from another level
|
||||
restoreHelper.SetGlobalMode( 1 ); // Don't overwrite global fields
|
||||
pSaveData->vecLandmarkOffset = (pSaveData->vecLandmarkOffset - pNewEntity->pev->mins) + tmpVars.mins;
|
||||
pSaveData->vecLandmarkOffset = ( pSaveData->vecLandmarkOffset - pNewEntity->pev->mins ) + tmpVars.mins;
|
||||
pEntity = pNewEntity;// we're going to restore this data OVER the old entity
|
||||
pent = ENT( pEntity->pev );
|
||||
// Update the global table to say that the global definition of this entity should come from this level
|
||||
|
@ -352,10 +347,9 @@ int DispatchRestore( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity
|
|||
// or call EntityUpdate() to move it to this level, we haven't changed global state at all.
|
||||
return 0;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if ( pEntity->ObjectCaps() & FCAP_MUST_SPAWN )
|
||||
if( pEntity->ObjectCaps() & FCAP_MUST_SPAWN )
|
||||
{
|
||||
pEntity->Restore( restoreHelper );
|
||||
pEntity->Spawn();
|
||||
|
@ -363,39 +357,37 @@ int DispatchRestore( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity
|
|||
else
|
||||
{
|
||||
pEntity->Restore( restoreHelper );
|
||||
pEntity->Precache( );
|
||||
pEntity->Precache();
|
||||
}
|
||||
|
||||
// Again, could be deleted, get the pointer again.
|
||||
pEntity = (CBaseEntity *)GET_PRIVATE(pent);
|
||||
|
||||
pEntity = (CBaseEntity *)GET_PRIVATE( pent );
|
||||
#if 0
|
||||
if ( pEntity && pEntity->pev->globalname && globalEntity )
|
||||
if( pEntity && pEntity->pev->globalname && globalEntity )
|
||||
{
|
||||
ALERT( at_console, "Global %s is %s\n", STRING(pEntity->pev->globalname), STRING(pEntity->pev->model) );
|
||||
ALERT( at_console, "Global %s is %s\n", STRING( pEntity->pev->globalname ), STRING( pEntity->pev->model ) );
|
||||
}
|
||||
#endif
|
||||
|
||||
// Is this an overriding global entity (coming over the transition), or one restoring in a level
|
||||
if ( globalEntity )
|
||||
if( globalEntity )
|
||||
{
|
||||
// ALERT( at_console, "After: %f %f %f %s\n", pEntity->pev->origin.x, pEntity->pev->origin.y, pEntity->pev->origin.z, STRING(pEntity->pev->model) );
|
||||
//ALERT( at_console, "After: %f %f %f %s\n", pEntity->pev->origin.x, pEntity->pev->origin.y, pEntity->pev->origin.z, STRING( pEntity->pev->model ) );
|
||||
pSaveData->vecLandmarkOffset = oldOffset;
|
||||
if ( pEntity )
|
||||
if( pEntity )
|
||||
{
|
||||
UTIL_SetOrigin( pEntity->pev, pEntity->pev->origin );
|
||||
pEntity->OverrideReset();
|
||||
}
|
||||
}
|
||||
else if ( pEntity && pEntity->pev->globalname )
|
||||
else if( pEntity && pEntity->pev->globalname )
|
||||
{
|
||||
const globalentity_t *pGlobal = gGlobalState.EntityFromTable( pEntity->pev->globalname );
|
||||
if ( pGlobal )
|
||||
if( pGlobal )
|
||||
{
|
||||
// Already dead? delete
|
||||
if ( pGlobal->state == GLOBAL_DEAD )
|
||||
if( pGlobal->state == GLOBAL_DEAD )
|
||||
return -1;
|
||||
else if ( !FStrEq( STRING(gpGlobals->mapname), pGlobal->levelName ) )
|
||||
else if( !FStrEq( STRING( gpGlobals->mapname ), pGlobal->levelName ) )
|
||||
{
|
||||
pEntity->MakeDormant(); // Hasn't been moved to this level yet, wait but stay alive
|
||||
}
|
||||
|
@ -403,7 +395,7 @@ int DispatchRestore( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity
|
|||
}
|
||||
else
|
||||
{
|
||||
ALERT( at_error, "Global Entity %s (%s) not in table!!!\n", STRING(pEntity->pev->globalname), STRING(pEntity->pev->classname) );
|
||||
ALERT( at_error, "Global Entity %s (%s) not in table!!!\n", STRING( pEntity->pev->globalname ), STRING( pEntity->pev->classname ) );
|
||||
// Spawned entities default to 'On'
|
||||
gGlobalState.EntityAdd( pEntity->pev->globalname, gpGlobals->mapname, GLOBAL_ON );
|
||||
}
|
||||
|
@ -412,11 +404,10 @@ int DispatchRestore( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity
|
|||
return 0;
|
||||
}
|
||||
|
||||
|
||||
void DispatchObjectCollsionBox( edict_t *pent )
|
||||
{
|
||||
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pent);
|
||||
if (pEntity)
|
||||
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE( pent );
|
||||
if( pEntity )
|
||||
{
|
||||
pEntity->SetObjectCollisionBox();
|
||||
}
|
||||
|
@ -424,54 +415,49 @@ void DispatchObjectCollsionBox( edict_t *pent )
|
|||
SetObjectCollisionBox( &pent->v );
|
||||
}
|
||||
|
||||
|
||||
void SaveWriteFields( SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount )
|
||||
{
|
||||
CSave saveHelper( pSaveData );
|
||||
saveHelper.WriteFields( pname, pBaseData, pFields, fieldCount );
|
||||
}
|
||||
|
||||
|
||||
void SaveReadFields( SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount )
|
||||
{
|
||||
CRestore restoreHelper( pSaveData );
|
||||
restoreHelper.ReadFields( pname, pBaseData, pFields, fieldCount );
|
||||
}
|
||||
|
||||
|
||||
edict_t * EHANDLE::Get( void )
|
||||
edict_t *EHANDLE::Get( void )
|
||||
{
|
||||
if (m_pent)
|
||||
if( m_pent )
|
||||
{
|
||||
if (m_pent->serialnumber == m_serialnumber)
|
||||
if( m_pent->serialnumber == m_serialnumber )
|
||||
return m_pent;
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
return NULL;
|
||||
};
|
||||
}
|
||||
|
||||
edict_t * EHANDLE::Set( edict_t *pent )
|
||||
{
|
||||
edict_t *EHANDLE::Set( edict_t *pent )
|
||||
{
|
||||
m_pent = pent;
|
||||
if (pent)
|
||||
if( pent )
|
||||
m_serialnumber = m_pent->serialnumber;
|
||||
return pent;
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
EHANDLE :: operator CBaseEntity *()
|
||||
EHANDLE::operator CBaseEntity *()
|
||||
{
|
||||
return (CBaseEntity *)GET_PRIVATE( Get( ) );
|
||||
};
|
||||
return (CBaseEntity *)GET_PRIVATE( Get() );
|
||||
}
|
||||
|
||||
|
||||
CBaseEntity * EHANDLE :: operator = (CBaseEntity *pEntity)
|
||||
CBaseEntity *EHANDLE::operator = ( CBaseEntity *pEntity )
|
||||
{
|
||||
if (pEntity)
|
||||
if( pEntity )
|
||||
{
|
||||
m_pent = ENT( pEntity->pev );
|
||||
if (m_pent)
|
||||
if( m_pent )
|
||||
m_serialnumber = m_pent->serialnumber;
|
||||
}
|
||||
else
|
||||
|
@ -482,30 +468,29 @@ CBaseEntity * EHANDLE :: operator = (CBaseEntity *pEntity)
|
|||
return pEntity;
|
||||
}
|
||||
|
||||
EHANDLE :: operator int ()
|
||||
EHANDLE::operator int ()
|
||||
{
|
||||
return Get() != NULL;
|
||||
}
|
||||
|
||||
CBaseEntity * EHANDLE :: operator -> ()
|
||||
CBaseEntity * EHANDLE::operator -> ()
|
||||
{
|
||||
return (CBaseEntity *)GET_PRIVATE( Get( ) );
|
||||
return (CBaseEntity *)GET_PRIVATE( Get() );
|
||||
}
|
||||
|
||||
|
||||
// give health
|
||||
int CBaseEntity :: TakeHealth( float flHealth, int bitsDamageType )
|
||||
int CBaseEntity::TakeHealth( float flHealth, int bitsDamageType )
|
||||
{
|
||||
if (!pev->takedamage)
|
||||
if( !pev->takedamage )
|
||||
return 0;
|
||||
|
||||
// heal
|
||||
if ( pev->health >= pev->max_health )
|
||||
// heal
|
||||
if( pev->health >= pev->max_health )
|
||||
return 0;
|
||||
|
||||
pev->health += flHealth;
|
||||
|
||||
if (pev->health > pev->max_health)
|
||||
if( pev->health > pev->max_health )
|
||||
pev->health = pev->max_health;
|
||||
|
||||
return 1;
|
||||
|
@ -513,48 +498,47 @@ int CBaseEntity :: TakeHealth( float flHealth, int bitsDamageType )
|
|||
|
||||
// inflict damage on this entity. bitsDamageType indicates type of damage inflicted, ie: DMG_CRUSH
|
||||
|
||||
int CBaseEntity :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType )
|
||||
int CBaseEntity::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
|
||||
{
|
||||
Vector vecTemp;
|
||||
Vector vecTemp;
|
||||
|
||||
if (!pev->takedamage)
|
||||
if( !pev->takedamage )
|
||||
return 0;
|
||||
|
||||
// UNDONE: some entity types may be immune or resistant to some bitsDamageType
|
||||
|
||||
// if Attacker == Inflictor, the attack was a melee or other instant-hit attack.
|
||||
// (that is, no actual entity projectile was involved in the attack so use the shooter's origin).
|
||||
if ( pevAttacker == pevInflictor )
|
||||
if( pevAttacker == pevInflictor )
|
||||
{
|
||||
vecTemp = pevInflictor->origin - ( VecBModelOrigin(pev) );
|
||||
vecTemp = pevInflictor->origin - VecBModelOrigin( pev );
|
||||
}
|
||||
else
|
||||
// an actual missile was involved.
|
||||
{
|
||||
vecTemp = pevInflictor->origin - ( VecBModelOrigin(pev) );
|
||||
vecTemp = pevInflictor->origin - VecBModelOrigin( pev );
|
||||
}
|
||||
|
||||
// this global is still used for glass and other non-monster killables, along with decals.
|
||||
// this global is still used for glass and other non-monster killables, along with decals.
|
||||
g_vecAttackDir = vecTemp.Normalize();
|
||||
|
||||
// save damage based on the target's armor level
|
||||
|
||||
// figure momentum add (don't let hurt brushes or other triggers move player)
|
||||
if ((!FNullEnt(pevInflictor)) && (pev->movetype == MOVETYPE_WALK || pev->movetype == MOVETYPE_STEP) && (pevAttacker->solid != SOLID_TRIGGER) )
|
||||
// save damage based on the target's armor level
|
||||
// figure momentum add (don't let hurt brushes or other triggers move player)
|
||||
if( ( !FNullEnt( pevInflictor ) ) && (pev->movetype == MOVETYPE_WALK || pev->movetype == MOVETYPE_STEP ) && ( pevAttacker->solid != SOLID_TRIGGER ) )
|
||||
{
|
||||
Vector vecDir = pev->origin - (pevInflictor->absmin + pevInflictor->absmax) * 0.5;
|
||||
Vector vecDir = pev->origin - ( pevInflictor->absmin + pevInflictor->absmax ) * 0.5;
|
||||
vecDir = vecDir.Normalize();
|
||||
|
||||
float flForce = flDamage * ((32 * 32 * 72.0) / (pev->size.x * pev->size.y * pev->size.z)) * 5;
|
||||
|
||||
if (flForce > 1000.0)
|
||||
float flForce = flDamage * ( ( 32 * 32 * 72.0 ) / ( pev->size.x * pev->size.y * pev->size.z ) ) * 5;
|
||||
|
||||
if( flForce > 1000.0 )
|
||||
flForce = 1000.0;
|
||||
pev->velocity = pev->velocity + vecDir * flForce;
|
||||
}
|
||||
|
||||
// do the damage
|
||||
// do the damage
|
||||
pev->health -= flDamage;
|
||||
if (pev->health <= 0)
|
||||
if( pev->health <= 0 )
|
||||
{
|
||||
Killed( pevAttacker, GIB_NORMAL );
|
||||
return 0;
|
||||
|
@ -563,28 +547,26 @@ int CBaseEntity :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker,
|
|||
return 1;
|
||||
}
|
||||
|
||||
|
||||
void CBaseEntity :: Killed( entvars_t *pevAttacker, int iGib )
|
||||
void CBaseEntity::Killed( entvars_t *pevAttacker, int iGib )
|
||||
{
|
||||
pev->takedamage = DAMAGE_NO;
|
||||
pev->deadflag = DEAD_DEAD;
|
||||
UTIL_Remove( this );
|
||||
}
|
||||
|
||||
|
||||
CBaseEntity *CBaseEntity::GetNextTarget( void )
|
||||
{
|
||||
if ( FStringNull( pev->target ) )
|
||||
if( FStringNull( pev->target ) )
|
||||
return NULL;
|
||||
edict_t *pTarget = FIND_ENTITY_BY_TARGETNAME ( NULL, STRING(pev->target) );
|
||||
if ( FNullEnt(pTarget) )
|
||||
edict_t *pTarget = FIND_ENTITY_BY_TARGETNAME( NULL, STRING( pev->target ) );
|
||||
if( FNullEnt( pTarget ) )
|
||||
return NULL;
|
||||
|
||||
return Instance( pTarget );
|
||||
}
|
||||
|
||||
// Global Savedata for Delay
|
||||
TYPEDESCRIPTION CBaseEntity::m_SaveData[] =
|
||||
TYPEDESCRIPTION CBaseEntity::m_SaveData[] =
|
||||
{
|
||||
DEFINE_FIELD( CBaseEntity, m_pGoalEnt, FIELD_CLASSPTR ),
|
||||
|
||||
|
@ -594,11 +576,10 @@ TYPEDESCRIPTION CBaseEntity::m_SaveData[] =
|
|||
DEFINE_FIELD( CBaseEntity, m_pfnBlocked, FIELD_FUNCTION ),
|
||||
};
|
||||
|
||||
|
||||
int CBaseEntity::Save( CSave &save )
|
||||
{
|
||||
if ( save.WriteEntVars( "ENTVARS", pev ) )
|
||||
return save.WriteFields( "BASE", this, m_SaveData, ARRAYSIZE(m_SaveData) );
|
||||
if( save.WriteEntVars( "ENTVARS", pev ) )
|
||||
return save.WriteFields( "BASE", this, m_SaveData, ARRAYSIZE( m_SaveData ) );
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -608,48 +589,47 @@ int CBaseEntity::Restore( CRestore &restore )
|
|||
int status;
|
||||
|
||||
status = restore.ReadEntVars( "ENTVARS", pev );
|
||||
if ( status )
|
||||
status = restore.ReadFields( "BASE", this, m_SaveData, ARRAYSIZE(m_SaveData) );
|
||||
if( status )
|
||||
status = restore.ReadFields( "BASE", this, m_SaveData, ARRAYSIZE( m_SaveData ) );
|
||||
|
||||
if ( pev->modelindex != 0 && !FStringNull(pev->model) )
|
||||
if( pev->modelindex != 0 && !FStringNull( pev->model ) )
|
||||
{
|
||||
Vector mins, maxs;
|
||||
mins = pev->mins; // Set model is about to destroy these
|
||||
maxs = pev->maxs;
|
||||
|
||||
|
||||
PRECACHE_MODEL( (char *)STRING(pev->model) );
|
||||
SET_MODEL(ENT(pev), STRING(pev->model));
|
||||
UTIL_SetSize(pev, mins, maxs); // Reset them
|
||||
PRECACHE_MODEL( (char *)STRING( pev->model ) );
|
||||
SET_MODEL( ENT( pev ), STRING( pev->model ) );
|
||||
UTIL_SetSize( pev, mins, maxs ); // Reset them
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
|
||||
// Initialize absmin & absmax to the appropriate box
|
||||
void SetObjectCollisionBox( entvars_t *pev )
|
||||
{
|
||||
if ( (pev->solid == SOLID_BSP) &&
|
||||
(pev->angles.x || pev->angles.y|| pev->angles.z) )
|
||||
{ // expand for rotation
|
||||
float max, v;
|
||||
int i;
|
||||
if( ( pev->solid == SOLID_BSP ) &&
|
||||
( pev->angles.x || pev->angles.y || pev->angles.z ) )
|
||||
{
|
||||
// expand for rotation
|
||||
float max, v;
|
||||
int i;
|
||||
|
||||
max = 0;
|
||||
for (i=0 ; i<3 ; i++)
|
||||
for( i = 0; i < 3; i++ )
|
||||
{
|
||||
v = fabs( ((float *)pev->mins)[i]);
|
||||
if (v > max)
|
||||
v = fabs( ( (float *)pev->mins )[i] );
|
||||
if( v > max )
|
||||
max = v;
|
||||
v = fabs( ((float *)pev->maxs)[i]);
|
||||
if (v > max)
|
||||
v = fabs( ( (float *)pev->maxs )[i] );
|
||||
if( v > max )
|
||||
max = v;
|
||||
}
|
||||
for (i=0 ; i<3 ; i++)
|
||||
for( i = 0; i < 3; i++ )
|
||||
{
|
||||
((float *)pev->absmin)[i] = ((float *)pev->origin)[i] - max;
|
||||
((float *)pev->absmax)[i] = ((float *)pev->origin)[i] + max;
|
||||
( (float *)pev->absmin )[i] = ( (float *)pev->origin )[i] - max;
|
||||
( (float *)pev->absmax )[i] = ( (float *)pev->origin )[i] + max;
|
||||
}
|
||||
}
|
||||
else
|
||||
|
@ -666,26 +646,24 @@ void SetObjectCollisionBox( entvars_t *pev )
|
|||
pev->absmax.z += 1;
|
||||
}
|
||||
|
||||
|
||||
void CBaseEntity::SetObjectCollisionBox( void )
|
||||
{
|
||||
::SetObjectCollisionBox( pev );
|
||||
}
|
||||
|
||||
|
||||
int CBaseEntity :: Intersects( CBaseEntity *pOther )
|
||||
int CBaseEntity::Intersects( CBaseEntity *pOther )
|
||||
{
|
||||
if ( pOther->pev->absmin.x > pev->absmax.x ||
|
||||
pOther->pev->absmin.y > pev->absmax.y ||
|
||||
pOther->pev->absmin.z > pev->absmax.z ||
|
||||
pOther->pev->absmax.x < pev->absmin.x ||
|
||||
pOther->pev->absmax.y < pev->absmin.y ||
|
||||
pOther->pev->absmax.z < pev->absmin.z )
|
||||
return 0;
|
||||
if( pOther->pev->absmin.x > pev->absmax.x ||
|
||||
pOther->pev->absmin.y > pev->absmax.y ||
|
||||
pOther->pev->absmin.z > pev->absmax.z ||
|
||||
pOther->pev->absmax.x < pev->absmin.x ||
|
||||
pOther->pev->absmax.y < pev->absmin.y ||
|
||||
pOther->pev->absmax.z < pev->absmin.z )
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
void CBaseEntity :: MakeDormant( void )
|
||||
void CBaseEntity::MakeDormant( void )
|
||||
{
|
||||
SetBits( pev->flags, FL_DORMANT );
|
||||
|
||||
|
@ -701,64 +679,73 @@ void CBaseEntity :: MakeDormant( void )
|
|||
UTIL_SetOrigin( pev, pev->origin );
|
||||
}
|
||||
|
||||
int CBaseEntity :: IsDormant( void )
|
||||
int CBaseEntity::IsDormant( void )
|
||||
{
|
||||
return FBitSet( pev->flags, FL_DORMANT );
|
||||
}
|
||||
|
||||
BOOL CBaseEntity :: IsInWorld( void )
|
||||
BOOL CBaseEntity::IsInWorld( void )
|
||||
{
|
||||
// position
|
||||
if (pev->origin.x >= 4096) return FALSE;
|
||||
if (pev->origin.y >= 4096) return FALSE;
|
||||
if (pev->origin.z >= 4096) return FALSE;
|
||||
if (pev->origin.x <= -4096) return FALSE;
|
||||
if (pev->origin.y <= -4096) return FALSE;
|
||||
if (pev->origin.z <= -4096) return FALSE;
|
||||
if( pev->origin.x >= 4096 )
|
||||
return FALSE;
|
||||
if( pev->origin.y >= 4096 )
|
||||
return FALSE;
|
||||
if( pev->origin.z >= 4096 )
|
||||
return FALSE;
|
||||
if( pev->origin.x <= -4096 )
|
||||
return FALSE;
|
||||
if( pev->origin.y <= -4096 )
|
||||
return FALSE;
|
||||
if( pev->origin.z <= -4096 )
|
||||
return FALSE;
|
||||
// speed
|
||||
if (pev->velocity.x >= 2000) return FALSE;
|
||||
if (pev->velocity.y >= 2000) return FALSE;
|
||||
if (pev->velocity.z >= 2000) return FALSE;
|
||||
if (pev->velocity.x <= -2000) return FALSE;
|
||||
if (pev->velocity.y <= -2000) return FALSE;
|
||||
if (pev->velocity.z <= -2000) return FALSE;
|
||||
if( pev->velocity.x >= 2000 )
|
||||
return FALSE;
|
||||
if( pev->velocity.y >= 2000 )
|
||||
return FALSE;
|
||||
if( pev->velocity.z >= 2000 )
|
||||
return FALSE;
|
||||
if( pev->velocity.x <= -2000 )
|
||||
return FALSE;
|
||||
if( pev->velocity.y <= -2000 )
|
||||
return FALSE;
|
||||
if( pev->velocity.z <= -2000 )
|
||||
return FALSE;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
int CBaseEntity::ShouldToggle( USE_TYPE useType, BOOL currentState )
|
||||
{
|
||||
if ( useType != USE_TOGGLE && useType != USE_SET )
|
||||
if( useType != USE_TOGGLE && useType != USE_SET )
|
||||
{
|
||||
if ( (currentState && useType == USE_ON) || (!currentState && useType == USE_OFF) )
|
||||
if( ( currentState && useType == USE_ON ) || ( !currentState && useType == USE_OFF ) )
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int CBaseEntity :: DamageDecal( int bitsDamageType )
|
||||
int CBaseEntity::DamageDecal( int bitsDamageType )
|
||||
{
|
||||
if ( pev->rendermode == kRenderTransAlpha )
|
||||
if( pev->rendermode == kRenderTransAlpha )
|
||||
return -1;
|
||||
|
||||
if ( pev->rendermode != kRenderNormal )
|
||||
if( pev->rendermode != kRenderNormal )
|
||||
return DECAL_BPROOF1;
|
||||
|
||||
return DECAL_GUNSHOT1 + RANDOM_LONG(0,4);
|
||||
return DECAL_GUNSHOT1 + RANDOM_LONG( 0, 4 );
|
||||
}
|
||||
|
||||
|
||||
|
||||
// NOTE: szName must be a pointer to constant memory, e.g. "monster_class" because the entity
|
||||
// will keep a pointer to it after this call.
|
||||
CBaseEntity * CBaseEntity::Create( char *szName, const Vector &vecOrigin, const Vector &vecAngles, edict_t *pentOwner )
|
||||
CBaseEntity *CBaseEntity::Create( char *szName, const Vector &vecOrigin, const Vector &vecAngles, edict_t *pentOwner )
|
||||
{
|
||||
edict_t *pent;
|
||||
CBaseEntity *pEntity;
|
||||
|
||||
pent = CREATE_NAMED_ENTITY( MAKE_STRING( szName ));
|
||||
if ( FNullEnt( pent ) )
|
||||
pent = CREATE_NAMED_ENTITY( MAKE_STRING( szName ) );
|
||||
if( FNullEnt( pent ) )
|
||||
{
|
||||
ALERT ( at_console, "NULL Ent in Create!\n" );
|
||||
return NULL;
|
||||
|
@ -770,5 +757,3 @@ CBaseEntity * CBaseEntity::Create( char *szName, const Vector &vecOrigin, const
|
|||
DispatchSpawn( pEntity->edict() );
|
||||
return pEntity;
|
||||
}
|
||||
|
||||
|
||||
|
|
377
dlls/cbase.h
377
dlls/cbase.h
|
@ -30,14 +30,14 @@ CBaseEntity
|
|||
|
||||
// These are caps bits to indicate what an object's capabilities (currently used for save/restore and level transitions)
|
||||
#define FCAP_CUSTOMSAVE 0x00000001
|
||||
#define FCAP_ACROSS_TRANSITION 0x00000002 // should transfer between transitions
|
||||
#define FCAP_ACROSS_TRANSITION 0x00000002 // should transfer between transitions
|
||||
#define FCAP_MUST_SPAWN 0x00000004 // Spawn after restore
|
||||
#define FCAP_DONT_SAVE 0x80000000 // Don't save this
|
||||
#define FCAP_IMPULSE_USE 0x00000008 // can be used by the player
|
||||
#define FCAP_CONTINUOUS_USE 0x00000010 // can be used by the player
|
||||
#define FCAP_ONOFF_USE 0x00000020 // can be used by the player
|
||||
#define FCAP_DIRECTIONAL_USE 0x00000040 // Player sends +/- 1 when using (currently only tracktrains)
|
||||
#define FCAP_MASTER 0x00000080 // Can be used to "master" other entities (like multisource)
|
||||
#define FCAP_DIRECTIONAL_USE 0x00000040 // Player sends +/- 1 when using (currently only tracktrains)
|
||||
#define FCAP_MASTER 0x00000080 // Can be used to "master" other entities (like multisource)
|
||||
|
||||
// UNDONE: This will ignore transition volumes (trigger_transition), but not the PVS!!!
|
||||
#define FCAP_FORCE_TRANSITION 0x00000080 // ALWAYS goes across transitions
|
||||
|
@ -64,37 +64,43 @@ extern void DispatchUse( edict_t *pentUsed, edict_t *pentOther );
|
|||
extern void DispatchThink( edict_t *pent );
|
||||
extern void DispatchBlocked( edict_t *pentBlocked, edict_t *pentOther );
|
||||
extern void DispatchSave( edict_t *pent, SAVERESTOREDATA *pSaveData );
|
||||
extern int DispatchRestore( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity );
|
||||
extern void DispatchObjectCollsionBox( edict_t *pent );
|
||||
extern int DispatchRestore( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity );
|
||||
extern void DispatchObjectCollsionBox( edict_t *pent );
|
||||
extern void SaveWriteFields( SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount );
|
||||
extern void SaveReadFields( SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount );
|
||||
extern void SaveGlobalState( SAVERESTOREDATA *pSaveData );
|
||||
extern void RestoreGlobalState( SAVERESTOREDATA *pSaveData );
|
||||
extern void ResetGlobalState( void );
|
||||
|
||||
typedef enum { USE_OFF = 0, USE_ON = 1, USE_SET = 2, USE_TOGGLE = 3 } USE_TYPE;
|
||||
typedef enum
|
||||
{
|
||||
USE_OFF = 0,
|
||||
USE_ON = 1,
|
||||
USE_SET = 2,
|
||||
USE_TOGGLE = 3
|
||||
} USE_TYPE;
|
||||
|
||||
extern void FireTargets( const char *targetName, CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
|
||||
|
||||
typedef void (CBaseEntity::*BASEPTR)(void);
|
||||
typedef void (CBaseEntity::*ENTITYFUNCPTR)(CBaseEntity *pOther );
|
||||
typedef void (CBaseEntity::*USEPTR)( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
|
||||
typedef void(CBaseEntity::*BASEPTR)( void );
|
||||
typedef void(CBaseEntity::*ENTITYFUNCPTR)( CBaseEntity *pOther );
|
||||
typedef void(CBaseEntity::*USEPTR)( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
|
||||
|
||||
// For CLASSIFY
|
||||
#define CLASS_NONE 0
|
||||
#define CLASS_NONE 0
|
||||
#define CLASS_MACHINE 1
|
||||
#define CLASS_PLAYER 2
|
||||
#define CLASS_HUMAN_PASSIVE 3
|
||||
#define CLASS_HUMAN_MILITARY 4
|
||||
#define CLASS_ALIEN_MILITARY 5
|
||||
#define CLASS_HUMAN_MILITARY 4
|
||||
#define CLASS_ALIEN_MILITARY 5
|
||||
#define CLASS_ALIEN_PASSIVE 6
|
||||
#define CLASS_ALIEN_MONSTER 7
|
||||
#define CLASS_ALIEN_PREY 8
|
||||
#define CLASS_ALIEN_PREDATOR 9
|
||||
#define CLASS_ALIEN_PREDATOR 9
|
||||
#define CLASS_INSECT 10
|
||||
#define CLASS_PLAYER_ALLY 11
|
||||
#define CLASS_PLAYER_BIOWEAPON 12 // hornets and snarks.launched by players
|
||||
#define CLASS_ALIEN_BIOWEAPON 13 // hornets and snarks.launched by the alien menace
|
||||
#define CLASS_PLAYER_BIOWEAPON 12 // hornets and snarks.launched by players
|
||||
#define CLASS_ALIEN_BIOWEAPON 13 // hornets and snarks.launched by the alien menace
|
||||
#define CLASS_BARNACLE 99 // special because no one pays attention to it, and it eats a wide cross-section of creatures.
|
||||
|
||||
class CBaseEntity;
|
||||
|
@ -102,7 +108,6 @@ class CBaseMonster;
|
|||
class CBasePlayerItem;
|
||||
class CSquadMonster;
|
||||
|
||||
|
||||
#define SF_NORESPAWN ( 1 << 30 )// !!!set this bit on guns and stuff that should never respawn.
|
||||
|
||||
//
|
||||
|
@ -112,7 +117,7 @@ class EHANDLE
|
|||
{
|
||||
private:
|
||||
edict_t *m_pent;
|
||||
int m_serialnumber;
|
||||
int m_serialnumber;
|
||||
public:
|
||||
edict_t *Get( void );
|
||||
edict_t *Set( edict_t *pent );
|
||||
|
@ -121,11 +126,10 @@ public:
|
|||
|
||||
operator CBaseEntity *();
|
||||
|
||||
CBaseEntity * operator = (CBaseEntity *pEntity);
|
||||
CBaseEntity * operator ->();
|
||||
CBaseEntity *operator = ( CBaseEntity *pEntity );
|
||||
CBaseEntity *operator ->();
|
||||
};
|
||||
|
||||
|
||||
//
|
||||
// Base Entity. All entity types derive from this
|
||||
//
|
||||
|
@ -137,91 +141,89 @@ public:
|
|||
entvars_t *pev; // Don't need to save/restore this pointer, the engine resets it
|
||||
|
||||
// path corners
|
||||
CBaseEntity *m_pGoalEnt;// path corner we are heading towards
|
||||
CBaseEntity *m_pLink;// used for temporary link-list operations.
|
||||
CBaseEntity *m_pGoalEnt;// path corner we are heading towards
|
||||
CBaseEntity *m_pLink;// used for temporary link-list operations.
|
||||
|
||||
// initialization functions
|
||||
virtual void Spawn( void ) { return; }
|
||||
virtual void Precache( void ) { return; }
|
||||
virtual void KeyValue( KeyValueData* pkvd) { pkvd->fHandled = FALSE; }
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
virtual int ObjectCaps( void ) { return FCAP_ACROSS_TRANSITION; }
|
||||
virtual void Activate( void ) {}
|
||||
|
||||
virtual void Spawn( void ) { return; }
|
||||
virtual void Precache( void ) { return; }
|
||||
virtual void KeyValue( KeyValueData* pkvd ) { pkvd->fHandled = FALSE; }
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
virtual int ObjectCaps( void ) { return FCAP_ACROSS_TRANSITION; }
|
||||
virtual void Activate( void ) {}
|
||||
|
||||
// Setup the object->object collision box (pev->mins / pev->maxs is the object->world collision box)
|
||||
virtual void SetObjectCollisionBox( void );
|
||||
virtual void SetObjectCollisionBox( void );
|
||||
|
||||
// Classify - returns the type of group (i.e, "houndeye", or "human military" so that monsters with different classnames
|
||||
// still realize that they are teammates. (overridden for monsters that form groups)
|
||||
virtual int Classify ( void ) { return CLASS_NONE; };
|
||||
virtual void DeathNotice ( entvars_t *pevChild ) {}// monster maker children use this to tell the monster maker that they have died.
|
||||
// Classify - returns the type of group (i.e, "houndeye", or "human military" so that monsters with different classnames
|
||||
// still realize that they are teammates. (overridden for monsters that form groups)
|
||||
virtual int Classify( void ) { return CLASS_NONE; };
|
||||
virtual void DeathNotice( entvars_t *pevChild ) {}// monster maker children use this to tell the monster maker that they have died.
|
||||
|
||||
static TYPEDESCRIPTION m_SaveData[];
|
||||
|
||||
static TYPEDESCRIPTION m_SaveData[];
|
||||
|
||||
virtual void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
|
||||
virtual int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType );
|
||||
virtual int TakeHealth( float flHealth, int bitsDamageType );
|
||||
virtual void Killed( entvars_t *pevAttacker, int iGib );
|
||||
virtual int BloodColor( void ) { return DONT_BLEED; }
|
||||
virtual void TraceBleed( float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType );
|
||||
virtual BOOL IsTriggered( CBaseEntity *pActivator ) {return TRUE;}
|
||||
virtual CBaseMonster *MyMonsterPointer( void ) { return NULL;}
|
||||
virtual CSquadMonster *MySquadMonsterPointer( void ) { return NULL;}
|
||||
virtual int GetToggleState( void ) { return TS_AT_TOP; }
|
||||
virtual void AddPoints( int score, BOOL bAllowNegativeScore ) {}
|
||||
virtual void AddPointsToTeam( int score, BOOL bAllowNegativeScore ) {}
|
||||
virtual BOOL AddPlayerItem( CBasePlayerItem *pItem ) { return 0; }
|
||||
virtual BOOL RemovePlayerItem( CBasePlayerItem *pItem ) { return 0; }
|
||||
virtual int GiveAmmo( int iAmount, char *szName, int iMax ) { return -1; };
|
||||
virtual float GetDelay( void ) { return 0; }
|
||||
virtual int IsMoving( void ) { return pev->velocity != g_vecZero; }
|
||||
virtual void OverrideReset( void ) {}
|
||||
virtual int DamageDecal( int bitsDamageType );
|
||||
virtual void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
|
||||
virtual int TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
|
||||
virtual int TakeHealth( float flHealth, int bitsDamageType );
|
||||
virtual void Killed( entvars_t *pevAttacker, int iGib );
|
||||
virtual int BloodColor( void ) { return DONT_BLEED; }
|
||||
virtual void TraceBleed( float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType );
|
||||
virtual BOOL IsTriggered( CBaseEntity *pActivator ) {return TRUE; }
|
||||
virtual CBaseMonster *MyMonsterPointer( void ) { return NULL; }
|
||||
virtual CSquadMonster *MySquadMonsterPointer( void ) { return NULL; }
|
||||
virtual int GetToggleState( void ) { return TS_AT_TOP; }
|
||||
virtual void AddPoints( int score, BOOL bAllowNegativeScore ) {}
|
||||
virtual void AddPointsToTeam( int score, BOOL bAllowNegativeScore ) {}
|
||||
virtual BOOL AddPlayerItem( CBasePlayerItem *pItem ) { return 0; }
|
||||
virtual BOOL RemovePlayerItem( CBasePlayerItem *pItem ) { return 0; }
|
||||
virtual int GiveAmmo( int iAmount, char *szName, int iMax ) { return -1; };
|
||||
virtual float GetDelay( void ) { return 0; }
|
||||
virtual int IsMoving( void ) { return pev->velocity != g_vecZero; }
|
||||
virtual void OverrideReset( void ) {}
|
||||
virtual int DamageDecal( int bitsDamageType );
|
||||
// This is ONLY used by the node graph to test movement through a door
|
||||
virtual void SetToggleState( int state ) {}
|
||||
virtual void StartSneaking( void ) {}
|
||||
virtual void StopSneaking( void ) {}
|
||||
virtual BOOL OnControls( entvars_t *pev ) { return FALSE; }
|
||||
virtual BOOL IsSneaking( void ) { return FALSE; }
|
||||
virtual BOOL IsAlive( void ) { return (pev->deadflag == DEAD_NO) && pev->health > 0; }
|
||||
virtual BOOL IsBSPModel( void ) { return pev->solid == SOLID_BSP || pev->movetype == MOVETYPE_PUSHSTEP; }
|
||||
virtual BOOL ReflectGauss( void ) { return ( IsBSPModel() && !pev->takedamage ); }
|
||||
virtual BOOL HasTarget( string_t targetname ) { return FStrEq(STRING(targetname), STRING(pev->targetname) ); }
|
||||
virtual BOOL IsInWorld( void );
|
||||
virtual BOOL IsPlayer( void ) { return FALSE; }
|
||||
virtual BOOL IsNetClient( void ) { return FALSE; }
|
||||
virtual void SetToggleState( int state ) {}
|
||||
virtual void StartSneaking( void ) {}
|
||||
virtual void StopSneaking( void ) {}
|
||||
virtual BOOL OnControls( entvars_t *pev ) { return FALSE; }
|
||||
virtual BOOL IsSneaking( void ) { return FALSE; }
|
||||
virtual BOOL IsAlive( void ) { return (pev->deadflag == DEAD_NO) && pev->health > 0; }
|
||||
virtual BOOL IsBSPModel( void ) { return pev->solid == SOLID_BSP || pev->movetype == MOVETYPE_PUSHSTEP; }
|
||||
virtual BOOL ReflectGauss( void ) { return ( IsBSPModel() && !pev->takedamage ); }
|
||||
virtual BOOL HasTarget( string_t targetname ) { return FStrEq(STRING(targetname), STRING(pev->targetname) ); }
|
||||
virtual BOOL IsInWorld( void );
|
||||
virtual BOOL IsPlayer( void ) { return FALSE; }
|
||||
virtual BOOL IsNetClient( void ) { return FALSE; }
|
||||
virtual const char *TeamID( void ) { return ""; }
|
||||
|
||||
|
||||
// virtual void SetActivator( CBaseEntity *pActivator ) {}
|
||||
//virtual void SetActivator( CBaseEntity *pActivator ) {}
|
||||
virtual CBaseEntity *GetNextTarget( void );
|
||||
|
||||
// fundamental callbacks
|
||||
void (CBaseEntity ::*m_pfnThink)(void);
|
||||
void (CBaseEntity ::*m_pfnTouch)( CBaseEntity *pOther );
|
||||
void (CBaseEntity ::*m_pfnUse)( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
|
||||
void (CBaseEntity ::*m_pfnBlocked)( CBaseEntity *pOther );
|
||||
void ( CBaseEntity ::*m_pfnThink )( void);
|
||||
void ( CBaseEntity ::*m_pfnTouch )( CBaseEntity *pOther );
|
||||
void ( CBaseEntity ::*m_pfnUse )( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
|
||||
void ( CBaseEntity ::*m_pfnBlocked )( CBaseEntity *pOther );
|
||||
|
||||
virtual void Think( void ) { if (m_pfnThink) (this->*m_pfnThink)(); };
|
||||
virtual void Touch( CBaseEntity *pOther ) { if (m_pfnTouch) (this->*m_pfnTouch)( pOther ); };
|
||||
virtual void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
|
||||
virtual void Think( void ) { if( m_pfnThink ) ( this->*m_pfnThink )(); }
|
||||
virtual void Touch( CBaseEntity *pOther ) { if( m_pfnTouch ) (this->*m_pfnTouch)( pOther ); }
|
||||
virtual void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
|
||||
{
|
||||
if (m_pfnUse)
|
||||
(this->*m_pfnUse)( pActivator, pCaller, useType, value );
|
||||
if( m_pfnUse )
|
||||
( this->*m_pfnUse )( pActivator, pCaller, useType, value );
|
||||
}
|
||||
virtual void Blocked( CBaseEntity *pOther ) { if (m_pfnBlocked) (this->*m_pfnBlocked)( pOther ); };
|
||||
virtual void Blocked( CBaseEntity *pOther ) { if( m_pfnBlocked ) ( this->*m_pfnBlocked )( pOther ); };
|
||||
|
||||
// allow engine to allocate instance data
|
||||
void *operator new( size_t stAllocateBlock, entvars_t *pev )
|
||||
void *operator new( size_t stAllocateBlock, entvars_t *pev )
|
||||
{
|
||||
return (void *)ALLOC_PRIVATE(ENT(pev), stAllocateBlock);
|
||||
return (void *)ALLOC_PRIVATE( ENT( pev ), stAllocateBlock );
|
||||
};
|
||||
|
||||
// don't use this.
|
||||
#if _MSC_VER >= 1200 // only build this code if MSVC++ 6.0 or higher
|
||||
void operator delete(void *pMem, entvars_t *pev)
|
||||
void operator delete( void *pMem, entvars_t *pev )
|
||||
{
|
||||
pev->flags |= FL_KILLME;
|
||||
};
|
||||
|
@ -233,26 +235,26 @@ public:
|
|||
void EXPORT SUB_Remove( void );
|
||||
void EXPORT SUB_DoNothing( void );
|
||||
void EXPORT SUB_StartFadeOut ( void );
|
||||
void EXPORT SUB_FadeOut ( void );
|
||||
void EXPORT SUB_FadeOut( void );
|
||||
void EXPORT SUB_CallUseToggle( void ) { this->Use( this, this, USE_TOGGLE, 0 ); }
|
||||
int ShouldToggle( USE_TYPE useType, BOOL currentState );
|
||||
void FireBullets( ULONG cShots, Vector vecSrc, Vector vecDirShooting, Vector vecSpread, float flDistance, int iBulletType, int iTracerFreq = 4, int iDamage = 0, entvars_t *pevAttacker = NULL );
|
||||
Vector FireBulletsPlayer( ULONG cShots, Vector vecSrc, Vector vecDirShooting, Vector vecSpread, float flDistance, int iBulletType, int iTracerFreq = 4, int iDamage = 0, entvars_t *pevAttacker = NULL, int shared_rand = 0 );
|
||||
int ShouldToggle( USE_TYPE useType, BOOL currentState );
|
||||
void FireBullets( ULONG cShots, Vector vecSrc, Vector vecDirShooting, Vector vecSpread, float flDistance, int iBulletType, int iTracerFreq = 4, int iDamage = 0, entvars_t *pevAttacker = NULL );
|
||||
Vector FireBulletsPlayer( ULONG cShots, Vector vecSrc, Vector vecDirShooting, Vector vecSpread, float flDistance, int iBulletType, int iTracerFreq = 4, int iDamage = 0, entvars_t *pevAttacker = NULL, int shared_rand = 0 );
|
||||
|
||||
virtual CBaseEntity *Respawn( void ) { return NULL; }
|
||||
|
||||
void SUB_UseTargets( CBaseEntity *pActivator, USE_TYPE useType, float value );
|
||||
// Do the bounding boxes of these two intersect?
|
||||
int Intersects( CBaseEntity *pOther );
|
||||
void MakeDormant( void );
|
||||
int IsDormant( void );
|
||||
BOOL IsLockedByMaster( void ) { return FALSE; }
|
||||
int Intersects( CBaseEntity *pOther );
|
||||
void MakeDormant( void );
|
||||
int IsDormant( void );
|
||||
BOOL IsLockedByMaster( void ) { return FALSE; }
|
||||
|
||||
static CBaseEntity *Instance( edict_t *pent )
|
||||
{
|
||||
if ( !pent )
|
||||
pent = ENT(0);
|
||||
CBaseEntity *pEnt = (CBaseEntity *)GET_PRIVATE(pent);
|
||||
{
|
||||
if( !pent )
|
||||
pent = ENT( 0 );
|
||||
CBaseEntity *pEnt = (CBaseEntity *)GET_PRIVATE( pent );
|
||||
return pEnt;
|
||||
}
|
||||
|
||||
|
@ -262,78 +264,72 @@ public:
|
|||
CBaseMonster *GetMonsterPointer( entvars_t *pevMonster )
|
||||
{
|
||||
CBaseEntity *pEntity = Instance( pevMonster );
|
||||
if ( pEntity )
|
||||
if( pEntity )
|
||||
return pEntity->MyMonsterPointer();
|
||||
return NULL;
|
||||
}
|
||||
CBaseMonster *GetMonsterPointer( edict_t *pentMonster )
|
||||
{
|
||||
CBaseEntity *pEntity = Instance( pentMonster );
|
||||
if ( pEntity )
|
||||
if( pEntity )
|
||||
return pEntity->MyMonsterPointer();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
// Ugly code to lookup all functions to make sure they are exported when set.
|
||||
#ifdef _DEBUG
|
||||
void FunctionCheck( void *pFunction, char *name )
|
||||
{
|
||||
if (pFunction && !NAME_FOR_FUNCTION((unsigned long)(pFunction)) )
|
||||
ALERT( at_error, "No EXPORT: %s:%s (%08lx)\n", STRING(pev->classname), name, (unsigned long)pFunction );
|
||||
if( pFunction && !NAME_FOR_FUNCTION( (unsigned long)( pFunction ) ) )
|
||||
ALERT( at_error, "No EXPORT: %s:%s (%08lx)\n", STRING( pev->classname ), name, (unsigned long)pFunction );
|
||||
}
|
||||
|
||||
BASEPTR ThinkSet( BASEPTR func, char *name )
|
||||
{
|
||||
m_pfnThink = func;
|
||||
FunctionCheck( (void *)*((int *)((char *)this + ( offsetof(CBaseEntity,m_pfnThink)))), name );
|
||||
FunctionCheck( (void *)*( (int *)( (char *)this + ( offsetof( CBaseEntity, m_pfnThink ) ) ) ), name );
|
||||
return func;
|
||||
}
|
||||
ENTITYFUNCPTR TouchSet( ENTITYFUNCPTR func, char *name )
|
||||
{
|
||||
{
|
||||
m_pfnTouch = func;
|
||||
FunctionCheck( (void *)*((int *)((char *)this + ( offsetof(CBaseEntity,m_pfnTouch)))), name );
|
||||
FunctionCheck( (void *)*( (int *)( (char *)this + ( offsetof( CBaseEntity, m_pfnTouch ) ) ) ), name );
|
||||
return func;
|
||||
}
|
||||
USEPTR UseSet( USEPTR func, char *name )
|
||||
USEPTR UseSet( USEPTR func, char *name )
|
||||
{
|
||||
m_pfnUse = func;
|
||||
FunctionCheck( (void *)*((int *)((char *)this + ( offsetof(CBaseEntity,m_pfnUse)))), name );
|
||||
FunctionCheck( (void *)*( (int *)( (char *)this + ( offsetof( CBaseEntity, m_pfnUse ) ) ) ), name );
|
||||
return func;
|
||||
}
|
||||
ENTITYFUNCPTR BlockedSet( ENTITYFUNCPTR func, char *name )
|
||||
ENTITYFUNCPTR BlockedSet( ENTITYFUNCPTR func, char *name )
|
||||
{
|
||||
m_pfnBlocked = func;
|
||||
FunctionCheck( (void *)*((int *)((char *)this + ( offsetof(CBaseEntity,m_pfnBlocked)))), name );
|
||||
FunctionCheck( (void *)*( (int *)( (char *)this + ( offsetof( CBaseEntity, m_pfnBlocked ) ) ) ), name );
|
||||
return func;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
// virtual functions used by a few classes
|
||||
|
||||
// used by monsters that are created by the MonsterMaker
|
||||
virtual void UpdateOwner( void ) { return; };
|
||||
|
||||
|
||||
//
|
||||
static CBaseEntity *Create( char *szName, const Vector &vecOrigin, const Vector &vecAngles, edict_t *pentOwner = NULL );
|
||||
|
||||
virtual BOOL FBecomeProne( void ) {return FALSE;};
|
||||
edict_t *edict() { return ENT( pev ); };
|
||||
EOFFSET eoffset( ) { return OFFSET( pev ); };
|
||||
int entindex( ) { return ENTINDEX( edict() ); };
|
||||
EOFFSET eoffset() { return OFFSET( pev ); };
|
||||
int entindex() { return ENTINDEX( edict() ); };
|
||||
|
||||
virtual Vector Center( ) { return (pev->absmax + pev->absmin) * 0.5; }; // center point of entity
|
||||
virtual Vector EyePosition( ) { return pev->origin + pev->view_ofs; }; // position of eyes
|
||||
virtual Vector EarPosition( ) { return pev->origin + pev->view_ofs; }; // position of ears
|
||||
virtual Vector BodyTarget( const Vector &posSrc ) { return Center( ); }; // position to shoot at
|
||||
virtual Vector Center() { return ( pev->absmax + pev->absmin ) * 0.5; }; // center point of entity
|
||||
virtual Vector EyePosition() { return pev->origin + pev->view_ofs; }; // position of eyes
|
||||
virtual Vector EarPosition() { return pev->origin + pev->view_ofs; }; // position of ears
|
||||
virtual Vector BodyTarget( const Vector &posSrc ) { return Center(); }; // position to shoot at
|
||||
|
||||
virtual int Illumination( ) { return GETENTITYILLUM( ENT( pev ) ); };
|
||||
virtual int Illumination() { return GETENTITYILLUM( ENT( pev ) ); };
|
||||
|
||||
virtual BOOL FVisible ( CBaseEntity *pEntity );
|
||||
virtual BOOL FVisible ( const Vector &vecOrigin );
|
||||
virtual BOOL FVisible( CBaseEntity *pEntity );
|
||||
virtual BOOL FVisible( const Vector &vecOrigin );
|
||||
|
||||
//We use this variables to store each ammo count.
|
||||
int ammo_9mm;
|
||||
|
@ -354,8 +350,6 @@ public:
|
|||
int m_fireState;
|
||||
};
|
||||
|
||||
|
||||
|
||||
// Ugly technique to override base member functions
|
||||
// Normally it's illegal to cast a pointer to a member function of a derived class to a pointer to a
|
||||
// member function of a base class. static_cast is a sleezy way around that problem.
|
||||
|
@ -378,19 +372,16 @@ public:
|
|||
#define ResetUse( ) m_pfnUse = static_cast <void (CBaseEntity::*)( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )> (NULL)
|
||||
#define ResetBlocked( ) m_pfnBlocked = static_cast <void (CBaseEntity::*)(CBaseEntity *)> (NULL)
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
class CPointEntity : public CBaseEntity
|
||||
{
|
||||
public:
|
||||
void Spawn( void );
|
||||
virtual int ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
|
||||
void Spawn( void );
|
||||
virtual int ObjectCaps( void ) { return CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
|
||||
private:
|
||||
};
|
||||
|
||||
|
||||
typedef struct locksounds // sounds that doors and buttons make when locked/unlocked
|
||||
{
|
||||
string_t sLockedSound; // sound a door makes when it's locked
|
||||
|
@ -407,34 +398,34 @@ typedef struct locksounds // sounds that doors and buttons make when locked/un
|
|||
BYTE bEOFUnlocked; // true if hit end of list of unlocked sentences
|
||||
} locksound_t;
|
||||
|
||||
void PlayLockSounds(entvars_t *pev, locksound_t *pls, int flocked, int fbutton);
|
||||
void PlayLockSounds( entvars_t *pev, locksound_t *pls, int flocked, int fbutton );
|
||||
|
||||
//
|
||||
// MultiSouce
|
||||
//
|
||||
|
||||
#define MAX_MULTI_TARGETS 16 // maximum number of targets a single multi_manager entity may be assigned.
|
||||
#define MS_MAX_TARGETS 32
|
||||
#define MS_MAX_TARGETS 32
|
||||
|
||||
class CMultiSource : public CPointEntity
|
||||
{
|
||||
public:
|
||||
void Spawn( );
|
||||
void Spawn();
|
||||
void KeyValue( KeyValueData *pkvd );
|
||||
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
|
||||
int ObjectCaps( void ) { return (CPointEntity::ObjectCaps() | FCAP_MASTER); }
|
||||
int ObjectCaps( void ) { return ( CPointEntity::ObjectCaps() | FCAP_MASTER ); }
|
||||
BOOL IsTriggered( CBaseEntity *pActivator );
|
||||
void EXPORT Register( void );
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
|
||||
static TYPEDESCRIPTION m_SaveData[];
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
static TYPEDESCRIPTION m_SaveData[];
|
||||
|
||||
EHANDLE m_rgEntities[MS_MAX_TARGETS];
|
||||
int m_rgTriggered[MS_MAX_TARGETS];
|
||||
EHANDLE m_rgEntities[MS_MAX_TARGETS];
|
||||
int m_rgTriggered[MS_MAX_TARGETS];
|
||||
|
||||
int m_iTotal;
|
||||
string_t m_globalstate;
|
||||
int m_iTotal;
|
||||
string_t m_globalstate;
|
||||
};
|
||||
|
||||
|
||||
|
@ -444,58 +435,54 @@ public:
|
|||
class CBaseDelay : public CBaseEntity
|
||||
{
|
||||
public:
|
||||
float m_flDelay;
|
||||
int m_iszKillTarget;
|
||||
float m_flDelay;
|
||||
int m_iszKillTarget;
|
||||
|
||||
virtual void KeyValue( KeyValueData* pkvd);
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
|
||||
static TYPEDESCRIPTION m_SaveData[];
|
||||
virtual void KeyValue( KeyValueData *pkvd );
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
static TYPEDESCRIPTION m_SaveData[];
|
||||
// common member functions
|
||||
void SUB_UseTargets( CBaseEntity *pActivator, USE_TYPE useType, float value );
|
||||
void EXPORT DelayThink( void );
|
||||
};
|
||||
|
||||
|
||||
class CBaseAnimating : public CBaseDelay
|
||||
{
|
||||
public:
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
|
||||
static TYPEDESCRIPTION m_SaveData[];
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
static TYPEDESCRIPTION m_SaveData[];
|
||||
|
||||
// Basic Monster Animation functions
|
||||
float StudioFrameAdvance( float flInterval = 0.0 ); // accumulate animation frame time from last time called until now
|
||||
int GetSequenceFlags( void );
|
||||
int LookupActivity ( int activity );
|
||||
int LookupActivityHeaviest ( int activity );
|
||||
int LookupSequence ( const char *label );
|
||||
void ResetSequenceInfo ( );
|
||||
void DispatchAnimEvents ( float flFutureInterval = 0.1 ); // Handle events that have happend since last time called up until X seconds into the future
|
||||
int GetSequenceFlags( void );
|
||||
int LookupActivity( int activity );
|
||||
int LookupActivityHeaviest( int activity );
|
||||
int LookupSequence( const char *label );
|
||||
void ResetSequenceInfo();
|
||||
void DispatchAnimEvents( float flFutureInterval = 0.1 ); // Handle events that have happend since last time called up until X seconds into the future
|
||||
virtual void HandleAnimEvent( MonsterEvent_t *pEvent ) { return; };
|
||||
float SetBoneController ( int iController, float flValue );
|
||||
void InitBoneControllers ( void );
|
||||
float SetBlending ( int iBlender, float flValue );
|
||||
void GetBonePosition ( int iBone, Vector &origin, Vector &angles );
|
||||
float SetBoneController( int iController, float flValue );
|
||||
void InitBoneControllers( void );
|
||||
float SetBlending( int iBlender, float flValue );
|
||||
void GetBonePosition( int iBone, Vector &origin, Vector &angles );
|
||||
void GetAutomovement( Vector &origin, Vector &angles, float flInterval = 0.1 );
|
||||
int FindTransition( int iEndingSequence, int iGoalSequence, int *piDir );
|
||||
void GetAttachment ( int iAttachment, Vector &origin, Vector &angles );
|
||||
int FindTransition( int iEndingSequence, int iGoalSequence, int *piDir );
|
||||
void GetAttachment( int iAttachment, Vector &origin, Vector &angles );
|
||||
void SetBodygroup( int iGroup, int iValue );
|
||||
int GetBodygroup( int iGroup );
|
||||
int ExtractBbox( int sequence, float *mins, float *maxs );
|
||||
void SetSequenceBox( void );
|
||||
|
||||
// animation needs
|
||||
float m_flFrameRate; // computed FPS for current sequence
|
||||
float m_flGroundSpeed; // computed linear movement rate for current sequence
|
||||
float m_flLastEventCheck; // last time the event list was checked
|
||||
BOOL m_fSequenceFinished;// flag set when StudioAdvanceFrame moves across a frame boundry
|
||||
BOOL m_fSequenceLoops; // true if the sequence loops
|
||||
float m_flFrameRate; // computed FPS for current sequence
|
||||
float m_flGroundSpeed; // computed linear movement rate for current sequence
|
||||
float m_flLastEventCheck; // last time the event list was checked
|
||||
BOOL m_fSequenceFinished;// flag set when StudioAdvanceFrame moves across a frame boundry
|
||||
BOOL m_fSequenceLoops; // true if the sequence loops
|
||||
};
|
||||
|
||||
|
||||
//
|
||||
// generic Toggle entity.
|
||||
//
|
||||
|
@ -671,7 +658,6 @@ class CSound;
|
|||
|
||||
char *ButtonSound( int sound ); // get string of button sound number
|
||||
|
||||
|
||||
//
|
||||
// Generic Button
|
||||
//
|
||||
|
@ -683,29 +669,29 @@ public:
|
|||
void RotSpawn( void );
|
||||
virtual void KeyValue( KeyValueData* pkvd);
|
||||
|
||||
void ButtonActivate( );
|
||||
void ButtonActivate();
|
||||
void SparkSoundCache( void );
|
||||
|
||||
void EXPORT ButtonShot( void );
|
||||
void EXPORT ButtonTouch( CBaseEntity *pOther );
|
||||
void EXPORT ButtonSpark ( void );
|
||||
void EXPORT ButtonSpark( void );
|
||||
void EXPORT TriggerAndWait( void );
|
||||
void EXPORT ButtonReturn( void );
|
||||
void EXPORT ButtonBackHome( void );
|
||||
void EXPORT ButtonUse ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
|
||||
virtual int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType );
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
void EXPORT ButtonUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
|
||||
virtual int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType );
|
||||
virtual int Save( CSave &save );
|
||||
virtual int Restore( CRestore &restore );
|
||||
|
||||
enum BUTTON_CODE { BUTTON_NOTHING, BUTTON_ACTIVATE, BUTTON_RETURN };
|
||||
BUTTON_CODE ButtonResponseToTouch( void );
|
||||
BUTTON_CODE ButtonResponseToTouch( void );
|
||||
|
||||
static TYPEDESCRIPTION m_SaveData[];
|
||||
// Buttons that don't take damage can be IMPULSE used
|
||||
virtual int ObjectCaps( void ) { return (CBaseToggle:: ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | (pev->takedamage?0:FCAP_IMPULSE_USE); }
|
||||
virtual int ObjectCaps( void ) { return (CBaseToggle:: ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | (pev->takedamage?0:FCAP_IMPULSE_USE); }
|
||||
|
||||
BOOL m_fStayPushed; // button stays pushed in until touched again?
|
||||
BOOL m_fRotating; // a rotating button? default is a sliding button.
|
||||
BOOL m_fStayPushed; // button stays pushed in until touched again?
|
||||
BOOL m_fRotating; // a rotating button? default is a sliding button.
|
||||
|
||||
string_t m_strChangeTarget; // if this field is not null, this is an index into the engine string array.
|
||||
// when this button is touched, it's target entity's TARGET field will be set
|
||||
|
@ -713,17 +699,16 @@ public:
|
|||
|
||||
locksound_t m_ls; // door lock sounds
|
||||
|
||||
BYTE m_bLockedSound; // ordinals from entity selection
|
||||
BYTE m_bLockedSentence;
|
||||
BYTE m_bUnlockedSound;
|
||||
BYTE m_bUnlockedSentence;
|
||||
int m_sounds;
|
||||
BYTE m_bLockedSound; // ordinals from entity selection
|
||||
BYTE m_bLockedSentence;
|
||||
BYTE m_bUnlockedSound;
|
||||
BYTE m_bUnlockedSentence;
|
||||
int m_sounds;
|
||||
};
|
||||
|
||||
//
|
||||
// Weapons
|
||||
//
|
||||
|
||||
#define BAD_WEAPON 0x00007FFF
|
||||
|
||||
//
|
||||
|
@ -735,22 +720,21 @@ template <class T> T * GetClassPtr( T *a )
|
|||
entvars_t *pev = (entvars_t *)a;
|
||||
|
||||
// allocate entity if necessary
|
||||
if (pev == NULL)
|
||||
pev = VARS(CREATE_ENTITY());
|
||||
if( pev == NULL )
|
||||
pev = VARS( CREATE_ENTITY() );
|
||||
|
||||
// get the private data
|
||||
a = (T *)GET_PRIVATE(ENT(pev));
|
||||
a = (T *)GET_PRIVATE( ENT( pev ) );
|
||||
|
||||
if (a == NULL)
|
||||
if( a == NULL )
|
||||
{
|
||||
// allocate private data
|
||||
a = new(pev) T;
|
||||
a = new( pev ) T;
|
||||
a->pev = pev;
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
bit_PUSHBRUSH_DATA | bit_TOGGLE_DATA
|
||||
bit_MONSTER_DATA
|
||||
|
@ -778,13 +762,12 @@ push_trigger_data
|
|||
|
||||
typedef struct _SelAmmo
|
||||
{
|
||||
BYTE Ammo1Type;
|
||||
BYTE Ammo1;
|
||||
BYTE Ammo2Type;
|
||||
BYTE Ammo2;
|
||||
BYTE Ammo1Type;
|
||||
BYTE Ammo1;
|
||||
BYTE Ammo2Type;
|
||||
BYTE Ammo2;
|
||||
} SelAmmo;
|
||||
|
||||
|
||||
// this moved here from world.cpp, to allow classes to be derived from it
|
||||
//=======================
|
||||
// CWorld
|
||||
|
|
|
@ -29,11 +29,11 @@
|
|||
|
||||
#define HIDEHUD_WEAPONS ( 1<<0 )
|
||||
#define HIDEHUD_FLASHLIGHT ( 1<<1 )
|
||||
#define HIDEHUD_ALL ( 1<<2 )
|
||||
#define HIDEHUD_HEALTH ( 1<<3 )
|
||||
#define HIDEHUD_ALL ( 1<<2 )
|
||||
#define HIDEHUD_HEALTH ( 1<<3 )
|
||||
|
||||
#define MAX_AMMO_TYPES 32 // ???
|
||||
#define MAX_AMMO_SLOTS 32 // not really slots
|
||||
#define MAX_AMMO_TYPES 32 // ???
|
||||
#define MAX_AMMO_SLOTS 32 // not really slots
|
||||
|
||||
#define HUD_PRINTNOTIFY 1
|
||||
#define HUD_PRINTCONSOLE 2
|
||||
|
@ -41,6 +41,5 @@
|
|||
#define HUD_PRINTCENTER 4
|
||||
|
||||
|
||||
#define WEAPON_SUIT 31
|
||||
|
||||
#endif
|
||||
#define WEAPON_SUIT 31
|
||||
#endif
|
||||
|
|
990
dlls/client.cpp
990
dlls/client.cpp
File diff suppressed because it is too large
Load Diff
|
@ -15,7 +15,7 @@
|
|||
#ifndef CLIENT_H
|
||||
#define CLIENT_H
|
||||
|
||||
extern void respawn( entvars_t* pev, BOOL fCopyCorpse );
|
||||
extern void respawn( entvars_t *pev, BOOL fCopyCorpse );
|
||||
extern BOOL ClientConnect( edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ] );
|
||||
extern void ClientDisconnect( edict_t *pEntity );
|
||||
extern void ClientKill( edict_t *pEntity );
|
||||
|
@ -35,31 +35,30 @@ extern void ClientPrecache( void );
|
|||
extern const char *GetGameDescription( void );
|
||||
extern void PlayerCustomization( edict_t *pEntity, customization_t *pCust );
|
||||
|
||||
extern void SpectatorConnect ( edict_t *pEntity );
|
||||
extern void SpectatorDisconnect ( edict_t *pEntity );
|
||||
extern void SpectatorThink ( edict_t *pEntity );
|
||||
extern void SpectatorConnect( edict_t *pEntity );
|
||||
extern void SpectatorDisconnect( edict_t *pEntity );
|
||||
extern void SpectatorThink( edict_t *pEntity );
|
||||
|
||||
extern void Sys_Error( const char *error_string );
|
||||
|
||||
extern void SetupVisibility( edict_t *pViewEntity, edict_t *pClient, unsigned char **pvs, unsigned char **pas );
|
||||
extern void UpdateClientData ( const struct edict_s *ent, int sendweapons, struct clientdata_s *cd );
|
||||
extern void UpdateClientData( const struct edict_s *ent, int sendweapons, struct clientdata_s *cd );
|
||||
extern int AddToFullPack( struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet );
|
||||
extern void CreateBaseline( int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, vec3_t player_mins, vec3_t player_maxs );
|
||||
extern void RegisterEncoders( void );
|
||||
|
||||
extern int GetWeaponData( struct edict_s *player, struct weapon_data_s *info );
|
||||
|
||||
extern void CmdStart( const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed );
|
||||
extern void CmdEnd ( const edict_t *player );
|
||||
extern void CmdStart( const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed );
|
||||
extern void CmdEnd ( const edict_t *player );
|
||||
|
||||
extern int ConnectionlessPacket( const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size );
|
||||
extern int ConnectionlessPacket( const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size );
|
||||
|
||||
extern int GetHullBounds( int hullnumber, float *mins, float *maxs );
|
||||
|
||||
extern void CreateInstancedBaselines ( void );
|
||||
extern void CreateInstancedBaselines( void );
|
||||
|
||||
extern int InconsistentFile( const edict_t *player, const char *filename, char *disconnect_message );
|
||||
extern int InconsistentFile( const edict_t *player, const char *filename, char *disconnect_message );
|
||||
|
||||
extern int AllowLagCompensation( void );
|
||||
|
||||
#endif // CLIENT_H
|
||||
#endif // CLIENT_H
|
||||
|
|
778
dlls/combat.cpp
778
dlls/combat.cpp
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -36,7 +36,7 @@ class CCrossbowBolt : public CBaseEntity
|
|||
{
|
||||
void Spawn( void );
|
||||
void Precache( void );
|
||||
int Classify ( void );
|
||||
int Classify( void );
|
||||
void EXPORT BubbleThink( void );
|
||||
void EXPORT BoltTouch( CBaseEntity *pOther );
|
||||
void EXPORT ExplodeThink( void );
|
||||
|
@ -46,52 +46,51 @@ class CCrossbowBolt : public CBaseEntity
|
|||
public:
|
||||
static CCrossbowBolt *BoltCreate( void );
|
||||
};
|
||||
LINK_ENTITY_TO_CLASS( crossbow_bolt, CCrossbowBolt );
|
||||
|
||||
LINK_ENTITY_TO_CLASS( crossbow_bolt, CCrossbowBolt )
|
||||
|
||||
CCrossbowBolt *CCrossbowBolt::BoltCreate( void )
|
||||
{
|
||||
// Create a new entity with CCrossbowBolt private data
|
||||
CCrossbowBolt *pBolt = GetClassPtr( (CCrossbowBolt *)NULL );
|
||||
pBolt->pev->classname = MAKE_STRING("crossbow_bolt"); // g-cont. enable save\restore
|
||||
pBolt->pev->classname = MAKE_STRING( "crossbow_bolt" ); // g-cont. enable save\restore
|
||||
pBolt->Spawn();
|
||||
|
||||
return pBolt;
|
||||
}
|
||||
|
||||
void CCrossbowBolt::Spawn( )
|
||||
void CCrossbowBolt::Spawn()
|
||||
{
|
||||
Precache( );
|
||||
Precache();
|
||||
pev->movetype = MOVETYPE_FLY;
|
||||
pev->solid = SOLID_BBOX;
|
||||
|
||||
pev->gravity = 0.5;
|
||||
|
||||
SET_MODEL(ENT(pev), "models/crossbow_bolt.mdl");
|
||||
SET_MODEL( ENT( pev ), "models/crossbow_bolt.mdl" );
|
||||
|
||||
UTIL_SetOrigin( pev, pev->origin );
|
||||
UTIL_SetSize(pev, Vector(0, 0, 0), Vector(0, 0, 0));
|
||||
UTIL_SetSize( pev, Vector( 0, 0, 0 ), Vector( 0, 0, 0 ) );
|
||||
|
||||
SetTouch( &CCrossbowBolt::BoltTouch );
|
||||
SetThink( &CCrossbowBolt::BubbleThink );
|
||||
pev->nextthink = gpGlobals->time + 0.2;
|
||||
}
|
||||
|
||||
|
||||
void CCrossbowBolt::Precache( )
|
||||
void CCrossbowBolt::Precache()
|
||||
{
|
||||
PRECACHE_MODEL ("models/crossbow_bolt.mdl");
|
||||
PRECACHE_SOUND("weapons/xbow_hitbod1.wav");
|
||||
PRECACHE_SOUND("weapons/xbow_hitbod2.wav");
|
||||
PRECACHE_SOUND("weapons/xbow_fly1.wav");
|
||||
PRECACHE_SOUND("weapons/xbow_hit1.wav");
|
||||
PRECACHE_SOUND("fvox/beep.wav");
|
||||
m_iTrail = PRECACHE_MODEL("sprites/streak.spr");
|
||||
PRECACHE_MODEL( "models/crossbow_bolt.mdl" );
|
||||
PRECACHE_SOUND( "weapons/xbow_hitbod1.wav" );
|
||||
PRECACHE_SOUND( "weapons/xbow_hitbod2.wav" );
|
||||
PRECACHE_SOUND( "weapons/xbow_fly1.wav" );
|
||||
PRECACHE_SOUND( "weapons/xbow_hit1.wav" );
|
||||
PRECACHE_SOUND( "fvox/beep.wav" );
|
||||
m_iTrail = PRECACHE_MODEL( "sprites/streak.spr" );
|
||||
}
|
||||
|
||||
|
||||
int CCrossbowBolt :: Classify ( void )
|
||||
int CCrossbowBolt::Classify( void )
|
||||
{
|
||||
return CLASS_NONE;
|
||||
return CLASS_NONE;
|
||||
}
|
||||
|
||||
void CCrossbowBolt::BoltTouch( CBaseEntity *pOther )
|
||||
|
@ -99,71 +98,73 @@ void CCrossbowBolt::BoltTouch( CBaseEntity *pOther )
|
|||
SetTouch( NULL );
|
||||
SetThink( NULL );
|
||||
|
||||
if (pOther->pev->takedamage)
|
||||
if( pOther->pev->takedamage )
|
||||
{
|
||||
TraceResult tr = UTIL_GetGlobalTrace( );
|
||||
entvars_t *pevOwner;
|
||||
TraceResult tr = UTIL_GetGlobalTrace();
|
||||
entvars_t *pevOwner;
|
||||
|
||||
pevOwner = VARS( pev->owner );
|
||||
|
||||
// UNDONE: this needs to call TraceAttack instead
|
||||
ClearMultiDamage( );
|
||||
ClearMultiDamage();
|
||||
|
||||
if ( pOther->IsPlayer() )
|
||||
if( pOther->IsPlayer() )
|
||||
{
|
||||
pOther->TraceAttack(pevOwner, gSkillData.plrDmgCrossbowClient, pev->velocity.Normalize(), &tr, DMG_NEVERGIB );
|
||||
pOther->TraceAttack( pevOwner, gSkillData.plrDmgCrossbowClient, pev->velocity.Normalize(), &tr, DMG_NEVERGIB );
|
||||
}
|
||||
else
|
||||
{
|
||||
pOther->TraceAttack(pevOwner, gSkillData.plrDmgCrossbowMonster, pev->velocity.Normalize(), &tr, DMG_BULLET | DMG_NEVERGIB );
|
||||
pOther->TraceAttack( pevOwner, gSkillData.plrDmgCrossbowMonster, pev->velocity.Normalize(), &tr, DMG_BULLET | DMG_NEVERGIB );
|
||||
}
|
||||
|
||||
ApplyMultiDamage( pev, pevOwner );
|
||||
|
||||
pev->velocity = Vector( 0, 0, 0 );
|
||||
// play body "thwack" sound
|
||||
switch( RANDOM_LONG(0,1) )
|
||||
switch( RANDOM_LONG( 0, 1 ) )
|
||||
{
|
||||
case 0:
|
||||
EMIT_SOUND(ENT(pev), CHAN_BODY, "weapons/xbow_hitbod1.wav", 1, ATTN_NORM); break;
|
||||
EMIT_SOUND( ENT( pev ), CHAN_BODY, "weapons/xbow_hitbod1.wav", 1, ATTN_NORM );
|
||||
break;
|
||||
case 1:
|
||||
EMIT_SOUND(ENT(pev), CHAN_BODY, "weapons/xbow_hitbod2.wav", 1, ATTN_NORM); break;
|
||||
EMIT_SOUND( ENT( pev ), CHAN_BODY, "weapons/xbow_hitbod2.wav", 1, ATTN_NORM );
|
||||
break;
|
||||
}
|
||||
|
||||
if ( !g_pGameRules->IsMultiplayer() )
|
||||
if( !g_pGameRules->IsMultiplayer() )
|
||||
{
|
||||
Killed( pev, GIB_NEVER );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
EMIT_SOUND_DYN(ENT(pev), CHAN_BODY, "weapons/xbow_hit1.wav", RANDOM_FLOAT(0.95, 1.0), ATTN_NORM, 0, 98 + RANDOM_LONG(0,7));
|
||||
EMIT_SOUND_DYN( ENT( pev ), CHAN_BODY, "weapons/xbow_hit1.wav", RANDOM_FLOAT( 0.95, 1.0 ), ATTN_NORM, 0, 98 + RANDOM_LONG( 0, 7 ) );
|
||||
|
||||
SetThink( &CBaseEntity::SUB_Remove );
|
||||
pev->nextthink = gpGlobals->time;// this will get changed below if the bolt is allowed to stick in what it hit.
|
||||
|
||||
if ( FClassnameIs( pOther->pev, "worldspawn" ) )
|
||||
if( FClassnameIs( pOther->pev, "worldspawn" ) )
|
||||
{
|
||||
// if what we hit is static architecture, can stay around for a while.
|
||||
Vector vecDir = pev->velocity.Normalize( );
|
||||
Vector vecDir = pev->velocity.Normalize();
|
||||
UTIL_SetOrigin( pev, pev->origin - vecDir * 12 );
|
||||
pev->angles = UTIL_VecToAngles( vecDir );
|
||||
pev->solid = SOLID_NOT;
|
||||
pev->movetype = MOVETYPE_FLY;
|
||||
pev->velocity = Vector( 0, 0, 0 );
|
||||
pev->avelocity.z = 0;
|
||||
pev->angles.z = RANDOM_LONG(0,360);
|
||||
pev->angles.z = RANDOM_LONG( 0, 360 );
|
||||
pev->nextthink = gpGlobals->time + 10.0;
|
||||
}
|
||||
else if ( pOther->pev->movetype == MOVETYPE_PUSH || pOther->pev->movetype == MOVETYPE_PUSHSTEP )
|
||||
else if( pOther->pev->movetype == MOVETYPE_PUSH || pOther->pev->movetype == MOVETYPE_PUSHSTEP )
|
||||
{
|
||||
Vector vecDir = pev->velocity.Normalize( );
|
||||
Vector vecDir = pev->velocity.Normalize();
|
||||
UTIL_SetOrigin( pev, pev->origin - vecDir * 12 );
|
||||
pev->angles = UTIL_VecToAngles( vecDir );
|
||||
pev->solid = SOLID_NOT;
|
||||
pev->velocity = Vector( 0, 0, 0 );
|
||||
pev->avelocity.z = 0;
|
||||
pev->angles.z = RANDOM_LONG(0,360);
|
||||
pev->angles.z = RANDOM_LONG( 0, 360 );
|
||||
pev->nextthink = gpGlobals->time + 10.0;
|
||||
|
||||
// g-cont. Setup movewith feature
|
||||
|
@ -171,13 +172,13 @@ void CCrossbowBolt::BoltTouch( CBaseEntity *pOther )
|
|||
pev->aiment = ENT( pOther->pev ); // set parent
|
||||
}
|
||||
|
||||
if (UTIL_PointContents(pev->origin) != CONTENTS_WATER)
|
||||
if( UTIL_PointContents( pev->origin ) != CONTENTS_WATER )
|
||||
{
|
||||
UTIL_Sparks( pev->origin );
|
||||
}
|
||||
}
|
||||
|
||||
if ( g_pGameRules->IsMultiplayer() )
|
||||
if( g_pGameRules->IsMultiplayer() )
|
||||
{
|
||||
SetThink( &CCrossbowBolt::ExplodeThink );
|
||||
pev->nextthink = gpGlobals->time + 0.1;
|
||||
|
@ -188,7 +189,7 @@ void CCrossbowBolt::BubbleThink( void )
|
|||
{
|
||||
pev->nextthink = gpGlobals->time + 0.1;
|
||||
|
||||
if (pev->waterlevel == 0)
|
||||
if( pev->waterlevel == 0 )
|
||||
return;
|
||||
|
||||
UTIL_BubbleTrail( pev->origin - pev->velocity * 0.1, pev->origin, 1 );
|
||||
|
@ -196,18 +197,18 @@ void CCrossbowBolt::BubbleThink( void )
|
|||
|
||||
void CCrossbowBolt::ExplodeThink( void )
|
||||
{
|
||||
int iContents = UTIL_PointContents ( pev->origin );
|
||||
int iContents = UTIL_PointContents( pev->origin );
|
||||
int iScale;
|
||||
|
||||
|
||||
pev->dmg = 40;
|
||||
iScale = 10;
|
||||
|
||||
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, pev->origin );
|
||||
WRITE_BYTE( TE_EXPLOSION);
|
||||
WRITE_BYTE( TE_EXPLOSION );
|
||||
WRITE_COORD( pev->origin.x );
|
||||
WRITE_COORD( pev->origin.y );
|
||||
WRITE_COORD( pev->origin.z );
|
||||
if (iContents != CONTENTS_WATER)
|
||||
if( iContents != CONTENTS_WATER )
|
||||
{
|
||||
WRITE_SHORT( g_sModelIndexFireball );
|
||||
}
|
||||
|
@ -215,14 +216,14 @@ void CCrossbowBolt::ExplodeThink( void )
|
|||
{
|
||||
WRITE_SHORT( g_sModelIndexWExplosion );
|
||||
}
|
||||
WRITE_BYTE( iScale ); // scale * 10
|
||||
WRITE_BYTE( 15 ); // framerate
|
||||
WRITE_BYTE( iScale ); // scale * 10
|
||||
WRITE_BYTE( 15 ); // framerate
|
||||
WRITE_BYTE( TE_EXPLFLAG_NONE );
|
||||
MESSAGE_END();
|
||||
|
||||
entvars_t *pevOwner;
|
||||
|
||||
if ( pev->owner )
|
||||
if( pev->owner )
|
||||
pevOwner = VARS( pev->owner );
|
||||
else
|
||||
pevOwner = NULL;
|
||||
|
@ -231,11 +232,12 @@ void CCrossbowBolt::ExplodeThink( void )
|
|||
|
||||
::RadiusDamage( pev->origin, pev, pevOwner, pev->dmg, 128, CLASS_NONE, DMG_BLAST | DMG_ALWAYSGIB );
|
||||
|
||||
UTIL_Remove(this);
|
||||
UTIL_Remove( this );
|
||||
}
|
||||
#endif
|
||||
|
||||
enum crossbow_e {
|
||||
enum crossbow_e
|
||||
{
|
||||
CROSSBOW_IDLE1 = 0, // full
|
||||
CROSSBOW_IDLE2, // empty
|
||||
CROSSBOW_FIDGET1, // full
|
||||
|
@ -247,16 +249,16 @@ enum crossbow_e {
|
|||
CROSSBOW_DRAW1, // full
|
||||
CROSSBOW_DRAW2, // empty
|
||||
CROSSBOW_HOLSTER1, // full
|
||||
CROSSBOW_HOLSTER2, // empty
|
||||
CROSSBOW_HOLSTER2 // empty
|
||||
};
|
||||
|
||||
LINK_ENTITY_TO_CLASS( weapon_crossbow, CCrossbow );
|
||||
LINK_ENTITY_TO_CLASS( weapon_crossbow, CCrossbow )
|
||||
|
||||
void CCrossbow::Spawn( )
|
||||
void CCrossbow::Spawn()
|
||||
{
|
||||
Precache( );
|
||||
Precache();
|
||||
m_iId = WEAPON_CROSSBOW;
|
||||
SET_MODEL(ENT(pev), "models/w_crossbow.mdl");
|
||||
SET_MODEL( ENT( pev ), "models/w_crossbow.mdl" );
|
||||
|
||||
m_iDefaultAmmo = CROSSBOW_DEFAULT_GIVE;
|
||||
|
||||
|
@ -265,7 +267,7 @@ void CCrossbow::Spawn( )
|
|||
|
||||
int CCrossbow::AddToPlayer( CBasePlayer *pPlayer )
|
||||
{
|
||||
if ( CBasePlayerWeapon::AddToPlayer( pPlayer ) )
|
||||
if( CBasePlayerWeapon::AddToPlayer( pPlayer ) )
|
||||
{
|
||||
MESSAGE_BEGIN( MSG_ONE, gmsgWeapPickup, NULL, pPlayer->pev );
|
||||
WRITE_BYTE( m_iId );
|
||||
|
@ -277,12 +279,12 @@ int CCrossbow::AddToPlayer( CBasePlayer *pPlayer )
|
|||
|
||||
void CCrossbow::Precache( void )
|
||||
{
|
||||
PRECACHE_MODEL("models/w_crossbow.mdl");
|
||||
PRECACHE_MODEL("models/v_crossbow.mdl");
|
||||
PRECACHE_MODEL("models/p_crossbow.mdl");
|
||||
PRECACHE_MODEL( "models/w_crossbow.mdl" );
|
||||
PRECACHE_MODEL( "models/v_crossbow.mdl" );
|
||||
PRECACHE_MODEL( "models/p_crossbow.mdl" );
|
||||
|
||||
PRECACHE_SOUND("weapons/xbow_fire1.wav");
|
||||
PRECACHE_SOUND("weapons/xbow_reload1.wav");
|
||||
PRECACHE_SOUND( "weapons/xbow_fire1.wav" );
|
||||
PRECACHE_SOUND( "weapons/xbow_reload1.wav" );
|
||||
|
||||
UTIL_PrecacheOther( "crossbow_bolt" );
|
||||
|
||||
|
@ -290,10 +292,9 @@ void CCrossbow::Precache( void )
|
|||
m_usCrossbow2 = PRECACHE_EVENT( 1, "events/crossbow2.sc" );
|
||||
}
|
||||
|
||||
|
||||
int CCrossbow::GetItemInfo(ItemInfo *p)
|
||||
int CCrossbow::GetItemInfo( ItemInfo *p )
|
||||
{
|
||||
p->pszName = STRING(pev->classname);
|
||||
p->pszName = STRING( pev->classname );
|
||||
p->pszAmmo1 = "bolts";
|
||||
p->iMaxAmmo1 = BOLT_MAX_CARRY;
|
||||
p->pszAmmo2 = NULL;
|
||||
|
@ -307,10 +308,9 @@ int CCrossbow::GetItemInfo(ItemInfo *p)
|
|||
return 1;
|
||||
}
|
||||
|
||||
|
||||
BOOL CCrossbow::Deploy( )
|
||||
BOOL CCrossbow::Deploy()
|
||||
{
|
||||
if (m_iClip)
|
||||
if( m_iClip )
|
||||
return DefaultDeploy( "models/v_crossbow.mdl", "models/p_crossbow.mdl", CROSSBOW_DRAW1, "bow" );
|
||||
return DefaultDeploy( "models/v_crossbow.mdl", "models/p_crossbow.mdl", CROSSBOW_DRAW2, "bow" );
|
||||
}
|
||||
|
@ -319,13 +319,13 @@ void CCrossbow::Holster( int skiplocal /* = 0 */ )
|
|||
{
|
||||
m_fInReload = FALSE;// cancel any reload in progress.
|
||||
|
||||
if ( m_fInZoom )
|
||||
if( m_fInZoom )
|
||||
{
|
||||
SecondaryAttack( );
|
||||
SecondaryAttack();
|
||||
}
|
||||
|
||||
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + 0.5;
|
||||
if (m_iClip)
|
||||
if( m_iClip )
|
||||
SendWeaponAnim( CROSSBOW_HOLSTER1 );
|
||||
else
|
||||
SendWeaponAnim( CROSSBOW_HOLSTER2 );
|
||||
|
@ -333,11 +333,10 @@ void CCrossbow::Holster( int skiplocal /* = 0 */ )
|
|||
|
||||
void CCrossbow::PrimaryAttack( void )
|
||||
{
|
||||
|
||||
#ifdef CLIENT_DLL
|
||||
if ( m_fInZoom && bIsMultiplayer() )
|
||||
if( m_fInZoom && bIsMultiplayer() )
|
||||
#else
|
||||
if ( m_fInZoom && g_pGameRules->IsMultiplayer() )
|
||||
if( m_fInZoom && g_pGameRules->IsMultiplayer() )
|
||||
#endif
|
||||
{
|
||||
FireSniperBolt();
|
||||
|
@ -352,9 +351,9 @@ void CCrossbow::FireSniperBolt()
|
|||
{
|
||||
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.75;
|
||||
|
||||
if (m_iClip == 0)
|
||||
if( m_iClip == 0 )
|
||||
{
|
||||
PlayEmptySound( );
|
||||
PlayEmptySound();
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -374,19 +373,19 @@ void CCrossbow::FireSniperBolt()
|
|||
|
||||
// player "shoot" animation
|
||||
m_pPlayer->SetAnimation( PLAYER_ATTACK1 );
|
||||
|
||||
|
||||
Vector anglesAim = m_pPlayer->pev->v_angle + m_pPlayer->pev->punchangle;
|
||||
UTIL_MakeVectors( anglesAim );
|
||||
Vector vecSrc = m_pPlayer->GetGunPosition( ) - gpGlobals->v_up * 2;
|
||||
Vector vecSrc = m_pPlayer->GetGunPosition() - gpGlobals->v_up * 2;
|
||||
Vector vecDir = gpGlobals->v_forward;
|
||||
|
||||
UTIL_TraceLine(vecSrc, vecSrc + vecDir * 8192, dont_ignore_monsters, m_pPlayer->edict(), &tr);
|
||||
UTIL_TraceLine( vecSrc, vecSrc + vecDir * 8192, dont_ignore_monsters, m_pPlayer->edict(), &tr );
|
||||
|
||||
#ifndef CLIENT_DLL
|
||||
if ( tr.pHit->v.takedamage )
|
||||
if( tr.pHit->v.takedamage )
|
||||
{
|
||||
ClearMultiDamage( );
|
||||
CBaseEntity::Instance(tr.pHit)->TraceAttack(m_pPlayer->pev, 120, vecDir, &tr, DMG_BULLET | DMG_NEVERGIB );
|
||||
ClearMultiDamage();
|
||||
CBaseEntity::Instance( tr.pHit )->TraceAttack( m_pPlayer->pev, 120, vecDir, &tr, DMG_BULLET | DMG_NEVERGIB );
|
||||
ApplyMultiDamage( pev, m_pPlayer->pev );
|
||||
}
|
||||
#endif
|
||||
|
@ -396,9 +395,9 @@ void CCrossbow::FireBolt()
|
|||
{
|
||||
TraceResult tr;
|
||||
|
||||
if (m_iClip == 0)
|
||||
if( m_iClip == 0 )
|
||||
{
|
||||
PlayEmptySound( );
|
||||
PlayEmptySound();
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -420,10 +419,10 @@ void CCrossbow::FireBolt()
|
|||
|
||||
Vector anglesAim = m_pPlayer->pev->v_angle + m_pPlayer->pev->punchangle;
|
||||
UTIL_MakeVectors( anglesAim );
|
||||
|
||||
anglesAim.x = -anglesAim.x;
|
||||
Vector vecSrc = m_pPlayer->GetGunPosition( ) - gpGlobals->v_up * 2;
|
||||
Vector vecDir = gpGlobals->v_forward;
|
||||
|
||||
anglesAim.x = -anglesAim.x;
|
||||
Vector vecSrc = m_pPlayer->GetGunPosition() - gpGlobals->v_up * 2;
|
||||
Vector vecDir = gpGlobals->v_forward;
|
||||
|
||||
#ifndef CLIENT_DLL
|
||||
CCrossbowBolt *pBolt = CCrossbowBolt::BoltCreate();
|
||||
|
@ -431,7 +430,7 @@ void CCrossbow::FireBolt()
|
|||
pBolt->pev->angles = anglesAim;
|
||||
pBolt->pev->owner = m_pPlayer->edict();
|
||||
|
||||
if (m_pPlayer->pev->waterlevel == 3)
|
||||
if( m_pPlayer->pev->waterlevel == 3 )
|
||||
{
|
||||
pBolt->pev->velocity = vecDir * BOLT_WATER_VELOCITY;
|
||||
pBolt->pev->speed = BOLT_WATER_VELOCITY;
|
||||
|
@ -444,68 +443,65 @@ void CCrossbow::FireBolt()
|
|||
pBolt->pev->avelocity.z = 10;
|
||||
#endif
|
||||
|
||||
if (!m_iClip && m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0)
|
||||
if( !m_iClip && m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0 )
|
||||
// HEV suit - indicate out of ammo condition
|
||||
m_pPlayer->SetSuitUpdate("!HEV_AMO0", FALSE, 0);
|
||||
m_pPlayer->SetSuitUpdate( "!HEV_AMO0", FALSE, 0 );
|
||||
|
||||
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.75;
|
||||
|
||||
m_flNextSecondaryAttack = UTIL_WeaponTimeBase() + 0.75;
|
||||
|
||||
if (m_iClip != 0)
|
||||
if( m_iClip != 0 )
|
||||
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 5.0;
|
||||
else
|
||||
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 0.75;
|
||||
}
|
||||
|
||||
|
||||
void CCrossbow::SecondaryAttack()
|
||||
{
|
||||
if ( m_pPlayer->pev->fov != 0 )
|
||||
if( m_pPlayer->pev->fov != 0 )
|
||||
{
|
||||
m_pPlayer->pev->fov = m_pPlayer->m_iFOV = 0; // 0 means reset to default fov
|
||||
m_fInZoom = 0;
|
||||
}
|
||||
else if ( m_pPlayer->pev->fov != 20 )
|
||||
else if( m_pPlayer->pev->fov != 20 )
|
||||
{
|
||||
m_pPlayer->pev->fov = m_pPlayer->m_iFOV = 20;
|
||||
m_fInZoom = 1;
|
||||
}
|
||||
|
||||
|
||||
pev->nextthink = UTIL_WeaponTimeBase() + 0.1;
|
||||
m_flNextSecondaryAttack = UTIL_WeaponTimeBase() + 1.0;
|
||||
}
|
||||
|
||||
|
||||
void CCrossbow::Reload( void )
|
||||
{
|
||||
if ( m_pPlayer->ammo_bolts <= 0 )
|
||||
if( m_pPlayer->ammo_bolts <= 0 )
|
||||
return;
|
||||
|
||||
if ( m_pPlayer->pev->fov != 0 )
|
||||
if( m_pPlayer->pev->fov != 0 )
|
||||
{
|
||||
SecondaryAttack();
|
||||
}
|
||||
|
||||
if ( DefaultReload( 5, CROSSBOW_RELOAD, 4.5 ) )
|
||||
if( DefaultReload( 5, CROSSBOW_RELOAD, 4.5 ) )
|
||||
{
|
||||
EMIT_SOUND_DYN(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/xbow_reload1.wav", RANDOM_FLOAT(0.95, 1.0), ATTN_NORM, 0, 93 + RANDOM_LONG(0,0xF));
|
||||
EMIT_SOUND_DYN( ENT( m_pPlayer->pev ), CHAN_ITEM, "weapons/xbow_reload1.wav", RANDOM_FLOAT( 0.95, 1.0 ), ATTN_NORM, 0, 93 + RANDOM_LONG( 0, 0xF ) );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CCrossbow::WeaponIdle( void )
|
||||
{
|
||||
m_pPlayer->GetAutoaimVector( AUTOAIM_2DEGREES ); // get the autoaim vector but ignore it; used for autoaim crosshair in DM
|
||||
|
||||
ResetEmptySound( );
|
||||
ResetEmptySound();
|
||||
|
||||
if ( m_flTimeWeaponIdle < UTIL_WeaponTimeBase() )
|
||||
if( m_flTimeWeaponIdle < UTIL_WeaponTimeBase() )
|
||||
{
|
||||
float flRand = UTIL_SharedRandomFloat( m_pPlayer->random_seed, 0, 1 );
|
||||
if (flRand <= 0.75)
|
||||
if( flRand <= 0.75 )
|
||||
{
|
||||
if (m_iClip)
|
||||
if( m_iClip )
|
||||
{
|
||||
SendWeaponAnim( CROSSBOW_IDLE1 );
|
||||
}
|
||||
|
@ -517,7 +513,7 @@ void CCrossbow::WeaponIdle( void )
|
|||
}
|
||||
else
|
||||
{
|
||||
if (m_iClip)
|
||||
if( m_iClip )
|
||||
{
|
||||
SendWeaponAnim( CROSSBOW_FIDGET1 );
|
||||
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 90.0 / 30.0;
|
||||
|
@ -532,33 +528,29 @@ void CCrossbow::WeaponIdle( void )
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
class CCrossbowAmmo : public CBasePlayerAmmo
|
||||
{
|
||||
void Spawn( void )
|
||||
{
|
||||
Precache( );
|
||||
SET_MODEL(ENT(pev), "models/w_crossbow_clip.mdl");
|
||||
CBasePlayerAmmo::Spawn( );
|
||||
Precache();
|
||||
SET_MODEL( ENT( pev ), "models/w_crossbow_clip.mdl" );
|
||||
CBasePlayerAmmo::Spawn();
|
||||
}
|
||||
void Precache( void )
|
||||
{
|
||||
PRECACHE_MODEL ("models/w_crossbow_clip.mdl");
|
||||
PRECACHE_SOUND("items/9mmclip1.wav");
|
||||
PRECACHE_MODEL( "models/w_crossbow_clip.mdl" );
|
||||
PRECACHE_SOUND( "items/9mmclip1.wav" );
|
||||
}
|
||||
BOOL AddAmmo( CBaseEntity *pOther )
|
||||
BOOL AddAmmo( CBaseEntity *pOther )
|
||||
{
|
||||
if (pOther->GiveAmmo( AMMO_CROSSBOWCLIP_GIVE, "bolts", BOLT_MAX_CARRY ) != -1)
|
||||
if( pOther->GiveAmmo( AMMO_CROSSBOWCLIP_GIVE, "bolts", BOLT_MAX_CARRY ) != -1 )
|
||||
{
|
||||
EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/9mmclip1.wav", 1, ATTN_NORM);
|
||||
EMIT_SOUND( ENT( pev ), CHAN_ITEM, "items/9mmclip1.wav", 1, ATTN_NORM );
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
};
|
||||
LINK_ENTITY_TO_CLASS( ammo_crossbow, CCrossbowAmmo );
|
||||
|
||||
|
||||
|
||||
LINK_ENTITY_TO_CLASS( ammo_crossbow, CCrossbowAmmo )
|
||||
#endif
|
||||
|
|
156
dlls/crowbar.cpp
156
dlls/crowbar.cpp
|
@ -22,15 +22,13 @@
|
|||
#include "player.h"
|
||||
#include "gamerules.h"
|
||||
|
||||
|
||||
#define CROWBAR_BODYHIT_VOLUME 128
|
||||
#define CROWBAR_WALLHIT_VOLUME 512
|
||||
|
||||
LINK_ENTITY_TO_CLASS( weapon_crowbar, CCrowbar );
|
||||
LINK_ENTITY_TO_CLASS( weapon_crowbar, CCrowbar )
|
||||
|
||||
|
||||
|
||||
enum gauss_e {
|
||||
enum gauss_e
|
||||
{
|
||||
CROWBAR_IDLE = 0,
|
||||
CROWBAR_DRAW,
|
||||
CROWBAR_HOLSTER,
|
||||
|
@ -45,33 +43,32 @@ enum gauss_e {
|
|||
|
||||
void CCrowbar::Spawn( )
|
||||
{
|
||||
Precache( );
|
||||
Precache();
|
||||
m_iId = WEAPON_CROWBAR;
|
||||
SET_MODEL(ENT(pev), "models/w_crowbar.mdl");
|
||||
SET_MODEL( ENT( pev ), "models/w_crowbar.mdl" );
|
||||
m_iClip = -1;
|
||||
|
||||
FallInit();// get ready to fall down.
|
||||
}
|
||||
|
||||
|
||||
void CCrowbar::Precache( void )
|
||||
{
|
||||
PRECACHE_MODEL("models/v_crowbar.mdl");
|
||||
PRECACHE_MODEL("models/w_crowbar.mdl");
|
||||
PRECACHE_MODEL("models/p_crowbar.mdl");
|
||||
PRECACHE_SOUND("weapons/cbar_hit1.wav");
|
||||
PRECACHE_SOUND("weapons/cbar_hit2.wav");
|
||||
PRECACHE_SOUND("weapons/cbar_hitbod1.wav");
|
||||
PRECACHE_SOUND("weapons/cbar_hitbod2.wav");
|
||||
PRECACHE_SOUND("weapons/cbar_hitbod3.wav");
|
||||
PRECACHE_SOUND("weapons/cbar_miss1.wav");
|
||||
PRECACHE_MODEL( "models/v_crowbar.mdl ");
|
||||
PRECACHE_MODEL( "models/w_crowbar.mdl ");
|
||||
PRECACHE_MODEL( "models/p_crowbar.mdl ");
|
||||
PRECACHE_SOUND( "weapons/cbar_hit1.wav ");
|
||||
PRECACHE_SOUND( "weapons/cbar_hit2.wav ");
|
||||
PRECACHE_SOUND( "weapons/cbar_hitbod1.wav ");
|
||||
PRECACHE_SOUND( "weapons/cbar_hitbod2.wav ");
|
||||
PRECACHE_SOUND( "weapons/cbar_hitbod3.wav ");
|
||||
PRECACHE_SOUND( "weapons/cbar_miss1.wav ");
|
||||
|
||||
m_usCrowbar = PRECACHE_EVENT ( 1, "events/crowbar.sc" );
|
||||
m_usCrowbar = PRECACHE_EVENT( 1, "events/crowbar.sc" );
|
||||
}
|
||||
|
||||
int CCrowbar::GetItemInfo(ItemInfo *p)
|
||||
int CCrowbar::GetItemInfo( ItemInfo *p )
|
||||
{
|
||||
p->pszName = STRING(pev->classname);
|
||||
p->pszName = STRING( pev->classname );
|
||||
p->pszAmmo1 = NULL;
|
||||
p->iMaxAmmo1 = -1;
|
||||
p->pszAmmo2 = NULL;
|
||||
|
@ -84,9 +81,7 @@ int CCrowbar::GetItemInfo(ItemInfo *p)
|
|||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
BOOL CCrowbar::Deploy( )
|
||||
BOOL CCrowbar::Deploy()
|
||||
{
|
||||
return DefaultDeploy( "models/v_crowbar.mdl", "models/p_crowbar.mdl", CROWBAR_DRAW, "crowbar" );
|
||||
}
|
||||
|
@ -97,41 +92,40 @@ void CCrowbar::Holster( int skiplocal /* = 0 */ )
|
|||
SendWeaponAnim( CROWBAR_HOLSTER );
|
||||
}
|
||||
|
||||
|
||||
void FindHullIntersection( const Vector &vecSrc, TraceResult &tr, float *mins, float *maxs, edict_t *pEntity )
|
||||
{
|
||||
int i, j, k;
|
||||
int i, j, k;
|
||||
float distance;
|
||||
float *minmaxs[2] = {mins, maxs};
|
||||
TraceResult tmpTrace;
|
||||
TraceResult tmpTrace;
|
||||
Vector vecHullEnd = tr.vecEndPos;
|
||||
Vector vecEnd;
|
||||
|
||||
distance = 1e6f;
|
||||
|
||||
vecHullEnd = vecSrc + ((vecHullEnd - vecSrc)*2);
|
||||
vecHullEnd = vecSrc + ( ( vecHullEnd - vecSrc ) * 2 );
|
||||
UTIL_TraceLine( vecSrc, vecHullEnd, dont_ignore_monsters, pEntity, &tmpTrace );
|
||||
if ( tmpTrace.flFraction < 1.0 )
|
||||
if( tmpTrace.flFraction < 1.0 )
|
||||
{
|
||||
tr = tmpTrace;
|
||||
return;
|
||||
}
|
||||
|
||||
for ( i = 0; i < 2; i++ )
|
||||
for( i = 0; i < 2; i++ )
|
||||
{
|
||||
for ( j = 0; j < 2; j++ )
|
||||
for( j = 0; j < 2; j++ )
|
||||
{
|
||||
for ( k = 0; k < 2; k++ )
|
||||
for( k = 0; k < 2; k++ )
|
||||
{
|
||||
vecEnd.x = vecHullEnd.x + minmaxs[i][0];
|
||||
vecEnd.y = vecHullEnd.y + minmaxs[j][1];
|
||||
vecEnd.z = vecHullEnd.z + minmaxs[k][2];
|
||||
|
||||
UTIL_TraceLine( vecSrc, vecEnd, dont_ignore_monsters, pEntity, &tmpTrace );
|
||||
if ( tmpTrace.flFraction < 1.0 )
|
||||
if( tmpTrace.flFraction < 1.0 )
|
||||
{
|
||||
float thisDistance = (tmpTrace.vecEndPos - vecSrc).Length();
|
||||
if ( thisDistance < distance )
|
||||
float thisDistance = ( tmpTrace.vecEndPos - vecSrc ).Length();
|
||||
if( thisDistance < distance )
|
||||
{
|
||||
tr = tmpTrace;
|
||||
distance = thisDistance;
|
||||
|
@ -142,131 +136,130 @@ void FindHullIntersection( const Vector &vecSrc, TraceResult &tr, float *mins, f
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
void CCrowbar::PrimaryAttack()
|
||||
{
|
||||
if (! Swing( 1 ))
|
||||
if( !Swing( 1 ) )
|
||||
{
|
||||
SetThink( &CCrowbar::SwingAgain );
|
||||
pev->nextthink = gpGlobals->time + 0.1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CCrowbar::Smack( )
|
||||
void CCrowbar::Smack()
|
||||
{
|
||||
DecalGunshot( &m_trHit, BULLET_PLAYER_CROWBAR );
|
||||
}
|
||||
|
||||
|
||||
void CCrowbar::SwingAgain( void )
|
||||
{
|
||||
Swing( 0 );
|
||||
}
|
||||
|
||||
|
||||
int CCrowbar::Swing( int fFirst )
|
||||
{
|
||||
int fDidHit = FALSE;
|
||||
|
||||
TraceResult tr;
|
||||
|
||||
UTIL_MakeVectors (m_pPlayer->pev->v_angle);
|
||||
Vector vecSrc = m_pPlayer->GetGunPosition( );
|
||||
Vector vecEnd = vecSrc + gpGlobals->v_forward * 32;
|
||||
UTIL_MakeVectors( m_pPlayer->pev->v_angle );
|
||||
Vector vecSrc = m_pPlayer->GetGunPosition();
|
||||
Vector vecEnd = vecSrc + gpGlobals->v_forward * 32;
|
||||
|
||||
UTIL_TraceLine( vecSrc, vecEnd, dont_ignore_monsters, ENT( m_pPlayer->pev ), &tr );
|
||||
|
||||
#ifndef CLIENT_DLL
|
||||
if ( tr.flFraction >= 1.0 )
|
||||
if( tr.flFraction >= 1.0 )
|
||||
{
|
||||
UTIL_TraceHull( vecSrc, vecEnd, dont_ignore_monsters, head_hull, ENT( m_pPlayer->pev ), &tr );
|
||||
if ( tr.flFraction < 1.0 )
|
||||
if( tr.flFraction < 1.0 )
|
||||
{
|
||||
// Calculate the point of intersection of the line (or hull) and the object we hit
|
||||
// This is and approximation of the "best" intersection
|
||||
CBaseEntity *pHit = CBaseEntity::Instance( tr.pHit );
|
||||
if ( !pHit || pHit->IsBSPModel() )
|
||||
if( !pHit || pHit->IsBSPModel() )
|
||||
FindHullIntersection( vecSrc, tr, VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX, m_pPlayer->edict() );
|
||||
vecEnd = tr.vecEndPos; // This is the point on the actual surface (the hull could have hit space)
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
PLAYBACK_EVENT_FULL( FEV_NOTHOST, m_pPlayer->edict(), m_usCrowbar,
|
||||
0.0, (float *)&g_vecZero, (float *)&g_vecZero, 0, 0, 0,
|
||||
0.0, 0, 0.0 );
|
||||
|
||||
|
||||
if ( tr.flFraction >= 1.0 )
|
||||
if( tr.flFraction >= 1.0 )
|
||||
{
|
||||
if (fFirst)
|
||||
if( fFirst )
|
||||
{
|
||||
// miss
|
||||
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.5;
|
||||
|
||||
|
||||
// player "shoot" animation
|
||||
m_pPlayer->SetAnimation( PLAYER_ATTACK1 );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
switch( ((m_iSwing++) % 2) + 1 )
|
||||
switch( ( ( m_iSwing++ ) % 2 ) + 1 )
|
||||
{
|
||||
case 0:
|
||||
SendWeaponAnim( CROWBAR_ATTACK1HIT ); break;
|
||||
SendWeaponAnim( CROWBAR_ATTACK1HIT );
|
||||
break;
|
||||
case 1:
|
||||
SendWeaponAnim( CROWBAR_ATTACK2HIT ); break;
|
||||
SendWeaponAnim( CROWBAR_ATTACK2HIT );
|
||||
break;
|
||||
case 2:
|
||||
SendWeaponAnim( CROWBAR_ATTACK3HIT ); break;
|
||||
SendWeaponAnim( CROWBAR_ATTACK3HIT );
|
||||
break;
|
||||
}
|
||||
|
||||
// player "shoot" animation
|
||||
m_pPlayer->SetAnimation( PLAYER_ATTACK1 );
|
||||
|
||||
#ifndef CLIENT_DLL
|
||||
|
||||
#ifndef CLIENT_DLL
|
||||
// hit
|
||||
fDidHit = TRUE;
|
||||
CBaseEntity *pEntity = CBaseEntity::Instance(tr.pHit);
|
||||
CBaseEntity *pEntity = CBaseEntity::Instance( tr.pHit );
|
||||
|
||||
ClearMultiDamage( );
|
||||
ClearMultiDamage();
|
||||
|
||||
if ( (m_flNextPrimaryAttack + 1 < UTIL_WeaponTimeBase() ) || g_pGameRules->IsMultiplayer() )
|
||||
if( ( m_flNextPrimaryAttack + 1 < UTIL_WeaponTimeBase() ) || g_pGameRules->IsMultiplayer() )
|
||||
{
|
||||
// first swing does full damage
|
||||
pEntity->TraceAttack(m_pPlayer->pev, gSkillData.plrDmgCrowbar, gpGlobals->v_forward, &tr, DMG_CLUB );
|
||||
pEntity->TraceAttack( m_pPlayer->pev, gSkillData.plrDmgCrowbar, gpGlobals->v_forward, &tr, DMG_CLUB );
|
||||
}
|
||||
else
|
||||
{
|
||||
// subsequent swings do half
|
||||
pEntity->TraceAttack(m_pPlayer->pev, gSkillData.plrDmgCrowbar / 2, gpGlobals->v_forward, &tr, DMG_CLUB );
|
||||
}
|
||||
pEntity->TraceAttack( m_pPlayer->pev, gSkillData.plrDmgCrowbar / 2, gpGlobals->v_forward, &tr, DMG_CLUB );
|
||||
}
|
||||
ApplyMultiDamage( m_pPlayer->pev, m_pPlayer->pev );
|
||||
|
||||
// play thwack, smack, or dong sound
|
||||
float flVol = 1.0;
|
||||
int fHitWorld = TRUE;
|
||||
|
||||
if (pEntity)
|
||||
if( pEntity )
|
||||
{
|
||||
if ( pEntity->Classify() != CLASS_NONE && pEntity->Classify() != CLASS_MACHINE )
|
||||
if( pEntity->Classify() != CLASS_NONE && pEntity->Classify() != CLASS_MACHINE )
|
||||
{
|
||||
// play thwack or smack sound
|
||||
switch( RANDOM_LONG(0,2) )
|
||||
switch( RANDOM_LONG( 0, 2 ) )
|
||||
{
|
||||
case 0:
|
||||
EMIT_SOUND(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/cbar_hitbod1.wav", 1, ATTN_NORM); break;
|
||||
EMIT_SOUND( ENT( m_pPlayer->pev ), CHAN_ITEM, "weapons/cbar_hitbod1.wav", 1, ATTN_NORM );
|
||||
break;
|
||||
case 1:
|
||||
EMIT_SOUND(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/cbar_hitbod2.wav", 1, ATTN_NORM); break;
|
||||
EMIT_SOUND( ENT( m_pPlayer->pev ), CHAN_ITEM, "weapons/cbar_hitbod2.wav", 1, ATTN_NORM );
|
||||
break;
|
||||
case 2:
|
||||
EMIT_SOUND(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/cbar_hitbod3.wav", 1, ATTN_NORM); break;
|
||||
EMIT_SOUND( ENT( m_pPlayer->pev ), CHAN_ITEM, "weapons/cbar_hitbod3.wav", 1, ATTN_NORM );
|
||||
break;
|
||||
}
|
||||
m_pPlayer->m_iWeaponVolume = CROWBAR_BODYHIT_VOLUME;
|
||||
if ( !pEntity->IsAlive() )
|
||||
return TRUE;
|
||||
if( !pEntity->IsAlive() )
|
||||
return TRUE;
|
||||
else
|
||||
flVol = 0.1;
|
||||
flVol = 0.1;
|
||||
|
||||
fHitWorld = FALSE;
|
||||
}
|
||||
|
@ -275,11 +268,11 @@ int CCrowbar::Swing( int fFirst )
|
|||
// play texture hit sound
|
||||
// UNDONE: Calculate the correct point of intersection when we hit with the hull instead of the line
|
||||
|
||||
if (fHitWorld)
|
||||
if( fHitWorld )
|
||||
{
|
||||
float fvolbar = TEXTURETYPE_PlaySound(&tr, vecSrc, vecSrc + (vecEnd-vecSrc)*2, BULLET_PLAYER_CROWBAR);
|
||||
float fvolbar = TEXTURETYPE_PlaySound( &tr, vecSrc, vecSrc + ( vecEnd - vecSrc ) * 2, BULLET_PLAYER_CROWBAR );
|
||||
|
||||
if ( g_pGameRules->IsMultiplayer() )
|
||||
if( g_pGameRules->IsMultiplayer() )
|
||||
{
|
||||
// override the volume here, cause we don't play texture sounds in multiplayer,
|
||||
// and fvolbar is going to be 0 from the above call.
|
||||
|
@ -288,13 +281,13 @@ int CCrowbar::Swing( int fFirst )
|
|||
}
|
||||
|
||||
// also play crowbar strike
|
||||
switch( RANDOM_LONG(0,1) )
|
||||
switch( RANDOM_LONG( 0, 1 ) )
|
||||
{
|
||||
case 0:
|
||||
EMIT_SOUND_DYN(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/cbar_hit1.wav", fvolbar, ATTN_NORM, 0, 98 + RANDOM_LONG(0,3));
|
||||
EMIT_SOUND_DYN( ENT( m_pPlayer->pev ), CHAN_ITEM, "weapons/cbar_hit1.wav", fvolbar, ATTN_NORM, 0, 98 + RANDOM_LONG( 0, 3 ) );
|
||||
break;
|
||||
case 1:
|
||||
EMIT_SOUND_DYN(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/cbar_hit2.wav", fvolbar, ATTN_NORM, 0, 98 + RANDOM_LONG(0,3));
|
||||
EMIT_SOUND_DYN( ENT( m_pPlayer->pev ), CHAN_ITEM, "weapons/cbar_hit2.wav", fvolbar, ATTN_NORM, 0, 98 + RANDOM_LONG( 0, 3 ) );
|
||||
break;
|
||||
}
|
||||
|
||||
|
@ -305,14 +298,9 @@ int CCrowbar::Swing( int fFirst )
|
|||
m_pPlayer->m_iWeaponVolume = flVol * CROWBAR_WALLHIT_VOLUME;
|
||||
#endif
|
||||
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.25;
|
||||
|
||||
|
||||
SetThink( &CCrowbar::Smack );
|
||||
pev->nextthink = UTIL_WeaponTimeBase() + 0.2;
|
||||
|
||||
|
||||
}
|
||||
return fDidHit;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -61,15 +61,14 @@ enum decal_e
|
|||
DECAL_SMALLSCORCH2, // Small scorch mark
|
||||
DECAL_SMALLSCORCH3, // Small scorch mark
|
||||
DECAL_MOMMABIRTH, // Big momma birth splatter
|
||||
DECAL_MOMMASPLAT,
|
||||
DECAL_MOMMASPLAT
|
||||
};
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char *name;
|
||||
int index;
|
||||
char *name;
|
||||
int index;
|
||||
} DLL_DECALLIST;
|
||||
|
||||
extern DLL_DECALLIST gDecals[];
|
||||
|
||||
#endif // DECALS_H
|
||||
#endif //DECALS_H
|
||||
|
|
File diff suppressed because it is too large
Load Diff
927
dlls/doors.cpp
927
dlls/doors.cpp
File diff suppressed because it is too large
Load Diff
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue