1003 lines
35 KiB
C++
1003 lines
35 KiB
C++
//========= 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,
|
|
VOTE_FAILED_ON_COOLDOWN,
|
|
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,
|
|
VOTE_FAILED_VOTE_IN_PROGRESS,
|
|
VOTE_FAILED_KICK_LIMIT_REACHED,
|
|
|
|
// 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_POI, // PASSTIME point of interest - game objective, big fight,
|
|
// anything interesting; added in the middle of the enum due
|
|
// to tons of hard-coded "<ROAMING" enum compares
|
|
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;
|
|
m_bUseServerRandomSeed = false;
|
|
}
|
|
|
|
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;
|
|
m_bUseServerRandomSeed = false;
|
|
}
|
|
|
|
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;
|
|
bool m_bUseServerRandomSeed;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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 "../../public/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
|