remove useless projects
Marrub
parent
44a4b8fd6d
commit
c206739e6d
|
|
@ -1,246 +0,0 @@
|
|||
#ifdef THREEWAVE
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "parsemsg.h"
|
||||
|
||||
#include "const.h"
|
||||
#include "entity_state.h"
|
||||
#include "cl_entity.h"
|
||||
#include "entity_types.h"
|
||||
#include "usercmd.h"
|
||||
#include "pm_defs.h"
|
||||
#include "pm_materials.h"
|
||||
#include "ref_params.h"
|
||||
#include <string.h>
|
||||
#include "vgui_viewport.h"
|
||||
#include "vgui_ScorePanel.h"
|
||||
|
||||
#define RED_FLAG_STOLE 1
|
||||
#define BLUE_FLAG_STOLE 2
|
||||
#define RED_FLAG_LOST 3
|
||||
#define BLUE_FLAG_LOST 4
|
||||
#define RED_FLAG_ATBASE 5
|
||||
#define BLUE_FLAG_ATBASE 6
|
||||
|
||||
#define ITEM_RUNE1_FLAG 1
|
||||
#define ITEM_RUNE2_FLAG 2
|
||||
#define ITEM_RUNE3_FLAG 3
|
||||
#define ITEM_RUNE4_FLAG 4
|
||||
|
||||
DECLARE_MESSAGE(m_FlagStat, FlagStat)
|
||||
DECLARE_MESSAGE(m_FlagStat, RuneStat)
|
||||
DECLARE_MESSAGE(m_FlagStat, FlagCarrier)
|
||||
|
||||
int CHudFlagStatus::Init(void)
|
||||
{
|
||||
HOOK_MESSAGE( FlagStat );
|
||||
HOOK_MESSAGE( RuneStat );
|
||||
HOOK_MESSAGE( FlagCarrier );
|
||||
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
|
||||
gHUD.AddHudElem(this);
|
||||
|
||||
Reset();
|
||||
|
||||
return 1;
|
||||
};
|
||||
|
||||
int CHudFlagStatus::VidInit(void)
|
||||
{
|
||||
m_iBlueAtBaseIndex = gHUD.GetSpriteIndex( "blue_atbase" );
|
||||
m_iBlueLostIndex = gHUD.GetSpriteIndex( "blue_lost" );
|
||||
m_iBlueStolenIndex = gHUD.GetSpriteIndex( "blue_stolen" );
|
||||
|
||||
m_iRedAtBaseIndex = gHUD.GetSpriteIndex( "red_atbase" );
|
||||
m_iRedLostIndex = gHUD.GetSpriteIndex( "red_lost" );
|
||||
m_iRedStolenIndex = gHUD.GetSpriteIndex( "red_stolen" );
|
||||
|
||||
m_iRune1Index = gHUD.GetSpriteIndex( "rune1" );
|
||||
m_iRune2Index = gHUD.GetSpriteIndex( "rune2" );
|
||||
m_iRune3Index = gHUD.GetSpriteIndex( "rune3" );
|
||||
m_iRune4Index = gHUD.GetSpriteIndex( "rune4" );
|
||||
|
||||
m_hBlueAtBase = gHUD.GetSprite( m_iBlueAtBaseIndex );
|
||||
m_hBlueLost = gHUD.GetSprite( m_iBlueLostIndex );
|
||||
m_hBlueStolen = gHUD.GetSprite( m_iBlueStolenIndex );
|
||||
|
||||
m_hRedAtBase = gHUD.GetSprite( m_iRedAtBaseIndex );
|
||||
m_hRedLost = gHUD.GetSprite( m_iRedLostIndex );
|
||||
m_hRedStolen = gHUD.GetSprite( m_iRedStolenIndex );
|
||||
|
||||
m_hRune1 = gHUD.GetSprite( m_iRune1Index );
|
||||
m_hRune2 = gHUD.GetSprite( m_iRune2Index );
|
||||
m_hRune3 = gHUD.GetSprite( m_iRune3Index );
|
||||
m_hRune4 = gHUD.GetSprite( m_iRune4Index );
|
||||
|
||||
// Load sprites here
|
||||
m_iBlueFlagIndex = gHUD.GetSpriteIndex( "b_flag_c" );
|
||||
m_iRedFlagIndex = gHUD.GetSpriteIndex( "r_flag_c" );
|
||||
|
||||
m_hBlueFlag = gHUD.GetSprite( m_iBlueFlagIndex );
|
||||
m_hRedFlag = gHUD.GetSprite( m_iRedFlagIndex );
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void CHudFlagStatus :: Reset( void )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
int CHudFlagStatus ::Draw(float flTime )
|
||||
{
|
||||
|
||||
if ( !iDrawStatus )
|
||||
return 1;
|
||||
|
||||
int x, y;
|
||||
int r,g,b;
|
||||
|
||||
r = g = b = 255;
|
||||
|
||||
x = 20;
|
||||
y = ( ScreenHeight - gHUD.m_iFontHeight ) - ( gHUD.m_iFontHeight / 2 ) - 40;
|
||||
|
||||
|
||||
switch ( iBlueFlagStatus )
|
||||
{
|
||||
case BLUE_FLAG_STOLE:
|
||||
SPR_Set( m_hBlueStolen, r, g, b );
|
||||
SPR_DrawHoles( 1, x, y, NULL );
|
||||
break;
|
||||
case BLUE_FLAG_LOST:
|
||||
SPR_Set( m_hBlueLost, r, g, b );
|
||||
SPR_DrawHoles( 1, x, y, NULL );
|
||||
break;
|
||||
case BLUE_FLAG_ATBASE:
|
||||
SPR_Set( m_hBlueAtBase, r, g, b );
|
||||
SPR_DrawHoles( 1, x, y, NULL );
|
||||
break;
|
||||
}
|
||||
|
||||
x = 50;
|
||||
|
||||
if ( iBlueTeamScore < 10)
|
||||
{
|
||||
x += 3;
|
||||
gHUD.DrawHudNumber( x, y + 4, DHN_DRAWZERO, iBlueTeamScore, 255, 255, 255 );
|
||||
}
|
||||
else if ( iBlueTeamScore >= 10 && iBlueTeamScore < 100 )
|
||||
gHUD.DrawHudNumber( x, y + 4, DHN_2DIGITS | DHN_DRAWZERO, iBlueTeamScore, 255, 255, 255 );
|
||||
|
||||
x = 20;
|
||||
y = ( ScreenHeight - gHUD.m_iFontHeight ) - ( gHUD.m_iFontHeight / 2 ) - 75;
|
||||
|
||||
switch ( iRedFlagStatus )
|
||||
{
|
||||
case RED_FLAG_STOLE:
|
||||
SPR_Set( m_hRedStolen, r, g, b );
|
||||
SPR_DrawHoles( 1, x, y, NULL );
|
||||
break;
|
||||
case RED_FLAG_LOST:
|
||||
SPR_Set( m_hRedLost, r, g, b );
|
||||
SPR_DrawHoles( 1, x, y, NULL );
|
||||
break;
|
||||
case RED_FLAG_ATBASE:
|
||||
SPR_Set( m_hRedAtBase, r, g, b );
|
||||
SPR_DrawHoles( 1, x, y, NULL );
|
||||
break;
|
||||
}
|
||||
|
||||
x = 50;
|
||||
if ( iRedTeamScore < 10)
|
||||
{
|
||||
x += 3;
|
||||
gHUD.DrawHudNumber( x, y + 4, DHN_DRAWZERO, iRedTeamScore, 255, 255, 255 );
|
||||
}
|
||||
else if ( iBlueTeamScore >= 10 && iBlueTeamScore < 100 )
|
||||
gHUD.DrawHudNumber( x, y + 4, DHN_2DIGITS | DHN_DRAWZERO, iRedTeamScore, 255, 255, 255 );
|
||||
|
||||
x = 20;
|
||||
y = ( ScreenHeight - gHUD.m_iFontHeight ) - ( gHUD.m_iFontHeight / 2 ) - 110;
|
||||
|
||||
switch ( m_iRuneStat )
|
||||
{
|
||||
case ITEM_RUNE1_FLAG:
|
||||
SPR_Set( m_hRune1, r, g, b );
|
||||
SPR_Draw( 1, x, y, NULL );
|
||||
break;
|
||||
|
||||
case ITEM_RUNE2_FLAG:
|
||||
SPR_Set( m_hRune2, r, g, b );
|
||||
SPR_Draw( 1, x, y, NULL );
|
||||
break;
|
||||
|
||||
case ITEM_RUNE3_FLAG:
|
||||
SPR_Set( m_hRune3, r, g, b );
|
||||
SPR_Draw( 1, x, y, NULL );
|
||||
break;
|
||||
|
||||
case ITEM_RUNE4_FLAG:
|
||||
SPR_Set( m_hRune4, r, g, b );
|
||||
SPR_Draw( 1, x, y, NULL );
|
||||
break;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudFlagStatus::MsgFunc_FlagStat(const char *pszName, int iSize, void *pbuf)
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
iDrawStatus = READ_BYTE();
|
||||
iRedFlagStatus = READ_BYTE();
|
||||
iBlueFlagStatus = READ_BYTE();
|
||||
|
||||
iRedTeamScore = READ_BYTE();
|
||||
iBlueTeamScore = READ_BYTE();
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudFlagStatus::MsgFunc_RuneStat(const char *pszName, int iSize, void *pbuf)
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
m_iRuneStat = READ_BYTE();
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudFlagStatus::MsgFunc_FlagCarrier(const char *pszName, int iSize, void *pbuf)
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
int index = READ_BYTE();
|
||||
|
||||
bool bRedFlag = false;
|
||||
bool bBlueFlag = false;
|
||||
|
||||
g_PlayerExtraInfo[ index ].iHasFlag = READ_BYTE();
|
||||
|
||||
for ( int i = 1; i < MAX_PLAYERS + 1; i++ )
|
||||
{
|
||||
if ( g_PlayerExtraInfo[ i ].iHasFlag )
|
||||
{
|
||||
if ( g_PlayerExtraInfo[ i ].teamnumber == 1 )
|
||||
bRedFlag = true;
|
||||
else if ( g_PlayerExtraInfo[ i ].teamnumber == 2 )
|
||||
bBlueFlag = true;
|
||||
}
|
||||
}
|
||||
|
||||
if ( !bRedFlag )
|
||||
gViewPort->m_pScoreBoard->m_pImages[ 5 ]->setVisible( false );
|
||||
if ( !bBlueFlag )
|
||||
gViewPort->m_pScoreBoard->m_pImages[ 4 ]->setVisible( false );
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
|
|
@ -1,184 +0,0 @@
|
|||
#ifdef THREEWAVE
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "parsemsg.h"
|
||||
|
||||
#include "const.h"
|
||||
#include "entity_state.h"
|
||||
#include "cl_entity.h"
|
||||
#include "entity_types.h"
|
||||
#include "usercmd.h"
|
||||
#include "pm_defs.h"
|
||||
#include "pm_materials.h"
|
||||
#include "ref_params.h"
|
||||
#include <string.h>
|
||||
|
||||
|
||||
#define MAX_BONUS 10
|
||||
|
||||
#define RED_FLAG_STOLEN 1
|
||||
#define BLUE_FLAG_STOLEN 2
|
||||
#define RED_FLAG_CAPTURED 3
|
||||
#define BLUE_FLAG_CAPTURED 4
|
||||
#define RED_FLAG_RETURNED_PLAYER 5
|
||||
#define BLUE_FLAG_RETURNED_PLAYER 6
|
||||
#define RED_FLAG_RETURNED 7
|
||||
#define BLUE_FLAG_RETURNED 8
|
||||
#define RED_FLAG_LOST_HUD 9
|
||||
#define BLUE_FLAG_LOST_HUD 10
|
||||
|
||||
|
||||
|
||||
char *sBonusStrings[] =
|
||||
{
|
||||
"",
|
||||
"\\w stole the \\rRED\\w Flag!",
|
||||
"\\w stole the \\bBLUE\\w Flag!",
|
||||
"\\w captured the \\rRED\\w Flag",
|
||||
"\\w captured the \\bBLUE\\w Flag",
|
||||
"\\w returned the \\rRED\\w Flag",
|
||||
"\\w returned the \\bBLUE\\w Flag",
|
||||
"\\wThe \\rRED\\w Flag has Returned",
|
||||
"\\wThe \\bBLUE\\w Flag has Returned",
|
||||
"\\w lost the \\rRED\\w Flag!",
|
||||
"\\w lost the \\bBLUE\\w Flag!",
|
||||
};
|
||||
|
||||
DECLARE_MESSAGE(m_Bonus, Bonus)
|
||||
|
||||
struct bonus_info_t
|
||||
{
|
||||
int iSlot;
|
||||
int iType;
|
||||
bool bActive;
|
||||
float flBonusTime;
|
||||
char sPlayerName[64];
|
||||
};
|
||||
|
||||
bonus_info_t g_PlayerBonus[MAX_BONUS+1];
|
||||
|
||||
int CHudBonus::Init(void)
|
||||
{
|
||||
HOOK_MESSAGE( Bonus );
|
||||
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
|
||||
gHUD.AddHudElem(this);
|
||||
|
||||
Reset();
|
||||
|
||||
return 1;
|
||||
};
|
||||
|
||||
int CHudBonus::VidInit(void)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
void CHudBonus :: Reset( void )
|
||||
{
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
|
||||
for ( int reset = 0; reset < MAX_BONUS; reset++)
|
||||
{
|
||||
g_PlayerBonus[ reset ].flBonusTime = 0.0;
|
||||
g_PlayerBonus[ reset ].iSlot = 0;
|
||||
g_PlayerBonus[ reset ].iType = 0;
|
||||
g_PlayerBonus[ reset ].bActive = false;
|
||||
m_bUsedSlot[ reset ] = false;
|
||||
strcpy ( g_PlayerBonus[ reset ].sPlayerName, "" );
|
||||
}
|
||||
}
|
||||
|
||||
int CHudBonus ::Draw(float flTime )
|
||||
{
|
||||
for (int index = 1; index < MAX_BONUS + 1; index++)
|
||||
{
|
||||
//Just activated
|
||||
if ( g_PlayerBonus[ index ].bActive && !g_PlayerBonus[ index ].flBonusTime )
|
||||
{
|
||||
g_PlayerBonus[ index ].flBonusTime = flTime + 5.0;
|
||||
|
||||
for ( int i = 1; i < MAX_BONUS + 1; i++ )
|
||||
{
|
||||
if ( m_bUsedSlot[ i ] == false ) //found one thats not used
|
||||
{
|
||||
m_bUsedSlot[ i ] = true; //use it!
|
||||
g_PlayerBonus[ index ].iSlot = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ( g_PlayerBonus[ index ].flBonusTime > flTime )
|
||||
{
|
||||
int YPos;
|
||||
int iMod = gHUD.ReturnStringPixelLength( "\\w\\r\\w" );
|
||||
|
||||
YPos = ( ( ScreenHeight - gHUD.m_iFontHeight ) - ( gHUD.m_iFontHeight / 2 ) + 3 ) - ( 30 * g_PlayerBonus[ index ].iSlot );
|
||||
|
||||
int XPos = 75;
|
||||
|
||||
char szText[256];
|
||||
|
||||
strcpy ( szText, g_PlayerBonus[ index ].sPlayerName );
|
||||
strcat ( szText, sBonusStrings[ g_PlayerBonus[ index ].iType ] );
|
||||
|
||||
if ( gHUD.m_FlagStat.iBlueTeamScore >= 10 )
|
||||
gHUD.DrawHudStringCTF( XPos + 20, YPos, 640, szText, 255, 255, 255 );
|
||||
else
|
||||
gHUD.DrawHudStringCTF( XPos , YPos, 320, szText, 255, 255, 255 );
|
||||
|
||||
}
|
||||
|
||||
if ( g_PlayerBonus[ index ].flBonusTime < flTime )
|
||||
{
|
||||
g_PlayerBonus[ index ].bActive = false;
|
||||
m_bUsedSlot[ g_PlayerBonus[ index ].iSlot ] = false;
|
||||
g_PlayerBonus[ index ].iSlot = 0;
|
||||
strcpy ( g_PlayerBonus[ index ].sPlayerName, "" );
|
||||
}
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudBonus::MsgFunc_Bonus(const char *pszName, int iSize, void *pbuf)
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
for ( int index = 1; index < MAX_BONUS + 1; index++)
|
||||
{
|
||||
//Find wich one is not used
|
||||
if ( g_PlayerBonus[ index ].bActive == false )
|
||||
break; //Not using this one?, then we shall use this.
|
||||
}
|
||||
|
||||
g_PlayerBonus[ index ].bActive = true;
|
||||
g_PlayerBonus[ index ].flBonusTime = 0.0;
|
||||
g_PlayerBonus[ index ].iType = READ_BYTE();
|
||||
strcpy ( g_PlayerBonus[ index ].sPlayerName, READ_STRING() );
|
||||
|
||||
switch ( g_PlayerBonus[ index ].iType )
|
||||
{
|
||||
case RED_FLAG_STOLEN:
|
||||
case BLUE_FLAG_STOLEN:
|
||||
PlaySound( "ctf/flagtk.wav", 1 );
|
||||
break;
|
||||
case RED_FLAG_CAPTURED:
|
||||
case BLUE_FLAG_CAPTURED:
|
||||
PlaySound( "ctf/flagcap.wav", 1 );
|
||||
break;
|
||||
case RED_FLAG_RETURNED_PLAYER:
|
||||
case BLUE_FLAG_RETURNED_PLAYER:
|
||||
case RED_FLAG_RETURNED:
|
||||
case BLUE_FLAG_RETURNED:
|
||||
PlaySound( "ctf/flagret.wav", 1 );
|
||||
break;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#if !defined( DMC_BSPFILE_H )
|
||||
#define DMC_BSPFILE_H
|
||||
#ifdef _WIN32
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
// MINI-version of BSPFILE.H to support DeathMatch Classic's entity lump extraction stuff.
|
||||
|
||||
#define BSPVERSION 30
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int fileofs, filelen;
|
||||
} lump_t;
|
||||
|
||||
#define LUMP_ENTITIES 0
|
||||
#define LUMP_PLANES 1
|
||||
#define LUMP_TEXTURES 2
|
||||
#define LUMP_VERTEXES 3
|
||||
#define LUMP_VISIBILITY 4
|
||||
#define LUMP_NODES 5
|
||||
#define LUMP_TEXINFO 6
|
||||
#define LUMP_FACES 7
|
||||
#define LUMP_LIGHTING 8
|
||||
#define LUMP_CLIPNODES 9
|
||||
#define LUMP_LEAFS 10
|
||||
#define LUMP_MARKSURFACES 11
|
||||
#define LUMP_EDGES 12
|
||||
#define LUMP_SURFEDGES 13
|
||||
#define LUMP_MODELS 14
|
||||
|
||||
#define HEADER_LUMPS 15
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int version;
|
||||
lump_t lumps[HEADER_LUMPS];
|
||||
} dheader_t;
|
||||
|
||||
|
||||
#endif // DMC_BSPFILE_H
|
||||
|
|
@ -1,520 +0,0 @@
|
|||
//========= Copyright © 1996-2001, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#include "extdll.h"
|
||||
#include "entity_state.h"
|
||||
#include "pm_defs.h"
|
||||
#include "pm_shared.h"
|
||||
#include "pm_movevars.h"
|
||||
#include "hud_iface.h"
|
||||
#include "com_model.h"
|
||||
#include "event_api.h"
|
||||
#include "com_weapons.h"
|
||||
#include "event_flags.h"
|
||||
#include "DMC_BSPFile.h"
|
||||
#include "cl_util.h"
|
||||
|
||||
#include "FileSystem.h"
|
||||
|
||||
extern IFileSystem *g_pFileSystem;
|
||||
|
||||
extern "C" playermove_t *pmove;
|
||||
extern int g_runfuncs;
|
||||
|
||||
// Don't support more than MAX_TELE teleporters ( map still can load tho )
|
||||
#define MAX_TELES 256
|
||||
|
||||
extern Vector g_vecTeleMins[ MAX_TELES ];
|
||||
extern Vector g_vecTeleMaxs[ MAX_TELES ];
|
||||
extern int g_iTeleNum;
|
||||
extern int g_iUser1;
|
||||
extern bool g_bLoadedTeles;
|
||||
vec3_t vecTempAngles;
|
||||
bool bChangeAngles;
|
||||
|
||||
|
||||
// We only care about two kinds of entities for now: Teleporters and their targets
|
||||
// FIXME: After loading, store a pointer from teleporter to target instead of looking up all the time.
|
||||
typedef enum
|
||||
{
|
||||
// Entity is a teleporter
|
||||
DMC_TELE = 0,
|
||||
// Entity is a target
|
||||
DMC_TARGET
|
||||
} dmc_teletype_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
// Type of entity
|
||||
dmc_teletype_t type;
|
||||
|
||||
// Classname
|
||||
char classname[ 32 ];
|
||||
|
||||
// What this entity targets
|
||||
char target[ 32 ];
|
||||
|
||||
// If entity is a target, the name tag it uses
|
||||
char targetname[ 32 ];
|
||||
|
||||
// Orientation of the teleporter
|
||||
float angles[3];
|
||||
|
||||
// Target origin
|
||||
float origin[3];
|
||||
|
||||
// Bounding box of the teleporter
|
||||
float absmin[3];
|
||||
float absmax[3];
|
||||
|
||||
} dmc_tele_t;
|
||||
|
||||
// Teleporter/Target entity database
|
||||
static dmc_tele_t s_teles[ MAX_TELES ];
|
||||
static int s_num_teles = 0;
|
||||
|
||||
// We'll use this for playing the teleporting sounds locally.
|
||||
static unsigned short s_usTeleport;
|
||||
|
||||
/*
|
||||
==============================
|
||||
Dmc_SetKeyValue
|
||||
|
||||
Fill in key/values fro the teleporter
|
||||
==============================
|
||||
*/
|
||||
void Dmc_SetKeyValue( dmc_tele_t *pTele, const char *key, const char *value )
|
||||
{
|
||||
float x, y, z;
|
||||
|
||||
if ( !stricmp( key, "classname" ) )
|
||||
{
|
||||
strcpy( pTele->classname, value );
|
||||
}
|
||||
else if ( !stricmp( key, "target" ) )
|
||||
{
|
||||
strcpy( pTele->target, value );
|
||||
}
|
||||
else if ( !stricmp( key, "targetname" ) )
|
||||
{
|
||||
strcpy( pTele->targetname, value );
|
||||
}
|
||||
else if ( !stricmp( key, "angles" ) )
|
||||
{
|
||||
if ( sscanf( value, "%f %f %f", &x, &y, &z ) == 3 )
|
||||
{
|
||||
pTele->angles[ 0 ] = x ;
|
||||
pTele->angles[ 1 ] = y;
|
||||
pTele->angles[ 2 ] = z;
|
||||
}
|
||||
}
|
||||
else if ( !stricmp( key, "origin" ) )
|
||||
{
|
||||
if ( sscanf( value, "%f %f %f", &x, &y, &z ) == 3 )
|
||||
{
|
||||
pTele->origin[ 0 ] = x;
|
||||
pTele->origin[ 1 ] = y;
|
||||
pTele->origin[ 2 ] = z;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
==============================
|
||||
Dmc_ParseTeleporter
|
||||
|
||||
Evaluate Key/Value pairs for the entity
|
||||
==============================
|
||||
*/
|
||||
char *Dmc_ParseTeleporter( char *buffer, dmc_tele_t *pTele, int *error )
|
||||
{
|
||||
char key[256];
|
||||
char token[ 1024 ];
|
||||
int n;
|
||||
|
||||
memset( pTele, 0, sizeof( *pTele ) );
|
||||
|
||||
while (1)
|
||||
{
|
||||
// Parse key
|
||||
buffer = gEngfuncs.COM_ParseFile ( buffer, token );
|
||||
if ( token[0] == '}' )
|
||||
break;
|
||||
|
||||
// Ran out of input buffer?
|
||||
if ( !buffer )
|
||||
{
|
||||
*error = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
// Store off the key
|
||||
strcpy ( key, token );
|
||||
|
||||
// Fix heynames with trailing spaces
|
||||
n = strlen( key );
|
||||
while (n && key[n-1] == ' ')
|
||||
{
|
||||
key[n-1] = 0;
|
||||
n--;
|
||||
}
|
||||
|
||||
// Parse value
|
||||
buffer = gEngfuncs.COM_ParseFile ( buffer, token );
|
||||
|
||||
// Ran out of buffer?
|
||||
if (!buffer)
|
||||
{
|
||||
*error = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
// Hit the end instead of a value?
|
||||
if ( token[0] == '}' )
|
||||
{
|
||||
*error = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
if ( token[0] == '}' && token[1] == '(' )
|
||||
int k = 0;
|
||||
|
||||
// Assign k/v pair
|
||||
Dmc_SetKeyValue( pTele, key, token );
|
||||
}
|
||||
|
||||
// Return what's left in the stream
|
||||
return buffer;
|
||||
}
|
||||
|
||||
/*
|
||||
==============================
|
||||
Dmc_ProcessEnts
|
||||
|
||||
Parse through entity lump looking for teleporters or targets
|
||||
==============================
|
||||
*/
|
||||
void Dmc_ProcessEnts( char *buffer )
|
||||
{
|
||||
char token[ 1024 ];
|
||||
dmc_tele_t *pTele = NULL;
|
||||
int error = 0;
|
||||
|
||||
// parse entities from entity lump of .bsp file
|
||||
while ( 1 )
|
||||
{
|
||||
// parse the opening brace
|
||||
buffer = gEngfuncs.COM_ParseFile ( buffer, token );
|
||||
if (!buffer)
|
||||
break;
|
||||
|
||||
// Didn't find opening brace?
|
||||
if ( token[0] != '{' )
|
||||
{
|
||||
gEngfuncs.Con_Printf ("Dmc_ProcessEnts: found %s when expecting {\n", token );
|
||||
return;
|
||||
}
|
||||
|
||||
// Assume we're filling in this tele
|
||||
pTele = &s_teles[ s_num_teles ];
|
||||
|
||||
// Fill in data
|
||||
buffer = Dmc_ParseTeleporter( buffer, pTele, &error );
|
||||
|
||||
// Check for errors and abort if any
|
||||
if ( error )
|
||||
{
|
||||
gEngfuncs.Con_Printf ("Dmc_ProcessEnts: error parsing entities\n" );
|
||||
return;
|
||||
}
|
||||
|
||||
// Check classname
|
||||
if ( stricmp( pTele->classname, "trigger_teleport" ) && stricmp( pTele->classname, "info_teleport_destination" ) )
|
||||
continue;
|
||||
|
||||
// Set type based on classname
|
||||
if ( !stricmp( pTele->classname, "trigger_teleport" ) )
|
||||
{
|
||||
pTele->type = DMC_TELE;
|
||||
}
|
||||
else
|
||||
{
|
||||
pTele->type = DMC_TARGET;
|
||||
}
|
||||
|
||||
// If we got to here, we're using the entity
|
||||
s_num_teles++;
|
||||
|
||||
// No more room...
|
||||
if ( s_num_teles >= MAX_TELES )
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
==============================
|
||||
Dmc_LoadEntityLump
|
||||
|
||||
Open the .bsp and read in the entity lump
|
||||
==============================
|
||||
*/
|
||||
char *Dmc_LoadEntityLump( const char *filename )
|
||||
{
|
||||
FileHandle_t fp;
|
||||
int i;
|
||||
dheader_t header;
|
||||
int size;
|
||||
lump_t *curLump;
|
||||
char *buffer = NULL;
|
||||
|
||||
fp = g_pFileSystem->Open( filename, "rb" );
|
||||
if ( !fp )
|
||||
return NULL;
|
||||
|
||||
// Read in the .bsp header
|
||||
if ( g_pFileSystem->Read(&header, sizeof(dheader_t), fp) != sizeof(dheader_t) )
|
||||
{
|
||||
gEngfuncs.Con_Printf("Dmc_LoadEntityLump: Could not read BSP header for map [%s].\n", filename);
|
||||
g_pFileSystem->Close(fp);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Check the version
|
||||
i = header.version;
|
||||
if ( i != 29 && i != 30)
|
||||
{
|
||||
g_pFileSystem->Close(fp);
|
||||
gEngfuncs.Con_Printf("Dmc_LoadEntityLump: Map [%s] has incorrect BSP version (%i should be %i).\n", filename, i, BSPVERSION);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Get entity lump
|
||||
curLump = &header.lumps[ LUMP_ENTITIES ];
|
||||
// and entity lump size
|
||||
size = curLump->filelen;
|
||||
|
||||
// Jump to it
|
||||
g_pFileSystem->Seek( fp, curLump->fileofs, FILESYSTEM_SEEK_HEAD );
|
||||
|
||||
// Allocate sufficient memmory
|
||||
buffer = (char *)malloc( size + 1 );
|
||||
if ( !buffer )
|
||||
{
|
||||
g_pFileSystem->Close(fp);
|
||||
gEngfuncs.Con_Printf("Dmc_LoadEntityLump: Couldn't allocate %i bytes\n", size + 1 );
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Read in the entity lump
|
||||
g_pFileSystem->Read( buffer, size, fp );
|
||||
|
||||
// Terminate the string
|
||||
buffer[ size ] = '\0';
|
||||
|
||||
if ( fp )
|
||||
{
|
||||
g_pFileSystem->Close(fp);
|
||||
}
|
||||
|
||||
return buffer;
|
||||
}
|
||||
|
||||
/*
|
||||
==============================
|
||||
Dmc_LoadTeleporters
|
||||
|
||||
Load in the .bsp file and process the entities
|
||||
==============================
|
||||
*/
|
||||
void Dmc_LoadTeleporters( const char *map )
|
||||
{
|
||||
char *buffer = NULL;
|
||||
char filename[ 256 ];
|
||||
|
||||
sprintf( filename, "%s", map );
|
||||
|
||||
// TODO: Fix Slashes?
|
||||
|
||||
// Reset count
|
||||
s_num_teles = 0;
|
||||
|
||||
// Load entity lump
|
||||
buffer = Dmc_LoadEntityLump( filename );
|
||||
if ( !buffer )
|
||||
return;
|
||||
|
||||
// Process buffer and extract teleporters/targets
|
||||
Dmc_ProcessEnts( buffer );
|
||||
|
||||
// Discard buffer
|
||||
free( buffer );
|
||||
}
|
||||
|
||||
/*
|
||||
==============================
|
||||
Dmc_FindTarget
|
||||
|
||||
Search entity list for target matching "name"
|
||||
==============================
|
||||
*/
|
||||
dmc_tele_t *Dmc_FindTarget( const char *name, int numtele, dmc_tele_t *pTeles )
|
||||
{
|
||||
int i;
|
||||
dmc_tele_t *target;
|
||||
|
||||
// Find the target
|
||||
for ( i = 0; i < numtele; i++ )
|
||||
{
|
||||
target = &pTeles[ i ];
|
||||
|
||||
if ( !target )
|
||||
continue;
|
||||
|
||||
if ( stricmp( target->targetname, name ) )
|
||||
continue;
|
||||
|
||||
return target;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
==============================
|
||||
Dmc_TeleporterTouched
|
||||
|
||||
Imparts the desired velocity to the player
|
||||
after touching a teleporter.
|
||||
==============================
|
||||
*/
|
||||
void Dmc_TeleporterTouched( int numtele, dmc_tele_t *pTeles, dmc_tele_t *pTele, struct local_state_s *player )
|
||||
{
|
||||
int i;
|
||||
dmc_tele_t *target;
|
||||
pmtrace_t tr;
|
||||
float flGravity = pmove->movevars->gravity;
|
||||
|
||||
vec3_t forward, up, right;
|
||||
|
||||
float zero[ 3 ] = { 0.0, 0.0, 0.0 };
|
||||
|
||||
// Find the target
|
||||
target = Dmc_FindTarget( pTele->target, numtele, pTeles );
|
||||
|
||||
for ( i = 0; i < 3; i++ )
|
||||
player->playerstate.origin[ i ] = target->origin[ i ];
|
||||
|
||||
player->playerstate.origin[ 2 ] += 27;
|
||||
|
||||
AngleVectors( target->angles, forward, right, up );
|
||||
player->client.velocity = forward * 300;
|
||||
|
||||
// Play sound if appropriate
|
||||
if ( s_usTeleport && g_runfuncs )
|
||||
{
|
||||
//Adrian - This is a little hack to make the player face
|
||||
//the destination angles as soon as we step out.
|
||||
//Check view.cpp for the rest.
|
||||
for ( i = 0; i < 3; i++ )
|
||||
vecTempAngles[ i ] = target->angles[ i ];
|
||||
|
||||
bChangeAngles = true;
|
||||
|
||||
gEngfuncs.pfnPlaybackEvent( FEV_NOTHOST, NULL, s_usTeleport, 0.0, target->origin, zero, 0.0, 0.0, 0, 0, 0, 0 );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
==============================
|
||||
Dmc_TouchTeleporters
|
||||
|
||||
See if player is touching a teleporter ( not that kind of touching! ).
|
||||
==============================
|
||||
*/
|
||||
void Dmc_TouchTeleporters ( struct local_state_s *player, dmc_tele_t *pTeles, int numtele )
|
||||
{
|
||||
int i, j;
|
||||
dmc_tele_t *pTele;
|
||||
float absmin[3], absmax[3];
|
||||
float pmins[ 3 ] = { 13, 13, 24 };
|
||||
float pmaxs[ 3 ] = { 13, 13, 32 };
|
||||
vec3_t LengthVector;
|
||||
int iTeleNum = 0;
|
||||
|
||||
|
||||
// Determine player's bbox
|
||||
for ( j = 0; j < 3; j++ )
|
||||
{
|
||||
absmin[ j ] = player->playerstate.origin[ j ] - pmins[ j ];
|
||||
absmax[ j ] = player->playerstate.origin[ j ] + pmaxs[ j ];
|
||||
}
|
||||
|
||||
for ( i = 0; i < numtele; i++ )
|
||||
{
|
||||
pTele = &pTeles[ i ];
|
||||
if ( !pTele )
|
||||
continue;
|
||||
|
||||
if ( pTele->type != DMC_TELE )
|
||||
continue;
|
||||
|
||||
//Adrian - Load all the teleporter Mins and Max size.
|
||||
//This comes via an event when the player connects.
|
||||
if ( !g_bLoadedTeles )
|
||||
{
|
||||
for ( int j = 0; j < 3; j++ )
|
||||
{
|
||||
pTele->absmin[ j ] = g_vecTeleMins[ iTeleNum ][ j ] - 1.0;
|
||||
pTele->absmax[ j ] = g_vecTeleMaxs[ iTeleNum ][ j ] + 1.0;
|
||||
}
|
||||
iTeleNum++;
|
||||
|
||||
//Done going thru all the teleporters
|
||||
if ( iTeleNum == g_iTeleNum )
|
||||
g_bLoadedTeles = true;
|
||||
}
|
||||
|
||||
if ( absmin[0] > pTele->absmax[0]
|
||||
|| absmin[1] > pTele->absmax[1]
|
||||
|| absmin[2] > pTele->absmax[2]
|
||||
|| absmax[0] < pTele->absmin[0]
|
||||
|| absmax[1] < pTele->absmin[1]
|
||||
|| absmax[2] < pTele->absmin[2] )
|
||||
continue;
|
||||
|
||||
Dmc_TeleporterTouched( numtele, pTeles, pTele, player );
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
==============================
|
||||
Dmc_CheckTeleporters
|
||||
|
||||
Load data if needed, otherwise just run checks on player's final position to see if teleporter needs
|
||||
to impart velocity on the player.
|
||||
==============================
|
||||
*/
|
||||
void Dmc_CheckTeleporters( struct local_state_s *from, struct local_state_s *to )
|
||||
{
|
||||
static char current_level[ 128 ];
|
||||
|
||||
// See if we've changed to a new map
|
||||
if ( stricmp( current_level, gEngfuncs.pfnGetLevelName() ) )
|
||||
{
|
||||
strcpy( current_level, gEngfuncs.pfnGetLevelName() );
|
||||
Dmc_LoadTeleporters( current_level );
|
||||
|
||||
// Grab sound event
|
||||
s_usTeleport = gEngfuncs.pfnPrecacheEvent( 1, "events/teleport.sc" );
|
||||
}
|
||||
|
||||
// Run test, only if we're not a spectator
|
||||
if ( g_iUser1 == OBS_NONE )
|
||||
Dmc_TouchTeleporters( to, s_teles, s_num_teles );
|
||||
}
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#if !defined( DMC_TELEPORTERS_H )
|
||||
#define DMC_TELEPORTERS_H
|
||||
#ifdef _WIN32
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
void Dmc_CheckTeleporters( struct local_state_s *from, struct local_state_s *to );
|
||||
|
||||
#endif // DMC_TELEPORTERS_H
|
||||
|
|
@ -1,117 +0,0 @@
|
|||
// CL_DLLEXPORT is the client version of dllexport. It's turned off for secure clients.
|
||||
#ifdef _WIN32
|
||||
#define CL_DLLEXPORT __declspec(dllexport)
|
||||
#else
|
||||
#define CL_DLLEXPORT __attribute__ ((visibility("default")))
|
||||
#endif
|
||||
|
||||
extern "C"
|
||||
{
|
||||
// From hl_weapons
|
||||
void CL_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 );
|
||||
|
||||
// From cdll_int
|
||||
int CL_DLLEXPORT Initialize( cl_enginefunc_t *pEnginefuncs, int iVersion );
|
||||
int CL_DLLEXPORT HUD_VidInit( void );
|
||||
void CL_DLLEXPORT HUD_Init( void );
|
||||
int CL_DLLEXPORT HUD_Redraw( float flTime, int intermission );
|
||||
int CL_DLLEXPORT HUD_UpdateClientData( client_data_t *cdata, float flTime );
|
||||
void CL_DLLEXPORT HUD_Reset ( void );
|
||||
void CL_DLLEXPORT HUD_PlayerMove( struct playermove_s *ppmove, int server );
|
||||
void CL_DLLEXPORT HUD_PlayerMoveInit( struct playermove_s *ppmove );
|
||||
char CL_DLLEXPORT HUD_PlayerMoveTexture( char *name );
|
||||
int CL_DLLEXPORT HUD_ConnectionlessPacket( const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size );
|
||||
int CL_DLLEXPORT HUD_GetHullBounds( int hullnumber, float *mins, float *maxs );
|
||||
void CL_DLLEXPORT HUD_Frame( double time );
|
||||
void CL_DLLEXPORT HUD_VoiceStatus(int entindex, qboolean bTalking);
|
||||
void CL_DLLEXPORT HUD_DirectorMessage( int iSize, void *pbuf );
|
||||
void CL_DLLEXPORT HUD_ChatInputPosition( int *x, int *y );
|
||||
|
||||
// From demo
|
||||
void CL_DLLEXPORT Demo_ReadBuffer( int size, unsigned char *buffer );
|
||||
|
||||
// From entity
|
||||
int CL_DLLEXPORT HUD_AddEntity( int type, struct cl_entity_s *ent, const char *modelname );
|
||||
void CL_DLLEXPORT HUD_CreateEntities( void );
|
||||
void CL_DLLEXPORT HUD_StudioEvent( const struct mstudioevent_s *event, const struct cl_entity_s *entity );
|
||||
void CL_DLLEXPORT HUD_TxferLocalOverrides( struct entity_state_s *state, const struct clientdata_s *client );
|
||||
void CL_DLLEXPORT HUD_ProcessPlayerState( struct entity_state_s *dst, const struct entity_state_s *src );
|
||||
void CL_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 CL_DLLEXPORT HUD_TempEntUpdate( double frametime, double client_time, double cl_gravity, struct tempent_s **ppTempEntFree, struct tempent_s **ppTempEntActive, int ( *Callback_AddVisibleEntity )( struct cl_entity_s *pEntity ), void ( *Callback_TempEntPlaySound )( struct tempent_s *pTemp, float damp ) );
|
||||
struct cl_entity_s CL_DLLEXPORT *HUD_GetUserEntity( int index );
|
||||
|
||||
// From in_camera
|
||||
void CL_DLLEXPORT CAM_Think( void );
|
||||
int CL_DLLEXPORT CL_IsThirdPerson( void );
|
||||
void CL_DLLEXPORT CL_CameraOffset( float *ofs );
|
||||
|
||||
// From input
|
||||
struct kbutton_s CL_DLLEXPORT *KB_Find( const char *name );
|
||||
void CL_DLLEXPORT CL_CreateMove ( float frametime, struct usercmd_s *cmd, int active );
|
||||
void CL_DLLEXPORT HUD_Shutdown( void );
|
||||
int CL_DLLEXPORT HUD_Key_Event( int eventcode, int keynum, const char *pszCurrentBinding );
|
||||
|
||||
// From inputw32
|
||||
void CL_DLLEXPORT IN_ActivateMouse( void );
|
||||
void CL_DLLEXPORT IN_DeactivateMouse( void );
|
||||
void CL_DLLEXPORT IN_MouseEvent (int mstate);
|
||||
void CL_DLLEXPORT IN_Accumulate (void);
|
||||
void CL_DLLEXPORT IN_ClearStates (void);
|
||||
|
||||
// From tri
|
||||
void CL_DLLEXPORT HUD_DrawNormalTriangles( void );
|
||||
void CL_DLLEXPORT HUD_DrawTransparentTriangles( void );
|
||||
|
||||
// From view
|
||||
void CL_DLLEXPORT V_CalcRefdef( struct ref_params_s *pparams );
|
||||
|
||||
// From GameStudioModelRenderer
|
||||
int CL_DLLEXPORT HUD_GetStudioModelInterface( int version, struct r_studio_interface_s **ppinterface, struct engine_studio_api_s *pstudio );
|
||||
}
|
||||
|
||||
/*
|
||||
extern cldll_func_dst_t *g_pcldstAddrs;
|
||||
|
||||
// Macros for the client receiving calls from the engine
|
||||
#define RecClInitialize(a, b) (g_pcldstAddrs->pInitFunc(&a, &b))
|
||||
#define RecClHudInit() (g_pcldstAddrs->pHudInitFunc())
|
||||
#define RecClHudVidInit() (g_pcldstAddrs->pHudVidInitFunc())
|
||||
#define RecClHudRedraw(a, b) (g_pcldstAddrs->pHudRedrawFunc(&a, &b))
|
||||
#define RecClHudUpdateClientData(a, b) (g_pcldstAddrs->pHudUpdateClientDataFunc(&a, &b))
|
||||
#define RecClHudReset() (g_pcldstAddrs->pHudResetFunc())
|
||||
#define RecClClientMove(a, b) (g_pcldstAddrs->pClientMove(&a, &b))
|
||||
#define RecClClientMoveInit(a) (g_pcldstAddrs->pClientMoveInit(&a))
|
||||
#define RecClClientTextureType(a) (g_pcldstAddrs->pClientTextureType(&a))
|
||||
#define RecClIN_ActivateMouse() (g_pcldstAddrs->pIN_ActivateMouse())
|
||||
#define RecClIN_DeactivateMouse() (g_pcldstAddrs->pIN_DeactivateMouse())
|
||||
#define RecClIN_MouseEvent(a) (g_pcldstAddrs->pIN_MouseEvent(&a))
|
||||
#define RecClIN_ClearStates() (g_pcldstAddrs->pIN_ClearStates())
|
||||
#define RecClIN_Accumulate() (g_pcldstAddrs->pIN_Accumulate())
|
||||
#define RecClCL_CreateMove(a, b, c) (g_pcldstAddrs->pCL_CreateMove(&a, &b, &c))
|
||||
#define RecClCL_IsThirdPerson() (g_pcldstAddrs->pCL_IsThirdPerson())
|
||||
#define RecClCL_GetCameraOffsets(a) (g_pcldstAddrs->pCL_GetCameraOffsets(&a))
|
||||
#define RecClFindKey(a) (g_pcldstAddrs->pFindKey(&a))
|
||||
#define RecClCamThink() (g_pcldstAddrs->pCamThink())
|
||||
#define RecClCalcRefdef(a) (g_pcldstAddrs->pCalcRefdef(&a))
|
||||
#define RecClAddEntity(a, b, c) (g_pcldstAddrs->pAddEntity(&a, &b, &c))
|
||||
#define RecClCreateEntities() (g_pcldstAddrs->pCreateEntities())
|
||||
#define RecClDrawNormalTriangles() (g_pcldstAddrs->pDrawNormalTriangles())
|
||||
#define RecClDrawTransparentTriangles() (g_pcldstAddrs->pDrawTransparentTriangles())
|
||||
#define RecClStudioEvent(a, b) (g_pcldstAddrs->pStudioEvent(&a, &b))
|
||||
#define RecClPostRunCmd(a, b, c, d, e, f) (g_pcldstAddrs->pPostRunCmd(&a, &b, &c, &d, &e, &f))
|
||||
#define RecClShutdown() (g_pcldstAddrs->pShutdown())
|
||||
#define RecClTxferLocalOverrides(a, b) (g_pcldstAddrs->pTxferLocalOverrides(&a, &b))
|
||||
#define RecClProcessPlayerState(a, b) (g_pcldstAddrs->pProcessPlayerState(&a, &b))
|
||||
#define RecClTxferPredictionData(a, b, c, d, e, f) (g_pcldstAddrs->pTxferPredictionData(&a, &b, &c, &d, &e, &f))
|
||||
#define RecClReadDemoBuffer(a, b) (g_pcldstAddrs->pReadDemoBuffer(&a, &b))
|
||||
#define RecClConnectionlessPacket(a, b, c, d) (g_pcldstAddrs->pConnectionlessPacket(&a, &b, &c, &d))
|
||||
#define RecClGetHullBounds(a, b, c) (g_pcldstAddrs->pGetHullBounds(&a, &b, &c))
|
||||
#define RecClHudFrame(a) (g_pcldstAddrs->pHudFrame(&a))
|
||||
#define RecClKeyEvent(a, b, c) (g_pcldstAddrs->pKeyEvent(&a, &b, &c))
|
||||
#define RecClTempEntUpdate(a, b, c, d, e, f, g) (g_pcldstAddrs->pTempEntUpdate(&a, &b, &c, &d, &e, &f, &g))
|
||||
#define RecClGetUserEntity(a) (g_pcldstAddrs->pGetUserEntity(&a))
|
||||
#define RecClVoiceStatus(a, b) (g_pcldstAddrs->pVoiceStatus(&a, &b))
|
||||
#define RecClDirectorMessage(a, b) (g_pcldstAddrs->pDirectorMessage(&a, &b))
|
||||
#define RecClStudioInterface(a, b, c) (g_pcldstAddrs->pStudioInterface(&a, &b, &c))
|
||||
#define RecClChatInputPosition(a, b) (g_pcldstAddrs->pChatInputPosition(&a, &b))
|
||||
*/
|
||||
|
|
@ -1,119 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#include <assert.h>
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "const.h"
|
||||
#include "com_model.h"
|
||||
#include "studio.h"
|
||||
#include "entity_state.h"
|
||||
#include "cl_entity.h"
|
||||
#include "dlight.h"
|
||||
#include "triangleapi.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <memory.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "studio_util.h"
|
||||
#include "r_studioint.h"
|
||||
|
||||
#include "StudioModelRenderer.h"
|
||||
#include "GameStudioModelRenderer.h"
|
||||
|
||||
//
|
||||
// Override the StudioModelRender virtual member functions here to implement custom bone
|
||||
// setup, blending, etc.
|
||||
//
|
||||
|
||||
// Global engine <-> studio model rendering code interface
|
||||
extern engine_studio_api_t IEngineStudio;
|
||||
|
||||
// The renderer object, created on the stack.
|
||||
CGameStudioModelRenderer g_StudioRenderer;
|
||||
|
||||
/*
|
||||
====================
|
||||
CGameStudioModelRenderer
|
||||
|
||||
====================
|
||||
*/
|
||||
CGameStudioModelRenderer::CGameStudioModelRenderer( void )
|
||||
{
|
||||
}
|
||||
|
||||
////////////////////////////////////
|
||||
// Hooks to class implementation
|
||||
////////////////////////////////////
|
||||
|
||||
/*
|
||||
====================
|
||||
R_StudioDrawPlayer
|
||||
|
||||
====================
|
||||
*/
|
||||
int R_StudioDrawPlayer( int flags, entity_state_t *pplayer )
|
||||
{
|
||||
return g_StudioRenderer.StudioDrawPlayer( flags, pplayer );
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
R_StudioDrawModel
|
||||
|
||||
====================
|
||||
*/
|
||||
int R_StudioDrawModel( int flags )
|
||||
{
|
||||
return g_StudioRenderer.StudioDrawModel( flags );
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
R_StudioInit
|
||||
|
||||
====================
|
||||
*/
|
||||
void R_StudioInit( void )
|
||||
{
|
||||
g_StudioRenderer.Init();
|
||||
}
|
||||
|
||||
// The simple drawing interface we'll pass back to the engine
|
||||
r_studio_interface_t studio =
|
||||
{
|
||||
STUDIO_INTERFACE_VERSION,
|
||||
R_StudioDrawModel,
|
||||
R_StudioDrawPlayer,
|
||||
};
|
||||
|
||||
/*
|
||||
====================
|
||||
HUD_GetStudioModelInterface
|
||||
|
||||
Export this function for the engine to use the studio renderer class to render objects.
|
||||
====================
|
||||
*/
|
||||
extern "C" int EXPORT HUD_GetStudioModelInterface( int version, struct r_studio_interface_s **ppinterface, struct engine_studio_api_s *pstudio )
|
||||
{
|
||||
if ( version != STUDIO_INTERFACE_VERSION )
|
||||
return 0;
|
||||
|
||||
// Point the engine to our callbacks
|
||||
*ppinterface = &studio;
|
||||
|
||||
// Copy in engine helper functions
|
||||
memcpy( &IEngineStudio, pstudio, sizeof( IEngineStudio ) );
|
||||
|
||||
// Initialize local variables, etc.
|
||||
R_StudioInit();
|
||||
|
||||
// Success
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -1,26 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#if !defined( GAMESTUDIOMODELRENDERER_H )
|
||||
#define GAMESTUDIOMODELRENDERER_H
|
||||
#if defined( _WIN32 )
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
/*
|
||||
====================
|
||||
CGameStudioModelRenderer
|
||||
|
||||
====================
|
||||
*/
|
||||
class CGameStudioModelRenderer : public CStudioModelRenderer
|
||||
{
|
||||
public:
|
||||
CGameStudioModelRenderer( void );
|
||||
};
|
||||
|
||||
#endif // GAMESTUDIOMODELRENDERER_H
|
||||
|
|
@ -1,155 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// MOTD.cpp
|
||||
//
|
||||
// for displaying a server-sent message of the day
|
||||
//
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "parsemsg.h"
|
||||
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
DECLARE_MESSAGE( m_MOTD, MOTD );
|
||||
|
||||
int CHudMOTD::MOTD_DISPLAY_TIME;
|
||||
|
||||
int CHudMOTD :: Init( void )
|
||||
{
|
||||
gHUD.AddHudElem( this );
|
||||
|
||||
HOOK_MESSAGE( MOTD );
|
||||
|
||||
CVAR_CREATE( "motd_display_time", "15", 0 );
|
||||
|
||||
m_iFlags &= ~HUD_ACTIVE; // start out inactive
|
||||
m_szMOTD[0] = 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudMOTD :: VidInit( void )
|
||||
{
|
||||
// Load sprites here
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void CHudMOTD :: Reset( void )
|
||||
{
|
||||
m_iFlags &= ~HUD_ACTIVE; // start out inactive
|
||||
m_szMOTD[0] = 0;
|
||||
m_iLines = 0;
|
||||
m_flActiveRemaining = 0;
|
||||
}
|
||||
|
||||
#define LINE_HEIGHT 13
|
||||
|
||||
int CHudMOTD :: Draw( float fTime )
|
||||
{
|
||||
static float sfLastTime;
|
||||
float fElapsed;
|
||||
|
||||
// Draw MOTD line-by-line
|
||||
if ( m_flActiveRemaining <= 0.0 )
|
||||
{
|
||||
// finished with MOTD, disable it
|
||||
m_szMOTD[0] = 0;
|
||||
m_iLines = 0;
|
||||
m_iFlags &= ~HUD_ACTIVE;
|
||||
m_flActiveRemaining = 0.0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
fElapsed = gHUD.m_flTime - sfLastTime;
|
||||
|
||||
// Don't let time go negative ( level transition? )
|
||||
fElapsed = max( 0.0, fElapsed );
|
||||
// Don't let time go hugely positive ( first connection to active server ? )
|
||||
fElapsed = min( 1.0, fElapsed );
|
||||
|
||||
// Remember last timestamp
|
||||
sfLastTime = gHUD.m_flTime;
|
||||
|
||||
// Remove a bit of time
|
||||
m_flActiveRemaining -= fElapsed;
|
||||
|
||||
// find the top of where the MOTD should be drawn, so the whole thing is centered in the screen
|
||||
int ypos = max(((ScreenHeight - (m_iLines * LINE_HEIGHT)) / 2) - 40, 30 ); // shift it up slightly
|
||||
char *ch = m_szMOTD;
|
||||
while ( *ch )
|
||||
{
|
||||
int line_length = 0; // count the length of the current line
|
||||
for ( char *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' )
|
||||
*top = 0;
|
||||
else
|
||||
top = NULL;
|
||||
|
||||
// find where to start drawing the line
|
||||
int xpos = (ScreenWidth - line_length) / 2;
|
||||
|
||||
gHUD.DrawHudString( xpos, ypos, ScreenWidth, ch, 255, 180, 0 );
|
||||
|
||||
ypos += LINE_HEIGHT;
|
||||
|
||||
if ( top ) // restore
|
||||
*top = '\n';
|
||||
ch = next_line;
|
||||
if ( *ch == '\n' )
|
||||
ch++;
|
||||
|
||||
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 )
|
||||
{
|
||||
if ( m_iFlags & HUD_ACTIVE )
|
||||
{
|
||||
Reset(); // clear the current MOTD in prep for this one
|
||||
}
|
||||
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
int is_finished = READ_BYTE();
|
||||
strcat( m_szMOTD, READ_STRING() );
|
||||
|
||||
if ( is_finished )
|
||||
{
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
|
||||
MOTD_DISPLAY_TIME = max( 10, CVAR_GET_FLOAT( "motd_display_time" ) );
|
||||
|
||||
m_flActiveRemaining = MOTD_DISPLAY_TIME;
|
||||
|
||||
for ( char *sz = m_szMOTD; *sz != 0; sz++ ) // count the number of lines in the MOTD
|
||||
{
|
||||
if ( *sz == '\n' )
|
||||
m_iLines++;
|
||||
}
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,189 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#if !defined ( STUDIOMODELRENDERER_H )
|
||||
#define STUDIOMODELRENDERER_H
|
||||
#if defined( _WIN32 )
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
/*
|
||||
====================
|
||||
CStudioModelRenderer
|
||||
|
||||
====================
|
||||
*/
|
||||
class CStudioModelRenderer
|
||||
{
|
||||
public:
|
||||
// Construction/Destruction
|
||||
CStudioModelRenderer( void );
|
||||
virtual ~CStudioModelRenderer( void );
|
||||
|
||||
// Initialization
|
||||
virtual void Init( void );
|
||||
|
||||
public:
|
||||
// Public Interfaces
|
||||
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 );
|
||||
|
||||
// Interpolate model position and angles and set up matrices
|
||||
virtual void StudioSetUpTransform (int trivial_accept);
|
||||
|
||||
// Set up model bone positions
|
||||
virtual void StudioSetupBones ( void );
|
||||
|
||||
// Find final attachment points
|
||||
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 );
|
||||
|
||||
// Determine interpolation fraction
|
||||
virtual float StudioEstimateInterpolant( void );
|
||||
|
||||
// Determine current frame for rendering
|
||||
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 );
|
||||
|
||||
// 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 );
|
||||
|
||||
// Get bone positions
|
||||
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 );
|
||||
|
||||
// Send bones and verts to renderer
|
||||
virtual void StudioRenderModel ( void );
|
||||
|
||||
// Finalize rendering
|
||||
virtual void StudioRenderFinal (void);
|
||||
|
||||
// GL&D3D vs. Software renderer finishing functions
|
||||
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 );
|
||||
|
||||
// Estimate gait frame for player
|
||||
virtual void StudioEstimateGait ( entity_state_t *pplayer );
|
||||
|
||||
// Process movement of player
|
||||
virtual void StudioProcessGait ( entity_state_t *pplayer );
|
||||
|
||||
public:
|
||||
|
||||
// Client clock
|
||||
double m_clTime;
|
||||
// Old Client clock
|
||||
double m_clOldTime;
|
||||
|
||||
// Do interpolation?
|
||||
int m_fDoInterp;
|
||||
// Do gait estimation?
|
||||
int m_fGaitEstimation;
|
||||
|
||||
// Current render frame #
|
||||
int m_nFrameCount;
|
||||
|
||||
// Cvars that studio model code needs to reference
|
||||
//
|
||||
// Use high quality models?
|
||||
cvar_t *m_pCvarHiModels;
|
||||
// Developer debug output desired?
|
||||
cvar_t *m_pCvarDeveloper;
|
||||
// Draw entities bone hit boxes, etc?
|
||||
cvar_t *m_pCvarDrawEntities;
|
||||
|
||||
// The entity which we are currently rendering.
|
||||
cl_entity_t *m_pCurrentEntity;
|
||||
|
||||
// The model for the entity being rendered
|
||||
model_t *m_pRenderModel;
|
||||
|
||||
// Player info for current player, if drawing a player
|
||||
player_info_t *m_pPlayerInfo;
|
||||
|
||||
// The index of the player being drawn
|
||||
int m_nPlayerIndex;
|
||||
|
||||
// The player's gait movement
|
||||
float m_flGaitMovement;
|
||||
|
||||
// Pointer to header block for studio model data
|
||||
studiohdr_t *m_pStudioHeader;
|
||||
|
||||
// Pointers to current body part and submodel
|
||||
mstudiobodyparts_t *m_pBodyPart;
|
||||
mstudiomodel_t *m_pSubModel;
|
||||
|
||||
// Palette substition for top and bottom of model
|
||||
int m_nTopColor;
|
||||
int m_nBottomColor;
|
||||
|
||||
//
|
||||
// Sprite model used for drawing studio model chrome
|
||||
model_t *m_pChromeSprite;
|
||||
|
||||
// Caching
|
||||
// Number of bones in bone cache
|
||||
int m_nCachedBones;
|
||||
// Names of cached bones
|
||||
char m_nCachedBoneNames[ MAXSTUDIOBONES ][ 32 ];
|
||||
// Cached bone & light transformation matrices
|
||||
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_vRenderOrigin[ 3 ];
|
||||
|
||||
// Model render counters ( from engine )
|
||||
int *m_pStudioModelCount;
|
||||
int *m_pModelsDrawn;
|
||||
|
||||
// Matrices
|
||||
// Model to world transformation
|
||||
float (*m_protationmatrix)[ 3 ][ 4 ];
|
||||
// Model to view transformation
|
||||
float (*m_paliastransform)[ 3 ][ 4 ];
|
||||
|
||||
// Concatenated bone and light transforms
|
||||
float (*m_pbonetransform) [ MAXSTUDIOBONES ][ 3 ][ 4 ];
|
||||
float (*m_plighttransform)[ MAXSTUDIOBONES ][ 3 ][ 4 ];
|
||||
};
|
||||
|
||||
#endif // STUDIOMODELRENDERER_H
|
||||
1131
dmc/cl_dll/ammo.cpp
1131
dmc/cl_dll/ammo.cpp
File diff suppressed because it is too large
Load Diff
|
|
@ -1,62 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
|
||||
#ifndef __AMMO_H__
|
||||
#define __AMMO_H__
|
||||
|
||||
#define MAX_WEAPON_NAME 128
|
||||
|
||||
|
||||
#define WEAPON_FLAGS_SELECTONEMPTY 1
|
||||
|
||||
#define WEAPON_IS_ONTARGET 0x40
|
||||
|
||||
struct WEAPON
|
||||
{
|
||||
char szName[MAX_WEAPON_NAME];
|
||||
int iAmmoType;
|
||||
int iAmmo2Type;
|
||||
int iMax1;
|
||||
int iMax2;
|
||||
int iSlot;
|
||||
int iSlotPos;
|
||||
int iFlags;
|
||||
int iId;
|
||||
int iClip;
|
||||
|
||||
int iCount; // # of itesm in plist
|
||||
|
||||
HSPRITE hActive;
|
||||
wrect_t rcActive;
|
||||
HSPRITE hInactive;
|
||||
wrect_t rcInactive;
|
||||
HSPRITE hAmmo;
|
||||
wrect_t rcAmmo;
|
||||
HSPRITE hAmmo2;
|
||||
wrect_t rcAmmo2;
|
||||
HSPRITE hCrosshair;
|
||||
wrect_t rcCrosshair;
|
||||
HSPRITE hAutoaim;
|
||||
wrect_t rcAutoaim;
|
||||
HSPRITE hZoomedCrosshair;
|
||||
wrect_t rcZoomedCrosshair;
|
||||
HSPRITE hZoomedAutoaim;
|
||||
wrect_t rcZoomedAutoaim;
|
||||
};
|
||||
|
||||
typedef int AMMO;
|
||||
|
||||
|
||||
#endif
|
||||
|
|
@ -1,159 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// ammo_secondary.cpp
|
||||
//
|
||||
// implementation of CHudAmmoSecondary class
|
||||
//
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include "parsemsg.h"
|
||||
|
||||
DECLARE_MESSAGE( m_AmmoSecondary, SecAmmoVal );
|
||||
DECLARE_MESSAGE( m_AmmoSecondary, SecAmmoIcon );
|
||||
|
||||
int CHudAmmoSecondary :: Init( void )
|
||||
{
|
||||
HOOK_MESSAGE( SecAmmoVal );
|
||||
HOOK_MESSAGE( SecAmmoIcon );
|
||||
|
||||
gHUD.AddHudElem(this);
|
||||
m_HUD_ammoicon = 0;
|
||||
|
||||
for ( int i = 0; i < MAX_SEC_AMMO_VALUES; i++ )
|
||||
m_iAmmoAmounts[i] = -1; // -1 means don't draw this value
|
||||
|
||||
Reset();
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void CHudAmmoSecondary :: Reset( void )
|
||||
{
|
||||
m_fFade = 0;
|
||||
}
|
||||
|
||||
int CHudAmmoSecondary :: VidInit( void )
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudAmmoSecondary :: Draw(float flTime)
|
||||
{
|
||||
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
|
||||
ScaleColors( r, g, b, a );
|
||||
|
||||
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
|
||||
x = ScreenWidth - AmmoWidth;
|
||||
|
||||
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);
|
||||
|
||||
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
|
||||
x -= AmmoWidth;
|
||||
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-- )
|
||||
{
|
||||
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);
|
||||
|
||||
// draw the number, right-aligned
|
||||
x -= (gHUD.GetNumWidth( m_iAmmoAmounts[i], DHN_DRAWZERO ) * AmmoWidth);
|
||||
gHUD.DrawHudNumber( x, y, DHN_DRAWZERO, m_iAmmoAmounts[i], r, g, b );
|
||||
|
||||
if ( i != 0 )
|
||||
{
|
||||
// draw the divider bar
|
||||
x -= (AmmoWidth / 2);
|
||||
FillRGBA(x, y, (AmmoWidth/10), gHUD.m_iFontHeight, r, g, b, a);
|
||||
}
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Message handler for Secondary Ammo Value
|
||||
// accepts one value:
|
||||
// string: sprite name
|
||||
int CHudAmmoSecondary :: MsgFunc_SecAmmoIcon( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
m_HUD_ammoicon = gHUD.GetSpriteIndex( READ_STRING() );
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Message handler for Secondary Ammo Icon
|
||||
// Sets an ammo value
|
||||
// takes two values:
|
||||
// byte: ammo index
|
||||
// byte: ammo value
|
||||
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 )
|
||||
return 1;
|
||||
|
||||
m_iAmmoAmounts[index] = READ_BYTE();
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
|
||||
// check to see if there is anything left to draw
|
||||
int count = 0;
|
||||
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
|
||||
m_iFlags &= ~HUD_ACTIVE;
|
||||
return 1;
|
||||
}
|
||||
|
||||
// make the icons light up
|
||||
m_fFade = 200.0f;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1,190 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// ammohistory.cpp
|
||||
//
|
||||
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "parsemsg.h"
|
||||
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "ammohistory.h"
|
||||
|
||||
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 MAX_ITEM_NAME 32
|
||||
int HISTORY_DRAW_TIME = 5;
|
||||
|
||||
// keep a list of items
|
||||
struct ITEM_INFO
|
||||
{
|
||||
char szName[MAX_ITEM_NAME];
|
||||
HSPRITE spr;
|
||||
wrect_t rect;
|
||||
};
|
||||
|
||||
void HistoryResource :: AddToHistory( int iType, int iId, int 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
|
||||
// so start from the bottom
|
||||
iCurrentHistorySlot = 0;
|
||||
}
|
||||
|
||||
HIST_ITEM *freeslot = &rgAmmoHistory[iCurrentHistorySlot++]; // default to just writing to the first slot
|
||||
HISTORY_DRAW_TIME = CVAR_GET_FLOAT( "hud_drawhistory_time" );
|
||||
|
||||
freeslot->type = iType;
|
||||
freeslot->iId = iId;
|
||||
freeslot->iCount = iCount;
|
||||
freeslot->DisplayTime = gHUD.m_flTime + HISTORY_DRAW_TIME;
|
||||
}
|
||||
|
||||
void HistoryResource :: AddToHistory( int iType, const char *szName, int iCount )
|
||||
{
|
||||
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
|
||||
// so start from the bottom
|
||||
iCurrentHistorySlot = 0;
|
||||
}
|
||||
|
||||
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 )
|
||||
return; // unknown sprite name, don't add it to history
|
||||
|
||||
freeslot->iId = i;
|
||||
freeslot->type = iType;
|
||||
freeslot->iCount = iCount;
|
||||
|
||||
HISTORY_DRAW_TIME = CVAR_GET_FLOAT( "hud_drawhistory_time" );
|
||||
freeslot->DisplayTime = gHUD.m_flTime + HISTORY_DRAW_TIME;
|
||||
}
|
||||
|
||||
|
||||
void HistoryResource :: CheckClearHistory( void )
|
||||
{
|
||||
for ( int i = 0; i < MAX_HISTORY; i++ )
|
||||
{
|
||||
if ( rgAmmoHistory[i].type )
|
||||
return;
|
||||
}
|
||||
|
||||
iCurrentHistorySlot = 0;
|
||||
}
|
||||
|
||||
//
|
||||
// Draw Ammo pickup history
|
||||
//
|
||||
int HistoryResource :: DrawAmmoHistory( float flTime )
|
||||
{
|
||||
for ( int i = 0; i < MAX_HISTORY; i++ )
|
||||
{
|
||||
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
|
||||
memset( &rgAmmoHistory[i], 0, sizeof(HIST_ITEM) );
|
||||
CheckClearHistory();
|
||||
}
|
||||
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) );
|
||||
|
||||
// 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
|
||||
SPR_Set( *spr, r, g, b );
|
||||
SPR_DrawAdditive( 0, xpos, ypos, &rcPic );
|
||||
}
|
||||
|
||||
// Draw the number
|
||||
gHUD.DrawHudNumberString( xpos - 10, ypos, xpos - 100, rgAmmoHistory[i].iCount, r, g, b );
|
||||
}
|
||||
else if ( rgAmmoHistory[i].type == HISTSLOT_WEAP )
|
||||
{
|
||||
WEAPON *weap = gWR.GetWeapon( rgAmmoHistory[i].iId );
|
||||
|
||||
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);
|
||||
|
||||
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) );
|
||||
|
||||
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 )
|
||||
{
|
||||
int r, g, b;
|
||||
|
||||
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) );
|
||||
|
||||
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 );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1,144 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// ammohistory.h
|
||||
//
|
||||
|
||||
// this is the max number of items in each bucket
|
||||
#define MAX_WEAPON_POSITIONS 1
|
||||
|
||||
class WeaponsResource
|
||||
{
|
||||
private:
|
||||
// Information about weapons & ammo
|
||||
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
|
||||
|
||||
public:
|
||||
void Init( void )
|
||||
{
|
||||
memset( rgWeapons, 0, sizeof rgWeapons );
|
||||
Reset();
|
||||
}
|
||||
|
||||
void Reset( void )
|
||||
{
|
||||
iOldWeaponBits = 0;
|
||||
memset( rgSlots, 0, sizeof rgSlots );
|
||||
memset( riAmmo, 0, sizeof riAmmo );
|
||||
}
|
||||
|
||||
///// WEAPON /////
|
||||
int iOldWeaponBits;
|
||||
|
||||
WEAPON *GetWeapon( int iId ) { return &rgWeapons[iId]; }
|
||||
void AddWeapon( WEAPON *wp )
|
||||
{
|
||||
rgWeapons[ wp->iId ] = *wp;
|
||||
LoadWeaponSprites( &rgWeapons[ wp->iId ] );
|
||||
}
|
||||
|
||||
void PickupWeapon( WEAPON *wp )
|
||||
{
|
||||
rgSlots[ wp->iSlot ][ 0 ] = wp;
|
||||
}
|
||||
|
||||
void DropWeapon( WEAPON *wp )
|
||||
{
|
||||
rgSlots[ wp->iSlot ][ 0 ] = NULL;
|
||||
}
|
||||
|
||||
void DropAllWeapons( void )
|
||||
{
|
||||
for ( int i = 0; i < MAX_WEAPONS; i++ )
|
||||
{
|
||||
if ( rgWeapons[i].iId )
|
||||
DropWeapon( &rgWeapons[i] );
|
||||
}
|
||||
}
|
||||
|
||||
WEAPON* GetWeaponSlot( int slot, int pos ) { return rgSlots[slot][pos]; }
|
||||
|
||||
void LoadWeaponSprites( WEAPON* wp );
|
||||
void LoadAllWeaponSprites( void );
|
||||
WEAPON* GetFirstPos( int iSlot );
|
||||
void SelectSlot( int iSlot, int fAdvance, int iDirection );
|
||||
WEAPON* GetNextActivePos( int iSlot, int iSlotPos );
|
||||
|
||||
int HasAmmo( WEAPON *p );
|
||||
|
||||
///// AMMO /////
|
||||
AMMO GetAmmo( int iId ) { return iId; }
|
||||
|
||||
void SetAmmo( int iId, int iCount ) { riAmmo[ iId ] = iCount; }
|
||||
|
||||
int CountAmmo( int iId );
|
||||
|
||||
HSPRITE* GetAmmoPicFromWeapon( int iAmmoId, wrect_t& rect );
|
||||
|
||||
};
|
||||
|
||||
extern WeaponsResource gWR;
|
||||
|
||||
|
||||
#define MAX_HISTORY 12
|
||||
enum {
|
||||
HISTSLOT_EMPTY,
|
||||
HISTSLOT_AMMO,
|
||||
HISTSLOT_WEAP,
|
||||
HISTSLOT_ITEM,
|
||||
};
|
||||
|
||||
class HistoryResource
|
||||
{
|
||||
private:
|
||||
struct HIST_ITEM {
|
||||
int type;
|
||||
float DisplayTime; // the time at which this item should be removed from the history
|
||||
int iCount;
|
||||
int iId;
|
||||
};
|
||||
|
||||
HIST_ITEM rgAmmoHistory[MAX_HISTORY];
|
||||
|
||||
public:
|
||||
|
||||
void Init( void )
|
||||
{
|
||||
Reset();
|
||||
}
|
||||
|
||||
void Reset( void )
|
||||
{
|
||||
memset( rgAmmoHistory, 0, sizeof rgAmmoHistory );
|
||||
}
|
||||
|
||||
int iHistoryGap;
|
||||
int iCurrentHistorySlot;
|
||||
|
||||
void AddToHistory( int iType, int iId, int iCount = 0 );
|
||||
void AddToHistory( int iType, const char *szName, int iCount = 0 );
|
||||
|
||||
void CheckClearHistory( void );
|
||||
int DrawAmmoHistory( float flTime );
|
||||
};
|
||||
|
||||
extern HistoryResource gHR;
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,135 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// battery.cpp
|
||||
//
|
||||
// implementation of CHudBattery class
|
||||
//
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "parsemsg.h"
|
||||
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
DECLARE_MESSAGE(m_Battery, Battery)
|
||||
|
||||
int CHudBattery::Init(void)
|
||||
{
|
||||
m_iBat = 0;
|
||||
m_fFade = 0;
|
||||
m_iFlags = 0;
|
||||
|
||||
HOOK_MESSAGE(Battery);
|
||||
|
||||
gHUD.AddHudElem(this);
|
||||
|
||||
return 1;
|
||||
};
|
||||
|
||||
|
||||
int CHudBattery::VidInit(void)
|
||||
{
|
||||
int HUD_suit_empty = gHUD.GetSpriteIndex( "suit_empty" );
|
||||
int HUD_suit_full = gHUD.GetSpriteIndex( "suit_full" );
|
||||
|
||||
m_hSprite1 = m_hSprite2 = 0; // delaying get sprite handles until we know the sprites are loaded
|
||||
m_prc1 = &gHUD.GetSpriteRect( HUD_suit_empty );
|
||||
m_prc2 = &gHUD.GetSpriteRect( HUD_suit_full );
|
||||
m_iHeight = m_prc2->bottom - m_prc1->top;
|
||||
m_fFade = 0;
|
||||
return 1;
|
||||
};
|
||||
|
||||
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)
|
||||
{
|
||||
m_fFade = FADE_TIME;
|
||||
m_iBat = x;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int CHudBattery::Draw(float flTime)
|
||||
{
|
||||
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
|
||||
|
||||
UnpackRGB(r,g,b, RGB_YELLOWISH);
|
||||
|
||||
// Has health changed? Flash the health #
|
||||
if (m_fFade)
|
||||
{
|
||||
if (m_fFade > FADE_TIME)
|
||||
m_fFade = FADE_TIME;
|
||||
|
||||
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;
|
||||
|
||||
}
|
||||
else
|
||||
a = MIN_ALPHA;
|
||||
|
||||
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;
|
||||
|
||||
// make sure we have the right sprite handles
|
||||
if ( !m_hSprite1 )
|
||||
m_hSprite1 = gHUD.GetSprite( gHUD.GetSpriteIndex( "suit_empty" ) );
|
||||
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);
|
||||
|
||||
if (rc.bottom > rc.top)
|
||||
{
|
||||
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);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
// Camera.h -- defines and such for a 3rd person camera
|
||||
// NOTE: must include quakedef.h first
|
||||
|
||||
#ifndef _CAMERA_H_
|
||||
#define _CAMERA_H_
|
||||
|
||||
// pitch, yaw, dist
|
||||
extern vec3_t cam_ofs;
|
||||
// Using third person camera
|
||||
extern int cam_thirdperson;
|
||||
|
||||
void CAM_Init( void );
|
||||
void CAM_ClearStates( void );
|
||||
void CAM_StartMouseMove(void);
|
||||
void CAM_EndMouseMove(void);
|
||||
|
||||
#endif // _CAMERA_H_
|
||||
|
|
@ -1,344 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1999, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// cdll_int.c
|
||||
//
|
||||
// this implementation handles the linking of the engine to the DLL
|
||||
//
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include <string.h>
|
||||
#include "netadr.h"
|
||||
#include "vgui_int.h"
|
||||
#include "voice_status.h"
|
||||
|
||||
#include "FileSystem.h"
|
||||
|
||||
#include "interface.h"
|
||||
#include "vgui_SchemeManager.h"
|
||||
|
||||
#ifdef _WIN32
|
||||
#include "winsani_in.h"
|
||||
#include <windows.h>
|
||||
#include "winsani_out.h"
|
||||
#endif
|
||||
|
||||
CSysModule *g_pFileSystemModule = NULL;
|
||||
IFileSystem *g_pFileSystem = NULL;
|
||||
|
||||
CSysModule *g_hTrackerModule = NULL;
|
||||
|
||||
cl_enginefunc_t gEngfuncs;
|
||||
CHud gHUD;
|
||||
TeamFortressViewport *gViewPort = NULL;
|
||||
|
||||
extern "C"
|
||||
{
|
||||
#include "pm_shared.h"
|
||||
}
|
||||
|
||||
#include "hud_servers.h"
|
||||
|
||||
void InitInput (void);
|
||||
void EV_HookEvents( void );
|
||||
void IN_Commands( void );
|
||||
|
||||
/*
|
||||
==========================
|
||||
Initialize
|
||||
|
||||
Called when the DLL is first loaded.
|
||||
==========================
|
||||
*/
|
||||
extern "C"
|
||||
{
|
||||
int EXPORT Initialize( cl_enginefunc_t *pEnginefuncs, int iVersion );
|
||||
int EXPORT HUD_VidInit( void );
|
||||
int EXPORT HUD_Init( void );
|
||||
int EXPORT HUD_Redraw( float flTime, int intermission );
|
||||
int EXPORT HUD_UpdateClientData( client_data_t *cdata, float flTime );
|
||||
int EXPORT HUD_Reset ( void );
|
||||
void EXPORT HUD_PlayerMove( struct playermove_s *ppmove, int server );
|
||||
void EXPORT HUD_PlayerMoveInit( struct playermove_s *ppmove );
|
||||
char EXPORT HUD_PlayerMoveTexture( char *name );
|
||||
int EXPORT HUD_ConnectionlessPacket( struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size );
|
||||
int EXPORT HUD_GetHullBounds( int hullnumber, float *mins, float *maxs );
|
||||
void EXPORT HUD_Frame( double time );
|
||||
void EXPORT 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 EXPORT HUD_VoiceStatus(int entindex, qboolean bTalking);
|
||||
void EXPORT HUD_DirectorMessage( int iSize, void *pbuf );
|
||||
}
|
||||
|
||||
/*
|
||||
================================
|
||||
HUD_GetHullBounds
|
||||
|
||||
Engine calls this to enumerate player collision hulls, for prediction. Return 0 if the hullnumber doesn't exist.
|
||||
================================
|
||||
*/
|
||||
int EXPORT HUD_GetHullBounds( int hullnumber, float *mins, float *maxs )
|
||||
{
|
||||
int iret = 0;
|
||||
|
||||
switch ( hullnumber )
|
||||
{
|
||||
case 0: // Normal player
|
||||
mins = Vector(-16, -16, -32);
|
||||
maxs = Vector(16, 16, 32);
|
||||
iret = 1;
|
||||
break;
|
||||
case 1: // Crouched player
|
||||
mins = Vector(-16, -16, -32);
|
||||
maxs = Vector(16, 16, 32);
|
||||
iret = 1;
|
||||
break;
|
||||
case 2: // Point based hull
|
||||
mins = Vector( 0, 0, 0 );
|
||||
maxs = Vector( 0, 0, 0 );
|
||||
iret = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
return iret;
|
||||
}
|
||||
|
||||
/*
|
||||
================================
|
||||
HUD_ConnectionlessPacket
|
||||
|
||||
Return 1 if the packet is valid. Set response_buffer_size if you want to send a response packet. Incoming, it holds the max
|
||||
size of the response_buffer, so you must zero it out if you choose not to respond.
|
||||
================================
|
||||
*/
|
||||
int EXPORT HUD_ConnectionlessPacket( 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;
|
||||
|
||||
// Zero it out since we aren't going to respond.
|
||||
// If we wanted to response, we'd write data into response_buffer
|
||||
*response_buffer_size = 0;
|
||||
|
||||
// Since we don't listen for anything here, just respond that it's a bogus message
|
||||
// If we didn't reject the message, we'd return 1 for success instead.
|
||||
return 0;
|
||||
}
|
||||
|
||||
void EXPORT HUD_PlayerMoveInit( struct playermove_s *ppmove )
|
||||
{
|
||||
PM_Init( ppmove );
|
||||
}
|
||||
|
||||
char EXPORT HUD_PlayerMoveTexture( char *name )
|
||||
{
|
||||
return PM_FindTextureType( name );
|
||||
}
|
||||
|
||||
void EXPORT HUD_PlayerMove( struct playermove_s *ppmove, int server )
|
||||
{
|
||||
PM_Move( ppmove, server );
|
||||
}
|
||||
|
||||
int EXPORT Initialize( cl_enginefunc_t *pEnginefuncs, int iVersion )
|
||||
{
|
||||
gEngfuncs = *pEnginefuncs;
|
||||
|
||||
//!!! mwh UNDONE We need to think about our versioning strategy. Do we want to try to be compatible
|
||||
// with previous versions, especially when we're only 'bonus' functionality? Should it be the engine
|
||||
// that decides if the DLL is compliant?
|
||||
|
||||
if (iVersion != CLDLL_INTERFACE_VERSION)
|
||||
return 0;
|
||||
|
||||
memcpy(&gEngfuncs, pEnginefuncs, sizeof(cl_enginefunc_t));
|
||||
|
||||
EV_HookEvents();
|
||||
|
||||
// Determine which filesystem to use.
|
||||
#if defined ( _WIN32 )
|
||||
char *szFsModule = "filesystem_stdio.dll";
|
||||
#elif defined(OSX)
|
||||
char *szFsModule = "filesystem_stdio.dylib";
|
||||
#elif defined(LINUX)
|
||||
char *szFsModule = "filesystem_stdio.so";
|
||||
#else
|
||||
#error
|
||||
#endif
|
||||
|
||||
|
||||
char szFSDir[MAX_PATH];
|
||||
szFSDir[0] = 0;
|
||||
if ( gEngfuncs.COM_ExpandFilename( szFsModule, szFSDir, sizeof( szFSDir ) ) == FALSE )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// Get filesystem interface.
|
||||
g_pFileSystemModule = Sys_LoadModule( szFSDir );
|
||||
assert( g_pFileSystemModule );
|
||||
if( !g_pFileSystemModule )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
CreateInterfaceFn fileSystemFactory = Sys_GetFactory( g_pFileSystemModule );
|
||||
if( !fileSystemFactory )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
g_pFileSystem = ( IFileSystem * )fileSystemFactory( FILESYSTEM_INTERFACE_VERSION, NULL );
|
||||
assert( g_pFileSystem );
|
||||
if( !g_pFileSystem )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
==========================
|
||||
HUD_VidInit
|
||||
|
||||
Called when the game initializes
|
||||
and whenever the vid_mode is changed
|
||||
so the HUD can reinitialize itself.
|
||||
==========================
|
||||
*/
|
||||
|
||||
int EXPORT HUD_VidInit( void )
|
||||
{
|
||||
gHUD.VidInit();
|
||||
|
||||
VGui_Startup();
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
==========================
|
||||
HUD_Init
|
||||
|
||||
Called whenever the client connects
|
||||
to a server. Reinitializes all
|
||||
the hud variables.
|
||||
==========================
|
||||
*/
|
||||
|
||||
int EXPORT HUD_Init( void )
|
||||
{
|
||||
InitInput();
|
||||
gHUD.Init();
|
||||
Scheme_Init();
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
==========================
|
||||
HUD_Redraw
|
||||
|
||||
called every screen frame to
|
||||
redraw the HUD.
|
||||
===========================
|
||||
*/
|
||||
|
||||
int EXPORT HUD_Redraw( float time, int intermission )
|
||||
{
|
||||
gHUD.Redraw( time, intermission );
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
==========================
|
||||
HUD_UpdateClientData
|
||||
|
||||
called every time shared client
|
||||
dll/engine data gets changed,
|
||||
and gives the cdll a chance
|
||||
to modify the data.
|
||||
|
||||
returns 1 if anything has been changed, 0 otherwise.
|
||||
==========================
|
||||
*/
|
||||
|
||||
int EXPORT HUD_UpdateClientData(client_data_t *pcldata, float flTime )
|
||||
{
|
||||
return gHUD.UpdateClientData(pcldata, flTime );
|
||||
}
|
||||
|
||||
/*
|
||||
==========================
|
||||
HUD_Reset
|
||||
|
||||
Called at start and end of demos to restore to "non"HUD state.
|
||||
==========================
|
||||
*/
|
||||
|
||||
int EXPORT HUD_Reset( void )
|
||||
{
|
||||
gHUD.VidInit();
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
==========================
|
||||
HUD_Frame
|
||||
|
||||
Called by engine every frame that client .dll is loaded
|
||||
==========================
|
||||
*/
|
||||
|
||||
void EXPORT HUD_Frame( double time )
|
||||
{
|
||||
IN_Commands();
|
||||
|
||||
ServersThink( time );
|
||||
|
||||
GetClientVoiceMgr()->Frame(time);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
==========================
|
||||
HUD_VoiceStatus
|
||||
|
||||
Called when a player starts or stops talking.
|
||||
==========================
|
||||
*/
|
||||
|
||||
void EXPORT HUD_VoiceStatus(int entindex, qboolean bTalking)
|
||||
{
|
||||
GetClientVoiceMgr()->UpdateSpeakerStatus(entindex, bTalking);
|
||||
}
|
||||
|
||||
/*
|
||||
==========================
|
||||
HUD_DirectorMessage
|
||||
|
||||
Called when a director event message was received
|
||||
==========================
|
||||
*/
|
||||
|
||||
void EXPORT HUD_DirectorMessage( int iSize, void *pbuf )
|
||||
{
|
||||
gHUD.m_Spectator.DirectorMessage( iSize, pbuf );
|
||||
}
|
||||
|
|
@ -1,598 +0,0 @@
|
|||
# Microsoft Developer Studio Project File - Name="cl_dll" - Package Owner=<4>
|
||||
# Microsoft Developer Studio Generated Build File, Format Version 6.00
|
||||
# ** DO NOT EDIT **
|
||||
|
||||
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
|
||||
|
||||
CFG=cl_dll - Win32 Release
|
||||
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
|
||||
!MESSAGE use the Export Makefile command and run
|
||||
!MESSAGE
|
||||
!MESSAGE NMAKE /f "cl_dll.mak".
|
||||
!MESSAGE
|
||||
!MESSAGE You can specify a configuration when running NMAKE
|
||||
!MESSAGE by defining the macro CFG on the command line. For example:
|
||||
!MESSAGE
|
||||
!MESSAGE NMAKE /f "cl_dll.mak" CFG="cl_dll - Win32 Release"
|
||||
!MESSAGE
|
||||
!MESSAGE Possible choices for configuration are:
|
||||
!MESSAGE
|
||||
!MESSAGE "cl_dll - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
|
||||
!MESSAGE "cl_dll - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
|
||||
!MESSAGE
|
||||
|
||||
# Begin Project
|
||||
# PROP AllowPerConfigDependencies 0
|
||||
# PROP Scc_ProjName ""$/GoldSrc/dmc/cl_dlls", STQCAAAA"
|
||||
# PROP Scc_LocalPath "."
|
||||
CPP=cl.exe
|
||||
MTL=midl.exe
|
||||
RSC=rc.exe
|
||||
|
||||
!IF "$(CFG)" == "cl_dll - Win32 Release"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 0
|
||||
# PROP BASE Output_Dir ".\Release"
|
||||
# PROP BASE Intermediate_Dir ".\Release"
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 0
|
||||
# PROP Output_Dir ".\Release"
|
||||
# PROP Intermediate_Dir ".\Release"
|
||||
# PROP Ignore_Export_Lib 0
|
||||
# PROP Target_Dir ""
|
||||
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
|
||||
# ADD CPP /nologo /MT /W3 /GX /Zi /O2 /I "..\utils\common" /I "..\..\public" /I "..\engine" /I "..\common" /I "..\utils\vgui\include" /I "..\dlls" /I "..\..\engine" /I "..\..\common" /I "..\pm_shared" /I "..\..\utils\vgui\include" /I "." /I "..\..\game_shared" /I "..\..\external" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "CLIENT_DLL" /D "DMC_BUILD" /YX /FD /c
|
||||
# ADD BASE MTL /nologo /D "NDEBUG" /win32
|
||||
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
|
||||
# ADD BASE RSC /l 0x409 /d "NDEBUG"
|
||||
# ADD RSC /l 0x409 /d "NDEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
LINK32=link.exe
|
||||
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386
|
||||
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib winmm.lib ..\..\utils\vgui\lib\win32_vc6\vgui.lib wsock32.lib ..\..\lib\public\sdl2.lib /nologo /subsystem:windows /dll /map /debug /machine:I386 /out:".\Release\client.dll"
|
||||
# Begin Custom Build - Copying to cl_dlls
|
||||
InputDir=.\Release
|
||||
ProjDir=.
|
||||
InputPath=.\Release\client.dll
|
||||
SOURCE="$(InputPath)"
|
||||
|
||||
BuildCmds= \
|
||||
call ..\..\filecopy.bat $(InputPath) $(ProjDir)\..\..\..\game\mod\cl_dlls\client.dll \
|
||||
call ..\..\filecopy.bat $(InputDir)\client.pdb $(ProjDir)\..\..\..\game\mod\cl_dlls\client.pdb \
|
||||
|
||||
|
||||
"..\..\..\game\mod\cl_dlls\client.dll" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
$(BuildCmds)
|
||||
|
||||
"..\..\..\game\mod\cl_dlls\client.pdb" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
$(BuildCmds)
|
||||
# End Custom Build
|
||||
|
||||
!ELSEIF "$(CFG)" == "cl_dll - Win32 Debug"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 1
|
||||
# PROP BASE Output_Dir ".\Debug"
|
||||
# PROP BASE Intermediate_Dir ".\Debug"
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 1
|
||||
# PROP Output_Dir ".\Debug"
|
||||
# PROP Intermediate_Dir ".\Debug"
|
||||
# PROP Ignore_Export_Lib 0
|
||||
# PROP Target_Dir ""
|
||||
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
|
||||
# ADD CPP /nologo /MTd /W3 /GX /ZI /Od /I "..\..\public" /I "..\engine" /I "..\common" /I "..\utils\vgui\include" /I "..\dlls" /I "..\..\engine" /I "..\..\common" /I "..\pm_shared" /I "..\..\utils\vgui\include" /I "." /I "..\..\game_shared" /I "..\..\external" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "CLIENT_DLL" /D "DMC_BUILD" /FR /Fp".\Release/cl_dll.pch" /YX /Fo".\Release/" /Fd".\Release/" /FD /c
|
||||
# ADD BASE MTL /nologo /D "_DEBUG" /win32
|
||||
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
|
||||
# ADD BASE RSC /l 0x409 /d "_DEBUG"
|
||||
# ADD RSC /l 0x409 /d "_DEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
LINK32=link.exe
|
||||
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386
|
||||
# ADD LINK32 oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib winmm.lib ..\..\utils\vgui\lib\win32_vc6\vgui.lib wsock32.lib ..\..\lib\public\sdl2.lib /nologo /subsystem:windows /dll /profile /map /debug /machine:I386 /out:".\Debug\client.dll"
|
||||
# Begin Custom Build - Copying to cl_dlls
|
||||
InputDir=.\Debug
|
||||
ProjDir=.
|
||||
InputPath=.\Debug\client.dll
|
||||
SOURCE="$(InputPath)"
|
||||
|
||||
BuildCmds= \
|
||||
call ..\..\filecopy.bat $(InputPath) $(ProjDir)\..\..\..\game\mod\cl_dlls\client.dll \
|
||||
call ..\..\filecopy.bat $(InputDir)\client.pdb $(ProjDir)\..\..\..\game\mod\cl_dlls\client.pdb \
|
||||
|
||||
|
||||
"..\..\..\game\mod\cl_dlls\client.dll" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
$(BuildCmds)
|
||||
|
||||
"..\..\..\game\mod\cl_dlls\client.pdb" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
$(BuildCmds)
|
||||
# End Custom Build
|
||||
|
||||
!ENDIF
|
||||
|
||||
# Begin Target
|
||||
|
||||
# Name "cl_dll - Win32 Release"
|
||||
# Name "cl_dll - Win32 Debug"
|
||||
# Begin Group "Source Files"
|
||||
|
||||
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat;for;f90"
|
||||
# Begin Group "quake"
|
||||
|
||||
# PROP Default_Filter "*.cpp"
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\CTF_FlagStatus.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\CTF_HudMessage.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\DMC_Teleporters.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\ev_hldm.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\quake\quake_baseentity.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\quake\quake_events.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\dlls\quake_gun.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\quake\quake_objects.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\quake\quake_weapons.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\dlls\quake_weapons_all.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\studio_util.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\vgui_SpectatorPanel.cpp
|
||||
# End Source File
|
||||
# End Group
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\ammo.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\ammo_secondary.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\ammohistory.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\battery.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\cdll_int.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\com_weapons.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\death.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\demo.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\entity.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\ev_common.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\events.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\GameStudioModelRenderer.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\geiger.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\health.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\hud.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\hud_msg.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\hud_redraw.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\hud_servers.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\hud_spectator.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\hud_update.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\in_camera.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\input.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\inputw32.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\public\interface.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\menu.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\message.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\common\parsemsg.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\pm_shared\pm_debug.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\pm_shared\pm_math.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\pm_shared\pm_shared.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\saytext.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\scoreboard.cpp
|
||||
# PROP Exclude_From_Build 1
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\status_icons.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\statusbar.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\StudioModelRenderer.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\text_message.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\train.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\tri.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\util.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\game_shared\vgui_checkbutton2.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\game_shared\vgui_grid.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\game_shared\vgui_helpers.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\vgui_int.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\game_shared\vgui_listbox.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\game_shared\vgui_loadtga.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\vgui_ScorePanel.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\game_shared\vgui_scrollbar2.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\vgui_ServerBrowser.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\game_shared\vgui_slider2.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\vgui_viewport.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\view.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\game_shared\voice_banmgr.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\voice_status.cpp
|
||||
# End Source File
|
||||
# End Group
|
||||
# Begin Group "Header Files"
|
||||
|
||||
# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\ammo.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\ammohistory.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\camera.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\cl_dll.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\cl_util.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\com_weapons.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\demo.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\DMC_BSPFile.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\DMC_Teleporters.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\ev_hldm.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\eventscripts.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\GameStudioModelRenderer.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\health.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\hud.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\hud_iface.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\hud_servers.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\hud_servers_priv.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\hud_spectator.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\in_defs.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\kbutton.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\common\parsemsg.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\pm_shared\pm_debug.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\pm_shared\pm_defs.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\pm_shared\pm_info.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\pm_shared\pm_materials.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\pm_shared\pm_movevars.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\pm_shared\pm_shared.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\dlls\quake_gun.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\StudioModelRenderer.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\util.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\util_vector.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\game_shared\vgui_checkbutton2.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\vgui_ControlConfigPanel.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\game_shared\vgui_grid.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\game_shared\vgui_helpers.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\vgui_int.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\game_shared\vgui_listbox.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\game_shared\vgui_loadtga.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\vgui_SchemeManager.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\vgui_ScorePanel.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\vgui_ServerBrowser.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\vgui_SpectatorPanel.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\vgui_viewport.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\view.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\voice_status.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\wrect.h
|
||||
# End Source File
|
||||
# End Group
|
||||
# Begin Group "Resource Files"
|
||||
|
||||
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe"
|
||||
# End Group
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\vgui_CustomObjects.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\vgui_MOTDWindow.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\vgui_SchemeManager.cpp
|
||||
# End Source File
|
||||
# End Target
|
||||
# End Project
|
||||
|
|
@ -1,43 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// cl_dll.h
|
||||
//
|
||||
|
||||
// 4-23-98 JOHN
|
||||
|
||||
//
|
||||
// This DLL is linked by the client when they first initialize.
|
||||
// This DLL is responsible for the following tasks:
|
||||
// - Loading the HUD graphics upon initialization
|
||||
// - Drawing the HUD graphics every frame
|
||||
// - Handling the custum HUD-update packets
|
||||
//
|
||||
typedef unsigned char byte;
|
||||
typedef unsigned short word;
|
||||
typedef float vec_t;
|
||||
typedef int (*pfnUserMsgHook)(const char *pszName, int iSize, void *pbuf);
|
||||
|
||||
#include "util_vector.h"
|
||||
#ifdef _WIN32
|
||||
#define EXPORT _declspec( dllexport )
|
||||
#else
|
||||
#define EXPORT __attribute__ ((visibility("default")))
|
||||
#endif
|
||||
|
||||
#include "../engine/cdll_int.h"
|
||||
#include "../dlls/cdll_dll.h"
|
||||
|
||||
extern cl_enginefunc_t gEngfuncs;
|
||||
|
|
@ -1,199 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// cl_util.h
|
||||
//
|
||||
|
||||
#include "cvardef.h"
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE 1
|
||||
#define FALSE 0
|
||||
#endif
|
||||
|
||||
#include <stdio.h> // for safe_sprintf()
|
||||
#include <stdarg.h> // "
|
||||
#include <string.h> // for safe_strcpy()
|
||||
|
||||
|
||||
// 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_COMMAND(x, y) gEngfuncs.pfnAddCommand( x, __CmdFunc_##y );
|
||||
#define DECLARE_COMMAND(y, x) void __CmdFunc_##x( void ) \
|
||||
{ \
|
||||
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)
|
||||
|
||||
// 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)
|
||||
// SPR_DrawAdditive adds the sprites RGB values to the background (additive transulency)
|
||||
#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_DisableScissor disables the clipping rect
|
||||
#define SPR_DisableScissor (*gEngfuncs.pfnSPR_DisableScissor)
|
||||
//
|
||||
#define FillRGBA (*gEngfuncs.pfnFillRGBA)
|
||||
|
||||
|
||||
// ScreenHeight returns the height of the screen, in pixels
|
||||
#define ScreenHeight (gHUD.m_scrinfo.iHeight)
|
||||
// ScreenWidth returns the width of the screen, in pixels
|
||||
#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))
|
||||
|
||||
// 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 GetScreenInfo (*gEngfuncs.pfnGetScreenInfo)
|
||||
#define ServerCmd (*gEngfuncs.pfnServerCmd)
|
||||
#define ClientCmd (*gEngfuncs.pfnClientCmd)
|
||||
#define SetCrosshair (*gEngfuncs.pfnSetCrosshair)
|
||||
#define AngleVectors (*gEngfuncs.pfnAngleVectors)
|
||||
|
||||
|
||||
// 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); }
|
||||
|
||||
inline client_textmessage_t *TextMessageGet( const char *pName ) { return gEngfuncs.pfnTextMessageGet( pName ); }
|
||||
inline int TextMessageDrawChar( int x, int y, int number, int r, int g, int b )
|
||||
{
|
||||
return gEngfuncs.pfnDrawCharacter( x, y, number, r, g, b );
|
||||
}
|
||||
|
||||
inline int DrawConsoleString( int x, int y, const char *string )
|
||||
{
|
||||
return gEngfuncs.pfnDrawConsoleString( x, y, (char*) string );
|
||||
}
|
||||
|
||||
inline void GetConsoleStringSize( const char *string, int *width, int *height )
|
||||
{
|
||||
gEngfuncs.pfnDrawConsoleStringLen( string, width, height );
|
||||
}
|
||||
|
||||
inline int ConsoleStringLen( const char *string )
|
||||
{
|
||||
int _width, _height;
|
||||
GetConsoleStringSize( string, &_width, &_height );
|
||||
return _width;
|
||||
}
|
||||
|
||||
inline void ConsolePrint( const char *string )
|
||||
{
|
||||
gEngfuncs.pfnConsolePrint( string );
|
||||
}
|
||||
|
||||
inline void CenterPrint( const char *string )
|
||||
{
|
||||
gEngfuncs.pfnCenterPrint( string );
|
||||
}
|
||||
|
||||
|
||||
inline char *safe_strcpy( char *dst, const char *src, int len_dst)
|
||||
{
|
||||
if( len_dst <= 0 )
|
||||
{
|
||||
return NULL; // this is bad
|
||||
}
|
||||
|
||||
strncpy(dst,src,len_dst);
|
||||
dst[ len_dst - 1 ] = '\0';
|
||||
|
||||
return dst;
|
||||
}
|
||||
|
||||
inline int safe_sprintf( char *dst, int len_dst, const char *format, ...)
|
||||
{
|
||||
if( len_dst <= 0 )
|
||||
{
|
||||
return -1; // this is bad
|
||||
}
|
||||
|
||||
va_list v;
|
||||
|
||||
va_start(v, format);
|
||||
|
||||
_vsnprintf(dst,len_dst,format,v);
|
||||
|
||||
va_end(v);
|
||||
|
||||
dst[ len_dst - 1 ] = '\0';
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// returns the players name of entity no.
|
||||
#define GetPlayerInfo (*gEngfuncs.pfnGetPlayerInfo)
|
||||
|
||||
// sound functions
|
||||
inline void PlaySound( char *szSound, float vol ) { gEngfuncs.pfnPlaySoundByName( szSound, vol ); }
|
||||
inline void PlaySound( int iSound, float vol ) { gEngfuncs.pfnPlaySoundByIndex( iSound, vol ); }
|
||||
|
||||
#define max(a, b) (((a) > (b)) ? (a) : (b))
|
||||
#define min(a, b) (((a) < (b)) ? (a) : (b))
|
||||
#define fabs(x) ((x) > 0 ? (x) : 0 - (x))
|
||||
|
||||
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];}
|
||||
#define VectorClear(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;
|
||||
|
||||
// disable 'possible loss of data converting float to int' warning message
|
||||
#pragma warning( disable: 4244 )
|
||||
// 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)\
|
||||
{\
|
||||
r = (ulRGB & 0xFF0000) >>16;\
|
||||
g = (ulRGB & 0xFF00) >> 8;\
|
||||
b = ulRGB & 0xFF;\
|
||||
}
|
||||
|
||||
HSPRITE LoadSprite(const char *pszName);
|
||||
|
|
@ -1,359 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
|
||||
// com_model.h
|
||||
#if !defined( COM_MODEL_H )
|
||||
#define COM_MODEL_H
|
||||
#if defined( _WIN32 )
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#define STUDIO_RENDER 1
|
||||
#define STUDIO_EVENTS 2
|
||||
|
||||
#define MAX_CLIENTS 32
|
||||
#define MAX_EDICTS 900
|
||||
|
||||
#define MAX_MODEL_NAME 64
|
||||
#define MAX_MAP_HULLS 4
|
||||
#define MIPLEVELS 4
|
||||
#define NUM_AMBIENTS 4 // automatic ambient sounds
|
||||
#define MAXLIGHTMAPS 4
|
||||
#define PLANE_ANYZ 5
|
||||
|
||||
#define ALIAS_Z_CLIP_PLANE 5
|
||||
|
||||
// flags in finalvert_t.flags
|
||||
#define ALIAS_LEFT_CLIP 0x0001
|
||||
#define ALIAS_TOP_CLIP 0x0002
|
||||
#define ALIAS_RIGHT_CLIP 0x0004
|
||||
#define ALIAS_BOTTOM_CLIP 0x0008
|
||||
#define ALIAS_Z_CLIP 0x0010
|
||||
#define ALIAS_ONSEAM 0x0020
|
||||
#define ALIAS_XY_CLIP_MASK 0x000F
|
||||
|
||||
#define ZISCALE ((float)0x8000)
|
||||
|
||||
#define CACHE_SIZE 32 // used to align key data structures
|
||||
|
||||
typedef enum
|
||||
{
|
||||
mod_brush,
|
||||
mod_sprite,
|
||||
mod_alias,
|
||||
mod_studio
|
||||
} modtype_t;
|
||||
|
||||
// must match definition in modelgen.h
|
||||
#ifndef SYNCTYPE_T
|
||||
#define SYNCTYPE_T
|
||||
|
||||
typedef enum
|
||||
{
|
||||
ST_SYNC=0,
|
||||
ST_RAND
|
||||
} synctype_t;
|
||||
|
||||
#endif
|
||||
|
||||
typedef struct
|
||||
{
|
||||
float mins[3], maxs[3];
|
||||
float origin[3];
|
||||
int headnode[MAX_MAP_HULLS];
|
||||
int visleafs; // not including the solid leaf 0
|
||||
int firstface, numfaces;
|
||||
} dmodel_t;
|
||||
|
||||
// plane_t structure
|
||||
typedef struct mplane_s
|
||||
{
|
||||
vec3_t normal; // surface normal
|
||||
float dist; // closest appoach to origin
|
||||
byte type; // for texture axis selection and fast side tests
|
||||
byte signbits; // signx + signy<<1 + signz<<1
|
||||
byte pad[2];
|
||||
} mplane_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
vec3_t position;
|
||||
} mvertex_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
unsigned short v[2];
|
||||
unsigned int cachededgeoffset;
|
||||
} medge_t;
|
||||
|
||||
typedef struct texture_s
|
||||
{
|
||||
char name[16];
|
||||
unsigned width, height;
|
||||
int anim_total; // total tenths in sequence ( 0 = no)
|
||||
int anim_min, anim_max; // time for this frame min <=time< max
|
||||
struct texture_s *anim_next; // in the animation sequence
|
||||
struct texture_s *alternate_anims; // bmodels in frame 1 use these
|
||||
unsigned offsets[MIPLEVELS]; // four mip maps stored
|
||||
unsigned paloffset;
|
||||
} texture_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
float vecs[2][4]; // [s/t] unit vectors in world space.
|
||||
// [i][3] is the s/t offset relative to the origin.
|
||||
// s or t = dot(3Dpoint,vecs[i])+vecs[i][3]
|
||||
float mipadjust; // ?? mipmap limits for very small surfaces
|
||||
texture_t *texture;
|
||||
int flags; // sky or slime, no lightmap or 256 subdivision
|
||||
} mtexinfo_t;
|
||||
|
||||
typedef struct mnode_s
|
||||
{
|
||||
// common with leaf
|
||||
int contents; // 0, to differentiate from leafs
|
||||
int visframe; // node needs to be traversed if current
|
||||
|
||||
short minmaxs[6]; // for bounding box culling
|
||||
|
||||
struct mnode_s *parent;
|
||||
|
||||
// node specific
|
||||
mplane_t *plane;
|
||||
struct mnode_s *children[2];
|
||||
|
||||
unsigned short firstsurface;
|
||||
unsigned short numsurfaces;
|
||||
} mnode_t;
|
||||
|
||||
typedef struct msurface_s msurface_t;
|
||||
typedef struct decal_s decal_t;
|
||||
|
||||
// JAY: Compress this as much as possible
|
||||
struct decal_s
|
||||
{
|
||||
decal_t *pnext; // linked list for each surface
|
||||
msurface_t *psurface; // Surface id for persistence / unlinking
|
||||
short dx; // Offsets into surface texture (in texture coordinates, so we don't need floats)
|
||||
short dy;
|
||||
short texture; // Decal texture
|
||||
byte scale; // Pixel scale
|
||||
byte flags; // Decal flags
|
||||
|
||||
short entityIndex; // Entity this is attached to
|
||||
};
|
||||
|
||||
typedef struct mleaf_s
|
||||
{
|
||||
// common with node
|
||||
int contents; // wil be a negative contents number
|
||||
int visframe; // node needs to be traversed if current
|
||||
|
||||
short minmaxs[6]; // for bounding box culling
|
||||
|
||||
struct mnode_s *parent;
|
||||
|
||||
// leaf specific
|
||||
byte *compressed_vis;
|
||||
struct efrag_s *efrags;
|
||||
|
||||
msurface_t **firstmarksurface;
|
||||
int nummarksurfaces;
|
||||
int key; // BSP sequence number for leaf's contents
|
||||
byte ambient_sound_level[NUM_AMBIENTS];
|
||||
} mleaf_t;
|
||||
|
||||
struct msurface_s
|
||||
{
|
||||
int visframe; // should be drawn when node is crossed
|
||||
|
||||
int dlightframe; // last frame the surface was checked by an animated light
|
||||
int dlightbits; // dynamically generated. Indicates if the surface illumination
|
||||
// is modified by an animated light.
|
||||
|
||||
mplane_t *plane; // pointer to shared plane
|
||||
int flags; // see SURF_ #defines
|
||||
|
||||
int firstedge; // look up in model->surfedges[], negative numbers
|
||||
int numedges; // are backwards edges
|
||||
|
||||
// surface generation data
|
||||
struct surfcache_s *cachespots[MIPLEVELS];
|
||||
|
||||
short texturemins[2]; // smallest s/t position on the surface.
|
||||
short extents[2]; // ?? s/t texture size, 1..256 for all non-sky surfaces
|
||||
|
||||
mtexinfo_t *texinfo;
|
||||
|
||||
// lighting info
|
||||
byte styles[MAXLIGHTMAPS]; // index into d_lightstylevalue[] for animated lights
|
||||
// no one surface can be effected by more than 4
|
||||
// animated lights.
|
||||
color24 *samples;
|
||||
|
||||
decal_t *pdecals;
|
||||
};
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int planenum;
|
||||
short children[2]; // negative numbers are contents
|
||||
} dclipnode_t;
|
||||
|
||||
typedef struct hull_s
|
||||
{
|
||||
dclipnode_t *clipnodes;
|
||||
mplane_t *planes;
|
||||
int firstclipnode;
|
||||
int lastclipnode;
|
||||
vec3_t clip_mins;
|
||||
vec3_t clip_maxs;
|
||||
} hull_t;
|
||||
|
||||
#if !defined( CACHE_USER ) && !defined( QUAKEDEF_H )
|
||||
#define CACHE_USER
|
||||
typedef struct cache_user_s
|
||||
{
|
||||
void *data;
|
||||
} cache_user_t;
|
||||
#endif
|
||||
|
||||
typedef struct model_s
|
||||
{
|
||||
char name[ MAX_MODEL_NAME ];
|
||||
qboolean needload; // bmodels and sprites don't cache normally
|
||||
|
||||
modtype_t type;
|
||||
int numframes;
|
||||
synctype_t synctype;
|
||||
|
||||
int flags;
|
||||
|
||||
//
|
||||
// volume occupied by the model
|
||||
//
|
||||
vec3_t mins, maxs;
|
||||
float radius;
|
||||
|
||||
//
|
||||
// brush model
|
||||
//
|
||||
int firstmodelsurface, nummodelsurfaces;
|
||||
|
||||
int numsubmodels;
|
||||
dmodel_t *submodels;
|
||||
|
||||
int numplanes;
|
||||
mplane_t *planes;
|
||||
|
||||
int numleafs; // number of visible leafs, not counting 0
|
||||
struct mleaf_s *leafs;
|
||||
|
||||
int numvertexes;
|
||||
mvertex_t *vertexes;
|
||||
|
||||
int numedges;
|
||||
medge_t *edges;
|
||||
|
||||
int numnodes;
|
||||
mnode_t *nodes;
|
||||
|
||||
int numtexinfo;
|
||||
mtexinfo_t *texinfo;
|
||||
|
||||
int numsurfaces;
|
||||
msurface_t *surfaces;
|
||||
|
||||
int numsurfedges;
|
||||
int *surfedges;
|
||||
|
||||
int numclipnodes;
|
||||
dclipnode_t *clipnodes;
|
||||
|
||||
int nummarksurfaces;
|
||||
msurface_t **marksurfaces;
|
||||
|
||||
hull_t hulls[MAX_MAP_HULLS];
|
||||
|
||||
int numtextures;
|
||||
texture_t **textures;
|
||||
|
||||
byte *visdata;
|
||||
|
||||
color24 *lightdata;
|
||||
|
||||
char *entities;
|
||||
|
||||
//
|
||||
// additional model data
|
||||
//
|
||||
cache_user_t cache; // only access through Mod_Extradata
|
||||
|
||||
} model_t;
|
||||
|
||||
typedef vec_t vec4_t[4];
|
||||
|
||||
typedef struct alight_s
|
||||
{
|
||||
int ambientlight; // clip at 128
|
||||
int shadelight; // clip at 192 - ambientlight
|
||||
vec3_t color;
|
||||
float *plightvec;
|
||||
} alight_t;
|
||||
|
||||
typedef struct auxvert_s
|
||||
{
|
||||
float fv[3]; // viewspace x, y
|
||||
} auxvert_t;
|
||||
|
||||
#include "custom.h"
|
||||
|
||||
#define MAX_INFO_STRING 256
|
||||
#define MAX_SCOREBOARDNAME 32
|
||||
typedef struct player_info_s
|
||||
{
|
||||
// User id on server
|
||||
int userid;
|
||||
|
||||
// User info string
|
||||
char userinfo[ MAX_INFO_STRING ];
|
||||
|
||||
// Name
|
||||
char name[ MAX_SCOREBOARDNAME ];
|
||||
|
||||
// Spectator or not, unused
|
||||
int spectator;
|
||||
|
||||
int ping;
|
||||
int packet_loss;
|
||||
|
||||
// skin information
|
||||
char model[MAX_QPATH];
|
||||
int topcolor;
|
||||
int bottomcolor;
|
||||
|
||||
// last frame rendered
|
||||
int renderframe;
|
||||
|
||||
// Gait frame estimation
|
||||
int gaitsequence;
|
||||
float gaitframe;
|
||||
float gaityaw;
|
||||
vec3_t prevgaitorigin;
|
||||
|
||||
customization_t customdata;
|
||||
} player_info_t;
|
||||
|
||||
#endif // #define COM_MODEL_H
|
||||
|
|
@ -1,278 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
|
||||
// Com_Weapons.cpp
|
||||
// Shared weapons common/shared functions
|
||||
#include <stdarg.h>
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "com_weapons.h"
|
||||
|
||||
#include "const.h"
|
||||
#include "entity_state.h"
|
||||
#include "r_efx.h"
|
||||
|
||||
// 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;
|
||||
|
||||
// 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
|
||||
// reset it to NULL as appropriate
|
||||
struct local_state_s *g_finalstate = NULL;
|
||||
|
||||
/*
|
||||
====================
|
||||
COM_Log
|
||||
|
||||
Log debug messages to file ( appends )
|
||||
====================
|
||||
*/
|
||||
void COM_Log( char *pszFile, char *fmt, ...)
|
||||
{
|
||||
va_list argptr;
|
||||
char string[1024];
|
||||
FILE *fp;
|
||||
char *pfilename;
|
||||
|
||||
if ( !pszFile )
|
||||
{
|
||||
pfilename = "c:\\hllog.txt";
|
||||
}
|
||||
else
|
||||
{
|
||||
pfilename = pszFile;
|
||||
}
|
||||
|
||||
va_start (argptr,fmt);
|
||||
vsprintf (string, fmt,argptr);
|
||||
va_end (argptr);
|
||||
|
||||
fp = fopen( pfilename, "a+t");
|
||||
if (fp)
|
||||
{
|
||||
fprintf(fp, "%s", string);
|
||||
fclose(fp);
|
||||
}
|
||||
}
|
||||
|
||||
// remember the current animation for the view model, in case we get out of sync with
|
||||
// server.
|
||||
static int g_currentanim;
|
||||
|
||||
/*
|
||||
=====================
|
||||
HUD_SendWeaponAnim
|
||||
|
||||
Change weapon model animation
|
||||
=====================
|
||||
*/
|
||||
void HUD_SendWeaponAnim( int iAnim, int body, int force )
|
||||
{
|
||||
// Don't actually change it.
|
||||
if ( !g_runfuncs && !force )
|
||||
return;
|
||||
|
||||
g_currentanim = iAnim;
|
||||
|
||||
// Tell animation system new info
|
||||
gEngfuncs.pfnWeaponAnim( iAnim, body );
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
HUD_GetWeaponAnim
|
||||
|
||||
Retrieve current predicted weapon animation
|
||||
=====================
|
||||
*/
|
||||
int HUD_GetWeaponAnim( void )
|
||||
{
|
||||
return g_currentanim;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
HUD_PlaySound
|
||||
|
||||
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 )
|
||||
return;
|
||||
|
||||
gEngfuncs.pfnPlaySoundByNameAtLocation( sound, volume, (float *)&g_finalstate->playerstate.origin );
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
HUD_PlaybackEvent
|
||||
|
||||
Directly queue up an event on the client
|
||||
=====================
|
||||
*/
|
||||
void HUD_PlaybackEvent( int flags, const edict_t *pInvoker, unsigned short eventindex, float delay,
|
||||
float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2 )
|
||||
{
|
||||
vec3_t org;
|
||||
vec3_t ang;
|
||||
|
||||
if ( !g_runfuncs || !g_finalstate )
|
||||
return;
|
||||
|
||||
// Weapon prediction events are assumed to occur at the player's origin
|
||||
org = g_finalstate->playerstate.origin;
|
||||
ang = v_angles;
|
||||
gEngfuncs.pfnPlaybackEvent( flags, pInvoker, eventindex, delay, (float *)&org, (float *)&ang, fparam1, fparam2, iparam1, iparam2, bparam1, bparam2 );
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
HUD_SetMaxSpeed
|
||||
|
||||
=====================
|
||||
*/
|
||||
void HUD_SetMaxSpeed( const edict_t *ed, float speed )
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
=====================
|
||||
UTIL_WeaponTimeBase
|
||||
|
||||
Always 0.0 on client, even if not predicting weapons ( won't get called
|
||||
in that case )
|
||||
=====================
|
||||
*/
|
||||
float UTIL_WeaponTimeBase( void )
|
||||
{
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
static unsigned int glSeed = 0;
|
||||
|
||||
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,
|
||||
26766, 907, 24102, 12370, 9674, 2972, 10472, 16492, 22683, 11529, 27968, 30406, 13213, 2319, 23620, 16823,
|
||||
10013, 23772, 21567, 1251, 19579, 20313, 18241, 30130, 8402, 20807, 27354, 7169, 21211, 17293, 5410, 19223,
|
||||
10255, 22480, 27388, 9946, 15628, 24389, 17308, 2370, 9530, 31683, 25927, 23567, 11694, 26397, 32602, 15031,
|
||||
18255, 17582, 1422, 28835, 23607, 12597, 20602, 10138, 5212, 1252, 10074, 23166, 19823, 31667, 5902, 24630,
|
||||
18948, 14330, 14950, 8939, 23540, 21311, 22428, 22391, 3583, 29004, 30498, 18714, 4278, 2437, 22430, 3439,
|
||||
28313, 23161, 25396, 13471, 19324, 15287, 2563, 18901, 13103, 16867, 9714, 14322, 15197, 26889, 19372, 26241,
|
||||
31925, 14640, 11497, 8941, 10056, 6451, 28656, 10737, 13874, 17356, 8281, 25937, 1661, 4850, 7448, 12744,
|
||||
21826, 5477, 10167, 16705, 26897, 8839, 30947, 27978, 27283, 24685, 32298, 3525, 12398, 28726, 9475, 10208,
|
||||
617, 13467, 22287, 2376, 6097, 26312, 2974, 9114, 21787, 28010, 4725, 15387, 3274, 10762, 31695, 17320,
|
||||
18324, 12441, 16801, 27376, 22464, 7500, 5666, 18144, 15314, 31914, 31627, 6495, 5226, 31203, 2331, 4668,
|
||||
12650, 18275, 351, 7268, 31319, 30119, 7600, 2905, 13826, 11343, 13053, 15583, 30055, 31093, 5067, 761,
|
||||
9685, 11070, 21369, 27155, 3663, 26542, 20169, 12161, 15411, 30401, 7580, 31784, 8985, 29367, 20989, 14203,
|
||||
29694, 21167, 10337, 1706, 28578, 887, 3373, 19477, 14382, 675, 7033, 15111, 26138, 12252, 30996, 21409,
|
||||
25678, 18555, 13256, 23316, 22407, 16727, 991, 9236, 5373, 29402, 6117, 15241, 27715, 19291, 19888, 19847
|
||||
};
|
||||
|
||||
unsigned int U_Random( void )
|
||||
{
|
||||
glSeed *= 69069;
|
||||
glSeed += seed_table[ glSeed & 0xff ];
|
||||
|
||||
return ( ++glSeed & 0x0fffffff );
|
||||
}
|
||||
|
||||
void U_Srand( unsigned int seed )
|
||||
{
|
||||
glSeed = seed_table[ seed & 0xff ];
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
UTIL_SharedRandomLong
|
||||
=====================
|
||||
*/
|
||||
int UTIL_SharedRandomLong( unsigned int seed, int low, int high )
|
||||
{
|
||||
|
||||
unsigned int range;
|
||||
|
||||
U_Srand( (int)seed + low + high );
|
||||
|
||||
range = high - low + 1;
|
||||
if ( !(range - 1) )
|
||||
{
|
||||
return low;
|
||||
}
|
||||
else
|
||||
{
|
||||
int offset;
|
||||
int rnum;
|
||||
|
||||
rnum = U_Random();
|
||||
|
||||
offset = rnum % range;
|
||||
|
||||
return (low + offset);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
UTIL_SharedRandomFloat
|
||||
=====================
|
||||
*/
|
||||
float UTIL_SharedRandomFloat( unsigned int seed, float low, float high )
|
||||
{
|
||||
//
|
||||
unsigned int range;
|
||||
|
||||
U_Srand( (int)seed + *(int *)&low + *(int *)&high );
|
||||
|
||||
U_Random();
|
||||
U_Random();
|
||||
|
||||
range = high - low;
|
||||
if ( !range )
|
||||
{
|
||||
return low;
|
||||
}
|
||||
else
|
||||
{
|
||||
int tensixrand;
|
||||
float offset;
|
||||
|
||||
tensixrand = U_Random() & 65535;
|
||||
|
||||
offset = (float)tensixrand / 65536.0;
|
||||
|
||||
return (low + offset * range );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
======================
|
||||
stub_*
|
||||
|
||||
stub functions for such things as precaching. So we don't have to modify weapons code that
|
||||
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 ( uint32 function ) { return "func"; }
|
||||
void stub_SetModel ( edict_t *e, const char *m ) {}
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
// com_weapons.h
|
||||
// Shared weapons common function prototypes
|
||||
#if !defined( COM_WEAPONSH )
|
||||
#define COM_WEAPONSH
|
||||
#ifdef _WIN32
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#include "hud_iface.h"
|
||||
|
||||
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, ...);
|
||||
int CL_IsDead( void );
|
||||
|
||||
float UTIL_SharedRandomFloat( unsigned int seed, float low, float high );
|
||||
int UTIL_SharedRandomLong( unsigned int seed, int low, int high );
|
||||
|
||||
int HUD_GetWeaponAnim( void );
|
||||
void HUD_SendWeaponAnim( int iAnim, int body, int force );
|
||||
void HUD_PlaySound( char *sound, float volume );
|
||||
void HUD_PlaybackEvent( int flags, const struct edict_s *pInvoker, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2 );
|
||||
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 ( uint32 function );
|
||||
void stub_SetModel ( struct edict_s *e, const char *m );
|
||||
|
||||
|
||||
extern cvar_t *cl_lw;
|
||||
|
||||
extern int g_runfuncs;
|
||||
extern vec3_t v_angles;
|
||||
extern float g_lastFOV;
|
||||
extern struct local_state_s *g_finalstate;
|
||||
|
||||
#endif
|
||||
|
|
@ -1,293 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// death notice
|
||||
//
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "parsemsg.h"
|
||||
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "vgui_viewport.h"
|
||||
|
||||
DECLARE_MESSAGE( m_DeathNotice, DeathMsg );
|
||||
|
||||
struct DeathNoticeItem {
|
||||
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;
|
||||
float flDisplayTime;
|
||||
float *KillerColor;
|
||||
float *VictimColor;
|
||||
};
|
||||
|
||||
#define MAX_DEATHNOTICES 4
|
||||
static int DEATHNOTICE_DISPLAY_TIME = 6;
|
||||
|
||||
#define DEATHNOTICE_TOP 32
|
||||
|
||||
DeathNoticeItem rgDeathNoticeList[ MAX_DEATHNOTICES + 1 ];
|
||||
|
||||
extern extra_player_info_t g_PlayerExtraInfo[MAX_PLAYERS+1];
|
||||
extern hud_player_info_t g_PlayerInfoList[MAX_PLAYERS+1];
|
||||
|
||||
float g_ColorBlue[3] = { 0.6, 0.8, 1.0 };
|
||||
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_ColorYellowish[3] = { 1.0, 0.625, 0.0 };
|
||||
|
||||
float *GetClientColor( int clientIndex )
|
||||
{
|
||||
const char *teamName = g_PlayerExtraInfo[ clientIndex].teamname;
|
||||
|
||||
if ( !teamName || *teamName == 0 )
|
||||
return g_ColorYellowish;
|
||||
|
||||
if ( !stricmp( "blue", teamName ) )
|
||||
return g_ColorBlue;
|
||||
else if ( !stricmp( "red", teamName ) )
|
||||
return g_ColorRed;
|
||||
else if ( !stricmp( "green", teamName ) )
|
||||
return g_ColorGreen;
|
||||
else if ( !stricmp( "yellow", teamName ) )
|
||||
return g_ColorYellow;
|
||||
|
||||
return g_ColorYellowish;
|
||||
}
|
||||
|
||||
int GetTeamIndex( int clientIndex )
|
||||
{
|
||||
const char *teamName = g_PlayerExtraInfo[ clientIndex].teamname;
|
||||
|
||||
if ( !teamName || *teamName == 0 )
|
||||
return NULL;
|
||||
|
||||
if ( !stricmp( "red", teamName ) )
|
||||
return 1;
|
||||
else if ( !stricmp( "blue", teamName ) )
|
||||
return 2;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int CHudDeathNotice :: Init( void )
|
||||
{
|
||||
gHUD.AddHudElem( this );
|
||||
|
||||
HOOK_MESSAGE( DeathMsg );
|
||||
|
||||
CVAR_CREATE( "hud_deathnotice_time", "6", 0 );
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
void CHudDeathNotice :: InitHUDData( void )
|
||||
{
|
||||
memset( rgDeathNoticeList, 0, sizeof(rgDeathNoticeList) );
|
||||
}
|
||||
|
||||
|
||||
int CHudDeathNotice :: VidInit( void )
|
||||
{
|
||||
m_HUD_d_skull = gHUD.GetSpriteIndex( "d_skull" );
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudDeathNotice :: Draw( float flTime )
|
||||
{
|
||||
int x, y, r, g, b;
|
||||
|
||||
for ( int i = 0; i < MAX_DEATHNOTICES; i++ )
|
||||
{
|
||||
if ( rgDeathNoticeList[i].iId == 0 )
|
||||
break; // we've gone through them all
|
||||
|
||||
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) );
|
||||
i--; // continue on the next item; stop the counter getting incremented
|
||||
continue;
|
||||
}
|
||||
|
||||
rgDeathNoticeList[i].flDisplayTime = min( rgDeathNoticeList[i].flDisplayTime, gHUD.m_flTime + DEATHNOTICE_DISPLAY_TIME );
|
||||
|
||||
// Draw the death notice
|
||||
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);
|
||||
|
||||
if ( !rgDeathNoticeList[i].iSuicide )
|
||||
{
|
||||
x -= (5 + ConsoleStringLen( rgDeathNoticeList[i].szKiller ) );
|
||||
|
||||
// Draw killers name
|
||||
if ( rgDeathNoticeList[i].KillerColor )
|
||||
gEngfuncs.pfnDrawSetTextColor( 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 = 10; g = 240; b = 10; // display it in sickly green
|
||||
}
|
||||
|
||||
// Draw death weapon
|
||||
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);
|
||||
|
||||
// Draw victims name
|
||||
if ( rgDeathNoticeList[i].VictimColor )
|
||||
gEngfuncs.pfnDrawSetTextColor( rgDeathNoticeList[i].VictimColor[0], rgDeathNoticeList[i].VictimColor[1], rgDeathNoticeList[i].VictimColor[2] );
|
||||
x = DrawConsoleString( x, y, rgDeathNoticeList[i].szVictim );
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
// This message handler may be better off elsewhere
|
||||
int CHudDeathNotice :: MsgFunc_DeathMsg( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
int killer = READ_BYTE();
|
||||
int victim = READ_BYTE();
|
||||
|
||||
char killedwith[32];
|
||||
strcpy( killedwith, "d_" );
|
||||
strncat( killedwith, READ_STRING(), 32 );
|
||||
|
||||
if (gViewPort)
|
||||
gViewPort->DeathMsg( killer, victim );
|
||||
|
||||
gHUD.m_Spectator.DeathMessage(victim);
|
||||
int i;
|
||||
for ( i = 0; i < MAX_DEATHNOTICES; i++ )
|
||||
{
|
||||
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 );
|
||||
i = MAX_DEATHNOTICES - 1;
|
||||
}
|
||||
|
||||
//gHUD.m_Scoreboard.GetAllPlayersInfo();
|
||||
|
||||
if (gViewPort)
|
||||
gViewPort->GetAllPlayersInfo();
|
||||
|
||||
char *killer_name = g_PlayerInfoList[ killer ].name;
|
||||
char *victim_name = g_PlayerInfoList[ victim ].name;
|
||||
if ( !killer_name )
|
||||
{
|
||||
killer_name = "";
|
||||
rgDeathNoticeList[i].szKiller[0] = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
rgDeathNoticeList[i].KillerColor = GetClientColor( killer );
|
||||
strncpy( rgDeathNoticeList[i].szKiller, killer_name, MAX_PLAYER_NAME_LENGTH );
|
||||
rgDeathNoticeList[i].szKiller[MAX_PLAYER_NAME_LENGTH-1] = 0;
|
||||
}
|
||||
|
||||
if ( !victim_name )
|
||||
{
|
||||
victim_name = "";
|
||||
rgDeathNoticeList[i].szVictim[0] = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
rgDeathNoticeList[i].VictimColor = GetClientColor( victim );
|
||||
strncpy( rgDeathNoticeList[i].szVictim, victim_name, MAX_PLAYER_NAME_LENGTH );
|
||||
rgDeathNoticeList[i].szVictim[MAX_PLAYER_NAME_LENGTH-1] = 0;
|
||||
}
|
||||
|
||||
if ( killer == victim || killer == 0 )
|
||||
rgDeathNoticeList[i].iSuicide = TRUE;
|
||||
|
||||
if ( !strcmp( killedwith, "d_teammate" ) )
|
||||
rgDeathNoticeList[i].iTeamKill = TRUE;
|
||||
|
||||
// Find the sprite in the list
|
||||
int spr = gHUD.GetSpriteIndex( killedwith );
|
||||
|
||||
rgDeathNoticeList[i].iId = spr;
|
||||
|
||||
DEATHNOTICE_DISPLAY_TIME = CVAR_GET_FLOAT( "hud_deathnotice_time" );
|
||||
rgDeathNoticeList[i].flDisplayTime = gHUD.m_flTime + DEATHNOTICE_DISPLAY_TIME;
|
||||
|
||||
// record the death notice in the console
|
||||
if ( rgDeathNoticeList[i].iSuicide )
|
||||
{
|
||||
ConsolePrint( rgDeathNoticeList[i].szVictim );
|
||||
|
||||
if ( !strcmp( killedwith, "d_world" ) )
|
||||
{
|
||||
ConsolePrint( " died" );
|
||||
}
|
||||
else
|
||||
{
|
||||
ConsolePrint( " killed self" );
|
||||
}
|
||||
}
|
||||
else if ( rgDeathNoticeList[i].iTeamKill )
|
||||
{
|
||||
ConsolePrint( rgDeathNoticeList[i].szKiller );
|
||||
ConsolePrint( " killed his teammate " );
|
||||
ConsolePrint( rgDeathNoticeList[i].szVictim );
|
||||
}
|
||||
else
|
||||
{
|
||||
ConsolePrint( rgDeathNoticeList[i].szKiller );
|
||||
ConsolePrint( " killed " );
|
||||
ConsolePrint( rgDeathNoticeList[i].szVictim );
|
||||
}
|
||||
|
||||
if ( killedwith && *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" ) )
|
||||
strcpy( killedwith, "d_gluon gun" );
|
||||
if ( !strcmp( killedwith+2, "gauss" ) )
|
||||
strcpy( killedwith, "d_tau cannon" );
|
||||
|
||||
ConsolePrint( killedwith+2 ); // skip over the "d_" part
|
||||
}
|
||||
|
||||
ConsolePrint( "\n" );
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,61 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "demo.h"
|
||||
#include "demo_api.h"
|
||||
#include <memory.h>
|
||||
|
||||
extern "C"
|
||||
{
|
||||
void EXPORT Demo_ReadBuffer( int size, unsigned char *buffer );
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
Demo_WriteBuffer
|
||||
|
||||
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 );
|
||||
|
||||
memcpy( &buf[pos], buffer, size );
|
||||
|
||||
// Write full buffer out
|
||||
gEngfuncs.pDemoAPI->WriteBuffer( size + sizeof( int ), buf );
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
Demo_ReadBuffer
|
||||
|
||||
Engine wants us to parse some data from the demo stream
|
||||
=====================
|
||||
*/
|
||||
void EXPORT Demo_ReadBuffer( int size, unsigned char *buffer )
|
||||
{
|
||||
int type;
|
||||
int i = 0;
|
||||
|
||||
type = *( int * )buffer;
|
||||
i += sizeof( int );
|
||||
switch ( type )
|
||||
{
|
||||
case TYPE_USER:
|
||||
break;
|
||||
default:
|
||||
gEngfuncs.Con_DPrintf( "Unknown demo buffer type, skipping.\n" );
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,20 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#if !defined( DEMOH )
|
||||
#define DEMOH
|
||||
#pragma once
|
||||
|
||||
// Types of demo messages we can write/parse
|
||||
enum
|
||||
{
|
||||
TYPE_USER = 0,
|
||||
};
|
||||
|
||||
void Demo_WriteBuffer( int type, int size, unsigned char *buffer );
|
||||
|
||||
#endif
|
||||
|
|
@ -1,860 +0,0 @@
|
|||
/****
|
||||
*
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
// Client side entity management functions
|
||||
#include <memory.h>
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "const.h"
|
||||
#include "entity_types.h"
|
||||
#include "studio_event.h" // def. of mstudioevent_t
|
||||
#include "r_efx.h"
|
||||
#include "usercmd.h"
|
||||
#include "event_api.h"
|
||||
#include "pm_defs.h"
|
||||
#include "pm_shared.h"
|
||||
#include "pmtrace.h"
|
||||
#include "voice_status.h"
|
||||
|
||||
void Game_AddObjects( void );
|
||||
|
||||
|
||||
extern vec3_t v_origin;
|
||||
|
||||
extern "C"
|
||||
{
|
||||
int EXPORT HUD_AddEntity( int type, struct cl_entity_s *ent, const char *modelname );
|
||||
void EXPORT HUD_CreateEntities( void );
|
||||
void EXPORT HUD_StudioEvent( const struct mstudioevent_s *event, const struct cl_entity_s *entity );
|
||||
void EXPORT HUD_TxferLocalOverrides( struct entity_state_s *state, const struct clientdata_s *client );
|
||||
void EXPORT HUD_ProcessPlayerState( struct entity_state_s *dst, const struct entity_state_s *src );
|
||||
void EXPORT 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 EXPORT HUD_TempEntUpdate( double frametime, double client_time, double cl_gravity, struct tempent_s **ppTempEntFree, struct tempent_s **ppTempEntActive, int ( *Callback_AddVisibleEntity )( struct cl_entity_s *pEntity ), void ( *Callback_TempEntPlaySound )( struct tempent_s *pTemp, float damp ) );
|
||||
struct cl_entity_s EXPORT *HUD_GetUserEntity( int index );
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
HUD_AddEntity
|
||||
Return 0 to filter entity from visible list for rendering
|
||||
========================
|
||||
*/
|
||||
int EXPORT HUD_AddEntity( int type, struct cl_entity_s *ent, const char *modelname )
|
||||
{
|
||||
switch ( type )
|
||||
{
|
||||
case ET_NORMAL:
|
||||
case ET_PLAYER:
|
||||
case ET_BEAM:
|
||||
case ET_TEMPENTITY:
|
||||
case ET_FRAGMENTED:
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
// each frame every entity passes this function, so the overview hooks it to filter the overview entities
|
||||
// in spectator mode:
|
||||
// each frame every entity passes this function, so the overview hooks
|
||||
// it to filter the overview entities
|
||||
|
||||
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 ) &&
|
||||
ent->index == g_iUser2 )
|
||||
return 0; // don't draw the player we are following in eye
|
||||
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
=========================
|
||||
HUD_TxferLocalOverrides
|
||||
|
||||
The server sends us our origin with extra precision as part of the clientdata structure, not during the normal
|
||||
playerstate update in entity_state_t. In order for these overrides to eventually get to the appropriate playerstate
|
||||
structure, we need to copy them into the state structure at this point.
|
||||
=========================
|
||||
*/
|
||||
void EXPORT HUD_TxferLocalOverrides( struct entity_state_s *state, const struct clientdata_s *client )
|
||||
{
|
||||
VectorCopy( client->origin, state->origin );
|
||||
|
||||
// Observer
|
||||
state->iuser1 = client->iuser1;
|
||||
state->iuser2 = client->iuser2;
|
||||
}
|
||||
|
||||
/*
|
||||
=========================
|
||||
HUD_ProcessPlayerState
|
||||
|
||||
We have received entity_state_t for this player over the network. We need to copy appropriate fields to the
|
||||
playerstate structure
|
||||
=========================
|
||||
*/
|
||||
void EXPORT HUD_ProcessPlayerState( struct entity_state_s *dst, const struct entity_state_s *src )
|
||||
{
|
||||
// Copy in network data
|
||||
VectorCopy( src->origin, dst->origin );
|
||||
VectorCopy( src->angles, dst->angles );
|
||||
|
||||
VectorCopy( src->velocity, dst->velocity );
|
||||
|
||||
dst->frame = src->frame;
|
||||
dst->modelindex = src->modelindex;
|
||||
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->rendermode = src->rendermode;
|
||||
dst->renderamt = src->renderamt;
|
||||
dst->rendercolor.r = src->rendercolor.r;
|
||||
dst->rendercolor.g = src->rendercolor.g;
|
||||
dst->rendercolor.b = src->rendercolor.b;
|
||||
dst->renderfx = src->renderfx;
|
||||
|
||||
dst->framerate = src->framerate;
|
||||
dst->body = src->body;
|
||||
|
||||
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 );
|
||||
|
||||
dst->friction = src->friction;
|
||||
dst->gravity = src->gravity;
|
||||
dst->gaitsequence = src->gaitsequence;
|
||||
dst->spectator = src->spectator;
|
||||
dst->usehull = src->usehull;
|
||||
dst->playerclass = src->playerclass;
|
||||
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 )
|
||||
{
|
||||
g_iUser1 = src->iuser1;
|
||||
g_iUser2 = src->iuser2;
|
||||
g_iUser3 = src->iuser3;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
=========================
|
||||
HUD_TxferPredictionData
|
||||
|
||||
Because we can predict an arbitrary number of frames before the server responds with an update, we need to be able to copy client side prediction data in
|
||||
from the state that the server ack'd receiving, which can be anywhere along the predicted frame path ( i.e., we could predict 20 frames into the future and the server ack's
|
||||
up through 10 of those frames, so we need to copy persistent client-side only state from the 10th predicted frame to the slot the server
|
||||
update is occupying.
|
||||
=========================
|
||||
*/
|
||||
void EXPORT 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;
|
||||
ps->iStepLeft = pps->iStepLeft;
|
||||
ps->playerclass = pps->playerclass;
|
||||
|
||||
pcd->viewmodel = ppcd->viewmodel;
|
||||
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->weaponanim = ppcd->weaponanim;
|
||||
pcd->tfstate = ppcd->tfstate;
|
||||
pcd->maxspeed = ppcd->maxspeed;
|
||||
|
||||
pcd->deadflag = ppcd->deadflag;
|
||||
|
||||
// Observer
|
||||
pcd->iuser1 = ppcd->iuser1;
|
||||
pcd->iuser2 = ppcd->iuser2;
|
||||
|
||||
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
|
||||
}
|
||||
// m_iQuakeItems
|
||||
pcd->iuser3 = ppcd->iuser3;
|
||||
// m_iQuakeWeapon #
|
||||
pcd->fuser1 = ppcd->fuser1;
|
||||
// m_iNailIndex
|
||||
pcd->fuser2 = ppcd->fuser2;
|
||||
// m_iRuneStatus
|
||||
pcd->fuser3 = ppcd->fuser3;
|
||||
|
||||
memcpy( wd, pwd, 32 * sizeof( weapon_data_t ) );
|
||||
}
|
||||
|
||||
/*
|
||||
//#define TEST_IT
|
||||
#if defined( TEST_IT )
|
||||
|
||||
cl_entity_t mymodel[9];
|
||||
|
||||
void MoveModel( void )
|
||||
{
|
||||
cl_entity_t *player;
|
||||
int i, j;
|
||||
int modelindex;
|
||||
struct model_s *mod;
|
||||
|
||||
// Load it up with some bogus data
|
||||
player = gEngfuncs.GetLocalPlayer();
|
||||
if ( !player )
|
||||
return;
|
||||
|
||||
mod = gEngfuncs.CL_LoadModel( "models/sentry3.mdl", &modelindex );
|
||||
for ( i = 0; i < 3; i++ )
|
||||
{
|
||||
for ( j = 0; j < 3; j++ )
|
||||
{
|
||||
// Don't draw over ourself...
|
||||
if ( ( i == 1 ) && ( j == 1 ) )
|
||||
continue;
|
||||
|
||||
mymodel[ i * 3 + j ] = *player;
|
||||
|
||||
mymodel[ i * 3 + j ].player = 0;
|
||||
|
||||
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 );
|
||||
|
||||
gEngfuncs.CL_CreateVisibleEntity( ET_NORMAL, &mymodel[i*3+j] );
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//#define TRACE_TEST
|
||||
#if defined( TRACE_TEST )
|
||||
|
||||
extern int hitent;
|
||||
|
||||
cl_entity_t hit;
|
||||
|
||||
void TraceModel( void )
|
||||
{
|
||||
cl_entity_t *ent;
|
||||
|
||||
if ( hitent <= 0 )
|
||||
return;
|
||||
|
||||
// Load it up with some bogus data
|
||||
ent = gEngfuncs.GetEntityByIndex( hitent );
|
||||
if ( !ent )
|
||||
return;
|
||||
|
||||
hit = *ent;
|
||||
//hit.curstate.rendermode = kRenderTransTexture;
|
||||
//hit.curstate.renderfx = kRenderFxGlowShell;
|
||||
//hit.curstate.renderamt = 100;
|
||||
|
||||
hit.origin[2] += 40;
|
||||
|
||||
gEngfuncs.CL_CreateVisibleEntity( ET_NORMAL, &hit );
|
||||
}
|
||||
|
||||
#endif
|
||||
*/
|
||||
|
||||
/*
|
||||
void ParticleCallback( struct particle_s *particle, float frametime )
|
||||
{
|
||||
int i;
|
||||
|
||||
for ( i = 0; i < 3; i++ )
|
||||
{
|
||||
particle->org[ i ] += particle->vel[ i ] * frametime;
|
||||
}
|
||||
}
|
||||
|
||||
void Particles( void )
|
||||
{
|
||||
static float lasttime;
|
||||
float curtime;
|
||||
|
||||
curtime = gEngfuncs.GetClientTime();
|
||||
|
||||
if ( ( curtime - lasttime ) < 10.0 )
|
||||
return;
|
||||
|
||||
lasttime = curtime;
|
||||
|
||||
// Create a few particles
|
||||
particle_t *p;
|
||||
int i, j;
|
||||
|
||||
for ( i = 0; i < 100; i++ )
|
||||
{
|
||||
p = gEngfuncs.pEfxAPI->R_AllocParticle( ParticleCallback );
|
||||
if ( !p )
|
||||
break;
|
||||
|
||||
for ( j = 0; j < 3; j++ )
|
||||
{
|
||||
p->org[ j ] = v_origin[ j ];
|
||||
p->vel[ j ] = gEngfuncs.pfnRandomFloat( -100.0, 100.0 );
|
||||
}
|
||||
|
||||
p->color = gEngfuncs.pfnRandomLong( 0, 255 );
|
||||
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
|
||||
p->die += 5.0;
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void TempEntCallback ( struct tempent_s *ent, float frametime, float currenttime )
|
||||
{
|
||||
int i;
|
||||
|
||||
for ( i = 0; i < 3; i++ )
|
||||
{
|
||||
ent->entity.curstate.origin[ i ] += ent->entity.baseline.origin[ i ] * frametime;
|
||||
}
|
||||
}
|
||||
|
||||
void TempEnts( void )
|
||||
{
|
||||
static float lasttime;
|
||||
float curtime;
|
||||
|
||||
curtime = gEngfuncs.GetClientTime();
|
||||
|
||||
if ( ( curtime - lasttime ) < 10.0 )
|
||||
return;
|
||||
|
||||
lasttime = curtime;
|
||||
|
||||
TEMPENTITY *p;
|
||||
int i, j;
|
||||
struct model_s *mod;
|
||||
vec3_t origin;
|
||||
int index;
|
||||
|
||||
mod = gEngfuncs.CL_LoadModel( "sprites/laserdot.spr", &index );
|
||||
|
||||
for ( i = 0; i < 100; i++ )
|
||||
{
|
||||
for ( j = 0; j < 3; j++ )
|
||||
{
|
||||
origin[ j ] = v_origin[ j ];
|
||||
if ( j != 2 )
|
||||
{
|
||||
origin[ j ] += 75;
|
||||
}
|
||||
}
|
||||
|
||||
p = gEngfuncs.pEfxAPI->CL_TentEntAllocCustom( (float *)&origin, mod, 0, TempEntCallback );
|
||||
if ( !p )
|
||||
break;
|
||||
|
||||
for ( j = 0; j < 3; j++ )
|
||||
{
|
||||
p->entity.curstate.origin[ j ] = origin[ j ];
|
||||
|
||||
// Store velocity in baseline origin
|
||||
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
|
||||
p->die += 10.0;
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
=========================
|
||||
HUD_CreateEntities
|
||||
|
||||
Gives us a chance to add additional entities to the render this frame
|
||||
=========================
|
||||
*/
|
||||
void EXPORT HUD_CreateEntities( void )
|
||||
{
|
||||
// e.g., create a persistent cl_entity_t somewhere.
|
||||
// Load an appropriate model into it ( gEngfuncs.CL_LoadModel )
|
||||
// Call gEngfuncs.CL_CreateVisibleEntity to add it to the visedicts list
|
||||
/*
|
||||
#if defined( TEST_IT )
|
||||
MoveModel();
|
||||
#endif
|
||||
|
||||
#if defined( TRACE_TEST )
|
||||
TraceModel();
|
||||
#endif
|
||||
*/
|
||||
/*
|
||||
Particles();
|
||||
*/
|
||||
/*
|
||||
TempEnts();
|
||||
*/
|
||||
// Add in any game specific objects
|
||||
Game_AddObjects();
|
||||
|
||||
GetClientVoiceMgr()->CreateEntities();
|
||||
}
|
||||
|
||||
/*
|
||||
=========================
|
||||
HUD_StudioEvent
|
||||
|
||||
The entity's studio model description indicated an event was
|
||||
fired during this frame, handle the event by it's tag ( e.g., muzzleflash, sound )
|
||||
=========================
|
||||
*/
|
||||
void EXPORT HUD_StudioEvent( const struct mstudioevent_s *event, const struct cl_entity_s *entity )
|
||||
{
|
||||
switch( event->event )
|
||||
{
|
||||
case 5001:
|
||||
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) );
|
||||
break;
|
||||
case 5021:
|
||||
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) );
|
||||
break;
|
||||
case 5002:
|
||||
gEngfuncs.pEfxAPI->R_SparkEffect( (float *)&entity->attachment[0], atoi( event->options), -100, 100 );
|
||||
break;
|
||||
// Client side sound
|
||||
case 5004:
|
||||
gEngfuncs.pfnPlaySoundByNameAtLocation( (char *)event->options, 1.0, (float *)&entity->attachment[0] );
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
=================
|
||||
CL_UpdateTEnts
|
||||
|
||||
Simulation and cleanup of temporary entities
|
||||
=================
|
||||
*/
|
||||
void EXPORT HUD_TempEntUpdate (
|
||||
double frametime, // Simulation time
|
||||
double client_time, // Absolute time on client
|
||||
double cl_gravity, // True gravity on client
|
||||
TEMPENTITY **ppTempEntFree, // List of freed temporary ents
|
||||
TEMPENTITY **ppTempEntActive, // List
|
||||
int ( *Callback_AddVisibleEntity )( cl_entity_t *pEntity ),
|
||||
void ( *Callback_TempEntPlaySound )( TEMPENTITY *pTemp, float damp ) )
|
||||
{
|
||||
static int gTempEntFrame = 0;
|
||||
int i;
|
||||
TEMPENTITY *pTemp, *pnext, *pprev;
|
||||
float freq, gravity, gravitySlow, life, fastFreq;
|
||||
|
||||
// Nothing to simulate
|
||||
if ( !*ppTempEntActive )
|
||||
return;
|
||||
|
||||
// in order to have tents collide with players, we have to run the player prediction code so
|
||||
// that the client has the player list. We run this code once when we detect any COLLIDEALL
|
||||
// tent, then set this BOOL to true so the code doesn't get run again if there's more than
|
||||
// one COLLIDEALL ent for this update. (often are).
|
||||
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 ( -1 );
|
||||
|
||||
// !!!BUGBUG -- This needs to be time based
|
||||
gTempEntFrame = (gTempEntFrame+1) & 31;
|
||||
|
||||
pTemp = *ppTempEntActive;
|
||||
|
||||
// !!! Don't simulate while paused.... This is sort of a hack, revisit.
|
||||
if ( frametime <= 0 )
|
||||
{
|
||||
while ( pTemp )
|
||||
{
|
||||
if ( !(pTemp->flags & FTENT_NOMODEL ) )
|
||||
{
|
||||
Callback_AddVisibleEntity( &pTemp->entity );
|
||||
}
|
||||
pTemp = pTemp->next;
|
||||
}
|
||||
goto finish;
|
||||
}
|
||||
|
||||
pprev = NULL;
|
||||
freq = client_time * 0.01;
|
||||
fastFreq = client_time * 5.5;
|
||||
gravity = -frametime * cl_gravity;
|
||||
gravitySlow = gravity * 0.5;
|
||||
|
||||
while ( pTemp )
|
||||
{
|
||||
int active;
|
||||
|
||||
active = 1;
|
||||
|
||||
life = pTemp->die - client_time;
|
||||
pnext = pTemp->next;
|
||||
if ( life < 0 )
|
||||
{
|
||||
if ( pTemp->flags & FTENT_FADEOUT )
|
||||
{
|
||||
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 )
|
||||
active = 0;
|
||||
|
||||
}
|
||||
else
|
||||
active = 0;
|
||||
}
|
||||
if ( !active ) // Kill it
|
||||
{
|
||||
pTemp->next = *ppTempEntFree;
|
||||
*ppTempEntFree = pTemp;
|
||||
if ( !pprev ) // Deleting at head of list
|
||||
*ppTempEntActive = pnext;
|
||||
else
|
||||
pprev->next = pnext;
|
||||
}
|
||||
else
|
||||
{
|
||||
pprev = pTemp;
|
||||
|
||||
VectorCopy( pTemp->entity.origin, pTemp->entity.prevstate.origin );
|
||||
|
||||
if ( pTemp->flags & FTENT_SPARKSHOWER )
|
||||
{
|
||||
// Adjust speed if it's time
|
||||
// Scale is next think time
|
||||
if ( client_time > pTemp->entity.baseline.scale )
|
||||
{
|
||||
// Show Sparks
|
||||
gEngfuncs.pEfxAPI->R_SparkEffect( pTemp->entity.origin, 8, -200, 200 );
|
||||
|
||||
// Reduce life
|
||||
pTemp->entity.baseline.framerate -= 0.1;
|
||||
|
||||
if ( pTemp->entity.baseline.framerate <= 0.0 )
|
||||
{
|
||||
pTemp->die = client_time;
|
||||
}
|
||||
else
|
||||
{
|
||||
// So it will die no matter what
|
||||
pTemp->die = client_time + 0.5;
|
||||
|
||||
// Next think
|
||||
pTemp->entity.baseline.scale = client_time + 0.1;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if ( pTemp->flags & FTENT_PLYRATTACHMENT )
|
||||
{
|
||||
cl_entity_t *pClient;
|
||||
|
||||
pClient = gEngfuncs.GetEntityByIndex( pTemp->clientIndex );
|
||||
|
||||
VectorAdd( pClient->origin, pTemp->tentOffset, pTemp->entity.origin );
|
||||
}
|
||||
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[2] += pTemp->entity.baseline.origin[2] * frametime;
|
||||
}
|
||||
else if ( pTemp->flags & FTENT_SPIRAL )
|
||||
{
|
||||
float s, c;
|
||||
s = sin( pTemp->entity.baseline.origin[2] + fastFreq );
|
||||
c = cos( pTemp->entity.baseline.origin[2] + fastFreq );
|
||||
|
||||
pTemp->entity.origin[0] += pTemp->entity.baseline.origin[0] * frametime + 8 * sin( client_time * 20 + (int)pTemp );
|
||||
pTemp->entity.origin[1] += pTemp->entity.baseline.origin[1] * frametime + 4 * sin( client_time * 30 + (int)pTemp );
|
||||
pTemp->entity.origin[2] += pTemp->entity.baseline.origin[2] * frametime;
|
||||
}
|
||||
else
|
||||
{
|
||||
for ( i = 0; i < 3; i++ )
|
||||
pTemp->entity.origin[i] += pTemp->entity.baseline.origin[i] * frametime;
|
||||
}
|
||||
|
||||
if ( pTemp->flags & FTENT_SPRANIMATE )
|
||||
{
|
||||
pTemp->entity.curstate.frame += frametime * pTemp->entity.curstate.framerate;
|
||||
if ( pTemp->entity.curstate.frame >= pTemp->frameMax )
|
||||
{
|
||||
pTemp->entity.curstate.frame = pTemp->entity.curstate.frame - (int)(pTemp->entity.curstate.frame);
|
||||
|
||||
if ( !(pTemp->flags & FTENT_SPRANIMATELOOP) )
|
||||
{
|
||||
// this animating sprite isn't set to loop, so destroy it.
|
||||
pTemp->die = client_time;
|
||||
pTemp = pnext;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if ( pTemp->flags & FTENT_SPRCYCLE )
|
||||
{
|
||||
pTemp->entity.curstate.frame += frametime * 10;
|
||||
if ( pTemp->entity.curstate.frame >= pTemp->frameMax )
|
||||
{
|
||||
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);
|
||||
#endif
|
||||
|
||||
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;
|
||||
pTemp->entity.angles[2] += pTemp->entity.baseline.angles[2] * frametime;
|
||||
|
||||
VectorCopy( pTemp->entity.angles, pTemp->entity.latched.prevangles );
|
||||
}
|
||||
|
||||
if ( pTemp->flags & (FTENT_COLLIDEALL | FTENT_COLLIDEWORLD) )
|
||||
{
|
||||
vec3_t traceNormal;
|
||||
float traceFraction = 1;
|
||||
|
||||
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 )
|
||||
{
|
||||
pe = gEngfuncs.pEventAPI->EV_GetPhysent( pmtrace.ent );
|
||||
|
||||
if ( !pmtrace.ent || ( pe->info != pTemp->clientIndex ) )
|
||||
{
|
||||
traceFraction = pmtrace.fraction;
|
||||
VectorCopy( pmtrace.plane.normal, traceNormal );
|
||||
|
||||
if ( pTemp->hitcallback )
|
||||
{
|
||||
(*pTemp->hitcallback)( pTemp, &pmtrace );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
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 );
|
||||
|
||||
if ( pmtrace.fraction != 1 )
|
||||
{
|
||||
traceFraction = pmtrace.fraction;
|
||||
VectorCopy( pmtrace.plane.normal, traceNormal );
|
||||
|
||||
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 )
|
||||
{
|
||||
pTemp->entity.baseline.framerate = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
if ( pTemp->hitcallback )
|
||||
{
|
||||
(*pTemp->hitcallback)( pTemp, &pmtrace );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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 );
|
||||
// Damp velocity
|
||||
damp = pTemp->bounceFactor;
|
||||
if ( pTemp->flags & (FTENT_GRAVITY|FTENT_SLOWGRAVITY) )
|
||||
{
|
||||
damp *= 0.5;
|
||||
if ( traceNormal[2] > 0.9 ) // Hit floor?
|
||||
{
|
||||
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->entity.angles[0] = 0;
|
||||
pTemp->entity.angles[2] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (pTemp->hitSound)
|
||||
{
|
||||
Callback_TempEntPlaySound(pTemp, damp);
|
||||
}
|
||||
|
||||
if (pTemp->flags & FTENT_COLLIDEKILL)
|
||||
{
|
||||
// die on impact
|
||||
pTemp->flags &= ~FTENT_FADEOUT;
|
||||
pTemp->die = client_time;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Reflect velocity
|
||||
if ( damp != 0 )
|
||||
{
|
||||
proj = DotProduct( pTemp->entity.baseline.origin, traceNormal );
|
||||
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 )
|
||||
{
|
||||
|
||||
VectorScale( pTemp->entity.baseline.origin, damp, pTemp->entity.baseline.origin );
|
||||
VectorScale( pTemp->entity.angles, 0.9, pTemp->entity.angles );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if ( (pTemp->flags & FTENT_FLICKER) && gTempEntFrame == pTemp->entity.curstate.effects )
|
||||
{
|
||||
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;
|
||||
dl->color.b = 0;
|
||||
dl->die = client_time + 0.01;
|
||||
}
|
||||
|
||||
if ( pTemp->flags & FTENT_SMOKETRAIL )
|
||||
{
|
||||
if ( pTemp->entity.baseline.sequence == 69 ) // Little smoke
|
||||
gEngfuncs.pEfxAPI->R_RocketTrail ( pTemp->entity.prevstate.origin, pTemp->entity.origin, 1 );
|
||||
else if ( pTemp->entity.baseline.sequence == 70 ) // Rocket Powered smoke ( heh? )
|
||||
gEngfuncs.pEfxAPI->R_RocketTrail ( pTemp->entity.prevstate.origin, pTemp->entity.origin, 0 );
|
||||
else
|
||||
gEngfuncs.pEfxAPI->R_RocketTrail ( pTemp->entity.prevstate.origin, pTemp->entity.origin, 2 );
|
||||
}
|
||||
|
||||
|
||||
if ( pTemp->flags & FTENT_GRAVITY )
|
||||
pTemp->entity.baseline.origin[2] += gravity;
|
||||
else if ( pTemp->flags & FTENT_SLOWGRAVITY )
|
||||
pTemp->entity.baseline.origin[2] += gravitySlow;
|
||||
|
||||
if ( pTemp->flags & FTENT_CLIENTCUSTOM )
|
||||
{
|
||||
if ( pTemp->callback )
|
||||
{
|
||||
( *pTemp->callback )( pTemp, frametime, client_time );
|
||||
}
|
||||
}
|
||||
|
||||
// Cull to PVS (not frustum cull, just PVS)
|
||||
if ( !(pTemp->flags & FTENT_NOMODEL ) )
|
||||
{
|
||||
if ( !Callback_AddVisibleEntity( &pTemp->entity ) )
|
||||
{
|
||||
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
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
pTemp = pnext;
|
||||
}
|
||||
|
||||
finish:
|
||||
// Restore state info
|
||||
gEngfuncs.pEventAPI->EV_PopPMStates();
|
||||
}
|
||||
|
||||
/*
|
||||
=================
|
||||
HUD_GetUserEntity
|
||||
|
||||
If you specify negative numbers for beam start and end point entities, then
|
||||
the engine will call back into this function requesting a pointer to a cl_entity_t
|
||||
object that describes the entity to attach the beam onto.
|
||||
|
||||
Indices must start at 1, not zero.
|
||||
=================
|
||||
*/
|
||||
cl_entity_t EXPORT *HUD_GetUserEntity( int index )
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -1,198 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
// shared event functions
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "const.h"
|
||||
#include "entity_state.h"
|
||||
#include "cl_entity.h"
|
||||
|
||||
#include "r_efx.h"
|
||||
|
||||
#include "eventscripts.h"
|
||||
#include "event_api.h"
|
||||
|
||||
/*
|
||||
=================
|
||||
GetEntity
|
||||
|
||||
Return's the requested cl_entity_t
|
||||
=================
|
||||
*/
|
||||
struct cl_entity_s *GetEntity( int idx )
|
||||
{
|
||||
return gEngfuncs.GetEntityByIndex( idx );
|
||||
}
|
||||
|
||||
/*
|
||||
=================
|
||||
GetViewEntity
|
||||
|
||||
Return's the current weapon/view model
|
||||
=================
|
||||
*/
|
||||
struct cl_entity_s *GetViewEntity( void )
|
||||
{
|
||||
return gEngfuncs.GetViewModel();
|
||||
}
|
||||
|
||||
/*
|
||||
=================
|
||||
EV_CreateTracer
|
||||
|
||||
Creates a tracer effect
|
||||
=================
|
||||
*/
|
||||
void EV_CreateTracer( float *start, float *end )
|
||||
{
|
||||
gEngfuncs.pEfxAPI->R_TracerEffect( start, end );
|
||||
}
|
||||
|
||||
/*
|
||||
=================
|
||||
EV_IsPlayer
|
||||
|
||||
Is the entity's index in the player range?
|
||||
=================
|
||||
*/
|
||||
qboolean EV_IsPlayer( int idx )
|
||||
{
|
||||
if ( idx >= 1 && idx <= gEngfuncs.GetMaxClients() )
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
=================
|
||||
EV_IsLocal
|
||||
|
||||
Is the entity == the local player
|
||||
=================
|
||||
*/
|
||||
qboolean EV_IsLocal( int idx )
|
||||
{
|
||||
return gEngfuncs.pEventAPI->EV_IsLocal( idx - 1 ) ? true : false;
|
||||
}
|
||||
|
||||
/*
|
||||
=================
|
||||
EV_GetGunPosition
|
||||
|
||||
Figure out the height of the gun
|
||||
=================
|
||||
*/
|
||||
void EV_GetGunPosition( event_args_t *args, float *pos, float *origin )
|
||||
{
|
||||
int idx;
|
||||
vec3_t view_ofs;
|
||||
|
||||
idx = args->entindex;
|
||||
|
||||
VectorClear( view_ofs );
|
||||
view_ofs[2] = DEFAULT_VIEWHEIGHT;
|
||||
|
||||
if ( EV_IsPlayer( idx ) )
|
||||
{
|
||||
if ( EV_IsLocal( idx ) )
|
||||
{
|
||||
// Grab predicted result for local player
|
||||
gEngfuncs.pEventAPI->EV_LocalPlayerViewheight( view_ofs );
|
||||
}
|
||||
else if ( args->ducking == 1 )
|
||||
{
|
||||
view_ofs[2] = VEC_DUCK_VIEW;
|
||||
}
|
||||
}
|
||||
|
||||
VectorAdd( origin, view_ofs, pos );
|
||||
}
|
||||
|
||||
/*
|
||||
=================
|
||||
EV_EjectBrass
|
||||
|
||||
Bullet shell casings
|
||||
=================
|
||||
*/
|
||||
void EV_EjectBrass( float *origin, float *velocity, float rotation, int model, int soundtype )
|
||||
{
|
||||
vec3_t endpos;
|
||||
VectorClear( endpos );
|
||||
endpos[1] = rotation;
|
||||
gEngfuncs.pEfxAPI->R_TempModel( origin, velocity, endpos, 2.5, model, soundtype );
|
||||
}
|
||||
|
||||
/*
|
||||
=================
|
||||
EV_GetDefaultShellInfo
|
||||
|
||||
Determine where to eject shells from
|
||||
=================
|
||||
*/
|
||||
void EV_GetDefaultShellInfo( event_args_t *args, float *origin, float *velocity, float *ShellVelocity, float *ShellOrigin, float *forward, float *right, float *up, float forwardScale, float upScale, float rightScale )
|
||||
{
|
||||
int i;
|
||||
vec3_t view_ofs;
|
||||
float fR, fU;
|
||||
|
||||
int idx;
|
||||
|
||||
idx = args->entindex;
|
||||
|
||||
VectorClear( view_ofs );
|
||||
view_ofs[2] = DEFAULT_VIEWHEIGHT;
|
||||
|
||||
if ( EV_IsPlayer( idx ) )
|
||||
{
|
||||
if ( EV_IsLocal( idx ) )
|
||||
{
|
||||
gEngfuncs.pEventAPI->EV_LocalPlayerViewheight( view_ofs );
|
||||
}
|
||||
else if ( args->ducking == 1 )
|
||||
{
|
||||
view_ofs[2] = VEC_DUCK_VIEW;
|
||||
}
|
||||
}
|
||||
|
||||
fR = gEngfuncs.pfnRandomFloat( 50, 70 );
|
||||
fU = gEngfuncs.pfnRandomFloat( 100, 150 );
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
=================
|
||||
EV_MuzzleFlash
|
||||
|
||||
Flag weapon/view model for muzzle flash
|
||||
=================
|
||||
*/
|
||||
void EV_MuzzleFlash( void )
|
||||
{
|
||||
// Add muzzle flash to current weapon model
|
||||
cl_entity_t *ent = GetViewEntity();
|
||||
if ( !ent )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Or in the muzzle flash
|
||||
ent->curstate.effects |= EF_MUZZLEFLASH;
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,96 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#if !defined ( EV_HLDMH )
|
||||
#define EV_HLDMH
|
||||
|
||||
// bullet types
|
||||
typedef enum
|
||||
{
|
||||
BULLET_NONE = 0,
|
||||
BULLET_PLAYER_9MM, // glock
|
||||
BULLET_PLAYER_MP5, // mp5
|
||||
BULLET_PLAYER_357, // python
|
||||
BULLET_PLAYER_BUCKSHOT, // shotgun
|
||||
BULLET_PLAYER_CROWBAR, // crowbar swipe
|
||||
|
||||
BULLET_MONSTER_9MM,
|
||||
BULLET_MONSTER_MP5,
|
||||
BULLET_MONSTER_12MM,
|
||||
} Bullet;
|
||||
|
||||
enum glock_e {
|
||||
GLOCK_IDLE1 = 0,
|
||||
GLOCK_IDLE2,
|
||||
GLOCK_IDLE3,
|
||||
GLOCK_SHOOT,
|
||||
GLOCK_SHOOT_EMPTY,
|
||||
GLOCK_RELOAD,
|
||||
GLOCK_RELOAD_NOT_EMPTY,
|
||||
GLOCK_DRAW,
|
||||
GLOCK_HOLSTER,
|
||||
GLOCK_ADD_SILENCER
|
||||
};
|
||||
|
||||
enum shotgun_e {
|
||||
SHOTGUN_IDLE = 0,
|
||||
SHOTGUN_FIRE,
|
||||
SHOTGUN_FIRE2,
|
||||
SHOTGUN_RELOAD,
|
||||
SHOTGUN_PUMP,
|
||||
SHOTGUN_START_RELOAD,
|
||||
SHOTGUN_DRAW,
|
||||
SHOTGUN_HOLSTER,
|
||||
SHOTGUN_IDLE4,
|
||||
SHOTGUN_IDLE_DEEP
|
||||
};
|
||||
|
||||
enum mp5_e
|
||||
{
|
||||
MP5_LONGIDLE = 0,
|
||||
MP5_IDLE1,
|
||||
MP5_LAUNCH,
|
||||
MP5_RELOAD,
|
||||
MP5_DEPLOY,
|
||||
MP5_FIRE1,
|
||||
MP5_FIRE2,
|
||||
MP5_FIRE3,
|
||||
};
|
||||
|
||||
enum python_e {
|
||||
PYTHON_IDLE1 = 0,
|
||||
PYTHON_FIDGET,
|
||||
PYTHON_FIRE1,
|
||||
PYTHON_RELOAD,
|
||||
PYTHON_HOLSTER,
|
||||
PYTHON_DRAW,
|
||||
PYTHON_IDLE2,
|
||||
PYTHON_IDLE3
|
||||
};
|
||||
|
||||
#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 {
|
||||
GAUSS_IDLE = 0,
|
||||
GAUSS_IDLE2,
|
||||
GAUSS_FIDGET,
|
||||
GAUSS_SPINUP,
|
||||
GAUSS_SPIN,
|
||||
GAUSS_FIRE,
|
||||
GAUSS_FIRE2,
|
||||
GAUSS_HOLSTER,
|
||||
GAUSS_DRAW
|
||||
};
|
||||
|
||||
int EV_HLDM_DamageDecal( int entity, int bitsDamageType );
|
||||
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 *vecSpread, float flDistance, int iBulletType, int iTracerFreq, int *tracerCount );
|
||||
|
||||
#endif // EV_HLDMH
|
||||
|
|
@ -1,30 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
|
||||
void Game_HookEvents( void );
|
||||
|
||||
/*
|
||||
===================
|
||||
EV_HookEvents
|
||||
|
||||
See if game specific code wants to hook any events.
|
||||
===================
|
||||
*/
|
||||
void EV_HookEvents( void )
|
||||
{
|
||||
Game_HookEvents();
|
||||
}
|
||||
|
|
@ -1,73 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
// eventscripts.h
|
||||
#if !defined ( EVENTSCRIPTSH )
|
||||
#define EVENTSCRIPTSH
|
||||
|
||||
// defaults for clientinfo messages
|
||||
#define DEFAULT_VIEWHEIGHT 22
|
||||
#define VEC_DUCK_VIEW 12
|
||||
|
||||
#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 );
|
||||
void EV_GetDefaultShellInfo( struct event_args_s *args, float *origin, float *velocity, float *ShellVelocity, float *ShellOrigin, float *forward, float *right, float *up, float forwardScale, float upScale, float rightScale );
|
||||
qboolean EV_IsLocal( int idx );
|
||||
qboolean EV_IsPlayer( int idx );
|
||||
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
|
||||
|
|
@ -1,146 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// flashlight.cpp
|
||||
//
|
||||
// implementation of CHudFlashlight class
|
||||
//
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "parsemsg.h"
|
||||
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
|
||||
|
||||
DECLARE_MESSAGE(m_Flash, FlashBat)
|
||||
DECLARE_MESSAGE(m_Flash, Flashlight)
|
||||
|
||||
#define BAT_NAME "sprites/%d_Flashlight.spr"
|
||||
|
||||
int CHudFlashlight::Init(void)
|
||||
{
|
||||
m_fFade = 0;
|
||||
m_fOn = 0;
|
||||
|
||||
HOOK_MESSAGE(Flashlight);
|
||||
HOOK_MESSAGE(FlashBat);
|
||||
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
|
||||
gHUD.AddHudElem(this);
|
||||
|
||||
return 1;
|
||||
};
|
||||
|
||||
void CHudFlashlight::Reset(void)
|
||||
{
|
||||
m_fFade = 0;
|
||||
m_fOn = 0;
|
||||
}
|
||||
|
||||
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_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 )
|
||||
{
|
||||
|
||||
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
int x = READ_BYTE();
|
||||
m_iBat = x;
|
||||
m_flBat = ((float)x)/100.0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudFlashlight::Draw(float flTime)
|
||||
{
|
||||
if ( gHUD.m_iHideHUDDisplay & ( HIDEHUD_FLASHLIGHT | HIDEHUD_ALL ) )
|
||||
return 1;
|
||||
|
||||
int r, g, b, x, y, a;
|
||||
wrect_t rc;
|
||||
|
||||
if (m_fOn)
|
||||
a = 225;
|
||||
else
|
||||
a = MIN_ALPHA;
|
||||
|
||||
if (m_flBat < 0.20)
|
||||
UnpackRGB(r,g,b, RGB_REDISH);
|
||||
else
|
||||
UnpackRGB(r,g,b, RGB_YELLOWISH);
|
||||
|
||||
ScaleColors(r, g, b, a);
|
||||
|
||||
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);
|
||||
|
||||
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)
|
||||
{
|
||||
rc = *m_prc2;
|
||||
rc.left += iOffset;
|
||||
|
||||
SPR_Set(m_hSprite2, r, g, b );
|
||||
SPR_DrawAdditive( 0, x + iOffset, y, &rc);
|
||||
}
|
||||
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -1,180 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// Geiger.cpp
|
||||
//
|
||||
// implementation of CHudAmmo class
|
||||
//
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "parsemsg.h"
|
||||
|
||||
DECLARE_MESSAGE(m_Geiger, Geiger )
|
||||
|
||||
int CHudGeiger::Init(void)
|
||||
{
|
||||
HOOK_MESSAGE( Geiger );
|
||||
|
||||
m_iGeigerRange = 0;
|
||||
m_iFlags = 0;
|
||||
|
||||
gHUD.AddHudElem(this);
|
||||
|
||||
srand( (unsigned)time( NULL ) );
|
||||
|
||||
return 1;
|
||||
};
|
||||
|
||||
int CHudGeiger::VidInit(void)
|
||||
{
|
||||
return 1;
|
||||
};
|
||||
|
||||
int CHudGeiger::MsgFunc_Geiger(const char *pszName, int iSize, void *pbuf)
|
||||
{
|
||||
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
// update geiger data
|
||||
m_iGeigerRange = READ_BYTE();
|
||||
m_iGeigerRange = m_iGeigerRange << 2;
|
||||
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudGeiger::Draw (float flTime)
|
||||
{
|
||||
int pct;
|
||||
float flvol;
|
||||
int rg[3];
|
||||
int i;
|
||||
|
||||
if (m_iGeigerRange <= 800 && m_iGeigerRange > 0)
|
||||
{
|
||||
// peicewise linear is better than continuous formula for this
|
||||
if (m_iGeigerRange > 600)
|
||||
{
|
||||
pct = 2;
|
||||
flvol = 0.4; //Con_Printf ( "range > 600\n");
|
||||
rg[0] = 1;
|
||||
rg[1] = 1;
|
||||
i = 2;
|
||||
}
|
||||
else if (m_iGeigerRange > 500)
|
||||
{
|
||||
pct = 4;
|
||||
flvol = 0.5; //Con_Printf ( "range > 500\n");
|
||||
rg[0] = 1;
|
||||
rg[1] = 2;
|
||||
i = 2;
|
||||
}
|
||||
else if (m_iGeigerRange > 400)
|
||||
{
|
||||
pct = 8;
|
||||
flvol = 0.6; //Con_Printf ( "range > 400\n");
|
||||
rg[0] = 1;
|
||||
rg[1] = 2;
|
||||
rg[2] = 3;
|
||||
i = 3;
|
||||
}
|
||||
else if (m_iGeigerRange > 300)
|
||||
{
|
||||
pct = 8;
|
||||
flvol = 0.7; //Con_Printf ( "range > 300\n");
|
||||
rg[0] = 2;
|
||||
rg[1] = 3;
|
||||
rg[2] = 4;
|
||||
i = 3;
|
||||
}
|
||||
else if (m_iGeigerRange > 200)
|
||||
{
|
||||
pct = 28;
|
||||
flvol = 0.78; //Con_Printf ( "range > 200\n");
|
||||
rg[0] = 2;
|
||||
rg[1] = 3;
|
||||
rg[2] = 4;
|
||||
i = 3;
|
||||
}
|
||||
else if (m_iGeigerRange > 150)
|
||||
{
|
||||
pct = 40;
|
||||
flvol = 0.80; //Con_Printf ( "range > 150\n");
|
||||
rg[0] = 3;
|
||||
rg[1] = 4;
|
||||
rg[2] = 5;
|
||||
i = 3;
|
||||
}
|
||||
else if (m_iGeigerRange > 100)
|
||||
{
|
||||
pct = 60;
|
||||
flvol = 0.85; //Con_Printf ( "range > 100\n");
|
||||
rg[0] = 3;
|
||||
rg[1] = 4;
|
||||
rg[2] = 5;
|
||||
i = 3;
|
||||
}
|
||||
else if (m_iGeigerRange > 75)
|
||||
{
|
||||
pct = 80;
|
||||
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)
|
||||
{
|
||||
pct = 90;
|
||||
flvol = 0.95; //Con_Printf ( "range > 50\n");
|
||||
rg[0] = 5;
|
||||
rg[1] = 6;
|
||||
i = 2;
|
||||
}
|
||||
else
|
||||
{
|
||||
pct = 95;
|
||||
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);
|
||||
|
||||
if ((rand() & 127) < pct || (rand() & 127) < pct)
|
||||
{
|
||||
//S_StartDynamicSound (-1, 0, rgsfx[rand() % i], r_origin, flvol, 1.0, 0, 100);
|
||||
char sz[256];
|
||||
|
||||
int j = rand() & 1;
|
||||
if (i > 2)
|
||||
j += rand() & 1;
|
||||
|
||||
sprintf(sz, "player/geiger%d.wav", j + 1);
|
||||
PlaySound(sz, flvol);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -1,476 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// Health.cpp
|
||||
//
|
||||
// implementation of CHudHealth class
|
||||
//
|
||||
|
||||
#include "stdio.h"
|
||||
#include "stdlib.h"
|
||||
#include "math.h"
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "parsemsg.h"
|
||||
#include <string.h>
|
||||
|
||||
|
||||
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] =
|
||||
{
|
||||
DMG_POISON,
|
||||
DMG_ACID,
|
||||
DMG_FREEZE|DMG_SLOWFREEZE,
|
||||
DMG_DROWN,
|
||||
DMG_BURN|DMG_SLOWBURN,
|
||||
DMG_NERVEGAS,
|
||||
DMG_RADIATION,
|
||||
DMG_SHOCK,
|
||||
DMG_CALTROP,
|
||||
DMG_TRANQ,
|
||||
DMG_CONCUSS,
|
||||
DMG_HALLUC
|
||||
};
|
||||
|
||||
int CHudHealth::Init(void)
|
||||
{
|
||||
HOOK_MESSAGE(Health);
|
||||
HOOK_MESSAGE(Damage);
|
||||
m_iHealth = 100;
|
||||
m_fFade = 0;
|
||||
m_iFlags = 0;
|
||||
m_bitsDamage = 0;
|
||||
m_fAttackFront = m_fAttackRear = m_fAttackRight = m_fAttackLeft = 0;
|
||||
giDmgHeight = 0;
|
||||
giDmgWidth = 0;
|
||||
|
||||
memset(m_dmg, 0, sizeof(DAMAGE_IMAGE) * NUM_DMG_TYPES);
|
||||
|
||||
|
||||
gHUD.AddHudElem(this);
|
||||
return 1;
|
||||
}
|
||||
|
||||
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++ )
|
||||
{
|
||||
m_dmg[i].fExpire = 0;
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudHealth:: MsgFunc_Health(const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
// TODO: update local health data
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
int x = READ_BYTE();
|
||||
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
|
||||
// Only update the fade if we've changed health
|
||||
if (x != m_iHealth)
|
||||
{
|
||||
m_fFade = FADE_TIME;
|
||||
m_iHealth = x;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int CHudHealth:: MsgFunc_Damage(const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
int armor = READ_BYTE(); // armor
|
||||
int damageTaken = READ_BYTE(); // health
|
||||
long bitsDamage = READ_LONG(); // damage bits
|
||||
|
||||
vec3_t vecFrom;
|
||||
|
||||
for ( int i = 0 ; i < 3 ; i++)
|
||||
vecFrom[i] = READ_COORD();
|
||||
|
||||
UpdateTiles(gHUD.m_flTime, bitsDamage);
|
||||
|
||||
// Actually took damage?
|
||||
if ( damageTaken > 0 || armor > 0 )
|
||||
CalcDamageDirection(vecFrom);
|
||||
|
||||
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)
|
||||
iHealth -= 25;
|
||||
else if ( iHealth < 0 )
|
||||
iHealth = 0;
|
||||
#if 0
|
||||
g = iHealth * 255 / 100;
|
||||
r = 255 - g;
|
||||
b = 0;
|
||||
#else
|
||||
if (m_iHealth > 25)
|
||||
{
|
||||
UnpackRGB(r,g,b, RGB_YELLOWISH);
|
||||
}
|
||||
else
|
||||
{
|
||||
r = 250;
|
||||
g = 0;
|
||||
b = 0;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
int CHudHealth::Draw(float flTime)
|
||||
{
|
||||
int r, g, b;
|
||||
int a = 0, x, y;
|
||||
int HealthWidth;
|
||||
|
||||
// if (m_iHealth <= 0)
|
||||
// return 1;
|
||||
|
||||
if ( gHUD.m_iHideHUDDisplay & HIDEHUD_HEALTH )
|
||||
return 1;
|
||||
|
||||
if ( !m_hSprite )
|
||||
m_hSprite = LoadSprite(PAIN_NAME);
|
||||
|
||||
// Has health changed? Flash the health #
|
||||
if (m_fFade)
|
||||
{
|
||||
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;
|
||||
|
||||
}
|
||||
else
|
||||
a = MIN_ALPHA;
|
||||
|
||||
// If health is getting low, make it bright red
|
||||
if (m_iHealth <= 15)
|
||||
a = 255;
|
||||
|
||||
GetPainColor( r, g, b );
|
||||
ScaleColors(r, g, b, a );
|
||||
|
||||
// Only draw health if we have the 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;
|
||||
|
||||
y = ScreenHeight - gHUD.m_iFontHeight - gHUD.m_iFontHeight / 2;
|
||||
x = CrossWidth /2;
|
||||
|
||||
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 += HealthWidth/2;
|
||||
|
||||
int iHeight = gHUD.m_iFontHeight;
|
||||
int iWidth = HealthWidth/10;
|
||||
FillRGBA(x, y, iWidth, iHeight, 255, 160, 0, a);
|
||||
}
|
||||
|
||||
DrawDamage(flTime);
|
||||
return DrawPain(flTime);
|
||||
}
|
||||
|
||||
void CHudHealth::CalcDamageDirection(vec3_t vecFrom)
|
||||
{
|
||||
vec3_t forward, right, up;
|
||||
float side, front;
|
||||
vec3_t vecOrigin, vecAngles;
|
||||
|
||||
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));
|
||||
|
||||
|
||||
VectorSubtract (vecFrom, vecOrigin, vecFrom);
|
||||
|
||||
float flDistToTarget = vecFrom.Length();
|
||||
|
||||
vecFrom = vecFrom.Normalize();
|
||||
AngleVectors (vecAngles, forward, right, up);
|
||||
|
||||
front = DotProduct (vecFrom, right);
|
||||
side = DotProduct (vecFrom, forward);
|
||||
|
||||
if (flDistToTarget <= 50)
|
||||
{
|
||||
m_fAttackFront = m_fAttackRear = m_fAttackRight = m_fAttackLeft = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (side > 0)
|
||||
{
|
||||
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);
|
||||
}
|
||||
|
||||
if (front > 0)
|
||||
{
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int CHudHealth::DrawPain(float flTime)
|
||||
{
|
||||
if (!(m_fAttackFront || m_fAttackRear || m_fAttackLeft || m_fAttackRight))
|
||||
return 1;
|
||||
|
||||
int r, g, b;
|
||||
int x, y, a, shade;
|
||||
|
||||
// TODO: get the shift value of the health
|
||||
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);
|
||||
m_fAttackFront = max( 0, m_fAttackFront - fFade );
|
||||
} else
|
||||
m_fAttackFront = 0;
|
||||
|
||||
if (m_fAttackRight > 0.4)
|
||||
{
|
||||
GetPainColor(r,g,b);
|
||||
shade = a * max( m_fAttackRight, 0.5 );
|
||||
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);
|
||||
m_fAttackRight = max( 0, m_fAttackRight - fFade );
|
||||
} else
|
||||
m_fAttackRight = 0;
|
||||
|
||||
if (m_fAttackRear > 0.4)
|
||||
{
|
||||
GetPainColor(r,g,b);
|
||||
shade = a * max( m_fAttackRear, 0.5 );
|
||||
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);
|
||||
m_fAttackRear = max( 0, m_fAttackRear - fFade );
|
||||
} else
|
||||
m_fAttackRear = 0;
|
||||
|
||||
if (m_fAttackLeft > 0.4)
|
||||
{
|
||||
GetPainColor(r,g,b);
|
||||
shade = a * max( m_fAttackLeft, 0.5 );
|
||||
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);
|
||||
|
||||
m_fAttackLeft = max( 0, m_fAttackLeft - fFade );
|
||||
} else
|
||||
m_fAttackLeft = 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudHealth::DrawDamage(float flTime)
|
||||
{
|
||||
int r, g, b, a;
|
||||
DAMAGE_IMAGE *pdmg;
|
||||
|
||||
if (!m_bitsDamage)
|
||||
return 1;
|
||||
|
||||
UnpackRGB(r,g,b, RGB_YELLOWISH);
|
||||
|
||||
a = (int)( fabs(sin(flTime*2)) * 256.0);
|
||||
|
||||
ScaleColors(r, g, b, a);
|
||||
|
||||
// Draw all the items
|
||||
int i;
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// check for bits that should be expired
|
||||
for ( i = 0; i < NUM_DMG_TYPES; i++ )
|
||||
{
|
||||
DAMAGE_IMAGE *pdmg = &m_dmg[i];
|
||||
|
||||
if ( m_bitsDamage & giDmgFlags[i] )
|
||||
{
|
||||
pdmg->fExpire = min( flTime + DMG_IMAGE_LIFE, pdmg->fExpire );
|
||||
|
||||
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;
|
||||
|
||||
int y = pdmg->y;
|
||||
pdmg->x = pdmg->y = 0;
|
||||
|
||||
// move everyone above down
|
||||
for (int j = 0; j < NUM_DMG_TYPES; j++)
|
||||
{
|
||||
pdmg = &m_dmg[j];
|
||||
if ((pdmg->y) && (pdmg->y < y))
|
||||
pdmg->y += giDmgHeight;
|
||||
|
||||
}
|
||||
|
||||
m_bitsDamage &= ~giDmgFlags[i]; // clear the bits
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
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++)
|
||||
{
|
||||
pdmg = &m_dmg[i];
|
||||
|
||||
// Is this one already on?
|
||||
if (m_bitsDamage & giDmgFlags[i])
|
||||
{
|
||||
pdmg->fExpire = flTime + DMG_IMAGE_LIFE; // extend the duration
|
||||
if (!pdmg->fBaseline)
|
||||
pdmg->fBaseline = flTime;
|
||||
}
|
||||
|
||||
// Are we just turning it on?
|
||||
if (bitsOn & giDmgFlags[i])
|
||||
{
|
||||
// put this one at the bottom
|
||||
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++)
|
||||
{
|
||||
if (j == i)
|
||||
continue;
|
||||
|
||||
pdmg = &m_dmg[j];
|
||||
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;
|
||||
}
|
||||
|
||||
|
|
@ -1,130 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
|
||||
#define DMG_IMAGE_LIFE 2 // seconds that image is up
|
||||
|
||||
#define DMG_IMAGE_POISON 0
|
||||
#define DMG_IMAGE_ACID 1
|
||||
#define DMG_IMAGE_COLD 2
|
||||
#define DMG_IMAGE_DROWN 3
|
||||
#define DMG_IMAGE_BURN 4
|
||||
#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
|
||||
#define DMG_IMAGE_CONCUSS 10
|
||||
#define DMG_IMAGE_HALLUC 11
|
||||
#define NUM_DMG_TYPES 12
|
||||
// instant damage
|
||||
|
||||
#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)
|
||||
|
||||
// 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;
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
class CHudHealth: public CHudBase
|
||||
{
|
||||
public:
|
||||
virtual int Init( void );
|
||||
virtual int VidInit( void );
|
||||
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 m_iHealth;
|
||||
int m_HUD_dmg_bio;
|
||||
int m_HUD_cross;
|
||||
|
||||
void GetPainColor( int &r, int &g, int &b );
|
||||
float m_fFade;
|
||||
|
||||
private:
|
||||
HSPRITE m_hSprite;
|
||||
HSPRITE m_hDamage;
|
||||
|
||||
DAMAGE_IMAGE m_dmg[NUM_DMG_TYPES];
|
||||
int m_bitsDamage;
|
||||
|
||||
|
||||
int DrawPain(float fTime);
|
||||
int DrawDamage(float fTime);
|
||||
float m_fAttackFront, m_fAttackRear, m_fAttackLeft, m_fAttackRight;
|
||||
void CalcDamageDirection(vec3_t vecFrom);
|
||||
void UpdateTiles(float fTime, long bits);
|
||||
};
|
||||
|
|
@ -1,594 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// hud.cpp
|
||||
//
|
||||
// implementation of CHud class
|
||||
//
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include "parsemsg.h"
|
||||
#include "hud_servers.h"
|
||||
#include "vgui_viewport.h"
|
||||
#include "demo.h"
|
||||
#include "demo_api.h"
|
||||
#include "voice_status.h"
|
||||
#include "vgui_ScorePanel.h"
|
||||
|
||||
|
||||
class CDMCVoiceStatusHelper : public IVoiceStatusHelper
|
||||
{
|
||||
public:
|
||||
virtual void GetPlayerTextColor(int entindex, int color[3])
|
||||
{
|
||||
color[0] = color[1] = color[2] = 255;
|
||||
|
||||
if( entindex >= 0 && entindex < sizeof(g_PlayerExtraInfo)/sizeof(g_PlayerExtraInfo[0]) )
|
||||
{
|
||||
int iTeam = g_PlayerExtraInfo[entindex].teamnumber;
|
||||
|
||||
if( iTeam >= 0 && iTeam < sizeof(iTeamColors)/sizeof(iTeamColors[0]) )
|
||||
{
|
||||
color[0] = iTeamColors[iTeam][0];
|
||||
color[1] = iTeamColors[iTeam][1];
|
||||
color[2] = iTeamColors[iTeam][2];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
virtual void UpdateCursorState()
|
||||
{
|
||||
gViewPort->UpdateCursorState();
|
||||
}
|
||||
|
||||
virtual int GetAckIconHeight()
|
||||
{
|
||||
return ScreenHeight - gHUD.m_iFontHeight*2 - 6;
|
||||
}
|
||||
|
||||
virtual bool CanShowSpeakerLabels()
|
||||
{
|
||||
if( gViewPort && gViewPort->m_pScoreBoard )
|
||||
return !gViewPort->m_pScoreBoard->isVisible();
|
||||
else
|
||||
return false;
|
||||
}
|
||||
};
|
||||
static CDMCVoiceStatusHelper g_VoiceStatusHelper;
|
||||
|
||||
|
||||
|
||||
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;
|
||||
cvar_t *cl_autowepswitch;
|
||||
cvar_t *cl_rollspeed;
|
||||
cvar_t *cl_rollangle;
|
||||
cvar_t *cl_fov;
|
||||
|
||||
void ShutdownInput (void);
|
||||
|
||||
void __CmdFunc_ToggleServerBrowser( void )
|
||||
{
|
||||
if ( gViewPort )
|
||||
{
|
||||
gViewPort->ToggleServerBrowser();
|
||||
}
|
||||
}
|
||||
|
||||
//DECLARE_MESSAGE(m_Logo, Logo)
|
||||
int __MsgFunc_Logo(const char *pszName, int iSize, void *pbuf)
|
||||
{
|
||||
return gHUD.MsgFunc_Logo(pszName, iSize, pbuf );
|
||||
}
|
||||
|
||||
//DECLARE_MESSAGE(m_Logo, Logo)
|
||||
int __MsgFunc_ResetHUD(const char *pszName, int iSize, void *pbuf)
|
||||
{
|
||||
return gHUD.MsgFunc_ResetHUD(pszName, iSize, pbuf );
|
||||
}
|
||||
|
||||
int __MsgFunc_InitHUD(const char *pszName, int iSize, void *pbuf)
|
||||
{
|
||||
gHUD.MsgFunc_InitHUD( pszName, iSize, pbuf );
|
||||
return 1;
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
return gHUD.MsgFunc_Concuss( pszName, iSize, pbuf );
|
||||
}
|
||||
|
||||
int __MsgFunc_GameMode(const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
return gHUD.MsgFunc_GameMode( pszName, iSize, pbuf );
|
||||
}
|
||||
|
||||
int __MsgFunc_MOTD(const char *pszName, int iSize, void *pbuf)
|
||||
{
|
||||
if (gViewPort)
|
||||
return gViewPort->MsgFunc_MOTD( pszName, iSize, pbuf );
|
||||
return 0;
|
||||
}
|
||||
|
||||
int __MsgFunc_ServerName(const char *pszName, int iSize, void *pbuf)
|
||||
{
|
||||
if (gViewPort)
|
||||
return gViewPort->MsgFunc_ServerName( pszName, iSize, pbuf );
|
||||
return 0;
|
||||
}
|
||||
|
||||
// QUAKECLASSIC
|
||||
int __MsgFunc_QItems(const char *pszName, int iSize, void *pbuf)
|
||||
{
|
||||
return gHUD.MsgFunc_QItems( pszName, iSize, pbuf );
|
||||
}
|
||||
|
||||
int __MsgFunc_ScoreInfo(const char *pszName, int iSize, void *pbuf)
|
||||
{
|
||||
if (gViewPort)
|
||||
return gViewPort->MsgFunc_ScoreInfo( pszName, iSize, pbuf );
|
||||
return 0;
|
||||
}
|
||||
|
||||
int __MsgFunc_TeamInfo(const char *pszName, int iSize, void *pbuf)
|
||||
{
|
||||
if (gViewPort)
|
||||
return gViewPort->MsgFunc_TeamInfo( pszName, iSize, pbuf );
|
||||
return 0;
|
||||
}
|
||||
|
||||
void __CmdFunc_OpenCommandMenu(void)
|
||||
{
|
||||
if ( gViewPort )
|
||||
{
|
||||
gViewPort->ShowCommandMenu( gViewPort->m_StandardMenu );
|
||||
}
|
||||
}
|
||||
|
||||
void __CmdFunc_CloseCommandMenu(void)
|
||||
{
|
||||
if ( gViewPort )
|
||||
{
|
||||
gViewPort->InputSignalHideCommandMenu();
|
||||
}
|
||||
}
|
||||
|
||||
void __CmdFunc_ForceCloseCommandMenu( void )
|
||||
{
|
||||
if ( gViewPort )
|
||||
{
|
||||
gViewPort->HideCommandMenu();
|
||||
}
|
||||
}
|
||||
|
||||
// This is called every time the DLL is loaded
|
||||
void CHud :: Init( void )
|
||||
{
|
||||
HOOK_MESSAGE( Logo );
|
||||
HOOK_MESSAGE( ResetHUD );
|
||||
HOOK_MESSAGE( GameMode );
|
||||
HOOK_MESSAGE( InitHUD );
|
||||
HOOK_MESSAGE( SetFOV );
|
||||
HOOK_MESSAGE( Concuss );
|
||||
|
||||
HOOK_MESSAGE( MOTD );
|
||||
HOOK_MESSAGE( ServerName );
|
||||
|
||||
HOOK_COMMAND( "togglebrowser", ToggleServerBrowser );
|
||||
|
||||
HOOK_COMMAND( "+commandmenu", OpenCommandMenu );
|
||||
HOOK_COMMAND( "-commandmenu", CloseCommandMenu );
|
||||
HOOK_COMMAND( "ForceCloseCommandMenu", ForceCloseCommandMenu );
|
||||
|
||||
// QUAKECLASSIC
|
||||
HOOK_MESSAGE( QItems );
|
||||
HOOK_MESSAGE( ScoreInfo );
|
||||
//HOOK_MESSAGE( TeamScore );
|
||||
HOOK_MESSAGE( TeamInfo );
|
||||
|
||||
m_iLogo = 0;
|
||||
m_iFOV = 0;
|
||||
|
||||
CVAR_CREATE( "zoom_sensitivity_ratio", "1.2", 0 );
|
||||
default_fov = CVAR_CREATE( "default_fov", "90", 0 );
|
||||
cl_lw = gEngfuncs.pfnGetCvarPointer( "cl_lw" );
|
||||
m_pCvarStealMouse = CVAR_CREATE( "hud_capturemouse", "1", FCVAR_ARCHIVE );
|
||||
m_pCvarDraw = CVAR_CREATE( "hud_draw", "1", FCVAR_ARCHIVE );
|
||||
/************************ CLIENT CVAR DEFINITIONS ************************/
|
||||
cl_autowepswitch = gEngfuncs.pfnRegisterVariable ( "cl_autowepswitch", "2", FCVAR_USERINFO|FCVAR_ARCHIVE );
|
||||
cl_rollangle = gEngfuncs.pfnRegisterVariable ( "cl_rollangle", "0.65", FCVAR_CLIENTDLL|FCVAR_ARCHIVE );
|
||||
cl_rollspeed = gEngfuncs.pfnRegisterVariable ( "cl_rollspeed", "300", FCVAR_CLIENTDLL|FCVAR_ARCHIVE );
|
||||
cl_fov = gEngfuncs.pfnRegisterVariable ( "cl_fov", "90", FCVAR_USERINFO|FCVAR_ARCHIVE );
|
||||
/************************ CLIENT CVAR DEFINITIONS ************************/
|
||||
|
||||
m_pSpriteList = NULL;
|
||||
|
||||
// Clear any old HUD list
|
||||
if ( m_pHudList )
|
||||
{
|
||||
HUDLIST *pList;
|
||||
while ( m_pHudList )
|
||||
{
|
||||
pList = m_pHudList;
|
||||
m_pHudList = m_pHudList->pNext;
|
||||
free( pList );
|
||||
}
|
||||
m_pHudList = NULL;
|
||||
}
|
||||
|
||||
// In case we get messages before the first update -- time will be valid
|
||||
m_flTime = 1.0;
|
||||
|
||||
m_Ammo.Init();
|
||||
m_Health.Init();
|
||||
m_SayText.Init();
|
||||
m_Spectator.Init();
|
||||
m_Geiger.Init();
|
||||
m_Train.Init();
|
||||
m_Battery.Init();
|
||||
m_Message.Init();
|
||||
// m_Scoreboard.Init();
|
||||
// m_MOTD.Init();
|
||||
m_StatusBar.Init();
|
||||
m_DeathNotice.Init();
|
||||
m_AmmoSecondary.Init();
|
||||
m_TextMessage.Init();
|
||||
m_StatusIcons.Init();
|
||||
|
||||
GetClientVoiceMgr()->Init(&g_VoiceStatusHelper, (vgui::Panel**)&gViewPort);
|
||||
|
||||
|
||||
m_Menu.Init();
|
||||
|
||||
ServersInit();
|
||||
|
||||
MsgFunc_ResetHUD(0, 0, NULL );
|
||||
}
|
||||
|
||||
CHud::CHud() : m_iSpriteCount(0), m_pHudList(NULL)
|
||||
{
|
||||
}
|
||||
|
||||
// CHud destructor
|
||||
// cleans up memory allocated for m_rg* arrays
|
||||
CHud :: ~CHud()
|
||||
{
|
||||
delete [] m_rghSprites;
|
||||
delete [] m_rgrcRects;
|
||||
delete [] m_rgszSpriteNames;
|
||||
|
||||
if ( m_pHudList )
|
||||
{
|
||||
HUDLIST *pList;
|
||||
while ( m_pHudList )
|
||||
{
|
||||
pList = m_pHudList;
|
||||
m_pHudList = m_pHudList->pNext;
|
||||
free( pList );
|
||||
}
|
||||
m_pHudList = NULL;
|
||||
}
|
||||
|
||||
ServersShutdown();
|
||||
}
|
||||
|
||||
// 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 )
|
||||
{
|
||||
// look through the loaded sprite name list for SpriteName
|
||||
for ( int i = 0; i < m_iSpriteCount; i++ )
|
||||
{
|
||||
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 )
|
||||
{
|
||||
m_scrinfo.iSize = sizeof(m_scrinfo);
|
||||
GetScreenInfo(&m_scrinfo);
|
||||
|
||||
// ----------
|
||||
// Load Sprites
|
||||
// ---------
|
||||
// m_hsprFont = LoadSprite("sprites/%d_font.spr");
|
||||
|
||||
m_hsprLogo = 0;
|
||||
m_hsprCursor = 0;
|
||||
|
||||
if (ScreenWidth < 640)
|
||||
m_iRes = 320;
|
||||
else
|
||||
m_iRes = 640;
|
||||
|
||||
// Only load this once
|
||||
if ( !m_pSpriteList )
|
||||
{
|
||||
// we need to load the hud.txt, and all sprites within
|
||||
m_pSpriteList = SPR_GetList("sprites/hud.txt", &m_iSpriteCountAllRes);
|
||||
|
||||
if (m_pSpriteList)
|
||||
{
|
||||
// count the number of sprites of the appropriate res
|
||||
m_iSpriteCount = 0;
|
||||
client_sprite_t *p = m_pSpriteList;
|
||||
int j;
|
||||
for ( j = 0; j < m_iSpriteCountAllRes; j++ )
|
||||
{
|
||||
if ( p->iRes == m_iRes )
|
||||
m_iSpriteCount++;
|
||||
p++;
|
||||
}
|
||||
|
||||
// allocated memory for sprite handle arrays
|
||||
m_rghSprites = new HSPRITE[m_iSpriteCount];
|
||||
m_rgrcRects = new wrect_t[m_iSpriteCount];
|
||||
m_rgszSpriteNames = new char[m_iSpriteCount * MAX_SPRITE_NAME_LENGTH];
|
||||
|
||||
p = m_pSpriteList;
|
||||
int index = 0;
|
||||
for ( j = 0; j < m_iSpriteCountAllRes; j++ )
|
||||
{
|
||||
if ( p->iRes == m_iRes )
|
||||
{
|
||||
char sz[256];
|
||||
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 );
|
||||
|
||||
index++;
|
||||
}
|
||||
|
||||
p++;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// we have already have loaded the sprite reference from hud.txt, but
|
||||
// we need to make sure all the sprites have been loaded (we've gone through a transition, or loaded a save game)
|
||||
client_sprite_t *p = m_pSpriteList;
|
||||
int index = 0;
|
||||
for ( int j = 0; j < m_iSpriteCountAllRes; j++ )
|
||||
{
|
||||
if ( p->iRes == m_iRes )
|
||||
{
|
||||
char sz[256];
|
||||
sprintf( sz, "sprites/%s.spr", p->szSprite );
|
||||
m_rghSprites[index] = SPR_Load(sz);
|
||||
index++;
|
||||
}
|
||||
|
||||
p++;
|
||||
}
|
||||
}
|
||||
|
||||
// assumption: number_1, number_2, etc, are all listed and loaded sequentially
|
||||
m_HUD_number_0 = GetSpriteIndex( "number_0" );
|
||||
|
||||
m_iFontHeight = m_rgrcRects[m_HUD_number_0].bottom - m_rgrcRects[m_HUD_number_0].top;
|
||||
|
||||
m_Ammo.VidInit();
|
||||
m_Health.VidInit();
|
||||
m_Spectator.VidInit();
|
||||
m_Geiger.VidInit();
|
||||
m_Train.VidInit();
|
||||
m_Battery.VidInit();
|
||||
m_Message.VidInit();
|
||||
// m_Scoreboard.VidInit();
|
||||
// m_MOTD.VidInit();
|
||||
m_StatusBar.VidInit();
|
||||
m_DeathNotice.VidInit();
|
||||
m_SayText.VidInit();
|
||||
m_Menu.VidInit();
|
||||
m_AmmoSecondary.VidInit();
|
||||
m_TextMessage.VidInit();
|
||||
m_StatusIcons.VidInit();
|
||||
|
||||
GetClientVoiceMgr()->VidInit();
|
||||
}
|
||||
|
||||
int CHud::MsgFunc_Logo(const char *pszName, int iSize, void *pbuf)
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
// update Train data
|
||||
m_iLogo = READ_BYTE();
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
float g_lastFOV = 0.0;
|
||||
|
||||
/*
|
||||
============
|
||||
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)
|
||||
{
|
||||
int len, start, end;
|
||||
|
||||
len = strlen( in );
|
||||
|
||||
// scan backward for '.'
|
||||
end = len - 1;
|
||||
while ( end && in[end] != '.' && in[end] != '/' && in[end] != '\\' )
|
||||
end--;
|
||||
|
||||
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--;
|
||||
|
||||
if ( in[start] != '/' && in[start] != '\\' )
|
||||
start = 0;
|
||||
else
|
||||
start++;
|
||||
|
||||
// Length of new sting
|
||||
len = end - start + 1;
|
||||
|
||||
// Copy partial string
|
||||
strncpy( out, &in[start], len );
|
||||
// Terminate it
|
||||
out[len] = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
=================
|
||||
HUD_IsGame
|
||||
|
||||
=================
|
||||
*/
|
||||
int HUD_IsGame( const char *game )
|
||||
{
|
||||
const char *gamedir;
|
||||
char gd[ 1024 ];
|
||||
|
||||
gamedir = gEngfuncs.pfnGetGameDirectory();
|
||||
if ( gamedir && gamedir[0] )
|
||||
{
|
||||
COM_FileBase( gamedir, gd );
|
||||
if ( !stricmp( gd, game ) )
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
HUD_GetFOV
|
||||
|
||||
Returns last FOV
|
||||
=====================
|
||||
*/
|
||||
float HUD_GetFOV( void )
|
||||
{
|
||||
/*
|
||||
if ( gEngfuncs.pDemoAPI->IsRecording() )
|
||||
{
|
||||
// Write it
|
||||
int i = 0;
|
||||
unsigned char buf[ 100 ];
|
||||
|
||||
// Active
|
||||
*( float * )&buf[ i ] = g_lastFOV;
|
||||
i += sizeof( float );
|
||||
|
||||
Demo_WriteBuffer( TYPE_ZOOM, i, buf );
|
||||
}
|
||||
|
||||
if ( gEngfuncs.pDemoAPI->IsPlayingback() )
|
||||
{
|
||||
g_lastFOV = g_demozoom;
|
||||
}
|
||||
*/
|
||||
return g_lastFOV;
|
||||
}
|
||||
|
||||
int CHud::MsgFunc_SetFOV(const char *pszName, int iSize, void *pbuf)
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
int newfov = READ_BYTE();
|
||||
int def_fov = CVAR_GET_FLOAT( "default_fov" );
|
||||
|
||||
if ( newfov == 0 )
|
||||
{
|
||||
m_iFOV = def_fov;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_iFOV = newfov;
|
||||
}
|
||||
|
||||
// the clients fov is actually set in the client data update section of the hud
|
||||
|
||||
// Set a new sensitivity
|
||||
if ( m_iFOV == def_fov )
|
||||
{
|
||||
// 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)def_fov) * CVAR_GET_FLOAT("zoom_sensitivity_ratio");
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
void CHud::AddHudElem(CHudBase *phudelem)
|
||||
{
|
||||
HUDLIST *pdl, *ptemp;
|
||||
|
||||
//phudelem->Think();
|
||||
|
||||
if (!phudelem)
|
||||
return;
|
||||
|
||||
pdl = (HUDLIST *)malloc(sizeof(HUDLIST));
|
||||
if (!pdl)
|
||||
return;
|
||||
|
||||
memset(pdl, 0, sizeof(HUDLIST));
|
||||
pdl->p = phudelem;
|
||||
|
||||
if (!m_pHudList)
|
||||
{
|
||||
m_pHudList = pdl;
|
||||
return;
|
||||
}
|
||||
|
||||
ptemp = m_pHudList;
|
||||
|
||||
while (ptemp->pNext)
|
||||
ptemp = ptemp->pNext;
|
||||
|
||||
ptemp->pNext = pdl;
|
||||
}
|
||||
|
||||
float CHud::GetSensitivity( void )
|
||||
{
|
||||
return m_flMouseSensitivity;
|
||||
}
|
||||
|
||||
|
||||
659
dmc/cl_dll/hud.h
659
dmc/cl_dll/hud.h
|
|
@ -1,659 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// hud.h
|
||||
//
|
||||
// class CHud declaration
|
||||
//
|
||||
// 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
|
||||
#define RGB_NORMAL 0x00FFFFFF // 255,255,255
|
||||
|
||||
#include "wrect.h"
|
||||
|
||||
#include "cl_dll.h"
|
||||
#include "ammo.h"
|
||||
|
||||
#define DHN_DRAWZERO 1
|
||||
#define DHN_2DIGITS 2
|
||||
#define DHN_3DIGITS 4
|
||||
#define MIN_ALPHA 100
|
||||
|
||||
#define HUDELEM_ACTIVE 1
|
||||
|
||||
typedef struct {
|
||||
int x, y;
|
||||
} POSITION;
|
||||
|
||||
typedef struct {
|
||||
unsigned char r,g,b,a;
|
||||
} RGBA;
|
||||
typedef struct cvar_s cvar_t;
|
||||
|
||||
|
||||
#define HUD_ACTIVE 1
|
||||
#define HUD_INTERMISSION 2
|
||||
|
||||
#define MAX_PLAYER_NAME_LENGTH 32
|
||||
|
||||
#define MAX_MOTD_LENGTH 1024
|
||||
|
||||
#ifndef _WIN32
|
||||
#define _cdecl
|
||||
#endif
|
||||
|
||||
enum
|
||||
{
|
||||
MAX_PLAYERS = 64,
|
||||
MAX_TEAMS = 64,
|
||||
MAX_TEAM_NAME = 16,
|
||||
};
|
||||
|
||||
struct extra_player_info_t
|
||||
{
|
||||
short frags;
|
||||
short deaths;
|
||||
short teamnumber;
|
||||
char teamname[MAX_TEAM_NAME];
|
||||
};
|
||||
|
||||
struct team_info_t
|
||||
{
|
||||
char name[MAX_TEAM_NAME];
|
||||
short frags;
|
||||
short deaths;
|
||||
short ping;
|
||||
short packetloss;
|
||||
short ownteam;
|
||||
short players;
|
||||
int already_drawn;
|
||||
int scores_overriden;
|
||||
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];
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
class CHudBase
|
||||
{
|
||||
public:
|
||||
POSITION m_pos;
|
||||
int m_type;
|
||||
int m_iFlags; // active, moving,
|
||||
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 {
|
||||
CHudBase *p;
|
||||
HUDLIST *pNext;
|
||||
};
|
||||
|
||||
|
||||
#include "hud_spectator.h"
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
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 DrawFastList(float flTime);
|
||||
float m_flFastListTime;
|
||||
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 );
|
||||
int MsgFunc_HideWeapon( const char *pszName, int iSize, void *pbuf );
|
||||
|
||||
void _cdecl UserCmd_Slot1( void );
|
||||
void _cdecl UserCmd_Slot2( void );
|
||||
void _cdecl UserCmd_Slot3( void );
|
||||
void _cdecl UserCmd_Slot4( void );
|
||||
void _cdecl UserCmd_Slot5( void );
|
||||
void _cdecl UserCmd_Slot6( void );
|
||||
void _cdecl UserCmd_Slot7( void );
|
||||
void _cdecl UserCmd_Slot8( void );
|
||||
void _cdecl UserCmd_Slot9( void );
|
||||
void _cdecl UserCmd_Slot10( void );
|
||||
void _cdecl UserCmd_Close( void );
|
||||
void _cdecl UserCmd_NextWeapon( void );
|
||||
void _cdecl UserCmd_PrevWeapon( void );
|
||||
|
||||
int m_iXPosition;
|
||||
int m_iNumberXPosition;
|
||||
HSPRITE m_sprAmmoSprite;
|
||||
int m_HUD_Ammo;
|
||||
wrect_t *m_prc1;
|
||||
|
||||
private:
|
||||
float m_fFade;
|
||||
RGBA m_rgba;
|
||||
WEAPON *m_pWeapon;
|
||||
int m_HUD_bucket0;
|
||||
int m_HUD_selection;
|
||||
|
||||
|
||||
};
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
|
||||
class CHudAmmoSecondary: public CHudBase
|
||||
{
|
||||
public:
|
||||
int Init( void );
|
||||
int VidInit( void );
|
||||
void Reset( void );
|
||||
int Draw(float flTime);
|
||||
|
||||
int MsgFunc_SecAmmoVal( const char *pszName, int iSize, void *pbuf );
|
||||
int MsgFunc_SecAmmoIcon( const char *pszName, int iSize, void *pbuf );
|
||||
|
||||
private:
|
||||
enum {
|
||||
MAX_SEC_AMMO_VALUES = 4
|
||||
};
|
||||
|
||||
int m_HUD_ammoicon; // sprite indices
|
||||
int m_iAmmoAmounts[MAX_SEC_AMMO_VALUES];
|
||||
float m_fFade;
|
||||
};
|
||||
|
||||
|
||||
#include "health.h"
|
||||
|
||||
|
||||
#define FADE_TIME 100
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
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);
|
||||
|
||||
private:
|
||||
int m_iGeigerRange;
|
||||
|
||||
};
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
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);
|
||||
|
||||
private:
|
||||
HSPRITE m_hSprite;
|
||||
int m_iPos;
|
||||
|
||||
};
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
// REMOVED: Vgui has replaced this.
|
||||
//
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
/*
|
||||
class CHudMOTD : public CHudBase
|
||||
{
|
||||
public:
|
||||
int Init( void );
|
||||
int VidInit( void );
|
||||
int Draw( float flTime );
|
||||
void Reset( void );
|
||||
|
||||
int MsgFunc_MOTD( const char *pszName, int iSize, void *pbuf );
|
||||
|
||||
protected:
|
||||
static int MOTD_DISPLAY_TIME;
|
||||
char m_szMOTD[ MAX_MOTD_LENGTH ];
|
||||
float m_flActiveRemaining;
|
||||
int m_iLines;
|
||||
};
|
||||
*/
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
class CHudStatusBar : public CHudBase
|
||||
{
|
||||
public:
|
||||
int Init( void );
|
||||
int VidInit( void );
|
||||
int Draw( float flTime );
|
||||
void Reset( void );
|
||||
void ParseStatusString( int line_num );
|
||||
|
||||
int MsgFunc_StatusText( const char *pszName, int iSize, void *pbuf );
|
||||
int MsgFunc_StatusValue( const char *pszName, int iSize, void *pbuf );
|
||||
|
||||
protected:
|
||||
enum {
|
||||
MAX_STATUSTEXT_LENGTH = 128,
|
||||
MAX_STATUSBAR_VALUES = 8,
|
||||
MAX_STATUSBAR_LINES = 2,
|
||||
};
|
||||
|
||||
HSPRITE m_hArmor;
|
||||
HSPRITE m_hHealth;
|
||||
int m_iArmorSpriteIndex;
|
||||
int m_iHealthSpriteIndex;
|
||||
|
||||
|
||||
char m_szStatusText[MAX_STATUSBAR_LINES][MAX_STATUSTEXT_LENGTH]; // a text string describing how the status bar is to be drawn
|
||||
char m_szStatusBar[MAX_STATUSBAR_LINES][MAX_STATUSTEXT_LENGTH]; // the constructed bar that is drawn
|
||||
int m_iStatusValues[MAX_STATUSBAR_VALUES]; // an array of values for use in the status bar
|
||||
|
||||
char m_szName[MAX_STATUSBAR_LINES][MAX_STATUSTEXT_LENGTH];
|
||||
char m_szHealth[MAX_STATUSBAR_LINES][MAX_STATUSTEXT_LENGTH];
|
||||
char m_szArmor[MAX_STATUSBAR_LINES][MAX_STATUSTEXT_LENGTH];
|
||||
|
||||
int m_iTeamMate[MAX_STATUSBAR_LINES];
|
||||
|
||||
int m_bReparseString; // set to TRUE whenever the m_szStatusBar needs to be recalculated
|
||||
};
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
|
||||
/*class CHudScoreboard: public CHudBase
|
||||
{
|
||||
public:
|
||||
int Init( void );
|
||||
void InitHUDData( void );
|
||||
int VidInit( void );
|
||||
int Draw( float flTime );
|
||||
int DrawPlayers( int xoffset, float listslot, int nameoffset = 0, char *team = NULL ); // returns the ypos where it finishes drawing
|
||||
void UserCmd_ShowScores( void );
|
||||
void UserCmd_HideScores( void );
|
||||
int MsgFunc_ScoreInfo( const char *pszName, int iSize, void *pbuf );
|
||||
int MsgFunc_TeamInfo( const char *pszName, int iSize, void *pbuf );
|
||||
int MsgFunc_TeamScore( const char *pszName, int iSize, void *pbuf );
|
||||
void DeathMsg( int killer, int victim );
|
||||
|
||||
|
||||
|
||||
int m_iNumTeams;
|
||||
|
||||
int m_iLastKilledBy;
|
||||
int m_fLastKillTime;
|
||||
int m_iPlayerNum;
|
||||
int m_iShowscoresHeld;
|
||||
|
||||
void GetAllPlayersInfo( void );
|
||||
|
||||
|
||||
|
||||
};
|
||||
|
||||
*/
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
class CHudDeathNotice : public CHudBase
|
||||
{
|
||||
public:
|
||||
int Init( void );
|
||||
void InitHUDData( void );
|
||||
int VidInit( void );
|
||||
int Draw( float flTime );
|
||||
int MsgFunc_DeathMsg( const char *pszName, int iSize, void *pbuf );
|
||||
|
||||
private:
|
||||
int m_HUD_d_skull; // sprite index of skull icon
|
||||
|
||||
char szText[256][4];
|
||||
};
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
class CHudMenu : public CHudBase
|
||||
{
|
||||
public:
|
||||
int Init( void );
|
||||
void InitHUDData( void );
|
||||
int VidInit( void );
|
||||
void Reset( void );
|
||||
int Draw( float flTime );
|
||||
int MsgFunc_ShowMenu( const char *pszName, int iSize, void *pbuf );
|
||||
|
||||
void SelectMenuItem( int menu_item );
|
||||
|
||||
int m_fMenuDisplayed;
|
||||
int m_bitsValidSlots;
|
||||
float m_flShutoffTime;
|
||||
int m_fWaitingForMore;
|
||||
};
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
class CHudSayText : public CHudBase
|
||||
{
|
||||
public:
|
||||
int Init( void );
|
||||
void InitHUDData( void );
|
||||
int VidInit( void );
|
||||
int Draw( float flTime );
|
||||
int MsgFunc_SayText( const char *pszName, int iSize, void *pbuf );
|
||||
void SayTextPrint( const char *pszBuf, int iBufSize, int clientIndex = -1 );
|
||||
void EnsureTextFitsInOneLineAndWrapIfHaveTo( int line );
|
||||
|
||||
struct cvar_s * m_HUD_saytext;
|
||||
struct cvar_s * m_HUD_saytext_time;
|
||||
};
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
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 );
|
||||
|
||||
private:
|
||||
HSPRITE m_hSprite1;
|
||||
HSPRITE m_hSprite2;
|
||||
wrect_t *m_prc1;
|
||||
wrect_t *m_prc2;
|
||||
int m_iBat;
|
||||
float m_fFade;
|
||||
int m_iHeight; // width of the battery innards
|
||||
};
|
||||
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
const int maxHUDMessages = 16;
|
||||
struct message_parms_t
|
||||
{
|
||||
client_textmessage_t *pMessage;
|
||||
float time;
|
||||
int x, y;
|
||||
int totalWidth, totalHeight;
|
||||
int width;
|
||||
int lines;
|
||||
int lineLength;
|
||||
int length;
|
||||
int r, g, b;
|
||||
int text;
|
||||
int fadeBlend;
|
||||
float charTime;
|
||||
float fadeTime;
|
||||
};
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
|
||||
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);
|
||||
};
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
|
||||
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);
|
||||
|
||||
float FadeBlend( float fadein, float fadeout, float hold, float localTime );
|
||||
int XPosition( float x, int width, int lineWidth );
|
||||
int YPosition( float y, int height );
|
||||
|
||||
void MessageAdd( const char *pName, float time );
|
||||
void MessageAdd(client_textmessage_t * newMessage );
|
||||
void MessageDrawScan( client_textmessage_t *pMessage, float time );
|
||||
void MessageScanStart( void );
|
||||
void MessageScanNextChar( void );
|
||||
void Reset( void );
|
||||
|
||||
private:
|
||||
client_textmessage_t *m_pMessages[maxHUDMessages];
|
||||
float m_startTime[maxHUDMessages];
|
||||
message_parms_t m_parms;
|
||||
float m_gameTitleTime;
|
||||
client_textmessage_t *m_pGameTitle;
|
||||
|
||||
int m_HUD_title_life;
|
||||
int m_HUD_title_half;
|
||||
};
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
#define MAX_SPRITE_NAME_LENGTH 24
|
||||
|
||||
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);
|
||||
|
||||
enum {
|
||||
MAX_ICONSPRITENAME_LENGTH = MAX_SPRITE_NAME_LENGTH,
|
||||
MAX_ICONSPRITES = 4,
|
||||
};
|
||||
|
||||
|
||||
//had to make these public so CHud could access them (to enable concussion icon)
|
||||
//could use a friend declaration instead...
|
||||
void EnableIcon( char *pszIconName, unsigned char red, unsigned char green, unsigned char blue );
|
||||
void DisableIcon( char *pszIconName );
|
||||
|
||||
private:
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char szSpriteName[MAX_ICONSPRITENAME_LENGTH];
|
||||
HSPRITE spr;
|
||||
wrect_t rc;
|
||||
unsigned char r, g, b;
|
||||
} icon_sprite_t;
|
||||
|
||||
icon_sprite_t m_IconList[MAX_ICONSPRITES];
|
||||
|
||||
};
|
||||
|
||||
|
||||
//
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
class CVoiceStatus;
|
||||
typedef struct cvar_s cvar_t;
|
||||
|
||||
class CHud
|
||||
{
|
||||
private:
|
||||
HUDLIST *m_pHudList;
|
||||
HSPRITE m_hsprLogo;
|
||||
int m_iLogo;
|
||||
client_sprite_t *m_pSpriteList;
|
||||
int m_iSpriteCount;
|
||||
int m_iSpriteCountAllRes;
|
||||
float m_flMouseSensitivity;
|
||||
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
|
||||
double m_flTimeDelta; // the difference between flTime and fOldTime
|
||||
Vector m_vecOrigin;
|
||||
Vector m_vecAngles;
|
||||
int m_iKeyBits;
|
||||
int m_iHideHUDDisplay;
|
||||
int m_iFOV;
|
||||
int m_Teamplay;
|
||||
int m_iRes;
|
||||
cvar_t *m_pCvarStealMouse;
|
||||
cvar_t *m_pCvarDraw;
|
||||
|
||||
// QUAKECLASSIC
|
||||
int m_iQuakeItems;
|
||||
|
||||
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 DrawHudStringCTF(int x, int y, int iMaxX, char *szString, int r, int g, int b );
|
||||
|
||||
int ReturnStringPixelLength ( char *Hihi );
|
||||
|
||||
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);
|
||||
|
||||
private:
|
||||
// the memory for these arrays are allocated in the first call to CHud::VidInit(), when the hud.txt and associated sprites are loaded.
|
||||
// freed in ~CHud()
|
||||
HSPRITE *m_rghSprites; /*[HUD_SPRITE_COUNT]*/ // the sprites loaded from hud.txt
|
||||
wrect_t *m_rgrcRects; /*[HUD_SPRITE_COUNT]*/
|
||||
char *m_rgszSpriteNames; /*[HUD_SPRITE_COUNT][MAX_SPRITE_NAME_LENGTH]*/
|
||||
|
||||
struct cvar_s *default_fov;
|
||||
public:
|
||||
HSPRITE GetSprite( int 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
|
||||
|
||||
CHudAmmo m_Ammo;
|
||||
CHudHealth m_Health;
|
||||
CHudSpectator m_Spectator;
|
||||
CHudGeiger m_Geiger;
|
||||
CHudBattery m_Battery;
|
||||
CHudTrain m_Train;
|
||||
CHudMessage m_Message;
|
||||
// CHudScoreboard m_Scoreboard;
|
||||
// CHudMOTD m_MOTD;
|
||||
CHudStatusBar m_StatusBar;
|
||||
CHudDeathNotice m_DeathNotice;
|
||||
CHudSayText m_SayText;
|
||||
CHudMenu m_Menu;
|
||||
CHudAmmoSecondary m_AmmoSecondary;
|
||||
CHudTextMessage m_TextMessage;
|
||||
CHudStatusIcons m_StatusIcons;
|
||||
|
||||
void Init( void );
|
||||
void VidInit( void );
|
||||
void Think(void);
|
||||
int Redraw( float flTime, int intermission );
|
||||
int UpdateClientData( client_data_t *cdata, float time );
|
||||
|
||||
CHud();
|
||||
~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);
|
||||
void _cdecl MsgFunc_InitHUD( 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 );
|
||||
|
||||
// QUAKECLASSIC
|
||||
int _cdecl MsgFunc_QItems( const char *pszName, int iSize, void *pbuf );
|
||||
|
||||
// Screen information
|
||||
SCREENINFO m_scrinfo;
|
||||
|
||||
int m_iWeaponBits;
|
||||
int m_fPlayerDead;
|
||||
int m_iIntermission;
|
||||
|
||||
// sprite indexes
|
||||
int m_HUD_number_0;
|
||||
|
||||
|
||||
void AddHudElem(CHudBase *p);
|
||||
|
||||
float GetSensitivity();
|
||||
};
|
||||
|
||||
class TeamFortressViewport;
|
||||
|
||||
extern CHud gHUD;
|
||||
extern TeamFortressViewport *gViewPort;
|
||||
|
||||
extern int g_iUser1;
|
||||
extern int g_iUser2;
|
||||
extern int g_iUser3;
|
||||
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#if !defined( HUD_IFACEH )
|
||||
#define HUD_IFACEH
|
||||
#pragma once
|
||||
|
||||
#ifdef _WIN32
|
||||
#define EXPORT _declspec( dllexport )
|
||||
#else
|
||||
#define EXPORT __attribute__ ((visibility("default")))
|
||||
#endif
|
||||
#define _DLLEXPORT EXPORT
|
||||
|
||||
typedef int (*pfnUserMsgHook)(const char *pszName, int iSize, void *pbuf);
|
||||
#include "wrect.h"
|
||||
#include "../engine/cdll_int.h"
|
||||
extern cl_enginefunc_t gEngfuncs;
|
||||
|
||||
#endif
|
||||
|
|
@ -1,171 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// hud_msg.cpp
|
||||
//
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "parsemsg.h"
|
||||
|
||||
extern float g_flLightTime;
|
||||
|
||||
#define MAX_TELES 256
|
||||
Vector g_vecTeleMins[ MAX_TELES ];
|
||||
Vector g_vecTeleMaxs[ MAX_TELES ];
|
||||
int g_iTeleNum;
|
||||
bool g_bLoadedTeles;
|
||||
|
||||
float g_iFogColor[3];
|
||||
float g_iStartDist;
|
||||
float g_iEndDist;
|
||||
|
||||
/// USER-DEFINED SERVER MESSAGE HANDLERS
|
||||
|
||||
int CHud :: MsgFunc_ResetHUD(const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
ASSERT( iSize == 0 );
|
||||
|
||||
// clear all hud data
|
||||
HUDLIST *pList = m_pHudList;
|
||||
|
||||
while ( pList )
|
||||
{
|
||||
if ( pList->p )
|
||||
pList->p->Reset();
|
||||
pList = pList->pNext;
|
||||
}
|
||||
|
||||
// reset sensitivity
|
||||
m_flMouseSensitivity = 0;
|
||||
|
||||
// reset concussion effect
|
||||
m_iConcussionEffect = 0;
|
||||
|
||||
g_flLightTime = 0.0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void CHud :: MsgFunc_InitHUD( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
g_iTeleNum = 0;
|
||||
g_bLoadedTeles = false;
|
||||
int i;
|
||||
|
||||
//Clear all the teleporters
|
||||
for ( i = 0; i < MAX_TELES; i++ )
|
||||
{
|
||||
g_vecTeleMins[ i ].x = 0.0;
|
||||
g_vecTeleMins[ i ].y = 0.0;
|
||||
g_vecTeleMins[ i ].z = 0.0;
|
||||
|
||||
g_vecTeleMaxs[ i ].x = 0.0;
|
||||
g_vecTeleMaxs[ i ].y = 0.0;
|
||||
g_vecTeleMaxs[ i ].z = 0.0;
|
||||
}
|
||||
|
||||
/***** FOG CLEARING JIBBA JABBA *****/
|
||||
for ( i = 0; i < 3; i++ )
|
||||
g_iFogColor[ i ] = 0.0;
|
||||
|
||||
g_iStartDist = 0.0;
|
||||
g_iEndDist = 0.0;
|
||||
/***** FOG CLEARING JIBBA JABBA *****/
|
||||
|
||||
// prepare all hud data
|
||||
HUDLIST *pList = m_pHudList;
|
||||
|
||||
while (pList)
|
||||
{
|
||||
if ( pList->p )
|
||||
pList->p->InitHUDData();
|
||||
pList = pList->pNext;
|
||||
}
|
||||
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
g_iTeleNum = READ_BYTE();
|
||||
|
||||
for ( i = 0; i < g_iTeleNum; i++ )
|
||||
{
|
||||
g_vecTeleMins[ i ].x = READ_COORD();
|
||||
g_vecTeleMins[ i ].y = READ_COORD();
|
||||
g_vecTeleMins[ i ].z = READ_COORD();
|
||||
g_vecTeleMaxs[ i ].x = READ_COORD();
|
||||
g_vecTeleMaxs[ i ].y = READ_COORD();
|
||||
g_vecTeleMaxs[ i ].z = READ_COORD();
|
||||
}
|
||||
|
||||
for ( i = 0; i < 3; i++ )
|
||||
g_iFogColor[ i ] = READ_SHORT(); // Should just get a byte.
|
||||
|
||||
//If they both are 0, it means no fog for this level.
|
||||
g_iStartDist = READ_SHORT();
|
||||
g_iEndDist = READ_SHORT();
|
||||
}
|
||||
|
||||
|
||||
int CHud :: MsgFunc_GameMode(const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
m_Teamplay = READ_BYTE();
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
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++)
|
||||
from[i] = READ_COORD();
|
||||
|
||||
count = (blood * 0.5) + (armor * 0.5);
|
||||
|
||||
if (count < 10)
|
||||
count = 10;
|
||||
|
||||
// TODO: kick viewangles, show damage visually
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
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);
|
||||
else
|
||||
this->m_StatusIcons.DisableIcon("dmg_concuss");
|
||||
return 1;
|
||||
}
|
||||
|
||||
// QUAKECLASSIC
|
||||
int CHud :: MsgFunc_QItems(const char *pszName, int iSize, void *pbuf)
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
m_iQuakeItems = READ_LONG();
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -1,447 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// hud_redraw.cpp
|
||||
//
|
||||
#include <math.h>
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include <string.h>
|
||||
#include "vgui_viewport.h"
|
||||
|
||||
extern int g_iVisibleMouse;
|
||||
|
||||
#define MAX_LOGO_FRAMES 56
|
||||
|
||||
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
|
||||
};
|
||||
|
||||
|
||||
// Think
|
||||
void CHud::Think(void)
|
||||
{
|
||||
m_scrinfo.iSize = sizeof(m_scrinfo);
|
||||
GetScreenInfo(&m_scrinfo);
|
||||
|
||||
HUDLIST *pList = m_pHudList;
|
||||
while (pList)
|
||||
{
|
||||
if (pList->p->m_iFlags & HUD_ACTIVE)
|
||||
pList->p->Think();
|
||||
pList = pList->pNext;
|
||||
}
|
||||
|
||||
// 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
|
||||
m_iFOV = max( default_fov->value, 90 );
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
// 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 )
|
||||
{
|
||||
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 )
|
||||
m_flTimeDelta = 0;
|
||||
|
||||
// Bring up the scoreboard during intermission
|
||||
if (gViewPort)
|
||||
{
|
||||
if ( m_iIntermission && !intermission )
|
||||
{
|
||||
// Have to do this here so the scoreboard goes away
|
||||
m_iIntermission = intermission;
|
||||
gViewPort->HideCommandMenu();
|
||||
gViewPort->HideScoreBoard();
|
||||
gViewPort->UpdateSpectatorPanel();
|
||||
}
|
||||
else if ( !m_iIntermission && intermission )
|
||||
{
|
||||
m_iIntermission = intermission;
|
||||
gViewPort->HideCommandMenu();
|
||||
gViewPort->HideVGUIMenu();
|
||||
gViewPort->ShowScoreBoard();
|
||||
gViewPort->UpdateSpectatorPanel();
|
||||
|
||||
// Take a screenshot if the client's got the cvar set
|
||||
if ( CVAR_GET_FLOAT( "hud_takesshots" ) != 0 )
|
||||
m_flShotTime = flTime + 1.0; // Take a screenshot in a second
|
||||
}
|
||||
}
|
||||
|
||||
if (m_flShotTime && m_flShotTime < flTime)
|
||||
{
|
||||
gEngfuncs.pfnClientCmd("snapshot\n");
|
||||
m_flShotTime = 0;
|
||||
}
|
||||
// if no redrawing is necessary
|
||||
// return 0;
|
||||
|
||||
// draw all registered HUD elements
|
||||
if ( m_pCvarDraw->value )
|
||||
{
|
||||
HUDLIST *pList = m_pHudList;
|
||||
|
||||
while (pList)
|
||||
{
|
||||
if ( !intermission )
|
||||
{
|
||||
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 )
|
||||
pList->p->Draw( flTime );
|
||||
}
|
||||
|
||||
pList = pList->pNext;
|
||||
}
|
||||
}
|
||||
|
||||
// are we in demo mode? do we need to draw the logo in the top corner?
|
||||
if (m_iLogo)
|
||||
{
|
||||
int x, y, i;
|
||||
|
||||
if (m_hsprLogo == 0)
|
||||
m_hsprLogo = LoadSprite("sprites/%d_logo.spr");
|
||||
|
||||
SPR_Set(m_hsprLogo, 250, 250, 250 );
|
||||
|
||||
x = SPR_Width(m_hsprLogo, 0);
|
||||
x = ScreenWidth - x;
|
||||
y = SPR_Height(m_hsprLogo, 0)/2;
|
||||
|
||||
// Draw the logo at 20 fps
|
||||
int iFrame = (int)(flTime * 20) % MAX_LOGO_FRAMES;
|
||||
i = grgLogoFrame[iFrame] - 1;
|
||||
|
||||
SPR_DrawAdditive(i, x, y, NULL);
|
||||
}
|
||||
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
===========================
|
||||
int ReturnStringPixelLength ( char *Hihi )
|
||||
|
||||
Returns a integer representing the length of the string passed
|
||||
===========================
|
||||
*/
|
||||
int CHud :: ReturnStringPixelLength ( char *Hihi )
|
||||
{
|
||||
int iNameLength = 0;
|
||||
|
||||
int strleng = ( strlen( Hihi ) );
|
||||
|
||||
for ( int har = 0; har < strleng; har++)
|
||||
iNameLength += gHUD.m_scrinfo.charWidths[ Hihi[har] ];
|
||||
|
||||
return iNameLength;
|
||||
}
|
||||
|
||||
int LastColor;
|
||||
|
||||
int CHud :: DrawHudStringCTF(int xpos, int ypos, int iMaxX, char *szIt, int r, int g, int b )
|
||||
{
|
||||
int WantColor = 0;
|
||||
int Color = 0;
|
||||
|
||||
// draw the string until we hit the null character or a newline character
|
||||
for ( ; *szIt != 0 && *szIt != '\n'; szIt++ )
|
||||
{
|
||||
int next;// = xpos + gHUD.m_scrinfo.charWidths[ *szIt ]; // variable-width fonts look cool
|
||||
|
||||
/* if ( next > iMaxX )
|
||||
return xpos;*/
|
||||
|
||||
|
||||
if (*szIt == '\\')
|
||||
{
|
||||
if (Color > 0)
|
||||
Color = 0;
|
||||
|
||||
WantColor = 1;
|
||||
|
||||
}
|
||||
|
||||
if (WantColor == 1 && *szIt == 'w')
|
||||
{
|
||||
Color = 1;
|
||||
LastColor = Color;
|
||||
}
|
||||
|
||||
|
||||
if (WantColor == 1 && *szIt == 'g')
|
||||
{
|
||||
Color = 2;
|
||||
LastColor = Color;
|
||||
}
|
||||
|
||||
|
||||
|
||||
if (WantColor == 1 && *szIt == 'b')
|
||||
{
|
||||
Color = 3;
|
||||
LastColor = Color;
|
||||
}
|
||||
|
||||
|
||||
if (WantColor == 1 && *szIt == 'r')
|
||||
{
|
||||
Color = 4;
|
||||
LastColor = Color;
|
||||
}
|
||||
|
||||
|
||||
|
||||
if (WantColor == 1 && *szIt == 'y')
|
||||
{
|
||||
Color = 5;
|
||||
LastColor = Color;
|
||||
}
|
||||
|
||||
|
||||
|
||||
if (WantColor == 1 && *szIt == 'q')
|
||||
{
|
||||
Color = 6;
|
||||
LastColor = Color;
|
||||
}
|
||||
|
||||
|
||||
|
||||
if (Color == 0 && WantColor == 0)
|
||||
{
|
||||
if (LastColor == 1)
|
||||
TextMessageDrawChar( xpos, ypos, *szIt, 255, 255, 255 );
|
||||
if (LastColor == 2)
|
||||
TextMessageDrawChar( xpos, ypos, *szIt, 0, 79, 0);
|
||||
if (LastColor == 3)
|
||||
TextMessageDrawChar( xpos, ypos, *szIt, 0, 0, 200);
|
||||
if (LastColor == 4)
|
||||
TextMessageDrawChar( xpos, ypos, *szIt, 200, 0, 0 );
|
||||
if (LastColor == 5)
|
||||
TextMessageDrawChar( xpos, ypos, *szIt, 198, 221, 66 );
|
||||
if (LastColor == 6)
|
||||
TextMessageDrawChar( xpos, ypos, *szIt, 136, 136, 136 );
|
||||
|
||||
else if (LastColor == 0)
|
||||
TextMessageDrawChar( xpos, ypos, *szIt, r, g, b );
|
||||
|
||||
next = xpos + gHUD.m_scrinfo.charWidths[ *szIt ];
|
||||
}
|
||||
|
||||
else if (Color > 0 && WantColor == 0 )
|
||||
{
|
||||
if (Color == 1)
|
||||
TextMessageDrawChar( xpos, ypos, *szIt, 255, 255, 255 );
|
||||
if (Color == 2)
|
||||
TextMessageDrawChar( xpos, ypos, *szIt, 0, 79, 0);
|
||||
if (Color == 3)
|
||||
TextMessageDrawChar( xpos, ypos, *szIt, 0, 0, 200);
|
||||
if (Color == 4)
|
||||
TextMessageDrawChar( xpos, ypos, *szIt, 200, 0, 0 );
|
||||
if (Color == 5)
|
||||
TextMessageDrawChar( xpos, ypos, *szIt, 198, 221, 66 );
|
||||
if (Color == 6)
|
||||
TextMessageDrawChar( xpos, ypos, *szIt, 136, 136, 136 );
|
||||
|
||||
next = xpos + gHUD.m_scrinfo.charWidths[ *szIt ];
|
||||
}
|
||||
|
||||
else if (Color > 0 && WantColor == 1)
|
||||
{
|
||||
//next = xpos + (gHUD.m_scrinfo.charWidths[ *szIt ] * 2); // variable-width fonts look cool
|
||||
WantColor = 0;
|
||||
}
|
||||
|
||||
|
||||
xpos = next;
|
||||
}
|
||||
|
||||
return xpos;
|
||||
}
|
||||
|
||||
|
||||
int CHud :: DrawHudString(int xpos, int ypos, int iMaxX, char *szIt, int r, int g, int b )
|
||||
{
|
||||
// draw the string until we hit the null character or a newline character
|
||||
for ( ; *szIt != 0 && *szIt != '\n'; szIt++ )
|
||||
{
|
||||
int next = xpos + gHUD.m_scrinfo.charWidths[ *szIt ]; // variable-width fonts look cool
|
||||
if ( next > iMaxX )
|
||||
return xpos;
|
||||
|
||||
TextMessageDrawChar( xpos, ypos, *szIt, r, g, b );
|
||||
xpos = next;
|
||||
}
|
||||
|
||||
return xpos;
|
||||
}
|
||||
|
||||
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 )
|
||||
{
|
||||
// find the end of the string
|
||||
char *szIt;
|
||||
for ( szIt = szString; *szIt != 0; szIt++ )
|
||||
{ // we should count the length?
|
||||
}
|
||||
|
||||
// iterate throug the string in reverse
|
||||
for ( szIt--; szIt != (szString-1); szIt-- )
|
||||
{
|
||||
int next = xpos - gHUD.m_scrinfo.charWidths[ *szIt ]; // variable-width fonts look cool
|
||||
if ( next < iMinX )
|
||||
return xpos;
|
||||
xpos = next;
|
||||
|
||||
TextMessageDrawChar( xpos, ypos, *szIt, r, g, b );
|
||||
}
|
||||
|
||||
return xpos;
|
||||
}
|
||||
|
||||
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 k;
|
||||
|
||||
if (iNumber > 0)
|
||||
{
|
||||
// SPR_Draw 100's
|
||||
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));
|
||||
x += iWidth;
|
||||
}
|
||||
else if (iFlags & (DHN_3DIGITS))
|
||||
{
|
||||
//SPR_DrawAdditive( 0, x, y, &rc );
|
||||
x += iWidth;
|
||||
}
|
||||
|
||||
// SPR_Draw 10's
|
||||
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));
|
||||
x += iWidth;
|
||||
}
|
||||
else if (iFlags & (DHN_3DIGITS | DHN_2DIGITS))
|
||||
{
|
||||
//SPR_DrawAdditive( 0, x, y, &rc );
|
||||
x += iWidth;
|
||||
}
|
||||
|
||||
// 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));
|
||||
x += iWidth;
|
||||
}
|
||||
else if (iFlags & DHN_DRAWZERO)
|
||||
{
|
||||
SPR_Set(GetSprite(m_HUD_number_0), r, g, b );
|
||||
|
||||
// SPR_Draw 100's
|
||||
if (iFlags & (DHN_3DIGITS))
|
||||
{
|
||||
//SPR_DrawAdditive( 0, x, y, &rc );
|
||||
x += iWidth;
|
||||
}
|
||||
|
||||
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));
|
||||
x += iWidth;
|
||||
}
|
||||
|
||||
return x;
|
||||
}
|
||||
|
||||
|
||||
int CHud::GetNumWidth( int iNumber, int iFlags )
|
||||
{
|
||||
if (iFlags & (DHN_3DIGITS))
|
||||
return 3;
|
||||
|
||||
if (iFlags & (DHN_2DIGITS))
|
||||
return 2;
|
||||
|
||||
if (iNumber <= 0)
|
||||
{
|
||||
if (iFlags & (DHN_DRAWZERO))
|
||||
return 1;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (iNumber < 10)
|
||||
return 1;
|
||||
|
||||
if (iNumber < 100)
|
||||
return 2;
|
||||
|
||||
return 3;
|
||||
|
||||
}
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,41 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#if !defined( HUD_SERVERSH )
|
||||
#define HUD_SERVERSH
|
||||
#pragma once
|
||||
|
||||
#define NET_CALLBACK /* */
|
||||
|
||||
// Dispatchers
|
||||
void NET_CALLBACK ListResponse( struct net_response_s *response );
|
||||
void NET_CALLBACK ServerResponse( struct net_response_s *response );
|
||||
void NET_CALLBACK PingResponse( struct net_response_s *response );
|
||||
void NET_CALLBACK RulesResponse( struct net_response_s *response );
|
||||
void NET_CALLBACK PlayersResponse( struct net_response_s *response );
|
||||
|
||||
void ServersInit( void );
|
||||
void ServersShutdown( void );
|
||||
void ServersThink( double time );
|
||||
void ServersCancel( void );
|
||||
|
||||
// Get list and get server info from each
|
||||
void ServersList( void );
|
||||
|
||||
// Query for IP / IPX LAN servers
|
||||
void BroadcastServersList( int clearpending );
|
||||
|
||||
void ServerPing( int server );
|
||||
void ServerRules( int server );
|
||||
void ServerPlayers( int server );
|
||||
|
||||
int ServersGetCount( void );
|
||||
const char *ServersGetInfo( int server );
|
||||
int ServersIsQuerying( void );
|
||||
void SortServers( const char *fieldname );
|
||||
|
||||
#endif // HUD_SERVERSH
|
||||
|
|
@ -1,98 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#if !defined( HUD_SERVERS_PRIVH )
|
||||
#define HUD_SERVERS_PRIVH
|
||||
#pragma once
|
||||
|
||||
#include "netadr.h"
|
||||
|
||||
class CHudServers
|
||||
{
|
||||
public:
|
||||
typedef struct request_s
|
||||
{
|
||||
struct request_s *next;
|
||||
netadr_t remote_address;
|
||||
int context;
|
||||
} request_t;
|
||||
|
||||
typedef struct server_s
|
||||
{
|
||||
struct server_s *next;
|
||||
netadr_t remote_address;
|
||||
char *info;
|
||||
int ping;
|
||||
} server_t;
|
||||
|
||||
CHudServers();
|
||||
~CHudServers();
|
||||
|
||||
void Think( double time );
|
||||
void QueryThink( void );
|
||||
int isQuerying( void );
|
||||
|
||||
int LoadMasterAddresses( int maxservers, int *count, netadr_t *padr );
|
||||
|
||||
void RequestList( void );
|
||||
void RequestBroadcastList( int clearpending );
|
||||
|
||||
void ServerPing( int server );
|
||||
void ServerRules( int server );
|
||||
void ServerPlayers( int server );
|
||||
|
||||
void CancelRequest( void );
|
||||
|
||||
int CompareServers( server_t *p1, server_t *p2 );
|
||||
|
||||
void ClearServerList( server_t **ppList );
|
||||
void ClearRequestList( request_t **ppList );
|
||||
|
||||
void AddServer( server_t **ppList, server_t *p );
|
||||
|
||||
void RemoveServerFromList( request_t **ppList, request_t *item );
|
||||
|
||||
request_t *FindRequest( int context, request_t *pList );
|
||||
|
||||
int ServerListSize( void );
|
||||
char *GetServerInfo( int server );
|
||||
int GetServerCount( void );
|
||||
void SortServers( const char *fieldname );
|
||||
|
||||
void ListResponse( struct net_response_s *response );
|
||||
void ServerResponse( struct net_response_s *response );
|
||||
void PingResponse( struct net_response_s *response );
|
||||
void RulesResponse( struct net_response_s *response );
|
||||
void PlayersResponse( struct net_response_s *response );
|
||||
private:
|
||||
|
||||
server_t *GetServer( int server );
|
||||
|
||||
//
|
||||
char m_szToken[ 1024 ];
|
||||
int m_nRequesting;
|
||||
int m_nDone;
|
||||
|
||||
double m_dStarted;
|
||||
|
||||
request_t *m_pServerList;
|
||||
request_t *m_pActiveList;
|
||||
|
||||
server_t *m_pServers;
|
||||
|
||||
int m_nServerCount;
|
||||
|
||||
int m_nActiveQueries;
|
||||
int m_nQuerying;
|
||||
double m_fElapsed;
|
||||
|
||||
request_t *m_pPingRequest;
|
||||
request_t *m_pRulesRequest;
|
||||
request_t *m_pPlayersRequest;
|
||||
};
|
||||
|
||||
#endif // HUD_SERVERS_PRIVH
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,129 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#ifndef SPECTATOR_H
|
||||
#define SPECTATOR_H
|
||||
#pragma once
|
||||
|
||||
#include "cl_entity.h"
|
||||
|
||||
|
||||
|
||||
#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 OVERVIEW_TILE_SIZE 128 // don't change this
|
||||
#define OVERVIEW_MAX_LAYERS 1
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Handles the drawing of the spectator stuff (camera & top-down map and all the things on it )
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
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
|
||||
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;
|
||||
} overviewInfo_t;
|
||||
|
||||
typedef struct overviewEntity_s {
|
||||
|
||||
HSPRITE hSprite;
|
||||
struct cl_entity_s * entity;
|
||||
double killTime;
|
||||
} overviewEntity_t;
|
||||
|
||||
#define MAX_OVERVIEW_ENTITIES 128
|
||||
|
||||
class CHudSpectator : public CHudBase
|
||||
{
|
||||
public:
|
||||
void Reset();
|
||||
int ToggleInset(bool allowOff);
|
||||
void CheckSettings();
|
||||
void InitHUDData( void );
|
||||
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();
|
||||
void DrawOverviewEntities();
|
||||
void GetMapPosition( float * returnvec );
|
||||
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);
|
||||
void FindNextPlayer( bool bReverse );
|
||||
void DirectorMessage( int iSize, void *pbuf );
|
||||
void SetSpectatorStartPosition();
|
||||
int Init();
|
||||
int VidInit();
|
||||
|
||||
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;
|
||||
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;
|
||||
|
||||
|
||||
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;
|
||||
HSPRITE m_hsprPlayerRed;
|
||||
HSPRITE m_hsprPlayer;
|
||||
HSPRITE m_hsprCamera;
|
||||
HSPRITE m_hsprPlayerDead;
|
||||
HSPRITE m_hsprViewcone;
|
||||
HSPRITE m_hsprUnkownMap;
|
||||
HSPRITE m_hsprBeam;
|
||||
HSPRITE m_hCrosshair;
|
||||
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;
|
||||
};
|
||||
|
||||
#endif // SPECTATOR_H
|
||||
|
|
@ -1,56 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// hud_update.cpp
|
||||
//
|
||||
|
||||
#include <math.h>
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include <stdlib.h>
|
||||
#include <memory.h>
|
||||
|
||||
int CL_ButtonBits( int );
|
||||
void CL_ResetButtonBits( int bits );
|
||||
|
||||
extern float v_idlescale;
|
||||
float in_fov;
|
||||
extern void HUD_SetCmdBits( int bits );
|
||||
int iCarriedWeapons;
|
||||
|
||||
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));
|
||||
|
||||
m_iKeyBits = CL_ButtonBits( 0 );
|
||||
m_iWeaponBits = cdata->iWeaponBits;
|
||||
|
||||
in_fov = cdata->fov;
|
||||
|
||||
Think();
|
||||
|
||||
cdata->fov = m_iFOV;
|
||||
|
||||
v_idlescale = m_iConcussionEffect;
|
||||
|
||||
CL_ResetButtonBits( m_iKeyBits );
|
||||
|
||||
// return 1 if in anything in the client_data struct has been changed, 0 otherwise
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,628 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "camera.h"
|
||||
#include "kbutton.h"
|
||||
#include "cvardef.h"
|
||||
#include "usercmd.h"
|
||||
#include "const.h"
|
||||
#include "camera.h"
|
||||
#include "in_defs.h"
|
||||
|
||||
#include "SDL2/SDL_mouse.h"
|
||||
#include "port.h"
|
||||
|
||||
float CL_KeyState (kbutton_t *key);
|
||||
|
||||
extern "C"
|
||||
{
|
||||
void EXPORT CAM_Think( void );
|
||||
int EXPORT CL_IsThirdPerson( void );
|
||||
void EXPORT CL_CameraOffset( float *ofs );
|
||||
}
|
||||
|
||||
extern cl_enginefunc_t gEngfuncs;
|
||||
|
||||
//-------------------------------------------------- Constants
|
||||
|
||||
#define CAM_DIST_DELTA 1.0
|
||||
#define CAM_ANGLE_DELTA 2.5
|
||||
#define CAM_ANGLE_SPEED 2.5
|
||||
#define CAM_MIN_DIST 30.0
|
||||
#define CAM_ANGLE_MOVE .5
|
||||
#define MAX_ANGLE_DIFF 10.0
|
||||
#define PITCH_MAX 90.0
|
||||
#define PITCH_MIN 0
|
||||
#define YAW_MAX 135.0
|
||||
#define YAW_MIN -135.0
|
||||
|
||||
enum ECAM_Command
|
||||
{
|
||||
CAM_COMMAND_NONE = 0,
|
||||
CAM_COMMAND_TOTHIRDPERSON = 1,
|
||||
CAM_COMMAND_TOFIRSTPERSON = 2
|
||||
};
|
||||
|
||||
//-------------------------------------------------- Global Variables
|
||||
|
||||
cvar_t *cam_command;
|
||||
cvar_t *cam_snapto;
|
||||
cvar_t *cam_idealyaw;
|
||||
cvar_t *cam_idealpitch;
|
||||
cvar_t *cam_idealdist;
|
||||
cvar_t *cam_contain;
|
||||
|
||||
cvar_t *c_maxpitch;
|
||||
cvar_t *c_minpitch;
|
||||
cvar_t *c_maxyaw;
|
||||
cvar_t *c_minyaw;
|
||||
cvar_t *c_maxdistance;
|
||||
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 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;
|
||||
//-------------------------------------------------- Local Variables
|
||||
|
||||
static kbutton_t cam_pitchup, cam_pitchdown, cam_yawleft, cam_yawright;
|
||||
static kbutton_t cam_in, cam_out, cam_move;
|
||||
|
||||
//-------------------------------------------------- Prototypes
|
||||
|
||||
void CAM_ToThirdPerson(void);
|
||||
void CAM_ToFirstPerson(void);
|
||||
void CAM_StartDistance(void);
|
||||
void CAM_EndDistance(void);
|
||||
|
||||
void SDL_GetCursorPos( POINT *p )
|
||||
{
|
||||
SDL_GetMouseState( (int *)&p->x, (int *)&p->y );
|
||||
}
|
||||
|
||||
void SDL_SetCursorPos( const int x, const int y )
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------- Local Functions
|
||||
|
||||
float MoveToward( float cur, float goal, float maxspeed )
|
||||
{
|
||||
if( cur != goal )
|
||||
{
|
||||
if( abs( cur - goal ) > 180.0 )
|
||||
{
|
||||
if( cur < goal )
|
||||
cur += 360.0;
|
||||
else
|
||||
cur -= 360.0;
|
||||
}
|
||||
|
||||
if( cur < goal )
|
||||
{
|
||||
if( cur < goal - 1.0 )
|
||||
cur += ( goal - cur ) / 4.0;
|
||||
else
|
||||
cur = goal;
|
||||
}
|
||||
else
|
||||
{
|
||||
if( cur > goal + 1.0 )
|
||||
cur -= ( cur - goal ) / 4.0;
|
||||
else
|
||||
cur = goal;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// bring cur back into range
|
||||
if( cur < 0 )
|
||||
cur += 360.0;
|
||||
else if( cur >= 360 )
|
||||
cur -= 360;
|
||||
|
||||
return cur;
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------- Gobal Functions
|
||||
|
||||
typedef struct
|
||||
{
|
||||
vec3_t boxmins, boxmaxs;// enclose the test object along entire move
|
||||
float *mins, *maxs; // size of the moving object
|
||||
vec3_t mins2, maxs2; // size when clipping against mosnters
|
||||
float *start, *end;
|
||||
trace_t trace;
|
||||
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);
|
||||
|
||||
void EXPORT CAM_Think( void )
|
||||
{
|
||||
vec3_t origin;
|
||||
vec3_t ext, pnt, camForward, camRight, camUp;
|
||||
moveclip_t clip;
|
||||
float dist;
|
||||
vec3_t camAngles;
|
||||
float flSensitivity;
|
||||
#ifdef LATER
|
||||
int i;
|
||||
#endif
|
||||
vec3_t viewangles;
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
if( !cam_thirdperson )
|
||||
return;
|
||||
|
||||
#ifdef LATER
|
||||
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;
|
||||
dist = cam_idealdist->value;
|
||||
//
|
||||
//movement of the camera with the mouse
|
||||
//
|
||||
if (cam_mousemove)
|
||||
{
|
||||
//get windows cursor position
|
||||
SDL_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())
|
||||
{
|
||||
//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;
|
||||
}
|
||||
}
|
||||
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)
|
||||
{
|
||||
camAngles[PITCH] +=(CAM_ANGLE_MOVE)* ((cam_mouse.y-gEngfuncs.GetWindowCenterY())/2);
|
||||
}
|
||||
if (camAngles[PITCH]>c_maxpitch->value)
|
||||
{
|
||||
camAngles[PITCH]=c_maxpitch->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;
|
||||
}
|
||||
else
|
||||
{
|
||||
cam_old_mouse_x=cam_mouse.x;
|
||||
cam_old_mouse_y=cam_mouse.y;
|
||||
}
|
||||
SDL_SetCursorPos (gEngfuncs.GetWindowCenterX(), gEngfuncs.GetWindowCenterY());
|
||||
}
|
||||
}
|
||||
|
||||
//Nathan code here
|
||||
if( CL_KeyState( &cam_pitchup ) )
|
||||
camAngles[ PITCH ] += CAM_ANGLE_DELTA;
|
||||
else if( CL_KeyState( &cam_pitchdown ) )
|
||||
camAngles[ PITCH ] -= CAM_ANGLE_DELTA;
|
||||
|
||||
if( CL_KeyState( &cam_yawleft ) )
|
||||
camAngles[ YAW ] -= CAM_ANGLE_DELTA;
|
||||
else if( CL_KeyState( &cam_yawright ) )
|
||||
camAngles[ YAW ] += CAM_ANGLE_DELTA;
|
||||
|
||||
if( CL_KeyState( &cam_in ) )
|
||||
{
|
||||
dist -= CAM_DIST_DELTA;
|
||||
if( dist < CAM_MIN_DIST )
|
||||
{
|
||||
// If we go back into first person, reset the angle
|
||||
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_mouse.y>gEngfuncs.GetWindowCenterY())
|
||||
{
|
||||
if(dist<c_maxdistance->value)
|
||||
{
|
||||
dist +=CAM_DIST_DELTA * ((cam_mouse.y-gEngfuncs.GetWindowCenterY())/2);
|
||||
}
|
||||
if (dist>c_maxdistance->value)
|
||||
{
|
||||
dist=c_maxdistance->value;
|
||||
}
|
||||
}
|
||||
else if (cam_mouse.y<gEngfuncs.GetWindowCenterY())
|
||||
{
|
||||
if (dist>c_mindistance->value)
|
||||
{
|
||||
dist -= (CAM_DIST_DELTA)*((gEngfuncs.GetWindowCenterY()-cam_mouse.y)/2);
|
||||
}
|
||||
if (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();
|
||||
SDL_SetCursorPos (gEngfuncs.GetWindowCenterX(), gEngfuncs.GetWindowCenterY());
|
||||
}
|
||||
#ifdef LATER
|
||||
if( cam_contain->value )
|
||||
{
|
||||
// check new ideal
|
||||
VectorCopy( origin, pnt );
|
||||
AngleVectors( camAngles, camForward, camRight, camUp );
|
||||
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 ) );
|
||||
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_idealdist->value = dist;
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
// update ideal
|
||||
cam_idealpitch->value = camAngles[ PITCH ];
|
||||
cam_idealyaw->value = camAngles[ YAW ];
|
||||
cam_idealdist->value = dist;
|
||||
}
|
||||
|
||||
// Move towards ideal
|
||||
VectorCopy( cam_ofs, camAngles );
|
||||
|
||||
gEngfuncs.GetViewAngles( (float *)viewangles );
|
||||
|
||||
if( cam_snapto->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[ PITCH ] - viewangles[ PITCH ] != cam_idealpitch->value )
|
||||
camAngles[ PITCH ] = MoveToward( camAngles[ PITCH ], cam_idealpitch->value + viewangles[ PITCH ], CAM_ANGLE_SPEED );
|
||||
|
||||
if( abs( camAngles[ 2 ] - cam_idealdist->value ) < 2.0 )
|
||||
camAngles[ 2 ] = cam_idealdist->value;
|
||||
else
|
||||
camAngles[ 2 ] += ( cam_idealdist->value - camAngles[ 2 ] ) / 4.0;
|
||||
}
|
||||
#ifdef LATER
|
||||
if( cam_contain->value )
|
||||
{
|
||||
// Test new position
|
||||
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];
|
||||
|
||||
// check line from r_refdef.vieworg to pnt
|
||||
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;
|
||||
}
|
||||
|
||||
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_ToThirdPerson(void)
|
||||
{
|
||||
//Only allow cam_command if we are running a debug version of the client.dll
|
||||
#ifndef _DEBUG
|
||||
return;
|
||||
#endif
|
||||
|
||||
vec3_t viewangles;
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
gEngfuncs.Cvar_SetValue( "cam_command", 0 );
|
||||
}
|
||||
|
||||
void CAM_ToFirstPerson(void)
|
||||
{
|
||||
cam_thirdperson = 0;
|
||||
|
||||
gEngfuncs.Cvar_SetValue( "cam_command", 0 );
|
||||
}
|
||||
|
||||
void CAM_ToggleSnapto( void )
|
||||
{
|
||||
cam_snapto->value = !cam_snapto->value;
|
||||
}
|
||||
|
||||
void CAM_Init( void )
|
||||
{
|
||||
gEngfuncs.pfnAddCommand( "+campitchup", CAM_PitchUpDown );
|
||||
gEngfuncs.pfnAddCommand( "-campitchup", CAM_PitchUpUp );
|
||||
gEngfuncs.pfnAddCommand( "+campitchdown", CAM_PitchDownDown );
|
||||
gEngfuncs.pfnAddCommand( "-campitchdown", CAM_PitchDownUp );
|
||||
gEngfuncs.pfnAddCommand( "+camyawleft", CAM_YawLeftDown );
|
||||
gEngfuncs.pfnAddCommand( "-camyawleft", CAM_YawLeftUp );
|
||||
gEngfuncs.pfnAddCommand( "+camyawright", CAM_YawRightDown );
|
||||
gEngfuncs.pfnAddCommand( "-camyawright", CAM_YawRightUp );
|
||||
gEngfuncs.pfnAddCommand( "+camin", CAM_InDown );
|
||||
gEngfuncs.pfnAddCommand( "-camin", CAM_InUp );
|
||||
gEngfuncs.pfnAddCommand( "+camout", CAM_OutDown );
|
||||
gEngfuncs.pfnAddCommand( "-camout", CAM_OutUp );
|
||||
gEngfuncs.pfnAddCommand( "thirdperson", CAM_ToThirdPerson );
|
||||
gEngfuncs.pfnAddCommand( "firstperson", CAM_ToFirstPerson );
|
||||
gEngfuncs.pfnAddCommand( "+cammousemove",CAM_StartMouseMove);
|
||||
gEngfuncs.pfnAddCommand( "-cammousemove",CAM_EndMouseMove);
|
||||
gEngfuncs.pfnAddCommand( "+camdistance", CAM_StartDistance );
|
||||
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
|
||||
|
||||
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 )
|
||||
{
|
||||
vec3_t viewangles;
|
||||
|
||||
gEngfuncs.GetViewAngles( (float *)viewangles );
|
||||
|
||||
cam_pitchup.state = 0;
|
||||
cam_pitchdown.state = 0;
|
||||
cam_yawleft.state = 0;
|
||||
cam_yawright.state = 0;
|
||||
cam_in.state = 0;
|
||||
cam_out.state = 0;
|
||||
|
||||
cam_thirdperson = 0;
|
||||
cam_command->value = 0;
|
||||
cam_mousemove=0;
|
||||
|
||||
cam_snapto->value = 0;
|
||||
cam_distancemove = 0;
|
||||
|
||||
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_idealdist->value = CAM_MIN_DIST;
|
||||
}
|
||||
|
||||
void CAM_StartMouseMove(void)
|
||||
{
|
||||
float flSensitivity;
|
||||
|
||||
//only move the cam with mouse if we are in third person.
|
||||
if (cam_thirdperson)
|
||||
{
|
||||
//set appropriate flags and initialize the old mouse position
|
||||
//variables for mouse camera movement
|
||||
if (!cam_mousemove)
|
||||
{
|
||||
cam_mousemove=1;
|
||||
iMouseInUse=1;
|
||||
SDL_GetCursorPos (&cam_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;
|
||||
}
|
||||
}
|
||||
}
|
||||
//we are not in 3rd person view..therefore do not allow camera movement
|
||||
else
|
||||
{
|
||||
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)
|
||||
{
|
||||
cam_mousemove=0;
|
||||
iMouseInUse=0;
|
||||
}
|
||||
|
||||
|
||||
//----------------------------------------------------------
|
||||
//routines to start the process of moving the cam in or out
|
||||
//using the mouse
|
||||
//----------------------------------------------------------
|
||||
void CAM_StartDistance(void)
|
||||
{
|
||||
//only move the cam with mouse if we are in third person.
|
||||
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;
|
||||
SDL_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;
|
||||
}
|
||||
}
|
||||
|
||||
//the key has been released for camera movement
|
||||
//tell the engine that mouse camera movement is off
|
||||
void CAM_EndDistance(void)
|
||||
{
|
||||
cam_distancemove=0;
|
||||
cam_mousemove=0;
|
||||
iMouseInUse=0;
|
||||
}
|
||||
|
||||
int EXPORT CL_IsThirdPerson( void )
|
||||
{
|
||||
return cam_thirdperson ? 1 : 0;
|
||||
}
|
||||
|
||||
void EXPORT CL_CameraOffset( float *ofs )
|
||||
{
|
||||
VectorCopy( cam_ofs, ofs );
|
||||
}
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#if !defined( IN_DEFSH )
|
||||
#define IN_DEFSH
|
||||
#pragma once
|
||||
|
||||
// up / down
|
||||
#define PITCH 0
|
||||
// left / right
|
||||
#define YAW 1
|
||||
// fall over
|
||||
#define ROLL 2
|
||||
|
||||
#define DLLEXPORT __declspec( dllexport )
|
||||
|
||||
#endif
|
||||
1039
dmc/cl_dll/input.cpp
1039
dmc/cl_dll/input.cpp
File diff suppressed because it is too large
Load Diff
|
|
@ -1,942 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
// in_win.c -- windows 95 mouse and joystick code
|
||||
// 02/21/97 JCB Added extended DirectInput code to support external controllers.
|
||||
|
||||
#include "port.h"
|
||||
#include <SDL2/SDL_mouse.h>
|
||||
#include <SDL2/SDL_gamecontroller.h>
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "camera.h"
|
||||
#include "kbutton.h"
|
||||
#include "cvardef.h"
|
||||
#include "usercmd.h"
|
||||
#include "const.h"
|
||||
#include "camera.h"
|
||||
#include "in_defs.h"
|
||||
#include "../public/keydefs.h"
|
||||
#include "view.h"
|
||||
#include "Exports.h"
|
||||
/*#ifdef _WIN32
|
||||
#define CL_DLLEXPORT EXPORT
|
||||
#else
|
||||
#define CL_DLLEXPORT __attribute__ ((visibility("default")))
|
||||
#endif*/
|
||||
|
||||
#define MOUSE_BUTTON_COUNT 5
|
||||
|
||||
// Set this to 1 to show mouse cursor. Experimental
|
||||
int g_iVisibleMouse = 0;
|
||||
|
||||
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 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;
|
||||
extern cvar_t *cl_pitchdown;
|
||||
extern cvar_t *cl_pitchup;
|
||||
extern cvar_t *cl_yawspeed;
|
||||
extern cvar_t *cl_sidespeed;
|
||||
extern cvar_t *cl_forwardspeed;
|
||||
extern cvar_t *cl_pitchspeed;
|
||||
extern cvar_t *cl_movespeedkey;
|
||||
|
||||
// mouse variables
|
||||
cvar_t *m_filter;
|
||||
cvar_t *sensitivity;
|
||||
|
||||
// Custom mouse acceleration (0 disable, 1 to enable, 2 enable with separate yaw/pitch rescale)
|
||||
static cvar_t *m_customaccel;
|
||||
//Formula: mousesensitivity = ( rawmousedelta^m_customaccel_exponent ) * m_customaccel_scale + sensitivity
|
||||
// If mode is 2, then x and y sensitivity are scaled by m_pitch and m_yaw respectively.
|
||||
// Custom mouse acceleration value.
|
||||
static cvar_t *m_customaccel_scale;
|
||||
//Max mouse move scale factor, 0 for no limit
|
||||
static cvar_t *m_customaccel_max;
|
||||
//Mouse move is raised to this power before being scaled by scale factor
|
||||
static cvar_t *m_customaccel_exponent;
|
||||
|
||||
int mouse_buttons;
|
||||
int mouse_oldbuttonstate;
|
||||
POINT current_pos;
|
||||
int old_mouse_x, old_mouse_y, mx_accum, my_accum;
|
||||
float mouse_x, mouse_y;
|
||||
|
||||
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_AXIS_X 0
|
||||
#define JOY_AXIS_Y 1
|
||||
#define JOY_AXIS_Z 2
|
||||
#define JOY_AXIS_R 3
|
||||
#define JOY_AXIS_U 4
|
||||
#define JOY_AXIS_V 5
|
||||
|
||||
enum _ControlList
|
||||
{
|
||||
AxisNada = 0,
|
||||
AxisForward,
|
||||
AxisLook,
|
||||
AxisSide,
|
||||
AxisTurn
|
||||
};
|
||||
|
||||
|
||||
DWORD dwAxisMap[ JOY_MAX_AXES ];
|
||||
DWORD dwControlMap[ JOY_MAX_AXES ];
|
||||
DWORD pdwRawValue[ JOY_MAX_AXES ];
|
||||
DWORD joy_oldbuttonstate, joy_oldpovstate;
|
||||
|
||||
int joy_id;
|
||||
DWORD joy_flags;
|
||||
DWORD joy_numbuttons;
|
||||
|
||||
SDL_GameController *s_pJoystick = NULL;
|
||||
|
||||
// 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;
|
||||
|
||||
int joy_avail, joy_advancedinit, joy_haspov;
|
||||
|
||||
/*
|
||||
===========
|
||||
Force_CenterView_f
|
||||
===========
|
||||
*/
|
||||
void Force_CenterView_f (void)
|
||||
{
|
||||
vec3_t viewangles;
|
||||
|
||||
if (!iMouseInUse)
|
||||
{
|
||||
gEngfuncs.GetViewAngles( (float *)viewangles );
|
||||
viewangles[PITCH] = 0;
|
||||
gEngfuncs.SetViewAngles( (float *)viewangles );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
===========
|
||||
IN_ActivateMouse
|
||||
===========
|
||||
*/
|
||||
void CL_DLLEXPORT IN_ActivateMouse (void)
|
||||
{
|
||||
if (mouseinitialized)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
if (mouseparmsvalid)
|
||||
restore_spi = SystemParametersInfo (SPI_SETMOUSE, 0, newmouseparms, 0);
|
||||
#endif
|
||||
mouseactive = 1;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
===========
|
||||
IN_DeactivateMouse
|
||||
===========
|
||||
*/
|
||||
void CL_DLLEXPORT IN_DeactivateMouse (void)
|
||||
{
|
||||
if (mouseinitialized)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
if (restore_spi)
|
||||
SystemParametersInfo (SPI_SETMOUSE, 0, originalmouseparms, 0);
|
||||
#endif
|
||||
|
||||
mouseactive = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
===========
|
||||
IN_StartupMouse
|
||||
===========
|
||||
*/
|
||||
void IN_StartupMouse (void)
|
||||
{
|
||||
if ( gEngfuncs.CheckParm ("-nomouse", NULL ) )
|
||||
return;
|
||||
|
||||
mouseinitialized = 1;
|
||||
#ifdef _WIN32
|
||||
mouseparmsvalid = SystemParametersInfo (SPI_GETMOUSE, 0, originalmouseparms, 0);
|
||||
|
||||
if (mouseparmsvalid)
|
||||
{
|
||||
if ( gEngfuncs.CheckParm ("-noforcemspd", NULL ) )
|
||||
newmouseparms[2] = originalmouseparms[2];
|
||||
|
||||
if ( gEngfuncs.CheckParm ("-noforcemaccel", NULL ) )
|
||||
{
|
||||
newmouseparms[0] = originalmouseparms[0];
|
||||
newmouseparms[1] = originalmouseparms[1];
|
||||
}
|
||||
|
||||
if ( gEngfuncs.CheckParm ("-noforcemparms", NULL ) )
|
||||
{
|
||||
newmouseparms[0] = originalmouseparms[0];
|
||||
newmouseparms[1] = originalmouseparms[1];
|
||||
newmouseparms[2] = originalmouseparms[2];
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
mouse_buttons = MOUSE_BUTTON_COUNT;
|
||||
}
|
||||
|
||||
/*
|
||||
===========
|
||||
IN_Shutdown
|
||||
===========
|
||||
*/
|
||||
void IN_Shutdown (void)
|
||||
{
|
||||
IN_DeactivateMouse ();
|
||||
}
|
||||
|
||||
/*
|
||||
===========
|
||||
IN_GetMousePos
|
||||
|
||||
Ask for mouse position from engine
|
||||
===========
|
||||
*/
|
||||
void IN_GetMousePos( int *mx, int *my )
|
||||
{
|
||||
gEngfuncs.GetMousePosition( mx, my );
|
||||
}
|
||||
|
||||
/*
|
||||
===========
|
||||
IN_ResetMouse
|
||||
|
||||
FIXME: Call through to engine?
|
||||
===========
|
||||
*/
|
||||
void IN_ResetMouse( void )
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
===========
|
||||
IN_MouseEvent
|
||||
===========
|
||||
*/
|
||||
void CL_DLLEXPORT IN_MouseEvent (int mstate)
|
||||
{
|
||||
int i;
|
||||
|
||||
if ( iMouseInUse || g_iVisibleMouse )
|
||||
return;
|
||||
|
||||
// perform button actions
|
||||
for (i=0 ; i<mouse_buttons ; i++)
|
||||
{
|
||||
if ( (mstate & (1<<i)) &&
|
||||
!(mouse_oldbuttonstate & (1<<i)) )
|
||||
{
|
||||
gEngfuncs.Key_Event (K_MOUSE1 + i, 1);
|
||||
}
|
||||
|
||||
if ( !(mstate & (1<<i)) &&
|
||||
(mouse_oldbuttonstate & (1<<i)) )
|
||||
{
|
||||
gEngfuncs.Key_Event (K_MOUSE1 + i, 0);
|
||||
}
|
||||
}
|
||||
|
||||
mouse_oldbuttonstate = mstate;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Allows modulation of mouse scaling/senstivity value and application
|
||||
// of custom algorithms.
|
||||
// Input : *x -
|
||||
// *y -
|
||||
//-----------------------------------------------------------------------------
|
||||
void IN_ScaleMouse( float *x, float *y )
|
||||
{
|
||||
float mx = *x;
|
||||
float my = *y;
|
||||
|
||||
// This is the default sensitivity
|
||||
float mouse_senstivity = ( gHUD.GetSensitivity() != 0 ) ? gHUD.GetSensitivity() : sensitivity->value;
|
||||
|
||||
// Using special accleration values
|
||||
if ( m_customaccel->value != 0 )
|
||||
{
|
||||
float raw_mouse_movement_distance = sqrt( mx * mx + my * my );
|
||||
float acceleration_scale = m_customaccel_scale->value;
|
||||
float accelerated_sensitivity_max = m_customaccel_max->value;
|
||||
float accelerated_sensitivity_exponent = m_customaccel_exponent->value;
|
||||
float accelerated_sensitivity = ( (float)pow( raw_mouse_movement_distance, accelerated_sensitivity_exponent ) * acceleration_scale + mouse_senstivity );
|
||||
|
||||
if ( accelerated_sensitivity_max > 0.0001f &&
|
||||
accelerated_sensitivity > accelerated_sensitivity_max )
|
||||
{
|
||||
accelerated_sensitivity = accelerated_sensitivity_max;
|
||||
}
|
||||
|
||||
*x *= accelerated_sensitivity;
|
||||
*y *= accelerated_sensitivity;
|
||||
|
||||
// Further re-scale by yaw and pitch magnitude if user requests alternate mode 2
|
||||
// This means that they will need to up their value for m_customaccel_scale greatly (>40x) since m_pitch/yaw default
|
||||
// to 0.022
|
||||
if ( m_customaccel->value == 2 )
|
||||
{
|
||||
*x *= m_yaw->value;
|
||||
*y *= m_pitch->value;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Just apply the default
|
||||
*x *= mouse_senstivity;
|
||||
*y *= mouse_senstivity;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
===========
|
||||
IN_MouseMove
|
||||
===========
|
||||
*/
|
||||
void IN_MouseMove ( float frametime, usercmd_t *cmd)
|
||||
{
|
||||
int mx, my;
|
||||
vec3_t viewangles;
|
||||
|
||||
gEngfuncs.GetViewAngles( (float *)viewangles );
|
||||
|
||||
if ( in_mlook.state & 1)
|
||||
{
|
||||
V_StopPitchDrift ();
|
||||
}
|
||||
|
||||
//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 && !gHUD.m_iIntermission && !g_iVisibleMouse )
|
||||
{
|
||||
int deltaX, deltaY;
|
||||
SDL_GetRelativeMouseState( &deltaX, &deltaY );
|
||||
current_pos.x = deltaX;
|
||||
current_pos.y = deltaY;
|
||||
mx = deltaX + mx_accum;
|
||||
my = deltaY + my_accum;
|
||||
|
||||
mx_accum = 0;
|
||||
my_accum = 0;
|
||||
|
||||
if (m_filter->value)
|
||||
{
|
||||
mouse_x = (mx + old_mouse_x) * 0.5;
|
||||
mouse_y = (my + old_mouse_y) * 0.5;
|
||||
}
|
||||
else
|
||||
{
|
||||
mouse_x = mx;
|
||||
mouse_y = my;
|
||||
}
|
||||
|
||||
old_mouse_x = mx;
|
||||
old_mouse_y = my;
|
||||
|
||||
// Apply custom mouse scaling/acceleration
|
||||
IN_ScaleMouse( &mouse_x, &mouse_y );
|
||||
|
||||
// add mouse X/Y movement to cmd
|
||||
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))
|
||||
{
|
||||
viewangles[PITCH] += m_pitch->value * mouse_y;
|
||||
if (viewangles[PITCH] > cl_pitchdown->value)
|
||||
viewangles[PITCH] = cl_pitchdown->value;
|
||||
if (viewangles[PITCH] < -cl_pitchup->value)
|
||||
viewangles[PITCH] = -cl_pitchup->value;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ((in_strafe.state & 1) && gEngfuncs.IsNoClipping() )
|
||||
{
|
||||
cmd->upmove -= m_forward->value * mouse_y;
|
||||
}
|
||||
else
|
||||
{
|
||||
cmd->forwardmove -= m_forward->value * mouse_y;
|
||||
}
|
||||
}
|
||||
|
||||
// if the mouse has moved, force it to the center, so there's room to move
|
||||
if ( mx || my )
|
||||
{
|
||||
IN_ResetMouse();
|
||||
}
|
||||
}
|
||||
|
||||
gEngfuncs.SetViewAngles( (float *)viewangles );
|
||||
|
||||
/*
|
||||
//#define TRACE_TEST
|
||||
#if defined( TRACE_TEST )
|
||||
{
|
||||
int mx, my;
|
||||
void V_Move( int mx, int my );
|
||||
IN_GetMousePos( &mx, &my );
|
||||
V_Move( mx, my );
|
||||
}
|
||||
#endif
|
||||
*/
|
||||
}
|
||||
|
||||
/*
|
||||
===========
|
||||
IN_Accumulate
|
||||
===========
|
||||
*/
|
||||
void CL_DLLEXPORT IN_Accumulate (void)
|
||||
{
|
||||
//only accumulate mouse if we are not moving the camera with the mouse
|
||||
if ( !iMouseInUse && !g_iVisibleMouse)
|
||||
{
|
||||
if (mouseactive)
|
||||
{
|
||||
int deltaX, deltaY;
|
||||
SDL_GetRelativeMouseState( &deltaX, &deltaY );
|
||||
mx_accum += deltaX;
|
||||
my_accum += deltaY;
|
||||
// force the mouse to the center, so there's room to move
|
||||
IN_ResetMouse();
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
===================
|
||||
IN_ClearStates
|
||||
===================
|
||||
*/
|
||||
void CL_DLLEXPORT IN_ClearStates (void)
|
||||
{
|
||||
if ( !mouseactive )
|
||||
return;
|
||||
|
||||
mx_accum = 0;
|
||||
my_accum = 0;
|
||||
mouse_oldbuttonstate = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
IN_StartupJoystick
|
||||
===============
|
||||
*/
|
||||
void IN_StartupJoystick (void)
|
||||
{
|
||||
// abort startup if user requests no joystick
|
||||
if ( gEngfuncs.CheckParm ("-nojoy", NULL ) )
|
||||
return;
|
||||
|
||||
// assume no joystick
|
||||
joy_avail = 0;
|
||||
|
||||
int nJoysticks = SDL_NumJoysticks();
|
||||
if ( nJoysticks > 0 )
|
||||
{
|
||||
for ( int i = 0; i < nJoysticks; i++ )
|
||||
{
|
||||
if ( SDL_IsGameController( i ) )
|
||||
{
|
||||
s_pJoystick = SDL_GameControllerOpen( i );
|
||||
if ( s_pJoystick )
|
||||
{
|
||||
//save the joystick's number of buttons and POV status
|
||||
joy_numbuttons = SDL_CONTROLLER_BUTTON_MAX;
|
||||
joy_haspov = 0;
|
||||
|
||||
// old button and POV states default to no buttons pressed
|
||||
joy_oldbuttonstate = joy_oldpovstate = 0;
|
||||
|
||||
// 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", SDL_GameControllerName(s_pJoystick));
|
||||
joy_avail = 1;
|
||||
joy_advancedinit = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
gEngfuncs.Con_DPrintf ("joystick not found -- driver not present\n\n");
|
||||
}
|
||||
}
|
||||
|
||||
int RawValuePointer (int axis)
|
||||
{
|
||||
switch (axis)
|
||||
{
|
||||
default:
|
||||
case JOY_AXIS_X:
|
||||
return SDL_GameControllerGetAxis( s_pJoystick, SDL_CONTROLLER_AXIS_LEFTX );
|
||||
case JOY_AXIS_Y:
|
||||
return SDL_GameControllerGetAxis( s_pJoystick, SDL_CONTROLLER_AXIS_LEFTY );
|
||||
case JOY_AXIS_Z:
|
||||
return SDL_GameControllerGetAxis( s_pJoystick, SDL_CONTROLLER_AXIS_RIGHTX );
|
||||
case JOY_AXIS_R:
|
||||
return SDL_GameControllerGetAxis( s_pJoystick, SDL_CONTROLLER_AXIS_RIGHTY );
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
===========
|
||||
Joy_AdvancedUpdate_f
|
||||
===========
|
||||
*/
|
||||
void Joy_AdvancedUpdate_f (void)
|
||||
{
|
||||
|
||||
// called once by IN_ReadJoystick and by user whenever an update is needed
|
||||
// cvars are now available
|
||||
int i;
|
||||
DWORD dwTemp;
|
||||
|
||||
// initialize all the maps
|
||||
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)
|
||||
{
|
||||
// default joystick initialization
|
||||
// 2 axes only with joystick control
|
||||
dwAxisMap[JOY_AXIS_X] = AxisTurn;
|
||||
// dwControlMap[JOY_AXIS_X] = JOY_ABSOLUTE_AXIS;
|
||||
dwAxisMap[JOY_AXIS_Y] = AxisForward;
|
||||
// dwControlMap[JOY_AXIS_Y] = JOY_ABSOLUTE_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( strcmp ( joy_name->string, "joystick") != 0 )
|
||||
{
|
||||
// notify user of advanced controller
|
||||
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;
|
||||
dwAxisMap[JOY_AXIS_X] = dwTemp & 0x0000000f;
|
||||
dwControlMap[JOY_AXIS_X] = dwTemp & JOY_RELATIVE_AXIS;
|
||||
dwTemp = (DWORD) joy_advaxisy->value;
|
||||
dwAxisMap[JOY_AXIS_Y] = dwTemp & 0x0000000f;
|
||||
dwControlMap[JOY_AXIS_Y] = dwTemp & JOY_RELATIVE_AXIS;
|
||||
dwTemp = (DWORD) joy_advaxisz->value;
|
||||
dwAxisMap[JOY_AXIS_Z] = dwTemp & 0x0000000f;
|
||||
dwControlMap[JOY_AXIS_Z] = dwTemp & JOY_RELATIVE_AXIS;
|
||||
dwTemp = (DWORD) joy_advaxisr->value;
|
||||
dwAxisMap[JOY_AXIS_R] = dwTemp & 0x0000000f;
|
||||
dwControlMap[JOY_AXIS_R] = dwTemp & JOY_RELATIVE_AXIS;
|
||||
dwTemp = (DWORD) joy_advaxisu->value;
|
||||
dwAxisMap[JOY_AXIS_U] = dwTemp & 0x0000000f;
|
||||
dwControlMap[JOY_AXIS_U] = dwTemp & JOY_RELATIVE_AXIS;
|
||||
dwTemp = (DWORD) joy_advaxisv->value;
|
||||
dwAxisMap[JOY_AXIS_V] = dwTemp & 0x0000000f;
|
||||
dwControlMap[JOY_AXIS_V] = dwTemp & JOY_RELATIVE_AXIS;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===========
|
||||
IN_Commands
|
||||
===========
|
||||
*/
|
||||
void IN_Commands (void)
|
||||
{
|
||||
int i, key_index;
|
||||
|
||||
if (!joy_avail)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
DWORD buttonstate, povstate;
|
||||
|
||||
// loop through the joystick buttons
|
||||
// key a joystick event or auxillary event for higher number buttons for each state change
|
||||
buttonstate = 0;
|
||||
for ( i = 0; i < SDL_CONTROLLER_BUTTON_MAX; i++ )
|
||||
{
|
||||
if ( SDL_GameControllerGetButton( s_pJoystick, (SDL_GameControllerButton)i ) )
|
||||
{
|
||||
buttonstate |= 1<<i;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < JOY_MAX_AXES; i++)
|
||||
{
|
||||
pdwRawValue[i] = RawValuePointer(i);
|
||||
}
|
||||
|
||||
for (i=0 ; i < (int)joy_numbuttons ; i++)
|
||||
{
|
||||
if ( (buttonstate & (1<<i)) && !(joy_oldbuttonstate & (1<<i)) )
|
||||
{
|
||||
key_index = (i < 4) ? K_JOY1 : K_AUX1;
|
||||
gEngfuncs.Key_Event (key_index + i, 1);
|
||||
}
|
||||
|
||||
if ( !(buttonstate & (1<<i)) && (joy_oldbuttonstate & (1<<i)) )
|
||||
{
|
||||
key_index = (i < 4) ? K_JOY1 : K_AUX1;
|
||||
gEngfuncs.Key_Event (key_index + i, 0);
|
||||
}
|
||||
}
|
||||
joy_oldbuttonstate = buttonstate;
|
||||
|
||||
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;
|
||||
// determine which bits have changed and key an auxillary event for each change
|
||||
for (i=0 ; i < 4 ; i++)
|
||||
{
|
||||
if ( (povstate & (1<<i)) && !(joy_oldpovstate & (1<<i)) )
|
||||
{
|
||||
gEngfuncs.Key_Event (K_AUX29 + i, 1);
|
||||
}
|
||||
|
||||
if ( !(povstate & (1<<i)) && (joy_oldpovstate & (1<<i)) )
|
||||
{
|
||||
gEngfuncs.Key_Event (K_AUX29 + i, 0);
|
||||
}
|
||||
}
|
||||
joy_oldpovstate = povstate;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
IN_ReadJoystick
|
||||
===============
|
||||
*/
|
||||
int IN_ReadJoystick (void)
|
||||
{
|
||||
SDL_JoystickUpdate();
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===========
|
||||
IN_JoyMove
|
||||
===========
|
||||
*/
|
||||
void IN_JoyMove ( float frametime, usercmd_t *cmd )
|
||||
{
|
||||
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 )
|
||||
{
|
||||
Joy_AdvancedUpdate_f();
|
||||
joy_advancedinit = 1;
|
||||
}
|
||||
|
||||
// verify joystick is available and that the user wants to use it
|
||||
if (!joy_avail || !in_joystick->value)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// collect the joystick data, if possible
|
||||
if (IN_ReadJoystick () != 1)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (in_speed.state & 1)
|
||||
speed = cl_movespeedkey->value;
|
||||
else
|
||||
speed = 1;
|
||||
|
||||
aspeed = speed * frametime;
|
||||
|
||||
// loop through the axes
|
||||
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 (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 = 14000.0;
|
||||
// restore direction information
|
||||
fAxisValue = (fAxisValue > 0.0) ? fTemp : -fTemp;
|
||||
}
|
||||
}
|
||||
|
||||
// convert range from -32768..32767 to -1..1
|
||||
fAxisValue /= 32768.0;
|
||||
|
||||
switch (dwAxisMap[i])
|
||||
{
|
||||
case AxisForward:
|
||||
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 mouse invert is on, invert the joystick pitch value
|
||||
// only absolute control support here (joy_advanced is 0)
|
||||
if (m_pitch->value < 0.0)
|
||||
{
|
||||
viewangles[PITCH] -= (fAxisValue * joy_pitchsensitivity->value) * aspeed * cl_pitchspeed->value;
|
||||
}
|
||||
else
|
||||
{
|
||||
viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity->value) * aspeed * cl_pitchspeed->value;
|
||||
}
|
||||
V_StopPitchDrift();
|
||||
}
|
||||
else
|
||||
{
|
||||
// no pitch movement
|
||||
// disable pitch return-to-center unless requested by user
|
||||
// *** this code can be removed when the lookspring bug is fixed
|
||||
// *** the bug always has the lookspring feature on
|
||||
if(lookspring->value == 0.0)
|
||||
{
|
||||
V_StopPitchDrift();
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// user wants forward control to be forward control
|
||||
if (fabs(fAxisValue) > joy_forwardthreshold->value)
|
||||
{
|
||||
cmd->forwardmove += (fAxisValue * joy_forwardsensitivity->value) * speed * cl_forwardspeed->value;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case AxisSide:
|
||||
if (fabs(fAxisValue) > joy_sidethreshold->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)))
|
||||
{
|
||||
// user wants turn control to become side control
|
||||
if (fabs(fAxisValue) > joy_sidethreshold->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(dwControlMap[i] == JOY_ABSOLUTE_AXIS)
|
||||
{
|
||||
viewangles[YAW] += (fAxisValue * joy_yawsensitivity->value) * aspeed * cl_yawspeed->value;
|
||||
}
|
||||
else
|
||||
{
|
||||
viewangles[YAW] += (fAxisValue * joy_yawsensitivity->value) * speed * 180.0;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case AxisLook:
|
||||
if (in_jlook.state & 1)
|
||||
{
|
||||
if (fabs(fAxisValue) > joy_pitchthreshold->value)
|
||||
{
|
||||
// pitch movement detected and pitch movement desired by user
|
||||
if(dwControlMap[i] == JOY_ABSOLUTE_AXIS)
|
||||
{
|
||||
viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity->value) * aspeed * cl_pitchspeed->value;
|
||||
}
|
||||
else
|
||||
{
|
||||
viewangles[PITCH] += (fAxisValue * joy_pitchsensitivity->value) * speed * 180.0;
|
||||
}
|
||||
V_StopPitchDrift();
|
||||
}
|
||||
else
|
||||
{
|
||||
// no pitch movement
|
||||
// disable pitch return-to-center unless requested by user
|
||||
// *** this code can be removed when the lookspring bug is fixed
|
||||
// *** the bug always has the lookspring feature on
|
||||
if( lookspring->value == 0.0 )
|
||||
{
|
||||
V_StopPitchDrift();
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// bounds check pitch
|
||||
if (viewangles[PITCH] > cl_pitchdown->value)
|
||||
viewangles[PITCH] = cl_pitchdown->value;
|
||||
if (viewangles[PITCH] < -cl_pitchup->value)
|
||||
viewangles[PITCH] = -cl_pitchup->value;
|
||||
|
||||
gEngfuncs.SetViewAngles( (float *)viewangles );
|
||||
}
|
||||
|
||||
/*
|
||||
===========
|
||||
IN_Move
|
||||
===========
|
||||
*/
|
||||
void IN_Move ( float frametime, usercmd_t *cmd)
|
||||
{
|
||||
if ( !iMouseInUse && mouseactive )
|
||||
{
|
||||
IN_MouseMove ( frametime, cmd);
|
||||
}
|
||||
|
||||
IN_JoyMove ( frametime, cmd);
|
||||
}
|
||||
|
||||
/*
|
||||
===========
|
||||
IN_Init
|
||||
===========
|
||||
*/
|
||||
void IN_Init (void)
|
||||
{
|
||||
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 );
|
||||
|
||||
m_customaccel = gEngfuncs.pfnRegisterVariable ( "m_customaccel", "0", FCVAR_ARCHIVE );
|
||||
m_customaccel_scale = gEngfuncs.pfnRegisterVariable ( "m_customaccel_scale", "0.04", FCVAR_ARCHIVE );
|
||||
m_customaccel_max = gEngfuncs.pfnRegisterVariable ( "m_customaccel_max", "0", FCVAR_ARCHIVE );
|
||||
m_customaccel_exponent = gEngfuncs.pfnRegisterVariable ( "m_customaccel_exponent", "1", FCVAR_ARCHIVE );
|
||||
|
||||
gEngfuncs.pfnAddCommand ("force_centerview", Force_CenterView_f);
|
||||
gEngfuncs.pfnAddCommand ("joyadvancedupdate", Joy_AdvancedUpdate_f);
|
||||
|
||||
IN_StartupMouse ();
|
||||
IN_StartupJoystick ();
|
||||
}
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#if !defined( KBUTTONH )
|
||||
#define KBUTTONH
|
||||
#pragma once
|
||||
|
||||
typedef struct kbutton_s
|
||||
{
|
||||
int down[2]; // key nums holding it down
|
||||
int state; // low bit is down state
|
||||
} kbutton_t;
|
||||
|
||||
#endif // !KBUTTONH
|
||||
|
|
@ -1,282 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// menu.cpp
|
||||
//
|
||||
// generic menu handler
|
||||
//
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "parsemsg.h"
|
||||
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include "vgui_viewport.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 );
|
||||
|
||||
int CHudMenu :: Init( void )
|
||||
{
|
||||
gHUD.AddHudElem( this );
|
||||
|
||||
HOOK_MESSAGE( ShowMenu );
|
||||
|
||||
InitHUDData();
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void CHudMenu :: InitHUDData( void )
|
||||
{
|
||||
m_fMenuDisplayed = 0;
|
||||
m_bitsValidSlots = 0;
|
||||
Reset();
|
||||
}
|
||||
|
||||
void CHudMenu :: Reset( void )
|
||||
{
|
||||
g_szPrelocalisedMenuString[0] = 0;
|
||||
m_fWaitingForMore = FALSE;
|
||||
}
|
||||
|
||||
int CHudMenu :: VidInit( void )
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/*=================================
|
||||
ParseEscapeToken
|
||||
|
||||
Interprets the given escape token (backslash followed by a letter). The
|
||||
first character of the token must be a backslash. The second character
|
||||
specifies the operation to perform:
|
||||
|
||||
\w : White text (this is the default)
|
||||
\d : Dim (gray) text
|
||||
\y : Yellow text
|
||||
\r : Red text
|
||||
\R : Right-align (just for the remainder of the current line)
|
||||
=================================*/
|
||||
|
||||
static int menu_r, menu_g, menu_b, menu_x, menu_ralign;
|
||||
|
||||
static inline const char* ParseEscapeToken( const char* token )
|
||||
{
|
||||
if ( *token != '\\' )
|
||||
return token;
|
||||
|
||||
token++;
|
||||
|
||||
switch ( *token )
|
||||
{
|
||||
case '\0':
|
||||
return token;
|
||||
|
||||
case 'w':
|
||||
menu_r = 255;
|
||||
menu_g = 255;
|
||||
menu_b = 255;
|
||||
break;
|
||||
|
||||
case 'd':
|
||||
menu_r = 100;
|
||||
menu_g = 100;
|
||||
menu_b = 100;
|
||||
break;
|
||||
|
||||
case 'y':
|
||||
menu_r = 255;
|
||||
menu_g = 210;
|
||||
menu_b = 64;
|
||||
break;
|
||||
|
||||
case 'r':
|
||||
menu_r = 210;
|
||||
menu_g = 24;
|
||||
menu_b = 0;
|
||||
break;
|
||||
|
||||
case 'R':
|
||||
menu_x = ScreenWidth/2;
|
||||
menu_ralign = TRUE;
|
||||
break;
|
||||
}
|
||||
|
||||
return ++token;
|
||||
}
|
||||
|
||||
|
||||
int CHudMenu :: Draw( float flTime )
|
||||
{
|
||||
// check for if menu is set to disappear
|
||||
if ( m_flShutoffTime > 0 )
|
||||
{
|
||||
if ( m_flShutoffTime <= gHUD.m_flTime )
|
||||
{ // times up, shutoff
|
||||
m_fMenuDisplayed = 0;
|
||||
m_iFlags &= ~HUD_ACTIVE;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
// don't draw the menu if the scoreboard is being shown
|
||||
if ( gViewPort && gViewPort->IsScoreBoardVisible() )
|
||||
return 1;
|
||||
|
||||
// draw the menu, along the left-hand side of the screen
|
||||
|
||||
// count the number of newlines
|
||||
int nlc = 0;
|
||||
int 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
|
||||
|
||||
menu_r = 255;
|
||||
menu_g = 255;
|
||||
menu_b = 255;
|
||||
menu_x = 20;
|
||||
menu_ralign = FALSE;
|
||||
|
||||
const char* sptr = g_szMenuString;
|
||||
|
||||
while ( *sptr != '\0' )
|
||||
{
|
||||
if ( *sptr == '\\' )
|
||||
{
|
||||
sptr = ParseEscapeToken( sptr );
|
||||
}
|
||||
else if ( *sptr == '\n' )
|
||||
{
|
||||
menu_ralign = FALSE;
|
||||
menu_x = 20;
|
||||
y += (12);
|
||||
|
||||
sptr++;
|
||||
}
|
||||
else
|
||||
{
|
||||
char menubuf[ 80 ];
|
||||
const char *ptr = sptr;
|
||||
while ( *sptr != '\0' && *sptr != '\n' && *sptr != '\\')
|
||||
{
|
||||
sptr++;
|
||||
}
|
||||
strncpy( menubuf, ptr, min( ( sptr - ptr), (int)sizeof( menubuf ) ));
|
||||
menubuf[ min( ( sptr - ptr), (int)(sizeof( menubuf )-1) ) ] = '\0';
|
||||
|
||||
if ( menu_ralign )
|
||||
{
|
||||
// IMPORTANT: Right-to-left rendered text does not parse escape tokens!
|
||||
menu_x = gHUD.DrawHudStringReverse( menu_x, y, 0, menubuf, menu_r, menu_g, menu_b );
|
||||
}
|
||||
else
|
||||
{
|
||||
menu_x = gHUD.DrawHudString( menu_x, y, 320, menubuf, menu_r, menu_g, menu_b );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// selects an item from the menu
|
||||
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))) )
|
||||
{
|
||||
char szbuf[32];
|
||||
sprintf( szbuf, "menuselect %d\n", menu_item );
|
||||
ClientCmd( szbuf );
|
||||
|
||||
// remove the menu
|
||||
m_fMenuDisplayed = 0;
|
||||
m_iFlags &= ~HUD_ACTIVE;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Message handler for ShowMenu message
|
||||
// takes four values:
|
||||
// short: a bitfield of keys that are valid input
|
||||
// char : the duration, in seconds, the menu should stay up. -1 means is stays until something is chosen.
|
||||
// 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 )
|
||||
{
|
||||
char *temp = NULL;
|
||||
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
m_bitsValidSlots = READ_SHORT();
|
||||
int DisplayTime = READ_CHAR();
|
||||
int NeedMore = READ_BYTE();
|
||||
|
||||
if ( DisplayTime > 0 )
|
||||
m_flShutoffTime = DisplayTime + gHUD.m_flTime;
|
||||
else
|
||||
m_flShutoffTime = -1;
|
||||
|
||||
if ( m_bitsValidSlots )
|
||||
{
|
||||
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) );
|
||||
}
|
||||
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
|
||||
strcpy( g_szMenuString, gHUD.m_TextMessage.BufferedLocaliseTextString( g_szPrelocalisedMenuString ) );
|
||||
|
||||
// Swap in characters
|
||||
if ( KB_ConvertString( g_szMenuString, &temp ) )
|
||||
{
|
||||
strcpy( g_szMenuString, temp );
|
||||
free( temp );
|
||||
}
|
||||
}
|
||||
|
||||
m_fMenuDisplayed = 1;
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_fMenuDisplayed = 0; // no valid slots means that the menu should be turned off
|
||||
m_iFlags &= ~HUD_ACTIVE;
|
||||
}
|
||||
|
||||
m_fWaitingForMore = NeedMore;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -1,481 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1999, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// Message.cpp
|
||||
//
|
||||
// implementation of CHudMessage class
|
||||
//
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include "parsemsg.h"
|
||||
|
||||
DECLARE_MESSAGE( m_Message, HudText )
|
||||
DECLARE_MESSAGE( m_Message, GameTitle )
|
||||
|
||||
|
||||
int CHudMessage::Init(void)
|
||||
{
|
||||
HOOK_MESSAGE( HudText );
|
||||
HOOK_MESSAGE( GameTitle );
|
||||
|
||||
gHUD.AddHudElem(this);
|
||||
|
||||
Reset();
|
||||
|
||||
return 1;
|
||||
};
|
||||
|
||||
int CHudMessage::VidInit( void )
|
||||
{
|
||||
m_HUD_title_half = gHUD.GetSpriteIndex( "title_half" );
|
||||
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 );
|
||||
|
||||
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 )
|
||||
return 0;
|
||||
|
||||
if ( localTime < fadein )
|
||||
{
|
||||
fadeBlend = 1 - ((fadein - localTime) / fadein);
|
||||
}
|
||||
else if ( localTime > fadeTime )
|
||||
{
|
||||
if ( fadeout > 0 )
|
||||
fadeBlend = 1 - ((localTime - fadeTime) / fadeout);
|
||||
else
|
||||
fadeBlend = 0;
|
||||
}
|
||||
else
|
||||
fadeBlend = 1;
|
||||
|
||||
return fadeBlend;
|
||||
}
|
||||
|
||||
|
||||
int CHudMessage::XPosition( float x, int width, int totalWidth )
|
||||
{
|
||||
int xPos;
|
||||
|
||||
if ( x == -1 )
|
||||
{
|
||||
xPos = (ScreenWidth - width) / 2;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( x < 0 )
|
||||
xPos = (1.0 + x) * ScreenWidth - totalWidth; // Alight right
|
||||
else
|
||||
xPos = x * ScreenWidth;
|
||||
}
|
||||
|
||||
if ( xPos + width > ScreenWidth )
|
||||
xPos = ScreenWidth - width;
|
||||
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;
|
||||
else
|
||||
{
|
||||
// Alight bottom?
|
||||
if ( y < 0 )
|
||||
yPos = (1.0 + y) * ScreenHeight - height; // Alight bottom
|
||||
else // align top
|
||||
yPos = y * ScreenHeight;
|
||||
}
|
||||
|
||||
if ( yPos + height > ScreenHeight )
|
||||
yPos = ScreenHeight - height;
|
||||
else if ( yPos < 0 )
|
||||
yPos = 0;
|
||||
|
||||
return yPos;
|
||||
}
|
||||
|
||||
|
||||
void CHudMessage::MessageScanNextChar( void )
|
||||
{
|
||||
int srcRed, srcGreen, srcBlue, destRed, destGreen, destBlue;
|
||||
int blend;
|
||||
|
||||
srcRed = m_parms.pMessage->r1;
|
||||
srcGreen = m_parms.pMessage->g1;
|
||||
srcBlue = m_parms.pMessage->b1;
|
||||
blend = 0; // Pure source
|
||||
destRed = destGreen = destBlue = 0;
|
||||
|
||||
switch( m_parms.pMessage->effect )
|
||||
{
|
||||
// Fade-in / Fade-out
|
||||
case 0:
|
||||
case 1:
|
||||
blend = m_parms.fadeBlend;
|
||||
break;
|
||||
|
||||
case 2:
|
||||
m_parms.charTime += m_parms.pMessage->fadein;
|
||||
if ( m_parms.charTime > m_parms.time )
|
||||
{
|
||||
srcRed = srcGreen = srcBlue = 0;
|
||||
blend = 0; // pure source
|
||||
}
|
||||
else
|
||||
{
|
||||
float deltaTime = m_parms.time - m_parms.charTime;
|
||||
|
||||
if ( m_parms.time > m_parms.fadeTime )
|
||||
{
|
||||
blend = m_parms.fadeBlend;
|
||||
}
|
||||
else if ( deltaTime > m_parms.pMessage->fxtime )
|
||||
blend = 0; // pure dest
|
||||
else
|
||||
{
|
||||
destRed = m_parms.pMessage->r2;
|
||||
destGreen = m_parms.pMessage->g2;
|
||||
destBlue = m_parms.pMessage->b2;
|
||||
blend = 255 - (deltaTime * (1.0/m_parms.pMessage->fxtime) * 255.0 + 0.5);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
if ( blend > 255 )
|
||||
blend = 255;
|
||||
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;
|
||||
|
||||
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 )
|
||||
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 )
|
||||
{
|
||||
// Fade-in / out with flicker
|
||||
case 1:
|
||||
case 0:
|
||||
m_parms.fadeTime = m_parms.pMessage->fadein + m_parms.pMessage->holdtime;
|
||||
|
||||
|
||||
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);
|
||||
}
|
||||
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);
|
||||
else
|
||||
m_parms.fadeBlend = 255; // Pure dest (off)
|
||||
}
|
||||
else
|
||||
m_parms.fadeBlend = 0; // Pure source (on)
|
||||
m_parms.charTime = 0;
|
||||
|
||||
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);
|
||||
else
|
||||
m_parms.fadeBlend = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CHudMessage::MessageDrawScan( client_textmessage_t *pMessage, float time )
|
||||
{
|
||||
int i, j, length, width;
|
||||
const char *pText;
|
||||
unsigned char line[80];
|
||||
|
||||
pText = pMessage->pMessage;
|
||||
// Count lines
|
||||
m_parms.lines = 1;
|
||||
m_parms.time = time;
|
||||
m_parms.pMessage = pMessage;
|
||||
length = 0;
|
||||
width = 0;
|
||||
m_parms.totalWidth = 0;
|
||||
while ( *pText )
|
||||
{
|
||||
if ( *pText == '\n' )
|
||||
{
|
||||
m_parms.lines++;
|
||||
if ( width > m_parms.totalWidth )
|
||||
m_parms.totalWidth = width;
|
||||
width = 0;
|
||||
}
|
||||
else
|
||||
width += gHUD.m_scrinfo.charWidths[*pText];
|
||||
pText++;
|
||||
length++;
|
||||
}
|
||||
m_parms.length = length;
|
||||
m_parms.totalHeight = (m_parms.lines * gHUD.m_scrinfo.iCharHeight);
|
||||
|
||||
|
||||
m_parms.y = YPosition( pMessage->y, m_parms.totalHeight );
|
||||
pText = pMessage->pMessage;
|
||||
|
||||
m_parms.charTime = 0;
|
||||
|
||||
MessageScanStart();
|
||||
|
||||
for ( i = 0; i < m_parms.lines; i++ )
|
||||
{
|
||||
m_parms.lineLength = 0;
|
||||
m_parms.width = 0;
|
||||
while ( *pText && *pText != '\n' )
|
||||
{
|
||||
unsigned char c = *pText;
|
||||
line[m_parms.lineLength] = c;
|
||||
m_parms.width += gHUD.m_scrinfo.charWidths[c];
|
||||
m_parms.lineLength++;
|
||||
pText++;
|
||||
}
|
||||
pText++; // Skip LF
|
||||
line[m_parms.lineLength] = 0;
|
||||
|
||||
m_parms.x = XPosition( pMessage->x, m_parms.width, m_parms.totalWidth );
|
||||
|
||||
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 ];
|
||||
MessageScanNextChar();
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
m_parms.y += gHUD.m_scrinfo.iCharHeight;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int CHudMessage::Draw( float fTime )
|
||||
{
|
||||
int i, drawn;
|
||||
client_textmessage_t *pMessage;
|
||||
float endTime;
|
||||
|
||||
drawn = 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 )
|
||||
m_gameTitleTime = gHUD.m_flTime;
|
||||
|
||||
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 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_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++ )
|
||||
{
|
||||
// Assume m_parms.time contains last time
|
||||
if ( m_pMessages[i] )
|
||||
{
|
||||
pMessage = m_pMessages[i];
|
||||
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++ )
|
||||
{
|
||||
if ( m_pMessages[i] )
|
||||
{
|
||||
pMessage = m_pMessages[i];
|
||||
|
||||
// This is when the message is over
|
||||
switch( pMessage->effect )
|
||||
{
|
||||
case 0:
|
||||
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;
|
||||
break;
|
||||
}
|
||||
|
||||
if ( fTime <= endTime )
|
||||
{
|
||||
float messageTime = fTime - m_startTime[i];
|
||||
|
||||
// Draw the message
|
||||
// effect 0 is fade in/fade out
|
||||
// effect 1 is flickery credits
|
||||
// effect 2 is write out (training room)
|
||||
MessageDrawScan( pMessage, messageTime );
|
||||
|
||||
drawn++;
|
||||
}
|
||||
else
|
||||
{
|
||||
// The message is over
|
||||
m_pMessages[i] = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Remember the time -- to fix up level transitions
|
||||
m_parms.time = gHUD.m_flTime;
|
||||
// Don't call until we get another message
|
||||
if ( !drawn )
|
||||
m_iFlags &= ~HUD_ACTIVE;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
void CHudMessage::MessageAdd( const char *pName, float time )
|
||||
{
|
||||
int i;
|
||||
|
||||
for ( i = 0; i < maxHUDMessages; i++ )
|
||||
{
|
||||
if ( !m_pMessages[i] )
|
||||
{
|
||||
m_pMessages[i] = TextMessageGet( pName );
|
||||
m_startTime[i] = time;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int CHudMessage::MsgFunc_HudText( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
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) )
|
||||
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 )
|
||||
{
|
||||
m_gameTitleTime = gHUD.m_flTime;
|
||||
|
||||
// Turn on drawing
|
||||
if ( !(m_iFlags & HUD_ACTIVE) )
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
void CHudMessage::MessageAdd(client_textmessage_t * newMessage )
|
||||
{
|
||||
m_parms.time = gHUD.m_flTime;
|
||||
|
||||
// Turn on drawing
|
||||
if ( !(m_iFlags & HUD_ACTIVE) )
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
|
||||
for ( int i = 0; i < maxHUDMessages; i++ )
|
||||
{
|
||||
if ( !m_pMessages[i] )
|
||||
{
|
||||
m_pMessages[i] = newMessage;
|
||||
m_startTime[i] = gHUD.m_flTime;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,330 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
|
||||
/*
|
||||
==========================
|
||||
This file contains "stubs" of class member implementations so that we can predict certain
|
||||
weapons client side. From time to time you might find that you need to implement part of the
|
||||
these functions. If so, cut it from here, paste it in hl_weapons.cpp or somewhere else and
|
||||
add in the functionality you need.
|
||||
==========================
|
||||
*/
|
||||
#include "extdll.h"
|
||||
#include "util.h"
|
||||
#include "cbase.h"
|
||||
#include "player.h"
|
||||
#include "weapons.h"
|
||||
#include "nodes.h"
|
||||
|
||||
// Globals used by game logic
|
||||
const Vector g_vecZero = Vector( 0, 0, 0 );
|
||||
int gmsgWeapPickup = 0;
|
||||
enginefuncs_t g_engfuncs;
|
||||
globalvars_t *gpGlobals;
|
||||
|
||||
short g_sModelIndexLaser;
|
||||
|
||||
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) { }
|
||||
|
||||
// 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; }
|
||||
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::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; }
|
||||
void CBaseEntity::SUB_Remove( void ) { }
|
||||
|
||||
// CBaseDelay Stubs
|
||||
void CBaseDelay :: KeyValue( struct KeyValueData_s * ) { }
|
||||
int CBaseDelay::Restore( class CRestore & ) { return 1; }
|
||||
int CBaseDelay::Save( class CSave & ) { return 1; }
|
||||
|
||||
// CBaseAnimating Stubs
|
||||
int CBaseAnimating::Restore( class CRestore & ) { return 1; }
|
||||
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) { }
|
||||
|
||||
// UTIL_* Stubs
|
||||
void UTIL_PrecacheOther( const char *szClassname ) { }
|
||||
void UTIL_BloodDrips( const Vector &origin, const Vector &direction, int color, int amount ) { }
|
||||
void UTIL_DecalTrace( TraceResult *pTrace, int decalNumber ) { }
|
||||
void UTIL_GunshotDecalTrace( TraceResult *pTrace, int decalNumber ) { }
|
||||
void UTIL_MakeVectors( const Vector &vecAngles ) { }
|
||||
BOOL UTIL_IsValidEntity( edict_t *pent ) { return TRUE; }
|
||||
void UTIL_SetOrigin( entvars_t *, const Vector &org ) { }
|
||||
BOOL UTIL_GetNextBestWeapon( CBasePlayer *pPlayer, CBasePlayerItem *pCurrentWeapon ) { return TRUE; }
|
||||
void UTIL_LogPrintf(char *,...) { }
|
||||
void UTIL_ClientPrintAll( int,char const *,char const *,char const *,char const *,char const *) { }
|
||||
void ClientPrint( entvars_t *client, int msg_dest, const char *msg_name, const char *param1, const char *param2, const char *param3, const char *param4 ) { }
|
||||
|
||||
// CBaseToggle Stubs
|
||||
int CBaseToggle::Restore( class CRestore & ) { return 1; }
|
||||
int CBaseToggle::Save( class CSave & ) { return 1; }
|
||||
void CBaseToggle :: KeyValue( struct KeyValueData_s * ) { }
|
||||
|
||||
// CGrenade Stubs
|
||||
void CGrenade::BounceSound( void ) { }
|
||||
void CGrenade::Explode( Vector, Vector ) { }
|
||||
void CGrenade::Explode( TraceResult *, int ) { }
|
||||
void CGrenade::Killed( entvars_t *, int ) { }
|
||||
void CGrenade::Spawn( void ) { }
|
||||
|
||||
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::MoveExecute( CBaseEntity *pTargetEnt, const Vector &vecDir, float flInterval ) { }
|
||||
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; }
|
||||
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::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::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 ) { }
|
||||
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; }
|
||||
int CBaseMonster::Restore( class CRestore & ) { return 1; }
|
||||
int CBaseMonster::Save( class CSave & ) { return 1; }
|
||||
|
||||
int TrainSpeed(int iSpeed, int iMax) { return 0; }
|
||||
void CBasePlayer::CheckAmmo(void) { }
|
||||
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::RemoveAllItems( BOOL removeSuit ) { }
|
||||
void CBasePlayer::SetAnimation( PLAYER_ANIM playerAnim ) { }
|
||||
void CBasePlayer::WaterMove() { }
|
||||
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::Jump() { }
|
||||
void CBasePlayer::Duck( ) { }
|
||||
int CBasePlayer::Classify ( void ) { return 0; }
|
||||
void CBasePlayer :: PlayStepSound(int step, float fvol) { }
|
||||
void CBasePlayer :: UpdateStepSound( void ) { }
|
||||
void CBasePlayer::PreThink(void) { }
|
||||
void CBasePlayer::CheckTimeBasedDamage() { }
|
||||
void CBasePlayer :: UpdateGeigerCounter( void ) { }
|
||||
void CBasePlayer::CheckSuitUpdate() { }
|
||||
void CBasePlayer::SetSuitUpdate(char *name, int fgroup, int iNoRepeatTime) { }
|
||||
void CBasePlayer::PostThink() { }
|
||||
int CBasePlayer::Save( CSave &save ) { return 0; }
|
||||
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( ) { }
|
||||
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; }
|
||||
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 ) { }
|
||||
BOOL CBasePlayer::HasPlayerItem( CBasePlayerItem *pCheckItem ) { return FALSE; }
|
||||
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; }
|
||||
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 AddMultiDamage( entvars_t *pevInflictor, CBaseEntity *pEntity, float flDamage, int bitsDamageType) { }
|
||||
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 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::Materialize( void ) { }
|
||||
void CBasePlayerItem::AttemptToMaterialize( void ) { }
|
||||
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; }
|
||||
void CBasePlayerItem::Drop( void ) { }
|
||||
void CBasePlayerItem::Kill( void ) { }
|
||||
void CBasePlayerItem::Holster( int skiplocal ) { }
|
||||
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; }
|
||||
int CBasePlayerWeapon::PrimaryAmmoIndex( 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 ) { }
|
||||
int CBasePlayerWeapon::ExtractAmmo( CBasePlayerWeapon *pWeapon ) { return 0; }
|
||||
int CBasePlayerWeapon::ExtractClipAmmo( CBasePlayerWeapon *pWeapon ) { return 0; }
|
||||
void CBasePlayerWeapon::RetireWeapon( void ) { }
|
||||
|
|
@ -1,83 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
#include "../hud.h"
|
||||
#include "../cl_util.h"
|
||||
#include "event_api.h"
|
||||
|
||||
extern "C"
|
||||
{
|
||||
// Deathmatch Classic
|
||||
void EV_FireShotGunSingle( struct event_args_s *args );
|
||||
void EV_FireShotGunDouble( struct event_args_s *args );
|
||||
void EV_FireAxe( struct event_args_s *args );
|
||||
void EV_FireAxeSwing( struct event_args_s *args );
|
||||
void EV_FireRocket( struct event_args_s *args );
|
||||
void EV_FireLightning( struct event_args_s *args );
|
||||
void EV_FireSpike( struct event_args_s *args );
|
||||
void EV_FireSuperSpike( struct event_args_s *args );
|
||||
void EV_FireGrenade( struct event_args_s *args );
|
||||
void EV_Gibbed (struct event_args_s *args );
|
||||
void EV_Teleport (struct event_args_s *args );
|
||||
void EV_Trail (struct event_args_s *args );
|
||||
void EV_Explosion (struct event_args_s *args );
|
||||
void EV_PlayerPowerup ( struct event_args_s *args );
|
||||
|
||||
void EV_DMC_DoorGoUp( struct event_args_s *args );
|
||||
void EV_DMC_DoorGoDown( struct event_args_s *args );
|
||||
void EV_DMC_DoorHitTop( struct event_args_s *args );
|
||||
void EV_DMC_DoorHitBottom( struct event_args_s *args );
|
||||
|
||||
// HLDM
|
||||
void EV_TrainPitchAdjust( struct event_args_s *args );
|
||||
}
|
||||
|
||||
/*
|
||||
======================
|
||||
Game_HookEvents
|
||||
|
||||
Associate script file name with callback functions. Callback's must be extern "C" so
|
||||
the engine doesn't get confused about name mangling stuff. Note that the format is
|
||||
always the same. Of course, a clever mod team could actually embed parameters, behavior
|
||||
into the actual .sc files and create a .sc file parser and hook their functionality through
|
||||
that.. i.e., a scripting system.
|
||||
|
||||
That was what we were going to do, but we ran out of time...oh well.
|
||||
======================
|
||||
*/
|
||||
void Game_HookEvents( void )
|
||||
{
|
||||
gEngfuncs.pfnHookEvent( "events/shotgun1.sc", EV_FireShotGunSingle );
|
||||
gEngfuncs.pfnHookEvent( "events/shotgun2.sc", EV_FireShotGunDouble );
|
||||
gEngfuncs.pfnHookEvent( "events/axe.sc", EV_FireAxe );
|
||||
gEngfuncs.pfnHookEvent( "events/axeswing.sc", EV_FireAxeSwing );
|
||||
gEngfuncs.pfnHookEvent( "events/rocket.sc", EV_FireRocket );
|
||||
gEngfuncs.pfnHookEvent( "events/lightning.sc", EV_FireLightning );
|
||||
gEngfuncs.pfnHookEvent( "events/grenade.sc", EV_FireGrenade );
|
||||
gEngfuncs.pfnHookEvent( "events/spike.sc", EV_FireSpike );
|
||||
gEngfuncs.pfnHookEvent( "events/superspike.sc", EV_FireSuperSpike );
|
||||
gEngfuncs.pfnHookEvent( "events/gibs.sc", EV_Gibbed );
|
||||
gEngfuncs.pfnHookEvent( "events/teleport.sc", EV_Teleport );
|
||||
gEngfuncs.pfnHookEvent( "events/trail.sc", EV_Trail );
|
||||
gEngfuncs.pfnHookEvent( "events/explosion.sc", EV_Explosion );
|
||||
|
||||
gEngfuncs.pfnHookEvent( "events/powerup.sc", EV_PlayerPowerup );
|
||||
|
||||
gEngfuncs.pfnHookEvent( "events/door/doorgoup.sc", EV_DMC_DoorGoUp );
|
||||
gEngfuncs.pfnHookEvent( "events/door/doorgodown.sc", EV_DMC_DoorGoDown );
|
||||
gEngfuncs.pfnHookEvent( "events/door/doorhittop.sc", EV_DMC_DoorHitTop );
|
||||
gEngfuncs.pfnHookEvent( "events/door/doorhitbottom.sc", EV_DMC_DoorHitBottom );
|
||||
|
||||
gEngfuncs.pfnHookEvent( "events/train.sc", EV_TrainPitchAdjust );
|
||||
}
|
||||
|
|
@ -1,81 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
#include "../hud.h"
|
||||
#include "../cl_util.h"
|
||||
#include "../demo.h"
|
||||
|
||||
#include "demo_api.h"
|
||||
#include "const.h"
|
||||
#include "entity_state.h"
|
||||
#include "cl_entity.h"
|
||||
|
||||
#include "pm_defs.h"
|
||||
#include "event_api.h"
|
||||
#include "entity_types.h"
|
||||
#include "r_efx.h"
|
||||
|
||||
|
||||
extern BEAM *pBeam;
|
||||
void HUD_GetLastOrg( float *org );
|
||||
|
||||
void UpdateBeams ( void )
|
||||
{
|
||||
vec3_t forward, vecSrc, vecEnd, origin, angles, right, up;
|
||||
vec3_t view_ofs;
|
||||
pmtrace_t tr;
|
||||
cl_entity_t *pthisplayer = gEngfuncs.GetLocalPlayer();
|
||||
int idx = pthisplayer->index;
|
||||
|
||||
// Get our exact viewangles from engine
|
||||
gEngfuncs.GetViewAngles( (float *)angles );
|
||||
|
||||
// Determine our last predicted origin
|
||||
HUD_GetLastOrg( (float *)&origin );
|
||||
|
||||
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_SetTraceHull( 2 );
|
||||
gEngfuncs.pEventAPI->EV_PlayerTrace( vecSrc, vecEnd, PM_STUDIO_BOX, -1, &tr );
|
||||
|
||||
gEngfuncs.pEventAPI->EV_PopPMStates();
|
||||
|
||||
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.
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
Game_AddObjects
|
||||
|
||||
Add game specific, client-side objects here
|
||||
=====================
|
||||
*/
|
||||
void Game_AddObjects( void )
|
||||
{
|
||||
if ( pBeam )
|
||||
UpdateBeams();
|
||||
}
|
||||
|
|
@ -1,988 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
#include "extdll.h"
|
||||
#include "util.h"
|
||||
#include "cbase.h"
|
||||
#include "monsters.h"
|
||||
#include "weapons.h"
|
||||
#include "nodes.h"
|
||||
#include "player.h"
|
||||
|
||||
#include "usercmd.h"
|
||||
#include "entity_state.h"
|
||||
#include "demo_api.h"
|
||||
#include "pm_defs.h"
|
||||
#include "event_api.h"
|
||||
#include "r_efx.h"
|
||||
|
||||
#include "../hud_iface.h"
|
||||
#include "../com_weapons.h"
|
||||
#include "../demo.h"
|
||||
|
||||
#include "quake_gun.h"
|
||||
#include "../DMC_Teleporters.h"
|
||||
|
||||
extern globalvars_t *gpGlobals;
|
||||
|
||||
// Pool of client side entities/entvars_t
|
||||
static entvars_t ev[ 32 ];
|
||||
static int num_ents = 0;
|
||||
|
||||
// The entity we'll use to represent the local client
|
||||
static CBasePlayer player;
|
||||
|
||||
// Local version of game .dll global variables ( time, etc. )
|
||||
static globalvars_t Globals;
|
||||
|
||||
static CBasePlayerWeapon *g_pWpns[ 32 ];
|
||||
extern int iCarriedWeapons;
|
||||
int g_iWaterLevel;
|
||||
// HLDM Weapon placeholder entities.
|
||||
CQuakeGun g_QuakeGun;
|
||||
|
||||
extern BEAM *pBeam;
|
||||
/*
|
||||
======================
|
||||
AlertMessage
|
||||
|
||||
Print debug messages to console
|
||||
======================
|
||||
*/
|
||||
void AlertMessage( ALERT_TYPE atype, char *szFmt, ... )
|
||||
{
|
||||
va_list argptr;
|
||||
static char string[1024];
|
||||
|
||||
va_start (argptr, szFmt);
|
||||
vsprintf (string, szFmt,argptr);
|
||||
va_end (argptr);
|
||||
|
||||
gEngfuncs.Con_Printf( "cl: " );
|
||||
gEngfuncs.Con_Printf( string );
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
HUD_PrepEntity
|
||||
|
||||
Links the raw entity to an entvars_s holder. If a player is passed in as the owner, then
|
||||
we set up the m_pPlayer field.
|
||||
=====================
|
||||
*/
|
||||
void HUD_PrepEntity( CBaseEntity *pEntity, CBasePlayer *pWeaponOwner )
|
||||
{
|
||||
memset( &ev[ num_ents ], 0, sizeof( entvars_t ) );
|
||||
pEntity->pev = &ev[ num_ents++ ];
|
||||
|
||||
pEntity->Precache();
|
||||
pEntity->Spawn();
|
||||
|
||||
if ( pWeaponOwner )
|
||||
{
|
||||
ItemInfo info;
|
||||
|
||||
((CBasePlayerWeapon *)pEntity)->m_pPlayer = pWeaponOwner;
|
||||
|
||||
((CBasePlayerWeapon *)pEntity)->GetItemInfo( &info );
|
||||
|
||||
g_pWpns[ info.iId ] = (CBasePlayerWeapon *)pEntity;
|
||||
}
|
||||
}
|
||||
|
||||
CQuakeRocket *CQuakeRocket::CreateRocket( Vector vecOrigin, Vector vecAngles, CBaseEntity *pOwner )
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
CQuakeRocket *CQuakeRocket::CreateGrenade( Vector vecOrigin, Vector vecVelocity, CBaseEntity *pOwner )
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
CQuakeNail *CQuakeNail::CreateSuperNail( Vector vecOrigin, Vector vecAngles, CBaseEntity *pOwner )
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
CQuakeNail *CQuakeNail::CreateNail( Vector vecOrigin, Vector vecAngles, CBaseEntity *pOwner )
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void CBasePlayer :: Precache( void )
|
||||
{
|
||||
m_usShotgunSingle = PRECACHE_EVENT( 1, "events/shotgun1.sc" );
|
||||
m_usShotgunDouble = PRECACHE_EVENT( 1, "events/shotgun2.sc" );
|
||||
m_usAxe = PRECACHE_EVENT( 1, "events/axe.sc" );
|
||||
m_usAxeSwing = PRECACHE_EVENT( 1, "events/axeswing.sc" );
|
||||
m_usRocket = PRECACHE_EVENT( 1, "events/rocket.sc" );
|
||||
m_usGrenade = PRECACHE_EVENT( 1, "events/grenade.sc" );
|
||||
m_usLightning = PRECACHE_EVENT( 1, "events/lightning.sc" );
|
||||
m_usSpike = PRECACHE_EVENT( 1, "events/spike.sc" );
|
||||
m_usSuperSpike = PRECACHE_EVENT( 1, "events/superspike.sc" );
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBaseEntity :: Killed
|
||||
|
||||
If weapons code "kills" an entity, just set its effects to EF_NODRAW
|
||||
=====================
|
||||
*/
|
||||
void CBaseEntity :: Killed( entvars_t *pevAttacker, int iGib )
|
||||
{
|
||||
pev->effects |= EF_NODRAW;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayerWeapon :: DefaultReload
|
||||
=====================
|
||||
*/
|
||||
BOOL CBasePlayerWeapon :: DefaultReload( int iClipSize, int iAnim, float fDelay )
|
||||
{
|
||||
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + fDelay;
|
||||
|
||||
//!!UNDONE -- reload sound goes here !!!
|
||||
SendWeaponAnim( iAnim );
|
||||
|
||||
m_fInReload = TRUE;
|
||||
|
||||
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 3;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayerWeapon :: CanDeploy
|
||||
=====================
|
||||
*/
|
||||
BOOL CBasePlayerWeapon :: CanDeploy( void )
|
||||
{
|
||||
BOOL bHasAmmo = 0;
|
||||
|
||||
if ( !pszAmmo1() )
|
||||
{
|
||||
// this weapon doesn't use ammo, can always deploy.
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
if ( pszAmmo1() )
|
||||
{
|
||||
bHasAmmo |= (m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] != 0);
|
||||
}
|
||||
if ( pszAmmo2() )
|
||||
{
|
||||
bHasAmmo |= (m_pPlayer->m_rgAmmo[m_iSecondaryAmmoType] != 0);
|
||||
}
|
||||
if (m_iClip > 0)
|
||||
{
|
||||
bHasAmmo |= 1;
|
||||
}
|
||||
if (!bHasAmmo)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayerWeapon :: DefaultDeploy
|
||||
|
||||
=====================
|
||||
*/
|
||||
BOOL CBasePlayerWeapon :: DefaultDeploy( char *szViewModel, char *szWeaponModel, int iAnim, char *szAnimExt, int skiplocal )
|
||||
{
|
||||
if ( !CanDeploy() )
|
||||
return FALSE;
|
||||
|
||||
gEngfuncs.CL_LoadModel( szViewModel, &m_pPlayer->pev->viewmodel );
|
||||
|
||||
SendWeaponAnim( iAnim );
|
||||
|
||||
m_bPlayedIdleAnim = FALSE;
|
||||
|
||||
m_pPlayer->m_flNextAttack = 0.5;
|
||||
m_flTimeWeaponIdle = 1.0;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayerWeapon :: PlayEmptySound
|
||||
|
||||
=====================
|
||||
*/
|
||||
BOOL CBasePlayerWeapon :: PlayEmptySound( void )
|
||||
{
|
||||
if (m_iPlayEmptySound)
|
||||
{
|
||||
HUD_PlaySound( "weapons/357_cock1.wav", 0.8 );
|
||||
m_iPlayEmptySound = 0;
|
||||
return 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayerWeapon :: ResetEmptySound
|
||||
|
||||
=====================
|
||||
*/
|
||||
void CBasePlayerWeapon :: ResetEmptySound( void )
|
||||
{
|
||||
m_iPlayEmptySound = 1;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayerWeapon::Holster
|
||||
|
||||
Put away weapon
|
||||
=====================
|
||||
*/
|
||||
void CBasePlayerWeapon::Holster( int skiplocal /* = 0 */ )
|
||||
{
|
||||
m_fInReload = FALSE; // cancel any reload in progress.
|
||||
m_pPlayer->pev->viewmodel = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayerWeapon::SendWeaponAnim
|
||||
|
||||
Animate weapon model
|
||||
=====================
|
||||
*/
|
||||
void CBasePlayerWeapon::SendWeaponAnim( int iAnim, int skiplocal )
|
||||
{
|
||||
m_pPlayer->pev->weaponanim = iAnim;
|
||||
|
||||
int body = 0;
|
||||
|
||||
HUD_SendWeaponAnim( iAnim, body, 0 );
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayerWeapon::ItemPostFrame
|
||||
|
||||
Handles weapon firing, reloading, etc.
|
||||
=====================
|
||||
*/
|
||||
void CBasePlayerWeapon::ItemPostFrame( void )
|
||||
{
|
||||
if ((m_fInReload) && (m_pPlayer->m_flNextAttack <= 0.0))
|
||||
{
|
||||
#if 0 // FIXME, need ammo on client to make this work right
|
||||
// complete the reload.
|
||||
int j = min( iMaxClip() - m_iClip, m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType]);
|
||||
|
||||
// Add them to the clip
|
||||
m_iClip += j;
|
||||
m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] -= j;
|
||||
#else
|
||||
m_iClip += 10;
|
||||
#endif
|
||||
m_fInReload = FALSE;
|
||||
}
|
||||
|
||||
if ((m_pPlayer->pev->button & IN_ATTACK2) && (m_flNextSecondaryAttack <= 0.0))
|
||||
{
|
||||
if ( pszAmmo2() && !m_pPlayer->m_rgAmmo[SecondaryAmmoIndex()] )
|
||||
{
|
||||
m_fFireOnEmpty = TRUE;
|
||||
}
|
||||
|
||||
SecondaryAttack();
|
||||
m_pPlayer->pev->button &= ~IN_ATTACK2;
|
||||
}
|
||||
else if ((m_pPlayer->pev->button & IN_ATTACK) && (m_flNextPrimaryAttack <= 0.0))
|
||||
{
|
||||
if ( (m_iClip == 0 && pszAmmo1()) || (iMaxClip() == -1 && !m_pPlayer->m_rgAmmo[PrimaryAmmoIndex()] ) )
|
||||
{
|
||||
m_fFireOnEmpty = TRUE;
|
||||
}
|
||||
|
||||
PrimaryAttack();
|
||||
}
|
||||
else if ( m_pPlayer->pev->button & IN_RELOAD && iMaxClip() != WEAPON_NOCLIP && !m_fInReload )
|
||||
{
|
||||
// reload when reload is pressed, or if no buttons are down and weapon is empty.
|
||||
Reload();
|
||||
}
|
||||
else if ( !(m_pPlayer->pev->button & (IN_ATTACK|IN_ATTACK2) ) )
|
||||
{
|
||||
// no fire buttons down
|
||||
|
||||
m_fFireOnEmpty = FALSE;
|
||||
|
||||
if ( !m_bPlayedIdleAnim )
|
||||
{
|
||||
m_bPlayedIdleAnim = TRUE;
|
||||
|
||||
if ( m_pPlayer->m_iQuakeWeapon == IT_LIGHTNING )
|
||||
PLAYBACK_EVENT_FULL( FEV_NOTHOST, m_pPlayer->edict(), m_pPlayer->m_usLightning, 0, (float *)&m_pPlayer->pev->origin, (float *)&m_pPlayer->pev->angles, 0.0, 0.0, 0, 1, 0, 0 );
|
||||
}
|
||||
|
||||
WeaponIdle( );
|
||||
return;
|
||||
}
|
||||
|
||||
// catch all
|
||||
if ( ShouldWeaponIdle() )
|
||||
{
|
||||
WeaponIdle();
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayer::SelectItem
|
||||
|
||||
Switch weapons
|
||||
=====================
|
||||
*/
|
||||
void CBasePlayer::SelectItem(const char *pstr)
|
||||
{
|
||||
if (!pstr)
|
||||
return;
|
||||
|
||||
CBasePlayerItem *pItem = NULL;
|
||||
|
||||
if (!pItem)
|
||||
return;
|
||||
|
||||
|
||||
if (pItem == m_pActiveItem)
|
||||
return;
|
||||
|
||||
if (m_pActiveItem)
|
||||
m_pActiveItem->Holster( );
|
||||
|
||||
m_pLastItem = m_pActiveItem;
|
||||
m_pActiveItem = pItem;
|
||||
|
||||
if (m_pActiveItem)
|
||||
{
|
||||
m_pActiveItem->Deploy( );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayer::SelectLastItem
|
||||
|
||||
=====================
|
||||
*/
|
||||
void CBasePlayer::SelectLastItem(void)
|
||||
{
|
||||
if (!m_pLastItem)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if ( m_pActiveItem && !m_pActiveItem->CanHolster() )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (m_pActiveItem)
|
||||
m_pActiveItem->Holster( );
|
||||
|
||||
CBasePlayerItem *pTemp = m_pActiveItem;
|
||||
m_pActiveItem = m_pLastItem;
|
||||
m_pLastItem = pTemp;
|
||||
m_pActiveItem->Deploy( );
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayer::Killed
|
||||
|
||||
=====================
|
||||
*/
|
||||
void CBasePlayer::Killed( entvars_t *pevAttacker, int iGib )
|
||||
{
|
||||
if ( m_iQuakeWeapon == IT_LIGHTNING )
|
||||
{
|
||||
PLAYBACK_EVENT_FULL( FEV_NOTHOST, edict(), m_usLightning, 0, (float *)&pev->origin, (float *)&pev->angles, 0.0, 0.0, 0, 1, 0, 0 );
|
||||
}
|
||||
|
||||
// Holster weapon immediately, to allow it to cleanup
|
||||
if (m_pActiveItem)
|
||||
m_pActiveItem->Holster( );
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayer::Spawn
|
||||
|
||||
=====================
|
||||
*/
|
||||
void CBasePlayer::Spawn( void )
|
||||
{
|
||||
if (m_pActiveItem)
|
||||
m_pActiveItem->Deploy( );
|
||||
}
|
||||
|
||||
BOOL CQuakeGun::Deploy( )
|
||||
{
|
||||
gEngfuncs.CL_LoadModel( "models/v_axe.mdl", &m_pPlayer->pev->viewmodel );
|
||||
strcpy( m_pPlayer->m_szAnimExtention, "onehanded" );
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
int HUD_GetModelIndex( char *modelname )
|
||||
{
|
||||
int retval = 0;
|
||||
gEngfuncs.CL_LoadModel( modelname, &retval );
|
||||
return retval;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
UTIL_TraceLine
|
||||
|
||||
Don't actually trace, but act like the trace didn't hit anything.
|
||||
=====================
|
||||
*/
|
||||
void UTIL_TraceLine( const Vector &vecStart, const Vector &vecEnd, IGNORE_MONSTERS igmon, edict_t *pentIgnore, TraceResult *ptr )
|
||||
{
|
||||
memset( ptr, 0, sizeof( *ptr ) );
|
||||
ptr->flFraction = 1.0;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
UTIL_ParticleBox
|
||||
|
||||
For debugging, draw a box around a player made out of particles
|
||||
=====================
|
||||
*/
|
||||
void UTIL_ParticleBox( CBasePlayer *player, float *mins, float *maxs, float life, unsigned char r, unsigned char g, unsigned char b )
|
||||
{
|
||||
int i;
|
||||
vec3_t mmin, mmax;
|
||||
|
||||
for ( i = 0; i < 3; i++ )
|
||||
{
|
||||
mmin[ i ] = player->pev->origin[ i ] + mins[ i ];
|
||||
mmax[ i ] = player->pev->origin[ i ] + maxs[ i ];
|
||||
}
|
||||
|
||||
gEngfuncs.pEfxAPI->R_ParticleBox( (float *)&mmin, (float *)&mmax, 5.0, 0, 255, 0 );
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
UTIL_ParticleBoxes
|
||||
|
||||
For debugging, draw boxes for other collidable players
|
||||
=====================
|
||||
*/
|
||||
void UTIL_ParticleBoxes( void )
|
||||
{
|
||||
int idx;
|
||||
physent_t *pe;
|
||||
cl_entity_t *player;
|
||||
vec3_t mins, maxs;
|
||||
|
||||
gEngfuncs.pEventAPI->EV_SetUpPlayerPrediction( false, true );
|
||||
|
||||
// Store off the old count
|
||||
gEngfuncs.pEventAPI->EV_PushPMStates();
|
||||
|
||||
player = gEngfuncs.GetLocalPlayer();
|
||||
// Now add in all of the players.
|
||||
gEngfuncs.pEventAPI->EV_SetSolidPlayers ( player->index - 1 );
|
||||
|
||||
for ( idx = 1; idx < 100; idx++ )
|
||||
{
|
||||
pe = gEngfuncs.pEventAPI->EV_GetPhysent( idx );
|
||||
if ( !pe )
|
||||
break;
|
||||
|
||||
if ( pe->info >= 1 && pe->info <= gEngfuncs.GetMaxClients() )
|
||||
{
|
||||
mins = pe->origin + pe->mins;
|
||||
maxs = pe->origin + pe->maxs;
|
||||
|
||||
gEngfuncs.pEfxAPI->R_ParticleBox( (float *)&mins, (float *)&maxs, 0, 0, 255, 2.0 );
|
||||
}
|
||||
}
|
||||
|
||||
gEngfuncs.pEventAPI->EV_PopPMStates();
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
UTIL_ParticleLine
|
||||
|
||||
For debugging, draw a line made out of particles
|
||||
=====================
|
||||
*/
|
||||
void UTIL_ParticleLine( CBasePlayer *player, float *start, float *end, float life, unsigned char r, unsigned char g, unsigned char b )
|
||||
{
|
||||
gEngfuncs.pEfxAPI->R_ParticleLine( start, end, r, g, b, life );
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayerWeapon::PrintState
|
||||
|
||||
For debugging, print out state variables to log file
|
||||
=====================
|
||||
*/
|
||||
void CBasePlayerWeapon::PrintState( void )
|
||||
{
|
||||
COM_Log( "c:\\hl.log", "%.4f ", gpGlobals->time );
|
||||
COM_Log( "c:\\hl.log", "%.4f ", m_pPlayer->m_flNextAttack );
|
||||
COM_Log( "c:\\hl.log", "%.4f ", m_flNextPrimaryAttack );
|
||||
COM_Log( "c:\\hl.log", "%.4f ", m_flTimeWeaponIdle - gpGlobals->time);
|
||||
COM_Log( "c:\\hl.log", "%i ", m_iClip );
|
||||
}
|
||||
|
||||
vec3_t previousorigin;
|
||||
|
||||
/*
|
||||
=====================
|
||||
HUD_GetLastOrg
|
||||
|
||||
Retruns the last position that we stored for egon beam endpoint.
|
||||
=====================
|
||||
*/
|
||||
void HUD_GetLastOrg( float *org )
|
||||
{
|
||||
int i;
|
||||
|
||||
// Return last origin
|
||||
for ( i = 0; i < 3; i++ )
|
||||
{
|
||||
org[i] = previousorigin[i];
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
HUD_SetLastOrg
|
||||
|
||||
Remember our exact predicted origin so we can draw the egon to the right position.
|
||||
=====================
|
||||
*/
|
||||
void HUD_SetLastOrg( void )
|
||||
{
|
||||
int i;
|
||||
|
||||
// Offset final origin by view_offset
|
||||
for ( i = 0; i < 3; i++ )
|
||||
{
|
||||
previousorigin[i] = g_finalstate->playerstate.origin[i] + g_finalstate->client.view_ofs[ i ];
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
HUD_InitClientWeapons
|
||||
|
||||
Set up weapons, player and functions needed to run weapons code client-side.
|
||||
=====================
|
||||
*/
|
||||
void HUD_InitClientWeapons( void )
|
||||
{
|
||||
static int initialized = 0;
|
||||
if ( initialized )
|
||||
return;
|
||||
|
||||
initialized = 1;
|
||||
|
||||
// Set up pointer ( dummy object )
|
||||
gpGlobals = &Globals;
|
||||
|
||||
// Fill in current time ( probably not needed )
|
||||
gpGlobals->time = gEngfuncs.GetClientTime();
|
||||
|
||||
// Fake functions
|
||||
g_engfuncs.pfnPrecacheModel = stub_PrecacheModel;
|
||||
g_engfuncs.pfnPrecacheSound = stub_PrecacheSound;
|
||||
g_engfuncs.pfnPrecacheEvent = stub_PrecacheEvent;
|
||||
g_engfuncs.pfnNameForFunction = stub_NameForFunction;
|
||||
g_engfuncs.pfnSetModel = stub_SetModel;
|
||||
g_engfuncs.pfnSetClientMaxspeed = HUD_SetMaxSpeed;
|
||||
|
||||
// Handled locally
|
||||
g_engfuncs.pfnPlaybackEvent = HUD_PlaybackEvent;
|
||||
g_engfuncs.pfnAlertMessage = AlertMessage;
|
||||
|
||||
// Pass through to engine
|
||||
g_engfuncs.pfnPrecacheEvent = gEngfuncs.pfnPrecacheEvent;
|
||||
g_engfuncs.pfnRandomFloat = gEngfuncs.pfnRandomFloat;
|
||||
g_engfuncs.pfnRandomLong = gEngfuncs.pfnRandomLong;
|
||||
|
||||
// Allocate a slot for the local player
|
||||
HUD_PrepEntity( &player , NULL );
|
||||
|
||||
// Allocate slot(s) for each weapon that we are going to be predicting
|
||||
HUD_PrepEntity( &g_QuakeGun , &player );
|
||||
}
|
||||
|
||||
int Quake_NumForWeaponItem( int quakeitem )
|
||||
{
|
||||
int retval = 1;
|
||||
switch ( quakeitem )
|
||||
{
|
||||
default:
|
||||
case IT_AXE:
|
||||
retval = 1;
|
||||
break;
|
||||
case IT_SHOTGUN:
|
||||
retval = 2;
|
||||
break;
|
||||
case IT_SUPER_SHOTGUN:
|
||||
retval = 3;
|
||||
break;
|
||||
case IT_NAILGUN:
|
||||
retval = 4;
|
||||
break;
|
||||
case IT_SUPER_NAILGUN:
|
||||
retval = 5;
|
||||
break;
|
||||
case IT_GRENADE_LAUNCHER:
|
||||
retval = 6;
|
||||
break;
|
||||
case IT_ROCKET_LAUNCHER:
|
||||
retval = 7;
|
||||
break;
|
||||
|
||||
case IT_LIGHTNING:
|
||||
retval = 8;
|
||||
break;
|
||||
}
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
HUD_WeaponsPostThink
|
||||
|
||||
Run Weapon firing code on client
|
||||
=====================
|
||||
*/
|
||||
void HUD_WeaponsPostThink( local_state_s *from, local_state_s *to, usercmd_t *cmd, double time, unsigned int random_seed )
|
||||
{
|
||||
int i;
|
||||
int buttonsChanged;
|
||||
CBasePlayerWeapon *pWeapon = NULL;
|
||||
CBasePlayerWeapon *pCurrent;
|
||||
weapon_data_t nulldata, *pfrom, *pto;
|
||||
static int lasthealth;
|
||||
|
||||
memset( &nulldata, 0, sizeof( nulldata ) );
|
||||
|
||||
HUD_InitClientWeapons();
|
||||
|
||||
// Get current clock
|
||||
gpGlobals->time = time;
|
||||
|
||||
// Fill in data based on selected weapon
|
||||
// FIXME, make this a method in each weapon? where you pass in an entity_state_t *?
|
||||
switch ( from->client.m_iId )
|
||||
{
|
||||
case WEAPON_GLOCK:
|
||||
pWeapon = &g_QuakeGun;
|
||||
break;
|
||||
}
|
||||
|
||||
// Store pointer to our destination entity_state_t so we can get our origin, etc. from it
|
||||
// for setting up events on the client
|
||||
g_finalstate = to;
|
||||
|
||||
// If we are running events/etc. go ahead and see if we
|
||||
// managed to die between last frame and this one
|
||||
// If so, run the appropriate player killed or spawn function
|
||||
if ( g_runfuncs )
|
||||
{
|
||||
if ( to->client.health <= 0 && lasthealth > 0 )
|
||||
{
|
||||
player.Killed( NULL, 0 );
|
||||
}
|
||||
else if ( to->client.health > 0 && lasthealth <= 0 )
|
||||
{
|
||||
player.Spawn();
|
||||
}
|
||||
|
||||
lasthealth = to->client.health;
|
||||
}
|
||||
|
||||
// We are not predicting the current weapon, just bow out here.
|
||||
if ( !pWeapon )
|
||||
return;
|
||||
|
||||
gpGlobals->deathmatch = from->client.iuser4;
|
||||
|
||||
for ( i = 0; i < 32; i++ )
|
||||
{
|
||||
pCurrent = g_pWpns[ i ];
|
||||
if ( !pCurrent )
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
pfrom = &from->weapondata[ i ];
|
||||
|
||||
pCurrent->m_fInReload = pfrom->m_fInReload;
|
||||
pCurrent->m_iClip = pfrom->m_iClip;
|
||||
pCurrent->m_flNextPrimaryAttack = pfrom->m_flNextPrimaryAttack;
|
||||
pCurrent->m_flNextSecondaryAttack = pfrom->m_flNextSecondaryAttack;
|
||||
pCurrent->m_flTimeWeaponIdle = pfrom->m_flTimeWeaponIdle;
|
||||
}
|
||||
|
||||
// For random weapon events, use this seed to seed random # generator
|
||||
player.random_seed = random_seed;
|
||||
|
||||
// Get old buttons from previous state.
|
||||
player.m_afButtonLast = from->playerstate.oldbuttons;
|
||||
|
||||
// Which buttsons chave changed
|
||||
buttonsChanged = (player.m_afButtonLast ^ cmd->buttons); // These buttons have changed this frame
|
||||
|
||||
// Debounced button codes for pressed/released
|
||||
// The changed ones still down are "pressed"
|
||||
player.m_afButtonPressed = buttonsChanged & cmd->buttons;
|
||||
// The ones not down are "released"
|
||||
player.m_afButtonReleased = buttonsChanged & (~cmd->buttons);
|
||||
|
||||
// Set player variables that weapons code might check/alter
|
||||
player.pev->button = cmd->buttons;
|
||||
|
||||
player.pev->velocity = from->client.velocity;
|
||||
player.pev->flags = from->client.flags;
|
||||
|
||||
player.pev->deadflag = from->client.deadflag;
|
||||
g_iWaterLevel = player.pev->waterlevel = from->client.waterlevel;
|
||||
player.pev->maxspeed = from->client.maxspeed;
|
||||
player.pev->fov = from->client.fov;
|
||||
player.pev->weaponanim = from->client.weaponanim;
|
||||
player.pev->viewmodel = from->client.viewmodel;
|
||||
player.m_flNextAttack = from->client.m_flNextAttack;
|
||||
player.m_iQuakeWeapon = (int)from->client.fuser1;
|
||||
iCarriedWeapons = player.m_iQuakeItems = from->client.iuser3;
|
||||
|
||||
player.m_iAmmoShells = from->client.ammo_shells;
|
||||
player.m_iAmmoCells = from->client.ammo_cells;
|
||||
player.m_iAmmoRockets = from->client.ammo_rockets;
|
||||
player.m_iAmmoNails = from->client.ammo_nails;
|
||||
|
||||
player.m_iNailOffset = (int)from->client.fuser2 != 0.0 ? 4.0 : -4.0;
|
||||
|
||||
|
||||
|
||||
// REally useful for debugging prediction
|
||||
/* if ( player.m_iQuakeWeapon > 0 )
|
||||
{
|
||||
gEngfuncs.Con_NPrintf( 9, "got qw %i", player.m_iQuakeWeapon );
|
||||
char items[33];
|
||||
for ( int i = 0; i < 32; i++ )
|
||||
{
|
||||
if ( player.m_iQuakeItems & (1<<i) )
|
||||
{
|
||||
items[i] = '1';
|
||||
}
|
||||
else
|
||||
{
|
||||
items[i] = '0';
|
||||
}
|
||||
}
|
||||
items[32] = 0;
|
||||
gEngfuncs.Con_NPrintf( 10, "got qi %s", items );
|
||||
gEngfuncs.Con_NPrintf( 11, "shells %i", player.m_iAmmoShells );
|
||||
gEngfuncs.Con_NPrintf( 12, "cells %i", player.m_iAmmoCells );
|
||||
gEngfuncs.Con_NPrintf( 13, "rockets %i", player.m_iAmmoRockets );
|
||||
gEngfuncs.Con_NPrintf( 14, "nails %i", player.m_iAmmoNails );
|
||||
gEngfuncs.Con_NPrintf( 15, "viewmodel %i", player.pev->viewmodel );
|
||||
gEngfuncs.Con_NPrintf( 16, "dm == %i", gpGlobals->deathmatch );
|
||||
}*/
|
||||
|
||||
|
||||
// Point to current weapon object
|
||||
if ( from->client.m_iId )
|
||||
{
|
||||
player.m_pActiveItem = g_pWpns[ from->client.m_iId ];
|
||||
}
|
||||
|
||||
// Set ammo, but don't change anim
|
||||
player.W_SetCurrentAmmo( 0 );
|
||||
|
||||
|
||||
|
||||
// Don't go firing anything if we have died.
|
||||
// Or if we don't have a weapon model deployed
|
||||
if ( ( player.pev->deadflag != ( DEAD_DISCARDBODY + 1 ) ) && !CL_IsDead() ) // && player.pev->viewmodel )
|
||||
{
|
||||
if ( player.m_flNextAttack <= 0 )
|
||||
{
|
||||
pWeapon->ItemPostFrame();
|
||||
}
|
||||
}
|
||||
|
||||
// Assume that we are not going to switch weapons
|
||||
to->client.m_iId = from->client.m_iId;
|
||||
|
||||
// Now see if we issued a changeweapon command ( and we're not dead )
|
||||
if ( cmd->weaponselect && ( player.pev->deadflag != ( DEAD_DISCARDBODY + 1 ) ) )
|
||||
{
|
||||
// Switched to a different weapon?
|
||||
if ( Quake_NumForWeaponItem( player.m_iQuakeWeapon ) != cmd->weaponselect )
|
||||
{
|
||||
player.W_ChangeWeapon( cmd->weaponselect );
|
||||
}
|
||||
}
|
||||
|
||||
if ( player.m_iQuakeWeapon != IT_LIGHTNING && pBeam != NULL )
|
||||
{
|
||||
pBeam->die = 0.0;
|
||||
pBeam = NULL;
|
||||
}
|
||||
// Copy in results of predcition code
|
||||
|
||||
to->client.viewmodel = player.pev->viewmodel;
|
||||
to->client.fov = player.pev->fov;
|
||||
to->client.weaponanim = player.pev->weaponanim;
|
||||
to->client.m_flNextAttack = player.m_flNextAttack;
|
||||
to->client.maxspeed = player.pev->maxspeed;
|
||||
to->client.iuser3 = player.m_iQuakeItems;
|
||||
to->client.fuser1 = (float)player.m_iQuakeWeapon;
|
||||
to->client.fuser2 = (float)player.m_iNailOffset > 0.0 ? 1.0 : 0.0;
|
||||
|
||||
to->client.ammo_shells = player.m_iAmmoShells;
|
||||
to->client.ammo_cells = player.m_iAmmoCells;
|
||||
to->client.ammo_rockets = player.m_iAmmoRockets;
|
||||
to->client.ammo_nails = player.m_iAmmoNails;
|
||||
|
||||
// Make sure that weapon animation matches what the game .dll is telling us
|
||||
// over the wire ( fixes some animation glitches )
|
||||
if ( g_runfuncs && ( HUD_GetWeaponAnim() != to->client.weaponanim ) )
|
||||
{
|
||||
int body = 2;
|
||||
// Force a fixed anim down to viewmodel
|
||||
HUD_SendWeaponAnim( to->client.weaponanim, body, 1 );
|
||||
}
|
||||
|
||||
for ( i = 0; i < 32; i++ )
|
||||
{
|
||||
pCurrent = g_pWpns[ i ];
|
||||
|
||||
pto = &to->weapondata[ i ];
|
||||
|
||||
if ( !pCurrent )
|
||||
{
|
||||
memset( pto, 0, sizeof( weapon_data_t ) );
|
||||
continue;
|
||||
}
|
||||
|
||||
pto->m_fInReload = pCurrent->m_fInReload;
|
||||
pto->m_iClip = pCurrent->m_iClip;
|
||||
pto->m_flNextPrimaryAttack = pCurrent->m_flNextPrimaryAttack;
|
||||
pto->m_flNextSecondaryAttack = pCurrent->m_flNextSecondaryAttack;
|
||||
pto->m_flTimeWeaponIdle = pCurrent->m_flTimeWeaponIdle;
|
||||
|
||||
// Decrement weapon counters, server does this at same time ( during post think, after doing everything else )
|
||||
pto->m_flNextReload -= cmd->msec / 1000.0;
|
||||
pto->m_fNextAimBonus -= cmd->msec / 1000.0;
|
||||
pto->m_flNextPrimaryAttack -= cmd->msec / 1000.0;
|
||||
pto->m_flNextSecondaryAttack -= cmd->msec / 1000.0;
|
||||
pto->m_flTimeWeaponIdle -= cmd->msec / 1000.0;
|
||||
|
||||
if ( pto->m_flPumpTime != -9999 )
|
||||
{
|
||||
pto->m_flPumpTime -= cmd->msec / 1000.0;
|
||||
if ( pto->m_flPumpTime < -0.001 )
|
||||
pto->m_flPumpTime = -0.001;
|
||||
}
|
||||
|
||||
if ( pto->m_fNextAimBonus < -1.0 )
|
||||
{
|
||||
pto->m_fNextAimBonus = -1.0;
|
||||
}
|
||||
|
||||
if ( pto->m_flNextPrimaryAttack < -1.0 )
|
||||
{
|
||||
pto->m_flNextPrimaryAttack = -1.0;
|
||||
}
|
||||
|
||||
if ( pto->m_flNextSecondaryAttack < -0.001 )
|
||||
{
|
||||
pto->m_flNextSecondaryAttack = -0.001;
|
||||
}
|
||||
|
||||
if ( pto->m_flTimeWeaponIdle < -0.001 )
|
||||
{
|
||||
pto->m_flTimeWeaponIdle = -0.001;
|
||||
}
|
||||
|
||||
if ( pto->m_flNextReload < -0.001 )
|
||||
{
|
||||
pto->m_flNextReload = -0.001;
|
||||
}
|
||||
}
|
||||
|
||||
// m_flNextAttack is now part of the weapons, but is part of the player instead
|
||||
to->client.m_flNextAttack -= cmd->msec / 1000.0;
|
||||
if ( to->client.m_flNextAttack < -0.001 )
|
||||
{
|
||||
to->client.m_flNextAttack = -0.001;
|
||||
}
|
||||
|
||||
// Store off the last position from the predicted state.
|
||||
HUD_SetLastOrg();
|
||||
// Wipe it so we can't use it after this frame
|
||||
g_finalstate = NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
HUD_PostRunCmd
|
||||
|
||||
Client calls this during prediction, after it has moved the player and updated any info changed into to->
|
||||
time is the current client clock based on prediction
|
||||
cmd is the command that caused the movement, etc
|
||||
runfuncs is 1 if this is the first time we've predicted this command. If so, sounds and effects should play, otherwise, they should
|
||||
be ignored
|
||||
=====================
|
||||
*/
|
||||
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 )
|
||||
{
|
||||
g_runfuncs = runfuncs;
|
||||
|
||||
// Only run post think stuff for glock for the sample
|
||||
// implementation
|
||||
if ( cl_lw && cl_lw->value )
|
||||
{
|
||||
HUD_WeaponsPostThink( from, to, cmd, time, random_seed );
|
||||
}
|
||||
else
|
||||
{
|
||||
to->client.fov = g_lastFOV;
|
||||
}
|
||||
|
||||
Dmc_CheckTeleporters( from, to ); // See if we stepped on a jump pad
|
||||
|
||||
// All games can use FOV state
|
||||
g_lastFOV = to->client.fov;
|
||||
}
|
||||
|
|
@ -1,107 +0,0 @@
|
|||
client dll readme.txt
|
||||
-------------------------
|
||||
|
||||
This file details the structure of the half-life client dll, and
|
||||
how it communicates with the half-life game engine.
|
||||
|
||||
|
||||
Engine callback functions:
|
||||
|
||||
Drawing functions:
|
||||
HSPRITE SPR_Load( char *picname );
|
||||
Loads a sprite into memory, and returns a handle to it.
|
||||
|
||||
int SPR_Frames( HSPRITE sprite );
|
||||
Returns the number of frames stored in the specified sprite.
|
||||
|
||||
int SPR_Height( HSPRITE x, int frame )
|
||||
Returns the height, in pixels, of a sprite at the specified frame.
|
||||
Returns 0 is the frame number or the sprite handle is invalid.
|
||||
|
||||
int SPR_Width( HSPRITE x, int f )
|
||||
Returns the width, in pixels, of a sprite at the specified frame.
|
||||
Returns 0 is the frame number or the sprite handle is invalid.
|
||||
|
||||
int SPR_Set( HSPRITE sprite, int r, int g, int b );
|
||||
Prepares a sprite about to be drawn. RBG color values are applied to the sprite at this time.
|
||||
|
||||
|
||||
void SPR_Draw( int frame, int x, int y );
|
||||
Precondition: SPR_Set has already been called for a sprite.
|
||||
Draws the currently active sprite to the screen, at position (x,y), where (0,0) is
|
||||
the top left-hand corner of the screen.
|
||||
|
||||
|
||||
void SPR_DrawHoles( int frame, int x, int y );
|
||||
Precondition: SPR_Set has already been called for a sprite.
|
||||
Draws the currently active sprite to the screen. Color index #255 is treated as transparent.
|
||||
|
||||
void SPR_DrawAdditive( int frame, int x, int y );
|
||||
Precondition: SPR_Set has already been called for a sprite.
|
||||
Draws the currently active sprite to the screen, adding it's color values to the background.
|
||||
|
||||
void SPR_EnableScissor( int x, int y, int width, int height );
|
||||
Creates a clipping rectangle. No pixels will be drawn outside the specified area. Will
|
||||
stay in effect until either the next frame, or SPR_DisableScissor is called.
|
||||
|
||||
void SPR_DisableScissor( void );
|
||||
Disables the effect of an SPR_EnableScissor call.
|
||||
|
||||
int IsHighRes( void );
|
||||
returns 1 if the res mode is 640x480 or higher; 0 otherwise.
|
||||
|
||||
int ScreenWidth( void );
|
||||
returns the screen width, in pixels.
|
||||
|
||||
int ScreenHeight( void );
|
||||
returns the screen height, in pixels.
|
||||
|
||||
// Sound functions
|
||||
void PlaySound( char *szSound, int volume )
|
||||
plays the sound 'szSound' at the specified volume. Loads the sound if it hasn't been cached.
|
||||
If it can't find the sound, it displays an error message and plays no sound.
|
||||
|
||||
void PlaySound( int iSound, int volume )
|
||||
Precondition: iSound has been precached.
|
||||
Plays the sound, from the precache list.
|
||||
|
||||
|
||||
// Communication functions
|
||||
void SendClientCmd( char *szCmdString );
|
||||
sends a command to the server, just as if the client had typed the szCmdString at the console.
|
||||
|
||||
char *GetPlayerName( int entity_number );
|
||||
returns a pointer to a string, that contains the name of the specified client.
|
||||
Returns NULL if the entity_number is not a client.
|
||||
|
||||
|
||||
DECLARE_MESSAGE(), HOOK_MESSAGE()
|
||||
These two macros bind the message sending between the entity DLL and the client DLL to
|
||||
the CHud object.
|
||||
|
||||
HOOK_MESSAGE( message_name )
|
||||
This is used inside CHud::Init(). It calls into the engine to hook that message
|
||||
from the incoming message stream.
|
||||
Precondition: There must be a function of name UserMsg_message_name declared
|
||||
for CHud. Eg, CHud::UserMsg_Health() must be declared if you want to
|
||||
use HOOK_MESSAGE( Health );
|
||||
|
||||
DECLARE_MESSAGE( message_name )
|
||||
For each HOOK_MESSAGE you must have an equivalent DECLARE_MESSAGE. This creates
|
||||
a function which passes the hooked messages into the CHud object.
|
||||
|
||||
|
||||
HOOK_COMMAND(), DECLARE_COMMAND()
|
||||
These two functions declare and hook console commands into the client dll.
|
||||
|
||||
HOOK_COMMAND( char *command, command_name )
|
||||
Whenever the user types the 'command' at the console, the function 'command_name'
|
||||
will be called.
|
||||
Precondition: There must be a function of the name UserCmd_command_name declared
|
||||
for CHud. Eg, CHud::UserMsg_ShowScores() must be declared if you want to
|
||||
use HOOK_COMMAND( "+showscores", ShowScores );
|
||||
|
||||
DECLARE_COMMAND( command_name )
|
||||
For each HOOK_COMMAND you must have an equivelant DECLARE_COMMAND. This creates
|
||||
a function which passes the hooked commands into the CHud object.
|
||||
|
||||
|
|
@ -1,312 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// saytext.cpp
|
||||
//
|
||||
// implementation of CHudSayText class
|
||||
//
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "parsemsg.h"
|
||||
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
extern float *GetClientColor( int clientIndex );
|
||||
extern hud_player_info_t g_PlayerInfoList[MAX_PLAYERS+1];
|
||||
|
||||
#define MAX_LINES 5
|
||||
#define MAX_CHARS_PER_LINE 256 /* it can be less than this, depending on char size */
|
||||
|
||||
// allow 20 pixels on either side of the text
|
||||
#define MAX_LINE_WIDTH ( ScreenWidth - 40 )
|
||||
#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 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 );
|
||||
|
||||
int CHudSayText :: Init( void )
|
||||
{
|
||||
gHUD.AddHudElem( this );
|
||||
|
||||
HOOK_MESSAGE( SayText );
|
||||
|
||||
InitHUDData();
|
||||
|
||||
m_HUD_saytext = gEngfuncs.pfnRegisterVariable( "hud_saytext", "1", 0 );
|
||||
m_HUD_saytext_time = gEngfuncs.pfnRegisterVariable( "hud_saytext_time", "5", 0 );
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
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 );
|
||||
|
||||
m_iFlags |= HUD_INTERMISSION; // is always drawn during an intermission
|
||||
}
|
||||
|
||||
int CHudSayText :: VidInit( void )
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int ScrollTextUp( void )
|
||||
{
|
||||
ConsolePrint( g_szLineBuffer[0] ); // move the first line into the console buffer
|
||||
g_szLineBuffer[MAX_LINES][0] = 0;
|
||||
memmove( g_szLineBuffer[0], g_szLineBuffer[1], sizeof(g_szLineBuffer) - sizeof(g_szLineBuffer[0]) ); // overwrite the first line
|
||||
memmove( &g_pflNameColors[0], &g_pflNameColors[1], sizeof(g_pflNameColors) - sizeof(g_pflNameColors[0]) );
|
||||
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
|
||||
{
|
||||
g_szLineBuffer[0][0] = 2;
|
||||
return 1 + ScrollTextUp();
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudSayText :: Draw( float flTime )
|
||||
{
|
||||
int y = Y_START;
|
||||
|
||||
// make sure the scrolltime is within reasonable bounds, to guard against the clock being reset
|
||||
flScrollTime = min( flScrollTime, flTime + m_HUD_saytext_time->value );
|
||||
|
||||
// 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 ( *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
|
||||
m_iFlags &= ~HUD_ACTIVE;
|
||||
}
|
||||
}
|
||||
|
||||
for ( int i = 0; i < MAX_LINES; i++ )
|
||||
{
|
||||
if ( *g_szLineBuffer[i] )
|
||||
{
|
||||
if ( *g_szLineBuffer[i] == 2 && g_pflNameColors[i] )
|
||||
{
|
||||
// it's a saytext string
|
||||
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;
|
||||
gEngfuncs.pfnDrawSetTextColor( g_pflNameColors[i][0], g_pflNameColors[i][1], g_pflNameColors[i][2] );
|
||||
|
||||
int x = DrawConsoleString( LINE_START, y, buf );
|
||||
|
||||
// color is reset after each string draw
|
||||
DrawConsoleString( x, y, g_szLineBuffer[i] + g_iNameLengths[i] );
|
||||
}
|
||||
else
|
||||
{
|
||||
// normal draw
|
||||
DrawConsoleString( LINE_START, y, g_szLineBuffer[i] );
|
||||
}
|
||||
}
|
||||
|
||||
y += line_height;
|
||||
}
|
||||
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
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 )
|
||||
{
|
||||
// find an empty string slot
|
||||
int i;
|
||||
for ( i = 0; i < MAX_LINES; i++ )
|
||||
{
|
||||
if ( ! *g_szLineBuffer[i] )
|
||||
break;
|
||||
}
|
||||
if ( i == MAX_LINES )
|
||||
{
|
||||
// force scroll buffer up
|
||||
ScrollTextUp();
|
||||
i = MAX_LINES - 1;
|
||||
}
|
||||
|
||||
g_iNameLengths[i] = 0;
|
||||
g_pflNameColors[i] = NULL;
|
||||
|
||||
// if it's a say message, search for the players name in the string
|
||||
if ( *pszBuf == 2 && clientIndex > 0 )
|
||||
{
|
||||
GetPlayerInfo( clientIndex, &g_PlayerInfoList[clientIndex] );
|
||||
const char *pName = g_PlayerInfoList[clientIndex].name;
|
||||
|
||||
if ( pName )
|
||||
{
|
||||
const char *nameInString = strstr( pszBuf, pName );
|
||||
|
||||
if ( nameInString )
|
||||
{
|
||||
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) );
|
||||
|
||||
// make sure the text fits in one line
|
||||
EnsureTextFitsInOneLineAndWrapIfHaveTo( i );
|
||||
|
||||
// Set scroll time
|
||||
if ( i == 0 )
|
||||
{
|
||||
flScrollTime = gHUD.m_flTime + m_HUD_saytext_time->value;
|
||||
}
|
||||
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
PlaySound( "misc/talk.wav", 1 );
|
||||
|
||||
if ( ScreenHeight >= 480 )
|
||||
Y_START = ScreenHeight - 138;
|
||||
else
|
||||
Y_START = ScreenHeight - 70;
|
||||
Y_START -= (line_height * (MAX_LINES+1));
|
||||
|
||||
}
|
||||
|
||||
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
|
||||
// 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++ )
|
||||
{
|
||||
// check for a color change, if so skip past it
|
||||
if ( x[0] == '/' && x[1] == '(' )
|
||||
{
|
||||
x += 2;
|
||||
// skip forward until past mode specifier
|
||||
while ( *x != 0 && *x != ')' )
|
||||
x++;
|
||||
|
||||
if ( *x != 0 )
|
||||
x++;
|
||||
|
||||
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
|
||||
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;
|
||||
|
||||
x = last_break;
|
||||
|
||||
// find an empty string slot
|
||||
int j;
|
||||
do
|
||||
{
|
||||
for ( j = 0; j < MAX_LINES; j++ )
|
||||
{
|
||||
if ( ! *g_szLineBuffer[j] )
|
||||
break;
|
||||
}
|
||||
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);
|
||||
}
|
||||
}
|
||||
while ( j == MAX_LINES );
|
||||
|
||||
// copy remaining string into next buffer, making sure it starts with a space character
|
||||
if ( (char)*last_break == (char)' ' )
|
||||
{
|
||||
int linelen = strlen(g_szLineBuffer[j]);
|
||||
int remaininglen = strlen(last_break);
|
||||
|
||||
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 )
|
||||
{
|
||||
strcat( g_szLineBuffer[j], " " );
|
||||
strcat( g_szLineBuffer[j], last_break );
|
||||
}
|
||||
}
|
||||
|
||||
*last_break = 0; // cut off the last string
|
||||
|
||||
EnsureTextFitsInOneLineAndWrapIfHaveTo( j );
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,527 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// Scoreboard.cpp
|
||||
//
|
||||
// implementation of CHudScoreboard class
|
||||
//
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "parsemsg.h"
|
||||
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
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 );
|
||||
|
||||
|
||||
int CHudScoreboard :: Init( void )
|
||||
{
|
||||
gHUD.AddHudElem( this );
|
||||
|
||||
HOOK_MESSAGE( ScoreInfo );
|
||||
HOOK_MESSAGE( TeamScore );
|
||||
HOOK_MESSAGE( TeamInfo );
|
||||
|
||||
InitHUDData();
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int CHudScoreboard :: VidInit( void )
|
||||
{
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void CHudScoreboard :: InitHUDData( void )
|
||||
{
|
||||
memset( g_PlayerExtraInfo, 0, sizeof g_PlayerExtraInfo );
|
||||
m_iLastKilledBy = 0;
|
||||
m_fLastKillTime = 0;
|
||||
m_iPlayerNum = 0;
|
||||
m_iNumTeams = 0;
|
||||
|
||||
memset( m_TeamInfo, 0, sizeof m_TeamInfo );
|
||||
|
||||
m_iFlags &= ~HUD_ACTIVE; // starts out inactive
|
||||
|
||||
m_iFlags |= HUD_INTERMISSION; // is always drawn during an intermission
|
||||
}
|
||||
|
||||
/* The scoreboard
|
||||
We have a minimum width of 1-320 - we could have the field widths scale with it?
|
||||
*/
|
||||
|
||||
// X positions
|
||||
// relative to the side of the scoreboard
|
||||
#define NAME_RANGE_MIN 20
|
||||
#define NAME_RANGE_MAX 145
|
||||
#define KILLS_RANGE_MIN 130
|
||||
#define KILLS_RANGE_MAX 170
|
||||
#define DIVIDER_POS 180
|
||||
#define DEATHS_RANGE_MIN 185
|
||||
#define DEATHS_RANGE_MAX 210
|
||||
#define PING_RANGE_MIN 245
|
||||
#define PING_RANGE_MAX 295
|
||||
|
||||
#define 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 )
|
||||
{
|
||||
if ( !m_iShowscoresHeld && gHUD.m_Health.m_iHealth > 0 && !gHUD.m_iIntermission )
|
||||
return 1;
|
||||
|
||||
|
||||
GetAllPlayersInfo();
|
||||
|
||||
// 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;
|
||||
|
||||
// print the heading line
|
||||
int ypos = ROW_RANGE_MIN + (list_slot * ROW_GAP);
|
||||
int xpos = NAME_RANGE_MIN + xpos_rel;
|
||||
|
||||
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 );
|
||||
|
||||
gHUD.DrawHudStringReverse( KILLS_RANGE_MAX + xpos_rel, ypos, 0, "kills", 255, 140, 0 );
|
||||
gHUD.DrawHudString( DIVIDER_POS + xpos_rel, ypos, ScreenWidth, "/", 255, 140, 0 );
|
||||
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 );
|
||||
|
||||
list_slot += 1.2;
|
||||
ypos = ROW_RANGE_MIN + (list_slot * ROW_GAP);
|
||||
xpos = NAME_RANGE_MIN + xpos_rel;
|
||||
FillRGBA( xpos - 5, ypos, PING_RANGE_MAX - 5, 1, 255, 140, 0, 255); // draw the seperator line
|
||||
|
||||
list_slot += 0.8;
|
||||
|
||||
if ( !gHUD.m_Teamplay )
|
||||
{
|
||||
// it's not teamplay, so just draw a simple player list
|
||||
DrawPlayers( xpos_rel, list_slot );
|
||||
return 1;
|
||||
}
|
||||
|
||||
// clear out team scores
|
||||
for ( int i = 1; i <= m_iNumTeams; i++ )
|
||||
{
|
||||
if ( !m_TeamInfo[i].scores_overriden )
|
||||
m_TeamInfo[i].frags = m_TeamInfo[i].deaths = 0;
|
||||
m_TeamInfo[i].ping = m_TeamInfo[i].packetloss = 0;
|
||||
}
|
||||
|
||||
// recalc the team scores, then draw them
|
||||
for ( i = 1; i < MAX_PLAYERS; i++ )
|
||||
{
|
||||
if ( m_PlayerInfoList[i].name == NULL )
|
||||
continue; // empty player slot, skip
|
||||
|
||||
if ( m_PlayerExtraInfo[i].teamname[0] == 0 )
|
||||
continue; // skip over players who are not in a team
|
||||
|
||||
// find what team this player is in
|
||||
for ( int j = 1; j <= m_iNumTeams; j++ )
|
||||
{
|
||||
if ( !stricmp( m_PlayerExtraInfo[i].teamname, m_TeamInfo[j].name ) )
|
||||
break;
|
||||
}
|
||||
if ( j > m_iNumTeams ) // player is not in a team, skip to the next guy
|
||||
continue;
|
||||
|
||||
if ( !m_TeamInfo[j].scores_overriden )
|
||||
{
|
||||
m_TeamInfo[j].frags += m_PlayerExtraInfo[i].frags;
|
||||
m_TeamInfo[j].deaths += m_PlayerExtraInfo[i].deaths;
|
||||
}
|
||||
|
||||
m_TeamInfo[j].ping += m_PlayerInfoList[i].ping;
|
||||
m_TeamInfo[j].packetloss += m_PlayerInfoList[i].packetloss;
|
||||
|
||||
if ( m_PlayerInfoList[i].thisplayer )
|
||||
m_TeamInfo[j].ownteam = TRUE;
|
||||
else
|
||||
m_TeamInfo[j].ownteam = FALSE;
|
||||
}
|
||||
|
||||
// find team ping/packetloss averages
|
||||
for ( i = 1; i <= m_iNumTeams; i++ )
|
||||
{
|
||||
m_TeamInfo[i].already_drawn = FALSE;
|
||||
|
||||
if ( m_TeamInfo[i].players > 0 )
|
||||
{
|
||||
m_TeamInfo[i].ping /= m_TeamInfo[i].players; // use the average ping of all the players in the team as the teams ping
|
||||
m_TeamInfo[i].packetloss /= m_TeamInfo[i].players; // use the average ping of all the players in the team as the teams ping
|
||||
}
|
||||
}
|
||||
|
||||
// Draw the teams
|
||||
while ( 1 )
|
||||
{
|
||||
int highest_frags = -99999; int lowest_deaths = 99999;
|
||||
int best_team = 0;
|
||||
|
||||
for ( i = 1; i <= m_iNumTeams; i++ )
|
||||
{
|
||||
if ( m_TeamInfo[i].players < 0 )
|
||||
continue;
|
||||
|
||||
if ( !m_TeamInfo[i].already_drawn && m_TeamInfo[i].frags >= highest_frags )
|
||||
{
|
||||
if ( m_TeamInfo[i].frags > highest_frags || m_TeamInfo[i].deaths < lowest_deaths )
|
||||
{
|
||||
best_team = i;
|
||||
lowest_deaths = m_TeamInfo[i].deaths;
|
||||
highest_frags = m_TeamInfo[i].frags;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// draw the best team on the scoreboard
|
||||
if ( !best_team )
|
||||
break;
|
||||
|
||||
// draw out the best team
|
||||
team_info_t *team_info = &m_TeamInfo[best_team];
|
||||
|
||||
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
|
||||
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
|
||||
{
|
||||
// overlay the background in blue, then draw the score text over it
|
||||
FillRGBA( NAME_RANGE_MIN + xpos_rel - 5, ypos, PING_RANGE_MAX - 5, ROW_GAP, 0, 0, 255, 70 );
|
||||
}
|
||||
|
||||
// draw their name (left to right)
|
||||
gHUD.DrawHudString( xpos, ypos, NAME_RANGE_MAX + xpos_rel, team_info->name, r, g, b );
|
||||
|
||||
// draw kills (right to left)
|
||||
xpos = KILLS_RANGE_MAX + xpos_rel;
|
||||
gHUD.DrawHudNumberString( xpos, ypos, KILLS_RANGE_MIN + xpos_rel, team_info->frags, r, g, b );
|
||||
|
||||
// draw divider
|
||||
xpos = DIVIDER_POS + xpos_rel;
|
||||
gHUD.DrawHudString( xpos, ypos, xpos + 20, "/", r, g, b );
|
||||
|
||||
// draw deaths
|
||||
xpos = DEATHS_RANGE_MAX + xpos_rel;
|
||||
gHUD.DrawHudNumberString( xpos, ypos, DEATHS_RANGE_MIN + xpos_rel, team_info->deaths, r, g, b );
|
||||
|
||||
// draw ping
|
||||
// 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;
|
||||
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
|
||||
sprintf( buf, " %d", team_info->packetloss );
|
||||
gHUD.DrawHudString( xpos, ypos, xpos+50, buf, r, g, b );
|
||||
*/
|
||||
|
||||
team_info->already_drawn = TRUE; // set the already_drawn to be TRUE, so this team won't get drawn again
|
||||
list_slot++;
|
||||
|
||||
// draw all the players that belong to this team, indented slightly
|
||||
list_slot = DrawPlayers( xpos_rel, list_slot, 10, team_info->name );
|
||||
}
|
||||
|
||||
// draw all the players who are not in a team
|
||||
list_slot += 0.5;
|
||||
DrawPlayers( xpos_rel, list_slot, 0, "" );
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// returns the ypos where it finishes drawing
|
||||
int CHudScoreboard :: DrawPlayers( int xpos_rel, float list_slot, int nameoffset, char *team )
|
||||
{
|
||||
// draw the players, in order, and restricted to team if set
|
||||
while ( 1 )
|
||||
{
|
||||
// Find the top ranking player
|
||||
int highest_frags = -99999; int lowest_deaths = 99999;
|
||||
int best_player = 0;
|
||||
|
||||
for ( int i = 1; i < MAX_PLAYERS; i++ )
|
||||
{
|
||||
if ( m_PlayerInfoList[i].name && m_PlayerExtraInfo[i].frags >= highest_frags )
|
||||
{
|
||||
if ( !(team && stricmp(m_PlayerExtraInfo[i].teamname, team)) ) // make sure it is the specified team
|
||||
{
|
||||
extra_player_info_t *pl_info = &m_PlayerExtraInfo[i];
|
||||
if ( pl_info->frags > highest_frags || pl_info->deaths < lowest_deaths )
|
||||
{
|
||||
best_player = i;
|
||||
lowest_deaths = pl_info->deaths;
|
||||
highest_frags = pl_info->frags;
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ( !best_player )
|
||||
break;
|
||||
|
||||
// draw out the best player
|
||||
hud_player_info_t *pl_info = &m_PlayerInfoList[best_player];
|
||||
|
||||
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
|
||||
break;
|
||||
|
||||
int xpos = NAME_RANGE_MIN + xpos_rel;
|
||||
int r = 255, g = 255, b = 255;
|
||||
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...
|
||||
FillRGBA( NAME_RANGE_MIN + xpos_rel - 5, ypos, PING_RANGE_MAX - 5, 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, PING_RANGE_MAX - 5, 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
|
||||
{
|
||||
// overlay the background in blue, then draw the score text over it
|
||||
FillRGBA( NAME_RANGE_MIN + xpos_rel - 5, ypos, PING_RANGE_MAX - 5, ROW_GAP, 0, 0, 255, 70 );
|
||||
}
|
||||
|
||||
// draw their name (left to right)
|
||||
gHUD.DrawHudString( xpos + nameoffset, ypos, NAME_RANGE_MAX + xpos_rel, pl_info->name, r, g, b );
|
||||
|
||||
// draw kills (right to left)
|
||||
xpos = KILLS_RANGE_MAX + xpos_rel;
|
||||
gHUD.DrawHudNumberString( xpos, ypos, KILLS_RANGE_MIN + xpos_rel, m_PlayerExtraInfo[best_player].frags, r, g, b );
|
||||
|
||||
// draw divider
|
||||
xpos = DIVIDER_POS + xpos_rel;
|
||||
gHUD.DrawHudString( xpos, ypos, xpos + 20, "/", r, g, b );
|
||||
|
||||
// draw deaths
|
||||
xpos = DEATHS_RANGE_MAX + xpos_rel;
|
||||
gHUD.DrawHudNumberString( xpos, ypos, DEATHS_RANGE_MIN + xpos_rel, m_PlayerExtraInfo[best_player].deaths, r, g, b );
|
||||
|
||||
// draw ping & packetloss
|
||||
static char buf[64];
|
||||
sprintf( buf, "%d", m_PlayerInfoList[best_player].ping );
|
||||
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 ( m_PlayerInfoList[best_player].packetloss >= 63 )
|
||||
{
|
||||
UnpackRGB( r, g, b, RGB_REDISH );
|
||||
sprintf( buf, " !!!!" );
|
||||
}
|
||||
else
|
||||
{
|
||||
sprintf( buf, " %d", m_PlayerInfoList[best_player].packetloss );
|
||||
}
|
||||
|
||||
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++;
|
||||
}
|
||||
|
||||
return list_slot;
|
||||
}
|
||||
|
||||
|
||||
void CHudScoreboard :: GetAllPlayersInfo( void )
|
||||
{
|
||||
for ( int i = 1; i < MAX_PLAYERS; i++ )
|
||||
{
|
||||
GetPlayerInfo( i, &m_PlayerInfoList[i] );
|
||||
|
||||
if ( m_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 )
|
||||
{
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
short cl = READ_BYTE();
|
||||
short frags = READ_SHORT();
|
||||
short deaths = READ_SHORT();
|
||||
|
||||
if ( cl > 0 && cl <= MAX_PLAYERS )
|
||||
{
|
||||
m_PlayerExtraInfo[cl].frags = frags;
|
||||
m_PlayerExtraInfo[cl].deaths = deaths;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Message handler for TeamInfo message
|
||||
// accepts two values:
|
||||
// byte: client number
|
||||
// string: client team name
|
||||
int CHudScoreboard :: MsgFunc_TeamInfo( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
short cl = READ_BYTE();
|
||||
|
||||
if ( cl > 0 && cl <= MAX_PLAYERS )
|
||||
{ // set the players team
|
||||
strncpy( m_PlayerExtraInfo[cl].teamname, READ_STRING(), MAX_TEAM_NAME );
|
||||
}
|
||||
|
||||
// rebuild the list of teams
|
||||
|
||||
// clear out player counts from teams
|
||||
for ( int i = 1; i <= m_iNumTeams; i++ )
|
||||
{
|
||||
m_TeamInfo[i].players = 0;
|
||||
}
|
||||
|
||||
// rebuild the team list
|
||||
GetAllPlayersInfo();
|
||||
m_iNumTeams = 0;
|
||||
for ( i = 1; i < MAX_PLAYERS; i++ )
|
||||
{
|
||||
if ( m_PlayerInfoList[i].name == NULL )
|
||||
continue;
|
||||
|
||||
if ( m_PlayerExtraInfo[i].teamname[0] == 0 )
|
||||
continue; // skip over players who are not in a team
|
||||
|
||||
// is this player in an existing team?
|
||||
for ( int j = 1; j <= m_iNumTeams; j++ )
|
||||
{
|
||||
if ( m_TeamInfo[j].name[0] == '\0' )
|
||||
break;
|
||||
|
||||
if ( !stricmp( m_PlayerExtraInfo[i].teamname, m_TeamInfo[j].name ) )
|
||||
break;
|
||||
}
|
||||
|
||||
if ( j > m_iNumTeams )
|
||||
{ // they aren't in a listed team, so make a new one
|
||||
// search through for an empty team slot
|
||||
for ( int j = 1; j <= m_iNumTeams; j++ )
|
||||
{
|
||||
if ( m_TeamInfo[j].name[0] == '\0' )
|
||||
break;
|
||||
}
|
||||
m_iNumTeams = max( j, m_iNumTeams );
|
||||
|
||||
strncpy( m_TeamInfo[j].name, m_PlayerExtraInfo[i].teamname, MAX_TEAM_NAME );
|
||||
m_TeamInfo[j].players = 0;
|
||||
}
|
||||
|
||||
m_TeamInfo[j].players++;
|
||||
}
|
||||
|
||||
// clear out any empty teams
|
||||
for ( i = 1; i <= m_iNumTeams; i++ )
|
||||
{
|
||||
if ( m_TeamInfo[i].players < 1 )
|
||||
memset( &m_TeamInfo[i], 0, sizeof(team_info_t) );
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Message handler for TeamScore message
|
||||
// accepts three values:
|
||||
// string: team name
|
||||
// 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 )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
char *TeamName = READ_STRING();
|
||||
|
||||
// find the team matching the name
|
||||
for ( int i = 1; i <= m_iNumTeams; i++ )
|
||||
{
|
||||
if ( !stricmp( TeamName, m_TeamInfo[i].name ) )
|
||||
break;
|
||||
}
|
||||
if ( i > m_iNumTeams )
|
||||
return 1;
|
||||
|
||||
// use this new score data instead of combined player scores
|
||||
m_TeamInfo[i].scores_overriden = TRUE;
|
||||
m_TeamInfo[i].frags = READ_SHORT();
|
||||
m_TeamInfo[i].deaths = READ_SHORT();
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
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 )
|
||||
{
|
||||
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 )
|
||||
m_iLastKilledBy = m_iPlayerNum;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void CHudScoreboard :: UserCmd_ShowScores( void )
|
||||
{
|
||||
m_iShowscoresHeld = TRUE;
|
||||
}
|
||||
|
||||
void CHudScoreboard :: UserCmd_HideScores( void )
|
||||
{
|
||||
m_iShowscoresHeld = FALSE;
|
||||
}
|
||||
|
|
@ -1,150 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// status_icons.cpp
|
||||
//
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include "parsemsg.h"
|
||||
|
||||
DECLARE_MESSAGE( m_StatusIcons, StatusIcon );
|
||||
|
||||
int CHudStatusIcons::Init( void )
|
||||
{
|
||||
HOOK_MESSAGE( StatusIcon );
|
||||
|
||||
gHUD.AddHudElem( this );
|
||||
|
||||
Reset();
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudStatusIcons::VidInit( void )
|
||||
{
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void CHudStatusIcons::Reset( void )
|
||||
{
|
||||
memset( m_IconList, 0, sizeof m_IconList );
|
||||
m_iFlags &= ~HUD_ACTIVE;
|
||||
}
|
||||
|
||||
// Draw status icons along the left-hand side of the screen
|
||||
int CHudStatusIcons::Draw( float flTime )
|
||||
{
|
||||
// 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++ )
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
// Message handler for StatusIcon message
|
||||
// accepts five values:
|
||||
// byte : TRUE = ENABLE icon, FALSE = DISABLE icon
|
||||
// string : the sprite name to display
|
||||
// byte : red
|
||||
// byte : green
|
||||
// byte : blue
|
||||
int CHudStatusIcons::MsgFunc_StatusIcon( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
int ShouldEnable = READ_BYTE();
|
||||
char *pszIconName = READ_STRING();
|
||||
if ( ShouldEnable )
|
||||
{
|
||||
int r = READ_BYTE();
|
||||
int g = READ_BYTE();
|
||||
int b = READ_BYTE();
|
||||
EnableIcon( pszIconName, r, g, b );
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
}
|
||||
else
|
||||
{
|
||||
DisableIcon( pszIconName );
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// add the icon to the icon list, and set it's drawing color
|
||||
void CHudStatusIcons::EnableIcon( char *pszIconName, unsigned char red, unsigned char green, unsigned char blue )
|
||||
{
|
||||
// check to see if the sprite is in the current list
|
||||
int i;
|
||||
for ( i = 0; i < MAX_ICONSPRITES; i++ )
|
||||
{
|
||||
if ( !stricmp( m_IconList[i].szSpriteName, pszIconName ) )
|
||||
break;
|
||||
}
|
||||
|
||||
if ( i == MAX_ICONSPRITES )
|
||||
{
|
||||
// icon not in list, so find an empty slot to add to
|
||||
for ( i = 0; i < MAX_ICONSPRITES; i++ )
|
||||
{
|
||||
if ( !m_IconList[i].spr )
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// if we've run out of space in the list, overwrite the first icon
|
||||
if ( i == MAX_ICONSPRITES )
|
||||
{
|
||||
i = 0;
|
||||
}
|
||||
|
||||
// Load the sprite and add it to the list
|
||||
// the sprite must be listed in hud.txt
|
||||
int spr_index = gHUD.GetSpriteIndex( pszIconName );
|
||||
m_IconList[i].spr = gHUD.GetSprite( spr_index );
|
||||
m_IconList[i].rc = gHUD.GetSpriteRect( spr_index );
|
||||
m_IconList[i].r = red;
|
||||
m_IconList[i].g = green;
|
||||
m_IconList[i].b = blue;
|
||||
strcpy( m_IconList[i].szSpriteName, pszIconName );
|
||||
}
|
||||
|
||||
void CHudStatusIcons::DisableIcon( char *pszIconName )
|
||||
{
|
||||
// find the sprite is in the current list
|
||||
for ( int i = 0; i < MAX_ICONSPRITES; i++ )
|
||||
{
|
||||
if ( !stricmp( m_IconList[i].szSpriteName, pszIconName ) )
|
||||
{
|
||||
// clear the item from the list
|
||||
memset( &m_IconList[i], 0, sizeof(icon_sprite_t) );
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,262 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// statusbar.cpp
|
||||
//
|
||||
// generic text status bar, set by game dll
|
||||
// runs across bottom of screen
|
||||
//
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "parsemsg.h"
|
||||
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
DECLARE_MESSAGE( m_StatusBar, StatusText );
|
||||
DECLARE_MESSAGE( m_StatusBar, StatusValue );
|
||||
|
||||
#define STATUSBAR_ID_LINE 1
|
||||
|
||||
extern int GetTeamIndex( int clientIndex );
|
||||
int g_iNameColors;
|
||||
|
||||
int CHudStatusBar :: Init( void )
|
||||
{
|
||||
gHUD.AddHudElem( this );
|
||||
|
||||
HOOK_MESSAGE( StatusText );
|
||||
HOOK_MESSAGE( StatusValue );
|
||||
|
||||
Reset();
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CHudStatusBar :: VidInit( void )
|
||||
{
|
||||
// Load sprites here
|
||||
m_iArmorSpriteIndex = gHUD.GetSpriteIndex( "armor_bar" );
|
||||
m_hArmor = gHUD.GetSprite( m_iArmorSpriteIndex );
|
||||
|
||||
m_iHealthSpriteIndex = gHUD.GetSpriteIndex( "health_bar" );
|
||||
m_hHealth = gHUD.GetSprite( m_iHealthSpriteIndex );
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void CHudStatusBar :: Reset( void )
|
||||
{
|
||||
m_iFlags &= ~HUD_ACTIVE; // start out inactive
|
||||
for ( int i = 0; i < MAX_STATUSBAR_LINES; i++ )
|
||||
m_szStatusText[i][0] = 0;
|
||||
memset( m_iStatusValues, 0, sizeof m_iStatusValues );
|
||||
|
||||
m_iStatusValues[0] = 1; // 0 is the special index, which always returns true
|
||||
}
|
||||
|
||||
void CHudStatusBar :: ParseStatusString( int line_num )
|
||||
{
|
||||
int indexval;
|
||||
|
||||
indexval = m_iStatusValues[ 1 ];
|
||||
|
||||
GetPlayerInfo( indexval, &g_PlayerInfoList[indexval] );
|
||||
|
||||
if ( g_PlayerInfoList[indexval].name != NULL )
|
||||
{
|
||||
strncpy( m_szName[line_num], g_PlayerInfoList[indexval].name, MAX_PLAYER_NAME_LENGTH );
|
||||
}
|
||||
else
|
||||
{
|
||||
strncpy( m_szName[line_num], "******", MAX_PLAYER_NAME_LENGTH );
|
||||
}
|
||||
|
||||
g_iNameColors = GetTeamIndex( indexval );
|
||||
|
||||
indexval = m_iStatusValues[ 2 ];
|
||||
sprintf( m_szHealth[ line_num ], ":%d", indexval );
|
||||
|
||||
indexval = m_iStatusValues[ 3 ];
|
||||
sprintf( m_szArmor[ line_num ], ":%d", indexval );
|
||||
|
||||
m_iTeamMate[ line_num ] = m_iStatusValues[ 5 ];
|
||||
}
|
||||
|
||||
int CHudStatusBar :: Draw( float fTime )
|
||||
{
|
||||
int r , g, b, a, name_r, name_g, name_b;
|
||||
|
||||
if ( m_bReparseString )
|
||||
{
|
||||
for ( int i = 0; i < MAX_STATUSBAR_LINES; i++ )
|
||||
ParseStatusString( i );
|
||||
m_bReparseString = FALSE;
|
||||
}
|
||||
|
||||
//Not Watching anyone
|
||||
if ( m_iStatusValues[ 1 ] == 0 )
|
||||
{
|
||||
m_iFlags &= ~HUD_ACTIVE;
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Draw the status bar lines
|
||||
for ( int i = 0; i < MAX_STATUSBAR_LINES; i++ )
|
||||
{
|
||||
int TextHeight = 0;
|
||||
int TotalTextWidth = 0;
|
||||
|
||||
//Ugly way to get
|
||||
if ( m_iTeamMate[i] )
|
||||
{
|
||||
TotalTextWidth += gHUD.ReturnStringPixelLength ( m_szName[i] );
|
||||
TotalTextWidth += gHUD.ReturnStringPixelLength ( m_szHealth[i] );
|
||||
TotalTextWidth += gHUD.ReturnStringPixelLength ( m_szArmor[i] );
|
||||
TotalTextWidth += 48;
|
||||
TextHeight = gHUD.m_scrinfo.iCharHeight;
|
||||
}
|
||||
else
|
||||
TotalTextWidth += gHUD.ReturnStringPixelLength ( m_szName[i] );
|
||||
|
||||
TextHeight = gHUD.m_scrinfo.iCharHeight;
|
||||
|
||||
if ( g_iNameColors == 1 )
|
||||
{
|
||||
name_r = 255;
|
||||
name_g = 50;
|
||||
name_b = 50;
|
||||
}
|
||||
else if ( g_iNameColors == 2 )
|
||||
{
|
||||
name_r = 50;
|
||||
name_g = 50;
|
||||
name_b = 255;
|
||||
}
|
||||
else
|
||||
name_r = name_g = name_b = 255;
|
||||
|
||||
int Y_START;
|
||||
if ( ScreenHeight >= 480 )
|
||||
Y_START = ScreenHeight - 55;
|
||||
else
|
||||
Y_START = ScreenHeight - 45;
|
||||
|
||||
int x = gHUD.m_Ammo.m_iNumberXPosition;
|
||||
int y = Y_START; // = ( ScreenHeight / 2 ) + ( TextHeight * 3 );
|
||||
|
||||
int x_offset;
|
||||
a = 200;
|
||||
|
||||
UnpackRGB( r, g, b, RGB_NORMAL);
|
||||
ScaleColors( r, g, b, a );
|
||||
ScaleColors( name_r, name_g, name_b, 125 );
|
||||
|
||||
//Draw the name First
|
||||
gHUD.DrawHudString( x, y, 1024, m_szName[i], name_r, name_g, name_b );
|
||||
|
||||
if ( !m_iTeamMate[i] )
|
||||
continue;
|
||||
|
||||
//Get the length in pixels for the name
|
||||
x_offset = gHUD.ReturnStringPixelLength ( m_szName[i] );
|
||||
|
||||
//Add the offset
|
||||
x += ( x_offset + 8 );
|
||||
|
||||
//Now draw the Sprite for the health
|
||||
SPR_Set( m_hHealth, r, g, b );
|
||||
SPR_DrawHoles( 0, x , y, &gHUD.GetSpriteRect( m_iHealthSpriteIndex ) );
|
||||
|
||||
//Add the sprite width size
|
||||
x += 16;
|
||||
|
||||
//Draw the health value ( x + offset for the name lenght + width of the sprite )
|
||||
gHUD.DrawHudString( x, y, 1024, m_szHealth[i], name_r, name_g, name_b );
|
||||
|
||||
//Get the length in pixels for the health
|
||||
x_offset = gHUD.ReturnStringPixelLength ( m_szHealth[i] );
|
||||
|
||||
//Add the offset
|
||||
x += ( x_offset + 8 );
|
||||
|
||||
//Now draw the Sprite for the Armor
|
||||
SPR_Set( m_hArmor, r, g, b );
|
||||
SPR_DrawHoles( 0, x, y, &gHUD.GetSpriteRect( m_iArmorSpriteIndex ) );
|
||||
|
||||
x += 16;
|
||||
|
||||
//Draw the armor value ( x + offset for the name lenght + width of the sprite )
|
||||
gHUD.DrawHudString( x, y, 1024, m_szArmor[i], name_r, name_g, name_b );
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Message handler for StatusText message
|
||||
// accepts two values:
|
||||
// byte: line number of status bar text
|
||||
// string: status bar text
|
||||
// this string describes how the status bar should be drawn
|
||||
// a semi-regular expression:
|
||||
// ( slotnum ([a..z] [%pX] [%iX])*)*
|
||||
// where slotnum is an index into the Value table (see below)
|
||||
// if slotnum is 0, the string is always drawn
|
||||
// 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 )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
int line = READ_BYTE();
|
||||
|
||||
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)
|
||||
|
||||
if ( m_szStatusText[0] == 0 )
|
||||
m_iFlags &= ~HUD_ACTIVE;
|
||||
else
|
||||
m_iFlags |= HUD_ACTIVE; // we have status text, so turn on the status bar
|
||||
|
||||
m_bReparseString = TRUE;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Message handler for StatusText message
|
||||
// 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 )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
int index = READ_BYTE();
|
||||
if ( index < 1 || index >= MAX_STATUSBAR_VALUES )
|
||||
return 1; // index out of range
|
||||
|
||||
m_iStatusValues[index] = READ_SHORT();
|
||||
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
|
||||
m_bReparseString = TRUE;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -1,251 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#include <memory.h>
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "const.h"
|
||||
#include "com_model.h"
|
||||
#include "studio_util.h"
|
||||
|
||||
/*
|
||||
====================
|
||||
AngleMatrix
|
||||
|
||||
====================
|
||||
*/
|
||||
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);
|
||||
|
||||
// matrix = (YAW * PITCH) * ROLL
|
||||
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][3] = 0.0;
|
||||
matrix[1][3] = 0.0;
|
||||
matrix[2][3] = 0.0;
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
VectorCompare
|
||||
|
||||
====================
|
||||
*/
|
||||
int VectorCompare (const float *v1, const float *v2)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i=0 ; i<3 ; i++)
|
||||
if (v1[i] != v2[i])
|
||||
return 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
CrossProduct
|
||||
|
||||
====================
|
||||
*/
|
||||
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];
|
||||
cross[2] = v1[0]*v2[1] - v1[1]*v2[0];
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
VectorTransform
|
||||
|
||||
====================
|
||||
*/
|
||||
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];
|
||||
out[2] = DotProduct(in1, in2[2]) + in2[2][3];
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
ConcatTransforms
|
||||
|
||||
================
|
||||
*/
|
||||
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];
|
||||
out[0][1] = in1[0][0] * in2[0][1] + in1[0][1] * in2[1][1] +
|
||||
in1[0][2] * in2[2][1];
|
||||
out[0][2] = in1[0][0] * in2[0][2] + in1[0][1] * in2[1][2] +
|
||||
in1[0][2] * in2[2][2];
|
||||
out[0][3] = in1[0][0] * in2[0][3] + in1[0][1] * in2[1][3] +
|
||||
in1[0][2] * in2[2][3] + in1[0][3];
|
||||
out[1][0] = in1[1][0] * in2[0][0] + in1[1][1] * in2[1][0] +
|
||||
in1[1][2] * in2[2][0];
|
||||
out[1][1] = in1[1][0] * in2[0][1] + in1[1][1] * in2[1][1] +
|
||||
in1[1][2] * in2[2][1];
|
||||
out[1][2] = in1[1][0] * in2[0][2] + in1[1][1] * in2[1][2] +
|
||||
in1[1][2] * in2[2][2];
|
||||
out[1][3] = in1[1][0] * in2[0][3] + in1[1][1] * in2[1][3] +
|
||||
in1[1][2] * in2[2][3] + in1[1][3];
|
||||
out[2][0] = in1[2][0] * in2[0][0] + in1[2][1] * in2[1][0] +
|
||||
in1[2][2] * in2[2][0];
|
||||
out[2][1] = in1[2][0] * in2[0][1] + in1[2][1] * in2[1][1] +
|
||||
in1[2][2] * in2[2][1];
|
||||
out[2][2] = in1[2][0] * in2[0][2] + in1[2][1] * in2[1][2] +
|
||||
in1[2][2] * in2[2][2];
|
||||
out[2][3] = in1[2][0] * in2[0][3] + in1[2][1] * in2[1][3] +
|
||||
in1[2][2] * in2[2][3] + in1[2][3];
|
||||
}
|
||||
|
||||
// angles index are not the same as ROLL, PITCH, YAW
|
||||
|
||||
/*
|
||||
====================
|
||||
AngleQuaternion
|
||||
|
||||
====================
|
||||
*/
|
||||
void AngleQuaternion( float *angles, vec4_t quaternion )
|
||||
{
|
||||
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);
|
||||
angle = angles[1] * 0.5;
|
||||
sp = sin(angle);
|
||||
cp = cos(angle);
|
||||
angle = angles[0] * 0.5;
|
||||
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
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
QuaternionSlerp
|
||||
|
||||
====================
|
||||
*/
|
||||
void QuaternionSlerp( vec4_t p, vec4_t q, float t, vec4_t qt )
|
||||
{
|
||||
int i;
|
||||
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++)
|
||||
{
|
||||
a += (p[i]-q[i])*(p[i]-q[i]);
|
||||
b += (p[i]+q[i])*(p[i]+q[i]);
|
||||
}
|
||||
if (a > b)
|
||||
{
|
||||
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];
|
||||
|
||||
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;
|
||||
}
|
||||
else
|
||||
{
|
||||
sclp = 1.0 - t;
|
||||
sclq = t;
|
||||
}
|
||||
for (i = 0; i < 4; i++) {
|
||||
qt[i] = sclp * p[i] + sclq * q[i];
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
qt[0] = -q[1];
|
||||
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++)
|
||||
{
|
||||
qt[i] = sclp * p[i] + sclq * qt[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
QuaternionMatrix
|
||||
|
||||
====================
|
||||
*/
|
||||
void QuaternionMatrix( vec4_t quaternion, float (*matrix)[4] )
|
||||
{
|
||||
matrix[0][0] = 1.0 - 2.0 * quaternion[1] * quaternion[1] - 2.0 * quaternion[2] * quaternion[2];
|
||||
matrix[1][0] = 2.0 * quaternion[0] * quaternion[1] + 2.0 * quaternion[3] * quaternion[2];
|
||||
matrix[2][0] = 2.0 * quaternion[0] * quaternion[2] - 2.0 * quaternion[3] * quaternion[1];
|
||||
|
||||
matrix[0][1] = 2.0 * quaternion[0] * quaternion[1] - 2.0 * quaternion[3] * quaternion[2];
|
||||
matrix[1][1] = 1.0 - 2.0 * quaternion[0] * quaternion[0] - 2.0 * quaternion[2] * quaternion[2];
|
||||
matrix[2][1] = 2.0 * quaternion[1] * quaternion[2] + 2.0 * quaternion[3] * quaternion[0];
|
||||
|
||||
matrix[0][2] = 2.0 * quaternion[0] * quaternion[2] + 2.0 * quaternion[3] * quaternion[1];
|
||||
matrix[1][2] = 2.0 * quaternion[1] * quaternion[2] - 2.0 * quaternion[3] * quaternion[0];
|
||||
matrix[2][2] = 1.0 - 2.0 * quaternion[0] * quaternion[0] - 2.0 * quaternion[1] * quaternion[1];
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
MatrixCopy
|
||||
|
||||
====================
|
||||
*/
|
||||
void MatrixCopy( float in[3][4], float out[3][4] )
|
||||
{
|
||||
memcpy( out, in, sizeof( float ) * 3 * 4 );
|
||||
}
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#if !defined( STUDIO_UTIL_H )
|
||||
#define STUDIO_UTIL_H
|
||||
#if defined( WIN32 )
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#ifndef M_PI
|
||||
#define M_PI 3.14159265358979323846 // matches value in gcc v2 math.h
|
||||
#endif
|
||||
|
||||
#ifndef PITCH
|
||||
// MOVEMENT INFO
|
||||
// up / down
|
||||
#define PITCH 0
|
||||
// left / right
|
||||
#define YAW 1
|
||||
// fall over
|
||||
#define ROLL 2
|
||||
#endif
|
||||
|
||||
#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 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
|
||||
|
|
@ -1,208 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// text_message.cpp
|
||||
//
|
||||
// implementation of CHudTextMessage class
|
||||
//
|
||||
// this class routes messages through titles.txt for localisation
|
||||
//
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include "parsemsg.h"
|
||||
|
||||
DECLARE_MESSAGE( m_TextMessage, TextMsg );
|
||||
|
||||
int CHudTextMessage::Init(void)
|
||||
{
|
||||
HOOK_MESSAGE( TextMsg );
|
||||
|
||||
gHUD.AddHudElem( this );
|
||||
|
||||
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
|
||||
// the new value is pushed into dst_buffer
|
||||
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-- )
|
||||
{
|
||||
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++ )
|
||||
{
|
||||
*wdst = *src;
|
||||
}
|
||||
*wdst = 0;
|
||||
|
||||
// lookup msg name in titles.txt
|
||||
client_textmessage_t *clmsg = TextMessageGet( word_buf );
|
||||
if ( !clmsg || !(clmsg->pMessage) )
|
||||
{
|
||||
src = word_start;
|
||||
*dst = *src;
|
||||
dst++, src++;
|
||||
continue;
|
||||
}
|
||||
|
||||
// copy string into message over the msg name
|
||||
for ( char *wsrc = (char*)clmsg->pMessage; *wsrc != 0; wsrc++, dst++ )
|
||||
{
|
||||
*dst = *wsrc;
|
||||
}
|
||||
*dst = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
*dst = *src;
|
||||
dst++, src++;
|
||||
*dst = 0;
|
||||
}
|
||||
}
|
||||
|
||||
dst_buffer[buffer_size-1] = 0; // ensure null termination
|
||||
return dst_buffer;
|
||||
}
|
||||
|
||||
// As above, but with a local static buffer
|
||||
char *CHudTextMessage::BufferedLocaliseTextString( const char *msg )
|
||||
{
|
||||
static char dst_buffer[1024];
|
||||
return LocaliseTextString( msg, dst_buffer, 1024 );
|
||||
}
|
||||
|
||||
// Simplified version of LocaliseTextString; assumes string is only one word
|
||||
char *CHudTextMessage::LookupString( const char *msg, int *msg_dest )
|
||||
{
|
||||
if ( !msg )
|
||||
return "";
|
||||
|
||||
// '#' character indicates this is a reference to a string in titles.txt, and not the string itself
|
||||
if ( msg[0] == '#' )
|
||||
{
|
||||
// this is a message name, so look up the real message
|
||||
client_textmessage_t *clmsg = TextMessageGet( msg+1 );
|
||||
|
||||
if ( !clmsg || !(clmsg->pMessage) )
|
||||
return (char*)msg; // lookup failed, so return the original string
|
||||
|
||||
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 ) //
|
||||
*msg_dest = -clmsg->effect;
|
||||
}
|
||||
|
||||
return (char*)clmsg->pMessage;
|
||||
}
|
||||
else
|
||||
{ // nothing special about this message, so just return the same string
|
||||
return (char*)msg;
|
||||
}
|
||||
}
|
||||
|
||||
void StripEndNewlineFromString( char *str )
|
||||
{
|
||||
int s = strlen( str ) - 1;
|
||||
if ( str[s] == '\n' || str[s] == '\r' )
|
||||
str[s] = 0;
|
||||
}
|
||||
|
||||
// converts all '\r' characters to '\n', so that the engine can deal with the properly
|
||||
// returns a pointer to str
|
||||
char* ConvertCRtoNL( char *str )
|
||||
{
|
||||
for ( char *ch = str; *ch != 0; ch++ )
|
||||
if ( *ch == '\r' )
|
||||
*ch = '\n';
|
||||
return str;
|
||||
}
|
||||
|
||||
// Message handler for text messages
|
||||
// displays a string, looking them up from the titles.txt file, which can be localised
|
||||
// parameters:
|
||||
// byte: message direction ( HUD_PRINTCONSOLE, HUD_PRINTNOTIFY, HUD_PRINTCENTER, HUD_PRINTTALK )
|
||||
// string: message
|
||||
// optional parameters:
|
||||
// string: message parameter 1
|
||||
// string: message parameter 2
|
||||
// string: message parameter 3
|
||||
// string: message parameter 4
|
||||
// any string that starts with the character '#' is a message name, and is used to look up the real message in titles.txt
|
||||
// the next (optional) one to four strings are parameters for that string (which can also be message names if they begin with '#')
|
||||
int CHudTextMessage::MsgFunc_TextMsg( const char *pszName, int iSize, void *pbuf )
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
int msg_dest = READ_BYTE();
|
||||
|
||||
#define MSG_BUF_SIZE 128
|
||||
static char szBuf[6][MSG_BUF_SIZE];
|
||||
char *msg_text = LookupString( READ_STRING(), &msg_dest );
|
||||
msg_text = safe_strcpy( szBuf[0], msg_text, MSG_BUF_SIZE );
|
||||
|
||||
// keep reading strings and using C format strings for subsituting the strings into the localised text string
|
||||
char *sstr1 = LookupString( READ_STRING() );
|
||||
sstr1 = safe_strcpy( szBuf[1], sstr1 , MSG_BUF_SIZE );
|
||||
StripEndNewlineFromString( sstr1 ); // these strings are meant for subsitution into the main strings, so cull the automatic end newlines
|
||||
char *sstr2 = LookupString( READ_STRING() );
|
||||
sstr2 = safe_strcpy( szBuf[2], sstr2 , MSG_BUF_SIZE );
|
||||
StripEndNewlineFromString( sstr2 );
|
||||
char *sstr3 = LookupString( READ_STRING() );
|
||||
sstr3 = safe_strcpy( szBuf[3], sstr3 , MSG_BUF_SIZE );
|
||||
StripEndNewlineFromString( sstr3 );
|
||||
char *sstr4 = LookupString( READ_STRING() );
|
||||
sstr4 = safe_strcpy( szBuf[4], sstr4 , MSG_BUF_SIZE );
|
||||
StripEndNewlineFromString( sstr4 );
|
||||
char *psz = szBuf[5];
|
||||
|
||||
switch ( msg_dest )
|
||||
{
|
||||
case HUD_PRINTCENTER:
|
||||
safe_sprintf( psz, MSG_BUF_SIZE, 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
|
||||
safe_sprintf( psz+1, MSG_BUF_SIZE, msg_text, sstr1, sstr2, sstr3, sstr4 );
|
||||
ConsolePrint( ConvertCRtoNL( psz ) );
|
||||
break;
|
||||
|
||||
case HUD_PRINTTALK:
|
||||
safe_sprintf( psz, MSG_BUF_SIZE, msg_text, sstr1, sstr2, sstr3, sstr4 );
|
||||
gHUD.m_SayText.SayTextPrint( ConvertCRtoNL( psz ), 128 );
|
||||
break;
|
||||
|
||||
case HUD_PRINTCONSOLE:
|
||||
safe_sprintf( psz, MSG_BUF_SIZE, msg_text, sstr1, sstr2, sstr3, sstr4 );
|
||||
ConsolePrint( ConvertCRtoNL( psz ) );
|
||||
break;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -1,85 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// Train.cpp
|
||||
//
|
||||
// implementation of CHudAmmo class
|
||||
//
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include "parsemsg.h"
|
||||
|
||||
DECLARE_MESSAGE(m_Train, Train )
|
||||
|
||||
|
||||
int CHudTrain::Init(void)
|
||||
{
|
||||
HOOK_MESSAGE( Train );
|
||||
|
||||
m_iPos = 0;
|
||||
m_iFlags = 0;
|
||||
gHUD.AddHudElem(this);
|
||||
|
||||
return 1;
|
||||
};
|
||||
|
||||
int CHudTrain::VidInit(void)
|
||||
{
|
||||
m_hSprite = 0;
|
||||
|
||||
return 1;
|
||||
};
|
||||
|
||||
int CHudTrain::Draw(float fTime)
|
||||
{
|
||||
if ( !m_hSprite )
|
||||
m_hSprite = LoadSprite("sprites/%d_train.spr");
|
||||
|
||||
if (m_iPos)
|
||||
{
|
||||
int r, g, b, x, y;
|
||||
|
||||
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);
|
||||
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
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)
|
||||
m_iFlags |= HUD_ACTIVE;
|
||||
else
|
||||
m_iFlags &= ~HUD_ACTIVE;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -1,129 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
// Triangle rendering, if any
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
|
||||
// Triangle rendering apis are in gEngfuncs.pTriAPI
|
||||
|
||||
#include "const.h"
|
||||
#include "entity_state.h"
|
||||
#include "cl_entity.h"
|
||||
#include "triangleapi.h"
|
||||
|
||||
extern "C"
|
||||
{
|
||||
void EXPORT HUD_DrawNormalTriangles( void );
|
||||
void EXPORT HUD_DrawTransparentTriangles( void );
|
||||
};
|
||||
|
||||
extern float g_iFogColor[3];
|
||||
extern float g_iStartDist;
|
||||
extern float g_iEndDist;
|
||||
extern int g_iWaterLevel;
|
||||
|
||||
//#define TEST_IT
|
||||
#if defined( TEST_IT )
|
||||
|
||||
/*
|
||||
=================
|
||||
Draw_Triangles
|
||||
|
||||
Example routine. Draws a sprite offset from the player origin.
|
||||
=================
|
||||
*/
|
||||
void Draw_Triangles( void )
|
||||
{
|
||||
cl_entity_t *player;
|
||||
vec3_t org;
|
||||
|
||||
// Load it up with some bogus data
|
||||
player = gEngfuncs.GetLocalPlayer();
|
||||
if ( !player )
|
||||
return;
|
||||
|
||||
org = player->origin;
|
||||
|
||||
org.x += 50;
|
||||
org.y += 50;
|
||||
|
||||
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 ))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Create a triangle, sigh
|
||||
gEngfuncs.pTriAPI->RenderMode( kRenderNormal );
|
||||
gEngfuncs.pTriAPI->CullFace( TRI_NONE );
|
||||
gEngfuncs.pTriAPI->Begin( TRI_QUADS );
|
||||
// Overload p->color with index into tracer palette, p->packedColor with brightness
|
||||
gEngfuncs.pTriAPI->Color4f( 1.0, 1.0, 1.0, 1.0 );
|
||||
// UNDONE: This gouraud shading causes tracers to disappear on some cards (permedia2)
|
||||
gEngfuncs.pTriAPI->Brightness( 1 );
|
||||
gEngfuncs.pTriAPI->TexCoord2f( 0, 0 );
|
||||
gEngfuncs.pTriAPI->Vertex3f( org.x, org.y, org.z );
|
||||
|
||||
gEngfuncs.pTriAPI->Brightness( 1 );
|
||||
gEngfuncs.pTriAPI->TexCoord2f( 0, 1 );
|
||||
gEngfuncs.pTriAPI->Vertex3f( org.x, org.y + 50, org.z );
|
||||
|
||||
gEngfuncs.pTriAPI->Brightness( 1 );
|
||||
gEngfuncs.pTriAPI->TexCoord2f( 1, 1 );
|
||||
gEngfuncs.pTriAPI->Vertex3f( org.x + 50, org.y + 50, org.z );
|
||||
|
||||
gEngfuncs.pTriAPI->Brightness( 1 );
|
||||
gEngfuncs.pTriAPI->TexCoord2f( 1, 0 );
|
||||
gEngfuncs.pTriAPI->Vertex3f( org.x + 50, org.y, org.z );
|
||||
|
||||
gEngfuncs.pTriAPI->End();
|
||||
gEngfuncs.pTriAPI->RenderMode( kRenderNormal );
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//Render fog ( duh ).
|
||||
void RenderFog ( void )
|
||||
{
|
||||
//Not in water and we want fog.
|
||||
bool bFog = g_iWaterLevel < 2 && g_iStartDist >= 0 && g_iEndDist >= 0;
|
||||
gEngfuncs.pTriAPI->Fog ( g_iFogColor, g_iStartDist, g_iEndDist, bFog );
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
=================
|
||||
HUD_DrawNormalTriangles
|
||||
|
||||
Non-transparent triangles-- add them here
|
||||
=================
|
||||
*/
|
||||
void EXPORT HUD_DrawNormalTriangles( void )
|
||||
{
|
||||
gHUD.m_Spectator.DrawOverview();
|
||||
}
|
||||
|
||||
/*
|
||||
=================
|
||||
HUD_DrawTransparentTriangles
|
||||
|
||||
Render any triangles with transparent rendermode needs here
|
||||
=================
|
||||
*/
|
||||
void EXPORT HUD_DrawTransparentTriangles( void )
|
||||
{
|
||||
|
||||
RenderFog();
|
||||
}
|
||||
|
|
@ -1,134 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// util.cpp
|
||||
//
|
||||
// implementation of class-less helper functions
|
||||
//
|
||||
|
||||
#include "stdio.h"
|
||||
#include "stdlib.h"
|
||||
#include "math.h"
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include <string.h>
|
||||
|
||||
#ifndef M_PI
|
||||
#define M_PI 3.14159265358979323846 // matches value in gcc v2 math.h
|
||||
#endif
|
||||
|
||||
vec3_t vec3_origin( 0, 0, 0 );
|
||||
|
||||
double sqrt(double x);
|
||||
|
||||
float Length(const float *v)
|
||||
{
|
||||
int i;
|
||||
float length;
|
||||
|
||||
length = 0;
|
||||
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)
|
||||
{
|
||||
yaw = 0;
|
||||
if (forward[2] > 0)
|
||||
pitch = 90;
|
||||
else
|
||||
pitch = 270;
|
||||
}
|
||||
else
|
||||
{
|
||||
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)
|
||||
pitch += 360;
|
||||
}
|
||||
|
||||
angles[0] = pitch;
|
||||
angles[1] = yaw;
|
||||
angles[2] = 0;
|
||||
}
|
||||
|
||||
float VectorNormalize (float *v)
|
||||
{
|
||||
float length, ilength;
|
||||
|
||||
length = v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
|
||||
length = sqrt (length); // FIXME
|
||||
|
||||
if (length)
|
||||
{
|
||||
ilength = 1/length;
|
||||
v[0] *= ilength;
|
||||
v[1] *= ilength;
|
||||
v[2] *= ilength;
|
||||
}
|
||||
|
||||
return length;
|
||||
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
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)
|
||||
{
|
||||
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)
|
||||
{
|
||||
int i;
|
||||
char sz[256];
|
||||
|
||||
if (ScreenWidth < 640)
|
||||
i = 320;
|
||||
else
|
||||
i = 640;
|
||||
|
||||
sprintf(sz, pszName, i);
|
||||
|
||||
return SPR_Load(sz);
|
||||
}
|
||||
|
||||
|
|
@ -1,152 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
//
|
||||
// util.h
|
||||
//
|
||||
|
||||
#include "cvardef.h"
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE 1
|
||||
#define FALSE 0
|
||||
#endif
|
||||
|
||||
// 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_COMMAND(x, y) gEngfuncs.pfnAddCommand( x, __CmdFunc_##y );
|
||||
#define DECLARE_COMMAND(y, x) void __CmdFunc_##x( void ) \
|
||||
{ \
|
||||
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)
|
||||
|
||||
// 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)
|
||||
// SPR_DrawAdditive adds the sprites RGB values to the background (additive transulency)
|
||||
#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_DisableScissor disables the clipping rect
|
||||
#define SPR_DisableScissor (*gEngfuncs.pfnSPR_DisableScissor)
|
||||
//
|
||||
#define FillRGBA (*gEngfuncs.pfnFillRGBA)
|
||||
|
||||
|
||||
// ScreenHeight returns the height of the screen, in pixels
|
||||
#define ScreenHeight (gHUD.m_scrinfo.iHeight)
|
||||
// ScreenWidth returns the width of the screen, in pixels
|
||||
#define ScreenWidth (gHUD.m_scrinfo.iWidth)
|
||||
|
||||
#define GetScreenInfo (*gEngfuncs.pfnGetScreenInfo)
|
||||
#define ServerCmd (*gEngfuncs.pfnServerCmd)
|
||||
#define ClientCmd (*gEngfuncs.pfnClientCmd)
|
||||
#define SetCrosshair (*gEngfuncs.pfnSetCrosshair)
|
||||
#define AngleVectors (*gEngfuncs.pfnAngleVectors)
|
||||
|
||||
|
||||
// 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); }
|
||||
|
||||
inline client_textmessage_t *TextMessageGet( const char *pName ) { return gEngfuncs.pfnTextMessageGet( pName ); }
|
||||
inline int TextMessageDrawChar( int x, int y, int number, int r, int g, int b )
|
||||
{
|
||||
return gEngfuncs.pfnDrawCharacter( x, y, number, r, g, b );
|
||||
}
|
||||
|
||||
inline int DrawConsoleString( int x, int y, const char *string )
|
||||
{
|
||||
return gEngfuncs.pfnDrawConsoleString( x, y, (char*) string );
|
||||
}
|
||||
|
||||
inline void GetConsoleStringSize( const char *string, int *width, int *height )
|
||||
{
|
||||
gEngfuncs.pfnDrawConsoleStringLen( string, width, height );
|
||||
}
|
||||
|
||||
inline int ConsoleStringLen( const char *string )
|
||||
{
|
||||
int _width, _height;
|
||||
GetConsoleStringSize( string, &_width, &_height );
|
||||
return _width;
|
||||
}
|
||||
|
||||
inline void ConsolePrint( const char *string )
|
||||
{
|
||||
gEngfuncs.pfnConsolePrint( string );
|
||||
}
|
||||
|
||||
inline void CenterPrint( const char *string )
|
||||
{
|
||||
gEngfuncs.pfnCenterPrint( string );
|
||||
}
|
||||
|
||||
// returns the players name of entity no.
|
||||
#define GetPlayerInfo (*gEngfuncs.pfnGetPlayerInfo)
|
||||
|
||||
// sound functions
|
||||
inline void PlaySound( char *szSound, float vol ) { gEngfuncs.pfnPlaySoundByName( szSound, vol ); }
|
||||
inline void PlaySound( int iSound, float vol ) { gEngfuncs.pfnPlaySoundByIndex( iSound, vol ); }
|
||||
|
||||
#define max(a, b) (((a) > (b)) ? (a) : (b))
|
||||
#define min(a, b) (((a) < (b)) ? (a) : (b))
|
||||
#define fabs(x) ((x) > 0 ? (x) : 0 - (x))
|
||||
|
||||
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];}
|
||||
#define VectorClear(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;
|
||||
|
||||
// disable 'possible loss of data converting float to int' warning message
|
||||
#pragma warning( disable: 4244 )
|
||||
// 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)\
|
||||
{\
|
||||
r = (ulRGB & 0xFF0000) >>16;\
|
||||
g = (ulRGB & 0xFF00) >> 8;\
|
||||
b = ulRGB & 0xFF;\
|
||||
}
|
||||
|
||||
HSPRITE LoadSprite(const char *pszName);
|
||||
|
|
@ -1,121 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
// Vector.h
|
||||
// A subset of the extdll.h in the project HL Entity DLL
|
||||
//
|
||||
|
||||
// Misc C-runtime library headers
|
||||
#include "stdio.h"
|
||||
#include "stdlib.h"
|
||||
#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 float vec_t; // needed before including progdefs.h
|
||||
|
||||
//=========================================================
|
||||
// 2DVector - used for many pathfinding and many other
|
||||
// operations that are treated as planar rather than 3d.
|
||||
//=========================================================
|
||||
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 Normalize ( void ) const
|
||||
{
|
||||
Vector2D vec2;
|
||||
|
||||
float flLen = Length();
|
||||
if ( flLen == 0 )
|
||||
{
|
||||
return Vector2D( (float)0, (float)0 );
|
||||
}
|
||||
else
|
||||
{
|
||||
flLen = 1 / flLen;
|
||||
return Vector2D( x * flLen, y * flLen );
|
||||
}
|
||||
}
|
||||
|
||||
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; }
|
||||
|
||||
//=========================================================
|
||||
// 3D Vector
|
||||
//=========================================================
|
||||
class Vector // same data-layout as engine's vec3_t,
|
||||
{ // 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]; }
|
||||
|
||||
// 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); }
|
||||
|
||||
// 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
|
||||
{
|
||||
float flLen = Length();
|
||||
if (flLen == 0) return Vector(0,0,1); // ????
|
||||
flLen = 1 / flLen;
|
||||
return Vector(x * flLen, y * flLen, z * flLen);
|
||||
}
|
||||
|
||||
inline Vector2D Make2D ( void ) const
|
||||
{
|
||||
Vector2D Vec2;
|
||||
|
||||
Vec2.x = x;
|
||||
Vec2.y = y;
|
||||
|
||||
return Vec2;
|
||||
}
|
||||
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 ); }
|
||||
|
||||
#define vec3_t Vector
|
||||
|
|
@ -1,47 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#ifndef CONTROLCONFIGPANEL_H
|
||||
#define CONTROLCONFIGPANEL_H
|
||||
|
||||
#include<VGUI_Panel.h>
|
||||
#include<VGUI_Dar.h>
|
||||
|
||||
namespace vgui
|
||||
{
|
||||
class HeaderPanel;
|
||||
class TablePanel;
|
||||
class ScrollPanel;
|
||||
class InputStream;
|
||||
class Label;
|
||||
}
|
||||
|
||||
class ControlConfigPanel : public vgui::Panel
|
||||
{
|
||||
private:
|
||||
vgui::HeaderPanel* _headerPanel;
|
||||
vgui::TablePanel* _tablePanel;
|
||||
vgui::ScrollPanel* _scrollPanel;
|
||||
vgui::Dar<char*> _cvarDar;
|
||||
vgui::Dar<char*> _descDar;
|
||||
vgui::Label* _actionLabel;
|
||||
vgui::Label* _keyButtonLabel;
|
||||
vgui::Label* _alternateLabel;
|
||||
public:
|
||||
ControlConfigPanel(int x,int y,int wide,int tall);
|
||||
public:
|
||||
void AddCVar(const char* cvar,const char* desc);
|
||||
void AddCVarFromInputStream(vgui::InputStream* is);
|
||||
int GetCVarCount();
|
||||
void GetCVar(int index,char* cvar,int cvarLen,char* desc,int descLen);
|
||||
void GetCVarBind(const char* cvar,char* bind,int bindLen,char* bindAlt,int bindAltLen);
|
||||
void SetCVarBind(const char* cvar,const char* bind,const char* bindAlt);
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
|
|
@ -1,428 +0,0 @@
|
|||
//=========== (C) Copyright 1996-2002 Valve, L.L.C. All rights reserved. ===========
|
||||
//
|
||||
// The copyright to the contents herein is the property of Valve, L.L.C.
|
||||
// The contents may be used and/or copied only with the written permission of
|
||||
// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
|
||||
// the agreement/contract under which the contents have been supplied.
|
||||
//
|
||||
// Purpose: Contains implementation of various VGUI-derived objects
|
||||
//
|
||||
// $Workfile: $
|
||||
// $Date: $
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
// $Log: $
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#include "VGUI_Font.h"
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "camera.h"
|
||||
#include "kbutton.h"
|
||||
#include "cvardef.h"
|
||||
#include "usercmd.h"
|
||||
#include "const.h"
|
||||
#include "camera.h"
|
||||
#include "in_defs.h"
|
||||
#include "parsemsg.h"
|
||||
|
||||
#include "vgui_int.h"
|
||||
#include "vgui_viewport.h"
|
||||
#include "vgui_ServerBrowser.h"
|
||||
#include "VGUI_BitmapTGA.h"
|
||||
|
||||
|
||||
// Arrow filenames
|
||||
char *sArrowFilenames[] =
|
||||
{
|
||||
"arrowup",
|
||||
"arrowdn",
|
||||
"arrowlt",
|
||||
"arrowrt",
|
||||
};
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Loads a .tga file and returns a pointer to the VGUI tga object
|
||||
//-----------------------------------------------------------------------------
|
||||
BitmapTGA *LoadTGA( const char* pImageName )
|
||||
{
|
||||
BitmapTGA *pTGA;
|
||||
|
||||
char sz[256];
|
||||
sprintf(sz, "%%d_%s", pImageName);
|
||||
|
||||
// Load the Image
|
||||
FileInputStream* fis = new FileInputStream( GetVGUITGAName(sz), false );
|
||||
pTGA = new BitmapTGA(fis,true);
|
||||
fis->close();
|
||||
|
||||
return pTGA;
|
||||
}
|
||||
|
||||
//===========================================================
|
||||
// All TFC Hud buttons are derived from this one.
|
||||
CommandButton::CommandButton( const char* text,int x,int y,int wide,int tall, bool bNoHighlight) : Button("",x,y,wide,tall)
|
||||
{
|
||||
m_iPlayerClass = 0;
|
||||
m_bNoHighlight = bNoHighlight;
|
||||
Init();
|
||||
setText( text );
|
||||
}
|
||||
|
||||
CommandButton::CommandButton( int iPlayerClass, const char* text,int x,int y,int wide,int tall) : Button("",x,y,wide,tall)
|
||||
{
|
||||
m_iPlayerClass = iPlayerClass;
|
||||
m_bNoHighlight = false;
|
||||
Init();
|
||||
setText( text );
|
||||
}
|
||||
|
||||
void CommandButton::Init( void )
|
||||
{
|
||||
m_pSubMenu = NULL;
|
||||
m_pSubLabel = NULL;
|
||||
m_pParentMenu = NULL;
|
||||
|
||||
// Set text color to orange
|
||||
setFgColor(Scheme::sc_primary1);
|
||||
|
||||
// left align
|
||||
setContentAlignment( vgui::Label::a_west );
|
||||
|
||||
// Add the Highlight signal
|
||||
if (!m_bNoHighlight)
|
||||
addInputSignal( new CHandler_CommandButtonHighlight(this) );
|
||||
|
||||
// not bound to any button yet
|
||||
m_cBoundKey = 0;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Prepends the button text with the current bound key
|
||||
// if no bound key, then a clear space ' ' instead
|
||||
//-----------------------------------------------------------------------------
|
||||
void CommandButton::RecalculateText( void )
|
||||
{
|
||||
char szBuf[128];
|
||||
|
||||
if ( m_cBoundKey != 0 )
|
||||
{
|
||||
if ( m_cBoundKey == (char)255 )
|
||||
{
|
||||
strcpy( szBuf, m_sMainText );
|
||||
}
|
||||
else
|
||||
{
|
||||
sprintf( szBuf, " %c %s", m_cBoundKey, m_sMainText );
|
||||
}
|
||||
szBuf[MAX_BUTTON_SIZE-1] = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
// just draw a space if no key bound
|
||||
sprintf( szBuf, " %s", m_sMainText );
|
||||
szBuf[MAX_BUTTON_SIZE-1] = 0;
|
||||
}
|
||||
|
||||
Button::setText( szBuf );
|
||||
}
|
||||
|
||||
void CommandButton::setText( const char *text )
|
||||
{
|
||||
strncpy( m_sMainText, text, MAX_BUTTON_SIZE );
|
||||
m_sMainText[MAX_BUTTON_SIZE-1] = 0;
|
||||
|
||||
RecalculateText();
|
||||
}
|
||||
|
||||
void CommandButton::setBoundKey( char boundKey )
|
||||
{
|
||||
m_cBoundKey = boundKey;
|
||||
RecalculateText();
|
||||
}
|
||||
|
||||
char CommandButton::getBoundKey( void )
|
||||
{
|
||||
return m_cBoundKey;
|
||||
}
|
||||
|
||||
void CommandButton::AddSubMenu( CCommandMenu *pNewMenu )
|
||||
{
|
||||
m_pSubMenu = pNewMenu;
|
||||
|
||||
// Prevent this button from being pushed
|
||||
setMouseClickEnabled( MOUSE_LEFT, false );
|
||||
}
|
||||
|
||||
void CommandButton::UpdateSubMenus( int iAdjustment )
|
||||
{
|
||||
if ( m_pSubMenu )
|
||||
m_pSubMenu->RecalculatePositions( iAdjustment );
|
||||
}
|
||||
|
||||
void CommandButton::paint()
|
||||
{
|
||||
// Make the sub label paint the same as the button
|
||||
if ( m_pSubLabel )
|
||||
{
|
||||
if ( isSelected() )
|
||||
m_pSubLabel->PushDown();
|
||||
else
|
||||
m_pSubLabel->PushUp();
|
||||
}
|
||||
|
||||
// draw armed button text in white
|
||||
if ( isArmed() )
|
||||
{
|
||||
setFgColor( Scheme::sc_secondary2 );
|
||||
}
|
||||
else
|
||||
{
|
||||
setFgColor( Scheme::sc_primary1 );
|
||||
}
|
||||
|
||||
Button::paint();
|
||||
}
|
||||
|
||||
void CommandButton::paintBackground()
|
||||
{
|
||||
if ( isArmed() )
|
||||
{
|
||||
// Orange highlight background
|
||||
drawSetColor( Scheme::sc_primary2 );
|
||||
drawFilledRect(0,0,_size[0],_size[1]);
|
||||
}
|
||||
|
||||
// Orange Border
|
||||
drawSetColor( Scheme::sc_secondary1 );
|
||||
drawOutlinedRect(0,0,_size[0],_size[1]);
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Highlights the current button, and all it's parent menus
|
||||
//-----------------------------------------------------------------------------
|
||||
void CommandButton::cursorEntered( void )
|
||||
{
|
||||
// unarm all the other buttons in this menu
|
||||
CCommandMenu *containingMenu = getParentMenu();
|
||||
if ( containingMenu )
|
||||
{
|
||||
containingMenu->ClearButtonsOfArmedState();
|
||||
|
||||
// make all our higher buttons armed
|
||||
CCommandMenu *pCParent = containingMenu->GetParentMenu();
|
||||
if ( pCParent )
|
||||
{
|
||||
CommandButton *pParentButton = pCParent->FindButtonWithSubmenu( containingMenu );
|
||||
|
||||
pParentButton->cursorEntered();
|
||||
}
|
||||
}
|
||||
|
||||
// arm ourselves
|
||||
setArmed( true );
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose:
|
||||
//-----------------------------------------------------------------------------
|
||||
void CommandButton::cursorExited( void )
|
||||
{
|
||||
// only clear ourselves if we have do not have a containing menu
|
||||
// only stay armed if we have a sub menu
|
||||
// the buttons only unarm themselves when another button is armed instead
|
||||
if ( !getParentMenu() || !GetSubMenu() )
|
||||
{
|
||||
setArmed( false );
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Returns the command menu that the button is part of, if any
|
||||
// Output : CCommandMenu *
|
||||
//-----------------------------------------------------------------------------
|
||||
CCommandMenu *CommandButton::getParentMenu( void )
|
||||
{
|
||||
return m_pParentMenu;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Sets the menu that contains this button
|
||||
// Input : *pParentMenu -
|
||||
//-----------------------------------------------------------------------------
|
||||
void CommandButton::setParentMenu( CCommandMenu *pParentMenu )
|
||||
{
|
||||
m_pParentMenu = pParentMenu;
|
||||
}
|
||||
|
||||
|
||||
//===========================================================
|
||||
int ClassButton::IsNotValid()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
//===========================================================
|
||||
// Button with Class image beneath it
|
||||
CImageLabel::CImageLabel( const char* pImageName,int x,int y ) : Label( "", x,y )
|
||||
{
|
||||
setContentFitted(true);
|
||||
m_pTGA = LoadTGA(pImageName);
|
||||
setImage( m_pTGA );
|
||||
}
|
||||
|
||||
CImageLabel::CImageLabel( const char* pImageName,int x,int y,int wide,int tall ) : Label( "", x,y,wide,tall )
|
||||
{
|
||||
setContentFitted(true);
|
||||
m_pTGA = LoadTGA(pImageName);
|
||||
setImage( m_pTGA );
|
||||
}
|
||||
|
||||
//===========================================================
|
||||
// Image size
|
||||
int CImageLabel::getImageWide( void )
|
||||
{
|
||||
int iXSize, iYSize;
|
||||
m_pTGA->getSize( iXSize, iYSize );
|
||||
return iXSize;
|
||||
}
|
||||
|
||||
int CImageLabel::getImageTall( void )
|
||||
{
|
||||
int iXSize, iYSize;
|
||||
m_pTGA->getSize( iXSize, iYSize );
|
||||
return iYSize;
|
||||
}
|
||||
|
||||
//===========================================================
|
||||
// Various overloaded paint functions for Custom VGUI objects
|
||||
void CCommandMenu::paintBackground()
|
||||
{
|
||||
// Transparent black background
|
||||
drawSetColor(Scheme::sc_primary3);
|
||||
drawFilledRect(0,0,_size[0],_size[1]);
|
||||
}
|
||||
|
||||
//=================================================================================
|
||||
// CUSTOM SCROLLPANEL
|
||||
//=================================================================================
|
||||
CTFScrollButton::CTFScrollButton(int iArrow, const char* text,int x,int y,int wide,int tall) : CommandButton(text,x,y,wide,tall)
|
||||
{
|
||||
// Set text color to orange
|
||||
setFgColor(Scheme::sc_primary1);
|
||||
|
||||
// Load in the arrow
|
||||
m_pTGA = LoadTGA( sArrowFilenames[iArrow] );
|
||||
setImage( m_pTGA );
|
||||
|
||||
// Highlight signal
|
||||
InputSignal *pISignal = new CHandler_CommandButtonHighlight(this);
|
||||
addInputSignal(pISignal);
|
||||
}
|
||||
|
||||
void CTFScrollButton::paint( void )
|
||||
{
|
||||
// draw armed button text in white
|
||||
if ( isArmed() )
|
||||
{
|
||||
m_pTGA->setColor( Color(255,255,255, 0) );
|
||||
}
|
||||
else
|
||||
{
|
||||
m_pTGA->setColor( Color(255,255,255, 128) );
|
||||
}
|
||||
|
||||
m_pTGA->doPaint(this);
|
||||
}
|
||||
|
||||
void CTFScrollButton::paintBackground( void )
|
||||
{
|
||||
/*
|
||||
if ( isArmed() )
|
||||
{
|
||||
// Orange highlight background
|
||||
drawSetColor( Scheme::sc_primary2 );
|
||||
drawFilledRect(0,0,_size[0],_size[1]);
|
||||
}
|
||||
|
||||
// Orange Border
|
||||
drawSetColor( Scheme::sc_secondary1 );
|
||||
drawOutlinedRect(0,0,_size[0]-1,_size[1]);
|
||||
*/
|
||||
}
|
||||
|
||||
void CTFSlider::paintBackground( void )
|
||||
{
|
||||
int wide,tall,nobx,noby;
|
||||
getPaintSize(wide,tall);
|
||||
getNobPos(nobx,noby);
|
||||
|
||||
// Border
|
||||
drawSetColor( Scheme::sc_secondary1 );
|
||||
drawOutlinedRect( 0,0,wide,tall );
|
||||
|
||||
if( isVertical() )
|
||||
{
|
||||
// Nob Fill
|
||||
drawSetColor( Scheme::sc_primary2 );
|
||||
drawFilledRect( 0,nobx,wide,noby );
|
||||
|
||||
// Nob Outline
|
||||
drawSetColor( Scheme::sc_primary1 );
|
||||
drawOutlinedRect( 0,nobx,wide,noby );
|
||||
}
|
||||
else
|
||||
{
|
||||
// Nob Fill
|
||||
drawSetColor( Scheme::sc_primary2 );
|
||||
drawFilledRect( nobx,0,noby,tall );
|
||||
|
||||
// Nob Outline
|
||||
drawSetColor( Scheme::sc_primary1 );
|
||||
drawOutlinedRect( nobx,0,noby,tall );
|
||||
}
|
||||
}
|
||||
|
||||
CTFScrollPanel::CTFScrollPanel(int x,int y,int wide,int tall) : ScrollPanel(x,y,wide,tall)
|
||||
{
|
||||
ScrollBar *pScrollBar = getVerticalScrollBar();
|
||||
pScrollBar->setButton( new CTFScrollButton( ARROW_UP, "", 0,0,16,16 ), 0 );
|
||||
pScrollBar->setButton( new CTFScrollButton( ARROW_DOWN, "", 0,0,16,16 ), 1 );
|
||||
pScrollBar->setSlider( new CTFSlider(0,wide-1,wide,(tall-(wide*2))+2,true) );
|
||||
pScrollBar->setPaintBorderEnabled(false);
|
||||
pScrollBar->setPaintBackgroundEnabled(false);
|
||||
pScrollBar->setPaintEnabled(false);
|
||||
|
||||
pScrollBar = getHorizontalScrollBar();
|
||||
pScrollBar->setButton( new CTFScrollButton( ARROW_LEFT, "", 0,0,16,16 ), 0 );
|
||||
pScrollBar->setButton( new CTFScrollButton( ARROW_RIGHT, "", 0,0,16,16 ), 1 );
|
||||
pScrollBar->setSlider( new CTFSlider(tall,0,wide-(tall*2),tall,false) );
|
||||
pScrollBar->setPaintBorderEnabled(false);
|
||||
pScrollBar->setPaintBackgroundEnabled(false);
|
||||
pScrollBar->setPaintEnabled(false);
|
||||
}
|
||||
|
||||
|
||||
//=================================================================================
|
||||
// CUSTOM HANDLERS
|
||||
//=================================================================================
|
||||
void CHandler_MenuButtonOver::cursorEntered(Panel *panel)
|
||||
{
|
||||
if ( gViewPort && m_pMenuPanel )
|
||||
{
|
||||
m_pMenuPanel->SetActiveInfo( m_iButton );
|
||||
}
|
||||
}
|
||||
|
||||
void CMenuHandler_StringCommandClassSelect::actionPerformed(Panel* panel)
|
||||
{
|
||||
CMenuHandler_StringCommand::actionPerformed( panel );
|
||||
|
||||
bool bAutoKill = CVAR_GET_FLOAT( "hud_classautokill" ) != 0;
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,153 +0,0 @@
|
|||
//=========== (C) Copyright 1996-2002 Valve, L.L.C. All rights reserved. ===========
|
||||
//
|
||||
// The copyright to the contents herein is the property of Valve, L.L.C.
|
||||
// The contents may be used and/or copied only with the written permission of
|
||||
// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
|
||||
// the agreement/contract under which the contents have been supplied.
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $Workfile: $
|
||||
// $Date: $
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
// $Log: $
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#include "VGUI_Font.h"
|
||||
#include "VGUI_ScrollPanel.h"
|
||||
#include "VGUI_TextImage.h"
|
||||
|
||||
#include<VGUI_StackLayout.h>
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "camera.h"
|
||||
#include "kbutton.h"
|
||||
#include "const.h"
|
||||
|
||||
#include "vgui_int.h"
|
||||
#include "vgui_viewport.h"
|
||||
#include "vgui_ServerBrowser.h"
|
||||
|
||||
#define MOTD_TITLE_X XRES(16)
|
||||
#define MOTD_TITLE_Y YRES(16)
|
||||
|
||||
#define MOTD_WINDOW_X XRES(112)
|
||||
#define MOTD_WINDOW_Y YRES(80)
|
||||
#define MOTD_WINDOW_SIZE_X XRES(424)
|
||||
#define MOTD_WINDOW_SIZE_Y YRES(312)
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Displays the MOTD and basic server information
|
||||
//-----------------------------------------------------------------------------
|
||||
class CMessageWindowPanel : public CMenuPanel
|
||||
{
|
||||
public:
|
||||
CMessageWindowPanel( const char *szMOTD, const char *szTitle, int iShadeFullScreen, int iRemoveMe, int x, int y, int wide, int tall );
|
||||
|
||||
private:
|
||||
CTransparentPanel *m_pBackgroundPanel;
|
||||
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Creates a new CMessageWindowPanel
|
||||
// Output : CMenuPanel - interface to the panel
|
||||
//-----------------------------------------------------------------------------
|
||||
CMenuPanel *CMessageWindowPanel_Create( const char *szMOTD, const char *szTitle, int iShadeFullscreen, int iRemoveMe, int x, int y, int wide, int tall )
|
||||
{
|
||||
return new CMessageWindowPanel( szMOTD, szTitle, iShadeFullscreen, iRemoveMe, x, y, wide, tall );
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Constructs a message panel
|
||||
//-----------------------------------------------------------------------------
|
||||
CMessageWindowPanel::CMessageWindowPanel( const char *szMOTD, const char *szTitle, int iShadeFullscreen, int iRemoveMe, int x, int y, int wide, int tall ) : CMenuPanel( iShadeFullscreen ? 100 : 255, iRemoveMe, x, y, wide, tall )
|
||||
{
|
||||
// Get the scheme used for the Titles
|
||||
CSchemeManager *pSchemes = gViewPort->GetSchemeManager();
|
||||
|
||||
// schemes
|
||||
SchemeHandle_t hTitleScheme = pSchemes->getSchemeHandle( "Title Font" );
|
||||
SchemeHandle_t hMOTDText = pSchemes->getSchemeHandle( "Briefing Text" );
|
||||
|
||||
// color schemes
|
||||
int r, g, b, a;
|
||||
|
||||
// Create the window
|
||||
m_pBackgroundPanel = new CTransparentPanel( iShadeFullscreen ? 255 : 100, MOTD_WINDOW_X, MOTD_WINDOW_Y, MOTD_WINDOW_SIZE_X, MOTD_WINDOW_SIZE_Y );
|
||||
m_pBackgroundPanel->setParent( this );
|
||||
m_pBackgroundPanel->setBorder( new LineBorder( Color(255 * 0.7,170 * 0.7,0,0)) );
|
||||
m_pBackgroundPanel->setVisible( true );
|
||||
|
||||
int iXSize,iYSize,iXPos,iYPos;
|
||||
m_pBackgroundPanel->getPos( iXPos,iYPos );
|
||||
m_pBackgroundPanel->getSize( iXSize,iYSize );
|
||||
|
||||
// Create the title
|
||||
Label *pLabel = new Label( "", iXPos + MOTD_TITLE_X, iYPos + MOTD_TITLE_Y );
|
||||
pLabel->setParent( this );
|
||||
pLabel->setFont( pSchemes->getFont(hTitleScheme) );
|
||||
pLabel->setFont( Scheme::sf_primary1 );
|
||||
|
||||
pSchemes->getFgColor( hTitleScheme, r, g, b, a );
|
||||
pLabel->setFgColor( r, g, b, a );
|
||||
pLabel->setFgColor( Scheme::sc_primary1 );
|
||||
pSchemes->getBgColor( hTitleScheme, r, g, b, a );
|
||||
pLabel->setBgColor( r, g, b, a );
|
||||
pLabel->setContentAlignment( vgui::Label::a_west );
|
||||
pLabel->setText(szTitle);
|
||||
|
||||
// Create the Scroll panel
|
||||
ScrollPanel *pScrollPanel = new CTFScrollPanel( iXPos + XRES(16), iYPos + MOTD_TITLE_Y*2 + YRES(16), iXSize - XRES(32), iYSize - (YRES(48) + BUTTON_SIZE_Y*2) );
|
||||
pScrollPanel->setParent(this);
|
||||
//force the scrollbars on so clientClip will take them in account after the validate
|
||||
pScrollPanel->setScrollBarAutoVisible(false, false);
|
||||
pScrollPanel->setScrollBarVisible(true, true);
|
||||
pScrollPanel->validate();
|
||||
|
||||
// Create the text panel
|
||||
TextPanel *pText = new TextPanel( "", 0,0, 64,64);
|
||||
pText->setParent( pScrollPanel->getClient() );
|
||||
|
||||
// get the font and colors from the scheme
|
||||
pText->setFont( pSchemes->getFont(hMOTDText) );
|
||||
pSchemes->getFgColor( hMOTDText, r, g, b, a );
|
||||
pText->setFgColor( r, g, b, a );
|
||||
pSchemes->getBgColor( hMOTDText, r, g, b, a );
|
||||
pText->setBgColor( r, g, b, a );
|
||||
pText->setText(szMOTD);
|
||||
|
||||
// Get the total size of the MOTD text and resize the text panel
|
||||
int iScrollSizeX, iScrollSizeY;
|
||||
|
||||
// First, set the size so that the client's wdith is correct at least because the
|
||||
// width is critical for getting the "wrapped" size right.
|
||||
// You'll see a horizontal scroll bar if there is a single word that won't wrap in the
|
||||
// specified width.
|
||||
pText->getTextImage()->setSize(pScrollPanel->getClientClip()->getWide(), pScrollPanel->getClientClip()->getTall());
|
||||
pText->getTextImage()->getTextSizeWrapped( iScrollSizeX, iScrollSizeY );
|
||||
|
||||
// Now resize the textpanel to fit the scrolled size
|
||||
pText->setSize( iScrollSizeX , iScrollSizeY );
|
||||
|
||||
//turn the scrollbars back into automode
|
||||
pScrollPanel->setScrollBarAutoVisible(true, true);
|
||||
pScrollPanel->setScrollBarVisible(false, false);
|
||||
|
||||
pScrollPanel->validate();
|
||||
|
||||
CommandButton *pButton = new CommandButton( CHudTextMessage::BufferedLocaliseTextString( "#Menu_OK" ), iXPos + XRES(16), iYPos + iYSize - YRES(16) - BUTTON_SIZE_Y, CMENU_SIZE_X, BUTTON_SIZE_Y);
|
||||
pButton->addActionSignal(new CMenuHandler_TextWindow(HIDE_TEXTWINDOW));
|
||||
pButton->setParent(this);
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,556 +0,0 @@
|
|||
//=========== (C) Copyright 1996-2002 Valve, L.L.C. All rights reserved. ===========
|
||||
//
|
||||
// The copyright to the contents herein is the property of Valve, L.L.C.
|
||||
// The contents may be used and/or copied only with the written permission of
|
||||
// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
|
||||
// the agreement/contract under which the contents have been supplied.
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $Workfile: $
|
||||
// $Date: $
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
// $Log: $
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#include "hud.h"
|
||||
#include "vgui_SchemeManager.h"
|
||||
#include "cvardef.h"
|
||||
|
||||
#include <string.h>
|
||||
|
||||
|
||||
cvar_t *g_CV_BitmapFonts;
|
||||
|
||||
|
||||
void Scheme_Init()
|
||||
{
|
||||
g_CV_BitmapFonts = gEngfuncs.pfnRegisterVariable("bitmapfonts", "1", 0);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Scheme managers data container
|
||||
//-----------------------------------------------------------------------------
|
||||
class CSchemeManager::CScheme
|
||||
{
|
||||
public:
|
||||
enum {
|
||||
SCHEME_NAME_LENGTH = 32,
|
||||
FONT_NAME_LENGTH = 48,
|
||||
FONT_FILENAME_LENGTH = 64,
|
||||
};
|
||||
|
||||
// name
|
||||
char schemeName[SCHEME_NAME_LENGTH];
|
||||
|
||||
// font
|
||||
char fontName[FONT_NAME_LENGTH];
|
||||
|
||||
int fontSize;
|
||||
int fontWeight;
|
||||
|
||||
vgui::Font *font;
|
||||
int ownFontPointer; // true if the font is ours to delete
|
||||
|
||||
// scheme
|
||||
byte fgColor[4];
|
||||
byte bgColor[4];
|
||||
byte armedFgColor[4];
|
||||
byte armedBgColor[4];
|
||||
byte mousedownFgColor[4];
|
||||
byte mousedownBgColor[4];
|
||||
byte borderColor[4];
|
||||
|
||||
// construction/destruction
|
||||
CScheme();
|
||||
~CScheme();
|
||||
};
|
||||
|
||||
CSchemeManager::CScheme::CScheme()
|
||||
{
|
||||
schemeName[0] = 0;
|
||||
fontName[0] = 0;
|
||||
fontSize = 0;
|
||||
fontWeight = 0;
|
||||
font = NULL;
|
||||
ownFontPointer = false;
|
||||
}
|
||||
|
||||
CSchemeManager::CScheme::~CScheme()
|
||||
{
|
||||
// only delete our font pointer if we own it
|
||||
if ( ownFontPointer )
|
||||
{
|
||||
delete font;
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: resolution information
|
||||
// !! needs to be shared out
|
||||
//-----------------------------------------------------------------------------
|
||||
static int g_ResArray[] =
|
||||
{
|
||||
320,
|
||||
400,
|
||||
512,
|
||||
640,
|
||||
800,
|
||||
1024,
|
||||
1152,
|
||||
1280,
|
||||
1600
|
||||
};
|
||||
static int g_NumReses = sizeof(g_ResArray) / sizeof(int);
|
||||
|
||||
static byte *LoadFileByResolution( const char *filePrefix, int xRes, const char *filePostfix )
|
||||
{
|
||||
// find our resolution in the res array
|
||||
int resNum = g_NumReses - 1;
|
||||
while ( g_ResArray[resNum] > xRes )
|
||||
{
|
||||
resNum--;
|
||||
|
||||
if ( resNum < 0 )
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// try open the file
|
||||
byte *pFile = NULL;
|
||||
while ( 1 )
|
||||
{
|
||||
|
||||
// try load
|
||||
char fname[256];
|
||||
sprintf( fname, "%s%d%s", filePrefix, g_ResArray[resNum], filePostfix );
|
||||
pFile = gEngfuncs.COM_LoadFile( fname, 5, NULL );
|
||||
|
||||
if ( pFile )
|
||||
break;
|
||||
|
||||
if ( resNum == 0 )
|
||||
return NULL;
|
||||
|
||||
resNum--;
|
||||
};
|
||||
|
||||
return pFile;
|
||||
}
|
||||
|
||||
static void ParseRGBAFromString( byte colorArray[4], const char *colorVector )
|
||||
{
|
||||
int r, g, b, a;
|
||||
sscanf( colorVector, "%d %d %d %d", &r, &g, &b, &a );
|
||||
colorArray[0] = r;
|
||||
colorArray[1] = g;
|
||||
colorArray[2] = b;
|
||||
colorArray[3] = a;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: initializes the scheme manager
|
||||
// loading the scheme files for the current resolution
|
||||
// Input : xRes -
|
||||
// yRes - dimensions of output window
|
||||
//-----------------------------------------------------------------------------
|
||||
CSchemeManager::CSchemeManager( int xRes, int yRes )
|
||||
{
|
||||
// basic setup
|
||||
m_pSchemeList = NULL;
|
||||
m_iNumSchemes = 0;
|
||||
|
||||
// find the closest matching scheme file to our resolution
|
||||
char token[1024];
|
||||
char *pFile = (char*)LoadFileByResolution( "", xRes, "_textscheme.txt" );
|
||||
m_xRes = xRes;
|
||||
|
||||
char *pFileStart = pFile;
|
||||
|
||||
byte *pFontData;
|
||||
int fontFileLength;
|
||||
char fontFilename[512];
|
||||
|
||||
//
|
||||
// Read the scheme descriptions from the text file, into a temporary array
|
||||
// format is simply:
|
||||
// <paramName name> = <paramValue>
|
||||
//
|
||||
// a <paramName name> of "SchemeName" signals a new scheme is being described
|
||||
//
|
||||
|
||||
const static int numTmpSchemes = 64;
|
||||
static CScheme tmpSchemes[numTmpSchemes];
|
||||
memset( tmpSchemes, 0, sizeof(tmpSchemes) );
|
||||
int currentScheme = -1;
|
||||
CScheme *pScheme = NULL;
|
||||
|
||||
if ( !pFile )
|
||||
{
|
||||
gEngfuncs.Con_DPrintf( "Unable to find *_textscheme.txt\n");
|
||||
goto buildDefaultFont;
|
||||
}
|
||||
|
||||
// record what has been entered so we can create defaults from the different values
|
||||
bool hasFgColor, hasBgColor, hasArmedFgColor, hasArmedBgColor, hasMouseDownFgColor, hasMouseDownBgColor;
|
||||
|
||||
pFile = gEngfuncs.COM_ParseFile( pFile, token );
|
||||
while ( strlen(token) > 0 && (currentScheme < numTmpSchemes) )
|
||||
{
|
||||
// get the paramName name
|
||||
static const int tokenSize = 64;
|
||||
char paramName[tokenSize], paramValue[tokenSize];
|
||||
|
||||
strncpy( paramName, token, tokenSize );
|
||||
paramName[tokenSize-1] = 0; // ensure null termination
|
||||
|
||||
// get the '=' character
|
||||
pFile = gEngfuncs.COM_ParseFile( pFile, token );
|
||||
if ( stricmp( token, "=" ) )
|
||||
{
|
||||
if ( currentScheme < 0 )
|
||||
{
|
||||
gEngfuncs.Con_Printf( "error parsing font scheme text file at file start - expected '=', found '%s''\n", token );
|
||||
}
|
||||
else
|
||||
{
|
||||
gEngfuncs.Con_Printf( "error parsing font scheme text file at scheme '%s' - expected '=', found '%s''\n", tmpSchemes[currentScheme].schemeName, token );
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
// get paramValue
|
||||
pFile = gEngfuncs.COM_ParseFile( pFile, token );
|
||||
strncpy( paramValue, token, tokenSize );
|
||||
paramValue[tokenSize-1] = 0; // ensure null termination
|
||||
|
||||
// is this a new scheme?
|
||||
if ( !stricmp(paramName, "SchemeName") )
|
||||
{
|
||||
// setup the defaults for the current scheme
|
||||
if ( pScheme )
|
||||
{
|
||||
// foreground color defaults (normal -> armed -> mouse down)
|
||||
if ( !hasFgColor )
|
||||
{
|
||||
pScheme->fgColor[0] = pScheme->fgColor[1] = pScheme->fgColor[2] = pScheme->fgColor[3] = 255;
|
||||
}
|
||||
if ( !hasArmedFgColor )
|
||||
{
|
||||
memcpy( pScheme->armedFgColor, pScheme->fgColor, sizeof(pScheme->armedFgColor) );
|
||||
}
|
||||
if ( !hasMouseDownFgColor )
|
||||
{
|
||||
memcpy( pScheme->mousedownFgColor, pScheme->armedFgColor, sizeof(pScheme->mousedownFgColor) );
|
||||
}
|
||||
|
||||
// background color (normal -> armed -> mouse down)
|
||||
if ( !hasBgColor )
|
||||
{
|
||||
pScheme->bgColor[0] = pScheme->bgColor[1] = pScheme->bgColor[2] = pScheme->bgColor[3] = 0;
|
||||
}
|
||||
if ( !hasArmedBgColor )
|
||||
{
|
||||
memcpy( pScheme->armedBgColor, pScheme->bgColor, sizeof(pScheme->armedBgColor) );
|
||||
}
|
||||
if ( !hasMouseDownBgColor )
|
||||
{
|
||||
memcpy( pScheme->mousedownBgColor, pScheme->armedBgColor, sizeof(pScheme->mousedownBgColor) );
|
||||
}
|
||||
|
||||
// font size
|
||||
if ( !pScheme->fontSize )
|
||||
{
|
||||
pScheme->fontSize = 17;
|
||||
}
|
||||
if ( !pScheme->fontName[0] )
|
||||
{
|
||||
strcpy( pScheme->fontName, "Arial" );
|
||||
}
|
||||
}
|
||||
|
||||
// create the new scheme
|
||||
currentScheme++;
|
||||
pScheme = &tmpSchemes[currentScheme];
|
||||
hasFgColor = hasBgColor = hasArmedFgColor = hasArmedBgColor = hasMouseDownFgColor = hasMouseDownBgColor = false;
|
||||
|
||||
strncpy( pScheme->schemeName, paramValue, CScheme::SCHEME_NAME_LENGTH );
|
||||
pScheme->schemeName[CScheme::SCHEME_NAME_LENGTH-1] = '\0'; // ensure null termination of string
|
||||
}
|
||||
|
||||
if ( !pScheme )
|
||||
{
|
||||
gEngfuncs.Con_Printf( "font scheme text file MUST start with a 'SchemeName'\n");
|
||||
break;
|
||||
}
|
||||
|
||||
// pull the data out into the scheme
|
||||
if ( !stricmp(paramName, "FontName") )
|
||||
{
|
||||
strncpy( pScheme->fontName, paramValue, CScheme::FONT_NAME_LENGTH );
|
||||
pScheme->fontName[CScheme::FONT_NAME_LENGTH-1] = 0;
|
||||
}
|
||||
else if ( !stricmp(paramName, "FontSize") )
|
||||
{
|
||||
pScheme->fontSize = atoi( paramValue );
|
||||
}
|
||||
else if ( !stricmp(paramName, "FontWeight") )
|
||||
{
|
||||
pScheme->fontWeight = atoi( paramValue );
|
||||
}
|
||||
else if ( !stricmp(paramName, "FgColor") )
|
||||
{
|
||||
ParseRGBAFromString( pScheme->fgColor, paramValue );
|
||||
hasFgColor = true;
|
||||
}
|
||||
else if ( !stricmp(paramName, "BgColor") )
|
||||
{
|
||||
ParseRGBAFromString( pScheme->bgColor, paramValue );
|
||||
hasBgColor = true;
|
||||
}
|
||||
else if ( !stricmp(paramName, "FgColorArmed") )
|
||||
{
|
||||
ParseRGBAFromString( pScheme->armedFgColor, paramValue );
|
||||
hasArmedFgColor = true;
|
||||
}
|
||||
else if ( !stricmp(paramName, "BgColorArmed") )
|
||||
{
|
||||
ParseRGBAFromString( pScheme->armedBgColor, paramValue );
|
||||
hasArmedBgColor = true;
|
||||
}
|
||||
else if ( !stricmp(paramName, "FgColorMousedown") )
|
||||
{
|
||||
ParseRGBAFromString( pScheme->mousedownFgColor, paramValue );
|
||||
hasMouseDownFgColor = true;
|
||||
}
|
||||
else if ( !stricmp(paramName, "BgColorMousedown") )
|
||||
{
|
||||
ParseRGBAFromString( pScheme->mousedownBgColor, paramValue );
|
||||
hasMouseDownBgColor = true;
|
||||
}
|
||||
else if ( !stricmp(paramName, "BorderColor") )
|
||||
{
|
||||
ParseRGBAFromString( pScheme->borderColor, paramValue );
|
||||
hasMouseDownBgColor = true;
|
||||
}
|
||||
|
||||
// get the new token last, so we now if the loop needs to be continued or not
|
||||
pFile = gEngfuncs.COM_ParseFile( pFile, token );
|
||||
}
|
||||
|
||||
// free the file
|
||||
gEngfuncs.COM_FreeFile( pFileStart );
|
||||
|
||||
|
||||
buildDefaultFont:
|
||||
|
||||
// make sure we have at least 1 valid font
|
||||
if ( currentScheme < 0 )
|
||||
{
|
||||
currentScheme = 0;
|
||||
strcpy( tmpSchemes[0].schemeName, "Default Scheme" );
|
||||
strcpy( tmpSchemes[0].fontName, "Arial" );
|
||||
tmpSchemes[0].fontSize = 0;
|
||||
tmpSchemes[0].fgColor[0] = tmpSchemes[0].fgColor[1] = tmpSchemes[0].fgColor[2] = tmpSchemes[0].fgColor[3] = 255;
|
||||
tmpSchemes[0].armedFgColor[0] = tmpSchemes[0].armedFgColor[1] = tmpSchemes[0].armedFgColor[2] = tmpSchemes[0].armedFgColor[3] = 255;
|
||||
tmpSchemes[0].mousedownFgColor[0] = tmpSchemes[0].mousedownFgColor[1] = tmpSchemes[0].mousedownFgColor[2] = tmpSchemes[0].mousedownFgColor[3] = 255;
|
||||
}
|
||||
|
||||
// we have the full list of schemes in the tmpSchemes array
|
||||
// now allocate the correct sized list
|
||||
m_iNumSchemes = currentScheme + 1; // 0-based index
|
||||
m_pSchemeList = new CScheme[ m_iNumSchemes ];
|
||||
|
||||
// copy in the data
|
||||
memcpy( m_pSchemeList, tmpSchemes, sizeof(CScheme) * m_iNumSchemes );
|
||||
|
||||
// create the fonts
|
||||
for ( int i = 0; i < m_iNumSchemes; i++ )
|
||||
{
|
||||
m_pSchemeList[i].font = NULL;
|
||||
|
||||
// see if the current font values exist in a previously loaded font
|
||||
for ( int j = 0; j < i; j++ )
|
||||
{
|
||||
// check if the font name, size, and weight are the same
|
||||
if ( !stricmp(m_pSchemeList[i].fontName, m_pSchemeList[j].fontName)
|
||||
&& m_pSchemeList[i].fontSize == m_pSchemeList[j].fontSize
|
||||
&& m_pSchemeList[i].fontWeight == m_pSchemeList[j].fontWeight )
|
||||
{
|
||||
// copy the pointer, but mark i as not owning it
|
||||
m_pSchemeList[i].font = m_pSchemeList[j].font;
|
||||
m_pSchemeList[i].ownFontPointer = false;
|
||||
}
|
||||
}
|
||||
|
||||
// if we haven't found the font already, load it ourselves
|
||||
if ( !m_pSchemeList[i].font )
|
||||
{
|
||||
fontFileLength = -1;
|
||||
pFontData = NULL;
|
||||
|
||||
if(g_CV_BitmapFonts && g_CV_BitmapFonts->value)
|
||||
{
|
||||
int fontRes = 640;
|
||||
if ( m_xRes >= 1600 )
|
||||
fontRes = 1600;
|
||||
else if ( m_xRes >= 1280 )
|
||||
fontRes = 1280;
|
||||
else if ( m_xRes >= 1152 )
|
||||
fontRes = 1152;
|
||||
else if ( m_xRes >= 1024 )
|
||||
fontRes = 1024;
|
||||
else if ( m_xRes >= 800 )
|
||||
fontRes = 800;
|
||||
|
||||
sprintf(fontFilename, "gfx\\vgui\\fonts\\%d_%s.tga", fontRes, m_pSchemeList[i].schemeName);
|
||||
pFontData = gEngfuncs.COM_LoadFile( fontFilename, 5, &fontFileLength );
|
||||
if(!pFontData)
|
||||
gEngfuncs.Con_Printf("Missing bitmap font: %s\n", fontFilename);
|
||||
}
|
||||
|
||||
m_pSchemeList[i].font = new vgui::Font(
|
||||
m_pSchemeList[i].fontName,
|
||||
pFontData,
|
||||
fontFileLength,
|
||||
m_pSchemeList[i].fontSize,
|
||||
0,
|
||||
0,
|
||||
m_pSchemeList[i].fontWeight,
|
||||
false,
|
||||
false,
|
||||
false,
|
||||
false);
|
||||
|
||||
m_pSchemeList[i].ownFontPointer = true;
|
||||
}
|
||||
|
||||
// fix up alpha values; VGUI uses 1-A (A=0 being solid, A=255 transparent)
|
||||
m_pSchemeList[i].fgColor[3] = 255 - m_pSchemeList[i].fgColor[3];
|
||||
m_pSchemeList[i].bgColor[3] = 255 - m_pSchemeList[i].bgColor[3];
|
||||
m_pSchemeList[i].armedFgColor[3] = 255 - m_pSchemeList[i].armedFgColor[3];
|
||||
m_pSchemeList[i].armedBgColor[3] = 255 - m_pSchemeList[i].armedBgColor[3];
|
||||
m_pSchemeList[i].mousedownFgColor[3] = 255 - m_pSchemeList[i].mousedownFgColor[3];
|
||||
m_pSchemeList[i].mousedownBgColor[3] = 255 - m_pSchemeList[i].mousedownBgColor[3];
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: frees all the memory used by the scheme manager
|
||||
//-----------------------------------------------------------------------------
|
||||
CSchemeManager::~CSchemeManager()
|
||||
{
|
||||
delete [] m_pSchemeList;
|
||||
m_iNumSchemes = 0;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Finds a scheme in the list, by name
|
||||
// Input : char *schemeName - string name of the scheme
|
||||
// Output : SchemeHandle_t handle to the scheme
|
||||
//-----------------------------------------------------------------------------
|
||||
SchemeHandle_t CSchemeManager::getSchemeHandle( const char *schemeName )
|
||||
{
|
||||
// iterate through the list
|
||||
for ( int i = 0; i < m_iNumSchemes; i++ )
|
||||
{
|
||||
if ( !stricmp(schemeName, m_pSchemeList[i].schemeName) )
|
||||
return i;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: always returns a valid scheme handle
|
||||
// Input : schemeHandle -
|
||||
// Output : CScheme
|
||||
//-----------------------------------------------------------------------------
|
||||
CSchemeManager::CScheme *CSchemeManager::getSafeScheme( SchemeHandle_t schemeHandle )
|
||||
{
|
||||
if ( schemeHandle < m_iNumSchemes )
|
||||
return m_pSchemeList + schemeHandle;
|
||||
|
||||
return m_pSchemeList;
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Returns the schemes pointer to a font
|
||||
// Input : schemeHandle -
|
||||
// Output : vgui::Font
|
||||
//-----------------------------------------------------------------------------
|
||||
vgui::Font *CSchemeManager::getFont( SchemeHandle_t schemeHandle )
|
||||
{
|
||||
return getSafeScheme( schemeHandle )->font;
|
||||
}
|
||||
|
||||
void CSchemeManager::getFgColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a )
|
||||
{
|
||||
CScheme *pScheme = getSafeScheme( schemeHandle );
|
||||
r = pScheme->fgColor[0];
|
||||
g = pScheme->fgColor[1];
|
||||
b = pScheme->fgColor[2];
|
||||
a = pScheme->fgColor[3];
|
||||
}
|
||||
|
||||
void CSchemeManager::getBgColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a )
|
||||
{
|
||||
CScheme *pScheme = getSafeScheme( schemeHandle );
|
||||
r = pScheme->bgColor[0];
|
||||
g = pScheme->bgColor[1];
|
||||
b = pScheme->bgColor[2];
|
||||
a = pScheme->bgColor[3];
|
||||
}
|
||||
|
||||
void CSchemeManager::getFgArmedColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a )
|
||||
{
|
||||
CScheme *pScheme = getSafeScheme( schemeHandle );
|
||||
r = pScheme->armedFgColor[0];
|
||||
g = pScheme->armedFgColor[1];
|
||||
b = pScheme->armedFgColor[2];
|
||||
a = pScheme->armedFgColor[3];
|
||||
}
|
||||
|
||||
void CSchemeManager::getBgArmedColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a )
|
||||
{
|
||||
CScheme *pScheme = getSafeScheme( schemeHandle );
|
||||
r = pScheme->armedBgColor[0];
|
||||
g = pScheme->armedBgColor[1];
|
||||
b = pScheme->armedBgColor[2];
|
||||
a = pScheme->armedBgColor[3];
|
||||
}
|
||||
|
||||
void CSchemeManager::getFgMousedownColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a )
|
||||
{
|
||||
CScheme *pScheme = getSafeScheme( schemeHandle );
|
||||
r = pScheme->mousedownFgColor[0];
|
||||
g = pScheme->mousedownFgColor[1];
|
||||
b = pScheme->mousedownFgColor[2];
|
||||
a = pScheme->mousedownFgColor[3];
|
||||
}
|
||||
|
||||
void CSchemeManager::getBgMousedownColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a )
|
||||
{
|
||||
CScheme *pScheme = getSafeScheme( schemeHandle );
|
||||
r = pScheme->mousedownBgColor[0];
|
||||
g = pScheme->mousedownBgColor[1];
|
||||
b = pScheme->mousedownBgColor[2];
|
||||
a = pScheme->mousedownBgColor[3];
|
||||
}
|
||||
|
||||
void CSchemeManager::getBorderColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a )
|
||||
{
|
||||
CScheme *pScheme = getSafeScheme( schemeHandle );
|
||||
r = pScheme->borderColor[0];
|
||||
g = pScheme->borderColor[1];
|
||||
b = pScheme->borderColor[2];
|
||||
a = pScheme->borderColor[3];
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,52 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#include <VGUI_Font.h>
|
||||
|
||||
// handle to an individual scheme
|
||||
typedef int SchemeHandle_t;
|
||||
|
||||
// Register console variables, etc..
|
||||
void Scheme_Init();
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Handles the loading of text scheme description from disk
|
||||
// supports different font/color/size schemes at different resolutions
|
||||
//-----------------------------------------------------------------------------
|
||||
class CSchemeManager
|
||||
{
|
||||
public:
|
||||
// initialization
|
||||
CSchemeManager( int xRes, int yRes );
|
||||
virtual ~CSchemeManager();
|
||||
|
||||
// scheme handling
|
||||
SchemeHandle_t getSchemeHandle( const char *schemeName );
|
||||
|
||||
// getting info from schemes
|
||||
vgui::Font *getFont( SchemeHandle_t schemeHandle );
|
||||
void getFgColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a );
|
||||
void getBgColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a );
|
||||
void getFgArmedColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a );
|
||||
void getBgArmedColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a );
|
||||
void getFgMousedownColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a );
|
||||
void getBgMousedownColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a );
|
||||
void getBorderColor( SchemeHandle_t schemeHandle, int &r, int &g, int &b, int &a );
|
||||
|
||||
private:
|
||||
class CScheme;
|
||||
CScheme *m_pSchemeList;
|
||||
int m_iNumSchemes;
|
||||
|
||||
// Resolution we were initted at.
|
||||
int m_xRes;
|
||||
|
||||
CScheme *getSafeScheme( SchemeHandle_t schemeHandle );
|
||||
};
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,314 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#ifndef SCOREPANEL_H
|
||||
#define SCOREPANEL_H
|
||||
|
||||
#include<VGUI_Panel.h>
|
||||
#include<VGUI_TablePanel.h>
|
||||
#include<VGUI_HeaderPanel.h>
|
||||
#include<VGUI_TextGrid.h>
|
||||
#include<VGUI_Label.h>
|
||||
#include<VGUI_TextImage.h>
|
||||
#include "vgui_listbox.h"
|
||||
|
||||
#include <ctype.h>
|
||||
|
||||
#define MAX_SCORES 10
|
||||
#define MAX_SCOREBOARD_TEAMS 5
|
||||
|
||||
// Scoreboard cells
|
||||
#define COLUMN_TRACKER 0
|
||||
#define COLUMN_NAME 1
|
||||
#define COLUMN_KILLS 2
|
||||
#define COLUMN_DEATHS 3
|
||||
#define COLUMN_LATENCY 4
|
||||
#define COLUMN_VOICE 5
|
||||
#define COLUMN_BLANK 6
|
||||
#define NUM_COLUMNS 7
|
||||
|
||||
#define NUM_ROWS (MAX_PLAYERS + (MAX_SCOREBOARD_TEAMS * 2))
|
||||
|
||||
using namespace vgui;
|
||||
|
||||
class CTextImage2 : public Image
|
||||
{
|
||||
public:
|
||||
CTextImage2()
|
||||
{
|
||||
_image[0] = new TextImage("");
|
||||
_image[1] = new TextImage("");
|
||||
}
|
||||
|
||||
~CTextImage2()
|
||||
{
|
||||
delete _image[0];
|
||||
delete _image[1];
|
||||
}
|
||||
|
||||
TextImage *GetImage(int image)
|
||||
{
|
||||
return _image[image];
|
||||
}
|
||||
|
||||
void getSize(int &wide, int &tall)
|
||||
{
|
||||
int w1, w2, t1, t2;
|
||||
_image[0]->getTextSize(w1, t1);
|
||||
_image[1]->getTextSize(w2, t2);
|
||||
|
||||
wide = w1 + w2;
|
||||
tall = max(t1, t2);
|
||||
setSize(wide, tall);
|
||||
}
|
||||
|
||||
void doPaint(Panel *panel)
|
||||
{
|
||||
_image[0]->doPaint(panel);
|
||||
_image[1]->doPaint(panel);
|
||||
}
|
||||
|
||||
void setPos(int x, int y)
|
||||
{
|
||||
_image[0]->setPos(x, y);
|
||||
|
||||
int swide, stall;
|
||||
_image[0]->getSize(swide, stall);
|
||||
|
||||
int wide, tall;
|
||||
_image[1]->getSize(wide, tall);
|
||||
_image[1]->setPos(x + wide, y + (stall * 0.9) - tall);
|
||||
}
|
||||
|
||||
void setColor(Color color)
|
||||
{
|
||||
_image[0]->setColor(color);
|
||||
}
|
||||
|
||||
void setColor2(Color color)
|
||||
{
|
||||
_image[1]->setColor(color);
|
||||
}
|
||||
|
||||
private:
|
||||
TextImage *_image[2];
|
||||
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Custom label for cells in the Scoreboard's Table Header
|
||||
//-----------------------------------------------------------------------------
|
||||
class CLabelHeader : public Label
|
||||
{
|
||||
public:
|
||||
CLabelHeader() : Label("")
|
||||
{
|
||||
_dualImage = new CTextImage2();
|
||||
_dualImage->setColor2(Color(255, 170, 0, 0));
|
||||
_row = -2;
|
||||
_useFgColorAsImageColor = true;
|
||||
_offset[0] = 0;
|
||||
_offset[1] = 0;
|
||||
}
|
||||
|
||||
~CLabelHeader()
|
||||
{
|
||||
delete _dualImage;
|
||||
}
|
||||
|
||||
void setRow(int row)
|
||||
{
|
||||
_row = row;
|
||||
}
|
||||
|
||||
void setFgColorAsImageColor(bool state)
|
||||
{
|
||||
_useFgColorAsImageColor = state;
|
||||
}
|
||||
|
||||
virtual void setText(int textBufferLen, const char* text)
|
||||
{
|
||||
_dualImage->GetImage(0)->setText(text);
|
||||
|
||||
// calculate the text size
|
||||
Font *font = _dualImage->GetImage(0)->getFont();
|
||||
_gap = 0;
|
||||
for (const char *ch = text; *ch != 0; ch++)
|
||||
{
|
||||
int a, b, c;
|
||||
font->getCharABCwide(*ch, a, b, c);
|
||||
_gap += (a + b + c);
|
||||
}
|
||||
|
||||
_gap += XRES(5);
|
||||
}
|
||||
|
||||
virtual void setText(const char* text)
|
||||
{
|
||||
// strip any non-alnum characters from the end
|
||||
char buf[512];
|
||||
strcpy(buf, text);
|
||||
|
||||
int len = strlen(buf);
|
||||
while (len && isspace(buf[--len]))
|
||||
{
|
||||
buf[len] = 0;
|
||||
}
|
||||
|
||||
CLabelHeader::setText(0, buf);
|
||||
}
|
||||
|
||||
void setText2(const char *text)
|
||||
{
|
||||
_dualImage->GetImage(1)->setText(text);
|
||||
}
|
||||
|
||||
void getTextSize(int &wide, int &tall)
|
||||
{
|
||||
_dualImage->getSize(wide, tall);
|
||||
}
|
||||
|
||||
void setFgColor(int r,int g,int b,int a)
|
||||
{
|
||||
Label::setFgColor(r,g,b,a);
|
||||
Color color(r,g,b,a);
|
||||
_dualImage->setColor(color);
|
||||
_dualImage->setColor2(color);
|
||||
if (_image && _useFgColorAsImageColor)
|
||||
{
|
||||
_image->setColor(color);
|
||||
}
|
||||
repaint();
|
||||
}
|
||||
|
||||
void setFgColor(Scheme::SchemeColor sc)
|
||||
{
|
||||
Label::setFgColor(sc);
|
||||
_dualImage->setColor(sc);
|
||||
}
|
||||
|
||||
void setFont(Font *font)
|
||||
{
|
||||
_dualImage->GetImage(0)->setFont(font);
|
||||
}
|
||||
|
||||
void setFont2(Font *font)
|
||||
{
|
||||
_dualImage->GetImage(1)->setFont(font);
|
||||
}
|
||||
|
||||
// this adjust the absolute position of the text after alignment is calculated
|
||||
void setTextOffset(int x, int y)
|
||||
{
|
||||
_offset[0] = x;
|
||||
_offset[1] = y;
|
||||
}
|
||||
|
||||
void paint();
|
||||
void paintBackground();
|
||||
void calcAlignment(int iwide, int itall, int &x, int &y);
|
||||
|
||||
private:
|
||||
CTextImage2 *_dualImage;
|
||||
int _row;
|
||||
int _gap;
|
||||
int _offset[2];
|
||||
bool _useFgColorAsImageColor;
|
||||
};
|
||||
|
||||
class ScoreTablePanel;
|
||||
|
||||
#include "vgui_grid.h"
|
||||
#include "vgui_defaultinputsignal.h"
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Scoreboard back panel
|
||||
//-----------------------------------------------------------------------------
|
||||
class ScorePanel : public Panel, public vgui::CDefaultInputSignal
|
||||
{
|
||||
private:
|
||||
// Default panel implementation doesn't forward mouse messages when there is no cursor and we need them.
|
||||
class HitTestPanel : public Panel
|
||||
{
|
||||
public:
|
||||
virtual void internalMousePressed(MouseCode code);
|
||||
};
|
||||
|
||||
|
||||
private:
|
||||
|
||||
Label m_TitleLabel;
|
||||
|
||||
// Here is how these controls are arranged hierarchically.
|
||||
// m_HeaderGrid
|
||||
// m_HeaderLabels
|
||||
|
||||
// m_PlayerGridScroll
|
||||
// m_PlayerGrid
|
||||
// m_PlayerEntries
|
||||
|
||||
CGrid m_HeaderGrid;
|
||||
CLabelHeader m_HeaderLabels[NUM_COLUMNS]; // Labels above the
|
||||
CLabelHeader *m_pCurrentHighlightLabel;
|
||||
int m_iHighlightRow;
|
||||
|
||||
vgui::CListBox m_PlayerList;
|
||||
CGrid m_PlayerGrids[NUM_ROWS]; // The grid with player and team info.
|
||||
CLabelHeader m_PlayerEntries[NUM_COLUMNS][NUM_ROWS]; // Labels for the grid entries.
|
||||
|
||||
ScorePanel::HitTestPanel m_HitTestPanel;
|
||||
|
||||
CLabelHeader* GetPlayerEntry(int x, int y) {return &m_PlayerEntries[x][y];}
|
||||
|
||||
public:
|
||||
|
||||
int m_iNumTeams;
|
||||
int m_iPlayerNum;
|
||||
int m_iShowscoresHeld;
|
||||
|
||||
int m_iRows;
|
||||
int m_iSortedRows[NUM_ROWS];
|
||||
int m_iIsATeam[NUM_ROWS];
|
||||
bool m_bHasBeenSorted[MAX_PLAYERS];
|
||||
int m_iLastKilledBy;
|
||||
int m_fLastKillTime;
|
||||
|
||||
CImageLabel *m_pImages[ 7 ];
|
||||
|
||||
|
||||
public:
|
||||
|
||||
ScorePanel(int x,int y,int wide,int tall);
|
||||
|
||||
void Update( void );
|
||||
|
||||
void SortTeams( void );
|
||||
void SortPlayers( int iTeam, char *team );
|
||||
void RebuildTeams( void );
|
||||
|
||||
void FillGrid();
|
||||
|
||||
void DeathMsg( int killer, int victim );
|
||||
|
||||
void Initialize( void );
|
||||
|
||||
void Open( void );
|
||||
|
||||
void MouseOverCell(int row, int col);
|
||||
|
||||
|
||||
// InputSignal overrides.
|
||||
public:
|
||||
|
||||
virtual void mousePressed(MouseCode code, Panel* panel);
|
||||
virtual void cursorMoved(int x, int y, Panel *panel);
|
||||
|
||||
friend class CLabelHeader;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -1,623 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#include<VGUI_HeaderPanel.h>
|
||||
#include<VGUI_TablePanel.h>
|
||||
#include<VGUI_LineBorder.h>
|
||||
#include<VGUI_Label.h>
|
||||
#include<VGUI_Button.h>
|
||||
#include<VGUI_ActionSignal.h>
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "hud_servers.h"
|
||||
#include "net_api.h"
|
||||
|
||||
#include "vgui_viewport.h"
|
||||
#include "vgui_ServerBrowser.h"
|
||||
|
||||
using namespace vgui;
|
||||
|
||||
namespace
|
||||
{
|
||||
|
||||
#define MAX_SB_ROWS 24
|
||||
|
||||
#define NUM_COLUMNS 5
|
||||
|
||||
#define HEADER_SIZE_Y YRES(18)
|
||||
|
||||
// Column sizes
|
||||
#define CSIZE_ADDRESS XRES(200)
|
||||
#define CSIZE_SERVER XRES(400)
|
||||
#define CSIZE_MAP XRES(500)
|
||||
#define CSIZE_CURRENT XRES(570)
|
||||
#define CSIZE_PING XRES(640)
|
||||
|
||||
#define CELL_HEIGHT YRES(15)
|
||||
|
||||
class ServerBrowserTablePanel;
|
||||
|
||||
class CBrowser_InputSignal : public InputSignal
|
||||
{
|
||||
private:
|
||||
ServerBrowserTablePanel *m_pBrowser;
|
||||
public:
|
||||
CBrowser_InputSignal( ServerBrowserTablePanel *pBrowser )
|
||||
{
|
||||
m_pBrowser = pBrowser;
|
||||
}
|
||||
|
||||
virtual void cursorMoved(int x,int y,Panel* panel) {};
|
||||
virtual void cursorEntered(Panel* panel){};
|
||||
virtual void cursorExited(Panel* Panel) {};
|
||||
|
||||
virtual void mousePressed(MouseCode code,Panel* panel);
|
||||
|
||||
virtual void mouseDoublePressed(MouseCode code,Panel* panel);
|
||||
virtual void mouseReleased(MouseCode code,Panel* panel) {};
|
||||
virtual void mouseWheeled(int delta,Panel* panel) {};
|
||||
virtual void keyPressed(KeyCode code,Panel* panel) {};
|
||||
virtual void keyTyped(KeyCode code,Panel* panel) {};
|
||||
virtual void keyReleased(KeyCode code,Panel* panel) {};
|
||||
virtual void keyFocusTicked(Panel* panel) {};
|
||||
};
|
||||
|
||||
class ServerBrowserTablePanel : public TablePanel
|
||||
{
|
||||
private:
|
||||
Label *m_pLabel;
|
||||
int m_nMouseOverRow;
|
||||
|
||||
public:
|
||||
|
||||
ServerBrowserTablePanel( int x,int y,int wide,int tall,int columnCount) : TablePanel( x,y,wide,tall,columnCount)
|
||||
{
|
||||
m_pLabel = new Label( "", 0, 0 /*,wide, tall*/ );
|
||||
|
||||
m_nMouseOverRow = 0;
|
||||
}
|
||||
|
||||
public:
|
||||
void setMouseOverRow( int row )
|
||||
{
|
||||
m_nMouseOverRow = row;
|
||||
}
|
||||
|
||||
void DoSort( char *sortkey )
|
||||
{
|
||||
// Request server list and refresh servers...
|
||||
SortServers( sortkey );
|
||||
}
|
||||
|
||||
void DoRefresh( void )
|
||||
{
|
||||
// Request server list and refresh servers...
|
||||
ServersList();
|
||||
BroadcastServersList( 0 );
|
||||
}
|
||||
|
||||
void DoBroadcastRefresh( void )
|
||||
{
|
||||
// Request server list and refresh servers...
|
||||
BroadcastServersList( 1 );
|
||||
}
|
||||
|
||||
void DoStop( void )
|
||||
{
|
||||
// Stop requesting
|
||||
ServersCancel();
|
||||
}
|
||||
|
||||
void DoCancel( void )
|
||||
{
|
||||
ClientCmd( "togglebrowser\n" );
|
||||
}
|
||||
|
||||
void DoConnect( void )
|
||||
{
|
||||
const char *info;
|
||||
const char *address;
|
||||
char sz[ 256 ];
|
||||
|
||||
info = ServersGetInfo( m_nMouseOverRow );
|
||||
if ( !info )
|
||||
return;
|
||||
|
||||
address = gEngfuncs.pNetAPI->ValueForKey( info, "address" );
|
||||
//gEngfuncs.Con_Printf( "Connecting to %s\n", address );
|
||||
|
||||
sprintf( sz, "connect %s\n", address );
|
||||
|
||||
ClientCmd( sz );
|
||||
|
||||
DoCancel();
|
||||
}
|
||||
|
||||
void DoPing( void )
|
||||
{
|
||||
ServerPing( 0 );
|
||||
ServerRules( 0 );
|
||||
ServerPlayers( 0 );
|
||||
}
|
||||
|
||||
virtual int getRowCount()
|
||||
{
|
||||
int rowcount;
|
||||
int height, width;
|
||||
|
||||
getSize( width, height );
|
||||
|
||||
// Space for buttons
|
||||
height -= YRES(20);
|
||||
height = max( 0, height );
|
||||
|
||||
rowcount = height / CELL_HEIGHT;
|
||||
|
||||
return rowcount;
|
||||
}
|
||||
|
||||
virtual int getCellTall(int row)
|
||||
{
|
||||
return CELL_HEIGHT - 2;
|
||||
}
|
||||
|
||||
virtual Panel* getCellRenderer(int column,int row,bool columnSelected,bool rowSelected,bool cellSelected)
|
||||
{
|
||||
const char *info;
|
||||
const char *val, *val2;
|
||||
char sz[ 32 ];
|
||||
|
||||
info = ServersGetInfo( row );
|
||||
|
||||
if ( row == m_nMouseOverRow )
|
||||
{
|
||||
m_pLabel->setFgColor( 200, 240, 63, 100 );
|
||||
}
|
||||
else
|
||||
{
|
||||
m_pLabel->setFgColor( 255, 255, 255, 0 );
|
||||
}
|
||||
m_pLabel->setBgColor( 0, 0, 0, 200 );
|
||||
m_pLabel->setContentAlignment( vgui::Label::a_west );
|
||||
m_pLabel->setFont( Scheme::sf_primary2 );
|
||||
|
||||
if ( info )
|
||||
{
|
||||
// Fill out with the correct data
|
||||
switch ( column )
|
||||
{
|
||||
case 0:
|
||||
val = gEngfuncs.pNetAPI->ValueForKey( info, "address" );
|
||||
if ( val )
|
||||
{
|
||||
strncpy( sz, val, 31 );
|
||||
sz[ 31 ] = '\0';
|
||||
// Server Name;
|
||||
m_pLabel->setText( sz );
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
val = gEngfuncs.pNetAPI->ValueForKey( info, "hostname" );
|
||||
if ( val )
|
||||
{
|
||||
strncpy( sz, val, 31 );
|
||||
sz[ 31 ] = '\0';
|
||||
// Server Map;
|
||||
m_pLabel->setText( sz );
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
val = gEngfuncs.pNetAPI->ValueForKey( info, "map" );
|
||||
if ( val )
|
||||
{
|
||||
strncpy( sz, val, 31 );
|
||||
sz[ 31 ] = '\0';
|
||||
// Server Name;
|
||||
m_pLabel->setText( sz );
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
val = gEngfuncs.pNetAPI->ValueForKey( info, "current" );
|
||||
val2 = gEngfuncs.pNetAPI->ValueForKey( info, "max" );
|
||||
if ( val && val2 )
|
||||
{
|
||||
sprintf( sz, "%s/%s", val, val2 );
|
||||
sz[ 31 ] = '\0';
|
||||
// Server Map;
|
||||
m_pLabel->setText( sz );
|
||||
}
|
||||
break;
|
||||
case 4:
|
||||
val = gEngfuncs.pNetAPI->ValueForKey( info, "ping" );
|
||||
if ( val )
|
||||
{
|
||||
strncpy( sz, val, 31 );
|
||||
sz[ 31 ] = '\0';
|
||||
// Server Name;
|
||||
m_pLabel->setText( sz );
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( !row && !column )
|
||||
{
|
||||
if ( ServersIsQuerying() )
|
||||
{
|
||||
m_pLabel->setText( "Waiting for servers to respond..." );
|
||||
}
|
||||
else
|
||||
{
|
||||
m_pLabel->setText( "Press 'Refresh' to search for servers..." );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
m_pLabel->setText( "" );
|
||||
}
|
||||
}
|
||||
|
||||
return m_pLabel;
|
||||
}
|
||||
|
||||
virtual Panel* startCellEditing(int column,int row)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
class ConnectHandler : public ActionSignal
|
||||
{
|
||||
private:
|
||||
ServerBrowserTablePanel *m_pBrowser;
|
||||
|
||||
public:
|
||||
ConnectHandler( ServerBrowserTablePanel *browser )
|
||||
{
|
||||
m_pBrowser = browser;
|
||||
}
|
||||
|
||||
virtual void actionPerformed( Panel *panel )
|
||||
{
|
||||
m_pBrowser->DoConnect();
|
||||
}
|
||||
};
|
||||
|
||||
class RefreshHandler : public ActionSignal
|
||||
{
|
||||
private:
|
||||
ServerBrowserTablePanel *m_pBrowser;
|
||||
|
||||
public:
|
||||
RefreshHandler( ServerBrowserTablePanel *browser )
|
||||
{
|
||||
m_pBrowser = browser;
|
||||
}
|
||||
|
||||
virtual void actionPerformed( Panel *panel )
|
||||
{
|
||||
m_pBrowser->DoRefresh();
|
||||
}
|
||||
};
|
||||
|
||||
class BroadcastRefreshHandler : public ActionSignal
|
||||
{
|
||||
private:
|
||||
ServerBrowserTablePanel *m_pBrowser;
|
||||
|
||||
public:
|
||||
BroadcastRefreshHandler( ServerBrowserTablePanel *browser )
|
||||
{
|
||||
m_pBrowser = browser;
|
||||
}
|
||||
|
||||
virtual void actionPerformed( Panel *panel )
|
||||
{
|
||||
m_pBrowser->DoBroadcastRefresh();
|
||||
}
|
||||
};
|
||||
|
||||
class StopHandler : public ActionSignal
|
||||
{
|
||||
private:
|
||||
ServerBrowserTablePanel *m_pBrowser;
|
||||
|
||||
public:
|
||||
StopHandler( ServerBrowserTablePanel *browser )
|
||||
{
|
||||
m_pBrowser = browser;
|
||||
}
|
||||
|
||||
virtual void actionPerformed( Panel *panel )
|
||||
{
|
||||
m_pBrowser->DoStop();
|
||||
}
|
||||
};
|
||||
|
||||
class CancelHandler : public ActionSignal
|
||||
{
|
||||
private:
|
||||
ServerBrowserTablePanel *m_pBrowser;
|
||||
|
||||
public:
|
||||
CancelHandler( ServerBrowserTablePanel *browser )
|
||||
{
|
||||
m_pBrowser = browser;
|
||||
}
|
||||
|
||||
virtual void actionPerformed( Panel *panel )
|
||||
{
|
||||
m_pBrowser->DoCancel();
|
||||
}
|
||||
};
|
||||
|
||||
class PingHandler : public ActionSignal
|
||||
{
|
||||
private:
|
||||
ServerBrowserTablePanel *m_pBrowser;
|
||||
|
||||
public:
|
||||
PingHandler( ServerBrowserTablePanel *browser )
|
||||
{
|
||||
m_pBrowser = browser;
|
||||
}
|
||||
|
||||
virtual void actionPerformed( Panel *panel )
|
||||
{
|
||||
m_pBrowser->DoPing();
|
||||
}
|
||||
};
|
||||
|
||||
class SortHandler : public ActionSignal
|
||||
{
|
||||
private:
|
||||
ServerBrowserTablePanel *m_pBrowser;
|
||||
|
||||
public:
|
||||
SortHandler( ServerBrowserTablePanel *browser )
|
||||
{
|
||||
m_pBrowser = browser;
|
||||
}
|
||||
|
||||
virtual void actionPerformed( Panel *panel )
|
||||
{
|
||||
m_pBrowser->DoSort( "map" );
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
class LabelSortInputHandler : public InputSignal
|
||||
{
|
||||
private:
|
||||
ServerBrowserTablePanel *m_pBrowser;
|
||||
char m_szSortKey[ 64 ];
|
||||
|
||||
public:
|
||||
LabelSortInputHandler( ServerBrowserTablePanel *pBrowser, char *name )
|
||||
{
|
||||
m_pBrowser = pBrowser;
|
||||
strcpy( m_szSortKey, name );
|
||||
}
|
||||
|
||||
virtual void cursorMoved(int x,int y,Panel* panel) {};
|
||||
virtual void cursorEntered(Panel* panel){};
|
||||
virtual void cursorExited(Panel* Panel) {};
|
||||
|
||||
virtual void mousePressed(MouseCode code,Panel* panel)
|
||||
{
|
||||
m_pBrowser->DoSort( m_szSortKey );
|
||||
}
|
||||
|
||||
virtual void mouseDoublePressed(MouseCode code,Panel* panel)
|
||||
{
|
||||
m_pBrowser->DoSort( m_szSortKey );
|
||||
}
|
||||
|
||||
virtual void mouseReleased(MouseCode code,Panel* panel) {};
|
||||
virtual void mouseWheeled(int delta,Panel* panel) {};
|
||||
virtual void keyPressed(KeyCode code,Panel* panel) {};
|
||||
virtual void keyTyped(KeyCode code,Panel* panel) {};
|
||||
virtual void keyReleased(KeyCode code,Panel* panel) {};
|
||||
virtual void keyFocusTicked(Panel* panel) {};
|
||||
};
|
||||
|
||||
class CSBLabel : public Label
|
||||
{
|
||||
|
||||
private:
|
||||
char m_szSortKey[ 64 ];
|
||||
ServerBrowserTablePanel *m_pBrowser;
|
||||
|
||||
public:
|
||||
CSBLabel( char *name, char *sortkey ) : Label( name )
|
||||
{
|
||||
m_pBrowser = NULL;
|
||||
|
||||
strcpy( m_szSortKey, sortkey );
|
||||
|
||||
int label_bg_r = 120,
|
||||
label_bg_g = 75,
|
||||
label_bg_b = 32,
|
||||
label_bg_a = 200;
|
||||
|
||||
int label_fg_r = 255,
|
||||
label_fg_g = 0,
|
||||
label_fg_b = 0,
|
||||
label_fg_a = 0;
|
||||
|
||||
setContentAlignment( vgui::Label::a_west );
|
||||
setFgColor( label_fg_r, label_fg_g, label_fg_b, label_fg_a );
|
||||
setBgColor( label_bg_r, label_bg_g, label_bg_b, label_bg_a );
|
||||
setFont( Scheme::sf_primary2 );
|
||||
|
||||
}
|
||||
|
||||
void setTable( ServerBrowserTablePanel *browser )
|
||||
{
|
||||
m_pBrowser = browser;
|
||||
|
||||
addInputSignal( new LabelSortInputHandler( (ServerBrowserTablePanel * )m_pBrowser, m_szSortKey ) );
|
||||
}
|
||||
};
|
||||
|
||||
ServerBrowser::ServerBrowser(int x,int y,int wide,int tall) : CTransparentPanel( 100, x,y,wide,tall )
|
||||
{
|
||||
int i;
|
||||
|
||||
_headerPanel = new HeaderPanel(0,0,wide,HEADER_SIZE_Y);
|
||||
_headerPanel->setParent(this);
|
||||
_headerPanel->setFgColor( 100,100,100, 100 );
|
||||
_headerPanel->setBgColor( 0, 0, 0, 100 );
|
||||
|
||||
CSBLabel *pLabel[5];
|
||||
|
||||
pLabel[0] = new CSBLabel( "Address", "address" );
|
||||
pLabel[1] = new CSBLabel( "Server", "hostname" );
|
||||
pLabel[2] = new CSBLabel( "Map", "map" );
|
||||
pLabel[3] = new CSBLabel( "Current", "current" );
|
||||
pLabel[4] = new CSBLabel( "Latency", "ping" );
|
||||
|
||||
for ( i = 0; i < 5; i++ )
|
||||
{
|
||||
_headerPanel->addSectionPanel( pLabel[i] );
|
||||
}
|
||||
|
||||
// _headerPanel->setFont( Scheme::sf_primary1 );
|
||||
|
||||
_headerPanel->setSliderPos( 0, CSIZE_ADDRESS );
|
||||
_headerPanel->setSliderPos( 1, CSIZE_SERVER );
|
||||
_headerPanel->setSliderPos( 2, CSIZE_MAP );
|
||||
_headerPanel->setSliderPos( 3, CSIZE_CURRENT );
|
||||
_headerPanel->setSliderPos( 4, CSIZE_PING );
|
||||
|
||||
_tablePanel = new ServerBrowserTablePanel( 0, HEADER_SIZE_Y, wide, tall - HEADER_SIZE_Y, NUM_COLUMNS );
|
||||
_tablePanel->setParent(this);
|
||||
_tablePanel->setHeaderPanel(_headerPanel);
|
||||
_tablePanel->setFgColor( 100,100,100, 100 );
|
||||
_tablePanel->setBgColor( 0, 0, 0, 100 );
|
||||
|
||||
_tablePanel->addInputSignal( new CBrowser_InputSignal( (ServerBrowserTablePanel *)_tablePanel ) );
|
||||
|
||||
for ( i = 0; i < 5; i++ )
|
||||
{
|
||||
pLabel[i]->setTable( (ServerBrowserTablePanel * )_tablePanel );
|
||||
}
|
||||
|
||||
int bw = 80, bh = 15;
|
||||
int by = tall - HEADER_SIZE_Y;
|
||||
|
||||
int btnx = 10;
|
||||
|
||||
_connectButton = new CommandButton( "Connect", btnx, by, bw, bh );
|
||||
_connectButton->setParent( this );
|
||||
_connectButton->addActionSignal( new ConnectHandler( (ServerBrowserTablePanel * )_tablePanel ) );
|
||||
|
||||
btnx += bw;
|
||||
|
||||
_refreshButton = new CommandButton( "Refresh", btnx, by, bw, bh );
|
||||
_refreshButton->setParent( this );
|
||||
_refreshButton->addActionSignal( new RefreshHandler( (ServerBrowserTablePanel * )_tablePanel ) );
|
||||
|
||||
/*
|
||||
btnx += bw;
|
||||
|
||||
_broadcastRefreshButton = new CommandButton( "LAN", btnx, by, bw, bh );
|
||||
_broadcastRefreshButton->setParent( this );
|
||||
_broadcastRefreshButton->addActionSignal( new BroadcastRefreshHandler( (ServerBrowserTablePanel * )_tablePanel ) );
|
||||
*/
|
||||
|
||||
btnx += bw;
|
||||
|
||||
_stopButton = new CommandButton( "Stop", btnx, by, bw, bh );
|
||||
_stopButton->setParent( this );
|
||||
_stopButton->addActionSignal( new StopHandler( (ServerBrowserTablePanel * )_tablePanel ) );
|
||||
|
||||
/*
|
||||
btnx += bw;
|
||||
|
||||
_pingButton = new CommandButton( "Test", btnx, by, bw, bh );
|
||||
_pingButton->setParent( this );
|
||||
_pingButton->addActionSignal( new PingHandler( (ServerBrowserTablePanel * )_tablePanel ) );
|
||||
|
||||
btnx += bw;
|
||||
|
||||
_sortButton = new CommandButton( "Sort", btnx, by, bw, bh );
|
||||
_sortButton->setParent( this );
|
||||
_sortButton->addActionSignal( new SortHandler( (ServerBrowserTablePanel * )_tablePanel ) );
|
||||
*/
|
||||
|
||||
btnx += bw;
|
||||
|
||||
_cancelButton = new CommandButton( "Close", btnx, by, bw, bh );
|
||||
_cancelButton->setParent( this );
|
||||
_cancelButton->addActionSignal( new CancelHandler( (ServerBrowserTablePanel * )_tablePanel ) );
|
||||
|
||||
setPaintBorderEnabled(false);
|
||||
setPaintBackgroundEnabled(false);
|
||||
setPaintEnabled(false);
|
||||
|
||||
}
|
||||
|
||||
void ServerBrowser::setSize(int wide,int tall)
|
||||
{
|
||||
Panel::setSize(wide,tall);
|
||||
|
||||
_headerPanel->setBounds(0,0,wide,HEADER_SIZE_Y);
|
||||
_tablePanel->setBounds(0,HEADER_SIZE_Y,wide,tall - HEADER_SIZE_Y);
|
||||
|
||||
_connectButton->setBounds( 5, tall - HEADER_SIZE_Y, 75, 15 );
|
||||
_refreshButton->setBounds( 85, tall - HEADER_SIZE_Y, 75, 15 );
|
||||
/*
|
||||
_broadcastRefreshButton->setBounds( 165, tall - HEADER_SIZE_Y, 75, 15 );
|
||||
*/
|
||||
_stopButton->setBounds( 165, tall - HEADER_SIZE_Y, 75, 15 );
|
||||
/*
|
||||
_pingButton->setBounds( 325, tall - HEADER_SIZE_Y, 75, 15 );
|
||||
*/
|
||||
_cancelButton->setBounds( 245, tall - HEADER_SIZE_Y, 75, 15 );
|
||||
}
|
||||
|
||||
void CBrowser_InputSignal::mousePressed(MouseCode code,Panel* panel)
|
||||
{
|
||||
int x, y;
|
||||
int therow = 2;
|
||||
|
||||
if ( code != MOUSE_LEFT )
|
||||
return;
|
||||
|
||||
panel->getApp()->getCursorPos(x,y);
|
||||
panel->screenToLocal( x, y );
|
||||
|
||||
therow = y / CELL_HEIGHT;
|
||||
|
||||
// Figure out which row it's on
|
||||
m_pBrowser->setMouseOverRow( therow );
|
||||
}
|
||||
|
||||
void CBrowser_InputSignal::mouseDoublePressed(MouseCode code,Panel* panel)
|
||||
{
|
||||
int x, y;
|
||||
int therow = 2;
|
||||
|
||||
if ( code != MOUSE_LEFT )
|
||||
return;
|
||||
|
||||
panel->getApp()->getCursorPos(x,y);
|
||||
panel->screenToLocal( x, y );
|
||||
|
||||
therow = y / CELL_HEIGHT;
|
||||
|
||||
// Figure out which row it's on
|
||||
m_pBrowser->setMouseOverRow( therow );
|
||||
m_pBrowser->DoConnect();
|
||||
}
|
||||
|
|
@ -1,50 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#ifndef ServerBrowser_H
|
||||
#define ServerBrowser_H
|
||||
|
||||
#include<VGUI_Panel.h>
|
||||
|
||||
namespace vgui
|
||||
{
|
||||
class Button;
|
||||
class TablePanel;
|
||||
class HeaderPanel;
|
||||
}
|
||||
|
||||
class CTransparentPanel;
|
||||
class CommandButton;
|
||||
|
||||
// Scoreboard positions
|
||||
#define SB_X_INDENT (20 * ((float)ScreenHeight / 640))
|
||||
#define SB_Y_INDENT (20 * ((float)ScreenHeight / 480))
|
||||
|
||||
class ServerBrowser : public CTransparentPanel
|
||||
{
|
||||
private:
|
||||
HeaderPanel * _headerPanel;
|
||||
TablePanel* _tablePanel;
|
||||
|
||||
CommandButton* _connectButton;
|
||||
CommandButton* _refreshButton;
|
||||
CommandButton* _broadcastRefreshButton;
|
||||
CommandButton* _stopButton;
|
||||
CommandButton* _sortButton;
|
||||
CommandButton* _cancelButton;
|
||||
|
||||
CommandButton* _pingButton;
|
||||
|
||||
public:
|
||||
ServerBrowser(int x,int y,int wide,int tall);
|
||||
public:
|
||||
virtual void setSize(int wide,int tall);
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
|
|
@ -1,204 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
// vgui_SpectatorPanel.cpp: implementation of the SpectatorPanel class.
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "const.h"
|
||||
#include "entity_state.h"
|
||||
#include "cl_entity.h"
|
||||
#include "pm_shared.h"
|
||||
#include "vgui_viewport.h"
|
||||
#include "vgui_SpectatorPanel.h"
|
||||
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// Construction/Destruction
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
|
||||
SpectatorPanel::SpectatorPanel(int x,int y,int wide,int tall) : Panel(x,y,wide,tall)
|
||||
{
|
||||
}
|
||||
|
||||
SpectatorPanel::~SpectatorPanel()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void SpectatorPanel::ActionSignal(int cmd)
|
||||
{
|
||||
switch (cmd)
|
||||
{
|
||||
case SPECTATOR_PANEL_CMD_NONE : break;
|
||||
|
||||
case SPECTATOR_PANEL_CMD_OPTIONS : gViewPort->ShowCommandMenu( gViewPort->m_SpectatorMenu );
|
||||
break;
|
||||
|
||||
case SPECTATOR_PANEL_CMD_NEXTPLAYER : gHUD.m_Spectator.FindNextPlayer(true);
|
||||
break;
|
||||
|
||||
case SPECTATOR_PANEL_CMD_PREVPLAYER : gHUD.m_Spectator.FindNextPlayer(false);
|
||||
break;
|
||||
|
||||
case SPECTATOR_PANEL_CMD_HIDEMENU : ShowMenu(false);
|
||||
break;
|
||||
|
||||
|
||||
|
||||
case SPECTATOR_PANEL_CMD_TOGGLE_INSET : gHUD.m_Spectator.SetModes( -1,
|
||||
gHUD.m_Spectator.ToggleInset(false) );
|
||||
break;
|
||||
|
||||
|
||||
default : gEngfuncs.Con_DPrintf("Unknown SpectatorPanel ActionSingal %i.\n",cmd); break;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
void SpectatorPanel::Initialize()
|
||||
{
|
||||
int x,y,wide,tall;
|
||||
|
||||
getBounds(x,y,wide,tall);
|
||||
|
||||
CSchemeManager * pSchemes = gViewPort->GetSchemeManager();
|
||||
|
||||
SchemeHandle_t hTitleScheme = pSchemes->getSchemeHandle( "Title Font" );
|
||||
|
||||
m_TopBorder = new CTransparentPanel(64, 0, 0, ScreenWidth, YRES(32));
|
||||
m_TopBorder->setParent(this);
|
||||
|
||||
m_BottomBorder = new CTransparentPanel(64, 0, ScreenHeight - YRES(32), ScreenWidth, YRES(32));
|
||||
m_BottomBorder->setParent(this);
|
||||
|
||||
setPaintBackgroundEnabled(false);
|
||||
|
||||
// Initialize the bottom title.
|
||||
m_BottomMainLabel = new Label( "Spectator Bottom", XRES(6+64+6+24+6), YRES(4), XRES(428), YRES(24) );
|
||||
m_BottomMainLabel->setParent(m_BottomBorder);
|
||||
m_BottomMainLabel->setFont( pSchemes->getFont( hTitleScheme ) );
|
||||
m_BottomMainLabel->setPaintBackgroundEnabled(false);
|
||||
m_BottomMainLabel->setFgColor( Scheme::sc_primary1 );
|
||||
m_BottomMainLabel->setContentAlignment( vgui::Label::a_center );
|
||||
|
||||
LineBorder * border = new LineBorder(1, Scheme::sc_secondary1);
|
||||
m_BottomMainLabel->setBorder(border);
|
||||
m_BottomMainLabel->setPaintBorderEnabled(true);
|
||||
|
||||
// Initialize the top title.
|
||||
m_TopMainLabel = new Label( "Spectator Top", 0, 0, wide, YRES(32) );
|
||||
m_TopMainLabel->setParent(m_TopBorder);
|
||||
m_TopMainLabel->setFont( pSchemes->getFont( hTitleScheme ) );
|
||||
m_TopMainLabel->setPaintBackgroundEnabled(false);
|
||||
m_TopMainLabel->setFgColor( Scheme::sc_primary1 );
|
||||
m_TopMainLabel->setContentAlignment( vgui::Label::a_center );
|
||||
|
||||
// Initialize command buttons.
|
||||
m_OptionButton = new CommandButton("Options", XRES(6), YRES(6), XRES(64), YRES(20) );
|
||||
m_OptionButton->setParent( m_BottomBorder );
|
||||
m_OptionButton->setContentAlignment( vgui::Label::a_center );
|
||||
m_OptionButton->setBoundKey( (char)255 ); // special no bound to avoid leading spaces in name
|
||||
m_OptionButton->addActionSignal( new CSpectatorHandler_Command(this,SPECTATOR_PANEL_CMD_OPTIONS) );
|
||||
|
||||
m_PrevPlayerButton= new CommandButton("<<", XRES(6+64+6), YRES(6), XRES(24), YRES(20) );
|
||||
m_PrevPlayerButton->setParent( m_BottomBorder );
|
||||
m_PrevPlayerButton->setContentAlignment( vgui::Label::a_center );
|
||||
m_PrevPlayerButton->setBoundKey( (char)255 ); // special no bound to avoid leading spaces in name
|
||||
m_PrevPlayerButton->addActionSignal( new CSpectatorHandler_Command(this,SPECTATOR_PANEL_CMD_PREVPLAYER) );
|
||||
|
||||
m_NextPlayerButton= new CommandButton(">>", XRES(640-6-64-6-24), YRES(6), XRES(24), YRES(20) );
|
||||
m_NextPlayerButton->setParent( m_BottomBorder );
|
||||
m_NextPlayerButton->setContentAlignment( vgui::Label::a_center );
|
||||
m_NextPlayerButton->setBoundKey( (char)255 ); // special no bound to avoid leading spaces in name
|
||||
m_NextPlayerButton->addActionSignal( new CSpectatorHandler_Command(this,SPECTATOR_PANEL_CMD_NEXTPLAYER) );
|
||||
|
||||
m_HideButton = new CommandButton("Hide", XRES(640-6-64), YRES(6), XRES(64), YRES(20) );
|
||||
m_HideButton->setParent( m_BottomBorder );
|
||||
m_HideButton->setContentAlignment( vgui::Label::a_center );
|
||||
m_HideButton->setBoundKey( (char)255 ); // special no bound to avoid leading spaces in name
|
||||
m_HideButton->addActionSignal( new CSpectatorHandler_Command(this,SPECTATOR_PANEL_CMD_HIDEMENU) );
|
||||
|
||||
|
||||
m_InsetViewButton = new CommandButton("", XRES(2), YRES(2), XRES(240), YRES(180) );
|
||||
m_InsetViewButton->setParent( this );
|
||||
m_InsetViewButton->addActionSignal( new CSpectatorHandler_Command(this,SPECTATOR_PANEL_CMD_TOGGLE_INSET) );
|
||||
|
||||
|
||||
m_menuVisible = false;
|
||||
m_HideButton->setVisible(false);
|
||||
m_OptionButton->setVisible(false);
|
||||
m_NextPlayerButton->setVisible(false);
|
||||
m_PrevPlayerButton->setVisible(false);
|
||||
m_BottomMainLabel->setPaintBorderEnabled(false);
|
||||
m_TopMainLabel->setVisible(false);
|
||||
|
||||
}
|
||||
|
||||
void SpectatorPanel::ShowMenu(bool isVisible)
|
||||
{
|
||||
m_HideButton->setVisible(isVisible);
|
||||
m_OptionButton->setVisible(isVisible);
|
||||
m_NextPlayerButton->setVisible(isVisible);
|
||||
m_PrevPlayerButton->setVisible(isVisible);
|
||||
m_BottomMainLabel->setPaintBorderEnabled(isVisible);
|
||||
m_TopMainLabel->setVisible(isVisible);
|
||||
|
||||
if ( !isVisible )
|
||||
{
|
||||
gViewPort->HideCommandMenu();
|
||||
|
||||
// if switching from visible menu to invisible menu, show help text
|
||||
if ( m_menuVisible && this->isVisible() )
|
||||
{
|
||||
char string[ 64 ];
|
||||
|
||||
_snprintf( string, sizeof( string ) - 1, "%c%s", HUD_PRINTCENTER, CHudTextMessage::BufferedLocaliseTextString( "#Spec_Duck" ) );
|
||||
string[ sizeof( string ) - 1 ] = '\0';
|
||||
|
||||
gHUD.m_TextMessage.MsgFunc_TextMsg( NULL, strlen( string ) + 1, string );
|
||||
}
|
||||
}
|
||||
|
||||
m_menuVisible = isVisible;
|
||||
|
||||
gViewPort->UpdateCursorState();
|
||||
}
|
||||
|
||||
void SpectatorPanel::EnableInsetView(bool isEnabled)
|
||||
{
|
||||
int x = gHUD.m_Spectator.m_OverviewData.insetWindowX;
|
||||
int y = gHUD.m_Spectator.m_OverviewData.insetWindowY;
|
||||
int wide = gHUD.m_Spectator.m_OverviewData.insetWindowWidth;
|
||||
int tall = gHUD.m_Spectator.m_OverviewData.insetWindowHeight;
|
||||
|
||||
if ( isEnabled )
|
||||
{
|
||||
// short black bar to see full inset
|
||||
m_TopBorder->setBounds( XRES(x+wide+2), 0, XRES(640 - (x+wide+2) ), YRES(32) );
|
||||
|
||||
m_TopMainLabel->setBounds( 0, 0, XRES(640 - (x+wide+2)), YRES(32) );
|
||||
|
||||
m_InsetViewButton->setBounds( XRES( x ), YRES( y ),
|
||||
XRES( wide ), YRES( tall ) );
|
||||
m_InsetViewButton->setVisible(true);
|
||||
}
|
||||
else
|
||||
{
|
||||
// full black bar, no inset border
|
||||
m_TopBorder->setBounds( 0, 0, ScreenWidth, YRES(32) );
|
||||
m_TopMainLabel->setBounds( 0, 0, ScreenWidth, YRES(32) );
|
||||
m_InsetViewButton->setVisible(false);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,93 +0,0 @@
|
|||
|
||||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
// vgui_SpectatorPanel.h: interface for the SpectatorPanel class.
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef SPECTATORPANEL_H
|
||||
#define SPECTATORPANEL_H
|
||||
|
||||
#include <VGUI_Panel.h>
|
||||
#include <VGUI_Label.h>
|
||||
#include <VGUI_Button.h>
|
||||
|
||||
using namespace vgui;
|
||||
|
||||
#define SPECTATOR_PANEL_CMD_NONE 0
|
||||
|
||||
#define SPECTATOR_PANEL_CMD_OPTIONS 1
|
||||
#define SPECTATOR_PANEL_CMD_PREVPLAYER 2
|
||||
#define SPECTATOR_PANEL_CMD_NEXTPLAYER 3
|
||||
#define SPECTATOR_PANEL_CMD_HIDEMENU 4
|
||||
#define SPECTATOR_PANEL_CMD_TOGGLE_INSET 5
|
||||
|
||||
|
||||
class SpectatorPanel : public Panel //, public vgui::CDefaultInputSignal
|
||||
{
|
||||
|
||||
public:
|
||||
SpectatorPanel(int x,int y,int wide,int tall);
|
||||
virtual ~SpectatorPanel();
|
||||
|
||||
void ActionSignal(int cmd);
|
||||
|
||||
// InputSignal overrides.
|
||||
public:
|
||||
void Initialize();
|
||||
|
||||
|
||||
|
||||
|
||||
public:
|
||||
|
||||
void EnableInsetView(bool isEnabled);
|
||||
void ShowMenu(bool isVisible);
|
||||
|
||||
|
||||
CommandButton * m_OptionButton;
|
||||
CommandButton * m_HideButton;
|
||||
CommandButton * m_PrevPlayerButton;
|
||||
CommandButton * m_NextPlayerButton;
|
||||
|
||||
CTransparentPanel * m_TopBorder;
|
||||
CTransparentPanel * m_BottomBorder;
|
||||
|
||||
CommandButton * m_InsetViewButton;
|
||||
|
||||
Label * m_TopMainLabel;
|
||||
Label * m_BottomMainLabel;
|
||||
|
||||
|
||||
bool m_menuVisible;
|
||||
};
|
||||
|
||||
|
||||
|
||||
class CSpectatorHandler_Command : public ActionSignal
|
||||
{
|
||||
|
||||
private:
|
||||
SpectatorPanel * m_pFather;
|
||||
int m_cmd;
|
||||
|
||||
public:
|
||||
CSpectatorHandler_Command( SpectatorPanel * panel, int cmd )
|
||||
{
|
||||
m_pFather = panel;
|
||||
m_cmd = cmd;
|
||||
}
|
||||
|
||||
virtual void actionPerformed( Panel * panel )
|
||||
{
|
||||
m_pFather->ActionSignal(m_cmd);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
#endif // !defined SPECTATORPANEL_H
|
||||
|
|
@ -1,128 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#include"vgui_int.h"
|
||||
#include<VGUI_Label.h>
|
||||
#include<VGUI_BorderLayout.h>
|
||||
#include<VGUI_LineBorder.h>
|
||||
#include<VGUI_SurfaceBase.h>
|
||||
#include<VGUI_TextEntry.h>
|
||||
#include<VGUI_ActionSignal.h>
|
||||
#include<string.h>
|
||||
#include "hud.h"
|
||||
#include "cl_util.h"
|
||||
#include "camera.h"
|
||||
#include "kbutton.h"
|
||||
#include "cvardef.h"
|
||||
#include "usercmd.h"
|
||||
#include "const.h"
|
||||
#include "camera.h"
|
||||
#include "in_defs.h"
|
||||
#include "vgui_viewport.h"
|
||||
#include "vgui_ControlConfigPanel.h"
|
||||
|
||||
namespace
|
||||
{
|
||||
|
||||
class TexturePanel : public Panel , public ActionSignal
|
||||
{
|
||||
private:
|
||||
int _bindIndex;
|
||||
TextEntry* _textEntry;
|
||||
public:
|
||||
TexturePanel() : Panel(0,0,256,276)
|
||||
{
|
||||
_bindIndex=2700;
|
||||
_textEntry=new TextEntry("2700",0,0,128,20);
|
||||
_textEntry->setParent(this);
|
||||
_textEntry->addActionSignal(this);
|
||||
}
|
||||
public:
|
||||
virtual bool isWithin(int x,int y)
|
||||
{
|
||||
return _textEntry->isWithin(x,y);
|
||||
}
|
||||
public:
|
||||
virtual void actionPerformed(Panel* panel)
|
||||
{
|
||||
char buf[256];
|
||||
_textEntry->getText(0,buf,256);
|
||||
sscanf(buf,"%d",&_bindIndex);
|
||||
}
|
||||
protected:
|
||||
virtual void paintBackground()
|
||||
{
|
||||
Panel::paintBackground();
|
||||
|
||||
int wide,tall;
|
||||
getPaintSize(wide,tall);
|
||||
|
||||
drawSetColor(0,0,255,0);
|
||||
drawSetTexture(_bindIndex);
|
||||
drawTexturedRect(0,19,257,257);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
using namespace vgui;
|
||||
|
||||
void VGui_ViewportPaintBackground(int extents[4])
|
||||
{
|
||||
gEngfuncs.VGui_ViewportPaintBackground(extents);
|
||||
}
|
||||
|
||||
void* VGui_GetPanel()
|
||||
{
|
||||
return (Panel*)gEngfuncs.VGui_GetPanel();
|
||||
}
|
||||
|
||||
void VGui_Startup()
|
||||
{
|
||||
Panel* root=(Panel*)VGui_GetPanel();
|
||||
root->setBgColor(128,128,0,0);
|
||||
//root->setNonPainted(false);
|
||||
//root->setBorder(new LineBorder());
|
||||
root->setLayout(new BorderLayout(0));
|
||||
|
||||
|
||||
//root->getSurfaceBase()->setEmulatedCursorVisible(true);
|
||||
|
||||
if (gViewPort != NULL)
|
||||
{
|
||||
// root->removeChild(gViewPort);
|
||||
|
||||
// free the memory
|
||||
// delete gViewPort;
|
||||
// gViewPort = NULL;
|
||||
|
||||
gViewPort->Initialize();
|
||||
}
|
||||
else
|
||||
{
|
||||
gViewPort = new TeamFortressViewport(0,0,root->getWide(),root->getTall());
|
||||
gViewPort->setParent(root);
|
||||
}
|
||||
|
||||
/*
|
||||
TexturePanel* texturePanel=new TexturePanel();
|
||||
texturePanel->setParent(gViewPort);
|
||||
*/
|
||||
|
||||
}
|
||||
|
||||
void VGui_Shutdown()
|
||||
{
|
||||
delete gViewPort;
|
||||
gViewPort = NULL;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#ifndef VGUI_INT_H
|
||||
#define VGUI_INT_H
|
||||
|
||||
extern "C"
|
||||
{
|
||||
void VGui_Startup();
|
||||
void VGui_Shutdown();
|
||||
|
||||
//Only safe to call from inside subclass of Panel::paintBackground
|
||||
void VGui_ViewportPaintBackground(int extents[4]);
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
1677
dmc/cl_dll/view.cpp
1677
dmc/cl_dll/view.cpp
File diff suppressed because it is too large
Load Diff
|
|
@ -1,15 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#if !defined ( VIEWH )
|
||||
#define VIEWH
|
||||
#pragma once
|
||||
|
||||
void V_StartPitchDrift( void );
|
||||
void V_StopPitchDrift( void );
|
||||
|
||||
#endif // !VIEWH
|
||||
|
|
@ -1,885 +0,0 @@
|
|||
//========= Copyright <20> 1996-2001, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
// There are hud.h's coming out of the woodwork so this ensures that we get the right one.
|
||||
#if defined(THREEWAVE) || defined(DMC_BUILD)
|
||||
#include "../dmc/cl_dll/hud.h"
|
||||
#elif defined(CSTRIKE)
|
||||
#include "../cstrike/cl_dll/hud.h"
|
||||
#elif defined(DOD)
|
||||
#include "../dod/cl_dll/hud.h"
|
||||
#else
|
||||
#include "hud.h"
|
||||
#endif
|
||||
|
||||
#include "cl_util.h"
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include "parsemsg.h"
|
||||
#include "hud_servers.h"
|
||||
#include "demo.h"
|
||||
#include "demo_api.h"
|
||||
#include "voice_status.h"
|
||||
#include "r_efx.h"
|
||||
#include "entity_types.h"
|
||||
#include "VGUI_ActionSignal.h"
|
||||
#include "VGUI_Scheme.h"
|
||||
#include "VGUI_TextImage.h"
|
||||
#include "vgui_loadtga.h"
|
||||
#include "vgui_helpers.h"
|
||||
#include "VGUI_MouseCode.h"
|
||||
|
||||
|
||||
|
||||
using namespace vgui;
|
||||
|
||||
|
||||
extern int cam_thirdperson;
|
||||
|
||||
|
||||
#define VOICE_MODEL_INTERVAL 0.3
|
||||
#define SCOREBOARD_BLINK_FREQUENCY 0.3 // How often to blink the scoreboard icons.
|
||||
#define SQUELCHOSCILLATE_PER_SECOND 2.0f
|
||||
|
||||
|
||||
extern BitmapTGA *LoadTGA( const char* pImageName );
|
||||
|
||||
|
||||
|
||||
// ---------------------------------------------------------------------- //
|
||||
// The voice manager for the client.
|
||||
// ---------------------------------------------------------------------- //
|
||||
CVoiceStatus g_VoiceStatus;
|
||||
|
||||
CVoiceStatus* GetClientVoiceMgr()
|
||||
{
|
||||
return &g_VoiceStatus;
|
||||
}
|
||||
|
||||
|
||||
|
||||
// ---------------------------------------------------------------------- //
|
||||
// CVoiceStatus.
|
||||
// ---------------------------------------------------------------------- //
|
||||
|
||||
static CVoiceStatus *g_pInternalVoiceStatus = NULL;
|
||||
|
||||
int __MsgFunc_VoiceMask(const char *pszName, int iSize, void *pbuf)
|
||||
{
|
||||
if(g_pInternalVoiceStatus)
|
||||
g_pInternalVoiceStatus->HandleVoiceMaskMsg(iSize, pbuf);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int __MsgFunc_ReqState(const char *pszName, int iSize, void *pbuf)
|
||||
{
|
||||
if(g_pInternalVoiceStatus)
|
||||
g_pInternalVoiceStatus->HandleReqStateMsg(iSize, pbuf);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int g_BannedPlayerPrintCount;
|
||||
void ForEachBannedPlayer(char id[16])
|
||||
{
|
||||
char str[256];
|
||||
sprintf(str, "Ban %d: %2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x\n",
|
||||
g_BannedPlayerPrintCount++,
|
||||
id[0], id[1], id[2], id[3],
|
||||
id[4], id[5], id[6], id[7],
|
||||
id[8], id[9], id[10], id[11],
|
||||
id[12], id[13], id[14], id[15]
|
||||
);
|
||||
#ifdef _WIN32
|
||||
strupr(str);
|
||||
#endif
|
||||
gEngfuncs.pfnConsolePrint(str);
|
||||
}
|
||||
|
||||
|
||||
void ShowBannedCallback()
|
||||
{
|
||||
if(g_pInternalVoiceStatus)
|
||||
{
|
||||
g_BannedPlayerPrintCount = 0;
|
||||
gEngfuncs.pfnConsolePrint("------- BANNED PLAYERS -------\n");
|
||||
g_pInternalVoiceStatus->m_BanMgr.ForEachBannedPlayer(ForEachBannedPlayer);
|
||||
gEngfuncs.pfnConsolePrint("------------------------------\n");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ---------------------------------------------------------------------- //
|
||||
// CVoiceStatus.
|
||||
// ---------------------------------------------------------------------- //
|
||||
|
||||
CVoiceStatus::CVoiceStatus()
|
||||
{
|
||||
m_bBanMgrInitialized = false;
|
||||
m_LastUpdateServerState = 0;
|
||||
|
||||
m_pSpeakerLabelIcon = NULL;
|
||||
m_pScoreboardNeverSpoken = NULL;
|
||||
m_pScoreboardNotSpeaking = NULL;
|
||||
m_pScoreboardSpeaking = NULL;
|
||||
m_pScoreboardSpeaking2 = NULL;
|
||||
m_pScoreboardSquelch = NULL;
|
||||
m_pScoreboardBanned = NULL;
|
||||
|
||||
m_pLocalBitmap = NULL;
|
||||
m_pAckBitmap = NULL;
|
||||
|
||||
m_bTalking = m_bServerAcked = false;
|
||||
|
||||
memset(m_pBanButtons, 0, sizeof(m_pBanButtons));
|
||||
|
||||
m_pParentPanel = NULL;
|
||||
|
||||
m_bServerModEnable = -1;
|
||||
|
||||
m_pchGameDir = NULL;
|
||||
}
|
||||
|
||||
|
||||
CVoiceStatus::~CVoiceStatus()
|
||||
{
|
||||
g_pInternalVoiceStatus = NULL;
|
||||
|
||||
for(int i=0; i < MAX_VOICE_SPEAKERS; i++)
|
||||
{
|
||||
delete m_Labels[i].m_pLabel;
|
||||
m_Labels[i].m_pLabel = NULL;
|
||||
|
||||
delete m_Labels[i].m_pIcon;
|
||||
m_Labels[i].m_pIcon = NULL;
|
||||
|
||||
delete m_Labels[i].m_pBackground;
|
||||
m_Labels[i].m_pBackground = NULL;
|
||||
}
|
||||
|
||||
delete m_pLocalLabel;
|
||||
m_pLocalLabel = NULL;
|
||||
|
||||
FreeBitmaps();
|
||||
|
||||
if(m_pchGameDir)
|
||||
{
|
||||
if(m_bBanMgrInitialized)
|
||||
{
|
||||
m_BanMgr.SaveState(m_pchGameDir);
|
||||
}
|
||||
|
||||
free(m_pchGameDir);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int CVoiceStatus::Init(
|
||||
IVoiceStatusHelper *pHelper,
|
||||
Panel **pParentPanel)
|
||||
{
|
||||
// Setup the voice_modenable cvar.
|
||||
gEngfuncs.pfnRegisterVariable("voice_modenable", "1", FCVAR_ARCHIVE);
|
||||
|
||||
gEngfuncs.pfnRegisterVariable("voice_clientdebug", "0", 0);
|
||||
|
||||
gEngfuncs.pfnAddCommand("voice_showbanned", ShowBannedCallback);
|
||||
|
||||
if(gEngfuncs.pfnGetGameDirectory())
|
||||
{
|
||||
m_BanMgr.Init(gEngfuncs.pfnGetGameDirectory());
|
||||
m_bBanMgrInitialized = true;
|
||||
}
|
||||
|
||||
assert(!g_pInternalVoiceStatus);
|
||||
g_pInternalVoiceStatus = this;
|
||||
|
||||
m_BlinkTimer = 0;
|
||||
m_VoiceHeadModel = NULL;
|
||||
memset(m_Labels, 0, sizeof(m_Labels));
|
||||
|
||||
for(int i=0; i < MAX_VOICE_SPEAKERS; i++)
|
||||
{
|
||||
CVoiceLabel *pLabel = &m_Labels[i];
|
||||
|
||||
pLabel->m_pBackground = new Label("");
|
||||
|
||||
if(pLabel->m_pLabel = new Label(""))
|
||||
{
|
||||
pLabel->m_pLabel->setVisible( true );
|
||||
pLabel->m_pLabel->setFont( Scheme::sf_primary2 );
|
||||
pLabel->m_pLabel->setTextAlignment( Label::a_east );
|
||||
pLabel->m_pLabel->setContentAlignment( Label::a_east );
|
||||
pLabel->m_pLabel->setParent( pLabel->m_pBackground );
|
||||
}
|
||||
|
||||
if( pLabel->m_pIcon = new ImagePanel( NULL ) )
|
||||
{
|
||||
pLabel->m_pIcon->setVisible( true );
|
||||
pLabel->m_pIcon->setParent( pLabel->m_pBackground );
|
||||
}
|
||||
|
||||
pLabel->m_clientindex = -1;
|
||||
}
|
||||
|
||||
m_pLocalLabel = new ImagePanel(NULL);
|
||||
|
||||
m_bInSquelchMode = false;
|
||||
|
||||
m_pHelper = pHelper;
|
||||
m_pParentPanel = pParentPanel;
|
||||
gHUD.AddHudElem(this);
|
||||
m_iFlags = HUD_ACTIVE;
|
||||
HOOK_MESSAGE(VoiceMask);
|
||||
HOOK_MESSAGE(ReqState);
|
||||
|
||||
// Cache the game directory for use when we shut down
|
||||
const char *pchGameDirT = gEngfuncs.pfnGetGameDirectory();
|
||||
m_pchGameDir = (char *)malloc(strlen(pchGameDirT) + 1);
|
||||
strcpy(m_pchGameDir, pchGameDirT);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int CVoiceStatus::VidInit()
|
||||
{
|
||||
FreeBitmaps();
|
||||
|
||||
|
||||
if( m_pLocalBitmap = vgui_LoadTGA("gfx/vgui/icntlk_pl.tga") )
|
||||
{
|
||||
m_pLocalBitmap->setColor(Color(255,255,255,135));
|
||||
}
|
||||
|
||||
if( m_pAckBitmap = vgui_LoadTGA("gfx/vgui/icntlk_sv.tga") )
|
||||
{
|
||||
m_pAckBitmap->setColor(Color(255,255,255,135)); // Give just a tiny bit of translucency so software draws correctly.
|
||||
}
|
||||
|
||||
m_pLocalLabel->setImage( m_pLocalBitmap );
|
||||
m_pLocalLabel->setVisible( false );
|
||||
|
||||
|
||||
if( m_pSpeakerLabelIcon = vgui_LoadTGANoInvertAlpha("gfx/vgui/speaker4.tga" ) )
|
||||
m_pSpeakerLabelIcon->setColor( Color(255,255,255,1) ); // Give just a tiny bit of translucency so software draws correctly.
|
||||
|
||||
if (m_pScoreboardNeverSpoken = vgui_LoadTGANoInvertAlpha("gfx/vgui/640_speaker1.tga"))
|
||||
m_pScoreboardNeverSpoken->setColor(Color(255,255,255,1)); // Give just a tiny bit of translucency so software draws correctly.
|
||||
|
||||
if(m_pScoreboardNotSpeaking = vgui_LoadTGANoInvertAlpha("gfx/vgui/640_speaker2.tga"))
|
||||
m_pScoreboardNotSpeaking->setColor(Color(255,255,255,1)); // Give just a tiny bit of translucency so software draws correctly.
|
||||
|
||||
if(m_pScoreboardSpeaking = vgui_LoadTGANoInvertAlpha("gfx/vgui/640_speaker3.tga"))
|
||||
m_pScoreboardSpeaking->setColor(Color(255,255,255,1)); // Give just a tiny bit of translucency so software draws correctly.
|
||||
|
||||
if(m_pScoreboardSpeaking2 = vgui_LoadTGANoInvertAlpha("gfx/vgui/640_speaker4.tga"))
|
||||
m_pScoreboardSpeaking2->setColor(Color(255,255,255,1)); // Give just a tiny bit of translucency so software draws correctly.
|
||||
|
||||
if(m_pScoreboardSquelch = vgui_LoadTGA("gfx/vgui/icntlk_squelch.tga"))
|
||||
m_pScoreboardSquelch->setColor(Color(255,255,255,1)); // Give just a tiny bit of translucency so software draws correctly.
|
||||
|
||||
if(m_pScoreboardBanned = vgui_LoadTGA("gfx/vgui/640_voiceblocked.tga"))
|
||||
m_pScoreboardBanned->setColor(Color(255,255,255,1)); // Give just a tiny bit of translucency so software draws correctly.
|
||||
|
||||
// Figure out the voice head model height.
|
||||
m_VoiceHeadModelHeight = 45;
|
||||
char *pFile = (char *)gEngfuncs.COM_LoadFile("scripts/voicemodel.txt", 5, NULL);
|
||||
if(pFile)
|
||||
{
|
||||
char token[4096];
|
||||
gEngfuncs.COM_ParseFile(pFile, token);
|
||||
if(token[0] >= '0' && token[0] <= '9')
|
||||
{
|
||||
m_VoiceHeadModelHeight = (float)atof(token);
|
||||
}
|
||||
|
||||
gEngfuncs.COM_FreeFile(pFile);
|
||||
}
|
||||
|
||||
m_VoiceHeadModel = gEngfuncs.pfnSPR_Load("sprites/voiceicon.spr");
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
void CVoiceStatus::Frame(double frametime)
|
||||
{
|
||||
// check server banned players once per second
|
||||
if(gEngfuncs.GetClientTime() - m_LastUpdateServerState > 1)
|
||||
{
|
||||
UpdateServerState(false);
|
||||
}
|
||||
|
||||
m_BlinkTimer += frametime;
|
||||
|
||||
// Update speaker labels.
|
||||
if( m_pHelper->CanShowSpeakerLabels() )
|
||||
{
|
||||
for( int i=0; i < MAX_VOICE_SPEAKERS; i++ )
|
||||
m_Labels[i].m_pBackground->setVisible( m_Labels[i].m_clientindex != -1 );
|
||||
}
|
||||
else
|
||||
{
|
||||
for( int i=0; i < MAX_VOICE_SPEAKERS; i++ )
|
||||
m_Labels[i].m_pBackground->setVisible( false );
|
||||
}
|
||||
|
||||
for(int i=0; i < VOICE_MAX_PLAYERS; i++)
|
||||
UpdateBanButton(i);
|
||||
}
|
||||
|
||||
|
||||
void CVoiceStatus::CreateEntities()
|
||||
{
|
||||
if(!m_VoiceHeadModel)
|
||||
return;
|
||||
|
||||
cl_entity_t *localPlayer = gEngfuncs.GetLocalPlayer();
|
||||
|
||||
int iOutModel = 0;
|
||||
for(int i=0; i < VOICE_MAX_PLAYERS; i++)
|
||||
{
|
||||
if(!m_VoicePlayers[i])
|
||||
continue;
|
||||
|
||||
cl_entity_s *pClient = gEngfuncs.GetEntityByIndex(i+1);
|
||||
|
||||
// Don't show an icon if the player is not in our PVS.
|
||||
if(!pClient || pClient->curstate.messagenum < localPlayer->curstate.messagenum)
|
||||
continue;
|
||||
|
||||
// Don't show an icon for dead or spectating players (ie: invisible entities).
|
||||
if(pClient->curstate.effects & EF_NODRAW)
|
||||
continue;
|
||||
|
||||
// Don't show an icon for the local player unless we're in thirdperson mode.
|
||||
if(pClient == localPlayer && !cam_thirdperson)
|
||||
continue;
|
||||
|
||||
cl_entity_s *pEnt = &m_VoiceHeadModels[iOutModel];
|
||||
++iOutModel;
|
||||
|
||||
memset(pEnt, 0, sizeof(*pEnt));
|
||||
|
||||
pEnt->curstate.rendermode = kRenderTransAdd;
|
||||
pEnt->curstate.renderamt = 255;
|
||||
pEnt->baseline.renderamt = 255;
|
||||
pEnt->curstate.renderfx = kRenderFxNoDissipation;
|
||||
pEnt->curstate.framerate = 1;
|
||||
pEnt->curstate.frame = 0;
|
||||
pEnt->model = (struct model_s*)gEngfuncs.GetSpritePointer(m_VoiceHeadModel);
|
||||
pEnt->angles[0] = pEnt->angles[1] = pEnt->angles[2] = 0;
|
||||
pEnt->curstate.scale = 0.5f;
|
||||
|
||||
pEnt->origin[0] = pEnt->origin[1] = 0;
|
||||
pEnt->origin[2] = 45;
|
||||
|
||||
VectorAdd(pEnt->origin, pClient->origin, pEnt->origin);
|
||||
|
||||
// Tell the engine.
|
||||
gEngfuncs.CL_CreateVisibleEntity(ET_NORMAL, pEnt);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CVoiceStatus::UpdateSpeakerStatus( int entindex, qboolean bTalking )
|
||||
{
|
||||
cvar_t *pVoiceLoopback = NULL;
|
||||
|
||||
if ( !m_pParentPanel || !*m_pParentPanel )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if ( gEngfuncs.pfnGetCvarFloat( "voice_clientdebug" ) )
|
||||
{
|
||||
char msg[256];
|
||||
_snprintf( msg, sizeof( msg ), "CVoiceStatus::UpdateSpeakerStatus: ent %d talking = %d\n", entindex, bTalking );
|
||||
gEngfuncs.pfnConsolePrint( msg );
|
||||
}
|
||||
|
||||
int iLocalPlayerIndex = gEngfuncs.GetLocalPlayer()->index;
|
||||
|
||||
// Is it the local player talking?
|
||||
if ( entindex == -1 )
|
||||
{
|
||||
m_bTalking = !!bTalking;
|
||||
if( bTalking )
|
||||
{
|
||||
// Enable voice for them automatically if they try to talk.
|
||||
gEngfuncs.pfnClientCmd( "voice_modenable 1" );
|
||||
}
|
||||
|
||||
// now set the player index to the correct index for the local player
|
||||
// this will allow us to have the local player's icon flash in the scoreboard
|
||||
entindex = iLocalPlayerIndex;
|
||||
|
||||
pVoiceLoopback = gEngfuncs.pfnGetCvarPointer( "voice_loopback" );
|
||||
}
|
||||
else if ( entindex == -2 )
|
||||
{
|
||||
m_bServerAcked = !!bTalking;
|
||||
}
|
||||
|
||||
if ( entindex >= 0 && entindex <= VOICE_MAX_PLAYERS )
|
||||
{
|
||||
int iClient = entindex - 1;
|
||||
if ( iClient < 0 )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
CVoiceLabel *pLabel = FindVoiceLabel( iClient );
|
||||
if ( bTalking )
|
||||
{
|
||||
m_VoicePlayers[iClient] = true;
|
||||
m_VoiceEnabledPlayers[iClient] = true;
|
||||
|
||||
// If we don't have a label for this guy yet, then create one.
|
||||
if ( !pLabel )
|
||||
{
|
||||
// if this isn't the local player (unless they have voice_loopback on)
|
||||
if ( ( entindex != iLocalPlayerIndex ) || ( pVoiceLoopback && pVoiceLoopback->value ) )
|
||||
{
|
||||
if ( pLabel = GetFreeVoiceLabel() )
|
||||
{
|
||||
// Get the name from the engine.
|
||||
hud_player_info_t info;
|
||||
memset( &info, 0, sizeof( info ) );
|
||||
GetPlayerInfo( entindex, &info );
|
||||
|
||||
char paddedName[512];
|
||||
_snprintf( paddedName, sizeof( paddedName ), "%s ", info.name );
|
||||
|
||||
int color[3];
|
||||
m_pHelper->GetPlayerTextColor( entindex, color );
|
||||
|
||||
if ( pLabel->m_pBackground )
|
||||
{
|
||||
pLabel->m_pBackground->setBgColor( color[0], color[1], color[2], 135 );
|
||||
pLabel->m_pBackground->setParent( *m_pParentPanel );
|
||||
pLabel->m_pBackground->setVisible( m_pHelper->CanShowSpeakerLabels() );
|
||||
}
|
||||
|
||||
if ( pLabel->m_pLabel )
|
||||
{
|
||||
pLabel->m_pLabel->setFgColor( 255, 255, 255, 0 );
|
||||
pLabel->m_pLabel->setBgColor( 0, 0, 0, 255 );
|
||||
pLabel->m_pLabel->setText( paddedName );
|
||||
}
|
||||
|
||||
pLabel->m_clientindex = iClient;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
m_VoicePlayers[iClient] = false;
|
||||
|
||||
// If we have a label for this guy, kill it.
|
||||
if ( pLabel )
|
||||
{
|
||||
pLabel->m_pBackground->setVisible( false );
|
||||
pLabel->m_clientindex = -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
RepositionLabels();
|
||||
}
|
||||
|
||||
|
||||
void CVoiceStatus::UpdateServerState(bool bForce)
|
||||
{
|
||||
// Can't do anything when we're not in a level.
|
||||
char const *pLevelName = gEngfuncs.pfnGetLevelName();
|
||||
if( pLevelName[0] == 0 )
|
||||
{
|
||||
if( gEngfuncs.pfnGetCvarFloat("voice_clientdebug") )
|
||||
{
|
||||
gEngfuncs.pfnConsolePrint( "CVoiceStatus::UpdateServerState: pLevelName[0]==0\n" );
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
int bCVarModEnable = !!gEngfuncs.pfnGetCvarFloat("voice_modenable");
|
||||
if(bForce || m_bServerModEnable != bCVarModEnable)
|
||||
{
|
||||
m_bServerModEnable = bCVarModEnable;
|
||||
|
||||
char str[256];
|
||||
_snprintf(str, sizeof(str), "VModEnable %d", m_bServerModEnable);
|
||||
ServerCmd(str);
|
||||
|
||||
if(gEngfuncs.pfnGetCvarFloat("voice_clientdebug"))
|
||||
{
|
||||
char msg[256];
|
||||
sprintf(msg, "CVoiceStatus::UpdateServerState: Sending '%s'\n", str);
|
||||
gEngfuncs.pfnConsolePrint(msg);
|
||||
}
|
||||
}
|
||||
|
||||
char str[2048];
|
||||
sprintf(str, "vban");
|
||||
bool bChange = false;
|
||||
|
||||
for(unsigned long dw=0; dw < VOICE_MAX_PLAYERS_DW; dw++)
|
||||
{
|
||||
unsigned long serverBanMask = 0;
|
||||
unsigned long banMask = 0;
|
||||
for(unsigned long i=0; i < 32; i++)
|
||||
{
|
||||
char playerID[16];
|
||||
if(!gEngfuncs.GetPlayerUniqueID(i+1, playerID))
|
||||
continue;
|
||||
|
||||
if(m_BanMgr.GetPlayerBan(playerID))
|
||||
banMask |= 1 << i;
|
||||
|
||||
if(m_ServerBannedPlayers[dw*32 + i])
|
||||
serverBanMask |= 1 << i;
|
||||
}
|
||||
|
||||
if(serverBanMask != banMask)
|
||||
bChange = true;
|
||||
|
||||
// Ok, the server needs to be updated.
|
||||
char numStr[512];
|
||||
sprintf(numStr, " %x", banMask);
|
||||
strcat(str, numStr);
|
||||
}
|
||||
|
||||
if(bChange || bForce)
|
||||
{
|
||||
if(gEngfuncs.pfnGetCvarFloat("voice_clientdebug"))
|
||||
{
|
||||
char msg[256];
|
||||
sprintf(msg, "CVoiceStatus::UpdateServerState: Sending '%s'\n", str);
|
||||
gEngfuncs.pfnConsolePrint(msg);
|
||||
}
|
||||
|
||||
gEngfuncs.pfnServerCmdUnreliable(str); // Tell the server..
|
||||
}
|
||||
else
|
||||
{
|
||||
if (gEngfuncs.pfnGetCvarFloat("voice_clientdebug"))
|
||||
{
|
||||
gEngfuncs.pfnConsolePrint( "CVoiceStatus::UpdateServerState: no change\n" );
|
||||
}
|
||||
}
|
||||
|
||||
m_LastUpdateServerState = gEngfuncs.GetClientTime();
|
||||
}
|
||||
|
||||
void CVoiceStatus::UpdateSpeakerImage(Label *pLabel, int iPlayer)
|
||||
{
|
||||
m_pBanButtons[iPlayer-1] = pLabel;
|
||||
UpdateBanButton(iPlayer-1);
|
||||
}
|
||||
|
||||
void CVoiceStatus::UpdateBanButton(int iClient)
|
||||
{
|
||||
Label *pPanel = m_pBanButtons[iClient];
|
||||
|
||||
if (!pPanel)
|
||||
return;
|
||||
|
||||
char playerID[16];
|
||||
extern bool HACK_GetPlayerUniqueID( int iPlayer, char playerID[16] );
|
||||
if(!HACK_GetPlayerUniqueID(iClient+1, playerID))
|
||||
return;
|
||||
|
||||
// Figure out if it's blinking or not.
|
||||
bool bBlink = fmod(m_BlinkTimer, SCOREBOARD_BLINK_FREQUENCY*2) < SCOREBOARD_BLINK_FREQUENCY;
|
||||
bool bTalking = !!m_VoicePlayers[iClient];
|
||||
bool bBanned = m_BanMgr.GetPlayerBan(playerID);
|
||||
bool bNeverSpoken = !m_VoiceEnabledPlayers[iClient];
|
||||
|
||||
// Get the appropriate image to display on the panel.
|
||||
if (bBanned)
|
||||
{
|
||||
pPanel->setImage(m_pScoreboardBanned);
|
||||
}
|
||||
else if (bTalking)
|
||||
{
|
||||
if (bBlink)
|
||||
{
|
||||
pPanel->setImage(m_pScoreboardSpeaking2);
|
||||
}
|
||||
else
|
||||
{
|
||||
pPanel->setImage(m_pScoreboardSpeaking);
|
||||
}
|
||||
pPanel->setFgColor(255, 170, 0, 1);
|
||||
}
|
||||
else if (bNeverSpoken)
|
||||
{
|
||||
pPanel->setImage(m_pScoreboardNeverSpoken);
|
||||
pPanel->setFgColor(100, 100, 100, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
pPanel->setImage(m_pScoreboardNotSpeaking);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CVoiceStatus::HandleVoiceMaskMsg(int iSize, void *pbuf)
|
||||
{
|
||||
BEGIN_READ( pbuf, iSize );
|
||||
|
||||
unsigned long dw;
|
||||
for(dw=0; dw < VOICE_MAX_PLAYERS_DW; dw++)
|
||||
{
|
||||
m_AudiblePlayers.SetDWord(dw, (unsigned long)READ_LONG());
|
||||
m_ServerBannedPlayers.SetDWord(dw, (unsigned long)READ_LONG());
|
||||
|
||||
if(gEngfuncs.pfnGetCvarFloat("voice_clientdebug"))
|
||||
{
|
||||
char str[256];
|
||||
gEngfuncs.pfnConsolePrint("CVoiceStatus::HandleVoiceMaskMsg\n");
|
||||
|
||||
sprintf(str, " - m_AudiblePlayers[%d] = %lu\n", dw, m_AudiblePlayers.GetDWord(dw));
|
||||
gEngfuncs.pfnConsolePrint(str);
|
||||
|
||||
sprintf(str, " - m_ServerBannedPlayers[%d] = %lu\n", dw, m_ServerBannedPlayers.GetDWord(dw));
|
||||
gEngfuncs.pfnConsolePrint(str);
|
||||
}
|
||||
}
|
||||
|
||||
m_bServerModEnable = READ_BYTE();
|
||||
}
|
||||
|
||||
void CVoiceStatus::HandleReqStateMsg(int iSize, void *pbuf)
|
||||
{
|
||||
if(gEngfuncs.pfnGetCvarFloat("voice_clientdebug"))
|
||||
{
|
||||
gEngfuncs.pfnConsolePrint("CVoiceStatus::HandleReqStateMsg\n");
|
||||
}
|
||||
|
||||
UpdateServerState(true);
|
||||
}
|
||||
|
||||
void CVoiceStatus::StartSquelchMode()
|
||||
{
|
||||
if(m_bInSquelchMode)
|
||||
return;
|
||||
|
||||
m_bInSquelchMode = true;
|
||||
m_pHelper->UpdateCursorState();
|
||||
}
|
||||
|
||||
void CVoiceStatus::StopSquelchMode()
|
||||
{
|
||||
m_bInSquelchMode = false;
|
||||
m_pHelper->UpdateCursorState();
|
||||
}
|
||||
|
||||
bool CVoiceStatus::IsInSquelchMode()
|
||||
{
|
||||
return m_bInSquelchMode;
|
||||
}
|
||||
|
||||
CVoiceLabel* CVoiceStatus::FindVoiceLabel(int clientindex)
|
||||
{
|
||||
for(int i=0; i < MAX_VOICE_SPEAKERS; i++)
|
||||
{
|
||||
if(m_Labels[i].m_clientindex == clientindex)
|
||||
return &m_Labels[i];
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
CVoiceLabel* CVoiceStatus::GetFreeVoiceLabel()
|
||||
{
|
||||
return FindVoiceLabel(-1);
|
||||
}
|
||||
|
||||
|
||||
void CVoiceStatus::RepositionLabels()
|
||||
{
|
||||
// find starting position to draw from, along right-hand side of screen
|
||||
int y = ScreenHeight / 2;
|
||||
|
||||
int iconWide = 8, iconTall = 8;
|
||||
if( m_pSpeakerLabelIcon )
|
||||
{
|
||||
m_pSpeakerLabelIcon->getSize( iconWide, iconTall );
|
||||
}
|
||||
|
||||
// Reposition active labels.
|
||||
for(int i = 0; i < MAX_VOICE_SPEAKERS; i++)
|
||||
{
|
||||
CVoiceLabel *pLabel = &m_Labels[i];
|
||||
|
||||
if( pLabel->m_clientindex == -1 || !pLabel->m_pLabel )
|
||||
{
|
||||
if( pLabel->m_pBackground )
|
||||
pLabel->m_pBackground->setVisible( false );
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
int textWide, textTall;
|
||||
pLabel->m_pLabel->getContentSize( textWide, textTall );
|
||||
|
||||
// Don't let it stretch too far across their screen.
|
||||
if( textWide > (ScreenWidth*2)/3 )
|
||||
textWide = (ScreenWidth*2)/3;
|
||||
|
||||
// Setup the background label to fit everything in.
|
||||
int border = 2;
|
||||
int bgWide = textWide + iconWide + border*3;
|
||||
int bgTall = max( textTall, iconTall ) + border*2;
|
||||
pLabel->m_pBackground->setBounds( ScreenWidth - bgWide - 8, y, bgWide, bgTall );
|
||||
|
||||
// Put the text at the left.
|
||||
pLabel->m_pLabel->setBounds( border, (bgTall - textTall) / 2, textWide, textTall );
|
||||
|
||||
// Put the icon at the right.
|
||||
int iconLeft = border + textWide + border;
|
||||
int iconTop = (bgTall - iconTall) / 2;
|
||||
if( pLabel->m_pIcon )
|
||||
{
|
||||
pLabel->m_pIcon->setImage( m_pSpeakerLabelIcon );
|
||||
pLabel->m_pIcon->setBounds( iconLeft, iconTop, iconWide, iconTall );
|
||||
}
|
||||
|
||||
y += bgTall + 2;
|
||||
}
|
||||
|
||||
if( m_pLocalBitmap && m_pAckBitmap && m_pLocalLabel && (m_bTalking || m_bServerAcked) )
|
||||
{
|
||||
m_pLocalLabel->setParent(*m_pParentPanel);
|
||||
m_pLocalLabel->setVisible( true );
|
||||
|
||||
if( m_bServerAcked && !!gEngfuncs.pfnGetCvarFloat("voice_clientdebug") )
|
||||
m_pLocalLabel->setImage( m_pAckBitmap );
|
||||
else
|
||||
m_pLocalLabel->setImage( m_pLocalBitmap );
|
||||
|
||||
int sizeX, sizeY;
|
||||
m_pLocalBitmap->getSize(sizeX, sizeY);
|
||||
|
||||
int local_xPos = ScreenWidth - sizeX - 10;
|
||||
int local_yPos = m_pHelper->GetAckIconHeight() - sizeY;
|
||||
|
||||
m_pLocalLabel->setPos( local_xPos, local_yPos );
|
||||
}
|
||||
else
|
||||
{
|
||||
m_pLocalLabel->setVisible( false );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CVoiceStatus::FreeBitmaps()
|
||||
{
|
||||
// Delete all the images we have loaded.
|
||||
delete m_pLocalBitmap;
|
||||
m_pLocalBitmap = NULL;
|
||||
|
||||
delete m_pAckBitmap;
|
||||
m_pAckBitmap = NULL;
|
||||
|
||||
delete m_pSpeakerLabelIcon;
|
||||
m_pSpeakerLabelIcon = NULL;
|
||||
|
||||
delete m_pScoreboardNeverSpoken;
|
||||
m_pScoreboardNeverSpoken = NULL;
|
||||
|
||||
delete m_pScoreboardNotSpeaking;
|
||||
m_pScoreboardNotSpeaking = NULL;
|
||||
|
||||
delete m_pScoreboardSpeaking;
|
||||
m_pScoreboardSpeaking = NULL;
|
||||
|
||||
delete m_pScoreboardSpeaking2;
|
||||
m_pScoreboardSpeaking2 = NULL;
|
||||
|
||||
delete m_pScoreboardSquelch;
|
||||
m_pScoreboardSquelch = NULL;
|
||||
|
||||
delete m_pScoreboardBanned;
|
||||
m_pScoreboardBanned = NULL;
|
||||
|
||||
// Clear references to the images in panels.
|
||||
for(int i=0; i < VOICE_MAX_PLAYERS; i++)
|
||||
{
|
||||
if (m_pBanButtons[i])
|
||||
{
|
||||
m_pBanButtons[i]->setImage(NULL);
|
||||
}
|
||||
}
|
||||
|
||||
if(m_pLocalLabel)
|
||||
m_pLocalLabel->setImage(NULL);
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: returns true if the target client has been banned
|
||||
// Input : playerID -
|
||||
// Output : Returns true on success, false on failure.
|
||||
//-----------------------------------------------------------------------------
|
||||
bool CVoiceStatus::IsPlayerBlocked(int iPlayer)
|
||||
{
|
||||
char playerID[16];
|
||||
if (!gEngfuncs.GetPlayerUniqueID(iPlayer, playerID))
|
||||
return false;
|
||||
|
||||
return m_BanMgr.GetPlayerBan(playerID);
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: returns true if the player can't hear the other client due to game rules (eg. the other team)
|
||||
// Input : playerID -
|
||||
// Output : Returns true on success, false on failure.
|
||||
//-----------------------------------------------------------------------------
|
||||
bool CVoiceStatus::IsPlayerAudible(int iPlayer)
|
||||
{
|
||||
return !!m_AudiblePlayers[iPlayer-1];
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: blocks/unblocks the target client from being heard
|
||||
// Input : playerID -
|
||||
// Output : Returns true on success, false on failure.
|
||||
//-----------------------------------------------------------------------------
|
||||
void CVoiceStatus::SetPlayerBlockedState(int iPlayer, bool blocked)
|
||||
{
|
||||
if (gEngfuncs.pfnGetCvarFloat("voice_clientdebug"))
|
||||
{
|
||||
gEngfuncs.pfnConsolePrint( "CVoiceStatus::SetPlayerBlockedState part 1\n" );
|
||||
}
|
||||
|
||||
char playerID[16];
|
||||
if (!gEngfuncs.GetPlayerUniqueID(iPlayer, playerID))
|
||||
return;
|
||||
|
||||
if (gEngfuncs.pfnGetCvarFloat("voice_clientdebug"))
|
||||
{
|
||||
gEngfuncs.pfnConsolePrint( "CVoiceStatus::SetPlayerBlockedState part 2\n" );
|
||||
}
|
||||
|
||||
// Squelch or (try to) unsquelch this player.
|
||||
if (gEngfuncs.pfnGetCvarFloat("voice_clientdebug"))
|
||||
{
|
||||
char str[256];
|
||||
sprintf(str, "CVoiceStatus::SetPlayerBlockedState: setting player %d ban to %d\n", iPlayer, !m_BanMgr.GetPlayerBan(playerID));
|
||||
gEngfuncs.pfnConsolePrint(str);
|
||||
}
|
||||
|
||||
m_BanMgr.SetPlayerBan( playerID, blocked );
|
||||
UpdateServerState(false);
|
||||
}
|
||||
|
|
@ -1,228 +0,0 @@
|
|||
//========= Copyright © 1996-2001, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#ifndef VOICE_STATUS_H
|
||||
#define VOICE_STATUS_H
|
||||
#pragma once
|
||||
|
||||
|
||||
#include "VGUI_Label.h"
|
||||
#include "VGUI_LineBorder.h"
|
||||
#include "VGUI_ImagePanel.h"
|
||||
#include "VGUI_BitmapTGA.h"
|
||||
#include "VGUI_InputSignal.h"
|
||||
#include "VGUI_Button.h"
|
||||
#include "voice_common.h"
|
||||
#include "cl_entity.h"
|
||||
#include "voice_banmgr.h"
|
||||
#include "vgui_checkbutton2.h"
|
||||
#include "vgui_defaultinputsignal.h"
|
||||
|
||||
|
||||
class CVoiceStatus;
|
||||
|
||||
|
||||
class CVoiceLabel
|
||||
{
|
||||
public:
|
||||
vgui::Label *m_pLabel;
|
||||
vgui::Label *m_pBackground;
|
||||
vgui::ImagePanel *m_pIcon; // Voice icon next to player name.
|
||||
int m_clientindex; // Client index of the speaker. -1 if this label isn't being used.
|
||||
};
|
||||
|
||||
|
||||
// This is provided by each mod to access data that may not be the same across mods.
|
||||
class IVoiceStatusHelper
|
||||
{
|
||||
public:
|
||||
virtual ~IVoiceStatusHelper() {}
|
||||
|
||||
// Get RGB color for voice status text about this player.
|
||||
virtual void GetPlayerTextColor(int entindex, int color[3]) = 0;
|
||||
|
||||
// Force it to update the cursor state.
|
||||
virtual void UpdateCursorState() = 0;
|
||||
|
||||
// Return the height above the bottom that the voice ack icons should be drawn at.
|
||||
virtual int GetAckIconHeight() = 0;
|
||||
|
||||
// Return true if the voice manager is allowed to show speaker labels
|
||||
// (mods usually return false when the scoreboard is up).
|
||||
virtual bool CanShowSpeakerLabels() = 0;
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Holds a color for the shared image
|
||||
//-----------------------------------------------------------------------------
|
||||
class VoiceImagePanel : public vgui::ImagePanel
|
||||
{
|
||||
virtual void paintBackground()
|
||||
{
|
||||
if (_image!=null)
|
||||
{
|
||||
vgui::Color col;
|
||||
getFgColor(col);
|
||||
_image->setColor(col);
|
||||
_image->doPaint(this);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
class CVoiceStatus : public CHudBase, public vgui::CDefaultInputSignal
|
||||
{
|
||||
public:
|
||||
CVoiceStatus();
|
||||
virtual ~CVoiceStatus();
|
||||
|
||||
// CHudBase overrides.
|
||||
public:
|
||||
|
||||
// Initialize the cl_dll's voice manager.
|
||||
virtual int Init(
|
||||
IVoiceStatusHelper *m_pHelper,
|
||||
vgui::Panel **pParentPanel);
|
||||
|
||||
// ackPosition is the bottom position of where CVoiceStatus will draw the voice acknowledgement labels.
|
||||
virtual int VidInit();
|
||||
|
||||
|
||||
public:
|
||||
|
||||
// Call from HUD_Frame each frame.
|
||||
void Frame(double frametime);
|
||||
|
||||
// Called when a player starts or stops talking.
|
||||
// entindex is -1 to represent the local client talking (before the data comes back from the server).
|
||||
// When the server acknowledges that the local client is talking, then entindex will be gEngfuncs.GetLocalPlayer().
|
||||
// entindex is -2 to represent the local client's voice being acked by the server.
|
||||
void UpdateSpeakerStatus(int entindex, qboolean bTalking);
|
||||
|
||||
// sets the correct image in the label for the player
|
||||
void UpdateSpeakerImage(vgui::Label *pLabel, int iPlayer);
|
||||
|
||||
// Call from the HUD_CreateEntities function so it can add sprites above player heads.
|
||||
void CreateEntities();
|
||||
|
||||
// Called when the server registers a change to who this client can hear.
|
||||
void HandleVoiceMaskMsg(int iSize, void *pbuf);
|
||||
|
||||
// The server sends this message initially to tell the client to send their state.
|
||||
void HandleReqStateMsg(int iSize, void *pbuf);
|
||||
|
||||
|
||||
// Squelch mode functions.
|
||||
public:
|
||||
|
||||
// When you enter squelch mode, pass in
|
||||
void StartSquelchMode();
|
||||
void StopSquelchMode();
|
||||
bool IsInSquelchMode();
|
||||
|
||||
// returns true if the target client has been banned
|
||||
// playerIndex is of range 1..maxplayers
|
||||
bool IsPlayerBlocked(int iPlayerIndex);
|
||||
|
||||
// returns false if the player can't hear the other client due to game rules (eg. the other team)
|
||||
bool IsPlayerAudible(int iPlayerIndex);
|
||||
|
||||
// blocks the target client from being heard
|
||||
void SetPlayerBlockedState(int iPlayerIndex, bool blocked);
|
||||
|
||||
public:
|
||||
|
||||
CVoiceLabel* FindVoiceLabel(int clientindex); // Find a CVoiceLabel representing the specified speaker.
|
||||
// Returns NULL if none.
|
||||
// entindex can be -1 if you want a currently-unused voice label.
|
||||
CVoiceLabel* GetFreeVoiceLabel(); // Get an unused voice label. Returns NULL if none.
|
||||
|
||||
void RepositionLabels();
|
||||
|
||||
void FreeBitmaps();
|
||||
|
||||
void UpdateServerState(bool bForce);
|
||||
|
||||
// Update the button artwork to reflect the client's current state.
|
||||
void UpdateBanButton(int iClient);
|
||||
|
||||
|
||||
public:
|
||||
|
||||
enum {MAX_VOICE_SPEAKERS=7};
|
||||
|
||||
float m_LastUpdateServerState; // Last time we called this function.
|
||||
int m_bServerModEnable; // What we've sent to the server about our "voice_modenable" cvar.
|
||||
|
||||
vgui::Panel **m_pParentPanel;
|
||||
CPlayerBitVec m_VoicePlayers; // Who is currently talking. Indexed by client index.
|
||||
|
||||
// This is the gamerules-defined list of players that you can hear. It is based on what teams people are on
|
||||
// and is totally separate from the ban list. Indexed by client index.
|
||||
CPlayerBitVec m_AudiblePlayers;
|
||||
|
||||
// Players who have spoken at least once in the game so far
|
||||
CPlayerBitVec m_VoiceEnabledPlayers;
|
||||
|
||||
// This is who the server THINKS we have banned (it can become incorrect when a new player arrives on the server).
|
||||
// It is checked periodically, and the server is told to squelch or unsquelch the appropriate players.
|
||||
CPlayerBitVec m_ServerBannedPlayers;
|
||||
|
||||
cl_entity_s m_VoiceHeadModels[VOICE_MAX_PLAYERS]; // These aren't necessarily in the order of players. They are just
|
||||
// a place for it to put data in during CreateEntities.
|
||||
|
||||
IVoiceStatusHelper *m_pHelper; // Each mod provides an implementation of this.
|
||||
|
||||
|
||||
// Scoreboard icons.
|
||||
double m_BlinkTimer; // Blink scoreboard icons..
|
||||
vgui::BitmapTGA *m_pScoreboardNeverSpoken;
|
||||
vgui::BitmapTGA *m_pScoreboardNotSpeaking;
|
||||
vgui::BitmapTGA *m_pScoreboardSpeaking;
|
||||
vgui::BitmapTGA *m_pScoreboardSpeaking2;
|
||||
vgui::BitmapTGA *m_pScoreboardSquelch;
|
||||
vgui::BitmapTGA *m_pScoreboardBanned;
|
||||
|
||||
vgui::Label *m_pBanButtons[VOICE_MAX_PLAYERS]; // scoreboard buttons.
|
||||
|
||||
// Squelch mode stuff.
|
||||
bool m_bInSquelchMode;
|
||||
|
||||
HSPRITE m_VoiceHeadModel; // Voice head model (goes above players who are speaking).
|
||||
float m_VoiceHeadModelHeight; // Height above their head to place the model.
|
||||
|
||||
vgui::Image *m_pSpeakerLabelIcon; // Icon next to speaker labels.
|
||||
|
||||
// Lower-right icons telling when the local player is talking..
|
||||
vgui::BitmapTGA *m_pLocalBitmap; // Represents the local client talking.
|
||||
vgui::BitmapTGA *m_pAckBitmap; // Represents the server ack'ing the client talking.
|
||||
vgui::ImagePanel *m_pLocalLabel; // Represents the local client talking.
|
||||
|
||||
bool m_bTalking; // Set to true when the client thinks it's talking.
|
||||
bool m_bServerAcked; // Set to true when the server knows the client is talking.
|
||||
|
||||
public:
|
||||
|
||||
CVoiceBanMgr m_BanMgr; // Tracks which users we have squelched and don't want to hear.
|
||||
|
||||
public:
|
||||
|
||||
bool m_bBanMgrInitialized;
|
||||
|
||||
// Labels telling who is speaking.
|
||||
CVoiceLabel m_Labels[MAX_VOICE_SPEAKERS];
|
||||
|
||||
// Cache the game directory for use when we shut down
|
||||
char * m_pchGameDir;
|
||||
};
|
||||
|
||||
|
||||
// Get the (global) voice manager.
|
||||
CVoiceStatus* GetClientVoiceMgr();
|
||||
|
||||
|
||||
#endif // VOICE_STATUS_H
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#if !defined( WRECTH )
|
||||
#define WRECTH
|
||||
|
||||
typedef struct rect_s
|
||||
{
|
||||
int left, right, top, bottom;
|
||||
} wrect_t;
|
||||
|
||||
#endif
|
||||
|
|
@ -1,126 +0,0 @@
|
|||
#
|
||||
# Half-Life DMC SDK 2.3 dmc_i386.so Makefile for x86 Linux
|
||||
#
|
||||
# October 2002 by Leon Hartwig (hartwig@valvesoftware.com)
|
||||
#
|
||||
|
||||
DLLNAME=dmc
|
||||
|
||||
ARCH=i386
|
||||
|
||||
#make sure this is the correct compiler for your system
|
||||
CC=gcc
|
||||
|
||||
DLL_SRCDIR=.
|
||||
ENGINE_SRCDIR=../../engine
|
||||
COMMON_SRCDIR=../../common
|
||||
PM_SHARED_SRCDIR=../pm_shared
|
||||
GAME_SHARED_SRCDIR=../../game_shared
|
||||
|
||||
DLL_OBJDIR=$(DLL_SRCDIR)/obj
|
||||
PM_SHARED_OBJDIR=$(DLL_OBJDIR)/pm_shared
|
||||
GAME_SHARED_OBJDIR=$(DLL_OBJDIR)/game_shared
|
||||
|
||||
BASE_CFLAGS= -Dstricmp=strcasecmp -D_strnicmp=strncasecmp -Dstrnicmp=strncasecmp -D_vsnprintf=vsnprintf\
|
||||
-DCLIENT_WEAPONS
|
||||
|
||||
#safe optimization
|
||||
CFLAGS=$(BASE_CFLAGS) -w -m486 -O1
|
||||
|
||||
#full optimization
|
||||
#CFLAGS=$(BASE_CFLAGS) -w -O1 -m486 -ffast-math -funroll-loops \
|
||||
-fomit-frame-pointer -fexpensive-optimizations \
|
||||
-malign-loops=2 -malign-jumps=2 -malign-functions=2
|
||||
|
||||
#use these when debugging
|
||||
#CFLAGS=$(BASE_CFLAGS) -g
|
||||
|
||||
INCLUDEDIRS=-I. -I$(ENGINE_SRCDIR) -I$(COMMON_SRCDIR) -I$(PM_SHARED_SRCDIR) -I$(GAME_SHARED_SRCDIR)
|
||||
|
||||
LDFLAGS=
|
||||
|
||||
SHLIBEXT=so
|
||||
SHLIBCFLAGS=-fPIC
|
||||
SHLIBLDFLAGS=-shared
|
||||
|
||||
DO_CC=$(CC) $(CFLAGS) $(SHLIBCFLAGS) $(INCLUDEDIRS) -o $@ -c $<
|
||||
|
||||
#############################################################################
|
||||
# SETUP AND BUILD
|
||||
# GAME
|
||||
#############################################################################
|
||||
|
||||
$(DLL_OBJDIR)/%.o: $(DLL_SRCDIR)/%.cpp
|
||||
$(DO_CC)
|
||||
|
||||
$(GAME_SHARED_OBJDIR)/%.o: $(GAME_SHARED_SRCDIR)/%.cpp
|
||||
$(DO_CC)
|
||||
|
||||
$(PM_SHARED_OBJDIR)/%.o: $(PM_SHARED_SRCDIR)/%.c
|
||||
$(DO_CC)
|
||||
|
||||
OBJ = \
|
||||
$(DLL_OBJDIR)/animating.o \
|
||||
$(DLL_OBJDIR)/animation.o \
|
||||
$(DLL_OBJDIR)/bmodels.o \
|
||||
$(DLL_OBJDIR)/buttons.o \
|
||||
$(DLL_OBJDIR)/cbase.o \
|
||||
$(DLL_OBJDIR)/client.o \
|
||||
$(DLL_OBJDIR)/combat.o \
|
||||
$(DLL_OBJDIR)/doors.o \
|
||||
$(DLL_OBJDIR)/effects.o \
|
||||
$(DLL_OBJDIR)/explode.o \
|
||||
$(DLL_OBJDIR)/func_break.o \
|
||||
$(DLL_OBJDIR)/game.o \
|
||||
$(DLL_OBJDIR)/gamerules.o \
|
||||
$(DLL_OBJDIR)/globals.o \
|
||||
$(DLL_OBJDIR)/h_ai.o \
|
||||
$(DLL_OBJDIR)/h_export.o \
|
||||
$(DLL_OBJDIR)/lights.o \
|
||||
$(DLL_OBJDIR)/maprules.o \
|
||||
$(DLL_OBJDIR)/monsters.o \
|
||||
$(DLL_OBJDIR)/monsterstate.o \
|
||||
$(DLL_OBJDIR)/multiplay_gamerules.o \
|
||||
$(DLL_OBJDIR)/nodes.o \
|
||||
$(DLL_OBJDIR)/observer.o \
|
||||
$(DLL_OBJDIR)/pathcorner.o \
|
||||
$(DLL_OBJDIR)/plane.o \
|
||||
$(DLL_OBJDIR)/plats.o \
|
||||
$(DLL_OBJDIR)/player.o \
|
||||
$(DLL_OBJDIR)/quake_gun.o \
|
||||
$(DLL_OBJDIR)/quake_items.o \
|
||||
$(DLL_OBJDIR)/quake_nail.o \
|
||||
$(DLL_OBJDIR)/quake_player.o \
|
||||
$(DLL_OBJDIR)/quake_rocket.o \
|
||||
$(DLL_OBJDIR)/quake_weapons_all.o \
|
||||
$(DLL_OBJDIR)/schedule.o \
|
||||
$(DLL_OBJDIR)/singleplay_gamerules.o \
|
||||
$(DLL_OBJDIR)/skill.o \
|
||||
$(DLL_OBJDIR)/sound.o \
|
||||
$(DLL_OBJDIR)/spectator.o \
|
||||
$(DLL_OBJDIR)/subs.o \
|
||||
$(DLL_OBJDIR)/teamplay_gamerules.o \
|
||||
$(DLL_OBJDIR)/triggers.o \
|
||||
$(DLL_OBJDIR)/util.o \
|
||||
$(DLL_OBJDIR)/weapons.o \
|
||||
$(DLL_OBJDIR)/world.o \
|
||||
$(PM_SHARED_OBJDIR)/pm_shared.o \
|
||||
$(PM_SHARED_OBJDIR)/pm_math.o \
|
||||
$(PM_SHARED_OBJDIR)/pm_debug.o \
|
||||
$(GAME_SHARED_OBJDIR)/voice_gamemgr.o
|
||||
|
||||
$(DLLNAME)_$(ARCH).$(SHLIBEXT) : neat $(OBJ)
|
||||
$(CC) $(CFLAGS) $(SHLIBLDFLAGS) $(LDFLAGS) -o $@ $(OBJ)
|
||||
|
||||
neat:
|
||||
-mkdir $(DLL_OBJDIR)
|
||||
-mkdir $(GAME_SHARED_OBJDIR)
|
||||
-mkdir $(PM_SHARED_OBJDIR)
|
||||
clean:
|
||||
-rm -f $(OBJ)
|
||||
-rm -f $(DLLNAME)_$(ARCH).$(SHLIBEXT)
|
||||
spotless: clean
|
||||
-rm -r $(GAME_SHARED_OBJDIR)
|
||||
-rm -r $(PM_SHARED_OBJDIR)
|
||||
-rm -r $(DLL_OBJDIR)
|
||||
|
||||
|
|
@ -1,109 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
|
||||
#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,
|
||||
ACT_GUARD,
|
||||
ACT_WALK,
|
||||
ACT_RUN,
|
||||
ACT_FLY, // Fly (and flap if appropriate)
|
||||
ACT_SWIM,
|
||||
ACT_HOP, // vertical jump
|
||||
ACT_LEAP, // long forward jump
|
||||
ACT_FALL,
|
||||
ACT_LAND,
|
||||
ACT_STRAFE_LEFT,
|
||||
ACT_STRAFE_RIGHT,
|
||||
ACT_ROLL_LEFT, // tuck and roll, left
|
||||
ACT_ROLL_RIGHT, // tuck and roll, right
|
||||
ACT_TURN_LEFT, // turn quickly left (stationary)
|
||||
ACT_TURN_RIGHT, // turn quickly right (stationary)
|
||||
ACT_CROUCH, // the act of crouching down from a standing position
|
||||
ACT_CROUCHIDLE, // holding body in crouched position (loops)
|
||||
ACT_STAND, // the act of standing from a crouched position
|
||||
ACT_USE,
|
||||
ACT_SIGNAL1,
|
||||
ACT_SIGNAL2,
|
||||
ACT_SIGNAL3,
|
||||
ACT_TWITCH,
|
||||
ACT_COWER,
|
||||
ACT_SMALL_FLINCH,
|
||||
ACT_BIG_FLINCH,
|
||||
ACT_RANGE_ATTACK1,
|
||||
ACT_RANGE_ATTACK2,
|
||||
ACT_MELEE_ATTACK1,
|
||||
ACT_MELEE_ATTACK2,
|
||||
ACT_RELOAD,
|
||||
ACT_ARM, // pull out gun, for instance
|
||||
ACT_DISARM, // reholster gun
|
||||
ACT_EAT, // monster chowing on a large food item (loop)
|
||||
ACT_DIESIMPLE,
|
||||
ACT_DIEBACKWARD,
|
||||
ACT_DIEFORWARD,
|
||||
ACT_DIEVIOLENT,
|
||||
ACT_BARNACLE_HIT, // barnacle tongue hits a monster
|
||||
ACT_BARNACLE_PULL, // barnacle is lifting the monster ( loop )
|
||||
ACT_BARNACLE_CHOMP, // barnacle latches on to the monster
|
||||
ACT_BARNACLE_CHEW, // barnacle is holding the monster in its mouth ( loop )
|
||||
ACT_SLEEP,
|
||||
ACT_INSPECT_FLOOR, // for active idles, look at something on or near the floor
|
||||
ACT_INSPECT_WALL, // for active idles, look at something directly ahead of you ( doesn't HAVE to be a wall or on a wall )
|
||||
ACT_IDLE_ANGRY, // alternate idle animation in which the monster is clearly agitated. (loop)
|
||||
ACT_WALK_HURT, // limp (loop)
|
||||
ACT_RUN_HURT, // limp (loop)
|
||||
ACT_HOVER, // Idle while in flight
|
||||
ACT_GLIDE, // Fly (don't flap)
|
||||
ACT_FLY_LEFT, // Turn left in flight
|
||||
ACT_FLY_RIGHT, // Turn right in flight
|
||||
ACT_DETECT_SCENT, // this means the monster smells a scent carried by the air
|
||||
ACT_SNIFF, // this is the act of actually sniffing an item in front of the monster
|
||||
ACT_BITE, // some large monsters can eat small things in one bite. This plays one time, EAT loops.
|
||||
ACT_THREAT_DISPLAY, // without attacking, monster demonstrates that it is angry. (Yell, stick out chest, etc )
|
||||
ACT_FEAR_DISPLAY, // monster just saw something that it is afraid of
|
||||
ACT_EXCITED, // for some reason, monster is excited. Sees something he really likes to eat, or whatever.
|
||||
ACT_SPECIAL_ATTACK1, // very monster specific special attacks.
|
||||
ACT_SPECIAL_ATTACK2,
|
||||
ACT_COMBAT_IDLE, // agitated idle.
|
||||
ACT_WALK_SCARED,
|
||||
ACT_RUN_SCARED,
|
||||
ACT_VICTORY_DANCE, // killed a player, do a victory dance.
|
||||
ACT_DIE_HEADSHOT, // die, hit in head.
|
||||
ACT_DIE_CHESTSHOT, // die, hit in chest
|
||||
ACT_DIE_GUTSHOT, // die, hit in gut
|
||||
ACT_DIE_BACKSHOT, // die, hit in back
|
||||
ACT_FLINCH_HEAD,
|
||||
ACT_FLINCH_CHEST,
|
||||
ACT_FLINCH_STOMACH,
|
||||
ACT_FLINCH_LEFTARM,
|
||||
ACT_FLINCH_RIGHTARM,
|
||||
ACT_FLINCH_LEFTLEG,
|
||||
ACT_FLINCH_RIGHTLEG,
|
||||
} Activity;
|
||||
|
||||
|
||||
typedef struct {
|
||||
int type;
|
||||
char *name;
|
||||
} activity_map_t;
|
||||
|
||||
extern activity_map_t activity_map[];
|
||||
|
||||
|
||||
#endif //ACTIVITY_H
|
||||
|
|
@ -1,97 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
|
||||
#define _A( a ) { a, #a }
|
||||
|
||||
activity_map_t activity_map[] =
|
||||
{
|
||||
_A( ACT_IDLE ),
|
||||
_A( ACT_GUARD ),
|
||||
_A( ACT_WALK ),
|
||||
_A( ACT_RUN ),
|
||||
_A( ACT_FLY ),
|
||||
_A( ACT_SWIM ),
|
||||
_A( ACT_HOP ),
|
||||
_A( ACT_LEAP ),
|
||||
_A( ACT_FALL ),
|
||||
_A( ACT_LAND ),
|
||||
_A( ACT_STRAFE_LEFT ),
|
||||
_A( ACT_STRAFE_RIGHT ),
|
||||
_A( ACT_ROLL_LEFT ),
|
||||
_A( ACT_ROLL_RIGHT ),
|
||||
_A( ACT_TURN_LEFT ),
|
||||
_A( ACT_TURN_RIGHT ),
|
||||
_A( ACT_CROUCH ),
|
||||
_A( ACT_CROUCHIDLE ),
|
||||
_A( ACT_STAND ),
|
||||
_A( ACT_USE ),
|
||||
_A( ACT_SIGNAL1 ),
|
||||
_A( ACT_SIGNAL2 ),
|
||||
_A( ACT_SIGNAL3 ),
|
||||
_A( ACT_TWITCH ),
|
||||
_A( ACT_COWER ),
|
||||
_A( ACT_SMALL_FLINCH ),
|
||||
_A( ACT_BIG_FLINCH ),
|
||||
_A( ACT_RANGE_ATTACK1 ),
|
||||
_A( ACT_RANGE_ATTACK2 ),
|
||||
_A( ACT_MELEE_ATTACK1 ),
|
||||
_A( ACT_MELEE_ATTACK2 ),
|
||||
_A( ACT_RELOAD ),
|
||||
_A( ACT_ARM ),
|
||||
_A( ACT_DISARM ),
|
||||
_A( ACT_EAT ),
|
||||
_A( ACT_DIESIMPLE ),
|
||||
_A( ACT_DIEBACKWARD ),
|
||||
_A( ACT_DIEFORWARD ),
|
||||
_A( ACT_DIEVIOLENT ),
|
||||
_A( ACT_BARNACLE_HIT ),
|
||||
_A( ACT_BARNACLE_PULL ),
|
||||
_A( ACT_BARNACLE_CHOMP ),
|
||||
_A( ACT_BARNACLE_CHEW ),
|
||||
_A( ACT_SLEEP ),
|
||||
_A( ACT_INSPECT_FLOOR ),
|
||||
_A( ACT_INSPECT_WALL ),
|
||||
_A( ACT_IDLE_ANGRY ),
|
||||
_A( ACT_WALK_HURT ),
|
||||
_A( ACT_RUN_HURT ),
|
||||
_A( ACT_HOVER ),
|
||||
_A( ACT_GLIDE ),
|
||||
_A( ACT_FLY_LEFT ),
|
||||
_A( ACT_FLY_RIGHT ),
|
||||
_A( ACT_DETECT_SCENT ),
|
||||
_A( ACT_SNIFF ),
|
||||
_A( ACT_BITE ),
|
||||
_A( ACT_THREAT_DISPLAY ),
|
||||
_A( ACT_FEAR_DISPLAY ),
|
||||
_A( ACT_EXCITED ),
|
||||
_A( ACT_SPECIAL_ATTACK1 ),
|
||||
_A( ACT_SPECIAL_ATTACK2 ),
|
||||
_A( ACT_COMBAT_IDLE ),
|
||||
_A( ACT_WALK_SCARED ),
|
||||
_A( ACT_RUN_SCARED ),
|
||||
_A( ACT_VICTORY_DANCE ),
|
||||
_A( ACT_DIE_HEADSHOT ),
|
||||
_A( ACT_DIE_CHESTSHOT ),
|
||||
_A( ACT_DIE_GUTSHOT ),
|
||||
_A( ACT_DIE_BACKSHOT ),
|
||||
_A( ACT_FLINCH_HEAD ),
|
||||
_A( ACT_FLINCH_CHEST ),
|
||||
_A( ACT_FLINCH_STOMACH ),
|
||||
_A( ACT_FLINCH_LEFTARM ),
|
||||
_A( ACT_FLINCH_RIGHTARM ),
|
||||
_A( ACT_FLINCH_LEFTLEG ),
|
||||
_A( ACT_FLINCH_RIGHTLEG ),
|
||||
0, NULL
|
||||
};
|
||||
|
|
@ -1,313 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
/*
|
||||
|
||||
===== monsters.cpp ========================================================
|
||||
|
||||
Monster-related utility code
|
||||
|
||||
*/
|
||||
|
||||
#include "extdll.h"
|
||||
#include "util.h"
|
||||
#include "cbase.h"
|
||||
#include "animation.h"
|
||||
#include "saverestore.h"
|
||||
|
||||
TYPEDESCRIPTION CBaseAnimating::m_SaveData[] =
|
||||
{
|
||||
DEFINE_FIELD( CBaseMonster, m_flFrameRate, FIELD_FLOAT ),
|
||||
DEFINE_FIELD( CBaseMonster, m_flGroundSpeed, FIELD_FLOAT ),
|
||||
DEFINE_FIELD( CBaseMonster, m_flLastEventCheck, FIELD_TIME ),
|
||||
DEFINE_FIELD( CBaseMonster, m_fSequenceFinished, FIELD_BOOLEAN ),
|
||||
DEFINE_FIELD( CBaseMonster, m_fSequenceLoops, FIELD_BOOLEAN ),
|
||||
};
|
||||
|
||||
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 )
|
||||
{
|
||||
if (flInterval == 0.0)
|
||||
{
|
||||
flInterval = (gpGlobals->time - pev->animtime);
|
||||
if (flInterval <= 0.001)
|
||||
{
|
||||
pev->animtime = gpGlobals->time;
|
||||
return 0.0;
|
||||
}
|
||||
}
|
||||
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 (m_fSequenceLoops)
|
||||
pev->frame -= (int)(pev->frame / 256.0) * 256.0;
|
||||
else
|
||||
pev->frame = (pev->frame < 0.0) ? 0 : 255;
|
||||
m_fSequenceFinished = TRUE; // just in case it wasn't caught in GetEvents
|
||||
}
|
||||
|
||||
return flInterval;
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
// LookupActivity
|
||||
//=========================================================
|
||||
int CBaseAnimating :: LookupActivity ( int activity )
|
||||
{
|
||||
ASSERT( activity != 0 );
|
||||
void *pmodel = GET_MODEL_PTR( ENT(pev) );
|
||||
|
||||
return ::LookupActivity( pmodel, pev, activity );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
// LookupActivityHeaviest
|
||||
//
|
||||
// Get activity with highest 'weight'
|
||||
//
|
||||
//=========================================================
|
||||
int CBaseAnimating :: LookupActivityHeaviest ( int activity )
|
||||
{
|
||||
void *pmodel = GET_MODEL_PTR( ENT(pev) );
|
||||
|
||||
return ::LookupActivityHeaviest( pmodel, pev, activity );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
int CBaseAnimating :: LookupSequence ( const char *label )
|
||||
{
|
||||
void *pmodel = GET_MODEL_PTR( ENT(pev) );
|
||||
|
||||
return ::LookupSequence( pmodel, label );
|
||||
}
|
||||
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CBaseAnimating :: ResetSequenceInfo ( )
|
||||
{
|
||||
void *pmodel = GET_MODEL_PTR( ENT(pev) );
|
||||
|
||||
GetSequenceInfo( pmodel, pev, &m_flFrameRate, &m_flGroundSpeed );
|
||||
m_fSequenceLoops = ((GetSequenceFlags() & STUDIO_LOOPING) != 0);
|
||||
pev->animtime = gpGlobals->time;
|
||||
pev->framerate = 1.0;
|
||||
m_fSequenceFinished = FALSE;
|
||||
m_flLastEventCheck = gpGlobals->time;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
BOOL CBaseAnimating :: GetSequenceFlags( )
|
||||
{
|
||||
void *pmodel = GET_MODEL_PTR( ENT(pev) );
|
||||
|
||||
return ::GetSequenceFlags( pmodel, pev );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
// DispatchAnimEvents
|
||||
//=========================================================
|
||||
void CBaseAnimating :: DispatchAnimEvents ( float flInterval )
|
||||
{
|
||||
MonsterEvent_t event;
|
||||
|
||||
void *pmodel = GET_MODEL_PTR( ENT(pev) );
|
||||
|
||||
if ( !pmodel )
|
||||
{
|
||||
ALERT( at_aiconsole, "Gibbed monster is thinking!\n" );
|
||||
return;
|
||||
}
|
||||
|
||||
// FIXME: I have to do this or some events get missed, and this is probably causing the problem below
|
||||
flInterval = 0.1;
|
||||
|
||||
// FIX: this still sometimes hits events twice
|
||||
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)
|
||||
m_fSequenceFinished = TRUE;
|
||||
|
||||
int index = 0;
|
||||
|
||||
while ( (index = GetAnimationEvent( pmodel, pev, &event, flStart, flEnd, index ) ) != 0 )
|
||||
{
|
||||
HandleAnimEvent( &event );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
float CBaseAnimating :: SetBoneController ( int iController, float flValue )
|
||||
{
|
||||
void *pmodel = GET_MODEL_PTR( ENT(pev) );
|
||||
|
||||
return SetController( pmodel, pev, iController, flValue );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CBaseAnimating :: InitBoneControllers ( void )
|
||||
{
|
||||
void *pmodel = GET_MODEL_PTR( ENT(pev) );
|
||||
|
||||
SetController( pmodel, pev, 0, 0.0 );
|
||||
SetController( pmodel, pev, 1, 0.0 );
|
||||
SetController( pmodel, pev, 2, 0.0 );
|
||||
SetController( pmodel, pev, 3, 0.0 );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
float CBaseAnimating :: SetBlending ( int iBlender, float flValue )
|
||||
{
|
||||
void *pmodel = GET_MODEL_PTR( ENT(pev) );
|
||||
|
||||
return ::SetBlending( pmodel, pev, iBlender, flValue );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CBaseAnimating :: GetBonePosition ( int iBone, Vector &origin, Vector &angles )
|
||||
{
|
||||
GET_BONE_POSITION( ENT(pev), iBone, origin, angles );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CBaseAnimating :: GetAttachment ( int iAttachment, Vector &origin, Vector &angles )
|
||||
{
|
||||
GET_ATTACHMENT( ENT(pev), iAttachment, origin, angles );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
int CBaseAnimating :: FindTransition( int iEndingSequence, int iGoalSequence, int *piDir )
|
||||
{
|
||||
void *pmodel = GET_MODEL_PTR( ENT(pev) );
|
||||
|
||||
if (piDir == NULL)
|
||||
{
|
||||
int iDir;
|
||||
int sequence = ::FindTransition( pmodel, iEndingSequence, iGoalSequence, &iDir );
|
||||
if (iDir != 1)
|
||||
return -1;
|
||||
else
|
||||
return sequence;
|
||||
}
|
||||
|
||||
return ::FindTransition( pmodel, iEndingSequence, iGoalSequence, piDir );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
void CBaseAnimating :: GetAutomovement( Vector &origin, Vector &angles, float flInterval )
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void CBaseAnimating :: SetBodygroup( int iGroup, int iValue )
|
||||
{
|
||||
::SetBodygroup( GET_MODEL_PTR( ENT(pev) ), pev, iGroup, iValue );
|
||||
}
|
||||
|
||||
int CBaseAnimating :: GetBodygroup( int iGroup )
|
||||
{
|
||||
return ::GetBodygroup( GET_MODEL_PTR( ENT(pev) ), pev, iGroup );
|
||||
}
|
||||
|
||||
|
||||
int CBaseAnimating :: ExtractBbox( int sequence, float *mins, float *maxs )
|
||||
{
|
||||
return ::ExtractBbox( GET_MODEL_PTR( ENT(pev) ), sequence, mins, maxs );
|
||||
}
|
||||
|
||||
//=========================================================
|
||||
//=========================================================
|
||||
|
||||
void CBaseAnimating :: SetSequenceBox( void )
|
||||
{
|
||||
Vector mins, maxs;
|
||||
|
||||
// Get sequence bbox
|
||||
if ( ExtractBbox( pev->sequence, mins, maxs ) )
|
||||
{
|
||||
// expand box for rotation
|
||||
// find min / max for rotations
|
||||
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);
|
||||
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++ )
|
||||
{
|
||||
base.x = bounds[i].x;
|
||||
for ( int j = 0; j <= 1; j++ )
|
||||
{
|
||||
base.y = bounds[j].y;
|
||||
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;
|
||||
transformed.z = base.z;
|
||||
|
||||
for ( int l = 0; l < 3; l++ )
|
||||
{
|
||||
if (transformed[l] < rmin[l])
|
||||
rmin[l] = transformed[l];
|
||||
if (transformed[l] > rmax[l])
|
||||
rmax[l] = transformed[l];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
rmin.z = 0;
|
||||
rmax.z = rmin.z + 1;
|
||||
UTIL_SetSize( pev, rmin, rmax );
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1,527 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
typedef bool BOOL;
|
||||
|
||||
// hack into header files that we can ship
|
||||
typedef int qboolean;
|
||||
typedef unsigned char byte;
|
||||
#include "../utils/common/mathlib.h"
|
||||
#include "const.h"
|
||||
|
||||
#include "progdefs.h"
|
||||
#include "edict.h"
|
||||
#include "eiface.h"
|
||||
|
||||
#include "studio.h"
|
||||
|
||||
#include "../engine/studio.h"
|
||||
|
||||
#ifndef ACTIVITY_H
|
||||
#include "activity.h"
|
||||
#endif
|
||||
|
||||
#include "activitymap.h"
|
||||
|
||||
#ifndef ANIMATION_H
|
||||
#include "animation.h"
|
||||
#endif
|
||||
|
||||
#ifndef SCRIPTEVENT_H
|
||||
#include "scriptevent.h"
|
||||
#endif
|
||||
|
||||
#ifndef ENGINECALLBACK_H
|
||||
#include "enginecallback.h"
|
||||
#endif
|
||||
|
||||
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)
|
||||
return 0;
|
||||
|
||||
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];
|
||||
|
||||
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)
|
||||
return 0;
|
||||
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
|
||||
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
|
||||
|
||||
int weighttotal = 0;
|
||||
int seq = ACTIVITY_NOT_AVAILABLE;
|
||||
for (int i = 0; i < pstudiohdr->numseq; i++)
|
||||
{
|
||||
if (pseqdesc[i].activity == activity)
|
||||
{
|
||||
weighttotal += pseqdesc[i].actweight;
|
||||
if (!weighttotal || RANDOM_LONG(0,weighttotal-1) < pseqdesc[i].actweight)
|
||||
seq = i;
|
||||
}
|
||||
}
|
||||
|
||||
return seq;
|
||||
}
|
||||
|
||||
|
||||
int LookupActivityHeaviest( void *pmodel, entvars_t *pev, int activity )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if ( !pstudiohdr )
|
||||
return 0;
|
||||
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
|
||||
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
|
||||
|
||||
int weight = 0;
|
||||
int seq = ACTIVITY_NOT_AVAILABLE;
|
||||
for (int i = 0; i < pstudiohdr->numseq; i++)
|
||||
{
|
||||
if (pseqdesc[i].activity == activity)
|
||||
{
|
||||
if ( pseqdesc[i].actweight > weight )
|
||||
{
|
||||
weight = pseqdesc[i].actweight;
|
||||
seq = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return seq;
|
||||
}
|
||||
|
||||
void GetEyePosition ( void *pmodel, float *vecEyePosition )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
|
||||
if ( !pstudiohdr )
|
||||
{
|
||||
ALERT ( at_console, "GetEyePosition() Can't get pstudiohdr ptr!\n" );
|
||||
return;
|
||||
}
|
||||
|
||||
VectorCopy ( pstudiohdr->eyeposition, vecEyePosition );
|
||||
}
|
||||
|
||||
int LookupSequence( void *pmodel, const char *label )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if (! pstudiohdr)
|
||||
return 0;
|
||||
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
|
||||
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
|
||||
|
||||
for (int i = 0; i < pstudiohdr->numseq; i++)
|
||||
{
|
||||
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 )
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
void SequencePrecache( void *pmodel, const char *pSequenceName )
|
||||
{
|
||||
int index = LookupSequence( pmodel, pSequenceName );
|
||||
if ( index >= 0 )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if ( !pstudiohdr || index >= pstudiohdr->numseq )
|
||||
return;
|
||||
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
mstudioevent_t *pevent;
|
||||
|
||||
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + index;
|
||||
pevent = (mstudioevent_t *)((byte *)pstudiohdr + pseqdesc->eventindex);
|
||||
|
||||
for (int i = 0; i < pseqdesc->numevents; i++)
|
||||
{
|
||||
// Don't send client-side events to the server AI
|
||||
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 ( !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) ) );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void GetSequenceInfo( void *pmodel, entvars_t *pev, float *pflFrameRate, float *pflGroundSpeed )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if (! pstudiohdr)
|
||||
return;
|
||||
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
|
||||
if (pev->sequence >= pstudiohdr->numseq)
|
||||
{
|
||||
*pflFrameRate = 0.0;
|
||||
*pflGroundSpeed = 0.0;
|
||||
return;
|
||||
}
|
||||
|
||||
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
|
||||
|
||||
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);
|
||||
}
|
||||
else
|
||||
{
|
||||
*pflFrameRate = 256.0;
|
||||
*pflGroundSpeed = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int GetSequenceFlags( void *pmodel, entvars_t *pev )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if ( !pstudiohdr || pev->sequence >= pstudiohdr->numseq )
|
||||
return 0;
|
||||
|
||||
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 )
|
||||
return 0;
|
||||
|
||||
int events = 0;
|
||||
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
mstudioevent_t *pevent;
|
||||
|
||||
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
|
||||
pevent = (mstudioevent_t *)((byte *)pstudiohdr + pseqdesc->eventindex);
|
||||
|
||||
if (pseqdesc->numevents == 0 || index > pseqdesc->numevents )
|
||||
return 0;
|
||||
|
||||
if (pseqdesc->numframes > 1)
|
||||
{
|
||||
flStart *= (pseqdesc->numframes - 1) / 256.0;
|
||||
flEnd *= (pseqdesc->numframes - 1) / 256.0;
|
||||
}
|
||||
else
|
||||
{
|
||||
flStart = 0;
|
||||
flEnd = 1.0;
|
||||
}
|
||||
|
||||
for (; index < pseqdesc->numevents; index++)
|
||||
{
|
||||
// Don't send client-side events to the server AI
|
||||
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) )
|
||||
{
|
||||
pMonsterEvent->event = pevent[index].event;
|
||||
pMonsterEvent->options = pevent[index].options;
|
||||
return index + 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
float SetController( void *pmodel, entvars_t *pev, int iController, float flValue )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if (! pstudiohdr)
|
||||
return flValue;
|
||||
|
||||
mstudiobonecontroller_t *pbonecontroller = (mstudiobonecontroller_t *)((byte *)pstudiohdr + pstudiohdr->bonecontrollerindex);
|
||||
|
||||
// find first controller that matches the index
|
||||
int i;
|
||||
for ( i = 0; i < pstudiohdr->numbonecontrollers; i++, pbonecontroller++)
|
||||
{
|
||||
if (pbonecontroller->index == iController)
|
||||
break;
|
||||
}
|
||||
if (i >= pstudiohdr->numbonecontrollers)
|
||||
return flValue;
|
||||
|
||||
// wrap 0..360 if it's a rotational controller
|
||||
|
||||
if (pbonecontroller->type & (STUDIO_XR | STUDIO_YR | STUDIO_ZR))
|
||||
{
|
||||
// ugly hack, invert value if end < start
|
||||
if (pbonecontroller->end < pbonecontroller->start)
|
||||
flValue = -flValue;
|
||||
|
||||
// does the controller not wrap?
|
||||
if (pbonecontroller->start + 359.0 >= pbonecontroller->end)
|
||||
{
|
||||
if (flValue > ((pbonecontroller->start + pbonecontroller->end) / 2.0) + 180)
|
||||
flValue = flValue - 360;
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
int setting = 255 * (flValue - pbonecontroller->start) / (pbonecontroller->end - pbonecontroller->start);
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
|
||||
float SetBlending( void *pmodel, entvars_t *pev, int iBlender, float flValue )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if (! pstudiohdr)
|
||||
return flValue;
|
||||
|
||||
mstudioseqdesc_t *pseqdesc;
|
||||
|
||||
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
|
||||
|
||||
if (pseqdesc->blendtype[iBlender] == 0)
|
||||
return flValue;
|
||||
|
||||
if (pseqdesc->blendtype[iBlender] & (STUDIO_XR | STUDIO_YR | STUDIO_ZR))
|
||||
{
|
||||
// ugly hack, invert value if end < start
|
||||
if (pseqdesc->blendend[iBlender] < pseqdesc->blendstart[iBlender])
|
||||
flValue = -flValue;
|
||||
|
||||
// does the controller not wrap?
|
||||
if (pseqdesc->blendstart[iBlender] + 359.0 >= pseqdesc->blendend[iBlender])
|
||||
{
|
||||
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)
|
||||
flValue = flValue + 360;
|
||||
}
|
||||
}
|
||||
|
||||
int setting = 255 * (flValue - pseqdesc->blendstart[iBlender]) / (pseqdesc->blendend[iBlender] - pseqdesc->blendstart[iBlender]);
|
||||
|
||||
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];
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
int FindTransition( void *pmodel, int iEndingAnim, int iGoalAnim, int *piDir )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if (! pstudiohdr)
|
||||
return iGoalAnim;
|
||||
|
||||
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)
|
||||
{
|
||||
return iGoalAnim;
|
||||
}
|
||||
|
||||
int iEndNode;
|
||||
|
||||
// ALERT( at_console, "from %d to %d: ", pEndNode->iEndNode, pGoalNode->iStartNode );
|
||||
|
||||
if (*piDir > 0)
|
||||
{
|
||||
iEndNode = pseqdesc[iEndingAnim].exitnode;
|
||||
}
|
||||
else
|
||||
{
|
||||
iEndNode = pseqdesc[iEndingAnim].entrynode;
|
||||
}
|
||||
|
||||
if (iEndNode == pseqdesc[iGoalAnim].entrynode)
|
||||
{
|
||||
*piDir = 1;
|
||||
return iGoalAnim;
|
||||
}
|
||||
|
||||
byte *pTransition = ((byte *)pstudiohdr + pstudiohdr->transitionindex);
|
||||
|
||||
int iInternNode = pTransition[(iEndNode-1)*pstudiohdr->numtransitions + (pseqdesc[iGoalAnim].entrynode-1)];
|
||||
|
||||
if (iInternNode == 0)
|
||||
return iGoalAnim;
|
||||
|
||||
int i;
|
||||
|
||||
// look for someone going
|
||||
for (i = 0; i < pstudiohdr->numseq; i++)
|
||||
{
|
||||
if (pseqdesc[i].entrynode == iEndNode && pseqdesc[i].exitnode == iInternNode)
|
||||
{
|
||||
*piDir = 1;
|
||||
return i;
|
||||
}
|
||||
if (pseqdesc[i].nodeflags)
|
||||
{
|
||||
if (pseqdesc[i].exitnode == iEndNode && pseqdesc[i].entrynode == iInternNode)
|
||||
{
|
||||
*piDir = -1;
|
||||
return i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ALERT( at_console, "error in transition graph" );
|
||||
return iGoalAnim;
|
||||
}
|
||||
|
||||
void SetBodygroup( void *pmodel, entvars_t *pev, int iGroup, int iValue )
|
||||
{
|
||||
studiohdr_t *pstudiohdr;
|
||||
|
||||
pstudiohdr = (studiohdr_t *)pmodel;
|
||||
if (! pstudiohdr)
|
||||
return;
|
||||
|
||||
if (iGroup > pstudiohdr->numbodyparts)
|
||||
return;
|
||||
|
||||
mstudiobodyparts_t *pbodypart = (mstudiobodyparts_t *)((byte *)pstudiohdr + pstudiohdr->bodypartindex) + iGroup;
|
||||
|
||||
if (iValue >= pbodypart->nummodels)
|
||||
return;
|
||||
|
||||
int iCurrent = (pev->body / pbodypart->base) % pbodypart->nummodels;
|
||||
|
||||
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)
|
||||
return 0;
|
||||
|
||||
if (iGroup > pstudiohdr->numbodyparts)
|
||||
return 0;
|
||||
|
||||
mstudiobodyparts_t *pbodypart = (mstudiobodyparts_t *)((byte *)pstudiohdr + pstudiohdr->bodypartindex) + iGroup;
|
||||
|
||||
if (pbodypart->nummodels <= 1)
|
||||
return 0;
|
||||
|
||||
int iCurrent = (pev->body / pbodypart->base) % pbodypart->nummodels;
|
||||
|
||||
return iCurrent;
|
||||
}
|
||||
|
|
@ -1,47 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Use, distribution, and modification of this source code and/or resulting
|
||||
* object code is restricted to non-commercial enhancements to products from
|
||||
* Valve LLC. All other use, distribution, or modification is prohibited
|
||||
* without written permission from Valve LLC.
|
||||
*
|
||||
****/
|
||||
#ifndef ANIMATION_H
|
||||
#define ANIMATION_H
|
||||
|
||||
#define ACTIVITY_NOT_AVAILABLE -1
|
||||
|
||||
#ifndef MONSTEREVENT_H
|
||||
#include "monsterevent.h"
|
||||
#endif
|
||||
|
||||
extern int IsSoundEvent( int eventNumber );
|
||||
|
||||
int LookupActivity( void *pmodel, entvars_t *pev, int activity );
|
||||
int LookupActivityHeaviest( void *pmodel, entvars_t *pev, int activity );
|
||||
int LookupSequence( void *pmodel, const char *label );
|
||||
void GetSequenceInfo( void *pmodel, entvars_t *pev, float *pflFrameRate, float *pflGroundSpeed );
|
||||
int GetSequenceFlags( void *pmodel, entvars_t *pev );
|
||||
int LookupAnimationEvents( void *pmodel, entvars_t *pev, float flStart, float flEnd );
|
||||
float SetController( void *pmodel, entvars_t *pev, int iController, float flValue );
|
||||
float SetBlending( void *pmodel, entvars_t *pev, int iBlender, float flValue );
|
||||
void GetEyePosition( void *pmodel, float *vecEyePosition );
|
||||
void SequencePrecache( void *pmodel, const char *pSequenceName );
|
||||
int FindTransition( void *pmodel, int iEndingAnim, int iGoalAnim, int *piDir );
|
||||
void SetBodygroup( void *pmodel, entvars_t *pev, int iGroup, int iValue );
|
||||
int GetBodygroup( void *pmodel, entvars_t *pev, int iGroup );
|
||||
|
||||
int GetAnimationEvent( void *pmodel, entvars_t *pev, MonsterEvent_t *pMonsterEvent, float flStart, float flEnd, int index );
|
||||
int ExtractBbox( void *pmodel, int sequence, float *mins, float *maxs );
|
||||
|
||||
// From /engine/studio.h
|
||||
#define STUDIO_LOOPING 0x0001
|
||||
|
||||
|
||||
#endif //ANIMATION_H
|
||||
|
|
@ -1,339 +0,0 @@
|
|||
/***
|
||||
*
|
||||
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
|
||||
*
|
||||
* This product contains software technology licensed from Id
|
||||
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* This source code contains proprietary and confidential information of
|
||||
* Valve LLC and its suppliers. Access to this code is restricted to
|
||||
* persons who have executed a written SDK license with Valve. Any access,
|
||||
* use or distribution of this code by or to any unlicensed person is illegal.
|
||||
*
|
||||
****/
|
||||
|
||||
#ifndef BASEMONSTER_H
|
||||
#define BASEMONSTER_H
|
||||
|
||||
//
|
||||
// generic Monster
|
||||
//
|
||||
class CBaseMonster : public CBaseToggle
|
||||
{
|
||||
private:
|
||||
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;
|
||||
|
||||
|
||||
|
||||
// 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;
|
||||
|
||||
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;
|
||||
|
||||
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_vecMoveGoal; // kept around for node graph moves, so we know our ultimate goal
|
||||
Activity m_movementActivity; // When moving, set this activity
|
||||
|
||||
int m_iAudibleList; // first index of a linked list of sounds that the monster can hear.
|
||||
int m_afSoundTypes;
|
||||
|
||||
Vector m_vecLastPosition;// monster sometimes wants to return to where it started after an operation.
|
||||
|
||||
int m_iHintNode; // this is the hint node that the monster is moving towards or performing active idle on.
|
||||
|
||||
int m_afMemory;
|
||||
|
||||
int m_iMaxHealth;// keeps track of monster's maximum health value (for re-healing, etc)
|
||||
|
||||
Vector m_vecEnemyLKP;// last known position of enemy. (enemy's origin)
|
||||
|
||||
int m_cAmmoLoaded; // how much ammo is in the weapon (used to trigger reload anim sequences)
|
||||
|
||||
int m_afCapability;// tells us what a monster can/can't do.
|
||||
|
||||
float m_flNextAttack; // cannot attack again until this time
|
||||
|
||||
int m_bitsDamageType; // what types of damage has monster (player) taken
|
||||
BYTE m_rgbTimeBasedDamage[CDMG_TIMEBASED];
|
||||
|
||||
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
|
||||
|
||||
int m_failSchedule; // Schedule type to choose if current schedule fails
|
||||
|
||||
float m_flHungryTime;// set this is a future time to stop the monster from eating for a while.
|
||||
|
||||
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_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.
|
||||
|
||||
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 );
|
||||
|
||||
// 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 BOOL IsAlive( void ) { return (pev->deadflag != DEAD_DEAD); }
|
||||
virtual BOOL ShouldFadeOnDeath( void );
|
||||
|
||||
// Basic Monster AI functions
|
||||
virtual float ChangeYaw ( int speed );
|
||||
float VecToYaw( Vector vecDir );
|
||||
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 );
|
||||
|
||||
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 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; }
|
||||
|
||||
// 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 );
|
||||
|
||||
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 void SentenceStop( 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 );
|
||||
|
||||
void CheckAttacks ( CBaseEntity *pTarget, float flDist );
|
||||
virtual int CheckEnemy ( CBaseEntity *pEnemy );
|
||||
void PushEnemy( CBaseEntity *pEnemy, Vector &vecLastKnownPos );
|
||||
BOOL PopEnemy( 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); }
|
||||
|
||||
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
|
||||
|
||||
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; }
|
||||
|
||||
virtual BOOL FValidateHintType( short sHint );
|
||||
int FindHintNode ( void );
|
||||
virtual BOOL FCanActiveIdle ( void );
|
||||
void SetTurnActivity ( void );
|
||||
float FLSoundVolume ( CSound *pSound );
|
||||
|
||||
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 );
|
||||
|
||||
// Returns the time when the door will be open
|
||||
float OpenDoorAndWait( entvars_t *pevDoor );
|
||||
|
||||
virtual int ISoundMask( void );
|
||||
virtual CSound* PBestSound ( void );
|
||||
virtual CSound* PBestScent ( void );
|
||||
virtual float HearingSensitivity( void ) { return 1.0; };
|
||||
|
||||
BOOL FBecomeProne ( void );
|
||||
virtual void BarnacleVictimBitten( entvars_t *pevBarnacle );
|
||||
virtual void BarnacleVictimReleased( void );
|
||||
|
||||
void SetEyePosition ( void );
|
||||
|
||||
BOOL FShouldEat( void );// see if a monster is 'hungry'
|
||||
void Eat ( float flFullDuration );// make the monster 'full' for a while.
|
||||
|
||||
CBaseEntity *CheckTraceHullAttack( float flDist, int iDamage, int iDmgType );
|
||||
BOOL FacingIdeal( void );
|
||||
|
||||
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 );
|
||||
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
|
||||
|
||||
Vector ShootAtEnemy( const Vector &shootOrigin );
|
||||
virtual Vector BodyTarget( const Vector &posSrc ) { return Center( ) * 0.75 + EyePosition() * 0.25; }; // position to shoot at
|
||||
|
||||
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 );
|
||||
|
||||
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 StopFollowing( BOOL clearSchedule ) {}
|
||||
|
||||
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( );
|
||||
|
||||
CBaseEntity* DropItem ( char *pszItemName, const Vector &vecPos, const Vector &vecAng );// drop an item.
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif // BASEMONSTER_H
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue