/**
* @brief G_ResetXP
* @param[in,out] ent
*/
void G_ResetXP(gentity_t *ent)
{
int i = 0;
int ammo[MAX_WEAPONS], ammoclip[MAX_WEAPONS];
int oldWeapon; //, newWeapon;
if (!ent || !ent->client)
{
return;
}
#ifdef FEATURE_RATING
if (!g_skillRating.integer)
#endif
{
ent->client->sess.rank = 0;
}
for (i = 0; i < SK_NUM_SKILLS; i++)
{
ent->client->sess.skillpoints[i] = 0.0f;
ent->client->sess.skill[i] = 0;
}
G_CalcRank(ent->client);
ent->client->ps.stats[STAT_XP] = 0;
ent->client->ps.persistant[PERS_SCORE] = 0;
// zero out all weapons and grab the default weapons for a player of this XP level.
// backup..
Com_Memcpy(ammo, ent->client->ps.ammo, sizeof(ammo));
Com_Memcpy(ammoclip, ent->client->ps.ammoclip, sizeof(ammoclip));
oldWeapon = ent->client->ps.weapon;
// Check weapon validity, maybe dump some weapons for this (now) unskilled player..
// It also sets the (possibly new) amounts of ammo for weapons.
SetWolfSpawnWeapons(ent->client);
// restore..
//newWeapon = ent->client->ps.weapon;
for (i = WP_NONE; i < WP_NUM_WEAPONS; ++i) //i<MAX_WEAPONS
{ // only restore ammo for valid weapons..
// ..they might have lost some weapons because of skill changes.
// Also restore to the old amount of ammo, because..
// ..SetWolfSpawnWeapons sets amount of ammo for a fresh spawning player,
// which is usually more than the player currently has left.
if (COM_BitCheck(ent->client->ps.weapons, i))
{
if (ammo[i] < ent->client->ps.ammo[i])
{
ent->client->ps.ammo[i] = ammo[i];
}
if (ammoclip[i] < ent->client->ps.ammoclip[i])
{
ent->client->ps.ammoclip[i] = ammoclip[i];
}
}
else
{
ent->client->ps.ammo[i] = 0;
ent->client->ps.ammoclip[i] = 0;
}
}
// check if the old weapon is still valid.
// If so, restore to the last used weapon..
if (COM_BitCheck(ent->client->ps.weapons, oldWeapon))
{
ent->client->ps.weapon = oldWeapon;
}
ClientUserinfoChanged(ent - g_entities);
}
/*
===========
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;
vec3_t spawn_origin, spawn_angles;
gclient_t *client;
int i;
clientPersistant_t saved;
clientSession_t savedSess;
int persistant[MAX_PERSISTANT];
gentity_t *spawnPoint;
int flags;
int savedPing;
int savedTeam;
qboolean update = qfalse;
save_position_t *pos = NULL;
index = ent - g_entities;
client = ent->client;
G_UpdateSpawnCounts();
client->pers.lastSpawnTime = level.time;
if (client->sess.sessionTeam != TEAM_AXIS && client->sess.sessionTeam != TEAM_ALLIES) {
spawnPoint = SelectSpectatorSpawnPoint(spawn_origin, spawn_angles);
} else {
spawnPoint = SelectPlayerSpawnPoint(client->sess.sessionTeam, spawn_origin, spawn_angles, client->sess.spawnObjectiveIndex);
}
client->pers.teamState.state = TEAM_ACTIVE;
// toggle the teleport bit so the client knows to not lerp
flags = ent->client->ps.eFlags & EF_TELEPORT_BIT;
flags ^= EF_TELEPORT_BIT;
flags |= (client->ps.eFlags & EF_VOTED);
// clear everything but the persistant data
ent->s.eFlags &= ~EF_MOUNTEDTANK;
// Nico, notify timerun_stop
notify_timerun_stop(ent, 0);
ent->client->sess.timerunActive = qfalse;
saved = client->pers;
savedSess = client->sess;
savedPing = client->ps.ping;
savedTeam = client->ps.teamNum;
for (i = 0 ; i < MAX_PERSISTANT ; i++) {
persistant[i] = client->ps.persistant[i];
}
memset(client, 0, sizeof (*client));
client->pers = saved;
client->sess = savedSess;
client->ps.ping = savedPing;
client->ps.teamNum = savedTeam;
for (i = 0 ; i < MAX_PERSISTANT ; i++) {
client->ps.persistant[i] = persistant[i];
}
// 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->ps.persistant[PERS_HWEAPON_USE] = 0;
client->airOutTime = level.time + 12000;
// clear entity values
client->ps.stats[STAT_MAX_HEALTH] = client->pers.maxHealth;
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;
// DHM - Nerve :: Init to -1 on first spawn;
ent->props_frame_state = -1;
ent->die = player_die;
ent->waterlevel = 0;
ent->watertype = 0;
ent->flags = 0;
VectorCopy(playerMins, ent->r.mins);
VectorCopy(playerMaxs, ent->r.maxs);
// Ridah, setup the bounding boxes and viewheights for prediction
VectorCopy(ent->r.mins, client->ps.mins);
VectorCopy(ent->r.maxs, client->ps.maxs);
client->ps.crouchViewHeight = CROUCH_VIEWHEIGHT;
client->ps.standViewHeight = DEFAULT_VIEWHEIGHT;
client->ps.deadViewHeight = DEAD_VIEWHEIGHT;
client->ps.crouchMaxZ = client->ps.maxs[2] - (client->ps.standViewHeight - client->ps.crouchViewHeight);
client->ps.runSpeedScale = 0.8;
client->ps.sprintSpeedScale = 1.1;
client->ps.crouchSpeedScale = 0.25;
client->ps.weaponstate = WEAPON_READY;
// Rafael
client->ps.friction = 1.0;
// done.
// TTimo
// retrieve from the persistant storage (we use this in pmoveExt_t beause we need it in bg_*)
client->pmext.bAutoReload = client->pers.bAutoReloadAux;
// done
client->ps.clientNum = index;
trap_GetUsercmd(client - level.clients, &ent->client->pers.cmd); // NERVE - SMF - moved this up here
if (client->sess.playerType != client->sess.latchPlayerType) {
update = qtrue;
}
client->sess.playerType = client->sess.latchPlayerType;
if (client->sess.playerWeapon != client->sess.latchPlayerWeapon) {
client->sess.playerWeapon = client->sess.latchPlayerWeapon;
update = qtrue;
}
client->sess.playerWeapon2 = client->sess.latchPlayerWeapon2;
if (update) {
ClientUserinfoChanged(index);
}
G_UpdateCharacter(client);
SetWolfSpawnWeapons(client);
client->pers.maxHealth = 125;
client->ps.stats[STAT_MAX_HEALTH] = client->pers.maxHealth;
client->pers.cmd.weapon = ent->client->ps.weapon;
// dhm - end
ent->health = client->ps.stats[STAT_HEALTH] = client->ps.stats[STAT_MAX_HEALTH];
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;
SetClientViewAngle(ent, spawn_angles);
if (ent->client->sess.sessionTeam != TEAM_SPECTATOR) {
trap_LinkEntity(ent);
}
client->inactivityTime = level.time + g_inactivity.integer * 1000;
client->latched_buttons = 0;
client->latched_wbuttons = 0; //----(SA) added
// fire the targets of the spawn point
G_UseTargets(spawnPoint, ent);
// 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;
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
ClientEndFrame(ent);
// set idle animation on weapon
ent->client->ps.weapAnim = ((ent->client->ps.weapAnim & ANIM_TOGGLEBIT) ^ ANIM_TOGGLEBIT) | PM_IdleAnimForWeapon(ent->client->ps.weapon);
// clear entity state values
BG_PlayerStateToEntityState(&client->ps, &ent->s, qtrue);
// show_bug.cgi?id=569
G_ResetMarkers(ent);
// RF, start the scripting system
if (client->sess.sessionTeam != TEAM_SPECTATOR) {
// RF, call entity scripting event
G_Script_ScriptEvent(ent, "playerstart", "");
}
// Nico, autoload position
if (ent->client->pers.autoLoad && !ent->client->sess.lastDieWasASelfkill && (ent->client->sess.sessionTeam == TEAM_AXIS || ent->client->sess.sessionTeam == TEAM_ALLIES)) {
if (ent->client->sess.sessionTeam == TEAM_ALLIES) {
pos = ent->client->sess.alliesSaves;
} else {
pos = ent->client->sess.axisSaves;
}
if (pos->valid) {
VectorCopy(pos->origin, ent->client->ps.origin);
// Nico, load angles if cg_loadViewAngles = 1
if (ent->client->pers.loadViewAngles) {
SetClientViewAngle(ent, pos->vangles);
}
// Nico, load saved weapon if cg_loadWeapon = 1
if (ent->client->pers.loadWeapon) {
ent->client->ps.weapon = pos->weapon;
}
VectorClear(ent->client->ps.velocity);
if (ent->client->ps.stats[STAT_HEALTH] < 100 && ent->client->ps.stats[STAT_HEALTH] > 0) {
ent->health = 100;
}
}
}
}
