mirror of
https://github.com/blendogames/thirtyflightsofloving.git
synced 2025-01-31 04:30:39 +00:00
95295401a4
Added weapon balancing and tech control cvars to 3ZB2 DLL. Added Vampire and Ammogen techs to 3ZB2 game DLL. Fixed func_door_secret movement bug (when built with origin brush) in Zaero DLL. Fixed armor stacking bug in default Lazarus, missionpack, and Zaero DLLs. Removed unused tech cvars in default Lazarus DLL. Changed parsing of TE_BLASTER_COLORED tempent.
1338 lines
34 KiB
C
1338 lines
34 KiB
C
// g_local.h -- local definitions for game module
|
|
|
|
#include "q_shared.h"
|
|
|
|
// define GAME_INCLUDE so that game.h does not define the
|
|
// short, server-visible gclient_t and edict_t structures,
|
|
// because we define the full size ones in this file
|
|
#define GAME_INCLUDE
|
|
#include "game.h"
|
|
#include "km_cvar.h"
|
|
|
|
// some custom defines
|
|
#ifdef Z_MAX
|
|
#undef Z_MAX
|
|
#endif // Z_MAX
|
|
#define Z_MAX(a,b) ((a) > (b) ? (a) : (b))
|
|
|
|
#ifdef Z_MIN
|
|
#undef Z_MIN
|
|
#endif // Z_MIN
|
|
#define Z_MIN(a,b) ((a) < (b) ? (a) : (b))
|
|
|
|
#define Z_MALLOC(size) gi.TagMalloc(size, TAG_GAME)
|
|
#define Z_FREE(block) gi.TagFree(block)
|
|
|
|
// Zaero includes
|
|
#include "z_debug.h"
|
|
#ifdef CACHE_SOUND
|
|
#include "z_list.h"
|
|
#endif
|
|
|
|
// the "gamename" client command will print this plus compile date
|
|
#define GAMEVERSION "Zaero 1.1"
|
|
|
|
// protocol bytes that can be directly added to messages
|
|
#define svc_muzzleflash 1
|
|
#define svc_muzzleflash2 2
|
|
#define svc_temp_entity 3
|
|
#define svc_layout 4
|
|
#define svc_inventory 5
|
|
|
|
//==================================================================
|
|
|
|
// view pitching times
|
|
#define DAMAGE_TIME 0.5
|
|
#define FALL_TIME 0.3
|
|
|
|
|
|
// edict->spawnflags
|
|
// these are set with checkboxes on each entity in the map editor
|
|
#define SPAWNFLAG_NOT_EASY 0x00000100
|
|
#define SPAWNFLAG_NOT_MEDIUM 0x00000200
|
|
#define SPAWNFLAG_NOT_HARD 0x00000400
|
|
#define SPAWNFLAG_NOT_DEATHMATCH 0x00000800
|
|
#define SPAWNFLAG_NOT_COOP 0x00001000
|
|
|
|
// edict->spawnflags2
|
|
// these are set with checkboxes on each entity in the map editor
|
|
#define SPAWNFLAG2_MIRRORLEVEL 0x0001
|
|
#define SPAWNFLAG2_NOT_COOP 0x0002
|
|
#define SPAWNFLAG2_NOT_SINGLE 0x0004
|
|
|
|
// edict->flags
|
|
#define FL_FLY 0x00000001
|
|
#define FL_SWIM 0x00000002 // implied immunity to drowining
|
|
#define FL_IMMUNE_LASER 0x00000004
|
|
#define FL_INWATER 0x00000008
|
|
#define FL_GODMODE 0x00000010
|
|
#define FL_NOTARGET 0x00000020
|
|
#define FL_IMMUNE_SLIME 0x00000040
|
|
#define FL_IMMUNE_LAVA 0x00000080
|
|
#define FL_PARTIALGROUND 0x00000100 // not all corners are valid
|
|
#define FL_WATERJUMP 0x00000200 // player jumping out of water
|
|
#define FL_TEAMSLAVE 0x00000400 // not the first on the team
|
|
#define FL_NO_KNOCKBACK 0x00000800
|
|
#define FL_POWER_ARMOR 0x00001000 // power armor (if any) is active
|
|
#define FL_DONTSETOLDORIGIN 0x00002000 // Don't set the old_origin for this entity
|
|
#define FL_BFGMISSFIRE 0x00004000 // BFG Miss Fire
|
|
#define FL_RESPAWN 0x80000000 // used for item respawning
|
|
|
|
|
|
|
|
#define FRAMETIME 0.1
|
|
|
|
// memory tags to allow dynamic memory to be cleaned up
|
|
#define TAG_GAME 765 // clear when unloading the dll
|
|
#define TAG_LEVEL 766 // clear when loading a new level
|
|
|
|
|
|
#define MELEE_DISTANCE 80
|
|
|
|
#define BODY_QUEUE_SIZE 8
|
|
|
|
typedef enum
|
|
{
|
|
DAMAGE_NO,
|
|
DAMAGE_YES, // will take damage if hit
|
|
DAMAGE_AIM, // auto targeting recognizes this
|
|
DAMAGE_IMMORTAL // similar to DAMAGE_YES, but health is not deducted
|
|
} damage_t;
|
|
|
|
typedef enum
|
|
{
|
|
WEAPON_READY,
|
|
WEAPON_ACTIVATING,
|
|
WEAPON_DROPPING,
|
|
WEAPON_FIRING
|
|
} weaponstate_t;
|
|
|
|
typedef enum
|
|
{
|
|
AMMO_BULLETS,
|
|
AMMO_SHELLS,
|
|
AMMO_ROCKETS,
|
|
AMMO_FLARES,
|
|
AMMO_GRENADES,
|
|
AMMO_CELLS,
|
|
AMMO_SLUGS,
|
|
AMMO_LASERTRIPBOMB,
|
|
AMMO_EMPNUKE,
|
|
AMMO_A2K,
|
|
AMMO_PLASMASHIELD
|
|
} ammo_t;
|
|
|
|
|
|
//deadflag
|
|
#define DEAD_NO 0
|
|
#define DEAD_DYING 1
|
|
#define DEAD_DEAD 2
|
|
#define DEAD_RESPAWNABLE 3
|
|
|
|
//range
|
|
#define RANGE_MELEE 0
|
|
#define RANGE_NEAR 1
|
|
#define RANGE_MID 2
|
|
#define RANGE_FAR 3
|
|
|
|
// gib types
|
|
#define GIB_ORGANIC 0
|
|
#define GIB_METALLIC 1
|
|
|
|
// monster ai flags
|
|
#define AI_STAND_GROUND 0x00000001
|
|
#define AI_TEMP_STAND_GROUND 0x00000002
|
|
#define AI_SOUND_TARGET 0x00000004
|
|
#define AI_LOST_SIGHT 0x00000008
|
|
#define AI_PURSUIT_LAST_SEEN 0x00000010
|
|
#define AI_PURSUE_NEXT 0x00000020
|
|
#define AI_PURSUE_TEMP 0x00000040
|
|
#define AI_HOLD_FRAME 0x00000080
|
|
#define AI_GOOD_GUY 0x00000100
|
|
#define AI_BRUTAL 0x00000200
|
|
#define AI_NOSTEP 0x00000400
|
|
#define AI_DUCKED 0x00000800
|
|
#define AI_COMBAT_POINT 0x00001000
|
|
#define AI_MEDIC 0x00002000
|
|
#define AI_RESURRECTING 0x00004000
|
|
#define AI_SCHOOLING 0x00008000
|
|
#define AI_REDUCEDDAMAGE 0x00010000
|
|
#define AI_SCHOOLINGTURNING 0x00020000
|
|
#define AI_SCHOOLINGTURNINGFAST 0x00040000
|
|
#define AI_DODGETIMEOUT 0x00080000
|
|
#define AI_JUMPING 0x00100000
|
|
#define AI_MONREDUCEDDAMAGE 0x00200000
|
|
#define AI_ONESHOTTARGET 0x00400000
|
|
|
|
|
|
// monster attack state
|
|
#define AS_STRAIGHT 1
|
|
#define AS_SLIDING 2
|
|
#define AS_MELEE 3
|
|
#define AS_MISSILE 4
|
|
#define AS_FLY_STRAFE 5
|
|
|
|
// armor types
|
|
#define ARMOR_NONE 0
|
|
#define ARMOR_JACKET 1
|
|
#define ARMOR_COMBAT 2
|
|
#define ARMOR_BODY 3
|
|
#define ARMOR_SHARD 4
|
|
|
|
// power armor types
|
|
#define POWER_ARMOR_NONE 0
|
|
#define POWER_ARMOR_SCREEN 1
|
|
#define POWER_ARMOR_SHIELD 2
|
|
|
|
// handedness values
|
|
#define RIGHT_HANDED 0
|
|
#define LEFT_HANDED 1
|
|
#define CENTER_HANDED 2
|
|
|
|
|
|
// game.serverflags values
|
|
#define SFL_CROSS_TRIGGER_1 0x00000001
|
|
#define SFL_CROSS_TRIGGER_2 0x00000002
|
|
#define SFL_CROSS_TRIGGER_3 0x00000004
|
|
#define SFL_CROSS_TRIGGER_4 0x00000008
|
|
#define SFL_CROSS_TRIGGER_5 0x00000010
|
|
#define SFL_CROSS_TRIGGER_6 0x00000020
|
|
#define SFL_CROSS_TRIGGER_7 0x00000040
|
|
#define SFL_CROSS_TRIGGER_8 0x00000080
|
|
#define SFL_CROSS_TRIGGER_MASK 0x000000ff
|
|
|
|
|
|
// noise types for PlayerNoise
|
|
#define PNOISE_SELF 0
|
|
#define PNOISE_WEAPON 1
|
|
#define PNOISE_IMPACT 2
|
|
|
|
|
|
// edict->movetype values
|
|
typedef enum
|
|
{
|
|
MOVETYPE_NONE, // never moves
|
|
MOVETYPE_NOCLIP, // origin and angles change with no interaction
|
|
MOVETYPE_PUSH, // no clip to world, push on box contact
|
|
MOVETYPE_STOP, // no clip to world, stops on box contact
|
|
|
|
MOVETYPE_WALK, // gravity
|
|
MOVETYPE_STEP, // gravity, special edge handling
|
|
MOVETYPE_FLY,
|
|
MOVETYPE_TOSS, // gravity
|
|
MOVETYPE_FLYMISSILE, // extra size to monsters
|
|
MOVETYPE_BOUNCE,
|
|
MOVETYPE_BOUNCEFLY,
|
|
MOVETYPE_FREEZE, // player freeze, used for Zaero Camera
|
|
MOVETYPE_FALLFLOAT, // falls down slopes and floats in water
|
|
MOVETYPE_RIDE // basically won't move unless it rides on a MOVETYPE_PUSH entity
|
|
} movetype_t;
|
|
|
|
|
|
|
|
|
|
typedef struct
|
|
{
|
|
int base_count;
|
|
int max_count;
|
|
float normal_protection;
|
|
float energy_protection;
|
|
int armor;
|
|
} gitem_armor_t;
|
|
|
|
|
|
// gitem_t->flags
|
|
#define IT_WEAPON 1 // use makes active weapon
|
|
#define IT_AMMO 2
|
|
#define IT_ARMOR 4
|
|
#define IT_STAY_COOP 8
|
|
#define IT_KEY 16
|
|
#define IT_POWERUP 32
|
|
|
|
// gitem_t->weapmodel for weapons indicates model index
|
|
#define WEAP_BLASTER 1
|
|
#define WEAP_SHOTGUN 2
|
|
#define WEAP_SUPERSHOTGUN 3
|
|
#define WEAP_MACHINEGUN 4
|
|
#define WEAP_CHAINGUN 5
|
|
#define WEAP_GRENADES 6
|
|
#define WEAP_GRENADELAUNCHER 7
|
|
#define WEAP_ROCKETLAUNCHER 8
|
|
#define WEAP_HYPERBLASTER 9
|
|
#define WEAP_RAILGUN 10
|
|
#define WEAP_BFG 11
|
|
#define WEAP_NONE 12
|
|
|
|
// hide flags
|
|
#define HIDE_FROM_INVENTORY 1 // don't list this item in the inventory
|
|
#define HIDE_DONT_KEEP 2 // don't keep in the lastweapon variable
|
|
#define HIDE_FROM_SELECTION 4 // don't autoselect or weapnext thru
|
|
|
|
typedef struct gitem_s
|
|
{
|
|
char *classname; // spawning name
|
|
qboolean (*pickup)(struct edict_s *ent, struct edict_s *other);
|
|
void (*use)(struct edict_s *ent, struct gitem_s *item);
|
|
void (*drop)(struct edict_s *ent, struct gitem_s *item);
|
|
void (*weaponthink)(struct edict_s *ent);
|
|
char *pickup_sound;
|
|
char *world_model;
|
|
int world_model_flags;
|
|
char *view_model;
|
|
|
|
// client side info
|
|
char *icon;
|
|
char *pickup_name; // for printing on pickup
|
|
int count_width; // number of digits to display by icon
|
|
|
|
int quantity; // for ammo how much, for weapons how much is used per shot
|
|
char *ammo; // for weapons
|
|
int flags; // IT_* flags
|
|
|
|
int weapmodel; // weapon model index (for weapons)
|
|
|
|
void *info;
|
|
int tag;
|
|
|
|
char *precaches; // string of all models, sounds, and images this item will use
|
|
int hideFlags;
|
|
char *weapon; // weapon used by ammo
|
|
} gitem_t;
|
|
|
|
|
|
|
|
//
|
|
// this structure is left intact through an entire game
|
|
// it should be initialized at dll load time, and read/written to
|
|
// the server.ssv file for savegames
|
|
//
|
|
typedef struct
|
|
{
|
|
char helpmessage1[512];
|
|
char helpmessage2[512];
|
|
int helpchanged; // flash F1 icon if non 0, play sound
|
|
// and increment only if 1, 2, or 3
|
|
|
|
gclient_t *clients; // [maxclients]
|
|
|
|
// can't store spawnpoint in level, because
|
|
// it would get overwritten by the savegame restore
|
|
char spawnpoint[512]; // needed for coop respawns
|
|
|
|
// store latched cvars here that we want to get at often
|
|
int maxclients;
|
|
int maxentities;
|
|
|
|
// cross level triggers
|
|
int serverflags;
|
|
|
|
// items
|
|
int num_items;
|
|
|
|
qboolean autosaved;
|
|
} game_locals_t;
|
|
|
|
|
|
//
|
|
// this structure is cleared as each map is entered
|
|
// it is read/written to the level.sav file for savegames
|
|
//
|
|
typedef struct
|
|
{
|
|
int framenum;
|
|
float time;
|
|
|
|
char level_name[MAX_QPATH]; // the descriptive name (Outer Base, etc)
|
|
char mapname[MAX_QPATH]; // the server name (base1, etc)
|
|
char nextmap[MAX_QPATH]; // go here when fraglimit is hit
|
|
|
|
// intermission state
|
|
float intermissiontime; // time the intermission was started
|
|
char *changemap;
|
|
int exitintermission;
|
|
int fadeFrames;
|
|
vec3_t intermission_origin;
|
|
vec3_t intermission_angle;
|
|
|
|
edict_t *sight_client; // changed once each frame for coop games
|
|
|
|
edict_t *sight_entity;
|
|
int sight_entity_framenum;
|
|
edict_t *sound_entity;
|
|
int sound_entity_framenum;
|
|
edict_t *sound2_entity;
|
|
int sound2_entity_framenum;
|
|
|
|
int pic_health;
|
|
|
|
int total_secrets;
|
|
int found_secrets;
|
|
|
|
int total_goals;
|
|
int found_goals;
|
|
|
|
int total_monsters;
|
|
int killed_monsters;
|
|
|
|
edict_t *current_entity; // entity running from G_RunFrame
|
|
int body_que; // dead bodies
|
|
|
|
int power_cubes; // ugly necessity for coop
|
|
} level_locals_t;
|
|
|
|
|
|
// spawn_temp_t is only used to hold entity field values that
|
|
// can be set from the editor, but aren't actualy present
|
|
// in edict_t during gameplay
|
|
typedef struct
|
|
{
|
|
// world vars
|
|
char *sky;
|
|
float skyrotate;
|
|
vec3_t skyaxis;
|
|
char *nextmap;
|
|
|
|
int lip;
|
|
int distance;
|
|
int height;
|
|
char *noise;
|
|
float pausetime;
|
|
char *item;
|
|
char *gravity;
|
|
|
|
float minyaw;
|
|
float maxyaw;
|
|
float minpitch;
|
|
float maxpitch;
|
|
} spawn_temp_t;
|
|
|
|
|
|
typedef struct
|
|
{
|
|
// fixed data
|
|
vec3_t start_origin;
|
|
vec3_t start_angles;
|
|
vec3_t end_origin;
|
|
vec3_t end_angles;
|
|
|
|
int sound_start;
|
|
int sound_middle;
|
|
int sound_end;
|
|
|
|
float accel;
|
|
float speed;
|
|
float decel;
|
|
float distance;
|
|
|
|
float wait;
|
|
|
|
// state data
|
|
int state;
|
|
vec3_t dir;
|
|
float current_speed;
|
|
float move_speed;
|
|
float next_speed;
|
|
float remaining_distance;
|
|
float decel_distance;
|
|
void (*endfunc)(edict_t *);
|
|
} moveinfo_t;
|
|
|
|
|
|
typedef struct
|
|
{
|
|
void (*aifunc)(edict_t *self, float dist);
|
|
float dist;
|
|
void (*thinkfunc)(edict_t *self);
|
|
} mframe_t;
|
|
|
|
typedef struct
|
|
{
|
|
int firstframe;
|
|
int lastframe;
|
|
mframe_t *frame;
|
|
void (*endfunc)(edict_t *self);
|
|
} mmove_t;
|
|
|
|
typedef struct
|
|
{
|
|
mmove_t *currentmove;
|
|
int aiflags;
|
|
int nextframe;
|
|
float scale;
|
|
|
|
void (*stand)(edict_t *self);
|
|
void (*idle)(edict_t *self);
|
|
void (*search)(edict_t *self);
|
|
void (*walk)(edict_t *self);
|
|
void (*run)(edict_t *self);
|
|
void (*dodge)(edict_t *self, edict_t *other, float eta);
|
|
void (*attack)(edict_t *self);
|
|
void (*melee)(edict_t *self);
|
|
void (*sight)(edict_t *self, edict_t *other);
|
|
qboolean (*checkattack)(edict_t *self);
|
|
void (*backwalk)(edict_t *self);
|
|
void (*sidestepright)(edict_t *self);
|
|
void (*sidestepleft)(edict_t *self);
|
|
|
|
float pausetime;
|
|
float attack_finished;
|
|
|
|
vec3_t saved_goal;
|
|
float search_time;
|
|
float trail_time;
|
|
vec3_t last_sighting;
|
|
int attack_state;
|
|
int lefty;
|
|
float idle_time;
|
|
int linkcount;
|
|
|
|
int power_armor_type;
|
|
int power_armor_power;
|
|
|
|
int flashTime;
|
|
int flashBase;
|
|
|
|
// strafing
|
|
float flyStrafePitch;
|
|
float flyStrafeTimeout;
|
|
|
|
// schooling info
|
|
float zSchoolSightRadius;
|
|
float zSchoolMaxSpeed, zSchoolMinSpeed;
|
|
float zSpeedStandMax, zSpeedWalkMax;
|
|
float zSchoolDecayRate, zSchoolMinimumDistance;
|
|
int zSchoolFlags;
|
|
|
|
float reducedDamageAmount;
|
|
|
|
float dodgetimeout;
|
|
|
|
vec3_t shottarget;
|
|
} monsterinfo_t;
|
|
|
|
|
|
|
|
extern game_locals_t game;
|
|
extern level_locals_t level;
|
|
extern game_import_t gi;
|
|
extern game_export_t globals;
|
|
extern spawn_temp_t st;
|
|
|
|
extern int sm_meat_index;
|
|
extern int snd_fry;
|
|
|
|
extern int jacket_armor_index;
|
|
extern int combat_armor_index;
|
|
extern int body_armor_index;
|
|
extern int shells_index;
|
|
extern int bullets_index;
|
|
extern int grenades_index;
|
|
extern int rockets_index;
|
|
extern int cells_index;
|
|
extern int slugs_index;
|
|
extern int flares_index;
|
|
extern int tbombs_index;
|
|
extern int empnuke_index;
|
|
extern int plasmashield_index;
|
|
extern int blaster_index;
|
|
extern int rg_index;
|
|
|
|
|
|
// means of death
|
|
#define MOD_UNKNOWN 0
|
|
#define MOD_BLASTER 1
|
|
#define MOD_SHOTGUN 2
|
|
#define MOD_SSHOTGUN 3
|
|
#define MOD_MACHINEGUN 4
|
|
#define MOD_CHAINGUN 5
|
|
#define MOD_GRENADE 6
|
|
#define MOD_G_SPLASH 7
|
|
#define MOD_ROCKET 8
|
|
#define MOD_R_SPLASH 9
|
|
#define MOD_HYPERBLASTER 10
|
|
#define MOD_RAILGUN 11
|
|
#define MOD_BFG_LASER 12
|
|
#define MOD_BFG_BLAST 13
|
|
#define MOD_BFG_EFFECT 14
|
|
#define MOD_HANDGRENADE 15
|
|
#define MOD_HG_SPLASH 16
|
|
#define MOD_WATER 17
|
|
#define MOD_SLIME 18
|
|
#define MOD_LAVA 19
|
|
#define MOD_CRUSH 20
|
|
#define MOD_TELEFRAG 21
|
|
#define MOD_FALLING 22
|
|
#define MOD_SUICIDE 23
|
|
#define MOD_HELD_GRENADE 24
|
|
#define MOD_EXPLOSIVE 25
|
|
#define MOD_BARREL 26
|
|
#define MOD_BOMB 27
|
|
#define MOD_EXIT 28
|
|
#define MOD_SPLASH 29
|
|
#define MOD_TARGET_LASER 30
|
|
#define MOD_TRIGGER_HURT 31
|
|
#define MOD_HIT 32
|
|
#define MOD_TARGET_BLASTER 33
|
|
#define MOD_SNIPERRIFLE 34
|
|
#define MOD_TRIPBOMB 35
|
|
#define MOD_FLARE 36
|
|
#define MOD_A2K 37
|
|
#define MOD_SONICCANNON 38
|
|
#define MOD_AUTOCANNON 39
|
|
#define MOD_GL_POLYBLEND 40
|
|
#define MOD_FRIENDLY_FIRE 0x8000000
|
|
|
|
extern int meansOfDeath;
|
|
|
|
|
|
extern edict_t *g_edicts;
|
|
|
|
#define FOFS(x) (size_t)&(((edict_t *)0)->x) // Knightmare- was int
|
|
#define STOFS(x) (size_t)&(((spawn_temp_t *)0)->x) // Knightmare- was int
|
|
#define LLOFS(x) (size_t)&(((level_locals_t *)0)->x) // Knightmare- was int
|
|
#define CLOFS(x) (size_t)&(((gclient_t *)0)->x) // Knightmare- was int
|
|
|
|
#define random() ((rand () & 0x7fff) / ((float)0x7fff))
|
|
#define crandom() (2.0 * (random() - 0.5))
|
|
|
|
extern cvar_t *maxentities;
|
|
extern cvar_t *deathmatch;
|
|
extern cvar_t *coop;
|
|
extern cvar_t *dmflags;
|
|
extern cvar_t *zdmflags;
|
|
extern cvar_t *skill;
|
|
extern cvar_t *fraglimit;
|
|
extern cvar_t *timelimit;
|
|
extern cvar_t *password;
|
|
extern cvar_t *g_select_empty;
|
|
extern cvar_t *dedicated;
|
|
|
|
extern cvar_t *sv_gravity;
|
|
extern cvar_t *sv_maxvelocity;
|
|
|
|
extern cvar_t *gun_x, *gun_y, *gun_z;
|
|
extern cvar_t *sv_rollspeed;
|
|
extern cvar_t *sv_rollangle;
|
|
|
|
extern cvar_t *run_pitch;
|
|
extern cvar_t *run_roll;
|
|
extern cvar_t *bob_up;
|
|
extern cvar_t *bob_pitch;
|
|
extern cvar_t *bob_roll;
|
|
|
|
extern cvar_t *sv_cheats;
|
|
extern cvar_t *maxclients;
|
|
|
|
extern cvar_t *gamedir;
|
|
|
|
extern cvar_t *grenadeammotype;
|
|
extern cvar_t *grenadeammo;
|
|
extern cvar_t *bettyammo;
|
|
#ifdef CACHE_SOUND
|
|
extern cvar_t *printSoundRejects;
|
|
#endif
|
|
extern cvar_t *readout; // Knightmare added
|
|
|
|
extern cvar_t *sv_stopspeed; // PGM - this was a define in g_phys.c
|
|
extern cvar_t *sv_step_fraction; // Knightmare- this was a define in p_view.c
|
|
|
|
#define world (&g_edicts[0])
|
|
|
|
// item spawnflags
|
|
#define ITEM_TRIGGER_SPAWN 0x00000001
|
|
#define ITEM_NO_TOUCH 0x00000002
|
|
// 6 bits reserved for editor flags
|
|
// 8 bits used as power cube id bits for coop games
|
|
#define DROPPED_ITEM 0x00010000
|
|
#define DROPPED_PLAYER_ITEM 0x00020000
|
|
#define ITEM_TARGETS_USED 0x00040000
|
|
|
|
//
|
|
// fields are needed for spawning from the entity string
|
|
// and saving / loading games
|
|
//
|
|
#define FFL_SPAWNTEMP 1
|
|
#define FFL_NOSPAWN 2
|
|
|
|
typedef enum {
|
|
F_INT,
|
|
F_FLOAT,
|
|
F_LSTRING, // string on disk, pointer in memory, TAG_LEVEL
|
|
F_GSTRING, // string on disk, pointer in memory, TAG_GAME
|
|
F_VECTOR,
|
|
F_ANGLEHACK,
|
|
F_EDICT, // index on disk, pointer in memory
|
|
F_ITEM, // index on disk, pointer in memory
|
|
F_CLIENT, // index on disk, pointer in memory
|
|
F_FUNCTION,
|
|
F_MMOVE,
|
|
F_IGNORE
|
|
} fieldtype_t;
|
|
|
|
typedef struct
|
|
{
|
|
char *name;
|
|
size_t ofs; // Knightmare- was int
|
|
fieldtype_t type;
|
|
int flags;
|
|
} field_t;
|
|
|
|
|
|
extern field_t fields[];
|
|
extern gitem_t itemlist[];
|
|
|
|
|
|
//
|
|
// g_cmds.c
|
|
//
|
|
void Cmd_Help_f (edict_t *ent);
|
|
void Cmd_Score_f (edict_t *ent);
|
|
|
|
//
|
|
// g_items.c
|
|
//
|
|
void PrecacheItem (gitem_t *it);
|
|
void InitItems (void);
|
|
void SetItemNames (void);
|
|
void SetAmmoPickupValues (void);
|
|
gitem_t *FindItem (char *pickup_name);
|
|
gitem_t *FindItemByClassname (char *classname);
|
|
#define ITEM_INDEX(x) ((x)-itemlist)
|
|
edict_t *Drop_Item (edict_t *ent, gitem_t *item);
|
|
void SetRespawn (edict_t *ent, float delay);
|
|
void ChangeWeapon (edict_t *ent);
|
|
void SpawnItem (edict_t *ent, gitem_t *item);
|
|
void Think_Weapon (edict_t *ent);
|
|
int ArmorIndex (edict_t *ent);
|
|
int PowerArmorType (edict_t *ent);
|
|
gitem_t *GetItemByIndex (int index);
|
|
int GetMaxAmmoByIndex (gclient_t *client, int item_index); // Knightmare added
|
|
int GetMaxArmorByIndex (int item_index); // Knightmare added
|
|
qboolean Add_Ammo (edict_t *ent, gitem_t *item, int count);
|
|
void Touch_Item (edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *surf);
|
|
void precacheAllItems();
|
|
|
|
//
|
|
// g_utils.c
|
|
//
|
|
qboolean KillBox (edict_t *ent);
|
|
qboolean MonsterKillBox (edict_t *ent);
|
|
qboolean MonsterPlayerKillBox (edict_t *ent);
|
|
void G_ProjectSource (vec3_t point, vec3_t distance, vec3_t forward, vec3_t right, vec3_t result);
|
|
edict_t *G_Find (edict_t *from, size_t fieldofs, char *match); // Knightmare- changed fieldofs from int
|
|
edict_t *findradius (edict_t *from, vec3_t org, float rad);
|
|
edict_t *G_PickTarget (char *targetname);
|
|
void G_UseTargets (edict_t *ent, edict_t *activator);
|
|
void G_SetMovedir (vec3_t angles, vec3_t movedir);
|
|
|
|
void G_InitEdict (edict_t *e);
|
|
edict_t *G_Spawn (void);
|
|
void G_FreeEdict (edict_t *e);
|
|
|
|
void G_TouchTriggers (edict_t *ent);
|
|
void G_TouchSolids (edict_t *ent);
|
|
|
|
char *G_CopyString (char *in);
|
|
|
|
float *tv (float x, float y, float z);
|
|
char *vtos (vec3_t v);
|
|
|
|
float vectoyaw (vec3_t vec);
|
|
void vectoangles (vec3_t vec, vec3_t angles);
|
|
|
|
//
|
|
// km_cvar.c
|
|
//
|
|
void InitLithiumVars (void); //init cvar defaults
|
|
|
|
//
|
|
// g_combat.c
|
|
//
|
|
qboolean OnSameTeam (edict_t *ent1, edict_t *ent2);
|
|
qboolean CanDamage (edict_t *targ, edict_t *inflictor);
|
|
void T_Damage (edict_t *targ, edict_t *inflictor, edict_t *attacker, vec3_t dir, vec3_t point, vec3_t normal, int damage, int knockback, int dflags, int mod);
|
|
void T_RadiusDamage (edict_t *inflictor, edict_t *attacker, float damage, edict_t *ignore, float radius, int mod);
|
|
void T_RadiusDamagePosition (vec3_t origin, edict_t *inflictor, edict_t *attacker, float damage, edict_t *ignore, float radius, int mod);
|
|
|
|
// damage flags
|
|
#define DAMAGE_RADIUS 0x00000001 // damage was indirect
|
|
#define DAMAGE_NO_ARMOR 0x00000002 // armour does not protect from this damage
|
|
#define DAMAGE_ENERGY 0x00000004 // damage is from an energy based weapon
|
|
#define DAMAGE_NO_KNOCKBACK 0x00000008 // do not affect velocity, just view angles
|
|
#define DAMAGE_BULLET 0x00000010 // damage is from a bullet (used for ricochets)
|
|
#define DAMAGE_NO_PROTECTION 0x00000020 // armor, shields, invulnerability, and godmode have no effect
|
|
#define DAMAGE_ARMORMOSTLY 0x00000040 // reduces the armor more than the health
|
|
|
|
#define DEFAULT_BULLET_HSPREAD 300
|
|
#define DEFAULT_BULLET_VSPREAD 500
|
|
#define DEFAULT_SHOTGUN_HSPREAD 1000
|
|
#define DEFAULT_SHOTGUN_VSPREAD 500
|
|
#define DEFAULT_DEATHMATCH_SHOTGUN_COUNT 12
|
|
#define DEFAULT_SHOTGUN_COUNT 12
|
|
#define DEFAULT_SSHOTGUN_COUNT 20
|
|
|
|
//
|
|
// g_monster.c
|
|
//
|
|
void monster_fire_bullet (edict_t *self, vec3_t start, vec3_t dir, int damage, int kick, int hspread, int vspread, int flashtype);
|
|
void monster_fire_shotgun (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int kick, int hspread, int vspread, int count, int flashtype);
|
|
void monster_fire_blaster (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int flashtype, int effect, int color);
|
|
void monster_fire_grenade (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, int flashtype);
|
|
void monster_fire_rocket (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int flashtype);
|
|
void monster_fire_railgun (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int kick, int flashtype);
|
|
void monster_fire_bfg (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, int kick, float damage_radius, int flashtype);
|
|
void M_droptofloor (edict_t *ent);
|
|
void monster_think (edict_t *self);
|
|
void walkmonster_start (edict_t *self);
|
|
void swimmonster_start (edict_t *self);
|
|
void flymonster_start (edict_t *self);
|
|
void AttackFinished (edict_t *self, float time);
|
|
void monster_death_use (edict_t *self);
|
|
void M_CatagorizePosition (edict_t *ent);
|
|
qboolean M_CheckAttack (edict_t *self);
|
|
void M_FlyCheck (edict_t *self);
|
|
void M_CheckGround (edict_t *ent);
|
|
|
|
//
|
|
// g_misc.c
|
|
//
|
|
void ThrowHead (edict_t *self, char *gibname, int damage, int type);
|
|
void ThrowClientHead (edict_t *self, int damage);
|
|
void ThrowGib (edict_t *self, char *gibname, int damage, int type);
|
|
void BecomeExplosion1(edict_t *self);
|
|
|
|
//
|
|
// g_ai.c
|
|
//
|
|
void AI_SetSightClient (void);
|
|
|
|
void ai_stand (edict_t *self, float dist);
|
|
void ai_move (edict_t *self, float dist);
|
|
void ai_walk (edict_t *self, float dist);
|
|
void ai_turn (edict_t *self, float dist);
|
|
void ai_run (edict_t *self, float dist);
|
|
void ai_charge (edict_t *self, float dist);
|
|
int range (edict_t *self, edict_t *other);
|
|
|
|
void FoundTarget (edict_t *self);
|
|
qboolean infront (edict_t *self, edict_t *other);
|
|
qboolean visible (edict_t *self, edict_t *other);
|
|
qboolean FacingIdeal(edict_t *self);
|
|
qboolean inweaponLineOfSight (edict_t *self, edict_t *other);
|
|
|
|
//
|
|
// g_weapon.c
|
|
//
|
|
#define BLASTER_ORANGE 1
|
|
#define BLASTER_GREEN 2
|
|
#define BLASTER_BLUE 3
|
|
#define BLASTER_RED 4
|
|
void ThrowDebris (edict_t *self, char *modelname, float speed, vec3_t origin);
|
|
qboolean fire_hit (edict_t *self, vec3_t aim, int damage, int kick);
|
|
void fire_bullet (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int kick, int hspread, int vspread, int mod);
|
|
void fire_shotgun (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int kick, int hspread, int vspread, int count, int mod);
|
|
void fire_blaster (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, int effect, qboolean hyper, int color);
|
|
void fire_grenade (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, float timer, float damage_radius, qboolean contact);
|
|
void fire_grenade2 (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, float timer, float damage_radius, qboolean held);
|
|
void fire_rocket (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, float damage_radius, int radius_damage);
|
|
void fire_rail (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int kick, qboolean useColor, int red, int green, int blue);
|
|
void fire_bfg (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, float damage_radius);
|
|
|
|
//
|
|
// g_ptrail.c
|
|
//
|
|
void PlayerTrail_Init (void);
|
|
void PlayerTrail_Add (vec3_t spot);
|
|
void PlayerTrail_New (vec3_t spot);
|
|
edict_t *PlayerTrail_PickFirst (edict_t *self);
|
|
edict_t *PlayerTrail_PickNext (edict_t *self);
|
|
edict_t *PlayerTrail_LastSpot (void);
|
|
|
|
|
|
//
|
|
// g_client.c
|
|
//
|
|
void respawn (edict_t *ent);
|
|
void BeginIntermission (edict_t *targ);
|
|
void PutClientInServer (edict_t *ent);
|
|
void InitClientPersistant (gclient_t *client);
|
|
void InitClientResp (gclient_t *client);
|
|
void InitBodyQue (void);
|
|
void ClientBeginServerFrame (edict_t *ent);
|
|
|
|
//
|
|
// g_player.c
|
|
//
|
|
void player_pain (edict_t *self, edict_t *other, float kick, int damage);
|
|
void player_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point);
|
|
|
|
//
|
|
// g_svcmds.c
|
|
//
|
|
void ServerCommand (void);
|
|
|
|
//
|
|
// p_view.c
|
|
//
|
|
void ClientEndServerFrame (edict_t *ent);
|
|
|
|
//
|
|
// p_hud.c
|
|
//
|
|
void MoveClientToIntermission (edict_t *client);
|
|
void G_SetStats (edict_t *ent);
|
|
void ValidateSelectedItem (edict_t *ent);
|
|
void DeathmatchScoreboardMessage (edict_t *client, edict_t *killer);
|
|
|
|
//
|
|
// g_pweapon.c
|
|
//
|
|
void PlayerNoise(edict_t *who, vec3_t where, int type);
|
|
|
|
//
|
|
// m_move.c
|
|
//
|
|
qboolean M_CheckBottom (edict_t *ent);
|
|
qboolean M_walkmove (edict_t *ent, float yaw, float dist);
|
|
void M_MoveToGoal (edict_t *ent, float dist);
|
|
void M_ChangeYaw (edict_t *ent);
|
|
|
|
//
|
|
// g_phys.c
|
|
//
|
|
void G_RunEntity (edict_t *ent);
|
|
|
|
//
|
|
// g_main.c
|
|
//
|
|
void SaveClientData (void);
|
|
void FetchClientEntData (edict_t *ent);
|
|
|
|
|
|
#if defined(_DEBUG) && defined(_Z_TESTMODE)
|
|
|
|
//
|
|
// z_mtest.c
|
|
//
|
|
void Cmd_TestItem (edict_t *ent);
|
|
|
|
#endif
|
|
|
|
//
|
|
// z_trigger.c
|
|
//
|
|
#ifdef CACHE_SOUND
|
|
void printSoundNum();
|
|
void initSoundList();
|
|
#endif
|
|
|
|
//
|
|
// z_item.c
|
|
//
|
|
qboolean EMPNukeCheck(edict_t *ent, vec3_t pos);
|
|
|
|
|
|
//
|
|
// z_weapon.c
|
|
//
|
|
void fire_bb (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, float timer, float damage_radius);
|
|
void fire_flare (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, float damage_radius, int radius_damage);
|
|
|
|
|
|
//
|
|
// z_ai.c
|
|
//
|
|
void ai_schoolStand (edict_t *self, float dist);
|
|
void ai_schoolRun (edict_t *self, float dist);
|
|
void ai_schoolWalk (edict_t *self, float dist);
|
|
void ai_schoolCharge (edict_t *self, float dist);
|
|
void ai_schoolBackWalk (edict_t *self, float dist);
|
|
void ai_schoolSideStepRight (edict_t *self, float dist);
|
|
void ai_schoolSideStepLeft (edict_t *self, float dist);
|
|
|
|
|
|
|
|
//============================================================================
|
|
|
|
// client_t->anim_priority
|
|
#define ANIM_BASIC 0 // stand / run
|
|
#define ANIM_WAVE 1
|
|
#define ANIM_JUMP 2
|
|
#define ANIM_PAIN 3
|
|
#define ANIM_ATTACK 4
|
|
#define ANIM_DEATH 5
|
|
#define ANIM_REVERSE 6
|
|
|
|
|
|
// client data that stays across multiple level loads
|
|
typedef struct
|
|
{
|
|
char userinfo[MAX_INFO_STRING];
|
|
char netname[16];
|
|
int hand;
|
|
int gl_polyblend; // so that we know whether to damage "cheating" players
|
|
|
|
qboolean connected; // a loadgame will leave valid entities that
|
|
// just don't have a connection yet
|
|
|
|
// values saved and restored from edicts when changing levels
|
|
int health;
|
|
int max_health;
|
|
qboolean powerArmorActive;
|
|
|
|
int selected_item;
|
|
int inventory[MAX_ITEMS];
|
|
|
|
// ammo capacities
|
|
int max_bullets;
|
|
int max_shells;
|
|
int max_rockets;
|
|
int max_grenades;
|
|
int max_cells;
|
|
int max_slugs;
|
|
int max_flares;
|
|
int max_tbombs;
|
|
int max_a2k;
|
|
int max_empnuke;
|
|
int max_plasmashield;
|
|
|
|
gitem_t *weapon;
|
|
gitem_t *lastweapon;
|
|
gitem_t *lastweapon2; // this if for inventory hiding items
|
|
|
|
int power_cubes; // used for tracking the cubes in coop games
|
|
int score; // for calculating total unit score in coop games
|
|
|
|
float visorFrames;
|
|
|
|
// Knightmare- Custom client colors
|
|
color_t color1;
|
|
color_t color2;
|
|
} client_persistant_t;
|
|
|
|
// client data that stays across deathmatch respawns
|
|
typedef struct
|
|
{
|
|
client_persistant_t coop_respawn; // what to set client->pers to on a respawn
|
|
int enterframe; // level.framenum the client entered the game
|
|
int score; // frags, etc
|
|
vec3_t cmd_angles; // angles sent over in the last command
|
|
int game_helpchanged;
|
|
int helpchanged;
|
|
} client_respawn_t;
|
|
|
|
// this structure is cleared on each PutClientInServer(),
|
|
// except for 'client->pers'
|
|
struct gclient_s
|
|
{
|
|
// known to server
|
|
player_state_t ps; // communicated by server to clients
|
|
int ping;
|
|
|
|
// private to game
|
|
client_persistant_t pers;
|
|
client_respawn_t resp;
|
|
pmove_state_t old_pmove; // for detecting out-of-pmove changes
|
|
|
|
qboolean showscores; // set layout stat
|
|
qboolean showinventory; // set layout stat
|
|
qboolean showhelp;
|
|
qboolean showhelpicon;
|
|
|
|
int ammo_index;
|
|
|
|
int buttons;
|
|
int oldbuttons;
|
|
int latched_buttons;
|
|
|
|
qboolean weapon_thunk;
|
|
|
|
gitem_t *newweapon;
|
|
|
|
// sum up damage over an entire frame, so
|
|
// shotgun blasts give a single big kick
|
|
int damage_armor; // damage absorbed by armor
|
|
int damage_parmor; // damage absorbed by power armor
|
|
int damage_blood; // damage taken out of health
|
|
int damage_knockback; // impact damage
|
|
vec3_t damage_from; // origin for vector calculation
|
|
|
|
float killer_yaw; // when dead, look at killer
|
|
|
|
weaponstate_t weaponstate;
|
|
vec3_t kick_angles; // weapon kicks
|
|
vec3_t kick_origin;
|
|
float v_dmg_roll, v_dmg_pitch, v_dmg_time; // damage kicks
|
|
float fall_time, fall_value; // for view drop on fall
|
|
float damage_alpha;
|
|
float bonus_alpha;
|
|
vec3_t damage_blend;
|
|
vec3_t v_angle; // aiming direction
|
|
float bobtime; // so off-ground doesn't change it
|
|
vec3_t oldviewangles;
|
|
vec3_t oldvelocity;
|
|
|
|
float next_drown_time;
|
|
int old_waterlevel;
|
|
int breather_sound;
|
|
|
|
int machinegun_shots; // for weapon raising
|
|
|
|
qboolean backpedaling; //<- CDawg added this
|
|
|
|
// animation vars
|
|
int anim_end;
|
|
int anim_priority;
|
|
qboolean anim_duck;
|
|
qboolean anim_run;
|
|
|
|
// powerup timers
|
|
float quad_framenum;
|
|
float invincible_framenum;
|
|
float breather_framenum;
|
|
float enviro_framenum;
|
|
float a2kFramenum;
|
|
|
|
qboolean grenade_blew_up;
|
|
float grenade_time;
|
|
int silencer_shots;
|
|
int weapon_sound;
|
|
|
|
float pickup_msg_time;
|
|
|
|
float respawn_time; // can respawn when time > this
|
|
|
|
#if defined(_DEBUG) && defined(_Z_TESTMODE)
|
|
struct edict_s *lineDraw;
|
|
#endif
|
|
|
|
// used for blinding
|
|
int flashTime;
|
|
int flashBase;
|
|
|
|
edict_t *zCameraTrack; // the entity to see through
|
|
vec3_t zCameraOffset; // offset from camera origin
|
|
edict_t *zCameraLocalEntity;
|
|
float zCameraStaticFramenum;
|
|
|
|
qboolean showOrigin;
|
|
|
|
// for sniper rifle
|
|
int sniperFramenum;
|
|
|
|
// for sonic cannon
|
|
float startFireTime;
|
|
};
|
|
|
|
struct edict_s
|
|
{
|
|
entity_state_t s;
|
|
struct gclient_s *client; // NULL if not a player
|
|
// the server expects the first part
|
|
// of gclient_s to be a player_state_t
|
|
// but the rest of it is opaque
|
|
|
|
qboolean inuse;
|
|
int linkcount;
|
|
|
|
// FIXME: move these fields to a server private sv_entity_t
|
|
link_t area; // linked to a division node or leaf
|
|
|
|
int num_clusters; // if -1, use headnode instead
|
|
int clusternums[MAX_ENT_CLUSTERS];
|
|
int headnode; // unused if num_clusters != -1
|
|
int areanum, areanum2;
|
|
|
|
//================================
|
|
|
|
int svflags;
|
|
vec3_t mins, maxs;
|
|
vec3_t absmin, absmax, size;
|
|
solid_t solid;
|
|
int clipmask;
|
|
edict_t *owner;
|
|
|
|
|
|
// DO NOT MODIFY ANYTHING ABOVE THIS, THE SERVER
|
|
// EXPECTS THE FIELDS IN THAT ORDER!
|
|
|
|
//================================
|
|
int movetype;
|
|
int flags;
|
|
|
|
char *model;
|
|
char *model2;
|
|
char *model3;
|
|
char *model4;
|
|
float freetime; // sv.time when the object was freed
|
|
|
|
//
|
|
// only used locally in game, not by server
|
|
//
|
|
char *message;
|
|
char *classname;
|
|
int spawnflags;
|
|
|
|
float timestamp;
|
|
|
|
float angle; // set in qe3, -1 = up, -2 = down
|
|
char *target;
|
|
char *targetname;
|
|
char *killtarget;
|
|
char *team;
|
|
char *pathtarget;
|
|
char *deathtarget;
|
|
char *combattarget;
|
|
edict_t *target_ent;
|
|
|
|
float speed, accel, decel, aspeed;
|
|
vec3_t movedir;
|
|
vec3_t pos1, pos2;
|
|
vec3_t pos0; // Knightmare- initial position for secret doors
|
|
|
|
vec3_t velocity;
|
|
vec3_t avelocity;
|
|
int mass;
|
|
float air_finished;
|
|
float gravity; // per entity gravity multiplier (1.0 is normal)
|
|
// use for lowgrav artifact, flares
|
|
|
|
edict_t *goalentity;
|
|
edict_t *movetarget;
|
|
float yaw_speed;
|
|
float ideal_yaw;
|
|
|
|
float nextthink;
|
|
void (*prethink) (edict_t *ent);
|
|
void (*think)(edict_t *self);
|
|
void (*blocked)(edict_t *self, edict_t *other); //move to moveinfo?
|
|
void (*touch)(edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf);
|
|
void (*use)(edict_t *self, edict_t *other, edict_t *activator);
|
|
void (*pain)(edict_t *self, edict_t *other, float kick, int damage);
|
|
void (*die)(edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point);
|
|
|
|
float touch_debounce_time; // are all these legit? do we need more/less of them?
|
|
float pain_debounce_time;
|
|
float damage_debounce_time;
|
|
float fly_sound_debounce_time; //move to clientinfo
|
|
float last_move_time;
|
|
|
|
int health;
|
|
int max_health;
|
|
int gib_health;
|
|
int deadflag;
|
|
qboolean show_hostile;
|
|
|
|
float powerarmor_time;
|
|
|
|
char *map; // target_changelevel
|
|
|
|
int viewheight; // height above origin where eyesight is determined
|
|
int takedamage;
|
|
int dmg;
|
|
int radius_dmg;
|
|
float dmg_radius;
|
|
int sounds; //make this a spawntemp var?
|
|
int count;
|
|
|
|
edict_t *chain;
|
|
edict_t *enemy;
|
|
edict_t *oldenemy;
|
|
edict_t *activator;
|
|
edict_t *groundentity;
|
|
int groundentity_linkcount;
|
|
edict_t *teamchain;
|
|
edict_t *teammaster;
|
|
|
|
edict_t *mynoise; // can go in client only
|
|
edict_t *mynoise2;
|
|
|
|
int noise_index;
|
|
int noise_index2;
|
|
float volume;
|
|
float attenuation;
|
|
|
|
// timing variables
|
|
float wait;
|
|
float delay; // before firing targets
|
|
float random;
|
|
|
|
float teleport_time;
|
|
|
|
int watertype;
|
|
int waterlevel;
|
|
|
|
vec3_t move_origin;
|
|
vec3_t move_angles;
|
|
|
|
// move this to clientinfo?
|
|
int light_level;
|
|
|
|
int style; // also used as areaportal number
|
|
|
|
gitem_t *item; // for bonus items
|
|
|
|
// common data blocks
|
|
moveinfo_t moveinfo;
|
|
monsterinfo_t monsterinfo;
|
|
|
|
// can use this for misc. timeouts
|
|
float timeout;
|
|
|
|
int blood_type; // specifies blood effect
|
|
|
|
// for func_door, also used by monster_autocannon, and misc_securitycamera
|
|
int active;
|
|
int seq;
|
|
|
|
// between level saves/loads
|
|
int spawnflags2;
|
|
int oldentnum;
|
|
|
|
// titan laser
|
|
edict_t *laser;
|
|
|
|
float weaponsound_time;
|
|
|
|
#if defined(_DEBUG) && defined(_Z_TESTMODE)
|
|
//can't teach an old dog new tricks
|
|
void *extra_data;
|
|
#endif
|
|
|
|
// schooling info
|
|
edict_t *zRaduisList, *zSchoolChain;
|
|
float zDistance;
|
|
|
|
// this is for MOVETYPE_RIDE
|
|
edict_t *rideWith[2];
|
|
vec3_t rideWithOffset[2];
|
|
|
|
// camera number
|
|
vec3_t mangle;
|
|
|
|
// time left for the visor (stored if a visor is dropped)
|
|
int visorFrames;
|
|
|
|
// monster team
|
|
char *mteam;
|
|
|
|
// for random func_timer targets
|
|
char targets[16][MAX_QPATH];
|
|
int numTargets;
|
|
|
|
// used by floor-mounted autocannon
|
|
int onFloor;
|
|
|
|
float bossFireTimeout;
|
|
int bossFireCount;
|
|
|
|
char *musictrack; // Knightmare- for specifying OGG or CD track
|
|
};
|
|
|
|
//zaero debug includes (need type info)
|
|
#include "z_frames.h"
|
|
#include "z_anim.h"
|
|
|
|
// Zaero dmflags
|
|
#define ZDM_NO_GL_POLYBLEND_DAMAGE 1
|
|
#define ZDM_ZAERO_ITEMS 2
|