2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Definitions that are shared by the game DLL and the client DLL.
//
// $NoKeywords: $
//=============================================================================//
# ifndef SHAREDDEFS_H
# define SHAREDDEFS_H
# ifdef _WIN32
# pragma once
# endif
# define TICK_INTERVAL (gpGlobals->interval_per_tick)
# define TIME_TO_TICKS( dt ) ( (int)( 0.5f + (float)(dt) / TICK_INTERVAL ) )
# define TICKS_TO_TIME( t ) ( TICK_INTERVAL *( t ) )
# define ROUND_TO_TICKS( t ) ( TICK_INTERVAL * TIME_TO_TICKS( t ) )
# define TICK_NEVER_THINK (-1)
# if defined( TF_DLL )
# define ANIMATION_CYCLE_BITS 10
# else
# define ANIMATION_CYCLE_BITS 15
# endif
# define ANIMATION_CYCLE_MINFRAC (1.0f / (1<<ANIMATION_CYCLE_BITS))
// Each mod defines these for itself.
class CViewVectors
{
public :
CViewVectors ( ) { }
CViewVectors (
Vector vView ,
Vector vHullMin ,
Vector vHullMax ,
Vector vDuckHullMin ,
Vector vDuckHullMax ,
Vector vDuckView ,
Vector vObsHullMin ,
Vector vObsHullMax ,
Vector vDeadViewHeight )
{
m_vView = vView ;
m_vHullMin = vHullMin ;
m_vHullMax = vHullMax ;
m_vDuckHullMin = vDuckHullMin ;
m_vDuckHullMax = vDuckHullMax ;
m_vDuckView = vDuckView ;
m_vObsHullMin = vObsHullMin ;
m_vObsHullMax = vObsHullMax ;
m_vDeadViewHeight = vDeadViewHeight ;
}
// Height above entity position where the viewer's eye is.
Vector m_vView ;
Vector m_vHullMin ;
Vector m_vHullMax ;
Vector m_vDuckHullMin ;
Vector m_vDuckHullMax ;
Vector m_vDuckView ;
Vector m_vObsHullMin ;
Vector m_vObsHullMax ;
Vector m_vDeadViewHeight ;
} ;
// Height above entity position where the viewer's eye is.
# define VEC_VIEW g_pGameRules->GetViewVectors()->m_vView
# define VEC_HULL_MIN g_pGameRules->GetViewVectors()->m_vHullMin
# define VEC_HULL_MAX g_pGameRules->GetViewVectors()->m_vHullMax
# define VEC_DUCK_HULL_MIN g_pGameRules->GetViewVectors()->m_vDuckHullMin
# define VEC_DUCK_HULL_MAX g_pGameRules->GetViewVectors()->m_vDuckHullMax
# define VEC_DUCK_VIEW g_pGameRules->GetViewVectors()->m_vDuckView
# define VEC_OBS_HULL_MIN g_pGameRules->GetViewVectors()->m_vObsHullMin
# define VEC_OBS_HULL_MAX g_pGameRules->GetViewVectors()->m_vObsHullMax
# define VEC_DEAD_VIEWHEIGHT g_pGameRules->GetViewVectors()->m_vDeadViewHeight
// If the player (enemy bots) are scaled, adjust the hull
# define VEC_VIEW_SCALED( player ) ( g_pGameRules->GetViewVectors()->m_vView * player->GetModelScale() )
# define VEC_HULL_MIN_SCALED( player ) ( g_pGameRules->GetViewVectors()->m_vHullMin * player->GetModelScale() )
# define VEC_HULL_MAX_SCALED( player ) ( g_pGameRules->GetViewVectors()->m_vHullMax * player->GetModelScale() )
# define VEC_DUCK_HULL_MIN_SCALED( player ) ( g_pGameRules->GetViewVectors()->m_vDuckHullMin * player->GetModelScale() )
# define VEC_DUCK_HULL_MAX_SCALED( player ) ( g_pGameRules->GetViewVectors()->m_vDuckHullMax * player->GetModelScale() )
# define VEC_DUCK_VIEW_SCALED( player ) ( g_pGameRules->GetViewVectors()->m_vDuckView * player->GetModelScale() )
# define VEC_OBS_HULL_MIN_SCALED( player ) ( g_pGameRules->GetViewVectors()->m_vObsHullMin * player->GetModelScale() )
# define VEC_OBS_HULL_MAX_SCALED( player ) ( g_pGameRules->GetViewVectors()->m_vObsHullMax * player->GetModelScale() )
# define VEC_DEAD_VIEWHEIGHT_SCALED( player ) ( g_pGameRules->GetViewVectors()->m_vDeadViewHeight * player->GetModelScale() )
# define WATERJUMP_HEIGHT 8
# define MAX_CLIMB_SPEED 200
# if defined(TF_DLL) || defined(TF_CLIENT_DLL)
# define TIME_TO_DUCK 0.2
# define TIME_TO_DUCK_MS 200.0f
# else
# define TIME_TO_DUCK 0.4
# define TIME_TO_DUCK_MS 400.0f
# endif
# define TIME_TO_UNDUCK 0.2
# define TIME_TO_UNDUCK_MS 200.0f
# define MAX_WEAPON_SLOTS 6 // hud item selection slots
# define MAX_WEAPON_POSITIONS 20 // max number of items within a slot
# define MAX_ITEM_TYPES 6 // hud item selection slots
# define MAX_WEAPONS 48 // Max number of weapons available
# define MAX_ITEMS 5 // hard coded item types
# define WEAPON_NOCLIP -1 // clip sizes set to this tell the weapon it doesn't use a clip
# define MAX_AMMO_TYPES 32 // ???
# define MAX_AMMO_SLOTS 32 // not really slots
# define HUD_PRINTNOTIFY 1
# define HUD_PRINTCONSOLE 2
# define HUD_PRINTTALK 3
# define HUD_PRINTCENTER 4
// Vote creation or processing failure codes
typedef enum
{
VOTE_FAILED_GENERIC = 0 ,
VOTE_FAILED_TRANSITIONING_PLAYERS ,
VOTE_FAILED_RATE_EXCEEDED ,
VOTE_FAILED_YES_MUST_EXCEED_NO ,
VOTE_FAILED_QUORUM_FAILURE ,
VOTE_FAILED_ISSUE_DISABLED ,
VOTE_FAILED_MAP_NOT_FOUND ,
VOTE_FAILED_MAP_NAME_REQUIRED ,
2022-03-01 20:00:42 +00:00
VOTE_FAILED_FAILED_RECENTLY ,
2020-04-22 16:56:21 +00:00
VOTE_FAILED_TEAM_CANT_CALL ,
VOTE_FAILED_WAITINGFORPLAYERS ,
VOTE_FAILED_PLAYERNOTFOUND ,
VOTE_FAILED_CANNOT_KICK_ADMIN ,
VOTE_FAILED_SCRAMBLE_IN_PROGRESS ,
VOTE_FAILED_SPECTATOR ,
VOTE_FAILED_NEXTLEVEL_SET ,
VOTE_FAILED_MAP_NOT_VALID ,
VOTE_FAILED_CANNOT_KICK_FOR_TIME ,
VOTE_FAILED_CANNOT_KICK_DURING_ROUND ,
// TF-specific?
VOTE_FAILED_MODIFICATION_ALREADY_ACTIVE ,
} vote_create_failed_t ;
enum
{
# ifdef STAGING_ONLY
SERVER_MODIFICATION_ITEM_DURATION_IN_MINUTES = 2
# else
SERVER_MODIFICATION_ITEM_DURATION_IN_MINUTES = 120
# endif
} ;
# define MAX_VOTE_DETAILS_LENGTH 64
# define INVALID_ISSUE -1
# define MAX_VOTE_OPTIONS 5
# define DEDICATED_SERVER 99
enum CastVote
{
VOTE_OPTION1 , // Use this for Yes
VOTE_OPTION2 , // Use this for No
VOTE_OPTION3 ,
VOTE_OPTION4 ,
VOTE_OPTION5 ,
VOTE_UNCAST
} ;
//===================================================================================================================
// Close caption flags
# define CLOSE_CAPTION_WARNIFMISSING ( 1<<0 )
# define CLOSE_CAPTION_FROMPLAYER ( 1<<1 )
# define CLOSE_CAPTION_GENDER_MALE ( 1<<2 )
# define CLOSE_CAPTION_GENDER_FEMALE ( 1<<3 )
//===================================================================================================================
// Hud Element hiding flags
# define HIDEHUD_WEAPONSELECTION ( 1<<0 ) // Hide ammo count & weapon selection
# define HIDEHUD_FLASHLIGHT ( 1<<1 )
# define HIDEHUD_ALL ( 1<<2 )
# define HIDEHUD_HEALTH ( 1<<3 ) // Hide health & armor / suit battery
# define HIDEHUD_PLAYERDEAD ( 1<<4 ) // Hide when local player's dead
# define HIDEHUD_NEEDSUIT ( 1<<5 ) // Hide when the local player doesn't have the HEV suit
# define HIDEHUD_MISCSTATUS ( 1<<6 ) // Hide miscellaneous status elements (trains, pickup history, death notices, etc)
# define HIDEHUD_CHAT ( 1<<7 ) // Hide all communication elements (saytext, voice icon, etc)
# define HIDEHUD_CROSSHAIR ( 1<<8 ) // Hide crosshairs
# define HIDEHUD_VEHICLE_CROSSHAIR ( 1<<9 ) // Hide vehicle crosshair
# define HIDEHUD_INVEHICLE ( 1<<10 )
# define HIDEHUD_BONUS_PROGRESS ( 1<<11 ) // Hide bonus progress display (for bonus map challenges)
# define HIDEHUD_BITCOUNT 12
//===================================================================================================================
// suit usage bits
# define bits_SUIT_DEVICE_SPRINT 0x00000001
# define bits_SUIT_DEVICE_FLASHLIGHT 0x00000002
# define bits_SUIT_DEVICE_BREATHER 0x00000004
# define MAX_SUIT_DEVICES 3
//===================================================================================================================
// Player Defines
// Max number of players in a game ( see const.h for ABSOLUTE_PLAYER_LIMIT (256 ) )
// The Source engine is really designed for 32 or less players. If you raise this number above 32, you better know what you are doing
// and have a good answer for a bunch of perf question related to player simulation, thinking logic, tracelines, networking overhead, etc.
// But if you are brave or are doing something interesting, go for it... ywb 9/22/03
//You might be wondering why these aren't multiple of 2. Well the reason is that if servers decide to have HLTV or Replay enabled we need the extra slot.
//This is ok since MAX_PLAYERS is used for code specific things like arrays and loops, but it doesn't really means that this is the max number of players allowed
//Since this is decided by the gamerules (and it can be whatever number as long as its less than MAX_PLAYERS).
# if defined( CSTRIKE_DLL )
# define MAX_PLAYERS 65 // Absolute max players supported
# else
# define MAX_PLAYERS 33 // Absolute max players supported
# endif
# define MAX_PLACE_NAME_LENGTH 18
# define MAX_FOV 90
//===================================================================================================================
// Team Defines
# define TEAM_ANY -2
# define TEAM_INVALID -1
# define TEAM_UNASSIGNED 0 // not assigned to a team
# define TEAM_SPECTATOR 1 // spectator team
// Start your team numbers after this
# define LAST_SHARED_TEAM TEAM_SPECTATOR
// The first team that's game specific (i.e. not unassigned / spectator)
# define FIRST_GAME_TEAM (LAST_SHARED_TEAM+1)
# define MAX_TEAMS 32 // Max number of teams in a game
# define MAX_TEAM_NAME_LENGTH 32 // Max length of a team's name
// Weapon m_iState
# define WEAPON_IS_ONTARGET 0x40
# define WEAPON_NOT_CARRIED 0 // Weapon is on the ground
# define WEAPON_IS_CARRIED_BY_PLAYER 1 // This client is carrying this weapon.
# define WEAPON_IS_ACTIVE 2 // This client is carrying this weapon and it's the currently held weapon
// -----------------------------------------
// Skill Level
// -----------------------------------------
# define SKILL_EASY 1
# define SKILL_MEDIUM 2
# define SKILL_HARD 3
// Weapon flags
// -----------------------------------------
// Flags - NOTE: KEEP g_ItemFlags IN WEAPON_PARSE.CPP UPDATED WITH THESE
// -----------------------------------------
# define ITEM_FLAG_SELECTONEMPTY (1<<0)
# define ITEM_FLAG_NOAUTORELOAD (1<<1)
# define ITEM_FLAG_NOAUTOSWITCHEMPTY (1<<2)
# define ITEM_FLAG_LIMITINWORLD (1<<3)
# define ITEM_FLAG_EXHAUSTIBLE (1<<4) // A player can totally exhaust their ammo supply and lose this weapon
# define ITEM_FLAG_DOHITLOCATIONDMG (1<<5) // This weapon take hit location into account when applying damage
# define ITEM_FLAG_NOAMMOPICKUPS (1<<6) // Don't draw ammo pickup sprites/sounds when ammo is received
# define ITEM_FLAG_NOITEMPICKUP (1<<7) // Don't draw weapon pickup when this weapon is picked up by the player
// NOTE: KEEP g_ItemFlags IN WEAPON_PARSE.CPP UPDATED WITH THESE
// Humans only have left and right hands, though we might have aliens with more
// than two, sigh
# define MAX_VIEWMODELS 2
# define MAX_BEAM_ENTS 10
# define TRACER_TYPE_DEFAULT 0x00000001
# define TRACER_TYPE_GUNSHIP 0x00000002
# define TRACER_TYPE_STRIDER 0x00000004 // Here ya go, Jay!
# define TRACER_TYPE_GAUSS 0x00000008
# define TRACER_TYPE_WATERBULLET 0x00000010
# define MUZZLEFLASH_TYPE_DEFAULT 0x00000001
# define MUZZLEFLASH_TYPE_GUNSHIP 0x00000002
# define MUZZLEFLASH_TYPE_STRIDER 0x00000004
// Muzzle flash definitions (for the flags field of the "MuzzleFlash" DispatchEffect)
enum
{
MUZZLEFLASH_AR2 = 0 ,
MUZZLEFLASH_SHOTGUN ,
MUZZLEFLASH_SMG1 ,
MUZZLEFLASH_SMG2 ,
MUZZLEFLASH_PISTOL ,
MUZZLEFLASH_COMBINE ,
MUZZLEFLASH_357 ,
MUZZLEFLASH_RPG ,
MUZZLEFLASH_COMBINE_TURRET ,
MUZZLEFLASH_FIRSTPERSON = 0x100 ,
} ;
// Tracer Flags
# define TRACER_FLAG_WHIZ 0x0001
# define TRACER_FLAG_USEATTACHMENT 0x0002
# define TRACER_DONT_USE_ATTACHMENT -1
// Entity Dissolve types
enum
{
ENTITY_DISSOLVE_NORMAL = 0 ,
ENTITY_DISSOLVE_ELECTRICAL ,
ENTITY_DISSOLVE_ELECTRICAL_LIGHT ,
ENTITY_DISSOLVE_CORE ,
// NOTE: Be sure to up the bits if you make more dissolve types
ENTITY_DISSOLVE_BITS = 3
} ;
// ---------------------------
// Hit Group standards
// ---------------------------
# define HITGROUP_GENERIC 0
# define HITGROUP_HEAD 1
# define HITGROUP_CHEST 2
# define HITGROUP_STOMACH 3
# define HITGROUP_LEFTARM 4
# define HITGROUP_RIGHTARM 5
# define HITGROUP_LEFTLEG 6
# define HITGROUP_RIGHTLEG 7
# define HITGROUP_GEAR 10 // alerts NPC, but doesn't do damage or bleed (1/100th damage)
//
// Enumerations for setting player animation.
//
enum PLAYER_ANIM
{
PLAYER_IDLE ,
PLAYER_WALK ,
PLAYER_JUMP ,
PLAYER_SUPERJUMP ,
PLAYER_DIE ,
PLAYER_ATTACK1 ,
PLAYER_IN_VEHICLE ,
// TF Player animations
PLAYER_RELOAD ,
PLAYER_START_AIMING ,
PLAYER_LEAVE_AIMING ,
} ;
# ifdef HL2_DLL
// HL2 has 600 gravity by default
// NOTE: The discrete ticks can have quantization error, so these numbers are biased a little to
// make the heights more exact
# define PLAYER_FATAL_FALL_SPEED 922.5f // approx 60 feet sqrt( 2 * gravity * 60 * 12 )
# define PLAYER_MAX_SAFE_FALL_SPEED 526.5f // approx 20 feet sqrt( 2 * gravity * 20 * 12 )
# define PLAYER_LAND_ON_FLOATING_OBJECT 173 // Can fall another 173 in/sec without getting hurt
# define PLAYER_MIN_BOUNCE_SPEED 173
# define PLAYER_FALL_PUNCH_THRESHOLD 303.0f // won't punch player's screen/make scrape noise unless player falling at least this fast - at least a 76" fall (sqrt( 2 * g * 76))
# else
# define PLAYER_FATAL_FALL_SPEED 1024 // approx 60 feet
# define PLAYER_MAX_SAFE_FALL_SPEED 580 // approx 20 feet
# define PLAYER_LAND_ON_FLOATING_OBJECT 200 // Can go another 200 units without getting hurt
# define PLAYER_MIN_BOUNCE_SPEED 200
# define PLAYER_FALL_PUNCH_THRESHOLD (float)350 // won't punch player's screen/make scrape noise unless player falling at least this fast.
# endif
# define DAMAGE_FOR_FALL_SPEED 100.0f / ( PLAYER_FATAL_FALL_SPEED - PLAYER_MAX_SAFE_FALL_SPEED ) // damage per unit per second.
# define AUTOAIM_2DEGREES 0.0348994967025
# define AUTOAIM_5DEGREES 0.08715574274766
# define AUTOAIM_8DEGREES 0.1391731009601
# define AUTOAIM_10DEGREES 0.1736481776669
# define AUTOAIM_20DEGREES 0.3490658503989
# define AUTOAIM_SCALE_DEFAULT 1.0f
# define AUTOAIM_SCALE_DIRECT_ONLY 0.0f
// instant damage
// For a means of resolving these consts into debug string text, see function
// CTakeDamageInfo::DebugGetDamageTypeString(unsigned int DamageType, char *outbuf, unsigned int outbuflength )
# define DMG_GENERIC 0 // generic damage -- do not use if you want players to flinch and bleed!
# define DMG_CRUSH (1 << 0) // crushed by falling or moving object.
// NOTE: It's assumed crush damage is occurring as a result of physics collision, so no extra physics force is generated by crush damage.
// DON'T use DMG_CRUSH when damaging entities unless it's the result of a physics collision. You probably want DMG_CLUB instead.
# define DMG_BULLET (1 << 1) // shot
# define DMG_SLASH (1 << 2) // cut, clawed, stabbed
# define DMG_BURN (1 << 3) // heat burned
# define DMG_VEHICLE (1 << 4) // hit by a vehicle
# 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_PREVENT_PHYSICS_FORCE (1 << 11) // Prevent a physics force
# 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.
# define DMG_DROWN (1 << 14) // Drowning
# define DMG_PARALYZE (1 << 15) // slows affected creature down
# define DMG_NERVEGAS (1 << 16) // nerve toxins, very bad
# define DMG_POISON (1 << 17) // blood poisoning - heals over time like drowning damage
# 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_REMOVENORAGDOLL (1<<22) // with this bit OR'd in, no ragdoll will be created, and the target will be quietly removed.
// use this to kill an entity that you've already got a server-side ragdoll for
# define DMG_PHYSGUN (1<<23) // Hit by manipulator. Usually doesn't do any damage.
# define DMG_PLASMA (1<<24) // Shot by Cremator
# define DMG_AIRBOAT (1<<25) // Hit by the airboat's gun
# define DMG_DISSOLVE (1<<26) // Dissolving!
# define DMG_BLAST_SURFACE (1<<27) // A blast on the surface of water that cannot harm things underwater
# define DMG_DIRECT (1<<28)
# define DMG_BUCKSHOT (1<<29) // not quite a bullet. Little, rounder, different.
// NOTE: DO NOT ADD ANY MORE CUSTOM DMG_ TYPES. MODS USE THE DMG_LASTGENERICFLAG BELOW, AND
// IF YOU ADD NEW DMG_ TYPES, THEIR TYPES WILL BE HOSED. WE NEED A BETTER SOLUTION.
// TODO: keep this up to date so all the mod-specific flags don't overlap anything.
# define DMG_LASTGENERICFLAG DMG_BUCKSHOT
// settings for m_takedamage
# define DAMAGE_NO 0
# define DAMAGE_EVENTS_ONLY 1 // Call damage functions, but don't modify health
# define DAMAGE_YES 2
# define DAMAGE_AIM 3
// Spectator Movement modes
enum {
OBS_MODE_NONE = 0 , // not in spectator mode
OBS_MODE_DEATHCAM , // special mode for death cam animation
OBS_MODE_FREEZECAM , // zooms to a target, and freeze-frames on them
OBS_MODE_FIXED , // view from a fixed camera position
OBS_MODE_IN_EYE , // follow a player in first person view
OBS_MODE_CHASE , // follow a player in third person view
OBS_MODE_ROAMING , // free roaming
NUM_OBSERVER_MODES ,
} ;
# define LAST_PLAYER_OBSERVERMODE OBS_MODE_ROAMING
// Force Camera Restrictions with mp_forcecamera
enum {
OBS_ALLOW_ALL = 0 , // allow all modes, all targets
OBS_ALLOW_TEAM , // allow only own team & first person, no PIP
OBS_ALLOW_NONE , // don't allow any spectating after death (fixed & fade to black)
OBS_ALLOW_NUM_MODES ,
} ;
enum
{
TYPE_TEXT = 0 , // just display this plain text
TYPE_INDEX , // lookup text & title in stringtable
TYPE_URL , // show this URL
TYPE_FILE , // show this local file
} ;
//=============================================================================
// HPE_BEGIN:
// [Forrest] Replaced text window command string with TEXTWINDOW_CMD enumeration
// of options. Passing a command string is dangerous and allowed a server network
// message to run arbitrary commands on the client.
//=============================================================================
enum
{
TEXTWINDOW_CMD_NONE = 0 ,
TEXTWINDOW_CMD_JOINGAME ,
TEXTWINDOW_CMD_CHANGETEAM ,
TEXTWINDOW_CMD_IMPULSE101 ,
TEXTWINDOW_CMD_MAPINFO ,
TEXTWINDOW_CMD_CLOSED_HTMLPAGE ,
TEXTWINDOW_CMD_CHOOSETEAM ,
} ;
//=============================================================================
// HPE_END
//=============================================================================
// VGui Screen Flags
enum
{
VGUI_SCREEN_ACTIVE = 0x1 ,
VGUI_SCREEN_VISIBLE_TO_TEAMMATES = 0x2 ,
VGUI_SCREEN_ATTACHED_TO_VIEWMODEL = 0x4 ,
VGUI_SCREEN_TRANSPARENT = 0x8 ,
VGUI_SCREEN_ONLY_USABLE_BY_OWNER = 0x10 ,
VGUI_SCREEN_MAX_BITS = 5
} ;
typedef enum
{
USE_OFF = 0 ,
USE_ON = 1 ,
USE_SET = 2 ,
USE_TOGGLE = 3
} USE_TYPE ;
// basic team colors
# define COLOR_RED Color(255, 64, 64, 255)
# define COLOR_BLUE Color(153, 204, 255, 255)
# define COLOR_YELLOW Color(255, 178, 0, 255)
# define COLOR_GREEN Color(153, 255, 153, 255)
# define COLOR_GREY Color(204, 204, 204, 255)
# define COLOR_WHITE Color(255, 255, 255, 255)
# define COLOR_BLACK Color(0, 0, 0, 255)
// All NPCs need this data
enum
{
DONT_BLEED = - 1 ,
BLOOD_COLOR_RED = 0 ,
BLOOD_COLOR_YELLOW ,
BLOOD_COLOR_GREEN ,
BLOOD_COLOR_MECH ,
# if defined( HL2_EPISODIC )
BLOOD_COLOR_ANTLION , // FIXME: Move to Base HL2
BLOOD_COLOR_ZOMBIE , // FIXME: Move to Base HL2
BLOOD_COLOR_ANTLION_WORKER ,
# endif // HL2_EPISODIC
} ;
//-----------------------------------------------------------------------------
// Vehicles may have more than one passenger.
// This enum may be expanded by derived classes
//-----------------------------------------------------------------------------
enum PassengerRole_t
{
VEHICLE_ROLE_NONE = - 1 ,
VEHICLE_ROLE_DRIVER = 0 , // Only one driver
LAST_SHARED_VEHICLE_ROLE ,
} ;
//-----------------------------------------------------------------------------
// Water splash effect flags
//-----------------------------------------------------------------------------
enum
{
FX_WATER_IN_SLIME = 0x1 ,
} ;
// Shared think context stuff
# define MAX_CONTEXT_LENGTH 32
# define NO_THINK_CONTEXT -1
// entity flags, CBaseEntity::m_iEFlags
enum
{
EFL_KILLME = ( 1 < < 0 ) , // This entity is marked for death -- This allows the game to actually delete ents at a safe time
EFL_DORMANT = ( 1 < < 1 ) , // Entity is dormant, no updates to client
EFL_NOCLIP_ACTIVE = ( 1 < < 2 ) , // Lets us know when the noclip command is active.
EFL_SETTING_UP_BONES = ( 1 < < 3 ) , // Set while a model is setting up its bones.
EFL_KEEP_ON_RECREATE_ENTITIES = ( 1 < < 4 ) , // This is a special entity that should not be deleted when we restart entities only
EFL_HAS_PLAYER_CHILD = ( 1 < < 4 ) , // One of the child entities is a player.
EFL_DIRTY_SHADOWUPDATE = ( 1 < < 5 ) , // Client only- need shadow manager to update the shadow...
EFL_NOTIFY = ( 1 < < 6 ) , // Another entity is watching events on this entity (used by teleport)
// The default behavior in ShouldTransmit is to not send an entity if it doesn't
// have a model. Certain entities want to be sent anyway because all the drawing logic
// is in the client DLL. They can set this flag and the engine will transmit them even
// if they don't have a model.
EFL_FORCE_CHECK_TRANSMIT = ( 1 < < 7 ) ,
EFL_BOT_FROZEN = ( 1 < < 8 ) , // This is set on bots that are frozen.
EFL_SERVER_ONLY = ( 1 < < 9 ) , // Non-networked entity.
EFL_NO_AUTO_EDICT_ATTACH = ( 1 < < 10 ) , // Don't attach the edict; we're doing it explicitly
// Some dirty bits with respect to abs computations
EFL_DIRTY_ABSTRANSFORM = ( 1 < < 11 ) ,
EFL_DIRTY_ABSVELOCITY = ( 1 < < 12 ) ,
EFL_DIRTY_ABSANGVELOCITY = ( 1 < < 13 ) ,
EFL_DIRTY_SURROUNDING_COLLISION_BOUNDS = ( 1 < < 14 ) ,
EFL_DIRTY_SPATIAL_PARTITION = ( 1 < < 15 ) ,
// UNUSED = (1<<16),
EFL_IN_SKYBOX = ( 1 < < 17 ) , // This is set if the entity detects that it's in the skybox.
// This forces it to pass the "in PVS" for transmission.
EFL_USE_PARTITION_WHEN_NOT_SOLID = ( 1 < < 18 ) , // Entities with this flag set show up in the partition even when not solid
EFL_TOUCHING_FLUID = ( 1 < < 19 ) , // Used to determine if an entity is floating
// FIXME: Not really sure where I should add this...
EFL_IS_BEING_LIFTED_BY_BARNACLE = ( 1 < < 20 ) ,
EFL_NO_ROTORWASH_PUSH = ( 1 < < 21 ) , // I shouldn't be pushed by the rotorwash
EFL_NO_THINK_FUNCTION = ( 1 < < 22 ) ,
EFL_NO_GAME_PHYSICS_SIMULATION = ( 1 < < 23 ) ,
EFL_CHECK_UNTOUCH = ( 1 < < 24 ) ,
EFL_DONTBLOCKLOS = ( 1 < < 25 ) , // I shouldn't block NPC line-of-sight
EFL_DONTWALKON = ( 1 < < 26 ) , // NPC;s should not walk on this entity
EFL_NO_DISSOLVE = ( 1 < < 27 ) , // These guys shouldn't dissolve
EFL_NO_MEGAPHYSCANNON_RAGDOLL = ( 1 < < 28 ) , // Mega physcannon can't ragdoll these guys.
EFL_NO_WATER_VELOCITY_CHANGE = ( 1 < < 29 ) , // Don't adjust this entity's velocity when transitioning into water
EFL_NO_PHYSCANNON_INTERACTION = ( 1 < < 30 ) , // Physcannon can't pick these up or punt them
EFL_NO_DAMAGE_FORCES = ( 1 < < 31 ) , // Doesn't accept forces from physics damage
} ;
//-----------------------------------------------------------------------------
// EFFECTS
//-----------------------------------------------------------------------------
const int FX_BLOODSPRAY_DROPS = 0x01 ;
const int FX_BLOODSPRAY_GORE = 0x02 ;
const int FX_BLOODSPRAY_CLOUD = 0x04 ;
const int FX_BLOODSPRAY_ALL = 0xFF ;
//-----------------------------------------------------------------------------
# define MAX_SCREEN_OVERLAYS 10
// These are the types of data that hang off of CBaseEntities and the flag bits used to mark their presence
enum
{
GROUNDLINK = 0 ,
TOUCHLINK ,
STEPSIMULATION ,
MODELSCALE ,
POSITIONWATCHER ,
PHYSICSPUSHLIST ,
VPHYSICSUPDATEAI ,
VPHYSICSWATCHER ,
// Must be last and <= 32
NUM_DATAOBJECT_TYPES ,
} ;
class CBaseEntity ;
//-----------------------------------------------------------------------------
// Bullet firing information
//-----------------------------------------------------------------------------
class CBaseEntity ;
enum FireBulletsFlags_t
{
FIRE_BULLETS_FIRST_SHOT_ACCURATE = 0x1 , // Pop the first shot with perfect accuracy
FIRE_BULLETS_DONT_HIT_UNDERWATER = 0x2 , // If the shot hits its target underwater, don't damage it
FIRE_BULLETS_ALLOW_WATER_SURFACE_IMPACTS = 0x4 , // If the shot hits water surface, still call DoImpactEffect
FIRE_BULLETS_TEMPORARY_DANGER_SOUND = 0x8 , // Danger sounds added from this impact can be stomped immediately if another is queued
} ;
struct FireBulletsInfo_t
{
FireBulletsInfo_t ( )
{
m_iShots = 1 ;
m_vecSpread . Init ( 0 , 0 , 0 ) ;
m_flDistance = 8192 ;
m_iTracerFreq = 4 ;
m_flDamage = 0 ;
m_iPlayerDamage = 0 ;
m_pAttacker = NULL ;
m_nFlags = 0 ;
m_pAdditionalIgnoreEnt = NULL ;
m_flDamageForceScale = 1.0f ;
# ifdef _DEBUG
m_iAmmoType = - 1 ;
m_vecSrc . Init ( VEC_T_NAN , VEC_T_NAN , VEC_T_NAN ) ;
m_vecDirShooting . Init ( VEC_T_NAN , VEC_T_NAN , VEC_T_NAN ) ;
# endif
m_bPrimaryAttack = true ;
}
FireBulletsInfo_t ( int nShots , const Vector & vecSrc , const Vector & vecDir , const Vector & vecSpread , float flDistance , int nAmmoType , bool bPrimaryAttack = true )
{
m_iShots = nShots ;
m_vecSrc = vecSrc ;
m_vecDirShooting = vecDir ;
m_vecSpread = vecSpread ;
m_flDistance = flDistance ;
m_iAmmoType = nAmmoType ;
m_iTracerFreq = 4 ;
m_flDamage = 0 ;
m_iPlayerDamage = 0 ;
m_pAttacker = NULL ;
m_nFlags = 0 ;
m_pAdditionalIgnoreEnt = NULL ;
m_flDamageForceScale = 1.0f ;
m_bPrimaryAttack = bPrimaryAttack ;
}
int m_iShots ;
Vector m_vecSrc ;
Vector m_vecDirShooting ;
Vector m_vecSpread ;
float m_flDistance ;
int m_iAmmoType ;
int m_iTracerFreq ;
float m_flDamage ;
int m_iPlayerDamage ; // Damage to be used instead of m_flDamage if we hit a player
int m_nFlags ; // See FireBulletsFlags_t
float m_flDamageForceScale ;
CBaseEntity * m_pAttacker ;
CBaseEntity * m_pAdditionalIgnoreEnt ;
bool m_bPrimaryAttack ;
} ;
//-----------------------------------------------------------------------------
// Purpose: Data for making the MOVETYPE_STEP entities appear to simulate every frame
// We precompute the simulation and then meter it out each tick during networking of the
// entities origin and orientation. Uses a bit more bandwidth, but it solves the NPCs interacting
// with elevators/lifts bugs.
//-----------------------------------------------------------------------------
struct StepSimulationStep
{
int nTickCount ;
Vector vecOrigin ;
Quaternion qRotation ;
} ;
struct StepSimulationData
{
// Are we using the Step Simulation Data
bool m_bOriginActive ;
bool m_bAnglesActive ;
// This is the pre-pre-Think position, orientation (Quaternion) and tick count
StepSimulationStep m_Previous2 ;
// This is the pre-Think position, orientation (Quaternion) and tick count
StepSimulationStep m_Previous ;
// This is a potential mid-think position, orientation (Quaternion) and tick count
// Used to mark motion discontinuities that happen between thinks
StepSimulationStep m_Discontinuity ;
// This is the goal or post-Think position and orientation (and Quaternion for blending) and next think time tick
StepSimulationStep m_Next ;
QAngle m_angNextRotation ;
// This variable is used so that we only compute networked origin/angles once per tick
int m_nLastProcessTickCount ;
// The computed/interpolated network origin/angles to use
Vector m_vecNetworkOrigin ;
QAngle m_angNetworkAngles ;
} ;
//-----------------------------------------------------------------------------
// Purpose: Simple state tracking for changing model sideways shrinkage during barnacle swallow
//-----------------------------------------------------------------------------
struct ModelScale
{
float m_flModelScaleStart ;
float m_flModelScaleGoal ;
float m_flModelScaleFinishTime ;
float m_flModelScaleStartTime ;
} ;
# include "soundflags.h"
struct CSoundParameters ;
typedef short HSOUNDSCRIPTHANDLE ;
//-----------------------------------------------------------------------------
// Purpose: Aggregates and sets default parameters for EmitSound function calls
//-----------------------------------------------------------------------------
struct EmitSound_t
{
EmitSound_t ( ) :
m_nChannel ( 0 ) ,
m_pSoundName ( 0 ) ,
m_flVolume ( VOL_NORM ) ,
m_SoundLevel ( SNDLVL_NONE ) ,
m_nFlags ( 0 ) ,
m_nPitch ( PITCH_NORM ) ,
m_nSpecialDSP ( 0 ) ,
m_pOrigin ( 0 ) ,
m_flSoundTime ( 0.0f ) ,
m_pflSoundDuration ( 0 ) ,
m_bEmitCloseCaption ( true ) ,
m_bWarnOnMissingCloseCaption ( false ) ,
m_bWarnOnDirectWaveReference ( false ) ,
m_nSpeakerEntity ( - 1 ) ,
m_UtlVecSoundOrigin ( ) ,
m_hSoundScriptHandle ( - 1 )
{
}
EmitSound_t ( const CSoundParameters & src ) ;
int m_nChannel ;
char const * m_pSoundName ;
float m_flVolume ;
soundlevel_t m_SoundLevel ;
int m_nFlags ;
int m_nPitch ;
int m_nSpecialDSP ;
const Vector * m_pOrigin ;
float m_flSoundTime ; ///< NOT DURATION, but rather, some absolute time in the future until which this sound should be delayed
float * m_pflSoundDuration ;
bool m_bEmitCloseCaption ;
bool m_bWarnOnMissingCloseCaption ;
bool m_bWarnOnDirectWaveReference ;
int m_nSpeakerEntity ;
mutable CUtlVector < Vector > m_UtlVecSoundOrigin ; ///< Actual sound origin(s) (can be multiple if sound routed through speaker entity(ies) )
mutable HSOUNDSCRIPTHANDLE m_hSoundScriptHandle ;
} ;
# define MAX_ACTORS_IN_SCENE 16
//-----------------------------------------------------------------------------
// Multiplayer specific defines
//-----------------------------------------------------------------------------
# define MAX_CONTROL_POINTS 8
# define MAX_CONTROL_POINT_GROUPS 8
// Maximum number of points that a control point may need owned to be cappable
# define MAX_PREVIOUS_POINTS 3
// The maximum number of teams the control point system knows how to deal with
# define MAX_CONTROL_POINT_TEAMS 8
// Maximum length of the cap layout string
# define MAX_CAPLAYOUT_LENGTH 32
// Maximum length of the current round printname
# define MAX_ROUND_NAME 32
// Maximum length of the current round name
# define MAX_ROUND_IMAGE_NAME 64
// Score added to the team score for a round win
# define TEAMPLAY_ROUND_WIN_SCORE 1
enum
{
CP_WARN_NORMAL = 0 ,
CP_WARN_FINALCAP ,
CP_WARN_NO_ANNOUNCEMENTS
} ;
// YWB: 3/12/2007
// Changing the following #define for Prediction Error checking (See gamemovement.cpp for overview) will to 1 or 2 enables the system, 0 turns it off
// Level 1 enables it, but doesn't force "full precision" networking, so you can still get lots of errors in position/velocity/etc.
// Level 2 enables it but also forces origins/angles to be sent full precision, so other fields can be error / tolerance checked
// NOTE: This stuff only works on a listen server since it punches a hole from the client .dll to server .dll!!!
# define PREDICTION_ERROR_CHECK_LEVEL 0
//-----------------------------------------------------------------------------
// Round timer states
//-----------------------------------------------------------------------------
enum
{
RT_STATE_SETUP , // Timer is in setup mode
RT_STATE_NORMAL , // Timer is in normal mode
} ;
enum
{
SIMULATION_TIME_WINDOW_BITS = 8 ,
} ;
//-----------------------------------------------------------------------------
// Commentary Mode
//-----------------------------------------------------------------------------
# if defined(TF_DLL) || defined(TF_CLIENT_DLL)
# define GAME_HAS_NO_USE_KEY
# if defined( SPROP_COORD )
# undef SPROP_COORD
# endif
# define SPROP_COORD SPROP_COORD_MP
# endif
// The player's method of starting / stopping commentary
# ifdef GAME_HAS_NO_USE_KEY
# define COMMENTARY_BUTTONS (IN_ATTACK | IN_ATTACK2 | IN_USE)
# else
# define COMMENTARY_BUTTONS (IN_USE)
# endif
# define TEAM_TRAIN_MAX_TEAMS 4
# define TEAM_TRAIN_MAX_HILLS 5
# define TEAM_TRAIN_FLOATS_PER_HILL 2
# define TEAM_TRAIN_HILLS_ARRAY_SIZE TEAM_TRAIN_MAX_TEAMS * TEAM_TRAIN_MAX_HILLS * TEAM_TRAIN_FLOATS_PER_HILL
enum
{
HILL_TYPE_NONE = 0 ,
HILL_TYPE_UPHILL ,
HILL_TYPE_DOWNHILL ,
} ;
# define NOINTERP_PARITY_MAX 4
# define NOINTERP_PARITY_MAX_BITS 2
//-----------------------------------------------------------------------------
// Generic activity lookup support
//-----------------------------------------------------------------------------
enum
{
kActivityLookup_Unknown = - 2 , // hasn't been searched for
kActivityLookup_Missing = - 1 , // has been searched for but wasn't found
} ;
# if defined(TF_DLL) || defined(TF_CLIENT_DLL)
//-----------------------------------------------------------------------------
// Vision Filters.
//-----------------------------------------------------------------------------
// Also used in the item schema to define vision filter or vision mode opt in
# define TF_VISION_FILTER_NONE 0
# define TF_VISION_FILTER_PYRO (1<<0) // 1
# define TF_VISION_FILTER_HALLOWEEN (1<<1) // 2
# define TF_VISION_FILTER_ROME (1<<2) // 4
// THIS ENUM SHOULD MATCH THE ORDER OF THE FLAGS ABOVE
enum
{
VISION_MODE_NONE = 0 ,
VISION_MODE_PYRO ,
VISION_MODE_HALLOWEEN ,
VISION_MODE_ROME ,
MAX_VISION_MODES
} ;
# endif // TF_DLL || TF_CLIENT_DLL
# endif // SHAREDDEFS_H