reaction/reaction/game/g_local.h

//-----------------------------------------------------------------------------
//
// $Id$
//
//-----------------------------------------------------------------------------
//
// $Log$
// Revision 1.102  2002/06/23 15:22:53  slicer
// Future 2.1 Matchmode Features - PART II
//
// Revision 1.101  2002/06/23 03:04:09  assimon
// Added suport for callvote map <map> and ref map <map>.
//
// Revision 1.100  2002/06/21 21:02:49  niceass
// worldspawn laserfog check
//
// Revision 1.99  2002/06/20 22:32:43  jbravo
// Added last damaged player and fixed a test2 model problem (atrimum my ass :)
// Changed g_RQ3_printOwnObits to g_RQ3_showOwnKills and it also controls $K
//
// Revision 1.98  2002/06/20 18:40:17  slicer
// Future 2.1 Matchmode Features - PART I
//
// Revision 1.97  2002/06/19 18:13:57  jbravo
// New TNG spawning system :)
//
// Revision 1.96  2002/06/18 09:22:16  niceass
// file exist function
//
// Revision 1.95  2002/06/16 20:11:41  niceass
// unused cvar removed
//
// Revision 1.94  2002/06/16 20:06:14  jbravo
// Reindented all the source files with "indent -kr -ut -i8 -l120 -lc120 -sob -bad -bap"
//
// Revision 1.93  2002/06/16 17:38:00  jbravo
// Removed the MISSIONPACK ifdefs and missionpack only code.
//
// Revision 1.92  2002/06/13 17:01:30  slicer
// Radio Gender changes according to model gender
//
// Revision 1.91  2002/06/11 01:43:08  blaze
// g_rq3_cvarfile allows you to change which file holds the restricted cvars
//
// Revision 1.90  2002/06/09 23:18:49  assimon
// Add coments to the init parser. Added Message before intermition telling next map. New cvar: g_RQ3_NextMap
//
// Revision 1.89  2002/06/07 19:07:08  slicer
// removed cvars for teamXready, replaced by level.teamXready
//
// Revision 1.88  2002/06/05 23:39:40  blaze
// unbreakables work properly.  Though I already commited this.
//
// Revision 1.87  2002/06/03 05:24:31  niceass
// spectator changes
//
// Revision 1.86  2002/05/31 18:17:10  makro
// Bot stuff. Added a server command that prints a line to a client
// and everyone who is spectating him
//
// Revision 1.85  2002/05/31 17:32:11  jbravo
// HC gibs almost working :)
//
// Revision 1.84  2002/05/30 21:18:28  makro
// Bots should reload/bandage when roaming around
// Added "pathtarget" key to all the entities
//
// Revision 1.83  2002/05/28 01:17:01  jbravo
// More gib fixes.  g_RQ3_gib added
//
// Revision 1.82  2002/05/23 15:55:25  makro
// Elevators
//
// Revision 1.81  2002/05/19 21:27:28  blaze
// added force and buoyancy to breakables
//
// Revision 1.80  2002/05/12 00:07:47  slicer
// Added Normal Radio Flood Protection
//
// Revision 1.79  2002/05/11 16:22:38  slicer
// Added a Repeat Flood Protection to Radio
//
// Revision 1.78  2002/05/10 04:06:27  jbravo
// Added Ignore
//
// Revision 1.77  2002/05/09 20:58:30  jbravo
// New Obit system and a warning cleanup in zcam
//
// Revision 1.76  2002/05/05 15:51:16  slicer
// Captain and subs get saved on map_restarts ( moved to "sess" )
//
// Revision 1.75  2002/05/05 04:23:00  jbravo
// Some MM fixes and cleanups
//
// Revision 1.74  2002/05/05 01:20:50  jbravo
// Delay the lights sound 5 server frames.
//
// Revision 1.73  2002/04/30 11:20:12  jbravo
// Redid the teamcount cvars.
//
// Revision 1.72  2002/04/29 06:17:20  niceass
// small change to pressure system
//
// Revision 1.71  2002/04/28 11:03:46  slicer
// Added "teammodel" for Matchmode, Referee "pause" command
//
// Revision 1.70  2002/04/23 00:21:44  jbravo
// Cleanups of the new model code.  Removed the spectator bar for zcam modes.
//
// Revision 1.69  2002/04/22 16:43:34  blaze
// Hey look, breakables explode now!  :)
//
// Revision 1.68  2002/04/22 02:27:57  jbravo
// Dynamic model recognition
//
// Revision 1.67  2002/04/15 00:54:26  assimon
// Simple ini file parser that reads a ini configuration file and suports rotations.
//
// Revision 1.66  2002/04/07 12:49:10  slicer
// Added 'teamname' command for MM, and tweaked the cvar system.
//
// Revision 1.65  2002/04/03 09:26:47  jbravo
// New FF system. Warns and then finally kickbans teamwounders and
// teamkillers
//
// Revision 1.64  2002/04/03 03:13:16  blaze
// NEW BREAKABLE CODE - will break all old breakables(wont appear in maps)
//
// Revision 1.63  2002/04/02 00:56:18  jbravo
// Removed the zcam defines again and did some cleanups
//
// Revision 1.62  2002/04/01 22:23:14  slicer
// Added "weapon" command buffering | Solved Gren Mode Bug
//
// Revision 1.59  2002/03/26 11:32:05  jbravo
// Remember specstate between rounds.
//
// Revision 1.58  2002/03/26 10:32:52  jbravo
// Bye bye LCA lag
//
// Revision 1.57  2002/03/25 14:55:00  jbravo
// teamCount cvars for Makro
//
// Revision 1.56  2002/03/23 05:17:42  jbravo
// Major cleanup of game -> cgame communication with LCA vars.
//
// Revision 1.55  2002/03/18 13:32:53  jbravo
// Fixed the fraglines for sniper head kills and twekaed bandaging a bit for
// testing
//
// Revision 1.54  2002/03/17 03:35:29  jbravo
// More radio tewaks and cleanups.
//
// Revision 1.53  2002/03/17 00:40:23  jbravo
// Adding variable team names. g_RQ3_team1name and g_RQ3_team2name. Fixed
// Slicers fraglimit check.
//
// Revision 1.52  2002/03/14 23:54:12  jbravo
// Added a variable system from AQ. Works the same except it uses $ for %
//
// Revision 1.51  2002/03/14 02:24:39  jbravo
// Adding radio :)
//
// Revision 1.50  2002/03/07 01:38:36  assimon
// Changed Ref System. New cvar added - g_RQ3_RefID. Now referee is peserved even on map changes or map_restarts.
//
// Revision 1.49  2002/03/07 00:00:54  assimon
// Added a skeleton referee suport, with some functional commands (map_restart and kick)
//
// Revision 1.48  2002/02/24 18:12:19  jbravo
// Added a cvar to control sniper behavior g_RQ3_sniperup. Def 0. if set yo 1
// it makes players spawn with the sniper up.
//
// Revision 1.47  2002/02/10 21:21:23  slicer
// Saving persistant and other data on some events..
//
// Revision 1.46  2002/02/10 18:38:42  jbravo
// Added new SPECTATOR_ZCAM spec mode.
//
// Revision 1.45  2002/02/10 02:49:28  niceass
// re-added zcam #define
//
// Revision 1.44  2002/02/06 03:10:43  jbravo
// Fix the instant spectate on death and an attempt to fix the scores
//
// Revision 1.43  2002/02/05 23:41:27  slicer
// More on matchmode..
//
// Revision 1.42  2002/02/04 00:10:49  slicer
// Matchmode: Teams Ready/Not Ready goes by cvar MM_team1/2
//
// Revision 1.40  2002/02/01 01:00:36  slicer
// Adding Matchmode: just a few basics and files...
//
// Revision 1.38  2002/01/31 02:55:58  blaze
// some basic work with the trains/elevators
//
// Revision 1.37  2002/01/31 02:25:31  jbravo
// Adding limchasecam.
//
// Revision 1.36  2002/01/24 14:20:53  jbravo
// Adding func_explosive and a few new surfaceparms
//
// Revision 1.35  2002/01/14 01:20:45  niceass
// No more default 800 gravity on items
// Thrown knife+Glass fix - NiceAss
//
// Revision 1.34  2002/01/11 20:20:58  jbravo
// Adding TP to main branch
//
// Revision 1.33  2002/01/11 19:48:30  jbravo
// Formatted the source in non DOS format.
//
// Revision 1.32  2001/12/31 16:28:42  jbravo
// I made a Booboo with the Log tag.
//
//
//-----------------------------------------------------------------------------
// Copyright (C) 1999-2000 Id Software, Inc.
//
// g_local.h -- local definitions for game module

#include "q_shared.h"
#include "bg_public.h"
#include "g_public.h"

//==================================================================

// the "gameversion" client command will print this plus compile date
#define	GAMEVERSION		"reaction"
#define BODY_QUEUE_SIZE		8

// JBravo: Max number of killed enemys to track
#define RQ3_MAXKILLS		5
#define MAX_TEAMS		2
#define MAX_SPAWN_POINTS	128

// Blaze: How long someone bleeds for
// Elder: This doesn't work the same as Q2 because clients and servers can
// run independent "clocks."  Normal servers send snapshots every 50ms
// (20 snapshots per second) so we double it from 10.
// Ideally, this number should match the server's sv_fps cvar value for those
// that run non-standard server frame rates.
#define BLEED_TIME			20
// Elder: Everyone knows you lose 6 health from the moment you start bandaging
// Let's enforce that in-code because it's sometimes 7 or even 8
// Elder: LOL it's 3, dumb Elder!
#define BLEED_BANDAGE			3
#define BLEED_BANDAGE_TIME		5400	// 27 x 2

// types of locations that can be hit
#define LOC_NOLOC			0	// non-location/world kill
#define LOC_HDAM			1	// head
#define LOC_CDAM			2	// chest
#define LOC_SDAM			3	// stomach
#define LOC_LDAM			4	// legs

#define INFINITE			1000000

#define	FRAMETIME			100	// msec
#define	CARNAGE_REWARD_TIME		3000
#define REWARD_SPRITE_TIME		2000

#define	INTERMISSION_DELAY_TIME		1000
#define	SP_INTERMISSION_DELAY_TIME	5000

// gentity->flags
#define	FL_GODMODE			0x00000010
#define	FL_NOTARGET			0x00000020
#define	FL_TEAMSLAVE			0x00000400	// not the first on the team
#define FL_NO_KNOCKBACK			0x00000800
#define FL_DROPPED_ITEM			0x00001000
#define FL_NO_BOTS			0x00002000	// spawn point not for bot use
#define FL_NO_HUMANS			0x00004000	// spawn point just for bots
#define FL_FORCE_GESTURE		0x00008000	// force gesture on client
//Elder: err - this looks funny... should it be 0x00010000 ?
//#define FL_THROWN_ITEM                0x00016000      // XRAY FMJ weapon throwing
#define FL_THROWN_ITEM			0x00010000	// XRAY FMJ weapon throwing
#define FL_RQ3_JUNKITEM			0x00020000	// Elder: the item we want to remove
//Elder: moved to bg_public.h
//#define FL_THROWN_KNIFE               0x00040000      // Elder: thrown knife special case

// movers are things like doors, plats, buttons, etc
typedef enum {
	MOVER_POS1,
	MOVER_POS2,
	MOVER_1TO2,
	MOVER_2TO1,
	// VALKYRIE: angle movements
	ROTATOR_POS1,
	ROTATOR_POS2,
	ROTATOR_1TO2,
	ROTATOR_2TO1
} moverState_t;

#define SP_PODIUM_MODEL			"models/mapobjects/podium/podium4.md3"
#define RQ3_RESPAWNTIME_DEFAULT		60000	// Elder: time for weapons to respawn - up to 60s
#define SP_AUTOOPEN			4	// Elder: revert to Q3 behaviour
#define SP_DOORTOGGLE			8	// Elder: added to enable mover toggling
#define MAXDOORTIME			100	// Elder: max time the opendoor key can stay open

//============================================================================

typedef struct gentity_s gentity_t;
typedef struct gclient_s gclient_t;

struct gentity_s {
	entityState_t s;	// communicated by server to clients
	entityShared_t r;	// shared by both the server system and game

	// DO NOT MODIFY ANYTHING ABOVE THIS, THE SERVER
	// EXPECTS THE FIELDS IN THAT ORDER!
	//================================

	struct gclient_s *client;	// NULL if not a client
	qboolean inuse;
	char *classname;	// set in QuakeEd
	int spawnflags;		// set in QuakeEd
	qboolean neverFree;	// if true, FreeEntity will only unlink
	// bodyque uses this
// JBravo: adding func_explosive
	int damage_radius;
	int mass;
	int tension;
	int bounce;
	int material;
	int size;
	int flags;		// FL_* variables
	char *model;
	char *model2;
	int freetime;		// level.time when the object was freed
	int eventTime;		// events will be cleared EVENT_VALID_MSEC after set
	qboolean freeAfterEvent;
	qboolean unlinkAfterEvent;
	qboolean physicsObject;	// if true, it can be pushed by movers and fall off edges
	// all game items are physicsObjects,
	float physicsBounce;	// 1.0 = continuous bounce, 0.0 = no bounce
	int clipmask;		// brushes with this content value will be collided against
	// when moving.  items and corpses do not collide against
	// players, for instance
	// movers
	moverState_t moverState;
	int soundPos1;
	int sound1to2;
	int sound2to1;
	int soundPos2;
	int soundLoop;
	gentity_t *parent;
	gentity_t *nextTrain;
	gentity_t *prevTrain;
	vec3_t pos1, pos2;
	char *message;
	int timestamp;		// body queue sinking, etc
	float angle;		// set in editor, -1 = up, -2 = down
	char *target;
	char *targetname;
	char *team;
	char *targetShaderName;
	char *targetShaderNewName;
	gentity_t *target_ent;

	float speed;
	vec3_t movedir;

	int nextthink;
	void (*think) (gentity_t * self);
	void (*reached) (gentity_t * self);	// movers call this when hitting endpoint
	void (*blocked) (gentity_t * self, gentity_t * other);
	void (*touch) (gentity_t * self, gentity_t * other, trace_t * trace);
	void (*use) (gentity_t * self, gentity_t * other, gentity_t * activator);
	void (*pain) (gentity_t * self, gentity_t * attacker, int damage);
	void (*die) (gentity_t * self, gentity_t * inflictor, gentity_t * attacker, int damage, int mod);

	int pain_debounce_time;
	int fly_sound_debounce_time;	// wind tunnel
	int last_move_time;

	int health;
	//Blaze: hold the health so when we respawn it, the health is set properly
	int health_saved;
	//Blaze: holds if we can "chip" off peices
	qboolean chippable;
	//true if we cant break it
	qboolean unbreakable;
	//true if it's explosive
	qboolean explosive;
	//True if it's already been exploded
	qboolean exploded;

	qboolean takedamage;
	int damage;
	int splashDamage;	// quad will increase this without increasing radius
	int splashRadius;
	int methodOfDeath;
	int splashMethodOfDeath;
	int count;
	gentity_t *chain;
	gentity_t *enemy;
	gentity_t *activator;
	gentity_t *teamchain;	// next entity in team
	gentity_t *teammaster;	// master of the team

	int watertype;
	int waterlevel;
	int noise_index;
	// timing variables
	float wait;
	float random;

	gitem_t *item;		// for bonus items
	float distance;		// VALKYRIE: for rotating door
	//Blaze: Holds the target set by a button
	char *pathtarget;
};

typedef enum {
	CON_DISCONNECTED,
	CON_CONNECTING,
	CON_CONNECTED
} clientConnected_t;

typedef enum {
	SPECTATOR_NOT,
	SPECTATOR_FREE,
	SPECTATOR_FOLLOW,
	SPECTATOR_ZCAM,
	SPECTATOR_CAMERA_FLIC,
	SPECTATOR_CAMERA_SWING,
	SPECTATOR_SCOREBOARD
} spectatorState_t;

typedef enum {
	TEAM_BEGIN,		// Beginning a team game, spawn at base
	TEAM_ACTIVE		// Now actively playing
} playerTeamStateState_t;

typedef struct {
	playerTeamStateState_t state;
	int location;
	int captures;
	int basedefense;
	int carrierdefense;
	int flagrecovery;
	int fragcarrier;
	int assists;
	float lasthurtcarrier;
	float lastreturnedflag;
	float flagsince;
	float lastfraggedcarrier;
} playerTeamState_t;

// the auto following clients don't follow a specific client
// number, but instead follow the first two active players
#define	FOLLOW_ACTIVE1	-1
#define	FOLLOW_ACTIVE2	-2

// JBravo: for ignore
#define MAXIGNORE	11
typedef gentity_t *ignorelist_t[MAXIGNORE];

// client data that stays across multiple levels or tournament restarts
// this is achieved by writing all the data to cvar strings at game shutdown
// time and reading them back at connection time.  Anything added here
// MUST be dealt with in G_InitSessionData() / G_ReadSessionData() / G_WriteSessionData()
typedef struct {
	//Slicer Matchmode
	team_t captain;
	team_t sub;
	team_t sessionTeam;
	team_t savedTeam;	// JBravo: Used to hold the real team status of a player.
	int spectatorTime;	// for determining next-in-line to play
	spectatorState_t spectatorState;
	int spectatorClient;	// for chasecam and follow mode
	int wins, losses;	// tournament stats
	qboolean teamLeader;	// true when this client is a team leader
	gentity_t *spawnPoint;	// JBravo: This players spawnpoint
	qboolean teamSpawn;	// JBravo: This player is being spawned with his team.
	int ignore_time;	// JBravo: to avoid ignore flooding
	ignorelist_t ignorelist;	// JBravo: This players ignore list.
} clientSession_t;

//
#define MAX_NETNAME		36
#define	MAX_VOTE_COUNT		3

// client data that stays across multiple respawns, but is cleared
// on each level change or team change at ClientBegin()
typedef struct {
	clientConnected_t connected;
	// aasimon: No Need for this here, using a cvar to record the clientnumber of referee, so that map_restarts dont change 
	// the referee
	// qboolean     referee;

	usercmd_t cmd;		// we would lose angles if not persistant
	qboolean localClient;	// true if "ip" info key is "localhost"
	qboolean initialSpawn;	// the first spawn should be at a cool location
	qboolean predictItemPickup;	// based on cg_predictItems userinfo
	qboolean pmoveFixed;	//
	char netname[MAX_NETNAME];
	int maxHealth;		// for handicapping
	int enterTime;		// level.time the client entered the game
	playerTeamState_t teamState;	// status in teamplay games
	int voteCount;		// to prevent people from constantly calling votes
	int teamVoteCount;	// to prevent people from constantly calling votes
	qboolean teamInfo;	// send team overlay updates?
	qboolean hadUniqueWeapon[MAX_WEAPONS];	//Elder: for "ammo" in last gun

	int sayTime;		// Elder: say validation stuff
	int sayCount;
	int sayWarnings;
	int sayBans;
	int sayMuteTime;
	qboolean sayModerated;	// so warnings are not repeated for multi-line, same-frame messages
	int records[REC_NUM_RECORDS];	// Elder: for our statistics tracking
} clientPersistant_t;

struct camera_s;

// Elder: spam prevention defaults
/*
#define SAY_MAX_NUMBER		6
#define SAY_MAX_WARNINGS	3
#define SAY_PERIOD_TIME		3			// Elder: in seconds
#define SAY_WARNING_TIME	15
#define SAY_BAN_TIME		60			// Technically should drop client
*/
#define SAY_MAX_NUMBER		"6"
#define SAY_MAX_WARNINGS	"3"
#define SAY_PERIOD_TIME		"3"	// Elder: in seconds
#define SAY_WARNING_TIME	"15"
#define SAY_BAN_TIME		"60"	// Technically should drop client
typedef enum {
	SAY_BAN,
	SAY_WARNING,
	SAY_OK,

	SAY_TOTAL
} sayValidations_t;

// this structure is cleared on each ClientSpawn(),
// except for 'client->pers' and 'client->sess'
struct gclient_s {
	// ps MUST be the first element, because the server expects it
	playerState_t ps;	// communicated by server to clients
	// the rest of the structure is private to game
	clientPersistant_t pers;
	clientSession_t sess;
	qboolean readyToExit;	// wishes to leave the intermission
	qboolean noclip;
	int lastCmdTime;	// level.time of last usercmd_t, for EF_CONNECTION
	// we can't just use pers.lastCommand.time, because
	// of the g_sycronousclients case
	int buttons;
	int oldbuttons;
	int latched_buttons;
	vec3_t oldOrigin;
	// sum up damage over an entire frame, so
	// shotgun blasts give a single big kick
	int damage_armor;	// damage absorbed by armor
	int damage_blood;	// damage taken out of health
	int damage_knockback;	// impact damage
	vec3_t damage_from;	// origin for vector calculation
	qboolean damage_fromWorld;	// if true, don't use the damage_from vector
	//qboolean              damage_vest;            // Elder: if true, play the vest-hit sound
	int accurateCount;	// for "impressive" reward sound
	int accuracy_shots;	// total number of shots
	int accuracy_hits;	// total number of hits
	gentity_t *lastkilled_client[5];	// JBravo: last 5 clients that this client killed
	char last_damaged_players[MAX_STRING_CHARS];	// JBravo: last client this one damaged.
	int num_kills;		// JBravo: Number of killed players in TP.
	int lasthurt_client;	// last client that damaged this client
	int lasthurt_mod;	// type of damage the client did
	//Slicer
	int weapon_attempts;
	qboolean weapon_after_bandage_warned;
// Begin Duffman
	int lasthurt_location;	// Where the client was hit.
// End Duffman
	// timers
	int respawnTime;	// can respawn when time > this, force after g_forcerespwan
	int inactivityTime;	// kick players when time > this
	qboolean inactivityWarning;	// qtrue if the five seoond warning has been given
	int rewardTime;		// clear the EF_AWARD_IMPRESSIVE, etc when time > this
	int airOutTime;
	int lastKillTime;	// for multiple kill rewards
	qboolean fireHeld;	// used for hook
	gentity_t *hook;	// grapple hook if out
	int switchTeamTime;	// time the player switched teams
// Begin Duffman
	int numClips[MAX_WEAPONS];	// Number of clips each weapon has
// End Duffman
	int weaponCount[WP_NUM_WEAPONS];	// Elder: for duplicate unique weapon tracking
	int openDoor;		//Blaze: used to hold if someone has hit opendoor key
	int openDoorTime;
	// timeResidual is used to handle events that happen every second
	// like health / armor countdowns and regeneration
	int timeResidual;
	//Elder: C3A laser tutorial
	gentity_t *lasersight;	// lasersight OR flashlight if in use
	// JBravo: sniperheadshots
	qboolean noHead;
	// Bleeding server-only cvars
	int bleeding;		// Blaze: remaining points to bleed away
	int bleed_remain;	// Blaze: How much left to bleed
	int bleedloc;		// Blaze: Where are we bleeding
	vec3_t bleedloc_offset;	// Blaze: location of bleeding (from origin)
	int bleed_delay;	// Elder: time for next spurt of blood
	vec3_t bleednorm;
	//qboolean              isBleeding;             // Blaze: is client bleeding
//      int                     legDamage;              // Blaze: Client has leg damage - holds number of hits too
	int bleedtick;		// Blaze: Holds # of seconds till bleeding stops.
	int bleedBandageCount;	// Elder: hack to restrict amount of bleeding to 3 points
	int headShotTime;	// Elder: got headshot?
	//Elder: server only needs to know for sniper spread - ARGH
//      int                     zoomed;                 // Hawkins (SSG zoom)
	//qboolean              semi;                   // hawkins (semiauto mode for m4, mp5, pistol)
	int shots;		// Blaze: Number of shots fired so far with this weapon
	int weaponfireNextTime;	// for akimbos
	int lastzoom;		// Elder: save last zoom state when firing
	// These are now obsolete with the new reload code
	int fastReloads;	// Elder: for queuing M3/SSG reloads
	int lastReloadTime;	// Elder: for queuing M3/SSG reloads
	int reloadAttempts;	// Elder: for queuing M3/SSG reloads
	int reloadStage;	// Elder: 0, 1, 2 for sound queuing - move to stats?
	int consecutiveShots;	// Elder: for M4 ride-up/kick
	int uniqueWeapons;	// Elder: formerly a stat, now just a server var
	int uniqueItems;
	int killStreak;		// Elder: replaces the old STAT_STREAK
	qboolean kevlarHit;	// Elder: kevlar hit -- FIXME: poor implementation
	int knife_sound;	// NiceAss: What did the player hit while slashing?

	char *areabits;
	struct camera_s *camera;
// JBravo adding TP stuff
	int specMode;
	int teamplayWeapon;
	int teamplayItem;
	int radioGender;
	qboolean radioOff;
	int team_wounds;
	int team_wounds_before;
	int ff_warning;
	int team_kills;
	qboolean gibbed;

	//Slicer Flood protect:

	float rd_mute;		//Time to be muted
	int rd_Count;		//Counter for the last msgs in "xx" secs allowed
	float rd_time;		//Time for the first radio message of the ones to follow

	int rd_lastRadio;	//Code of the last radio used
	int rd_repCount;	//Counter for the number of repeated radio msgs
	float rd_repTime;	//The time for the last repeated radio msg
};

// JBravo: for model loading
#define MAXMODELS	64
#define MAXMODELLEN	100

typedef struct legitmodel {
	char name[MAXMODELLEN];
	vec3_t team1color;
	vec3_t team2color;
	int gender;
} legitmodel_t;

// Begin Duffman
int G_LocationDamage(vec3_t point, gentity_t * targ, gentity_t * attacker, int take);
void Cmd_Reload(gentity_t * ent);	// reloads the current weapon

// Elder: removed - prototype in bg_public.h
//   int ClipAmountForWeapon( int w );  // returns the maximum ammo for the current weapon
// End Duffman

//
// this structure is cleared as each map is entered
//
#define	MAX_SPAWN_VARS		64
#define	MAX_SPAWN_VARS_CHARS	4096

typedef struct {
	struct gclient_s *clients;	// [maxclients]
	struct gentity_s *gentities;
	int gentitySize;
	int num_entities;	// current number, <= MAX_GENTITIES
	int warmupTime;		// restart match at this time
	fileHandle_t logFile;
	// store latched cvars here that we want to get at often
	int maxclients;
	int framenum;
	int time;		// in msec
	int previousTime;	// so movers can back up when blocked
	int startTime;		// level.time the map was started
	int teamScores[TEAM_NUM_TEAMS];
	int lastTeamLocationTime;	// last time of client team location update
	qboolean newSession;	// don't use any old session data, because
	// we changed gametype
	qboolean restarted;	// waiting for a map_restart to fire
	int numConnectedClients;
	int numNonSpectatorClients;	// includes connecting clients
	int numPlayingClients;	// connected, non-spectators
	int sortedClients[MAX_CLIENTS];	// sorted by score
	int follow1, follow2;	// clientNums for auto-follow spectators
	int snd_fry;		// sound index for standing in lava
	int warmupModificationCount;	// for detecting if g_warmup is changed
	// voting state	
	char voteString[MAX_STRING_CHARS];
	char voteDisplayString[MAX_STRING_CHARS];
	// vote extras
	char voteMap[MAX_STRING_CHARS];
	
	int voteTime;		// level.time vote was called
	int voteExecuteTime;	// time the vote is executed
	int voteYes;
	int voteNo;
	int numVotingClients;	// set by CalculateRanks

	// team voting state
	char teamVoteString[2][MAX_STRING_CHARS];
	int teamVoteTime[2];	// level.time vote was called
	int teamVoteYes[2];
	int teamVoteNo[2];
	int numteamVotingClients[2];	// set by CalculateRanks

	// spawn variables
	qboolean spawning;	// the G_Spawn*() functions are valid
	int numSpawnVars;
	char *spawnVars[MAX_SPAWN_VARS][2];	// key / value pairs
	int numSpawnVarChars;
	char spawnVarChars[MAX_SPAWN_VARS_CHARS];

	// intermission state
	int intermissionQueued;	// intermission was qualified, but
	// wait INTERMISSION_DELAY_TIME before
	// actually going there so the last
	// frag can be watched.  Disable future
	// kills during this delay
	int intermissiontime;	// time the intermission was started
	char *changemap;
	qboolean readyToExit;	// at least one client wants to exit
	int exitTime;
	vec3_t intermission_origin;	// also used for spectator spawns
	vec3_t intermission_angle;

	qboolean locationLinked;	// target_locations get linked
	gentity_t *locationHead;	// head of the location list
	int bodyQueIndex;	// dead bodies
	gentity_t *bodyQue[BODY_QUEUE_SIZE];
//      Slicer: Matchmode
	float matchTime;
	qboolean team1ready;
	qboolean team2ready;
	qboolean inGame;
	qboolean paused;
	qboolean settingsLocked;
// JBravo adding TP
	int lights_camera_action;
	qboolean team_round_going;
	int holding_on_tie_check;
	int team_round_countdown;
	qboolean team_game_going;
	int rulecheckfrequency;
	int current_round_length;
	qboolean spawnPointsLocated;
	gentity_t *team1spawnpoint;
	gentity_t *team2spawnpoint;
	vec3_t team1spawn_origin;
	vec3_t team1spawn_angles;
	vec3_t team2spawn_origin;
	vec3_t team2spawn_angles;
	int fps;
	int lights_delay;
	//Slicer: 
	int team1gender;
	int team2gender;

	// Freud: spawning system
	int randteam;
	int num_used_farteamplay_spawns[MAX_TEAMS];
	int num_potential_spawns[MAX_TEAMS];
	gentity_t *teamplay_spawns[MAX_TEAMS];
	qboolean teams_assigned[MAX_TEAMS];
	gentity_t *potential_spawns[MAX_TEAMS][MAX_SPAWN_POINTS];
	gentity_t *used_farteamplay_spawns[MAX_TEAMS][MAX_SPAWN_POINTS];

} level_locals_t;

//
// rxn_game.c
//

void CheckBleeding(gentity_t * targ);
void StartBandage(gentity_t * ent);

int ThrowWeapon(gentity_t * ent, qboolean forceThrow);
void ThrowItem(gentity_t * ent);
gentity_t *dropWeapon(gentity_t * ent, gitem_t * item, float angle, int xr_flags);	// XRAY FMJ

//Blaze Reaction knife stuff
//Elder: commented out - unused?
//void Rxn_SpawnKnife( gentity_t *e);
//
// g_spawn.c
//
qboolean G_SpawnString(const char *key, const char *defaultString, char **out);

// spawn string returns a temporary reference, you must CopyString() if you want to keep it
qboolean G_SpawnFloat(const char *key, const char *defaultString, float *out);
qboolean G_SpawnInt(const char *key, const char *defaultString, int *out);
qboolean G_SpawnVector(const char *key, const char *defaultString, float *out);
void G_SpawnEntitiesFromString(void);
char *G_NewString(const char *string);

//
// g_cmds.c
//
char *ConcatArgs(int start);
void Cmd_Score_f(gentity_t * ent);
void StopFollowing(gentity_t * ent);
void BroadcastTeamChange(gclient_t * client, int oldTeam);
void SetTeam(gentity_t * ent, char *s);
void Cmd_FollowCycle_f(gentity_t * ent, int dir);
void Cmd_Unzoom(gentity_t * ent);
void Cmd_OpenDoor(gentity_t * ent);
void Cmd_Weapon(gentity_t * ent);

//Elder: C3A laser tutorial
void Laser_Gen(gentity_t * ent, qboolean enabled);
void Laser_Think(gentity_t * self);

//Elder: anti-spam stuff
int RQ3_ValidateSay(gentity_t * ent);

//Elder: commented out for Homer
//void toggleSemi(gentity_t *ent);
//Makro - sends a command to a client and all the ones spectating him
void G_SendClientSpec(gentity_t * ent, const char *msg);

//
// g_items.c
//
void G_CheckTeamItems(void);
void G_RunItem(gentity_t * ent);
void RespawnItem(gentity_t * ent);

void UseHoldableItem(gentity_t * ent);
void PrecacheItem(gitem_t * it);
gentity_t *Drop_Item(gentity_t * ent, gitem_t * item, float angle);
gentity_t *LaunchItem(gitem_t * item, vec3_t origin, vec3_t velocity, int xrflags);
void SetRespawn(gentity_t * ent, float delay);
void G_SpawnItem(gentity_t * ent, gitem_t * item);
void FinishSpawningItem(gentity_t * ent);
void Think_Weapon(gentity_t * ent);
int ArmorIndex(gentity_t * ent);

//Elder: added bandolier factor
void Add_Ammo(gentity_t * ent, int weapon, int count, int bandolierfactor);
void Touch_Item(gentity_t * ent, gentity_t * other, trace_t * trace);

void ClearRegisteredItems(void);
void RegisterItem(gitem_t * item);
void SaveRegisteredItems(void);

//Elder: added
void RQ3_DroppedItemThink(gentity_t * ent);
void RQ3_DroppedWeaponThink(gentity_t * ent);
void RQ3_ResetWeapon(int weapon);
void RQ3_ResetItem(int itemTag);

//
// g_utils.c
//
int G_ModelIndex(char *name);
int G_SoundIndex(char *name);
void G_TeamCommand(team_t team, char *cmd);
void G_KillBox(gentity_t * ent);
gentity_t *G_Find(gentity_t * from, int fieldofs, const char *match);

//Makro - added
gentity_t *G_Find2(gentity_t * from, int fieldofs, const char *match, int fieldofs2, const char *match2);
gentity_t *G_PickTarget(char *targetname);
void G_UseTargets(gentity_t * ent, gentity_t * activator);
void G_SetMovedir(vec3_t angles, vec3_t movedir);

void G_InitGentity(gentity_t * e);
gentity_t *G_Spawn(void);
gentity_t *G_TempEntity(vec3_t origin, int event);

//Elder: added
gentity_t *G_TempEntity2(vec3_t origin, int event, int eParm);
void G_Sound(gentity_t * ent, int channel, int soundIndex);
void G_FreeEntity(gentity_t * e);

//Elder: added
void RQ3_SaveZoomLevel(gentity_t * ent);
int RQ3_isZoomed(gentity_t * ent);

qboolean G_EntitiesFree(void);

void G_TouchTriggers(gentity_t * ent);
void G_TouchSolids(gentity_t * ent);

float *tv(float x, float y, float z);
char *vtos(const vec3_t v);

float vectoyaw(const vec3_t vec);

void G_AddPredictableEvent(gentity_t * ent, int event, int eventParm);
void G_AddEvent(gentity_t * ent, int event, int eventParm);
void G_SetOrigin(gentity_t * ent, vec3_t origin);
void AddRemap(const char *oldShader, const char *newShader, float timeOffset);
const char *BuildShaderStateConfig();

//
// g_combat.c
//
qboolean G_HitPlayer(gentity_t * targ, vec3_t dir, vec3_t point);	// Added by NiceAss for new head hit-detection
qboolean CanDamage(gentity_t * targ, vec3_t origin);
void G_Damage(gentity_t * targ, gentity_t * inflictor, gentity_t * attacker, vec3_t dir, vec3_t point, int damage,
	      int dflags, int mod);
qboolean G_RadiusDamage(vec3_t origin, gentity_t * attacker, float damage, float radius, gentity_t * ignore, int mod);
int G_InvulnerabilityEffect(gentity_t * targ, vec3_t dir, vec3_t point, vec3_t impactpoint, vec3_t bouncedir);
void body_die(gentity_t * self, gentity_t * inflictor, gentity_t * attacker, int damage, int meansOfDeath);
void TossClientItems(gentity_t * self);
void TossClientCubes(gentity_t * self);

// damage flags
#define DAMAGE_RADIUS			0x00000001	// damage was indirect
#define DAMAGE_NO_ARMOR			0x00000002	// armour does not protect from this damage
#define DAMAGE_NO_KNOCKBACK			0x00000004	// do not affect velocity, just view angles
#define DAMAGE_NO_PROTECTION		0x00000008	// armor, shields, invulnerability, and godmode have no effect
//Elder: Changed from 0x00000016 to 0x00000020
#define DAMAGE_NO_LOCATIONAL		0x00000020	// Generic damage (shotguns, grenades, kicks)

//
// g_missile.c
//
void G_RunMissile(gentity_t * ent);

gentity_t *fire_knife(gentity_t * self, vec3_t start, vec3_t aimdir);
gentity_t *fire_blaster(gentity_t * self, vec3_t start, vec3_t aimdir);

//Blaze: Dont need these functions
//gentity_t *fire_plasma (gentity_t *self, vec3_t start, vec3_t aimdir);
gentity_t *fire_grenade(gentity_t * self, vec3_t start, vec3_t aimdir);

//gentity_t *fire_rocket (gentity_t *self, vec3_t start, vec3_t dir);
//gentity_t *fire_bfg (gentity_t *self, vec3_t start, vec3_t dir);
//gentity_t *fire_grapple (gentity_t *self, vec3_t start, vec3_t dir);

//
// g_mover.c
//
void G_RunMover(gentity_t * ent);
void Touch_DoorTrigger(gentity_t * ent, gentity_t * other, trace_t * trace);

//void Touch_DoorTriggerSpectator( gentity_t *ent, gentity_t *other, trace_t *trace ); // NiceAss: Added

//
// g_trigger.c
//
void trigger_teleporter_touch(gentity_t * self, gentity_t * other, trace_t * trace);

//
// g_misc.c
//
void TeleportPlayer(gentity_t * player, vec3_t origin, vec3_t angles);
void G_BreakGlass(gentity_t * ent, gentity_t * inflictor, gentity_t * attacker, vec3_t point, int mod, int damage);	//Blaze: Breakable glass
void G_RunDlight(gentity_t * ent);	// Elder: dlight running
void G_EvaluateTrajectory(const trajectory_t * tr, int atTime, vec3_t result);
void G_EvaluateTrajectoryDelta(const trajectory_t * tr, int atTime, vec3_t result);
void G_GravityChange(void);
void G_CreatePressure(vec3_t origin, vec3_t normal, gentity_t * ent);
qboolean G_FileExists(char *filename);

//
// g_weapon.c
//
qboolean LogAccuracyHit(gentity_t * target, gentity_t * attacker);
void CalcMuzzlePoint(gentity_t * ent, vec3_t forward, vec3_t right, vec3_t up, vec3_t muzzlePoint);
void SnapVectorTowards(vec3_t v, vec3_t to);
qboolean CheckGauntletAttack(gentity_t * ent);

//void Knife_Touch (gentity_t *ent, gentity_t *other,trace_t *trace);
//Blaze: No need for these because no gauntlet
//void Weapon_HookFree (gentity_t *ent);
//void Weapon_HookThink (gentity_t *ent);
//Elder: for shotgun damage reports
void RQ3_InitShotgunDamageReport(void);
void RQ3_ProduceShotgunDamageReport(gentity_t * self);
qboolean JumpKick(gentity_t * ent);
qboolean DoorKick(trace_t * trIn, gentity_t * ent, vec3_t origin, vec3_t forward);
extern int tookShellHit[MAX_CLIENTS];

//
// g_client.c
//
team_t TeamCount(int ignoreClientNum, int team);
int TeamLeader(int team);
team_t PickTeam(int ignoreClientNum);
void SetClientViewAngle(gentity_t * ent, vec3_t angle);
gentity_t *SelectSpawnPoint(vec3_t avoidPoint, vec3_t origin, vec3_t angles);

//Elder: added because I use it in g_main.c and g_items.c for item spawning
gentity_t *SelectRandomDeathmatchSpawnPoint(void);

// JBravo: need this for teamspawning
gentity_t *SelectRandomFurthestSpawnPoint(vec3_t avoidPoint, vec3_t origin, vec3_t angles);
gentity_t *SelectInitialSpawnPoint(vec3_t origin, vec3_t angles);
void CopyToBodyQue(gentity_t * ent);
void respawn(gentity_t * ent);
void BeginIntermission(void);
void InitClientPersistant(gclient_t * client);
void InitClientResp(gclient_t * client);
void InitBodyQue(void);
void ClientSpawn(gentity_t * ent);

//Blaze: for the cheat vars stuff
int G_SendCheatVars(int);

//Blaze: for the breakable stuff
int G_SendBreakableInfo(int);
void player_die(gentity_t * self, gentity_t * inflictor, gentity_t * attacker, int damage, int mod);
void AddScore(gentity_t * ent, vec3_t origin, int score);
void CalculateRanks(void);
qboolean SpotWouldTelefrag(gentity_t * spot);

//
// g_svcmds.c
//
qboolean ConsoleCommand(void);
void G_ProcessIPBans(void);
qboolean G_FilterPacket(char *from);

//
// g_weapon.c
//
void FireWeapon(gentity_t * ent);
void ReloadWeapon(gentity_t * ent, int stage);	// Elder: added

//
// p_hud.c
//
void MoveClientToIntermission(gentity_t * client);
void G_SetStats(gentity_t * ent);
void DeathmatchScoreboardMessage(gentity_t * client);

//
// g_cmds.c
//

//
// g_pweapon.c
//

//
// g_main.c
//
void FindIntermissionPoint(void);
void SetLeader(int team, int client);
void CheckTeamLeader(int team);
void G_RunThink(gentity_t * ent);
void QDECL G_LogPrintf(const char *fmt, ...);
void SendScoreboardMessageToAllClients(void);
void QDECL G_Printf(const char *fmt, ...);
void QDECL G_Error(const char *fmt, ...);

//Elder: added
void RQ3_StartUniqueItems(void);

// aasimon: init stuff
void RQ3_ReadInitFile(void);
void RQ3_ParseBuffer(char *buf, int len);
int RQ3_GetTag(char *buf, int *cur_pos, char *tag, int len);
int RQ3_CheckTag(char *tag);
int RQ3_ParseBlock(int tag_type, char *tag, int *cur_pos, char *buf, int len);
int RQ3_GetCommand(char *buf, int *cur_pos, char *cvar, char *value, int len);
int RQ3_GetWord(char *buf, int *cur_pos, char *word, int len);
int RQ3_CheckClosingTag(char *buf, int *cur_pos, int tag_type, int len);
void RQ3_SkipLineComment(char *buf, int *cur_pos);

//
// g_client.c
//
char *ClientConnect(int clientNum, qboolean firstTime, qboolean isBot);
void ClientUserinfoChanged(int clientNum);
void ClientDisconnect(int clientNum);
void ClientBegin(int clientNum);
void ClientCommand(int clientNum);
typedef struct {
	char name[80];
	int jump;
	int velocity;
} breakable_t;
extern breakable_t rq3_breakables[RQ3_MAX_BREAKABLES];

//
// g_active.c
//
void ClientThink(int clientNum);
void ClientEndFrame(gentity_t * ent);
void G_RunClient(gentity_t * ent);

//
// g_team.c
//
qboolean OnSameTeam(gentity_t * ent1, gentity_t * ent2);
void Team_CheckDroppedItem(gentity_t * dropped);
qboolean CheckObeliskAttack(gentity_t * obelisk, gentity_t * attacker);

//
// g_mem.c
//
void *G_Alloc(int size);
void G_InitMemory(void);
void Svcmd_GameMem_f(void);

//
// g_session.c
//
void G_ReadSessionData(gclient_t * client);
void G_InitSessionData(gclient_t * client, char *userinfo);

void G_InitWorldSession(void);
void G_WriteSessionData(void);

//
// g_arenas.c
//
void UpdateTournamentInfo(void);
void SpawnModelsOnVictoryPads(void);
void Svcmd_AbortPodium_f(void);

//
// g_bot.c
//
void G_InitBots(qboolean restart);
char *G_GetBotInfoByNumber(int num);
char *G_GetBotInfoByName(const char *name);
void G_CheckBotSpawn(void);
void G_RemoveQueuedBotBegin(int clientNum);
qboolean G_BotConnect(int clientNum, qboolean restart);
void Svcmd_AddBot_f(void);
void Svcmd_BotList_f(void);
void BotInterbreedEndMatch(void);

// ai_main.c
#define MAX_FILEPATH			144

//bot settings
typedef struct bot_settings_s {
	char characterfile[MAX_FILEPATH];
	float skill;
	char team[MAX_FILEPATH];
} bot_settings_t;

int BotAISetup(int restart);
int BotAIShutdown(int restart);
int BotAILoadMap(int restart);
int BotAISetupClient(int client, struct bot_settings_s *settings, qboolean restart);
int BotAIShutdownClient(int client, qboolean restart);
int BotAIStartFrame(int time);
void BotTestAAS(vec3_t origin);

#include "g_team.h"		// teamplay specific stuff

// JBravo: Functions from g_teamplay.c
#include "g_teamplay.h"

extern level_locals_t level;
extern gentity_t g_entities[MAX_GENTITIES];

#define	FOFS(x) ((int)&(((gentity_t *)0)->x))

extern vmCvar_t g_gametype;
extern vmCvar_t g_dedicated;
extern vmCvar_t g_cheats;
extern vmCvar_t g_maxclients;	// allow this many total, including spectators
extern vmCvar_t g_maxGameClients;	// allow this many active
extern vmCvar_t g_restarted;

extern vmCvar_t g_dmflags;
extern vmCvar_t g_fraglimit;
extern vmCvar_t g_timelimit;
extern vmCvar_t g_capturelimit;
extern vmCvar_t g_friendlyFire;
extern vmCvar_t g_password;
extern vmCvar_t g_needpass;
extern vmCvar_t g_gravity;
extern vmCvar_t g_speed;
extern vmCvar_t g_quadfactor;
extern vmCvar_t g_forcerespawn;
extern vmCvar_t g_inactivity;
extern vmCvar_t g_debugMove;
extern vmCvar_t g_debugAlloc;
extern vmCvar_t g_debugDamage;
extern vmCvar_t g_weaponRespawn;
extern vmCvar_t g_weaponTeamRespawn;
extern vmCvar_t g_synchronousClients;
extern vmCvar_t g_motd;
extern vmCvar_t g_warmup;
extern vmCvar_t g_doWarmup;
extern vmCvar_t g_blood;
extern vmCvar_t g_allowVote;
extern vmCvar_t g_teamAutoJoin;
extern vmCvar_t g_teamForceBalance;
extern vmCvar_t g_banIPs;
extern vmCvar_t g_filterBan;
extern vmCvar_t g_obeliskHealth;
extern vmCvar_t g_obeliskRegenPeriod;
extern vmCvar_t g_obeliskRegenAmount;
extern vmCvar_t g_obeliskRespawnDelay;
extern vmCvar_t g_cubeTimeout;
extern vmCvar_t g_redteam;
extern vmCvar_t g_blueteam;
extern vmCvar_t g_smoothClients;
extern vmCvar_t pmove_fixed;
extern vmCvar_t pmove_msec;
extern vmCvar_t g_rankings;
extern vmCvar_t g_enableDust;
extern vmCvar_t g_enableBreath;
extern vmCvar_t g_enableFogLaser;
extern vmCvar_t g_singlePlayer;
extern vmCvar_t g_proxMineTimeout;

//Slicer: Matchmode
extern vmCvar_t g_RQ3_matchmode;
extern vmCvar_t g_RQ3_forceteamtalk;
extern vmCvar_t g_RQ3_maxplayers;

//Blaze: Reaction cvars
extern vmCvar_t g_rxn_knifelimit;
extern vmCvar_t g_RQ3_maxWeapons;
extern vmCvar_t g_RQ3_statLog;
extern vmCvar_t g_RQ3_ejectBlood;
extern vmCvar_t g_RQ3_respawnProtectTime;
extern vmCvar_t g_RQ3_cvarfile;

//Elder: spam protection cvars
extern vmCvar_t g_RQ3_messageMaxCount;	// Max messages in interval
extern vmCvar_t g_RQ3_messageInterval;	// Time interval for spam check
extern vmCvar_t g_RQ3_messageMaxWarnings;	// Max warning count
extern vmCvar_t g_RQ3_messageWarnTime;	// Time for warning; 0 for no-penalty warning
extern vmCvar_t g_RQ3_messageBanTime;	// Time for ban; 0 to kick
extern vmCvar_t g_RQ3_messageProtect;	// Elder: 0 disable, non-zero enable

// JBravo
extern vmCvar_t g_RQ3_roundlimit;	// JBravo: No. of rounds pr. map
extern vmCvar_t g_RQ3_roundtimelimit;	// JBravo: Time pr. round
extern vmCvar_t g_RQ3_tgren;	// JBravo: no. of team grenades
extern vmCvar_t g_RQ3_limchasecam;	// JBravo: 0 = no chasecam limit, 1 = limited to same team.
extern vmCvar_t g_RQ3_sniperup;	// JBravo: 0 = snipers begin with pistol, 1 = begin with sniper
extern vmCvar_t g_RQ3_team1name;	// JBravo: cvar for the name of team 1
extern vmCvar_t g_RQ3_team2name;	// JBravo: cvar for the name of team 2
extern vmCvar_t g_RQ3_team1model;	// JBravo: team 1 model and skin
extern vmCvar_t g_RQ3_team2model;	// JBravo: team 2 model and skin
extern vmCvar_t g_RQ3_tpcountdown;	// JBravo: to disable the pregame countdown
extern vmCvar_t g_RQ3_lca;	// JBravo: cvar to signal cgame that LCA is in progress
extern vmCvar_t g_RQ3_showOwnKills;	// JBravo: cvar to control if attaker sees his own obits and $K behavior
extern vmCvar_t g_RQ3_gib;	// JBravo: cvar for gib control
extern vmCvar_t g_RQ3_maxteamkills;	// JBravo: Max teamkills
extern vmCvar_t g_RQ3_twbanrounds;	// JBravo: no. of games team wounders are banned
extern vmCvar_t g_RQ3_tkbanrounds;	// JBravo: no. of games team killers are banned

//Slicer: Team Status Cvars for MM
//extern vmCvar_t       g_RQ3_team1ready;
//extern vmCvar_t       g_RQ3_team2ready;
//aasimon: Ref System for MM
extern vmCvar_t g_RQ3_AllowRef;
extern vmCvar_t g_RQ3_RefPass;
extern vmCvar_t g_RQ3_RefID;

// aasimon: ini stuff
extern vmCvar_t g_RQ3_IniFile;
extern vmCvar_t g_RQ3_ValidIniFile;
extern vmCvar_t g_RQ3_NextMapID;
extern vmCvar_t g_RQ3_NextMap;

//Slicer: Radio flood protect
extern vmCvar_t g_RQ3_radioRepeat;
extern vmCvar_t g_RQ3_radioRepeatTime;
extern vmCvar_t g_RQ3_radioBan;
extern vmCvar_t g_RQ3_radioFlood;
extern vmCvar_t g_RQ3_radioFloodTime;

void trap_Printf(const char *fmt);
void trap_Error(const char *fmt);
int trap_Milliseconds(void);
int trap_Argc(void);
void trap_Argv(int n, char *buffer, int bufferLength);
void trap_Args(char *buffer, int bufferLength);
int trap_FS_FOpenFile(const char *qpath, fileHandle_t * f, fsMode_t mode);
void trap_FS_Read(void *buffer, int len, fileHandle_t f);
void trap_FS_Write(const void *buffer, int len, fileHandle_t f);
void trap_FS_FCloseFile(fileHandle_t f);
int trap_FS_GetFileList(const char *path, const char *extension, char *listbuf, int bufsize);
void trap_SendConsoleCommand(int exec_when, const char *text);
void trap_Cvar_Register(vmCvar_t * cvar, const char *var_name, const char *value, int flags);
void trap_Cvar_Update(vmCvar_t * cvar);
void trap_Cvar_Set(const char *var_name, const char *value);
int trap_Cvar_VariableIntegerValue(const char *var_name);
float trap_Cvar_VariableValue(const char *var_name);
void trap_Cvar_VariableStringBuffer(const char *var_name, char *buffer, int bufsize);
void trap_LocateGameData(gentity_t * gEnts, int numGEntities, int sizeofGEntity_t, playerState_t * gameClients,
			 int sizeofGameClient);
void trap_DropClient(int clientNum, const char *reason);
void trap_SendServerCommand(int clientNum, const char *text);
void trap_SetConfigstring(int num, const char *string);
void trap_GetConfigstring(int num, char *buffer, int bufferSize);
void trap_GetUserinfo(int num, char *buffer, int bufferSize);
void trap_SetUserinfo(int num, const char *buffer);
void trap_GetServerinfo(char *buffer, int bufferSize);
void trap_SetBrushModel(gentity_t * ent, const char *name);
void trap_Trace(trace_t * results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end,
		int passEntityNum, int contentmask);
int trap_PointContents(const vec3_t point, int passEntityNum);
qboolean trap_InPVS(const vec3_t p1, const vec3_t p2);
qboolean trap_InPVSIgnorePortals(const vec3_t p1, const vec3_t p2);
void trap_AdjustAreaPortalState(gentity_t * ent, qboolean open);
qboolean trap_AreasConnected(int area1, int area2);
void trap_LinkEntity(gentity_t * ent);
void trap_UnlinkEntity(gentity_t * ent);
int trap_EntitiesInBox(const vec3_t mins, const vec3_t maxs, int *entityList, int maxcount);
qboolean trap_EntityContact(const vec3_t mins, const vec3_t maxs, const gentity_t * ent);
int trap_BotAllocateClient(void);
void trap_BotFreeClient(int clientNum);
void trap_GetUsercmd(int clientNum, usercmd_t * cmd);
qboolean trap_GetEntityToken(char *buffer, int bufferSize);

int trap_DebugPolygonCreate(int color, int numPoints, vec3_t * points);
void trap_DebugPolygonDelete(int id);

int trap_BotLibSetup(void);
int trap_BotLibShutdown(void);
int trap_BotLibVarSet(char *var_name, char *value);
int trap_BotLibVarGet(char *var_name, char *value, int size);
int trap_BotLibDefine(char *string);
int trap_BotLibStartFrame(float time);
int trap_BotLibLoadMap(const char *mapname);
int trap_BotLibUpdateEntity(int ent, void /* struct bot_updateentity_s */ *bue);
int trap_BotLibTest(int parm0, char *parm1, vec3_t parm2, vec3_t parm3);

int trap_BotGetSnapshotEntity(int clientNum, int sequence);
int trap_BotGetServerCommand(int clientNum, char *message, int size);
void trap_BotUserCommand(int client, usercmd_t * ucmd);

int trap_AAS_BBoxAreas(vec3_t absmins, vec3_t absmaxs, int *areas, int maxareas);
int trap_AAS_AreaInfo(int areanum, void /* struct aas_areainfo_s */ *info);
void trap_AAS_EntityInfo(int entnum, void /* struct aas_entityinfo_s */ *info);

int trap_AAS_Initialized(void);
void trap_AAS_PresenceTypeBoundingBox(int presencetype, vec3_t mins, vec3_t maxs);
float trap_AAS_Time(void);

int trap_AAS_PointAreaNum(vec3_t point);
int trap_AAS_PointReachabilityAreaIndex(vec3_t point);
int trap_AAS_TraceAreas(vec3_t start, vec3_t end, int *areas, vec3_t * points, int maxareas);

int trap_AAS_PointContents(vec3_t point);
int trap_AAS_NextBSPEntity(int ent);
int trap_AAS_ValueForBSPEpairKey(int ent, char *key, char *value, int size);
int trap_AAS_VectorForBSPEpairKey(int ent, char *key, vec3_t v);
int trap_AAS_FloatForBSPEpairKey(int ent, char *key, float *value);
int trap_AAS_IntForBSPEpairKey(int ent, char *key, int *value);

int trap_AAS_AreaReachability(int areanum);

int trap_AAS_AreaTravelTimeToGoalArea(int areanum, vec3_t origin, int goalareanum, int travelflags);
int trap_AAS_EnableRoutingArea(int areanum, int enable);
int trap_AAS_PredictRoute(void /*struct aas_predictroute_s */ *route, int areanum, vec3_t origin,
			  int goalareanum, int travelflags, int maxareas, int maxtime,
			  int stopevent, int stopcontents, int stoptfl, int stopareanum);

int trap_AAS_AlternativeRouteGoals(vec3_t start, int startareanum, vec3_t goal, int goalareanum, int travelflags,
				   void /*struct aas_altroutegoal_s */ *altroutegoals, int maxaltroutegoals,
				   int type);
int trap_AAS_Swimming(vec3_t origin);
int trap_AAS_PredictClientMovement(void /* aas_clientmove_s */ *move, int entnum, vec3_t origin, int presencetype,
				   int onground, vec3_t velocity, vec3_t cmdmove, int cmdframes, int maxframes,
				   float frametime, int stopevent, int stopareanum, int visualize);

void trap_EA_Say(int client, char *str);
void trap_EA_SayTeam(int client, char *str);
void trap_EA_Command(int client, char *command);

void trap_EA_Action(int client, int action);
void trap_EA_Gesture(int client);
void trap_EA_Talk(int client);
void trap_EA_Attack(int client);
void trap_EA_Use(int client);
void trap_EA_Respawn(int client);
void trap_EA_Crouch(int client);
void trap_EA_MoveUp(int client);
void trap_EA_MoveDown(int client);
void trap_EA_MoveForward(int client);
void trap_EA_MoveBack(int client);
void trap_EA_MoveLeft(int client);
void trap_EA_MoveRight(int client);
void trap_EA_SelectWeapon(int client, int weapon);
void trap_EA_Jump(int client);
void trap_EA_DelayedJump(int client);
void trap_EA_Move(int client, vec3_t dir, float speed);
void trap_EA_View(int client, vec3_t viewangles);

void trap_EA_EndRegular(int client, float thinktime);
void trap_EA_GetInput(int client, float thinktime, void /* struct bot_input_s */ *input);
void trap_EA_ResetInput(int client);

int trap_BotLoadCharacter(char *charfile, float skill);
void trap_BotFreeCharacter(int character);
float trap_Characteristic_Float(int character, int index);
float trap_Characteristic_BFloat(int character, int index, float min, float max);
int trap_Characteristic_Integer(int character, int index);
int trap_Characteristic_BInteger(int character, int index, int min, int max);
void trap_Characteristic_String(int character, int index, char *buf, int size);

int trap_BotAllocChatState(void);
void trap_BotFreeChatState(int handle);
void trap_BotQueueConsoleMessage(int chatstate, int type, char *message);
void trap_BotRemoveConsoleMessage(int chatstate, int handle);
int trap_BotNextConsoleMessage(int chatstate, void /* struct bot_consolemessage_s */ *cm);
int trap_BotNumConsoleMessages(int chatstate);
void trap_BotInitialChat(int chatstate, char *type, int mcontext, char *var0, char *var1, char *var2, char *var3,
			 char *var4, char *var5, char *var6, char *var7);
int trap_BotNumInitialChats(int chatstate, char *type);
int trap_BotReplyChat(int chatstate, char *message, int mcontext, int vcontext, char *var0, char *var1, char *var2,
		      char *var3, char *var4, char *var5, char *var6, char *var7);
int trap_BotChatLength(int chatstate);
void trap_BotEnterChat(int chatstate, int client, int sendto);
void trap_BotGetChatMessage(int chatstate, char *buf, int size);
int trap_StringContains(char *str1, char *str2, int casesensitive);
int trap_BotFindMatch(char *str, void /* struct bot_match_s */ *match, unsigned long int context);
void trap_BotMatchVariable(void /* struct bot_match_s */ *match, int variable, char *buf, int size);
void trap_UnifyWhiteSpaces(char *string);
void trap_BotReplaceSynonyms(char *string, unsigned long int context);
int trap_BotLoadChatFile(int chatstate, char *chatfile, char *chatname);
void trap_BotSetChatGender(int chatstate, int gender);
void trap_BotSetChatName(int chatstate, char *name, int client);
void trap_BotResetGoalState(int goalstate);
void trap_BotRemoveFromAvoidGoals(int goalstate, int number);
void trap_BotResetAvoidGoals(int goalstate);
void trap_BotPushGoal(int goalstate, void /* struct bot_goal_s */ *goal);
void trap_BotPopGoal(int goalstate);
void trap_BotEmptyGoalStack(int goalstate);
void trap_BotDumpAvoidGoals(int goalstate);
void trap_BotDumpGoalStack(int goalstate);
void trap_BotGoalName(int number, char *name, int size);
int trap_BotGetTopGoal(int goalstate, void /* struct bot_goal_s */ *goal);
int trap_BotGetSecondGoal(int goalstate, void /* struct bot_goal_s */ *goal);
int trap_BotChooseLTGItem(int goalstate, vec3_t origin, int *inventory, int travelflags);
int trap_BotChooseNBGItem(int goalstate, vec3_t origin, int *inventory, int travelflags,
			  void /* struct bot_goal_s */ *ltg, float maxtime);
int trap_BotTouchingGoal(vec3_t origin, void /* struct bot_goal_s */ *goal);
int trap_BotItemGoalInVisButNotVisible(int viewer, vec3_t eye, vec3_t viewangles, void /* struct bot_goal_s */ *goal);
int trap_BotGetNextCampSpotGoal(int num, void /* struct bot_goal_s */ *goal);
int trap_BotGetMapLocationGoal(char *name, void /* struct bot_goal_s */ *goal);
int trap_BotGetLevelItemGoal(int index, char *classname, void /* struct bot_goal_s */ *goal);
float trap_BotAvoidGoalTime(int goalstate, int number);
void trap_BotSetAvoidGoalTime(int goalstate, int number, float avoidtime);
void trap_BotInitLevelItems(void);
void trap_BotUpdateEntityItems(void);
int trap_BotLoadItemWeights(int goalstate, char *filename);
void trap_BotFreeItemWeights(int goalstate);
void trap_BotInterbreedGoalFuzzyLogic(int parent1, int parent2, int child);
void trap_BotSaveGoalFuzzyLogic(int goalstate, char *filename);
void trap_BotMutateGoalFuzzyLogic(int goalstate, float range);
int trap_BotAllocGoalState(int state);
void trap_BotFreeGoalState(int handle);

void trap_BotResetMoveState(int movestate);
void trap_BotMoveToGoal(void /* struct bot_moveresult_s */ *result, int movestate, void /* struct bot_goal_s */ *goal,
			int travelflags);
int trap_BotMoveInDirection(int movestate, vec3_t dir, float speed, int type);
void trap_BotResetAvoidReach(int movestate);
void trap_BotResetLastAvoidReach(int movestate);
int trap_BotReachabilityArea(vec3_t origin, int testground);
int trap_BotMovementViewTarget(int movestate, void /* struct bot_goal_s */ *goal, int travelflags, float lookahead,
			       vec3_t target);
int trap_BotPredictVisiblePosition(vec3_t origin, int areanum, void /* struct bot_goal_s */ *goal, int travelflags,
				   vec3_t target);
int trap_BotAllocMoveState(void);
void trap_BotFreeMoveState(int handle);
void trap_BotInitMoveState(int handle, void /* struct bot_initmove_s */ *initmove);
void trap_BotAddAvoidSpot(int movestate, vec3_t origin, float radius, int type);

int trap_BotChooseBestFightWeapon(int weaponstate, int *inventory);
void trap_BotGetWeaponInfo(int weaponstate, int weapon, void /* struct weaponinfo_s */ *weaponinfo);
int trap_BotLoadWeaponWeights(int weaponstate, char *filename);
int trap_BotAllocWeaponState(void);
void trap_BotFreeWeaponState(int weaponstate);
void trap_BotResetWeaponState(int weaponstate);

int trap_GeneticParentsAndChildSelection(int numranks, float *ranks, int *parent1, int *parent2, int *child);

void trap_SnapVector(float *v);

gentity_t *findradius(gentity_t * from, vec3_t org, float rad);	// Blaze: Find someone in a radius around you

//Slicer: MatchMode
#include "g_matchmode.h"