reaction/code/game/g_client.c
2013-07-21 23:15:13 +00:00

2067 lines
60 KiB
C

//-----------------------------------------------------------------------------
//
// $Id$
//
//-----------------------------------------------------------------------------
//
// $Log$
// Revision 1.135 2004/01/26 21:26:08 makro
// no message
//
// Revision 1.134 2003/04/26 22:33:06 jbravo
// Wratted all calls to G_FreeEnt() to avoid crashing and provide debugging
//
// Revision 1.133 2003/04/23 17:49:11 slicer
// Fixed Crash Bug caused by merging 1.32 source code
//
// Revision 1.132 2003/04/19 17:41:26 jbravo
// Applied changes that where in 1.29h -> 1.32b gamecode.
//
// Revision 1.131 2003/04/19 15:27:30 jbravo
// Backing out of most of unlagged. Only optimized prediction and smooth clients
// remains.
//
// Revision 1.130 2003/04/09 02:00:43 jbravo
// Fixed team none in DM and some final cleanups for the 3.0 release
//
// Revision 1.129 2003/04/02 22:23:51 jbravo
// More replacements tweaks. Added zcam_stfu
//
// Revision 1.128 2003/03/28 10:36:02 jbravo
// Tweaking the replacement system a bit. Reactionmale now the default model
//
// Revision 1.127 2003/03/22 20:29:26 jbravo
// wrapping linkent and unlinkent calls
//
// Revision 1.126 2003/03/10 07:07:58 jbravo
// Small unlagged fixes and voting delay added.
//
// Revision 1.125 2003/03/09 21:30:38 jbravo
// Adding unlagged. Still needs work.
//
// Revision 1.124 2003/02/27 03:58:35 jbravo
// Fixed the FF system after adding TDM broke it. Added color to error messages
//
// Revision 1.123 2002/11/17 20:14:15 jbravo
// Itembanning added
//
// Revision 1.122 2002/11/13 00:50:38 jbravo
// Fixed item dropping, specmode selection on death and helmet probs.
//
// Revision 1.121 2002/10/29 01:34:52 jbravo
// Added g_RQ3_tdmMode (0 = TP style, 1 = DM style) including UI support.
//
// Revision 1.120 2002/10/26 22:03:43 jbravo
// Made TeamDM work RQ3 style.
//
// Revision 1.119 2002/10/26 18:29:17 jbravo
// Added allweap and allitem funtionality.
//
// Revision 1.118 2002/10/21 21:00:39 slicer
// New MM features and bug fixes
//
// Revision 1.117 2002/09/29 16:06:44 jbravo
// Work done at the HPWorld expo
//
// Revision 1.116 2002/09/24 05:06:16 blaze
// fixed spectating so ref\'s can now use all the chasecam modes.
//
// Revision 1.115 2002/09/02 03:30:53 jbravo
// Hopefully fixed the skinhacking
//
// Revision 1.114 2002/08/30 01:09:06 jbravo
// Semi fixed the bodies thing in CTB
//
// Revision 1.113 2002/08/28 23:10:06 jbravo
// Added cg_RQ3_SuicideLikeARealMan, timestamping to server logs and
// fixed stats for non-TP modes.
//
// Revision 1.112 2002/08/23 14:25:05 slicer
// Added a new Referee System with multiple ref support
//
// Revision 1.111 2002/08/21 07:00:07 jbravo
// Added CTB respawn queue and fixed game <-> cgame synch problem in CTB
//
// Revision 1.110 2002/08/07 03:35:57 jbravo
// Added dynamic radio and stopped all radio usage during lca
//
// Revision 1.109 2002/07/26 22:28:38 jbravo
// Fixed the server about menu, made the UI handle illegal models and skins
// better.
//
// Revision 1.108 2002/07/26 06:21:43 jbravo
// Fixed the MM settings stuff so it works on remote servers also.
// Removed the MM_NAMES_COLOR since it broke on nicks with color in them.
//
// Revision 1.107 2002/07/16 04:09:14 niceass
// stupid team scoreboard fix
//
// Revision 1.106 2002/07/11 04:32:24 niceass
// misc CTB changes for joining a team or becoming a spectator on map load. Also team check before weapon equip
//
// Revision 1.105 2002/07/09 05:42:18 niceass
// small change to userinfo
//
// Revision 1.104 2002/07/02 03:41:59 jbravo
// Fixed a 2 frags pr kill bug, the use cmd now cancels weaponchanges in progress
// and fixed the captain status lingering on people after switching from MM
//
// Revision 1.103 2002/06/30 17:33:01 jbravo
// New radio sounds and the 0wned sound was added.
//
// Revision 1.102 2002/06/26 15:58:13 makro
// Fixed a crash bug in the spawning code
// (happenned on maps with one spawn point)
//
// Revision 1.101 2002/06/24 05:51:51 jbravo
// CTF mode is now semi working
//
// Revision 1.100 2002/06/23 23:32:29 jbravo
// Fixed logging of clients IP addresses.
//
// Revision 1.99 2002/06/21 11:55:32 freud
// Changed spawning system to move spawns up 9 pixels (q3 style)
//
// Revision 1.98 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.97 2002/06/19 18:18:09 jbravo
// Small cleanups for compiler warnings
//
// Revision 1.96 2002/06/19 18:13:57 jbravo
// New TNG spawning system :)
//
// Revision 1.95 2002/06/17 00:23:59 slicer
// Lasersight problem fixed
//
// 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 20:59:35 slicer
// Setting ( for real ) gender on DM
//
// Revision 1.91 2002/06/12 22:32:24 slicer
// Even better way to improve the Cvar Anti-Cheat System
//
// Revision 1.90 2002/06/12 15:29:53 slicer
// Improved and fixed the Anti-Cheat System
//
// Revision 1.89 2002/06/12 03:37:38 blaze
// some fixes for the add bot code
//
// Revision 1.88 2002/06/11 23:37:27 blaze
// moved the cheat cvars to be sent at a different time, should work better
//
// Revision 1.87 2002/06/11 01:43:08 blaze
// g_rq3_cvarfile allows you to change which file holds the restricted cvars
//
// Revision 1.86 2002/06/07 19:07:08 slicer
// removed cvars for teamXready, replaced by level.teamXready
//
// Revision 1.85 2002/06/05 22:09:21 niceass
// bot fix. NOT MY FAULT
//
// Revision 1.84 2002/06/04 08:25:44 niceass
// cgame team fix. (when you change your name, etc)
//
// Revision 1.83 2002/06/04 07:12:32 niceass
// spectators spawn where you are rather than at a spawnpoint
//
// Revision 1.82 2002/05/31 17:32:11 jbravo
// HC gibs almost working :)
//
// Revision 1.81 2002/05/28 04:46:12 niceass
// headless fix
//
// Revision 1.80 2002/05/28 01:17:01 jbravo
// More gib fixes. g_RQ3_gib added
//
// Revision 1.79 2002/05/27 06:50:01 niceass
// further spawning and removed kamakazi
//
// Revision 1.78 2002/05/25 16:31:18 blaze
// moved breakable stuff over to config strings
//
// Revision 1.77 2002/05/21 23:16:30 blaze
// Only send cheat vars on client connect instead of every spawn
//
// Revision 1.76 2002/05/20 04:59:33 jbravo
// Lots of small fixes.
//
// Revision 1.75 2002/05/19 21:27:28 blaze
// added force and buoyancy to breakables
//
// Revision 1.74 2002/05/13 07:29:14 jbravo
// Fixed server chrasing on incorrect models in TP and also added default skins
//
// Revision 1.73 2002/05/10 13:21:53 makro
// Mainly bot stuff. Also fixed a couple of crash bugs
//
// Revision 1.72 2002/05/05 15:51:16 slicer
// Captain and subs get saved on map_restarts ( moved to "sess" )
//
// Revision 1.71 2002/05/03 18:09:20 makro
// Bot stuff. Jump kicks
//
// Revision 1.70 2002/04/30 11:54:37 makro
// Bots rule ! Also, added clips to give all. Maybe some other things
//
// Revision 1.69 2002/04/30 01:23:05 jbravo
// Changed the server logging to be more like a normal AQ server. Cleaned
// all colors from the logs.
//
// Revision 1.68 2002/04/23 00:21:44 jbravo
// Cleanups of the new model code. Removed the spectator bar for zcam modes.
//
// Revision 1.67 2002/04/22 02:27:57 jbravo
// Dynamic model recognition
//
// Revision 1.66 2002/04/18 16:13:23 jbravo
// Scoreboard now shows green for live players and white for dead.
// Time should not get reset on deaths any more.
//
// Revision 1.65 2002/04/09 14:30:10 jbravo
// Made cg_thirdPerson a CVAR_ROM, Made bots understand team aliases (1 and 2) and
// made TP spawns more random.
//
// Revision 1.64 2002/04/07 17:50:54 makro
// Abbey
//
// Revision 1.63 2002/04/07 12:49:10 slicer
// Added 'teamname' command for MM, and tweaked the cvar system.
//
// Revision 1.62 2002/04/07 03:22:48 jbravo
// Tweaks and crashbug fixes
//
// Revision 1.61 2002/04/05 18:53:26 jbravo
// Warning fixes
//
// Revision 1.60 2002/04/03 03:13:16 blaze
// NEW BREAKABLE CODE - will break all old breakables(wont appear in maps)
//
// Revision 1.59 2002/04/02 20:23:12 jbravo
// Bots dont get to use any specmode other than FREE and the recive radio cmds
// as text and not sounds.
//
// Revision 1.58 2002/04/01 22:23:14 slicer
// Added "weapon" command buffering | Solved Gren Mode Bug
//
// Revision 1.57 2002/03/31 03:31:24 jbravo
// Compiler warning cleanups
//
// Revision 1.56 2002/03/30 21:51:42 jbravo
// Removed all those ifdefs for zcam.
//
// Revision 1.55 2002/03/30 02:29:43 jbravo
// Lots of spectator code updates. Removed debugshit, added some color.
//
// Revision 1.54 2002/03/26 11:32:04 jbravo
// Remember specstate between rounds.
//
// Revision 1.53 2002/03/26 10:32:52 jbravo
// Bye bye LCA lag
//
// Revision 1.52 2002/03/17 23:43:43 slicer
// Made Bots visible again at DM
//
// Revision 1.51 2002/03/17 02:03:48 jbravo
// Fixed a bug where a players laser would stay in the map after he disconnects
//
// Revision 1.50 2002/03/17 01:44:39 jbravo
// Fixed the "xxx died" fraglines, did some code cleanups andalmost fixed
// DM. Only DM problem I can see is that bots are invisible.
//
// Revision 1.49 2002/03/14 23:54:12 jbravo
// Added a variable system from AQ. Works the same except it uses $ for %
//
// Revision 1.48 2002/03/14 02:24:39 jbravo
// Adding radio :)
//
// Revision 1.47 2002/03/11 18:02:33 slicer
// Fixed team changes and scoreboard bugs
//
// Revision 1.46 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.45 2002/03/03 13:49:28 jbravo
// Initializing weapon modes on connect.
//
// Revision 1.44 2002/03/03 03:11:37 jbravo
// Use propper weapon anims on TP spawns
//
// Revision 1.43 2002/03/02 15:39:34 jbravo
// Fixed team auto (PickTeam) up for TP
//
// Revision 1.42 2002/03/02 14:54:24 jbravo
// Added the skin and model names to the name of the player thats being
// followed, as in AQ
//
// Revision 1.41 2002/03/01 18:21:26 jbravo
// Cleanups and removal of g_RQ3_sniperup
//
// Revision 1.40 2002/02/27 01:54:29 jbravo
// More spectatorfixes and finally stopped all fallingdamage anims and
// sounds during LCA.
//
// Revision 1.39 2002/02/26 21:59:10 jbravo
// Fixed death on switching teams while dead
//
// Revision 1.38 2002/02/26 02:58:47 jbravo
// Fixing the spectator_free mode not being predicted in the client.
//
// Revision 1.37 2002/02/10 21:21:22 slicer
// Saving persistant and other data on some events..
//
// Revision 1.36 2002/02/10 16:26:55 jbravo
// Attempting to intergrate zcam better into rq3 and a fix for lights.wav
//
// Revision 1.35 2002/02/07 23:01:07 slicer
// Small fix..
//
// Revision 1.34 2002/02/06 12:06:48 slicer
// TP Scores bug fix
//
// Revision 1.33 2002/02/06 03:10:43 jbravo
// Fix the instant spectate on death and an attempt to fix the scores
//
// Revision 1.32 2002/02/05 23:41:27 slicer
// More on matchmode..
//
// Revision 1.31 2002/02/04 00:10:49 slicer
// Matchmode: Teams Ready/Not Ready goes by cvar MM_team1/2
//
// Revision 1.28 2002/02/01 01:00:36 slicer
// Adding Matchmode: just a few basics and files...
//
// Revision 1.27 2002/01/27 13:33:28 jbravo
// Teamplay antistick system.
//
// Revision 1.26 2002/01/23 15:26:31 niceass
// body sinkage removed
// weapon reset fixed
//
// Revision 1.25 2002/01/11 20:20:58 jbravo
// Adding TP to main branch
//
// Revision 1.24 2002/01/11 19:48:30 jbravo
// Formatted the source in non DOS format.
//
// Revision 1.23 2001/12/31 16:28:42 jbravo
// I made a Booboo with the Log tag.
//
//
//-----------------------------------------------------------------------------
// Copyright (C) 1999-2000 Id Software, Inc.
//
#include "g_local.h"
#include "zcam.h"
// JBravo: fixme. Hack to use SelectInitialSpawnPoint() in ClientSpawn.
gentity_t *SelectInitialSpawnPoint(vec3_t origin, vec3_t angles);
//Blaze: for the breakables
breakable_t rq3_breakables[RQ3_MAX_BREAKABLES];
#define RQ3_NONAMEPLAYER "Nameless"
// JBravo: for models
extern legitmodel_t legitmodels[MAXMODELS];
int RQ3_Validatemodel(char *model);
extern char *settings[];
extern char *settings2[];
// g_client.c -- client functions that don't happen every frame
static vec3_t playerMins = { -15, -15, -24 };
static vec3_t playerMaxs = { 15, 15, 32 };
/*QUAKED info_player_deathmatch (1 0 1) (-16 -16 -24) (16 16 32) initial
potential spawning position for deathmatch games.
The first time a player enters the game, they will be at an 'initial' spot.
Targets will be fired when someone spawns in on them.
"nobots" will prevent bots from using this spot.
"nohumans" will prevent non-bots from using this spot.
*/
void SP_info_player_deathmatch(gentity_t * ent)
{
int i;
G_SpawnInt("nobots", "0", &i);
if (i) {
ent->flags |= FL_NO_BOTS;
}
G_SpawnInt("nohumans", "0", &i);
if (i) {
ent->flags |= FL_NO_HUMANS;
}
}
/*QUAKED info_player_start (1 0 0) (-16 -16 -24) (16 16 32)
equivelant to info_player_deathmatch
*/
void SP_info_player_start(gentity_t * ent)
{
ent->classname = "info_player_deathmatch";
SP_info_player_deathmatch(ent);
}
/*QUAKED info_player_intermission (1 0 1) (-16 -16 -24) (16 16 32)
The intermission will be viewed from this point. Target an info_notnull for the view direction.
*/
void SP_info_player_intermission(gentity_t * ent)
{
}
/*
=======================================================================
SelectSpawnPoint
=======================================================================
*/
/*
================
SpotWouldTelefrag
================
*/
qboolean SpotWouldTelefrag(gentity_t * spot)
{
int i, num;
int touch[MAX_GENTITIES];
gentity_t *hit;
vec3_t mins, maxs;
VectorAdd(spot->s.origin, playerMins, mins);
VectorAdd(spot->s.origin, playerMaxs, maxs);
num = trap_EntitiesInBox(mins, maxs, touch, MAX_GENTITIES);
for (i = 0; i < num; i++) {
//Blaze: Print out some Debug info
if (&g_entities[touch[i]] == NULL) G_Printf("Ln 0376\n");
hit = &g_entities[touch[i]];
if (hit->client) {
return qtrue;
}
}
return qfalse;
}
/*
================
SelectNearestDeathmatchSpawnPoint
Find the spot that we DON'T want to use
================
*/
// Moved to g_local.h
//#define MAX_SPAWN_POINTS 128
gentity_t *SelectNearestDeathmatchSpawnPoint(vec3_t from)
{
gentity_t *spot;
vec3_t delta;
float dist, nearestDist;
gentity_t *nearestSpot;
nearestDist = 999999;
nearestSpot = NULL;
spot = NULL;
while ((spot = G_Find(spot, FOFS(classname), "info_player_deathmatch")) != NULL) {
VectorSubtract(spot->s.origin, from, delta);
dist = VectorLength(delta);
if (dist < nearestDist) {
nearestDist = dist;
nearestSpot = spot;
}
}
return nearestSpot;
}
/*
================
SelectRandomDeathmatchSpawnPoint
go to a random point that doesn't telefrag
================
*/
// Moved to g_local.h
//#define MAX_SPAWN_POINTS 128
gentity_t *SelectRandomDeathmatchSpawnPoint(void)
{
gentity_t *spot;
int count;
int selection;
gentity_t *spots[MAX_SPAWN_POINTS];
count = 0;
spot = NULL;
while ((spot = G_Find(spot, FOFS(classname), "info_player_deathmatch")) != NULL) {
if (SpotWouldTelefrag(spot)) {
continue;
}
spots[count] = spot;
count++;
}
if (!count) { // no spots that won't telefrag
return G_Find(NULL, FOFS(classname), "info_player_deathmatch");
}
selection = rand() % count;
return spots[selection];
}
/*
===========
SelectRandomFurthestSpawnPoint
Chooses a player start, deathmatch start, etc
============
*/
gentity_t *SelectRandomFurthestSpawnPoint(vec3_t avoidPoint, vec3_t origin, vec3_t angles)
{
gentity_t *spot;
vec3_t delta;
float dist;
float list_dist[64];
gentity_t *list_spot[64];
int numSpots, rnd, i, j;
numSpots = 0;
spot = NULL;
while ((spot = G_Find(spot, FOFS(classname), "info_player_deathmatch")) != NULL) {
if (SpotWouldTelefrag(spot)) {
continue;
}
VectorSubtract(spot->s.origin, avoidPoint, delta);
dist = VectorLength(delta);
for (i = 0; i < numSpots; i++) {
if (dist > list_dist[i]) {
if (numSpots >= 64)
numSpots = 64 - 1;
for (j = numSpots; j > i; j--) {
list_dist[j] = list_dist[j - 1];
list_spot[j] = list_spot[j - 1];
}
list_dist[i] = dist;
list_spot[i] = spot;
numSpots++;
if (numSpots > 64)
numSpots = 64;
break;
}
}
if (i >= numSpots && numSpots < 64) {
list_dist[numSpots] = dist;
list_spot[numSpots] = spot;
numSpots++;
}
}
//Makro - on a map with one spawn point, if one player has to respawn and someone is
//already near the spawnpoint, Q3 crashes; added check
if (numSpots != 0) {
// select a random spot from the spawn points furthest away
rnd = random() * (numSpots / 3); // NiceAss: divided by 2 changed to 3 to cut down on close spawns
VectorCopy(list_spot[rnd]->s.origin, origin);
origin[2] += 9;
VectorCopy(list_spot[rnd]->s.angles, angles);
return list_spot[rnd];
} else {
//Makro - added; note - plenty of room for improvement here, I just wanted to get rid of the crash bug
spot = G_Find(NULL, FOFS(classname), "info_player_deathmatch");
if (!spot) {
G_Error("Couldn't find a spawn point");
}
VectorCopy(spot->s.origin, origin);
origin[2] += 9;
VectorCopy(spot->s.angles, angles);
return spot;
}
}
/*
===========
SelectSpawnPoint
Chooses a player start, deathmatch start, etc
============
*/
gentity_t *SelectSpawnPoint(vec3_t avoidPoint, vec3_t origin, vec3_t angles)
{
return SelectRandomFurthestSpawnPoint(avoidPoint, origin, angles);
}
/*
===========
SelectInitialSpawnPoint
Try to find a spawn point marked 'initial', otherwise
use normal spawn selection.
============
*/
gentity_t *SelectInitialSpawnPoint(vec3_t origin, vec3_t angles)
{
gentity_t *spot;
spot = NULL;
while ((spot = G_Find(spot, FOFS(classname), "info_player_deathmatch")) != NULL) {
if (spot->spawnflags & 1) {
break;
}
}
if (!spot || SpotWouldTelefrag(spot)) {
return SelectSpawnPoint(vec3_origin, origin, angles);
}
VectorCopy(spot->s.origin, origin);
origin[2] += 9;
VectorCopy(spot->s.angles, angles);
return spot;
}
/*
===========
SelectSpectatorSpawnPoint
============
*/
gentity_t *SelectSpectatorSpawnPoint(vec3_t origin, vec3_t angles)
{
FindIntermissionPoint();
VectorCopy(level.intermission_origin, origin);
VectorCopy(level.intermission_angle, angles);
return NULL;
}
/*
=======================================================================
BODYQUE
=======================================================================
*/
/*
===============
InitBodyQue
===============
*/
void InitBodyQue(void)
{
int i;
gentity_t *ent;
level.bodyQueIndex = 0;
for (i = 0; i < BODY_QUEUE_SIZE; i++) {
ent = G_Spawn();
ent->classname = "bodyque";
ent->neverFree = qtrue;
level.bodyQue[i] = ent;
}
}
/*
===============
ClearBodyQue - By NiceAss
===============
*/
void ClearBodyQue(void)
{
int i;
gentity_t *ent;
level.bodyQueIndex = 0;
for (i = 0; i < BODY_QUEUE_SIZE; i++) {
ent = level.bodyQue[i];
trap_UnlinkEntity(ent);
ent->physicsObject = qfalse;
}
}
/*
=============
BodySink
After sitting around for five seconds, fall into the ground and dissapear
=============
*/
void BodySink(gentity_t * ent)
{
// NiceAss: Prevent body sink in TP. Bodies will be removed at before LCA
if (g_gametype.integer == GT_TEAMPLAY)
return;
if (level.time - ent->timestamp > 6500) {
// the body ques are never actually freed, they are just unlinked
trap_UnlinkEntity(ent);
ent->physicsObject = qfalse;
return;
}
ent->nextthink = level.time + 100;
ent->s.pos.trBase[2] -= 1;
}
/*
=============
CopyToBodyQue
A player is respawning, so make an entity that looks
just like the existing corpse to leave behind.
=============
*/
void CopyToBodyQue(gentity_t * ent)
{
gentity_t *body;
int contents;
trap_UnlinkEntity(ent);
// if client is in a nodrop area, don't leave the body
contents = trap_PointContents(ent->s.origin, -1);
if (contents & CONTENTS_NODROP) {
return;
}
// grab a body que and cycle to the next one
body = level.bodyQue[level.bodyQueIndex];
level.bodyQueIndex = (level.bodyQueIndex + 1) % BODY_QUEUE_SIZE;
trap_UnlinkEntity(body);
body->s = ent->s;
// clear EF_TALK, etc
if (body->s.eFlags & EF_HEADLESS)
body->s.eFlags = EF_DEAD | EF_HEADLESS;
else
body->s.eFlags = EF_DEAD;
body->s.powerups = 0; // clear powerups
body->s.loopSound = 0; // clear lava burning
body->s.number = body - g_entities;
body->timestamp = level.time;
body->physicsObject = qtrue;
body->physicsBounce = 0; // don't bounce
if (body->s.groundEntityNum == ENTITYNUM_NONE) {
body->s.pos.trType = TR_GRAVITY;
body->s.pos.trTime = level.time;
VectorCopy(ent->client->ps.velocity, body->s.pos.trDelta);
} else {
body->s.pos.trType = TR_STATIONARY;
}
body->s.event = 0;
// change the animation to the last-frame only, so the sequence
// doesn't repeat anew for the body
switch (body->s.legsAnim & ~ANIM_TOGGLEBIT) {
case BOTH_DEATH1:
case BOTH_DEAD1:
body->s.torsoAnim = body->s.legsAnim = BOTH_DEAD1;
break;
case BOTH_DEATH2:
case BOTH_DEAD2:
body->s.torsoAnim = body->s.legsAnim = BOTH_DEAD2;
break;
case BOTH_DEATH3:
case BOTH_DEAD3:
default:
body->s.torsoAnim = body->s.legsAnim = BOTH_DEAD3;
break;
}
body->r.svFlags = ent->r.svFlags;
VectorCopy(ent->r.mins, body->r.mins);
VectorCopy(ent->r.maxs, body->r.maxs);
VectorCopy(ent->r.absmin, body->r.absmin);
VectorCopy(ent->r.absmax, body->r.absmax);
body->clipmask = CONTENTS_SOLID | CONTENTS_PLAYERCLIP;
body->r.contents = CONTENTS_CORPSE;
body->r.ownerNum = ent->s.number;
body->nextthink = level.time + 5000;
// NiceAss: Prevent sinkage of the body in TP
body->think = BodySink;
body->die = body_die;
// don't take more damage if already gibbed
if (ent->health <= GIB_HEALTH) {
body->takedamage = qfalse;
} else {
body->takedamage = qtrue;
}
VectorCopy(body->s.pos.trBase, body->r.currentOrigin);
trap_LinkEntity(body);
}
//======================================================================
/*
==================
SetClientViewAngle
==================
*/
void SetClientViewAngle(gentity_t * ent, vec3_t angle)
{
int i;
// set the delta angle
for (i = 0; i < 3; i++) {
int cmdAngle;
cmdAngle = ANGLE2SHORT(angle[i]);
ent->client->ps.delta_angles[i] = cmdAngle - ent->client->pers.cmd.angles[i];
}
VectorCopy(angle, ent->s.angles);
VectorCopy(ent->s.angles, ent->client->ps.viewangles);
}
/*
================
respawn
================
*/
void respawn(gentity_t * ent)
{
CopyToBodyQue(ent);
ClientSpawn(ent);
}
/*
================
TeamCount
Returns number of players on a team
================
*/
int TeamCount(int ignoreClientNum, int team)
{
int i;
int count = 0;
for (i = 0; i < level.maxclients; i++) {
if (i == ignoreClientNum) {
continue;
}
if (level.clients[i].pers.connected == CON_DISCONNECTED) {
continue;
}
if (level.clients[i].sess.sessionTeam == team) {
count++;
}
}
return count;
}
/*
================
TeamLeader
Returns the client number of the team leader
================
*/
int TeamLeader(int team)
{
int i;
for (i = 0; i < level.maxclients; i++) {
if (level.clients[i].pers.connected == CON_DISCONNECTED) {
continue;
}
if (level.clients[i].sess.sessionTeam == team) {
if (level.clients[i].sess.teamLeader)
return i;
}
}
return -1;
}
/*
================
PickTeam
================
*/
team_t PickTeam(int ignoreClientNum)
{
int counts[TEAM_NUM_TEAMS];
if (g_gametype.integer >= GT_TEAM) {
counts[TEAM_BLUE] = RQ3TeamCount(ignoreClientNum, TEAM_BLUE);
counts[TEAM_RED] = RQ3TeamCount(ignoreClientNum, TEAM_RED);
} else {
counts[TEAM_BLUE] = TeamCount(ignoreClientNum, TEAM_BLUE);
counts[TEAM_RED] = TeamCount(ignoreClientNum, TEAM_RED);
}
if (counts[TEAM_BLUE] > counts[TEAM_RED]) {
return TEAM_RED;
}
if (counts[TEAM_RED] > counts[TEAM_BLUE]) {
return TEAM_BLUE;
}
// equal team count, so join the team with the lowest score
if (level.teamScores[TEAM_BLUE] > level.teamScores[TEAM_RED]) {
return TEAM_RED;
}
return TEAM_BLUE;
}
/*
===========
ClientCheckName
============
*/
static void ClientCleanName(const char *in, char *out, int outSize)
{
int outpos = 0, colorlessLen = 0, spaces = 0;
// discard leading spaces
for (; *in == ' '; in++);
for (; *in && outpos < outSize - 1; in++) {
out[outpos] = *in;
if (*in == ' ') {
// don't allow too many consecutive spaces
if (spaces > 2)
continue;
spaces++;
} else if (outpos > 0 && out[outpos - 1] == Q_COLOR_ESCAPE) {
if (Q_IsColorString(&out[outpos - 1])) {
colorlessLen--;
if (ColorIndex(*in) == 0) {
// Disallow color black in names to prevent players
// from getting advantage playing in front of black backgrounds
outpos--;
continue;
}
} else {
spaces = 0;
colorlessLen++;
}
} else {
spaces = 0;
colorlessLen++;
}
outpos++;
}
out[outpos] = '\0';
// don't allow empty names
if( *out == '\0' || colorlessLen == 0)
Q_strncpyz(out, RQ3_NONAMEPLAYER, outSize);
}
/*
===========
ClientUserInfoChanged
Called from ClientConnect when the player first connects and
directly by the server system when the player updates a userinfo variable.
The game can override any of the settings and call trap_SetUserinfo
if desired.
============
*/
void ClientUserinfoChanged(int clientNum)
{
gentity_t *ent;
gclient_t *client;
int teamTask, teamLeader, team, health, gender;
char *s, model[MAX_QPATH], headModel[MAX_QPATH], oldname[MAX_STRING_CHARS];
char c1[MAX_INFO_STRING], c2[MAX_INFO_STRING], redTeam[MAX_INFO_STRING];
char blueTeam[MAX_INFO_STRING], userinfo[MAX_INFO_STRING];
char *skin2, model2[MAX_STRING_CHARS];
ent = g_entities + clientNum;
client = ent->client;
trap_GetUserinfo(clientNum, userinfo, sizeof(userinfo));
// check for malformed or illegal info strings
if (!Info_Validate(userinfo)) {
strcpy(userinfo, "\\name\\badinfo");
// don't keep those clients and userinfo
trap_DropClient(clientNum, "Invalid userinfo");
}
// check for local client
s = Info_ValueForKey(userinfo, "ip");
if (!strcmp(s, "localhost")) {
client->pers.localClient = qtrue;
}
// check the item prediction
s = Info_ValueForKey(userinfo, "cg_predictItems");
if (!atoi(s)) {
client->pers.predictItemPickup = qfalse;
} else {
client->pers.predictItemPickup = qtrue;
}
// JBravo: unlagged
s = Info_ValueForKey(userinfo, "cg_delag");
if (!atoi(s)) {
client->pers.delag = 0;
} else {
client->pers.delag = atoi(s);
}
// set name
Q_strncpyz(oldname, client->pers.netname, sizeof(oldname));
s = Info_ValueForKey(userinfo, "name");
ClientCleanName(s, client->pers.netname, sizeof(client->pers.netname));
if (client->sess.sessionTeam == TEAM_SPECTATOR) {
if (client->sess.spectatorState == SPECTATOR_SCOREBOARD) {
Q_strncpyz(client->pers.netname, "scoreboard", sizeof(client->pers.netname));
}
}
if (client->pers.connected == CON_CONNECTED) {
if (strcmp(oldname, client->pers.netname)) {
trap_SendServerCommand(-1, va("print \"%s" S_COLOR_WHITE " renamed to %s\n\"", oldname,
client->pers.netname));
}
}
// set max health
health = atoi(Info_ValueForKey(userinfo, "handicap"));
client->pers.maxHealth = health;
if (client->pers.maxHealth < 1 || client->pers.maxHealth > 100) {
client->pers.maxHealth = 100;
}
// set model
if (g_gametype.integer >= GT_TEAM) {
Q_strncpyz(model, Info_ValueForKey(userinfo, "team_model"), sizeof(model));
Q_strncpyz(headModel, Info_ValueForKey(userinfo, "team_headmodel"), sizeof(headModel));
} else {
Q_strncpyz(model, Info_ValueForKey(userinfo, "model"), sizeof(model));
Q_strncpyz(headModel, Info_ValueForKey(userinfo, "headmodel"), sizeof(headModel));
}
// JBravo: set the radiosoundset
s = Info_ValueForKey(userinfo, "cg_RQ3_radiovoice_male");
if (!atoi(s)) {
client->radioSetMale = 0;
} else {
client->radioSetMale = atoi(s);
}
s = Info_ValueForKey(userinfo, "cg_RQ3_radiovoice_female");
if (!atoi(s)) {
client->radioSetFemale = 0;
} else {
client->radioSetFemale = atoi(s);
}
// JBravo: Does the client get a frag reduced on suicides or not.
s = Info_ValueForKey(userinfo, "cg_RQ3_SuicideLikeARealMan");
if (!atoi(s)) {
client->SuicideLikeARealMan = 0;
} else {
client->SuicideLikeARealMan = atoi(s);
}
// JBravo: to silence zcam messages
s = Info_ValueForKey(userinfo, "cg_RQ3_zcam_stfu");
if (!atoi(s)) {
client->zcam_stfu = 0;
} else {
client->zcam_stfu = atoi(s);
}
if (g_gametype.integer >= GT_TEAM) {
if (client->sess.savedTeam == TEAM_RED) {
Q_strncpyz(model2, g_RQ3_team1model.string, sizeof(model));
skin2 = strrchr(model2, '/');
if (skin2) {
*skin2++ = '\0';
} else {
skin2 = "robbers";
}
if (RQ3_Validatemodel(model2) != -1) {
Com_sprintf(model, sizeof(model), "%s/%s", model2, skin2);
Com_sprintf(headModel, sizeof(headModel), "%s/%s", model2, skin2);
} else {
Com_sprintf(model, sizeof(model), "reactionmale/robbers");
Com_sprintf(headModel, sizeof(headModel), "reactionmale/robbers");
}
} else {
Q_strncpyz(model2, g_RQ3_team2model.string, sizeof(model));
skin2 = strrchr(model2, '/');
if (skin2) {
*skin2++ = '\0';
} else {
skin2 = "cops";
}
if (RQ3_Validatemodel(model2) != -1) {
Com_sprintf(model, sizeof(model), "%s/%s", model2, skin2);
Com_sprintf(headModel, sizeof(headModel), "%s/%s", model2, skin2);
} else {
Com_sprintf(model, sizeof(model), "reactionmale/cops");
Com_sprintf(headModel, sizeof(headModel), "reactionmale/cops");
}
}
} else {
Q_strncpyz(model2, model, sizeof(model));
skin2 = strrchr(model2, '/');
if (skin2) {
*skin2++ = '\0';
} else {
skin2 = "default";
}
// JBravo: Validating the model
gender = RQ3_Validatemodel(model2);
if (gender == -1) {
trap_SendServerCommand(ent - g_entities,
va("print \"^1Illegal player model (%s). Forcing change on server.\n\"",
model2));
Q_strncpyz(model, "reactionmale/default", sizeof("reactionmale/default"));
Q_strncpyz(headModel, "reactionmale/default", sizeof("reactionmale/default"));
client->radioGender = 0; // Male
} else if (gender != GENDER_NEUTER)
client->radioGender = gender;
}
// bots set their team a few frames later
if (g_gametype.integer >= GT_TEAM && g_entities[clientNum].r.svFlags & SVF_BOT) {
s = Info_ValueForKey(userinfo, "team");
if (!Q_stricmp(s, "red") || !Q_stricmp(s, "r") || !Q_stricmp(s, "1")) {
team = TEAM_RED;
} else if (!Q_stricmp(s, "blue") || !Q_stricmp(s, "b") || !Q_stricmp(s, "2")) {
team = TEAM_BLUE;
} else {
// pick the team with the least number of players
team = PickTeam(clientNum);
}
} else {
team = client->sess.sessionTeam;
}
// teamInfo
s = Info_ValueForKey(userinfo, "teamoverlay");
if (!*s || atoi(s) != 0) {
client->pers.teamInfo = qtrue;
} else {
client->pers.teamInfo = qfalse;
}
// team task (0 = none, 1 = offence, 2 = defence)
teamTask = atoi(Info_ValueForKey(userinfo, "teamtask"));
// team Leader (1 = leader, 0 is normal player)
teamLeader = client->sess.teamLeader;
// colors
strcpy(c1, Info_ValueForKey(userinfo, "color1"));
strcpy(c2, Info_ValueForKey(userinfo, "color2"));
strcpy(redTeam, Info_ValueForKey(userinfo, "g_redteam"));
strcpy(blueTeam, Info_ValueForKey(userinfo, "g_blueteam"));
// send over a subset of the userinfo keys so other clients can
// print scoreboards, display models, and play custom sounds
if (ent->r.svFlags & SVF_BOT) {
//Makro - adding teamplay weapon/item info for bots
s = va
("n\\%s\\t\\%i\\model\\%s\\hmodel\\%s\\c1\\%s\\c2\\%s\\hc\\%i\\w\\%i\\l\\%i\\skill\\%s\\tt\\%d\\tl\\%d\\tpw\\%s\\tpi\\%s",
client->pers.netname, team, model, headModel, c1, c2, client->pers.maxHealth, client->sess.wins,
client->sess.losses,
//Info_ValueForKey( userinfo, "skill" ), teamTask, teamLeader );
Info_ValueForKey(userinfo, "skill"), teamTask, teamLeader, Info_ValueForKey(userinfo, "tpw"),
Info_ValueForKey(userinfo, "tpi"));
} else {
s = va
("n\\%s\\t\\%i\\model\\%s\\hmodel\\%s\\g_redteam\\%s\\g_blueteam\\%s\\c1\\%s\\c2\\%s\\hc\\%i\\w\\%i\\l\\%i\\tt\\%d\\tl\\%d",
client->pers.netname, client->sess.savedTeam, model, headModel, redTeam, blueTeam, c1, c2,
client->pers.maxHealth, client->sess.wins, client->sess.losses, teamTask, teamLeader);
}
trap_SetConfigstring(CS_PLAYERS + clientNum, s);
// this is not the userinfo, more like the configstring actually
// JBravo: ugly in the logs. Enable to debug if necessary
// G_LogPrintf( "ClientUserinfoChanged: %i %s\n", clientNum, s );
}
/*
===========
G_SendCheatVars(int)
Send which cvars are cheats, and the acceptable values
===========
*/
int G_SendCheatVars(int clientNum)
{
char *text_p;
int len;
int i;
char *token;
char text[20000];
fileHandle_t f;
char cheatVar[40], cl_cheatvar[128];
float lowval, highval;
//NiceAss: Added so /devmap will not have the client check cvars. Lie to the server that it loaded fine =)
if (g_cheats.integer)
return qtrue;
// load the file
len = trap_FS_FOpenFile(g_RQ3_cvarfile.string, &f, FS_READ);
if (len <= 0) {
return qfalse;
}
if (len >= sizeof(text) - 1) {
G_Printf("File %s too long\n", g_RQ3_cvarfile.string);
return qfalse;
}
trap_FS_Read(text, len, f);
text[len] = 0;
trap_FS_FCloseFile(f);
// parse the text
text_p = text;
for (i = 0; i < 30; i++) {
token = COM_Parse(&text_p);
if (!token)
break;
if (strlen(token) >= 40) {
Com_Printf("Cheatvar %s is too long\n", token);
return qfalse;
}
Q_strncpyz(cheatVar, token, sizeof(cheatVar));
// Fix from hal9000. Was NULL in that strcmp
if (!strcmp(token, ""))
return qtrue;
token = COM_Parse(&text_p);
if (!token)
break;
lowval = atof(token);
token = COM_Parse(&text_p);
if (!token)
break;
highval = atof(token);
Com_sprintf(cl_cheatvar, sizeof(cl_cheatvar), "addCheatVar %s %f %f\n", cheatVar, lowval, highval);
//Com_Printf("%s", cl_cheatvar);
trap_SendServerCommand(clientNum, va("%s", cl_cheatvar));
}
return qtrue;
}
/*
===========
ClientConnect
Called when a player begins connecting to the server.
Called again for every map change or tournement restart.
The session information will be valid after exit.
Return NULL if the client should be allowed, otherwise return
a string with the reason for denial.
Otherwise, the client will be sent the current gamestate
and will eventually get to ClientBegin.
firstTime will be qtrue the very first time a client connects
to the server machine, but qfalse on map changes and tournement
restarts.
============
*/
char *ClientConnect(int clientNum, qboolean firstTime, qboolean isBot)
{
char *value;
gclient_t *client;
char userinfo[MAX_INFO_STRING], ipaddr[64];
gentity_t *ent;
ent = &g_entities[clientNum];
trap_GetUserinfo(clientNum, userinfo, sizeof(userinfo));
// IP filtering
// https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=500
// recommanding PB based IP / GUID banning, the builtin system is pretty limited
// check to see if they are on the banned IP list
value = Info_ValueForKey(userinfo, "ip");
strncpy(ipaddr, value, sizeof(ipaddr));
if (G_FilterPacket(value)) {
return "You are banned from this server..";
}
// we don't check password for bots and local client
// NOTE: local client <-> "ip" "localhost"
// this means this client is not running in our current process
if ( !isBot && (strcmp(value, "localhost") != 0)) {
// check for a password
value = Info_ValueForKey(userinfo, "password");
if (g_password.string[0] && Q_stricmp(g_password.string, "none") &&
strcmp(g_password.string, value) != 0) {
return "Invalid password";
}
}
// if a player reconnects quickly after a disconnect, the client disconnect may never be called, thus flag can get lost in the ether
if (ent->inuse) {
G_LogPrintf("Forcing disconnect on active client: %i\n", clientNum);
// so lets just fix up anything that should happen on a disconnect
ClientDisconnect(clientNum);
}
// they can connect
ent->client = level.clients + clientNum;
client = ent->client;
memset(client, 0, sizeof(*client));
client->pers.connected = CON_CONNECTING;
// JBravo: Antistick
client->ps.stats[STAT_RQ3] &= ~RQ3_PLAYERSOLID;
// JBravo: Clear zcam flag for cgame
client->ps.stats[STAT_RQ3] &= ~RQ3_ZCAM;
// read or initialize the session data
if (firstTime || level.newSession) {
G_InitSessionData(client, userinfo);
}
G_ReadSessionData(client);
if (isBot) {
ent->r.svFlags |= SVF_BOT;
ent->inuse = qtrue;
if (!G_BotConnect(clientNum, !firstTime)) {
return "BotConnectfailed";
}
}
// slicer : make sessionTeam = to savedTeam for scoreboard on cgame
// JBravo: only for teambased games. Could break DM
if (g_gametype.integer >= GT_TEAM) {
client->sess.sessionTeam = client->sess.savedTeam;
ClientUserinfoChanged(clientNum);
} else
ClientUserinfoChanged(clientNum);
// don't do the "xxx connected" messages if they were caried over from previous level
if (firstTime) {
trap_SendServerCommand(-1, va("print \"%s" S_COLOR_WHITE " connected\n\"", client->pers.netname));
G_LogPrintf("%s@%s connected (clientNum %i)\n", client->pers.netname, ipaddr, clientNum);
}
if (g_gametype.integer >= GT_TEAM && g_gametype.integer != GT_TEAMPLAY && g_gametype.integer != GT_CTF &&
client->sess.sessionTeam != TEAM_SPECTATOR) {
BroadcastTeamChange(client, -1);
}
// count current clients and rank for scoreboard
CalculateRanks();
// JBravo: clients in TP begin as spectators
if (g_gametype.integer >= GT_TEAM) {
client->sess.sessionTeam = TEAM_SPECTATOR;
client->ps.persistant[PERS_TEAM] = TEAM_SPECTATOR;
client->sess.spectatorState = SPECTATOR_FREE;
client->specMode = SPECTATOR_FREE;
client->ps.pm_flags &= ~PMF_FOLLOW;
client->ps.stats[STAT_RQ3] &= ~RQ3_ZCAM;
camera_begin(ent);
client->camera->mode = CAMERA_MODE_SWING;
} else {
client->ps.stats[STAT_RQ3] &= ~RQ3_ZCAM;
camera_begin(ent);
client->camera->mode = CAMERA_MODE_SWING;
}
// JBravo: moved from ClientBegin
client->pers.enterTime = level.time;
// JBravo: ditto
if (g_gametype.integer == GT_FFA) {
client->sess.sessionTeam = TEAM_FREE;
client->sess.savedTeam = TEAM_FREE;
client->ps.persistant[PERS_TEAM] = TEAM_FREE;
client->sess.spectatorState = SPECTATOR_NOT;
client->specMode = SPECTATOR_NOT;
}
return NULL;
}
/*
===========
ClientBegin
called when a client has finished connecting, and is ready
to be placed into the level. This will happen every level load,
and on transition between teams, but doesn't happen on respawns
============
*/
void ClientBegin(int clientNum)
{
gentity_t *ent;
gclient_t *client;
int flags, savedPing = 0, i;
int savedPers[MAX_PERSISTANT];
char str[256];
ent = g_entities + clientNum;
client = level.clients + clientNum;
if (ent->r.linked) {
trap_UnlinkEntity(ent);
}
G_InitGentity(ent);
ent->touch = 0;
ent->pain = 0;
ent->client = client;
//Slicer: Saving persistant and ping
if (g_gametype.integer >= GT_TEAM) {
savedPing = client->ps.ping;
for (i = 0; i < MAX_PERSISTANT; i++)
savedPers[i] = client->ps.persistant[i];
}
client->pers.connected = CON_CONNECTED;
client->pers.teamState.state = TEAM_BEGIN;
// save eflags around this, because changing teams will
// cause this to happen with a valid entity, and we
// want to make sure the teleport bit is set right
// so the viewpoint doesn't interpolate through the
// world to the new position
flags = client->ps.eFlags;
memset(&client->ps, 0, sizeof(client->ps));
client->ps.eFlags = flags;
//Slicer: Repost score and ping
if (g_gametype.integer >= GT_TEAM) {
client->ps.ping = savedPing;
for (i = 0; i < MAX_PERSISTANT; i++)
client->ps.persistant[i] = savedPers[i];
}
// locate ent at a spawn point
ClientSpawn(ent);
// JBravo: if teamplay and the client has not been on teams, make them a spectator.
if ((g_gametype.integer >= GT_TEAM) &&
client->sess.sessionTeam != TEAM_RED && client->sess.sessionTeam != TEAM_BLUE) {
client->sess.sessionTeam = TEAM_SPECTATOR;
client->ps.persistant[PERS_SAVEDTEAM] = TEAM_SPECTATOR;
client->ps.persistant[PERS_TEAM] = TEAM_SPECTATOR;
client->sess.spectatorState = SPECTATOR_FREE;
client->specMode = SPECTATOR_FREE;
client->ps.pm_flags &= ~PMF_FOLLOW;
client->ps.stats[STAT_RQ3] &= ~RQ3_ZCAM;
RQ3_SpectatorMode(ent);
// JBravo: Set grenades to short, and the other weapons to full automatic on connect.
client->ps.persistant[PERS_WEAPONMODES] |= RQ3_GRENSHORT;
client->ps.persistant[PERS_WEAPONMODES] &= ~RQ3_GRENMED;
client->ps.persistant[PERS_WEAPONMODES] |= RQ3_KNIFEMODE;
client->ps.persistant[PERS_WEAPONMODES] &= ~RQ3_MP5MODE;
client->ps.persistant[PERS_WEAPONMODES] &= ~RQ3_M4MODE;
client->ps.persistant[PERS_WEAPONMODES] &= ~RQ3_MK23MODE;
client->camera->mode = CAMERA_MODE_SWING;
}
// JBravo: moved this up to clientconnect so DM players can join the spectator team.
/* if (g_gametype.integer == GT_FFA) {
client->sess.sessionTeam = TEAM_FREE;
client->ps.persistant[PERS_TEAM] = TEAM_FREE;
client->sess.spectatorState = SPECTATOR_NOT;
client->specMode = SPECTATOR_NOT;
} */
if (client->sess.sessionTeam != TEAM_SPECTATOR && g_gametype.integer != GT_TEAMPLAY) {
client->ps.persistant[PERS_WEAPONMODES] |= RQ3_GRENSHORT; //set to short range
client->ps.persistant[PERS_WEAPONMODES] |= RQ3_KNIFEMODE; //set to slash attack
if (g_gametype.integer != GT_TOURNAMENT) {
trap_SendServerCommand(-1,
va("print \"%s" S_COLOR_WHITE " entered the game\n\"",
client->pers.netname));
}
}
G_LogPrintf("ClientBegin: %i\n", clientNum);
// JBravo: synching the cvars over to clients for the MM ingame menu.
if ((g_gametype.integer >= GT_TEAM) && g_RQ3_matchmode.integer) {
for (i = 0; i < 9; ++i) {
trap_SendServerCommand(ent - g_entities, va("rq3_cmd %i %s %i", CVARSET, settings2[i],
trap_Cvar_VariableIntegerValue(settings[i])));
}
trap_SendServerCommand(ent - g_entities, va("rq3_cmd %i cg_RQ3_capturelimit %i", CVARSET,
trap_Cvar_VariableIntegerValue("capturelimit")));
}
// JBravo: setting cvars for the about menu
trap_Cvar_VariableStringBuffer("sv_hostname", str, sizeof(str));
trap_SendServerCommand(ent - g_entities, va("rq3_cmd %i cg_RQ3_hostname %s", CVARSET, str));
trap_SendServerCommand(ent - g_entities, va("rq3_cmd %i cg_RQ3_needpass %i", CVARSET, g_needpass.integer));
trap_SendServerCommand(ent - g_entities, va("rq3_cmd %i cg_RQ3_dmflags %i", CVARSET, g_dmflags.integer));
trap_SendServerCommand(ent - g_entities, va("rq3_cmd %i cg_RQ3_showOwnKills %i", CVARSET, g_RQ3_showOwnKills.integer));
trap_SendServerCommand(ent - g_entities, va("rq3_cmd %i cg_RQ3_timelimit %i", CVARSET, g_timelimit.integer));
trap_SendServerCommand(ent - g_entities, va("rq3_cmd %i cg_RQ3_fraglimit %i", CVARSET, g_fraglimit.integer));
trap_SendServerCommand(ent - g_entities, va("rq3_cmd %i cg_RQ3_bot_minplayers %i", CVARSET,
trap_Cvar_VariableIntegerValue("bot_minplayers")));
// count current clients and rank for scoreboard
CalculateRanks();
// JBravo: default weapons
if (g_gametype.integer >= GT_TEAM) {
// NiceAss: Only set it if there is no value. Fix for going into spectator resetting values.
if (ent->r.svFlags & SVF_BOT) {
//Makro - changed to m4/laser from pistol/kevlar
if (!client->teamplayWeapon) {
if ((int) g_RQ3_weaponban.integer & WPF_M4) {
client->teamplayWeapon = WP_M4;
} else if ((int) g_RQ3_weaponban.integer & WPF_MK23) {
client->teamplayWeapon = WP_PISTOL;
} else if ((int) g_RQ3_weaponban.integer & WPF_KNIFE) {
client->teamplayWeapon = WP_KNIFE;
} else {
client->teamplayWeapon = WP_PISTOL;
}
}
if (!client->teamplayItem && ((int) g_RQ3_weaponban.integer & ITF_LASER))
client->teamplayItem = HI_LASER;
} else {
if (!client->teamplayWeapon) {
if ((int) g_RQ3_weaponban.integer & WPF_MP5) {
client->teamplayWeapon = WP_MP5;
} else if ((int) g_RQ3_weaponban.integer & WPF_MK23) {
client->teamplayWeapon = WP_PISTOL;
} else if ((int) g_RQ3_weaponban.integer & WPF_KNIFE) {
client->teamplayWeapon = WP_KNIFE;
} else {
client->teamplayWeapon = WP_PISTOL;
}
}
if (!client->teamplayItem && ((int) g_RQ3_weaponban.integer & ITF_KEVLAR))
client->teamplayItem = HI_KEVLAR;
}
i = RQ3TeamCount(-1, client->sess.sessionTeam);
}
}
/*
===========
ClientSpawn
Called every time a client is placed fresh in the world:
after the first ClientBegin, and after each respawn
Initializes all non-persistant parts of playerState
============
*/
void ClientSpawn(gentity_t * ent)
{
int index, i, flags, savedPing;
int persistant[MAX_PERSISTANT];
vec3_t spawn_origin, spawn_angles;
gclient_t *client;
clientPersistant_t saved;
clientSession_t savedSess;
gentity_t *spawnPoint;
int accuracy_hits, accuracy_shots, eventSequence;
int savedWeapon, savedItem, savedSpec; // JBravo: to save weapon/item info
int savedRadiopower, savedRadiogender; // JBravo: for radio.
int savedMaleSet, savedFemaleSet; // JBravo: for soundset saves.
camera_t savedCamera; // JBravo: to save camera stuff
char userinfo[MAX_INFO_STRING];
char *classname;
//Slicer : Laser FIX
//Try to turn the laser off if it's on
if (ent->client->lasersight)
Laser_Gen(ent, qfalse);
index = ent - g_entities;
client = ent->client;
spawnPoint = NULL;
// find a spawn point
// do it before setting health back up, so farthest
// ranging doesn't count this client
if (client->sess.sessionTeam == TEAM_SPECTATOR) {
if (g_gametype.integer == GT_CTF &&
(client->sess.savedTeam == TEAM_RED || client->sess.savedTeam == TEAM_BLUE)) {
if (client->sess.savedTeam == TEAM_RED)
classname = "team_CTF_redflag";
else if (client->sess.savedTeam == TEAM_BLUE)
classname = "team_CTF_blueflag";
while ((spawnPoint = G_Find(spawnPoint, FOFS(classname), classname)) != NULL) {
if (!(spawnPoint->flags & FL_DROPPED_ITEM))
break;
}
if (spawnPoint) {
VectorCopy(spawnPoint->r.currentOrigin, spawn_origin);
VectorCopy(spawnPoint->s.angles, spawn_angles);
spawn_origin[2] += 30;
}
} else if (VectorLength(ent->client->ps.origin) == 0.0f) {
// Origin is not set yet? Use a spawn point
spawnPoint = SelectSpectatorSpawnPoint(spawn_origin, spawn_angles);
// Have a set origin already? Use it. (where you died or changed to spectator)
} else {
spawnPoint = NULL;
VectorCopy(ent->client->ps.origin, spawn_origin);
VectorCopy(ent->client->ps.viewangles, spawn_angles);
}
} else if (g_gametype.integer >= GT_CTF) {
// all base oriented team games use the CTF spawn points
spawnPoint = SelectCTFSpawnPoint(client->sess.sessionTeam,
client->pers.teamState.state, spawn_origin, spawn_angles);
// JBravo: If we are in Teamplay mode, use the teamspawnpoints.
} else if (g_gametype.integer == GT_TEAMPLAY || (g_gametype.integer == GT_TEAM && client->sess.teamSpawn)) {
// Freud: Assign the spawns from the spawning system (g_teamplay.c)
level.team1spawnpoint = level.teamplay_spawns[0];
level.team2spawnpoint = level.teamplay_spawns[1];
if (client->sess.sessionTeam == TEAM_RED) {
client->sess.spawnPoint = level.team1spawnpoint;
spawnPoint = level.team1spawnpoint;
VectorCopy(level.team1spawnpoint->s.angles, spawn_angles);
VectorCopy(level.team1spawnpoint->s.origin, spawn_origin);
} else {
client->sess.spawnPoint = level.team2spawnpoint;
spawnPoint = level.team2spawnpoint;
VectorCopy(level.team2spawnpoint->s.angles, spawn_angles);
VectorCopy(level.team2spawnpoint->s.origin, spawn_origin);
}
// Freud: Quake3 moves spawns up 9 pixs?
spawn_origin[2] += 9;
// End JBravo.
} else {
do {
// the first spawn should be at a good looking spot
if (!client->pers.initialSpawn && client->pers.localClient) {
client->pers.initialSpawn = qtrue;
spawnPoint = SelectInitialSpawnPoint(spawn_origin, spawn_angles);
} else {
// don't spawn near existing origin if possible
spawnPoint = SelectSpawnPoint(client->ps.origin, spawn_origin, spawn_angles);
}
// Tim needs to prevent bots from spawning at the initial point
// on q3dm0...
if ((spawnPoint->flags & FL_NO_BOTS) && (ent->r.svFlags & SVF_BOT)) {
continue; // try again
}
// just to be symetric, we have a nohumans option...
if ((spawnPoint->flags & FL_NO_HUMANS) && !(ent->r.svFlags & SVF_BOT)) {
continue; // try again
}
break;
} while (1);
}
client->pers.teamState.state = TEAM_ACTIVE;
// toggle the teleport bit so the client knows to not lerp
// and never clear the voted flag
flags = ent->client->ps.eFlags & (EF_TELEPORT_BIT | EF_VOTED | EF_TEAMVOTED);
flags ^= EF_TELEPORT_BIT;
// JBravo: unlagged
//ent->client->saved.leveltime = 0;
// clear everything but the persistant data
saved = client->pers;
savedSess = client->sess;
savedPing = client->ps.ping;
accuracy_hits = client->accuracy_hits;
accuracy_shots = client->accuracy_shots;
for (i = 0; i < MAX_PERSISTANT; i++) {
persistant[i] = client->ps.persistant[i];
}
eventSequence = client->ps.eventSequence;
// JBravo: save weapon/item info
savedWeapon = client->teamplayWeapon;
savedItem = client->teamplayItem;
savedSpec = client->specMode;
// JBravo: save radiosettings
savedRadiopower = client->radioOff;
savedRadiogender = client->radioGender;
savedMaleSet = client->radioSetMale;
savedFemaleSet = client->radioSetFemale;
memcpy(&savedCamera, &client->camera, sizeof(camera_t));
Com_Memset (client, 0, sizeof(*client));
// JBravo: restore weapon/item info
client->teamplayWeapon = savedWeapon;
client->teamplayItem = savedItem;
client->specMode = savedSpec;
// JBravo: restore radiosettings
client->radioOff = savedRadiopower;
client->radioGender = savedRadiogender;
client->radioSetMale = savedMaleSet;
client->radioSetFemale = savedFemaleSet;
memcpy(&client->camera, &savedCamera, sizeof(camera_t));
client->pers = saved;
client->sess = savedSess;
client->ps.ping = savedPing;
client->accuracy_hits = accuracy_hits;
client->accuracy_shots = accuracy_shots;
client->lastkilled_client[0] = NULL;
//Slicer
client->weapon_attempts = 0;
client->weapon_after_bandage_warned = qfalse;
client->gibbed = qfalse;
for (i = 0; i < MAX_PERSISTANT; i++) {
client->ps.persistant[i] = persistant[i];
}
client->ps.eventSequence = eventSequence;
// increment the spawncount so the client will detect the respawn
client->ps.persistant[PERS_SPAWN_COUNT]++;
client->ps.persistant[PERS_TEAM] = client->sess.sessionTeam;
client->airOutTime = level.time + 12000;
trap_GetUserinfo(index, userinfo, sizeof(userinfo));
// set max health
client->pers.maxHealth = atoi(Info_ValueForKey(userinfo, "handicap"));
if (client->pers.maxHealth < 1 || client->pers.maxHealth > 100) {
client->pers.maxHealth = 100;
}
// clear entity values
client->ps.eFlags = flags;
ent->s.groundEntityNum = ENTITYNUM_NONE;
ent->client = &level.clients[index];
ent->takedamage = qtrue;
ent->inuse = qtrue;
ent->classname = "player";
ent->r.contents = CONTENTS_BODY;
ent->clipmask = MASK_PLAYERSOLID;
ent->die = player_die;
ent->waterlevel = 0;
ent->watertype = 0;
ent->flags = 0;
VectorCopy(playerMins, ent->r.mins);
VectorCopy(playerMaxs, ent->r.maxs);
client->ps.clientNum = index;
camera_begin(ent);
//Blaze: changed WP_MACHINEGUN to WP_PISTOL, makes the base weapon you start with the pistol
// JBravo: Not in TP
if (g_gametype.integer == GT_FFA || (g_gametype.integer == GT_TEAM && g_RQ3_tdmMode.integer)) {
if ((int) g_RQ3_weaponban.integer & WPF_MK23) {
client->ps.stats[STAT_WEAPONS] = (1 << WP_PISTOL);
client->numClips[WP_PISTOL] = 0;
client->ps.ammo[WP_PISTOL] = ClipAmountForAmmo(WP_PISTOL);
}
if ((int) g_RQ3_weaponban.integer & WPF_KNIFE) {
client->ps.stats[STAT_WEAPONS] |= (1 << WP_KNIFE);
client->ps.ammo[WP_KNIFE] = 1;
}
}
//Blaze: Set the bandage variable to 0
client->bleedtick = 0;
// health will count down towards max_health
ent->health = client->ps.stats[STAT_HEALTH] = 100; //Blaze: removed * 1.25 becase we wanna start at 100 health
// reset streak count
client->killStreak = 0;
G_SetOrigin(ent, spawn_origin);
VectorCopy(spawn_origin, client->ps.origin);
// the respawned flag will be cleared after the attack and jump keys come up
client->ps.pm_flags |= PMF_RESPAWNED;
trap_GetUsercmd(client - level.clients, &ent->client->pers.cmd);
SetClientViewAngle(ent, spawn_angles);
if (ent->client->sess.sessionTeam == TEAM_SPECTATOR) {
} else {
G_KillBox(ent);
trap_LinkEntity(ent);
// force the base weapon up
//Blaze: Changed WP_MACHINEGUN to WP_PISTOL
// JBravo: we dont want the endless pistol in TP
if (g_gametype.integer < GT_TEAM || (g_gametype.integer == GT_TEAM && g_RQ3_tdmMode.integer)) {
client->ps.weapon = WP_PISTOL;
client->ps.weaponstate = WEAPON_READY;
}
}
//Blaze: Set the opendoor flag to 0
client->openDoor = qfalse;
client->openDoorTime = 0;
// don't allow full run speed for a bit
client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
client->ps.pm_time = 100;
client->respawnTime = level.time;
client->inactivityTime = level.time + g_inactivity.integer * 1000;
client->latched_buttons = 0;
//Elder: reset all RQ3 non-persistent stats
ent->client->ps.stats[STAT_RQ3] = 0;
// JBravo: remember saved specmodes.
if ((g_gametype.integer >= GT_TEAM) &&
client->sess.sessionTeam == TEAM_SPECTATOR) {
if (client->specMode == SPECTATOR_FOLLOW || client->specMode == SPECTATOR_FREE) {
client->sess.spectatorState = client->specMode;
client->ps.stats[STAT_RQ3] &= ~RQ3_ZCAM;
}
if (client->specMode == SPECTATOR_ZCAM && client->sess.sessionTeam == TEAM_SPECTATOR) {
client->sess.spectatorState = client->specMode;
client->ps.stats[STAT_RQ3] |= RQ3_ZCAM;
client->ps.pm_flags &= ~PMF_FOLLOW;
}
}
//Elder: set weaponfireNextTime amount
client->weaponfireNextTime = 0;
//Elder: Initialize fast reloads stuff
client->fastReloads = 0;
client->lastReloadTime = 0;
//Elder: initialize consecutive shots for M4 ride-up
client->consecutiveShots = 0;
// set default animations
client->ps.torsoAnim = TORSO_STAND;
client->ps.legsAnim = LEGS_IDLE;
// weapon animations
if (g_gametype.integer == GT_FFA || (g_gametype.integer == GT_TEAM && g_RQ3_tdmMode.integer))
client->ps.generic1 = ((client->ps.generic1 & ANIM_TOGGLEBIT)
^ ANIM_TOGGLEBIT) | WP_ANIM_IDLE;
if (level.intermissiontime) {
MoveClientToIntermission(ent);
} else {
// fire the targets of the spawn point
if (spawnPoint)
G_UseTargets(spawnPoint, ent);
// select the highest weapon number available, after any
// spawn given items have fired
// JBravo: Lets make sure we have the right weapons
if (g_gametype.integer >= GT_TEAM && !(g_gametype.integer == GT_TEAM && g_RQ3_tdmMode.integer) &&
(client->sess.sessionTeam == TEAM_RED || client->sess.sessionTeam == TEAM_BLUE)) {
EquipPlayer(ent);
} else {
client->ps.weapon = 1;
for (i = WP_NUM_WEAPONS - 1; i > 0; i--) {
if (i == WP_KNIFE)
continue;
if (client->ps.stats[STAT_WEAPONS] & (1 << i)) {
client->ps.weapon = i;
break;
}
}
}
}
// run a client frame to drop exactly to the floor,
// initialize animations and other things
client->ps.commandTime = level.time - 100;
ent->client->pers.cmd.serverTime = level.time;
// JBravo: We should not have to call this during TP spawns
if (g_gametype.integer == GT_FFA || (g_gametype.integer == GT_TEAM && g_RQ3_tdmMode.integer))
ClientThink(ent - g_entities);
// positively link the client, even if the command times are weird
if (ent->client->sess.sessionTeam != TEAM_SPECTATOR) {
BG_PlayerStateToEntityState(&client->ps, &ent->s, qtrue);
VectorCopy(ent->client->ps.origin, ent->r.currentOrigin);
trap_LinkEntity(ent);
}
// run the presend to set anything else
// JBravo: We should not have to call this during TP spawns
if (g_gametype.integer == GT_FFA || (g_gametype.integer == GT_TEAM && g_RQ3_tdmMode.integer))
ClientEndFrame(ent);
ent->client->noHead = qfalse;
// JBravo: adding allitems.
if (g_RQ3_allItems.integer) {
ent->client->ps.stats[STAT_HOLDABLE_ITEM] = (1 << HI_KEVLAR);
ent->client->ps.stats[STAT_HOLDABLE_ITEM] |= (1 << HI_LASER);
ent->client->ps.stats[STAT_HOLDABLE_ITEM] |= (1 << HI_SILENCER);
ent->client->ps.stats[STAT_HOLDABLE_ITEM] |= (1 << HI_BANDOLIER);
ent->client->ps.stats[STAT_HOLDABLE_ITEM] |= (1 << HI_SLIPPERS);
if (g_RQ3_haveHelmet.integer) {
ent->client->ps.stats[STAT_HOLDABLE_ITEM] |= (1 << HI_HELMET);
ent->client->uniqueItems = 6;
} else {
ent->client->uniqueItems = 5;
}
}
// JBravo: adding allweapons.
if (g_RQ3_allWeapons.integer) {
ent->client->ps.stats[STAT_WEAPONS] = (1 << WP_NUM_WEAPONS) - 1 - (1 << WP_NONE);
ent->client->weaponCount[WP_SSG3000] = 1;
ent->client->weaponCount[WP_MP5] = 1;
ent->client->weaponCount[WP_M3] = 1;
ent->client->weaponCount[WP_M4] = 1;
ent->client->weaponCount[WP_AKIMBO] = 1;
ent->client->weaponCount[WP_HANDCANNON] = 1;
ent->client->uniqueWeapons = 5;
//Makro - added knives
ent->client->weaponCount[WP_KNIFE] = 1;
for (i = 0; i < MAX_WEAPONS; i++) {
ent->client->ps.ammo[i] = ClipAmountForAmmo(i);
Add_Ammo(ent, i, 100, 1);
}
if (ent->client->ps.stats[STAT_HOLDABLE_ITEM] & (1 << HI_BANDOLIER))
ent->client->ps.ammo[WP_KNIFE] = 20;
else
ent->client->ps.ammo[WP_KNIFE] = 10;
ent->client->ps.stats[STAT_WEAPONS] |= (1 << WP_GRENADE) | (1 << WP_KNIFE);
}
// JBravo: lock the player down
if (g_gametype.integer == GT_CTF && ent->client->sess.sessionTeam == TEAM_SPECTATOR &&
(ent->client->sess.savedTeam == TEAM_RED || ent->client->sess.savedTeam == TEAM_BLUE) &&
!level.lights_camera_action)
ent->client->ps.pm_type = PM_FREEZE;
// clear entity state values
BG_PlayerStateToEntityState(&client->ps, &ent->s, qtrue);
}
/*
===========
ClientDisconnect
Called when a player drops from the server.
Will not be called between levels.
This should NOT be called directly by any game logic,
call trap_DropClient(), which will call this and do
server system housekeeping.
============
*/
void ClientDisconnect(int clientNum)
{
gentity_t *ent;
gentity_t *tent;
int oldTeam = 0, i;
// cleanup if we are kicking a bot that
// hasn't spawned yet
G_RemoveQueuedBotBegin(clientNum);
ent = g_entities + clientNum;
if (!ent->client || ent->client->pers.connected == CON_DISCONNECTED) {
return;
}
// JBravo: to keep the ui teamcount cvars right.
if (g_gametype.integer >= GT_TEAM) {
oldTeam = ent->client->sess.sessionTeam;
}
//Slicer: matchmode
if (g_RQ3_matchmode.integer) {
if(ent->client->sess.referee)
--level.refAmmount;
switch (ent->client->sess.captain) {
case TEAM_RED:
level.team1ready = qfalse;
break;
case TEAM_BLUE:
level.team2ready = qfalse;
break;
default:
break;
}
}
// aasimon: Referee. If player is referee, clean ref
/*if (clientNum == g_RQ3_RefID.integer)
trap_Cvar_Set("g_RQ3_RefID", "-1"); */
// JBravo: if the client had a laser, turn it off so it doesnt stay there forever.
if (ent->client->lasersight) {
G_FreeEntity(ent->client->lasersight);
ent->client->lasersight = NULL;
}
// stop any following clients
for (i = 0; i < level.maxclients; i++) {
if (level.clients[i].sess.sessionTeam == TEAM_SPECTATOR
&& level.clients[i].sess.spectatorState == SPECTATOR_FOLLOW
&& level.clients[i].sess.spectatorClient == clientNum) {
//Blaze: Prit out some Debug info
if (&g_entities[i] == NULL) G_Printf("Ln 2049\n");
StopFollowing(&g_entities[i]);
}
}
camera_disconnect(ent);
// send effect if they were completely connected
if (ent->client->pers.connected == CON_CONNECTED && ent->client->sess.sessionTeam != TEAM_SPECTATOR) {
tent = G_TempEntity(ent->client->ps.origin, EV_PLAYER_TELEPORT_OUT);
tent->s.clientNum = ent->s.clientNum;
// They don't get to take powerups with them!
// Especially important for stuff like CTF flags
TossClientItems(ent);
}
// JBravo: Make this more like AQ
// G_LogPrintf( "ClientDisconnect: %i\n", clientNum );
G_LogPrintf("%s disconnected (clientNum %i)\n", ent->client->pers.netname, clientNum);
// if we are playing in tourney mode and losing, give a win to the other player
if ((g_gametype.integer == GT_TOURNAMENT)
&& !level.intermissiontime && !level.warmupTime && level.sortedClients[1] == clientNum) {
level.clients[level.sortedClients[0]].sess.wins++;
ClientUserinfoChanged(level.sortedClients[0]);
}
trap_UnlinkEntity(ent);
ent->s.modelindex = 0;
ent->inuse = qfalse;
ent->classname = "disconnected";
ent->client->pers.connected = CON_DISCONNECTED;
ent->client->ps.persistant[PERS_TEAM] = TEAM_FREE;
ent->client->sess.sessionTeam = TEAM_FREE;
trap_SetConfigstring(CS_PLAYERS + clientNum, "");
CalculateRanks();
// JBravo: to keep the ui teamcount cvars right.
if (g_gametype.integer >= GT_TEAM) {
i = RQ3TeamCount(-1, oldTeam);
}
if (ent->r.svFlags & SVF_BOT) {
BotAIShutdownClient(clientNum, qfalse);
}
}