/*
* TVM_ClientConnect
*/
void TVM_ClientConnect( tvm_relay_t *relay, edict_t *ent, char *userinfo )
{
edict_t *spec;
assert( relay );
assert( ent );
assert( userinfo );
// make sure we start with known default
if( ent->relay->playernum < 0 )
spec = NULL;
else
spec = ent->relay->edicts + ent->relay->playernum + 1;
ent->local = true;
ent->relay = relay;
ent->r.inuse = true;
ent->r.svflags = SVF_NOCLIENT;
ent->s.team = spec ? spec->s.team : 0;
ent->r.client = relay->local_clients + PLAYERNUM( ent );
memset( ent->r.client, 0, sizeof( *ent->r.client ) );
ent->r.client->ps.playerNum = PLAYERNUM( ent );
InitClientPersistant( ent->r.client );
TVM_ClientUserinfoChanged( relay, ent, userinfo );
//TVM_Printf( "Connect: %s\n", ent->r.client->pers.netname );
ent->r.client->pers.connected = true;
ent->r.client->pers.connecting = true;
}
/*
===========
ClientConnect
Called when a player begins connecting to the server.
The game can refuse entrance to a client by returning false.
If the client is allowed, the connection process will continue
and eventually get to ClientBegin()
Changing levels will NOT cause this to be called again, but
loadgames will.
============
*/
qboolean ClientConnect (edict_t *ent, char *userinfo)
{
char *value;
// check to see if they are on the banned IP list
value = Info_ValueForKey (userinfo, "ip");
// check for a password
value = Info_ValueForKey (userinfo, "password");
if (strcmp(password->string, value) != 0)
return false;
// they can connect
ent->client = game.clients + (ent - g_edicts - 1);
// if there is already a body waiting for us (a loadgame), just
// take it, otherwise spawn one from scratch
if (ent->inuse == false)
{
// clear the respawning variables
InitClientResp (ent->client);
if (!game.autosaved || !ent->client->pers.weapon)
InitClientPersistant (ent->client);
}
ClientUserinfoChanged (ent, userinfo);
if (game.maxclients > 1)
gi.dprintf ("%s connected\n", ent->client->pers.netname);
ent->client->pers.connected = true;
return true;
}
void boss_spawn_tank (edict_t *ent)
{
char userinfo[MAX_INFO_STRING];
//edict_t *tank;
//gi.dprintf("boss_spawn_tank()\n");
if (G_EntExists(ent->owner) && (ent->owner->mtype == BOSS_TANK))
{
G_PrintGreenText(va("%s got bored and left the game.", ent->client->pers.netname));
BecomeTE(ent->owner);
ent->svflags &= ~SVF_NOCLIENT;
ent->viewheight = 22;
ent->movetype = MOVETYPE_WALK;
ent->solid = SOLID_BBOX;
ent->takedamage = DAMAGE_AIM;
// recover player info
memcpy(userinfo, ent->client->pers.userinfo, sizeof(userinfo));
InitClientPersistant(ent->client);
ClientUserinfoChanged(ent, userinfo);
modify_max(ent);
Pick_respawnweapon(ent);
ent->owner = NULL;
return;
}
CreateBoss(ent);
}
///////////////////////////////////////////////////////////////////////
// Modified version of id's code
///////////////////////////////////////////////////////////////////////
void ACESP_PutClientInServer(edict_t *bot, qboolean respawn, int team)
{
vec3_t mins = {-16, -16, -24};
vec3_t maxs = {16, 16, 32};
int index;
vec3_t spawn_origin, spawn_angles;
gclient_t *client;
client_persistant_t saved;
client_respawn_t resp;
char *s;
int spawn_style;
int spawn_health;
// find a spawn point
// do it before setting health back up, so farthest
// ranging doesn't count this client
SelectSpawnPoint (bot, spawn_origin, spawn_angles, &spawn_style, &spawn_health);
index = bot-g_edicts-1;
client = bot->client;
// deathmatch wipes most client data every spawn
if (deathmatch->value)
{
char userinfo[MAX_INFO_STRING];
resp = bot->client->resp;
memcpy (userinfo, client->pers.userinfo, sizeof(userinfo));
InitClientPersistant (client, spawn_style);
ClientUserinfoChanged (bot, userinfo);
}
else
memset(&resp, 0, sizeof(resp));
// clear everything but the persistant data
saved = client->pers;
memset(client, 0, sizeof(*client));
client->pers = saved;
client->resp = resp;
// copy some data from the client to the entity
FetchClientEntData (bot);
// clear entity values
bot->groundentity = NULL;
bot->client = &game.clients[index];
bot->takedamage = DAMAGE_AIM;
bot->movetype = MOVETYPE_WALK;
bot->viewheight = 24;
bot->classname = "bot";
bot->mass = 200;
bot->solid = SOLID_BBOX;
bot->deadflag = DEAD_NO;
bot->air_finished = level.time + 12;
bot->clipmask = MASK_PLAYERSOLID;
bot->model = "players/male/tris.md2";
bot->pain = player_pain;
bot->die = player_die;
bot->waterlevel = 0;
bot->watertype = 0;
bot->flags &= ~FL_NO_KNOCKBACK;
bot->svflags &= ~SVF_DEADMONSTER;
bot->is_jumping = false;
if (ctf->value)
{
client->resp.ctf_team = team;
client->resp.ctf_state = CTF_STATE_START;
s = Info_ValueForKey(client->pers.userinfo, "skin");
CTFAssignSkin(bot, s);
}
VectorCopy(mins, bot->mins);
VectorCopy(maxs, bot->maxs);
VectorClear(bot->velocity);
// clear playerstate values
memset(&bot->client->ps, 0, sizeof(client->ps));
client->ps.pmove.origin[0] = spawn_origin[0]*8;
client->ps.pmove.origin[1] = spawn_origin[1]*8;
client->ps.pmove.origin[2] = spawn_origin[2]*8;
//ZOID
client->ps.pmove.pm_flags &= ~PMF_NO_PREDICTION;
//ZOID
if (deathmatch->value && ((int)dmflags->value & DF_FIXED_FOV))
{
client->ps.fov = 90;
}
else
{
client->ps.fov = atoi(Info_ValueForKey(client->pers.userinfo, "fov"));
if (client->ps.fov < 1)
client->ps.fov = 90;
else if (client->ps.fov > 160)
client->ps.fov = 160;
}
// Knightmare- fix for null model?
if (client->pers.weapon && client->pers.weapon->view_model)
client->ps.gunindex = gi.modelindex(client->pers.weapon->view_model);
// clear entity state values
bot->s.effects = 0;
bot->s.skinnum = bot - g_edicts - 1;
bot->s.modelindex = MAX_MODELS-1; // will use the skin specified model
bot->s.modelindex2 = MAX_MODELS-1; // custom gun model
bot->s.frame = 0;
VectorCopy(spawn_origin, bot->s.origin);
bot->s.origin[2] += 1; // make sure off ground
// set the delta angle
for (int i = 0; i < 3; i++)
client->ps.pmove.delta_angles[i] = ANGLE2SHORT(spawn_angles[i] - client->resp.cmd_angles[i]);
bot->s.angles[PITCH] = 0;
bot->s.angles[YAW] = spawn_angles[YAW];
bot->s.angles[ROLL] = 0;
VectorCopy(bot->s.angles, client->ps.viewangles);
VectorCopy(bot->s.angles, client->v_angle);
// force the current weapon up
client->newweapon = client->pers.weapon;
ChangeWeapon (bot);
bot->enemy = NULL;
bot->movetarget = NULL;
bot->state = STATE_MOVE;
// Set the current node
bot->current_node = ACEND_FindClosestReachableNode(bot,NODE_DENSITY, NODE_ALL);
bot->goal_node = bot->current_node;
bot->next_node = bot->current_node;
bot->next_move_time = level.time;
bot->suicide_timeout = level.time + 15.0;
// If we are not respawning hold off for up to three seconds before releasing into game
if (!respawn)
{
bot->think = ACESP_HoldSpawn;
//bot->nextthink = level.time + 0.1; //mxd
bot->nextthink = level.time + random()*3.0f; // up to three seconds
}
else
{
if (!KillBox(bot))
{ // could't spawn in?
}
gi.linkentity(bot);
bot->think = ACEAI_Think;
bot->nextthink = level.time + FRAMETIME;
// send effect
gi.WriteByte(svc_muzzleflash);
gi.WriteShort(bot-g_edicts);
gi.WriteByte(MZ_LOGIN);
gi.multicast(bot->s.origin, MULTICAST_PVS);
}
}
/*
===========
PutClientInServer
Called when a player connects to a server or respawns in
a deathmatch.
============
*/
void PutClientInServer (edict_t *ent)
{
vec3_t mins = {-16, -16, -24};
vec3_t maxs = {16, 16, 32};
int index;
vec3_t spawn_origin, spawn_angles;
gclient_t *client;
int i;
client_persistant_t saved;
client_respawn_t resp;
// find a spawn point
// do it before setting health back up, so farthest
// ranging doesn't count this client
SelectSpawnPoint (ent, spawn_origin, spawn_angles);
index = ent-g_edicts-1;
client = ent->client;
// deathmatch wipes most client data every spawn
if (deathmatch->value)
{
char userinfo[MAX_INFO_STRING];
resp = client->resp;
memcpy (userinfo, client->pers.userinfo, sizeof(userinfo));
InitClientPersistant (client);
ClientUserinfoChanged (ent, userinfo);
}
else if (coop->value)
{
int n;
char userinfo[MAX_INFO_STRING];
resp = client->resp;
memcpy (userinfo, client->pers.userinfo, sizeof(userinfo));
// this is kind of ugly, but it's how we want to handle keys in coop
for (n = 0; n < MAX_ITEMS; n++)
{
if (itemlist[n].flags & IT_KEY)
resp.coop_respawn.inventory[n] = client->pers.inventory[n];
}
client->pers = resp.coop_respawn;
ClientUserinfoChanged (ent, userinfo);
if (resp.score > client->pers.score)
client->pers.score = resp.score;
}
else
{
memset (&resp, 0, sizeof(resp));
}
// clear everything but the persistant data
saved = client->pers;
memset (client, 0, sizeof(*client));
client->pers = saved;
if (client->pers.health <= 0)
InitClientPersistant(client);
else if (Q_stricmp(level.mapname, "zboss") == 0)
{
char userinfo[MAX_INFO_STRING];
int health = client->pers.health;
memcpy (userinfo, client->pers.userinfo, sizeof(userinfo));
InitClientPersistant(client);
ClientUserinfoChanged (ent, userinfo);
client->pers.health = health;
}
client->resp = resp;
// copy some data from the client to the entity
FetchClientEntData (ent);
// clear entity values
ent->groundentity = NULL;
ent->client = &game.clients[index];
ent->takedamage = DAMAGE_AIM;
ent->movetype = MOVETYPE_WALK;
ent->viewheight = 22;
ent->inuse = true;
ent->classname = "player";
ent->mass = 200;
ent->solid = SOLID_BBOX;
ent->deadflag = DEAD_NO;
ent->air_finished = level.time + 12;
ent->clipmask = MASK_PLAYERSOLID;
ent->model = "players/male/tris.md2";
ent->pain = player_pain;
ent->die = player_die;
ent->waterlevel = 0;
ent->watertype = 0;
ent->flags &= ~FL_NO_KNOCKBACK;
ent->svflags &= ~SVF_DEADMONSTER;
#ifdef WITH_ACEBOT
// ACEBOT_ADD
ent->is_bot = false;
ent->last_node = -1;
ent->is_jumping = false;
// ACEBOT_END
#endif
VectorCopy (mins, ent->mins);
VectorCopy (maxs, ent->maxs);
VectorClear (ent->velocity);
// clear playerstate values
memset (&ent->client->ps, 0, sizeof(client->ps));
client->ps.pmove.origin[0] = spawn_origin[0]*8;
client->ps.pmove.origin[1] = spawn_origin[1]*8;
client->ps.pmove.origin[2] = spawn_origin[2]*8;
if (deathmatch->value && ((int)dmflags->value & DF_FIXED_FOV))
{
client->ps.fov = 90;
}
else
{
client->ps.fov = atoi(Info_ValueForKey(client->pers.userinfo, "fov"));
if (client->ps.fov < 1)
client->ps.fov = 90;
else if (client->ps.fov > 160)
client->ps.fov = 160;
}
client->ps.gunindex = gi.modelindex(client->pers.weapon->view_model);
// clear entity state values
ent->s.effects = 0;
ent->s.skinnum = ent - g_edicts - 1;
ent->s.modelindex = 255; // will use the skin specified model
ent->s.modelindex2 = 255; // custom gun model
ent->s.frame = 0;
#ifdef WITH_ACEBOT
//botchat>
ent->last_insult = level.time;
ent->last_taunt = level.time;
ent->last_chat = level.time;
//<botchat
#endif
VectorCopy (spawn_origin, ent->s.origin);
ent->s.origin[2] += 1; // make sure off ground
VectorCopy (ent->s.origin, ent->s.old_origin);
// set the delta angle
for (i=0 ; i<3 ; i++)
client->ps.pmove.delta_angles[i] = ANGLE2SHORT(spawn_angles[i] - client->resp.cmd_angles[i]);
ent->s.angles[PITCH] = 0;
ent->s.angles[YAW] = spawn_angles[YAW];
ent->s.angles[ROLL] = 0;
VectorCopy (ent->s.angles, client->ps.viewangles);
VectorCopy (ent->s.angles, client->v_angle);
if (!KillBox (ent))
{ // could't spawn in?
}
gi.linkentity (ent);
// force the current weapon up
client->newweapon = client->pers.weapon;
ChangeWeapon (ent);
}
/*
===========
ClientConnect
Called when a player begins connecting to the server.
The game can refuse entrance to a client by returning false.
If the client is allowed, the connection process will continue
and eventually get to ClientBegin()
Changing levels will NOT cause this to be called again, but
loadgames will.
============
*/
qboolean ClientConnect (edict_t *ent, char *userinfo)
{
char *value;
// check to see if they are on the banned IP list
value = Info_ValueForKey (userinfo, "ip");
if (SV_FilterPacket(value)) {
Info_SetValueForKey(userinfo, "rejmsg", "Banned.");
return false;
}
// check for a spectator
value = Info_ValueForKey (userinfo, "spectator");
if (deathmatch->value && *value && strcmp(value, "0")) {
int i, numspec;
if (*spectator_password->string &&
strcmp(spectator_password->string, "none") &&
strcmp(spectator_password->string, value)) {
Info_SetValueForKey(userinfo, "rejmsg", "Spectator password required or incorrect.");
return false;
}
// count spectators
for (i = numspec = 0; i < maxclients->value; i++)
if (g_edicts[i+1].inuse && g_edicts[i+1].client->pers.spectator)
numspec++;
if (numspec >= maxspectators->value) {
Info_SetValueForKey(userinfo, "rejmsg", "Server spectator limit is full.");
return false;
}
} else {
// check for a password
value = Info_ValueForKey (userinfo, "password");
if (*password->string && strcmp(password->string, "none") &&
strcmp(password->string, value)) {
Info_SetValueForKey(userinfo, "rejmsg", "Password required or incorrect.");
return false;
}
}
// they can connect
ent->client = game.clients + (ent - g_edicts - 1);
// if there is already a body waiting for us (a loadgame), just
// take it, otherwise spawn one from scratch
if (ent->inuse == false)
{
// clear the respawning variables
InitClientResp (ent->client);
if (!game.autosaved || !ent->client->pers.weapon)
InitClientPersistant (ent->client);
}
ClientUserinfoChanged (ent, userinfo);
if (game.maxclients > 1)
gi.dprintf ("%s connected\n", ent->client->pers.netname);
ent->svflags = 0; // make sure we start with known default
ent->client->pers.connected = true;
return true;
}
/*
* Called when a player connects to
* a server or respawns in a deathmatch.
*/
void
PutClientInServer(edict_t *ent)
{
char userinfo[MAX_INFO_STRING];
if (!ent)
{
return;
}
vec3_t mins = {-16, -16, -24};
vec3_t maxs = {16, 16, 32};
int index;
vec3_t spawn_origin, spawn_angles;
gclient_t *client;
int i;
client_persistant_t saved;
client_respawn_t resp;
/* find a spawn point do it before setting
health back up, so farthest ranging
doesn't count this client */
SelectSpawnPoint(ent, spawn_origin, spawn_angles);
index = ent - g_edicts - 1;
client = ent->client;
/* deathmatch wipes most client data every spawn */
if (deathmatch->value)
{
resp = client->resp;
memcpy(userinfo, client->pers.userinfo, sizeof(userinfo));
InitClientPersistant(client);
ClientUserinfoChanged(ent, userinfo);
}
else if (coop->value)
{
resp = client->resp;
memcpy(userinfo, client->pers.userinfo, sizeof(userinfo));
resp.coop_respawn.game_helpchanged = client->pers.game_helpchanged;
resp.coop_respawn.helpchanged = client->pers.helpchanged;
client->pers = resp.coop_respawn;
ClientUserinfoChanged(ent, userinfo);
if (resp.score > client->pers.score)
{
client->pers.score = resp.score;
}
}
else
{
memset(&resp, 0, sizeof(resp));
}
memcpy(userinfo, client->pers.userinfo, sizeof(userinfo));
ClientUserinfoChanged(ent, userinfo);
/* clear everything but the persistant data */
saved = client->pers;
memset(client, 0, sizeof(*client));
client->pers = saved;
if (client->pers.health <= 0)
{
InitClientPersistant(client);
}
client->resp = resp;
/* copy some data from the client to the entity */
FetchClientEntData(ent);
/* clear entity values */
ent->groundentity = NULL;
ent->client = &game.clients[index];
ent->takedamage = DAMAGE_AIM;
ent->movetype = MOVETYPE_WALK;
ent->viewheight = 22;
ent->inuse = true;
ent->classname = "player";
ent->mass = 200;
ent->solid = SOLID_BBOX;
ent->deadflag = DEAD_NO;
ent->air_finished = level.time + 12;
ent->clipmask = MASK_PLAYERSOLID;
ent->model = "players/male/tris.md2";
ent->pain = player_pain;
ent->die = player_die;
ent->waterlevel = 0;
ent->watertype = 0;
ent->flags &= ~FL_NO_KNOCKBACK;
ent->svflags = 0;
VectorCopy(mins, ent->mins);
VectorCopy(maxs, ent->maxs);
VectorClear(ent->velocity);
/* clear playerstate values */
memset(&ent->client->ps, 0, sizeof(client->ps));
client->ps.pmove.origin[0] = spawn_origin[0] * 8;
client->ps.pmove.origin[1] = spawn_origin[1] * 8;
client->ps.pmove.origin[2] = spawn_origin[2] * 8;
if (deathmatch->value && ((int)dmflags->value & DF_FIXED_FOV))
{
client->ps.fov = 90;
}
else
{
client->ps.fov = (int)strtol(Info_ValueForKey(client->pers.userinfo, "fov"), (char **)NULL, 10);
if (client->ps.fov < 1)
{
client->ps.fov = 90;
}
else if (client->ps.fov > 160)
{
client->ps.fov = 160;
}
}
client->ps.gunindex = gi.modelindex(client->pers.weapon->view_model);
/* clear entity state values */
ent->s.effects = 0;
ent->s.modelindex = 255; /* will use the skin specified model */
ent->s.modelindex2 = 255; /* custom gun model */
/* sknum is player num and weapon number
weapon number will be added in changeweapon */
ent->s.skinnum = ent - g_edicts - 1;
ent->s.frame = 0;
VectorCopy(spawn_origin, ent->s.origin);
ent->s.origin[2] += 1; /* make sure off ground */
VectorCopy(ent->s.origin, ent->s.old_origin);
/* set the delta angle */
for (i = 0; i < 3; i++)
{
client->ps.pmove.delta_angles[i] = ANGLE2SHORT(
spawn_angles[i] - client->resp.cmd_angles[i]);
}
ent->s.angles[PITCH] = 0;
ent->s.angles[YAW] = spawn_angles[YAW];
ent->s.angles[ROLL] = 0;
VectorCopy(ent->s.angles, client->ps.viewangles);
VectorCopy(ent->s.angles, client->v_angle);
/* spawn a spectator */
if (client->pers.spectator)
{
client->chase_target = NULL;
client->resp.spectator = true;
ent->movetype = MOVETYPE_NOCLIP;
ent->solid = SOLID_NOT;
ent->svflags |= SVF_NOCLIENT;
ent->client->ps.gunindex = 0;
gi.linkentity(ent);
return;
}
else
{
client->resp.spectator = false;
}
if (!KillBox(ent))
{
/* could't spawn in? */
}
gi.linkentity(ent);
/* force the current weapon up */
client->newweapon = client->pers.weapon;
ChangeWeapon(ent);
}
void boss_spawn_tank (edict_t *ent)
{
char userinfo[MAX_INFO_STRING], *message;
//edict_t *tank;
//gi.dprintf("boss_spawn_tank()\n");
if (G_EntExists(ent->owner) && (ent->owner->mtype == BOSS_TANK))
{
message = HiPrint(va("%s got bored and left the game.", ent->client->pers.netname));
gi.bprintf(PRINT_HIGH, "%s\n", message);
V_Free(message);
BecomeTE(ent->owner);
ent->svflags &= ~SVF_NOCLIENT;
ent->viewheight = 22;
ent->movetype = MOVETYPE_WALK;
ent->solid = SOLID_BBOX;
ent->takedamage = DAMAGE_AIM;
// recover player info
memcpy(userinfo, ent->client->pers.userinfo, sizeof(userinfo));
InitClientPersistant(ent->client);
ClientUserinfoChanged(ent, userinfo);
modify_max(ent);
Pick_respawnweapon(ent);
ent->owner = NULL;
return;
}
CreateBoss(ent);
/*
message = HiPrint(va("A level %d boss known as %s has spawned!", average_player_level, ent->client->pers.netname));
gi.bprintf(PRINT_HIGH, "%s\n", message);
// create the tank entity that the player will pilot
tank = G_Spawn();
tank->classname = "boss";
tank->solid = SOLID_BBOX;
tank->takedamage = DAMAGE_YES;
tank->movetype = MOVETYPE_STEP;
tank->clipmask = MASK_MONSTERSOLID;
tank->svflags |= SVF_MONSTER;
tank->activator = ent;
tank->die = boss_tank_die;
tank->think = boss_tank_think;
tank->mass = 500;
tank->monsterinfo.level = average_player_level;
tank->health = TANK_INITIAL_HEALTH+TANK_ADDON_HEALTH*tank->monsterinfo.level;
tank->max_health = tank->health;
tank->mtype = BOSS_TANK;
tank->pain = boss_pain;
tank->flags |= FL_CHASEABLE; // 3.65 indicates entity can be chase cammed
// set up pointers
tank->owner = ent;
ent->owner = tank;
tank->s.modelindex = gi.modelindex ("models/monsters/tank/tris.md2");
VectorSet (tank->mins, -24, -24, -16);
VectorSet (tank->maxs, 24, 24, 64);
tank->s.skinnum = 2; // commander skin
VectorCopy(ent->s.angles, tank->s.angles);
tank->s.angles[PITCH] = 0; // monsters don't use pitch
tank->nextthink = level.time + FRAMETIME;
VectorCopy(ent->s.origin, tank->s.origin);
VectorCopy(ent->s.old_origin, tank->s.old_origin);
// link up entities
gi.linkentity(tank);
gi.linkentity(ent);
// make the player into a ghost
ent->svflags |= SVF_NOCLIENT;
ent->viewheight = 0;
ent->movetype = MOVETYPE_NOCLIP;
ent->solid = SOLID_NOT;
ent->takedamage = DAMAGE_NO;
ent->client->ps.gunindex = 0;
memset (ent->client->pers.inventory, 0, sizeof(ent->client->pers.inventory));
ent->client->pers.weapon = NULL;
*/
}