xatrix/kingpin-sdk
0
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity
kingpin-sdk/gamesrc/G_LOCAL.H

1747 lines
46 KiB
C
Raw Normal View History

as released 2000-03-27
2000-03-27 00:00:00 +00:00
// 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 "g_nav.h"
#include "vehicles.h"
#include "g_teamplay.h"
// Ridah, new AI system defines
#include "g_ai.h"
#include "voice.h"
// Episode specific defines
#include "ep_all.h"
// the "gameversion" client command will print this plus compile date
#define GAMEVERSION "main"
// protocol bytes that can be directly added to messages
#define svc_muzzleflash 1
#define svc_muzzleflash2 2
#define svc_muzzleflash3 3
#define svc_temp_entity 4
#define svc_layout 5
#define svc_inventory 6
// JOSEPH 29-DEC-98
#define svc_hud 7
#define svc_stufftext 13
//==================================================================
// 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->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
// Ridah, Vehicles
#define FL_HOVERCAR 0x00002000 // this entity is currently using a Hovercar
#define FL_HOVERCAR_GROUND 0x00004000 // this entity is currently using a Grounded Hovercar
#define FL_BIKE 0x00008000
#define FL_CAR 0x00010000
// done.
#define FL_SPAWNED_BLOODPOOL 0x00020000
#define FL_FOLLOWING 0x00040000 // this character has followed us to the next level. so if we're
// loading in a game as a result of changing levels, delete any
// characters that have this flag set, since they've moved onto
// the next level.
//
// If we're manually loading a level (not changing levels), leave
// these characters in place, and clear the flag.
#define FL_CHASECAM 0x00100000 // entity is using chasecam
#define FL_MDXBBOX 0x00200000
#define FL_JETPACK 0x00400000 // Jet Pack enabled
#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
// *** RIDAH: do not change this, 766 is hardcoded into MDX_GetObjectBounds() ***
#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_t;
typedef enum
{
WEAPON_READY,
WEAPON_ACTIVATING,
WEAPON_DROPPING,
WEAPON_FIRING,
// RAFAEL 01-11-99
WEAPON_RELOADING,
WEAPON_RELOAD_CYCLE,
WEAPON_RELOADING_SPISTOL
} weaponstate_t;
typedef enum
{
AMMO_BULLETS,
AMMO_SHELLS,
AMMO_ROCKETS,
AMMO_GRENADES,
AMMO_CELLS,
AMMO_SLUGS,
AMMO_MAGSLUG,
AMMO_TRAP
} ammo_t;
// RAFAEL
typedef enum
{
CLIP_NONE,
CLIP_PISTOL,
CLIP_SHOTGUN,
CLIP_TOMMYGUN,
CLIP_SLUGS,
CLIP_GRENADES,
CLIP_ROCKETS,
CLIP_FLAMEGUN
} clip_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
// Ridah, MDX, simplify assigning model parts, this isn't needed by the engine
#define PART_HEAD 0 // HEAD must ALWAYS use this index!
#define PART_LEGS 1
#define PART_BODY 2
#define PART_GUN 3
// done.
#define PART_GUN2 4
#define PART_CIGAR 5
#define PART_HAT 6
//monster attack state
#define AS_STRAIGHT 1
#define AS_SLIDING 2
#define AS_MELEE 3
#define AS_MISSILE 4
// 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, // added this (the comma at the end of line)
MOVETYPE_WALLBOUNCE,
MOVETYPE_TOSS_SLIDE // Ridah, testing
} 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
#define IT_FLASHLIGHT 64
#define IT_SILENCER 128
#define IT_NOCHEATS 256
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
void *info;
int tag;
char *precaches; // string of all models, sounds, and images this item will use
} 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
//
#define MAX_LIGHT_SOURCES 512
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;
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
// BEGIN: Xatrix/Ridah/Navigator/19-mar-1998
// this stores all the node data for the current level
active_node_data_t *node_data;
// END: Xatrix/Ridah/Navigator/19-mar-1998
// Ridah
int num_characters; // progressive total, updated each time a character enters or leaves the game
// NOTE: includes players!
edict_t *characters[MAX_CHARACTERS]; // indexes in g_edicts to all characters in the game
// Global Cast Memory - stores a lookup table pointing to character-character memories
//
// This allows us to easily indentify whether a particular character can see another character
//
// [ SOURCE ][ DEST ]
cast_memory_t *global_cast_memory[MAX_CHARACTERS][MAX_CHARACTERS];
int episode; // current episode being played
int unit; // current unit within the episode
// Ridah, done.
// RAFAEL 11-05-98
vec3_t light_orgs[MAX_LIGHT_SOURCES];
vec3_t light_colors[MAX_LIGHT_SOURCES];
float light_values[MAX_LIGHT_SOURCES];
//float light_radius[MAX_LIGHT_SOURCES];
byte light_styles[MAX_LIGHT_SOURCES];
int num_light_sources;
// END 11-05-98
// RAFAEL
float cut_scene_time;
// int exit_cut_scene;
vec3_t cut_scene_origin;
vec3_t cut_scene_angle;
vec3_t player_oldpos;
vec3_t player_oldang;
float pawn_time;
vec3_t pawn_origin;
qboolean pawn_exit;
qboolean bar_lvl;
float speaktime;
// JOSEPH 24-FEB-99
int cut_scene_camera_switch;
int cut_scene_end_count;
// END JOSEPH
// JOSEPH 19-MAR-99-B
float fadeendtime;
float totalfade;
int inversefade;
// END JOSEPH
// JOSEPH 13-JUN-99
int helpchange;
// END JOSEPH
} 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;
char *nextmap;
int lip;
int distance;
int height;
char *noise;
float pausetime;
char *item;
char *gravity;
float minyaw;
float maxyaw;
float minpitch;
float maxpitch;
float fogdensity;
vec3_t fogval;
float fogdensity2;
vec3_t fogval2;
} spawn_temp_t;
// JOSEPH 7-OCT-98
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;
int sound_start2;
int sound_middle2;
int sound_end2;
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;
// END JOSEPH
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;
// float *lateral_array;
void (*endfunc)(edict_t *self);
} mmove_t;
typedef struct
{
mmove_t *currentmove;
int aiflags;
int nextframe;
float scale;
void (*idle)(edict_t *self);
void (*search)(edict_t *self);
void (*dodge)(edict_t *self, edict_t *other, float eta);
qboolean (*attack)(edict_t *self); // standing attack
void (*long_attack)(edict_t *self); // running attack (run, and attack if facing enemy and path is clear)
void (*sight)(edict_t *self, edict_t *other);
qboolean (*checkattack)(edict_t *self);
// Ridah, new AI system
mmove_t *oldcurrentmove; // used for thug_sit
void (*duck)(edict_t *self); // called when beginning to duck (may be part of normal movement)
void (*talk)(edict_t *self); // will start a random talking animation, and play a sound
void (*avoid)(edict_t *self, edict_t *other, qboolean face); // will start a random talking animation, and play a sound
void (*catch_fire)(edict_t *self, edict_t *other);
float last_talk_turn;
edict_t *talk_ent; // person we are talking to
float max_attack_distance; // try and move closer to enemy if outside this range
float max_sighting_distance; // can't see things out of this range
float standing_max_z; // set to self->maxs[2] upon spawning
float last_avoid, last_reverse;
edict_t *avoid_ent;
float goal_ent_pausetime; // avoid goal_ent if > level.time
int last_side_attack;
float last_side_attack_time;
cast_memory_t *friend_memory;
cast_memory_t *enemy_memory;
cast_memory_t *neutral_memory;
// these allow a generic AI system for all characters to interact with the animations
mmove_t *move_stand;
mmove_t *move_crstand;
mmove_t *move_run;
mmove_t *move_runwalk;
mmove_t *move_crwalk;
mmove_t *move_jump;
mmove_t *move_crouch_down;
mmove_t *move_stand_up;
mmove_t *move_avoid_walk;
mmove_t *move_avoid_run;
mmove_t *move_avoid_reverse_walk;
mmove_t *move_avoid_reverse_run;
mmove_t *move_avoid_crwalk;
mmove_t *move_lside_step;
mmove_t *move_rside_step;
mmove_t *move_start_climb;
mmove_t *move_end_climb;
mmove_t *move_evade;
mmove_t *move_stand_evade; // not quite a hostile enemy yet, but they may have their weapon out
void (*backoff)(edict_t *self, edict_t *other);
// done.
float pausetime;
vec3_t saved_goal;
vec3_t last_sighting;
float idle_time;
int linkcount;
// Rafael
// was missing this variable
float trail_time;
} cast_info_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;
// Ridah, in-game effects
//extern int sp_blood1;
// 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_RIPPER 34
#define MOD_PHALANX 35
#define MOD_BRAINTENTACLE 36
#define MOD_BLASTOFF 37
#define MOD_GEKK 38
#define MOD_TRAP 39
#define MOD_FLAMETHROWER 40
#define MOD_BLACKJACK 41
#define MOD_SILENCER 42
#define MOD_CROWBAR 43
#define MOD_DOGBITE 44
#define MOD_BLOWBACK 45
#define MOD_PISTOL 46
#define MOD_BARMACHINEGUN 47
#define MOD_SAFECAMPER 48
#define MOD_FRIENDLY_FIRE 0x8000000
extern int meansOfDeath;
extern edict_t *g_edicts;
extern cast_memory_t *g_cast_memory;
extern cast_group_t *g_cast_groups;
#define FOFS(x) (int)&(((edict_t *)0)->x)
#define STOFS(x) (int)&(((spawn_temp_t *)0)->x)
#define LLOFS(x) (int)&(((level_locals_t *)0)->x)
#define CLOFS(x) (int)&(((gclient_t *)0)->x)
#define CMOFS(x) (int)&(((cast_memory_t *)0)->x)
#define random() ((rand () & 0x7fff) / ((float)0x7fff))
#define crandom() (2.0 * (random() - 0.5))
extern cvar_t *maxentities;
extern cvar_t *deathmatch;
extern cvar_t *maxrate;
extern cvar_t *coop;
extern cvar_t *dmflags;
extern cvar_t *skill;
extern cvar_t *fraglimit;
extern cvar_t *timelimit;
extern cvar_t *cashlimit;
extern cvar_t *password;
extern cvar_t *g_select_empty;
extern cvar_t *dedicated;
extern cvar_t *filterban;
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 *flood_msgs;
extern cvar_t *flood_persecond;
extern cvar_t *flood_waitdelay;
// Ridah, new cvar's
extern cvar_t *developer;
extern cvar_t *ai_debug_memory;
extern cvar_t *g_vehicle_test;
extern cvar_t *dm_locational_damage;
extern cvar_t *showlights;
extern cvar_t *r_directional_lighting;
extern cvar_t *sv_runscale;
extern cvar_t *burn_enabled;
extern cvar_t *burn_size;
extern cvar_t *burn_intensity;
extern cvar_t *burn_r;
extern cvar_t *burn_g;
extern cvar_t *burn_b;
extern cvar_t *timescale;
extern cvar_t *teamplay;
extern cvar_t *g_cashspawndelay;
extern cvar_t *cl_parental_lock;
extern cvar_t *cl_parental_override;
extern cvar_t *dm_realmode;
extern cvar_t *g_mapcycle_file;
// Ridah, done.
extern cvar_t *cl_captions;
#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_CAST_MEMORY,
F_IGNORE
} fieldtype_t;
typedef struct
{
char *name;
int ofs;
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, int page);
void Cmd_Score_f (edict_t *ent);
//
// g_items.c
//
void PrecacheItem (gitem_t *it);
void InitItems (void);
void SetItemNames (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);
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);
// JOSEPH 6-JAN-99
edict_t *Shot_Drop_Item (edict_t *ent, gitem_t *item, char* modeloverride);
void Think_FlashLight (edict_t *ent);
//
// g_utils.c
//
qboolean KillBox (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, int fieldofs, char *match);
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);
float entyaw( edict_t *self, edict_t *other );
// Ridah, Surface Sprites
qboolean SurfaceSpriteEffect( byte surf_sfx, byte width, byte height,
edict_t *impact_ent, vec3_t pos, vec3_t normal );
qboolean SurfaceSpriteEffectRipple( byte surf_sfx, byte width, byte height,
edict_t *impact_ent, vec3_t pos, vec3_t normal );
// done.
// Ridah, moved vectoangles() to q_shared.c
//
// 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);
// JOSEPH 21-APR-99
void T_RadiusDamage_Fire (edict_t *inflictor, edict_t *attacker, float damage, edict_t *ignore, float radius);
// END JOSEPH
// RAFAEL
void T_DamageMDX (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, int mdx_part, int mdx_subobject);
edict_t *SpawnTheWeapon (edict_t *self, char *itemname);
// 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 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 6
#define DEFAULT_SSHOTGUN_COUNT 20
#define DEFAULT_SAWED_SHOTGUN_COUNT 6
//
// g_cast.c
//
void cast_fire_bullet (edict_t *self, vec3_t start, vec3_t dir, int damage, int kick, int hspread, int vspread, int flashtype);
void cast_fire_shotgun (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int kick, int hspread, int vspread, int count, int flashtype);
void cast_fire_blaster (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int flashtype, int effect);
void cast_fire_grenade (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, int flashtype);
void cast_fire_rocket (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int flashtype);
void cast_fire_railgun (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int kick, int flashtype);
void cast_fire_bfg (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, int kick, float damage_radius, int flashtype);
void think_checkedges (edict_t *ent);
void think_slide (edict_t *ent);
void fire_fire (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, int effect, qboolean hyper);
qboolean DeathByGib( edict_t *self, edict_t *inflictor, edict_t *attacker, float damage );
// RAFAEL
void cast_fire_ionripper (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int flashtype, int effect);
void cast_fire_heat (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int flashtype);
void cast_dabeam (edict_t *self);
void cast_fire_blueblaster (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int flashtype, int effect);
void M_droptofloor (edict_t *ent);
void cast_think (edict_t *self);
void walking_cast_start (edict_t *self);
void swimming_cast_start (edict_t *self);
void flying_cast_start (edict_t *self);
void AttackFinished (edict_t *self, float time);
void cast_death_use (edict_t *self);
void M_CatagorizePosition (edict_t *ent);
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);
edict_t *ThrowGib (edict_t *self, char *gibname, int damage, int type);
// Ridah
void GibEntity( edict_t *self, edict_t *inflictor, float damage );
void BecomeExplosion1(edict_t *self);
// RAFAEL
void ThrowHeadACID (edict_t *self, char *gibname, int damage, int type);
void ThrowGibACID (edict_t *self, char *gibname, int damage, int type);
extern void path_corner_cast_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf);
void AddLightSource(edict_t *self);
void UpdateDirLights( edict_t *self );
void UpdateLightVecs( 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 ai_runFLASHLIGHT (edict_t *self, float dist);
void ai_runDOKEY (edict_t *self, float dist);
// RAFAEL
void ai_turn2 (edict_t *self, float dist);
void FoundTarget (edict_t *self);
qboolean infront (edict_t *self, edict_t *other);
// Ridah, for more precise infront check
qboolean directly_infront (edict_t *self, edict_t *other);
// Ridah, done.
qboolean visible (edict_t *self, edict_t *other);
qboolean FacingIdeal(edict_t *self);
// RAFAEL
void SpawnBloodPool (edict_t *self);
//
// g_weapon.c
//
void ThrowDebris (edict_t *self, char *modelname, float speed, vec3_t origin);
// JOSEPH 1-JUN-99
void ThrowDebris_stuff (edict_t *self, char *modelname, float speed, vec3_t origin);
// END JOSEPH
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);
void fire_grenade (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, float timer, float damage_radius);
// JOSEPH 19-MAY-99
void fire_dynamite (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, float timer, float damage_radius);
// END JOSEPH
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);
void fire_bfg (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, float damage_radius);
void fire_barmachinegun (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int kick);
// RAFAEL
/*
void fire_ionripper (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, int effect);
void fire_heat (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, float damage_radius, int radius_damage);
void fire_blueblaster (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, int effect);
void fire_plasma (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, float damage_radius, int radius_damage);
void fire_trap (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, float timer, float damage_radius, qboolean held);
*/
void fire_flamethrower (edict_t *self, vec3_t start, vec3_t forward, int damage, int kick, int mod);
qboolean fire_blackjack (edict_t *self, vec3_t start, vec3_t forward, int damage, int kick, int mod);
// JOSEPH 19-JAN-99
qboolean fire_crowbar (edict_t *self, vec3_t start, vec3_t forward, int damage, int kick, int mod);
qboolean fire_dogbite (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int kick, int mod);
// JOSEPH 30-APR-99
void fire_rat (edict_t *self, vec3_t start, vec3_t forward, int damage);
// END JOSEPH
//
// 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);
// RAFAEL
void BeginCutScene (edict_t *ent);
void EndCutScene (edict_t *ent);
// JOSEPH 16-DEC-98
void AdjustCutSceneCamera(edict_t *ent);
void NewCutSceneCamera (edict_t *ent);
// END JOSEPH
//
// g_player.c
//
void player_pain (edict_t *self, edict_t *other, float kick, int damage, int mdx_part, int mdx_subobject);
void player_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point, int mdx_part, int mdx_subobject);
//
// g_svcmds.c
//
void ServerCommand (void);
qboolean SV_FilterPacket (char *from);
//
// 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);
void MoveClientToCutScene (edict_t *camera);
// JOSEPH 22-FEB-99
void MoveClientToCutSceneCamera (edict_t *camera, int fov);
// END JOSEPH
//
// 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);
void M_ChangeYawOld (edict_t *ent);
//
// m_bbox.c
//
// RAFAEL
void MDX_Bbox_Init (void);
trace_t MDX_HitCheck (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, vec3_t end);
void MDX_Cleanup (void);
//
// g_phys.c
//
void G_RunEntity (edict_t *ent);
//
// g_main.c
//
void SaveClientData (void);
void FetchClientEntData (edict_t *ent);
//
// g_pawn.c
//
void PawnNext (edict_t *ent);
void PawnPrev (edict_t *ent);
void PawnBuy (edict_t *ent);
void PawnAgree (edict_t *ent);
void PawnDisagree (edict_t *ent);
void PawnLevelPrevious (edict_t *ent);
void PawnLeft (edict_t *ent);
void PawnRight (edict_t *ent);
//
// g_chase.c
//
void UpdateChaseCam(edict_t *ent);
void ChaseNext(edict_t *ent);
void ChasePrev(edict_t *ent);
//============================================================================
// client_t->anim_priority
#define ANIM_ATTACK 0
#define ANIM_BASIC 1 // stand / run
#define ANIM_WAVE 2
#define ANIM_JUMP 3
#define ANIM_PAIN 4
#define ANIM_REVERSE 5
#define ANIM_DEATH 6
#define MAX_WEAPONS 10
// client data that stays across multiple level loads
typedef struct
{
char userinfo[MAX_INFO_STRING];
char netname[16];
int hand;
int version; // collected from Userinfo, used to determine
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;
int savedFlags;
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;
// RAFAEL
int max_magslug;
int max_trap;
gitem_t *weapon;
gitem_t *lastweapon;
// JOSEPH 25-SEP-98
gitem_t *holsteredweapon;
// JOSEPH 3-FEB-99
int currentcash;
// END JOSEPH
int power_cubes; // used for tracking the cubes in coop games
int score; // for calculating total unit score in coop games
int game_helpchanged;
int helpchanged;
int weapon_clip[MAX_WEAPONS];
int pistol_mods;
// shared flags for episode
int episode_flags;
int silencer_shots;
// number of hired guys
int friends;
// teamplay
int team;
int bagcash; // cash being held in bag
int hmg_shots;
// bagman stuff
float timeatsafe; // record how long we've been standing at the safe
int friendly_vulnerable;
} 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;
// teamplay
int deposited; // amount this player has deposited
// voting system
char ban_id; // so we only let them vote once
float last_ban;
} 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_flame; // Ridah, damage from flamethrower
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;
// JOSEPH 6-JAN-99
int bonus_alpha_color;
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; // not used anymore
// animation vars
int anim_end;
int anim_priority;
qboolean anim_duck;
qboolean anim_run;
qboolean anim_reverse; // Ridah, for running backwards
qboolean anim_slide; // Ridah, strafing
float last_climb_anim_z; // Z value at last climbing animation change
int last_weapontype; // Ridah, so we change animations when they change weapons
// powerup timers
float quad_framenum;
float invincible_framenum;
float breather_framenum;
float enviro_framenum;
qboolean grenade_blew_up;
float grenade_time;
// RAFAEL
float quadfire_framenum;
qboolean trap_blew_up;
float trap_time;
int weapon_sound;
float pickup_msg_time;
// JOSEPH 2-FEB-99
float hud_enemy_talk_time;
float hud_self_talk_time;
// END JOSEPH
float flood_locktill; // locked from talking
float flood_when[10]; // when messages were said
int flood_whenhead; // head pointer for when said
char flood_lastmsg[160]; // so we don't repeat ourselves (annoying)
float respawn_time; // can respawn when time > this
qboolean flashlight;
// RAFAEL 28-dec-98
qboolean gun_noise;
// Ridah
float jetpack_power; // recharges at 0.5 per second (while not in use), uses at 1.0 per second, maxes at 5.0 seconds of power
qboolean jetpack_warned;
// RAFAEL 01-11-99
qboolean reload_weapon;
int clip_index;
float last_wave;
// chase
edict_t *chase_target;
qboolean update_chase;
};
// MORAL values
// these effect willingness to fight until death, attack unprovoked, etc
#define MORAL_RANDOM 0 // engine will assign a random value upon spawning (using formula, so it's the same each time the level loads)
#define MORAL_COWARD 1
#define MORAL_HAPPY 2
#define MORAL_NORMAL 3
#define MORAL_AGGRESSIVE 4
#define MORAL_BESERK 5
#define MORAL_HEROIC 6
#define MORAL_PSYCOTIC 7
#define MORAL_MAX 7
#define ACC_GREEN 0
#define ACC_POOR 1
#define ACC_NORMAL 2
#define ACC_SEASONED 3
#define ACC_VETERAN 4
#define ACC_ELITE 5
#define GENDER_NONE 0
#define GENDER_MALE 1
#define GENDER_FEMALE 2
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;
float voice_pitch; // used to pitch voices up/down, 1.0 = same, 2.0 = chipmunk (double speed)
// DO NOT MODIFY ANYTHING ABOVE THIS, THE SERVER
// EXPECTS THE FIELDS IN THAT ORDER!
//================================
int movetype;
int flags;
char *model;
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;
vec3_t movedir;
vec3_t pos1, pos2;
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, int mdx_part, int mdx_subobject);
void (*die)(edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point, int mdx_part, int mdx_subobject);
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;
cast_info_t cast_info;
// BEGIN: Xatrix/Ridah/Navigator/17-mar-1998
nav_data_t nav_data; // CNS-specific data, present for all entities
nav_build_data_t *nav_build_data; // used only by entities that create nodes (clients)
active_node_data_t *active_node_data; // points to the active node data of the current unit
// END: Xatrix/Ridah/Navigator/17-mar-1998
// JOSEPH 19-MAR-99
vec3_t rotate;
vec3_t nodeorigin;
vec3_t angletarget;
vec3_t save_avel;
vec3_t savecameraorigin;
vec3_t cameraangle;
vec3_t cameraorigin;
vec3_t cameravel;
vec3_t cameravelrel;
float duration; // Ridah, used this for Bike thruster
float lastduration;
float alphalevel;
int avelflag;
int durationflag; // Ridah, used this for Thug reload checking
int firstnode;
int handleflag;
int handle2flag;
int doorflag;
int firetype;
int fallerflag;
int fallingflag;
int footsteptype;
int fxdensity;
int currentcash;
int pullable;
int deadticks;
int healspeed;
int healtimer;
int nokickbackflag;
int thudsurf;
int thudsnd;
int misstime;
int missteam;
int debugprint;
int onarampage;
float timemissing;
char *target2;
edict_t *target2_ent;
edict_t *missent;
edict_t *handle;
edict_t *handle2;
edict_t *save_self;
edict_t *save_other;
char *type;
char *localteam;
float reactdelay;
char head;
int key; // Door key [-1 = trigger unlocked][0 = unlocked][1+ = key to unlock]
int lightit;
int option;
int noshadow;
// JOSEPH 17-MAY-99
int monsterprop;
solid_t savesolid;
int surfacetype;
int pullingflag;
// END JOSEPH
// Flamethrower stuff
char onfiretime;
edict_t *onfireent; // Ridah, added this so we can record the entity that set us on fire
// Ridah, new AI system
edict_t *leader;
char *leader_target; // for setting up AI's to follow other AI's from in the .map
edict_t *last_goal; // set each time we AI_Run(), was the last goal entity (eg. leader or enemy)
int order; // last order issued
float order_timestamp; // time of last order, so only followers that can see us will respond to the order
// updated when the player issues an order, and when the AI character follows it
edict_t *moveout_ent; // set to the target position when we have issued a "moveout" command
int cast_group; // index of group in which this cast member belongs (set by .map)
int character_index; // our position in the global character array
float last_talk_time;
int profanity_level; // each time the profanity button is pressed, this is incremented
voice_table_t *last_voice; // voice_table_t structure of last speech
int skin; // set self->s.skinnum to this upon spawning
int moral; // one of MORAL_* values, set in editor
char *guard_target; // point this to the targetname of the guard_ent this character should guard
int guard_radius; // deeemed to be guarding if inside this radius
edict_t *guard_ent; // guard this if set
char *sight_target; // will head for this entity upon sighting an enemy
edict_t *goal_ent; // if this is set, we should ignore everything apart from an enemy, and head for it
edict_t *combat_goalent; // we should go here instead of going straight to our enemy
edict_t *cover_ent; // entity we are taking cover from
char *next_combattarget;
float last_getcombatpos;
float last_gethidepos;
float dont_takecover_time;
// Ridah, this gets copied to the client.pers->episode_flags for client when they change maps
int episode_flags; // up to 32 bit flags, that represent various things according to the episode being played
char *name; // Special character name eg. "Bernie"
int name_index; // Each name has a name_index (unique for each episode), for fast lookups
char *scriptname; // used to identify hard-coded scripting events
edict_t *last_territory_touched; // set when we touch an "ai_territory" brush, so gangs react when we're in there territory
float time_territory_touched;
int current_territory;
edict_t *response_ent;
float last_response_time;
response_t last_response;
edict_t *start_ent; // entity marking our starting position
vec3_t last_step_pos; // for AI footsteps
float last_step_time;
float last_stand_evade;
int noroute_count;
int last_rval;
float fall_height; // max Z value of last jump
float last_offground, last_onground;
// Ridah, 6-jun-99, so they know where to return to when done hiding
edict_t *holdpos_ent;
// RAFAEL
int activate_flags;
float biketime;
int bikestate;
// Ridah, Vehicles
int vehicle_index; // references a vehicle_t structure in the global array
int acc; // accuracy variable - troop quality variable
int cal; // damage caused by weapon - calibur
char *art_skins; // holds 3-digit skins for head, torso and legs
float gun_noise_delay;
float noise_time;
vec3_t noise_pos;
int noise_type;
vec3_t noise_angles;
int gender; // so we know what sorts of sounds to play, uses GENDER_*
// combat AI stuff
float combat_last_visible;
vec3_t combat_last_visible_pos;
int combat_flags;
float take_cover_time;
// so we can trigger an event when a character gets below a certain health value
int health_threshold;
char *health_target;
int health_threshold2;
char *health_target2;
int health_threshold3;
char *health_target3;
float stand_if_idle_time; // stand if crouching and not doing much
};
// RAFAEL
#define ACTIVATE_GENERAL 1
#define ACTIVATE_AND_OPEN 2
// Ridah, used for lightpainting
#define LP_SIZE (12+2+1+1+1+1)
unsigned char *lpbuf[0xFFFF];
int num_lpbuf;
#define WEAPON_MOD_ROF 1
#define WEAPON_MOD_RELOAD 2
#define WEAPON_MOD_DAMAGE 4
#define WEAPON_MOD_COOLING_JACKET 8
// Ridah, level -> level followers
typedef struct
{
char classname[64];
char name[64];
char art_skins[64];
int health, max_health;
int skinofs[MAX_MODEL_PARTS][MAX_MODELPART_OBJECTS]; // add to baseskin to get current skin
int head;
float scale;
int spawnflags;
int count; // for the Runt
} follower_t;
#define MAX_FOLLOWERS 2
follower_t followers[MAX_FOLLOWERS];
extern int num_followers;
// Ridah, object bounds data is now stored in a global array for indexing, to accomodate the save/loadgame system
#define MAX_OBJECT_BOUNDS 2048
extern int num_object_bounds;
extern object_bounds_t *g_objbnds[MAX_OBJECT_BOUNDS];
Reference in a new issue Copy permalink