id/quake-rerelease-qc
0
0
Fork 0
mirror of https://github.com/id-Software/quake-rerelease-qc.git synced 2024-12-04 01:51:41 +00:00
Code Issues Projects Releases Packages Wiki Activity
quake-rerelease-qc/quakec_ctf/client.qc
Mike Rubits bebf782915 Update 4 QuakeC
2022-08-17 17:00:59 -05:00

1848 lines
45 KiB
C++
Raw Permalink Blame History

/* Copyright (C) 1996-2022 id Software LLC
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
See file, 'COPYING', for details.
*/
// prototypes
void () W_WeaponFrame;
void() W_SetCurrentAmmo;
void(entity attacker, float damage) player_pain;
void() player_stand1;
void (vector org) spawn_tfog;
void (vector org, entity death_owner) spawn_tdeath;
void() UnHookPlayer;
float modelindex_eyes, modelindex_player;
float pregameover;
// if supported by the engine, block color changes from going through
void(float color) SV_ChangeTeam = {
dprint("SV_ChangeTeam: blocking color change\n");
return;
}
// ZOID: with several effects doing the dimlight thing, they just can't
// turn it off. Do not set self.effects with EF_DIMLIGHT directly. This
// will automatically do it when CheckPowerups is called
// EF_DIMLIGHT is used;
// 1. Invincible (Pentagram)
// 2. Super Damage (Quad Power)
// 3. Having Flag in Capture
// self is player
void () CheckDimLight = {
local float flag;
flag = 0;
// invincable
if (self.invincible_finished > time)
flag = 1;
// quad
if (self.super_damage_finished > time)
flag = 1;
// flag
// if (self.player_flag & ITEM_ENEMY_FLAG)
// flag = 1;
if (flag)
self.effects = self.effects | EF_DIMLIGHT;
else
self.effects = self.effects - (self.effects & EF_DIMLIGHT);
};
/*
=============================================================================
LEVEL CHANGING / INTERMISSION
=============================================================================
*/
float intermission_running;
float intermission_exittime;
/*QUAKED info_intermission (1 0.5 0.5) (-16 -16 -16) (16 16 16)
This is the camera point for the intermission.
Use mangle instead of angle, so you can set pitch or roll as well as yaw. 'pitch roll yaw'
*/
void() info_intermission =
{
};
void() SetChangeParms =
{
if (self.health <= 0)
{
parm14 = self.statstate;
SetNewParms ();
// *TEAMPLAY*
parm10 = self.lastteam; // Save the current team of the player
parm15 = self.accesslvl; // remote admin state
parm16 = self.player_flag;
return;
}
// remove items
self.items = self.items - (self.items &
(IT_KEY1 | IT_KEY2 | IT_INVISIBILITY | IT_INVULNERABILITY | IT_SUIT | IT_QUAD) );
// cap super health
if (self.health > 100)
self.health = 100;
if (self.health < 50)
self.health = 50;
parm14 = self.statstate;
SetNewParms();
// *TEAMPLAY*
if (gamestart || self.observer)
parm10 = -1;
else
parm10 = self.lastteam; // Save the current team of the player
parm15 = self.accesslvl; // remote admin state
parm16 = self.player_flag;
};
void() SetNewParms =
{
if (gamestart && !pregameover) {
parm1 = IT_AXE;
parm2 = 100;
parm4 = 0;
parm8 = IT_AXE;
parm10 = 1;
} else {
if (cvar("teamplay") & TEAM_DISABLE_GRAPPLE)
parm1 = IT_SHOTGUN | IT_AXE;
else
parm1 = IT_SHOTGUN | IT_AXE | IT_HOOK;
parm2 = 100;
parm3 = 50;
parm9 = 30;
parm1 = parm1 + IT_ARMOR1;
parm4 = 40;
parm8 = IT_SHOTGUN;
parm10 = -1; // Reset
}
parm5 = 0;
parm6 = 0;
parm7 = 0;
// *TEAMPLAY*
parm14 = self.statstate;
parm15 = 0; // remote admin
parm16 = 0;
};
void() DecodeLevelParms =
{
self.player_flag = self.player_flag | parm16;
self.player_flag = self.player_flag - (self.player_flag & ITEM_RUNE_MASK);
self.player_flag = self.player_flag - (self.player_flag & ITEM_ENEMY_FLAG);
self.skin = (self.player_flag & 65280)/256;
self.accesslvl = parm15;
self.statstate = parm14;
if (gamestart)
SetNewParms (); // take away all stuff on starting new episode
self.items = parm1;
self.health = parm2;
self.armorvalue = parm3;
self.ammo_shells = parm4;
self.ammo_nails = parm5;
self.ammo_rockets = parm6;
self.ammo_cells = parm7;
self.weapon = parm8;
self.armortype = parm9 * 0.01;
// *XXX* EXPERT CTF
// Reset times for additional scoring system on level change and server join
// dprint("decode level parms\n");
self.last_returned_flag = -10;
self.last_fragged_carrier = -10;
self.flag_since = -10;
self.last_hurt_carrier = -10;
// *TEAMPLAY*
if(TeamColorIsLegal(parm10))
self.lastteam = parm10;
};
/*
============
FindIntermission
Returns the entity to view from
============
*/
entity() FindIntermission =
{
local entity spot;
local float cyc;
// look for info_intermission first
spot = find (world, classname, "info_intermission");
if (spot)
{ // pick a random one
cyc = random() * 4;
while (cyc > 1)
{
spot = find (spot, classname, "info_intermission");
if (!spot)
spot = find (spot, classname, "info_intermission");
cyc = cyc - 1;
}
return spot;
}
// then look for the start position
spot = find (world, classname, "info_player_start");
if (spot)
return spot;
// testinfo_player_start is only found in regioned levels
spot = find (world, classname, "testplayerstart");
if (spot)
return spot;
objerror ("FindIntermission: no spot");
};
string nextmap;
void() GotoNextMap =
{
if (cvar("samelevel")) // if samelevel is set, stay on same level
changelevel (mapname);
else {
if (mapname == "ctf1") nextmap = "ctf2";
else if (mapname == "ctf2") nextmap = "ctf3";
else if (mapname == "ctf3") nextmap = "ctf4";
else if (mapname == "ctf4") nextmap = "ctf5";
else if (mapname == "ctf5") nextmap = "ctf6";
else if (mapname == "ctf6") nextmap = "ctf7";
else if (mapname == "ctf7") nextmap = "ctf8";
else if (mapname == "ctf8") nextmap = "ctf9";
else if (mapname == "ctf9") nextmap = "ctf1";
else nextmap = "ctf1";
changelevel (nextmap);
}
};
void() ExitIntermission =
{
// skip any text in deathmatch
if (deathmatch)
{
GotoNextMap ();
return;
}
intermission_exittime = time + 1;
intermission_running = intermission_running + 1;
//
// run some text if at the end of an episode
//
if (intermission_running == 2)
{
if (world.model == "maps/e1m7.bsp")
{
WriteByte (MSG_ALL, SVC_CDTRACK);
WriteByte (MSG_ALL, 2);
WriteByte (MSG_ALL, 3);
if (!cvar("registered"))
{
WriteByte (MSG_ALL, SVC_FINALE);
WriteString (MSG_ALL, "$qc_finale_e1_shareware");
}
else
{
WriteByte (MSG_ALL, SVC_FINALE);
WriteString (MSG_ALL, "$qc_finale_e1");
}
return;
}
else if (world.model == "maps/e2m6.bsp")
{
WriteByte (MSG_ALL, SVC_CDTRACK);
WriteByte (MSG_ALL, 2);
WriteByte (MSG_ALL, 3);
WriteByte (MSG_ALL, SVC_FINALE);
WriteString (MSG_ALL, "$qc_finale_e2");
return;
}
else if (world.model == "maps/e3m6.bsp")
{
WriteByte (MSG_ALL, SVC_CDTRACK);
WriteByte (MSG_ALL, 2);
WriteByte (MSG_ALL, 3);
WriteByte (MSG_ALL, SVC_FINALE);
WriteString (MSG_ALL, "$qc_finale_e3");
return;
}
else if (world.model == "maps/e4m7.bsp")
{
WriteByte (MSG_ALL, SVC_CDTRACK);
WriteByte (MSG_ALL, 2);
WriteByte (MSG_ALL, 3);
WriteByte (MSG_ALL, SVC_FINALE);
WriteString (MSG_ALL, "$qc_finale_e4");
return;
}
GotoNextMap();
}
if (intermission_running == 3)
{
if (!cvar("registered"))
{ // shareware episode has been completed, go to sell screen
WriteByte (MSG_ALL, SVC_SELLSCREEN);
return;
}
if ( (serverflags&15) == 15)
{
WriteByte (MSG_ALL, SVC_FINALE);
WriteString (MSG_ALL, "$qc_finale_all_runes");
return;
}
}
GotoNextMap();
};
/*
============
IntermissionThink
When the player presses attack or jump, change to the next level
============
*/
void() IntermissionThink =
{
if (time < intermission_exittime)
return;
if (!self.button0 && !self.button1 && !self.button2)
return;
ExitIntermission ();
};
void() execute_changelevel =
{
local entity pos;
intermission_running = 1;
// enforce a wait time before allowing changelevel
if (deathmatch)
intermission_exittime = time + 5;
else
intermission_exittime = time + 2;
WriteByte (MSG_ALL, SVC_CDTRACK);
WriteByte (MSG_ALL, 3);
WriteByte (MSG_ALL, 3);
pos = FindIntermission ();
other = find (world, classname, "player");
while (other != world)
{
other.view_ofs = '0 0 0';
other.angles = other.v_angle = pos.mangle;
other.fixangle = TRUE; // turn this way immediately
other.nextthink = time + 0.5;
other.takedamage = DAMAGE_NO;
other.solid = SOLID_NOT;
other.movetype = MOVETYPE_NONE;
other.modelindex = 0;
setorigin (other, pos.origin);
other = find (other, classname, "player");
}
WriteByte (MSG_ALL, SVC_INTERMISSION);
};
void() changelevel_touch =
{
local entity pos;
local float noexit;
if (other.classname != "player")
return;
noexit = cvar("noexit");
if (noexit == 1 || (noexit == 2 && !gamestart))
return; // do nothing
if (coop || deathmatch)
{
bprint("$qc_exited", other.netname);
}
nextmap = self.map;
SUB_UseTargets ();
if ( (self.spawnflags & 1) && (deathmatch == 0) )
{ // NO_INTERMISSION
GotoNextMap();
return;
}
self.touch = SUB_Null;
// we can't move people right now, because touch functions are called
// in the middle of C movement code, so set a think time to do it
self.think = execute_changelevel;
self.nextthink = time + 0.1;
};
/*QUAKED trigger_changelevel (0.5 0.5 0.5) ? NO_INTERMISSION
When the player touches this, he gets sent to the map listed in the "map" variable. Unless the NO_INTERMISSION flag is set, the view will go to the info_intermission spot and display stats.
*/
void() trigger_changelevel =
{
if (!self.map)
objerror ("chagnelevel trigger doesn't have map");
InitTrigger ();
self.touch = changelevel_touch;
};
/*
=============================================================================
PLAYER GAME EDGE FUNCTIONS
=============================================================================
*/
void() set_suicide_frame;
// called by ClientKill and DeadThink
void() respawn =
{
// make a copy of the dead body for appearances sake
CopyToBodyQueue (self);
// set default spawn parms
SetNewParms ();
// respawn
PutClientInServer ();
};
/*
============
ClientKill
Player entered the suicide command
============
*/
void() ClientKill =
{
if (self.observer)
return; // can't suicide when observer
if (gamestart) {
return;
}
if (self.suicide_count > 3) {
sprint(self, "$qc_ctf_too_many_suicide");
return;
}
bprint("$qc_suicides", self.netname);
DropRune();
TeamCaptureDropFlagOfPlayer(self);
UnHookPlayer();
set_suicide_frame ();
self.modelindex = modelindex_player;
self.frags = self.frags - 2; // extra penalty
self.suicide_count = self.suicide_count + 1;
respawn ();
};
void() SilentKill =
{
set_suicide_frame ();
self.modelindex = modelindex_player;
respawn ();
};
float(vector v) CheckSpawnPoint =
{
return FALSE;
};
/*
============
SelectSpawnPoint
Returns the entity to spawn at
============
*/
entity() SelectSpawnPoint =
{
local entity spot;
// testinfo_player_start is only found in regioned levels
spot = find (world, classname, "testplayerstart");
if (spot)
return spot;
// choose a info_player_deathmatch point
if (coop)
{
lastspawn = find(lastspawn, classname, "info_player_coop");
if (lastspawn == world)
lastspawn = find (lastspawn, classname, "info_player_start");
if (lastspawn != world)
return lastspawn;
}
else if (deathmatch)
{
if (!self.killed) {
spot = TeamCaptureSpawn();
if (spot != world)
return spot;
} else if (gamestart && self.killed) {
lastvotespawn = find(lastvotespawn, classname, "info_vote_destination");
if (lastvotespawn == world)
lastvotespawn = find(lastvotespawn, classname, "info_vote_destination");
return lastvotespawn;
}
lastspawn = find(lastspawn, classname, "info_player_deathmatch");
if (lastspawn == world)
lastspawn = find (lastspawn, classname, "info_player_deathmatch");
if (lastspawn != world)
return lastspawn;
}
if (serverflags)
{ // return with a rune to start
spot = find (world, classname, "info_player_start2");
if (spot)
return spot;
}
spot = find (world, classname, "info_player_start");
if (!spot)
error ("PutClientInServer: no info_player_start on level");
return spot;
};
/*
===========
PutClientInServer
called each time a player is spawned
============
*/
void() DecodeLevelParms;
void() PlayerDie;
void() PutClientInServer =
{
local entity spot;
serverflags = 0; // make sure it's clear
spot = SelectSpawnPoint ();
self.classname = "player";
self.health = 100;
self.takedamage = DAMAGE_AIM;
self.solid = SOLID_SLIDEBOX;
self.movetype = MOVETYPE_WALK;
self.show_hostile = 0;
self.max_health = 100;
self.flags = FL_CLIENT;
self.air_finished = time + 12;
self.dmg = 2; // initial water damage
self.super_damage_finished = 0;
self.radsuit_finished = 0;
self.invisible_finished = 0;
self.invincible_finished = 0;
self.effects = 0;
self.invincible_time = 0;
self.staydeadtime = 0;
self.regen_time = 0;
self.rune_notice_time = 0;
self.last_hurt_carrier = -10;
DecodeLevelParms ();
W_SetCurrentAmmo ();
self.attack_finished = time;
self.th_pain = player_pain;
self.th_die = PlayerDie;
self.deadflag = DEAD_NO;
// paustime is set by teleporters to keep the player from moving a while
self.pausetime = 0;
// spot = SelectSpawnPoint ();
self.fixangle = TRUE; // turn this way immediately
// oh, this is a hack!
setmodel (self, "progs/eyes.mdl");
modelindex_eyes = self.modelindex;
setmodel (self, "progs/player.mdl");
modelindex_player = self.modelindex;
setsize (self, VEC_HULL_MIN, VEC_HULL_MAX);
self.view_ofs = '0 0 22';
self.origin = spot.origin + '0 0 1';
self.angles = spot.angles;
player_stand1 ();
if (self.do_observer) {
BecomeObserver(self);
return;
}
if (deathmatch || coop)
{
makevectors(self.angles);
spawn_tfog (self.origin + v_forward*20);
}
spawn_tdeath (self.origin, self);
};
/*
=============================================================================
QUAKED FUNCTIONS
=============================================================================
*/
/*QUAKED info_player_start (1 0 0) (-16 -16 -24) (16 16 24)
The normal starting point for a level.
*/
void() info_player_start =
{
};
/*QUAKED info_player_start2 (1 0 0) (-16 -16 -24) (16 16 24)
Only used on start map for the return point from an episode.
*/
void() info_player_start2 =
{
};
void() SpawnRunes;
/*
saved out by quaked in region mode
*/
void() testplayerstart =
{
};
/*QUAKED info_player_deathmatch (1 0 1) (-16 -16 -24) (16 16 24)
potential spawning position for deathmatch games
*/
void() info_player_deathmatch =
{
if (deathmatch)
StartRuneSpawn();
};
void() info_player_team1 =
{
};
void() info_player_team2 =
{
};
/*QUAKED info_player_coop (1 0 1) (-16 -16 -24) (16 16 24)
potential spawning position for coop games
*/
void() info_player_coop =
{
};
/*
===============================================================================
RULES
===============================================================================
*/
/*
go to the next level for deathmatch
only called if a time or frag limit has expired
*/
void() NextLevel =
{
local entity o;
if (mapname == "ctf1") nextmap = "ctf2";
else if (mapname == "ctf2") nextmap = "ctf3";
else if (mapname == "ctf3") nextmap = "ctf4";
else if (mapname == "ctf4") nextmap = "ctf5";
else if (mapname == "ctf5") nextmap = "ctf6";
else if (mapname == "ctf6") nextmap = "ctf7";
else if (mapname == "ctf7") nextmap = "ctf8";
else if (mapname == "ctf8") nextmap = "ctf9";
else if (mapname == "ctf9") nextmap = "ctf1";
else nextmap = "ctf1";
o = spawn();
o.map = nextmap;
o.think = execute_changelevel;
o.nextthink = time + 0.1;
};
/*
============
CheckRules
Exit deathmatch games upon conditions
============
*/
void() CheckRules =
{
local float timelimit;
local float fraglimit;
local entity o;
if (gameover || pregameover) // someone else quit the game already
return;
if (gamestart) {
if ((vote_leader != world) && voteexit_time && (time > voteexit_time)) {
pregameover = 1;
o = spawn();
nextmap = vote_leader.map;
o.map = nextmap;
o.think = execute_changelevel;
o.nextthink = time + 0.1;
return;
}
return;
}
timelimit = cvar("timelimit") * 60;
fraglimit = cvar("fraglimit");
if ((timelimit && time >= timelimit) ||
(fraglimit && (teamscr1 >= fraglimit || teamscr2 >= fraglimit))) {
pregameover = 1;
TeamEndScore();
NextLevel ();
return;
}
};
//============================================================================
void() PlayerDeathThink =
{
local entity old_self;
local float forward;
if ((self.flags & FL_ONGROUND))
{
forward = vlen (self.velocity);
forward = forward - 20;
if (forward <= 0)
self.velocity = '0 0 0';
else
self.velocity = forward * normalize(self.velocity);
}
// wait for all buttons released
if (self.deadflag == DEAD_DEAD)
{
if (self.button2 || self.button1 || self.button0)
return;
self.deadflag = DEAD_RESPAWNABLE;
return;
}
// wait for any button down
if (!self.button2 && !self.button1 && !self.button0)
return;
self.button0 = 0;
self.button1 = 0;
self.button2 = 0;
respawn();
};
void() PlayerJump =
{
local vector start, end;
if (self.flags & FL_WATERJUMP)
return;
if (self.waterlevel >= 2)
{
if (self.watertype == CONTENT_WATER)
self.velocity_z = 100;
else if (self.watertype == CONTENT_SLIME)
self.velocity_z = 80;
else
self.velocity_z = 50;
// play swiming sound
if (self.swim_flag < time)
{
self.swim_flag = time + 1;
if (random() < 0.5)
sound (self, CHAN_BODY, "misc/water1.wav", 1, ATTN_NORM);
else
sound (self, CHAN_BODY, "misc/water2.wav", 1, ATTN_NORM);
}
return;
}
if (!(self.flags & FL_ONGROUND))
return;
if ( !(self.flags & FL_JUMPRELEASED) )
return; // don't pogo stick
self.flags = self.flags - (self.flags & FL_JUMPRELEASED);
self.flags = self.flags - FL_ONGROUND; // don't stairwalk
self.button2 = 0;
// player jumping sound
sound (self, CHAN_BODY, "player/plyrjmp8.wav", 1, ATTN_NORM);
self.velocity_z = self.velocity_z + 270;
};
/*
===========
WaterMove
============
*/
.float dmgtime;
void() WaterMove =
{
//dprint (ftos(self.waterlevel));
if (self.movetype == MOVETYPE_NOCLIP)
return;
if (self.health < 0)
return;
if (self.waterlevel != 3)
{
if (self.air_finished < time)
sound (self, CHAN_VOICE, "player/gasp2.wav", 1, ATTN_NORM);
else if (self.air_finished < time + 9)
sound (self, CHAN_VOICE, "player/gasp1.wav", 1, ATTN_NORM);
self.air_finished = time + 12;
self.dmg = 2;
}
else if (self.air_finished < time)
{ // drown!
if (self.pain_finished < time)
{
self.dmg = self.dmg + 2;
if (self.dmg > 15)
self.dmg = 10;
T_Damage (self, world, world, self.dmg);
self.pain_finished = time + 1;
}
}
if (!self.waterlevel)
{
if (self.flags & FL_INWATER)
{
// play leave water sound
sound (self, CHAN_BODY, "misc/outwater.wav", 1, ATTN_NORM);
self.flags = self.flags - FL_INWATER;
}
return;
}
if (self.watertype == CONTENT_LAVA)
{ // do damage
if (self.dmgtime < time)
{
if (self.radsuit_finished > time)
self.dmgtime = time + 1;
else
self.dmgtime = time + 0.2;
T_Damage (self, world, world, 10*self.waterlevel);
}
}
else if (self.watertype == CONTENT_SLIME)
{ // do damage
if (self.dmgtime < time && self.radsuit_finished < time)
{
self.dmgtime = time + 1;
T_Damage (self, world, world, 4*self.waterlevel);
}
}
if ( !(self.flags & FL_INWATER) )
{
// player enter water sound
if (self.watertype == CONTENT_LAVA)
sound (self, CHAN_BODY, "player/inlava.wav", 1, ATTN_NORM);
if (self.watertype == CONTENT_WATER)
sound (self, CHAN_BODY, "player/inh2o.wav", 1, ATTN_NORM);
if (self.watertype == CONTENT_SLIME)
sound (self, CHAN_BODY, "player/slimbrn2.wav", 1, ATTN_NORM);
self.flags = self.flags + FL_INWATER;
self.dmgtime = 0;
}
if (! (self.flags & FL_WATERJUMP) )
self.velocity = self.velocity - 0.8*self.waterlevel*frametime*self.velocity;
};
void() CheckWaterJump =
{
local vector start, end;
// check for a jump-out-of-water
makevectors (self.angles);
start = self.origin;
start_z = start_z + 8;
v_forward_z = 0;
normalize(v_forward);
end = start + v_forward*24;
traceline (start, end, TRUE, self);
if (trace_fraction < 1)
{ // solid at waist
start_z = start_z + self.maxs_z - 8;
end = start + v_forward*24;
self.movedir = trace_plane_normal * -50;
traceline (start, end, TRUE, self);
if (trace_fraction == 1)
{ // open at eye level
self.flags = self.flags | FL_WATERJUMP;
self.velocity_z = 225;
self.flags = self.flags - (self.flags & FL_JUMPRELEASED);
self.teleport_time = time + 2; // safety net
return;
}
}
};
/*
================
PlayerPreThink
Called every frame before physics are run
================
*/
void() PlayerPreThink =
{
local float mspeed, aspeed;
local float r;
local string s;
if (intermission_running)
{
IntermissionThink (); // otherwise a button could be missed between
return; // the think tics
}
if (self.staydeadtime && self.staydeadtime > time)
return;// wait a bit before respawn
// *TEAMPLAY*
if (coop && TEAM_STRICT_COOP)
return;
if (self.motd_sent == 2)
{
self.motd_sent += 1;
if (self.observer)
MOTD_ChooseTeam();
else
MOTD();
}
// don't send the message immediately on connect, wait a frame
if (self.motd_sent < 2)
self.motd_sent += 1;
if ( self.flags & FL_ISBOT ) { // make sure bots end up on a team...
if ( self.team != TEAM_COLOR1 && self.team != TEAM_COLOR2 ) {
self.impulse = 103;
}
}
DoObserverImpulse();
if (self.view_ofs == '0 0 0')
return; // intermission or finale
makevectors (self.v_angle); // is this still used
CheckRules ();
WaterMove ();
// *TEAMPLAY*
// TeamCheckLock performs all necessary teamlock checking, and performs all
// actions needed.
TeamCheckLock();
if (self.waterlevel == 2)
CheckWaterJump ();
if (self.deadflag >= DEAD_DEAD)
{
PlayerDeathThink ();
return;
}
//ZOID-Observer
if (self.observer) {
ObserverThink();
return;
}
//
if (self.deadflag == DEAD_DYING)
return; // dying, so do nothing
if (self.button2)
{
PlayerJump ();
}
else
self.flags = self.flags | FL_JUMPRELEASED;
// teleporters can force a non-moving pause time
if (time < self.pausetime)
self.velocity = '0 0 0';
// RUNE: If player has rune of elder magic (4), regeneration
if (self.player_flag & ITEM_RUNE4_FLAG) {
if (self.regen_time < time) {
self.regen_time = time;
if (self.health < 150) {
self.health = self.health + 5;
if (self.health > 150)
self.health = 150;
self.regen_time = self.regen_time + 0.5;
RegenerationSound();
}
if (self.armorvalue < 150 && self.armortype) {
self.armorvalue = self.armorvalue + 5;
if (self.armorvalue > 150)
self.armorvalue = 150;
self.regen_time = self.regen_time + 0.5;
RegenerationSound();
}
}
}
// RUNE
if(time > self.attack_finished && self.currentammo == 0 &&
self.weapon != IT_AXE && self.weapon != IT_HOOK)
{
self.weapon = W_BestWeapon ();
W_SetCurrentAmmo ();
}
// Track the grapple
if (self.hook_out)
GrappleTrail(self.goalentity, self);
};
/*
================
CheckPowerups
Check for turning off powerups
================
*/
void() CheckPowerups =
{
if (self.health <= 0)
return;
// invisibility
if (self.invisible_finished)
{
// sound and screen flash when items starts to run out
if (self.invisible_sound < time)
{
sound (self, CHAN_AUTO, "items/inv3.wav", 0.5, ATTN_IDLE);
self.invisible_sound = time + ((random() * 3) + 1);
}
if (self.invisible_finished < time + 3)
{
if (self.invisible_time == 1)
{
sprint(self, "$qc_ring_fade");
stuffcmd (self, "bf\n");
sound (self, CHAN_AUTO, "items/inv2.wav", 1, ATTN_NORM);
self.invisible_time = time + 1;
}
if (self.invisible_time < time)
{
self.invisible_time = time + 1;
stuffcmd (self, "bf\n");
}
}
if (self.invisible_finished < time)
{ // just stopped
self.items = self.items - IT_INVISIBILITY;
self.invisible_finished = 0;
self.invisible_time = 0;
}
// use the eyes
self.frame = 0;
self.modelindex = modelindex_eyes;
}
else
self.modelindex = modelindex_player; // don't use eyes
// invincibility
if (self.invincible_finished)
{
// sound and screen flash when items starts to run out
if (self.invincible_finished < time + 3)
{
if (self.invincible_time == 1)
{
sprint(self, "$qc_protection_fade");
stuffcmd (self, "bf\n");
sound (self, CHAN_AUTO, "items/protect2.wav", 1, ATTN_NORM);
self.invincible_time = time + 1;
}
if (self.invincible_time < time)
{
self.invincible_time = time + 1;
stuffcmd (self, "bf\n");
}
}
if (self.invincible_finished < time)
{ // just stopped
self.items = self.items - IT_INVULNERABILITY;
self.invincible_time = 0;
self.invincible_finished = 0;
}
// ZOID, next line isn't needed, EF_DIMLIGHT is handled by
// client.qc:CheckDimLight
// if (self.invincible_finished > time)
// self.effects = self.effects | EF_DIMLIGHT;
// else
// self.effects = self.effects - (self.effects & EF_DIMLIGHT);
}
// super damage
if (self.super_damage_finished)
{
// sound and screen flash when items starts to run out
if (self.super_damage_finished < time + 3)
{
if (self.super_time == 1)
{
sprint(self, "$qc_quad_fade");
stuffcmd (self, "bf\n");
sound (self, CHAN_AUTO, "items/damage2.wav", 1, ATTN_NORM);
self.super_time = time + 1;
}
if (self.super_time < time)
{
self.super_time = time + 1;
stuffcmd (self, "bf\n");
}
}
if (self.super_damage_finished < time)
{ // just stopped
self.items = self.items - IT_QUAD;
self.super_damage_finished = 0;
self.super_time = 0;
}
// ZOID, next line isn't needed, EF_DIMLIGHT is handled by
// client.qc:CheckDimLight
// if (self.super_damage_finished > time)
// self.effects = self.effects | EF_DIMLIGHT;
// else
// self.effects = self.effects - (self.effects & EF_DIMLIGHT);
}
// suit
if (self.radsuit_finished)
{
self.air_finished = time + 12; // don't drown
// sound and screen flash when items starts to run out
if (self.radsuit_finished < time + 3)
{
if (self.rad_time == 1)
{
sprint(self, "$qc_biosuit_fade");
stuffcmd (self, "bf\n");
sound (self, CHAN_AUTO, "items/suit2.wav", 1, ATTN_NORM);
self.rad_time = time + 1;
}
if (self.rad_time < time)
{
self.rad_time = time + 1;
stuffcmd (self, "bf\n");
}
}
if (self.radsuit_finished < time)
{ // just stopped
self.items = self.items - IT_SUIT;
self.rad_time = 0;
self.radsuit_finished = 0;
}
}
// Check to see about DIMLIGHT effects
CheckDimLight();
};
/*
================
PlayerPostThink
Called every frame after physics are run
================
*/
void() PlayerPostThink =
{
local float mspeed, aspeed;
local float r;
local string num;
if (self.view_ofs == '0 0 0')
return; // intermission or finale
if (self.deadflag) {
return;
}
// do weapon stuff
if (!self.observer)
W_WeaponFrame ();
// check to see if player landed and play landing sound
if ((self.jump_flag < -300) && (self.flags & FL_ONGROUND) && (self.health > 0))
{
if (self.watertype == CONTENT_WATER)
sound (self, CHAN_BODY, "player/h2ojump.wav", 1, ATTN_NORM);
else if (self.jump_flag < -650 && !self.hook_pulling)
{
T_Damage (self, world, world, 5);
sound (self, CHAN_VOICE, "player/land2.wav", 1, ATTN_NORM);
self.deathtype = "falling";
}
else
sound (self, CHAN_VOICE, "player/land.wav", 1, ATTN_NORM);
self.jump_flag = 0;
}
if (!(self.flags & FL_ONGROUND))
self.jump_flag = self.velocity_z;
CheckPowerups ();
};
/*
===========
ClientConnect
called when a player connects to a server
============
*/
void() ClientConnect =
{
bprint("$qc_entered", self.netname);
LogMsg(self, "CONNECT");
self.suicide_count = 0;
self.killed = 0;
self.frags = 0;
self.voted = 0;
self.motd_sent = 0;
if ( parm10 < 0 && teamplay > 0 ) {
// *TEAMPLAY*
// If this is our first connection, parm10 is < 0
// Set lastteam negative.
self.lastteam = -50;
self.team = -1;
if ( teamplay & TEAM_CAPTURE_SELECT_TEAM ) {
self.do_observer = 1;
} else if ( !self.do_observer ) {
TeamCheckLock();
self.player_flag = self.player_flag | TEAM_STUFF_COLOR;
self.player_flag = self.player_flag - ( self.player_flag & 65280 );
self.player_flag = self.player_flag | ( self.skin * 256 );
}
}
SendCTFScoresUpdate( self );
// a client connecting during an intermission can cause problems
if ( intermission_running ) {
ExitIntermission();
}
};
/*
===========
ClientDisconnect
called when a player disconnects from a server
============
*/
void() ClientDisconnect =
{
if (gameover)
return;
// if the level end trigger has been activated, just return
// since they aren't *really* leaving
// let everyone else know
bprint("$qc_left_game", self.netname, ftos(self.frags));
sound (self, CHAN_BODY, "player/tornoff2.wav", 1, ATTN_NONE);
DropRune();
TeamCaptureDropFlagOfPlayer(self);
set_suicide_frame ();
self.lastteam = -50;
self.team = -50;
self.frags = 0;
self.statstate = 0;
LogMsg(self, "DISCONNECT");
};
// *TEAMPLAY*
// Prototypes
float(entity targ, entity attacker) TeamFragPenalty;
void(entity targ, entity attacker) TeamDeathPenalty;
/*
===========
ClientObituary
called when a player dies
============
*/
void(entity targ, entity attacker) ClientObituary =
{
// *XXX* EXPERT CTF variable for
// flag/flag carrier defense bonus determination
local entity head;
local float flag_radius;
local float flag_carrier_radius;
local float rnum;
// from GPL QW source
local float attackerteam, targteam;
attackerteam = attacker.team;
targteam = targ.team;
local string s;
rnum = random();
if (targ.classname == "player")
{
// *XXX* EXPERT CTF:
// When the flag carrier dies, reset the last_hurt_carrier field in
// all players on the opposite team from the flag carrier. The carrier
// has been killed, so there is no longer a reason to award points for
// killing off his assailants
if (targ.player_flag & ITEM_ENEMY_FLAG) {
head = find(world, classname, "player");
while (head != world) {
if (head.team != targ.team) {
head.last_hurt_carrier = -10;
}
head = find(head, classname, "player");
}
}
// END EXPERT CTF
if (attacker.classname == "teledeath")
{
bprint("$qc_telefragged", targ.netname, attacker.owner.netname);
attacker.owner.frags = attacker.owner.frags + 1;
LogPlayerDMDeath(targ, attacker.owner, "telefrag");
return;
}
if (attacker.classname == "teledeath2")
{
bprint("$qc_satans_power", targ.netname);
targ.frags = targ.frags - 1;
LogPlayerDeath(targ, "telefrag");
return;
}
if (attacker.classname == "player")
{
if (targ == attacker)
{
// killed self
attacker.frags = attacker.frags - 1;
if (targ.weapon == 64 && targ.waterlevel > 1)
{
if (targ.watertype == CONTENT_SLIME)
bprint("$qc_discharge_slime", targ.netname);
else if (targ.watertype == CONTENT_LAVA)
bprint("$qc_discharge_lava", targ.netname);
else
bprint("$qc_discharge_water", targ.netname);
LogPlayerDeath(targ, "discharge");
return;
}
if (targ.weapon == IT_GRENADE_LAUNCHER) {
bprint("$qc_suicide_pin", targ.netname);
LogPlayerDeath(targ, "grenade");
} else if (targ.team != targ.lastteam) {
//ZOID: try if player was gibbed for changing teams
if (teamplay & TEAM_STATIC_TEAMS)
bprint ("$qc_ks_tried_change_teams", targ.netname);
else
bprint ("$qc_ks_changed_teams", targ.netname);
LogPlayerDeath(targ, "teamchange");
} else {
bprint("$qc_suicide_bored", targ.netname);
LogPlayerDeath(targ, "rocket");
}
return;
}
else if ( (teamplay == 2) && (targteam == attackerteam) &&
(attackerteam != 0) )
{
if (rnum < 0.25)
bprint("$qc_ff_teammate", attacker.netname);
else if (rnum < 0.50)
bprint("$qc_ff_glasses", attacker.netname);
else if (rnum < 0.75)
bprint("$qc_ff_otherteam", attacker.netname);
else
bprint("$qc_ff_friend", attacker.netname);
attacker.frags = attacker.frags - 1;
return;
}
else
{
// *TEAMPLAY*
// TeamFragPenalty returns true if the attacker gets a frag penalty for
// killing this target. It also deducts frags as needed.
if (!TeamFragPenalty(targ, attacker)) {
// the attacker is award the normal one frag.. now we
// determine if he gets any bonuses
attacker.frags = attacker.frags + 1;
if ((targ.player_flag & ITEM_ENEMY_FLAG) &&
(targ.team != attacker.team)) {
//ZOID: one team fragged the other team's flag carrier
// *XXX* EXPERT CTF
// Mark the attacker with the time at which he killed the flag
// carrier, for awarding assist points
attacker.last_fragged_carrier = time;
// *XXX* EXPERT CTF: give player only the normal amount of frags
// if the carrier has only had the flag for a few seconds, to
// prevent ppl intentionally allowing enemies to grab the flag,
// then immediately fragging them
if (targ.flag_since + TEAM_CAPTURE_CARRIER_FLAG_SINCE_TIMEOUT > time) {
sprint(attacker, "$qc_ctf_carrier_no_bonus");
} else {
attacker.frags = attacker.frags + TEAM_CAPTURE_FRAG_CARRIER_BONUS;
// TeamScore (attacker, TEAM_CAPTURE_FRAG_CARRIER_BONUS);
s = ftos(TEAM_CAPTURE_FRAG_CARRIER_BONUS);
sprint(attacker, "$qc_ctf_kill_carrier", s);
}
// END FLAG CARRIER FRAG CODE
}
// *XXX* EXPERT CTF
// This code checks for all game-critical kills OTHER THAN fragging the enemy
// flag carrier, like killing players who are trying to kill your flag carrier
// or trying to grab your flag, and hands out bonus frags.
// The two variables below track whether special bonus frags have already
// been awarded for the attacker or target being near the flag or flag carrier.
flag_radius = 0;
flag_carrier_radius = 0;
// get a string for the attacker's team now, for later announcements
s = GetCTFTeam(attacker.team);
if ((targ.last_hurt_carrier + TEAM_CAPTURE_CARRIER_DANGER_PROTECT_TIMEOUT > time) &&
!(attacker.player_flag & ITEM_ENEMY_FLAG) ) {
// a player on the same team as the flag carrier killed
// someone who recently shot the flag carrier
attacker.frags = attacker.frags +
TEAM_CAPTURE_CARRIER_DANGER_PROTECT_BONUS;
flag_carrier_radius = 1;
// NOTE: getting CARRIER_DANGER_PROTECT_BONUS precludes getting
// other kinds of bonuses for defending the flag carrier, since
// it's worth more points
bprint("$qc_ks_defends_carrier_aggressive", attacker.netname, s);
}
// *XXX* EXPERT CTF
// Bonusus for defending the flag carrier or the flag itself.
// Extra frags are awarded if either the attacker or the target are
// 1. within 40 feet of a flag carrier on the same team as the attacker
// 2. within 40 feet of the attacker's flag
// These bonuses are cumulative with respect to defending both the
// flag and the flag carrier at the same time, but not cumulative with
// respect to both the target and attacker being near the object being defended
// find flags or flag carriers within a radius of the attacker
head = findradius(attacker.origin, TEAM_CAPTURE_ATTACKER_PROTECT_RADIUS);
while (head) {
if (head.classname == "player") {
if ( (head.team == attacker.team) &&
(head.player_flag & ITEM_ENEMY_FLAG) &&
(head != attacker) && // self defense
(!flag_carrier_radius) ) {
// attacker was near his own flag carrier
attacker.frags = attacker.frags +
TEAM_CAPTURE_CARRIER_PROTECT_BONUS;
flag_carrier_radius = 1;
bprint("$qc_ks_defends_carrier", attacker.netname, s);
}
}
if ( (head.classname == "item_flag_team1") ||
(head.classname == "item_flag_team2")) {
if (((attacker.team == TEAM_COLOR1) &&
(head.classname == "item_flag_team1")) ||
((attacker.team == TEAM_COLOR2) &&
(head.classname == "item_flag_team2"))) {
// attacker was near his own flag
attacker.frags = attacker.frags +
TEAM_CAPTURE_FLAG_DEFENSE_BONUS;
flag_radius = 1;
bprint("$qc_ks_defends_flag", attacker.netname, s);
}
}
head = head.chain;
}
// find flags or flag carriers within a radius from the target
head = findradius(targ.origin, TEAM_CAPTURE_TARGET_PROTECT_RADIUS);
while (head) {
if (head.classname == "player") {
if ( (head.team == attacker.team) &&
(head.player_flag & ITEM_ENEMY_FLAG) &&
(head != attacker) &&
(!flag_carrier_radius)) { // prevents redundant points awarded
// target was near attacker's flag carrier
attacker.frags = attacker.frags +
TEAM_CAPTURE_CARRIER_PROTECT_BONUS;
flag_carrier_radius = 1;
bprint("$qc_ks_defends_carrier", attacker.netname, s);
}
}
if (((attacker.team == TEAM_COLOR1) &&
(head.classname == "item_flag_team1")) ||
((attacker.team == TEAM_COLOR2) &&
(head.classname == "item_flag_team2"))
&& (!flag_radius)) { // prevents redundant points awarded
// target was near attacker's flag
attacker.frags = attacker.frags +
TEAM_CAPTURE_FLAG_DEFENSE_BONUS;
flag_radius = 1;
bprint("$qc_ks_defends_the_flag", attacker.netname, s);
}
head = head.chain;
}
}
// *XXX* EXPERT CTF
// End frag determination code. Now determine death text for
// a member of one team killing a member of the other
// *TEAMPLAY*
// TeamDeathPenalty kills the attacker if necessary and adjusts frags to
// offset the one frag penalty for dying.
TeamDeathPenalty(targ, attacker);
rnum = attacker.weapon;
if (rnum == IT_AXE)
{
bprint("$qc_death_ax", targ.netname, attacker.netname);
LogPlayerDMDeath(targ, attacker, "axe");
return;
}
if (rnum == IT_HOOK) {
LogPlayerDMDeath(targ, attacker, "hook");
if (random() < 0.5)
bprint("$qc_death_hook1", targ.netname, attacker.netname);
else
bprint("$qc_death_hook2", targ.netname, attacker.netname);
return;
}
if (rnum == IT_SHOTGUN)
{
bprint("$qc_death_sg", targ.netname, attacker.netname);
LogPlayerDMDeath(targ, attacker, "shotgun");
return;
}
if (rnum == IT_SUPER_SHOTGUN)
{
bprint("$qc_death_dbl", targ.netname, attacker.netname);
LogPlayerDMDeath(targ, attacker, "supershotgun");
return;
}
if (rnum == IT_NAILGUN)
{
bprint("$qc_death_nail", targ.netname, attacker.netname);
LogPlayerDMDeath(targ, attacker, "nailgun");
return;
}
if (rnum == IT_SUPER_NAILGUN)
{
bprint("$qc_death_sng", targ.netname, attacker.netname);
LogPlayerDMDeath(targ, attacker, "supernailgun");
return;
}
if (rnum == IT_GRENADE_LAUNCHER)
{
LogPlayerDMDeath(targ, attacker, "grenade");
if (targ.health < -40)
{
bprint("$qc_death_gl1", targ.netname, attacker.netname);
return;
}
else
{
bprint("$qc_death_gl2", targ.netname, attacker.netname);
return;
}
}
if (rnum == IT_ROCKET_LAUNCHER)
{
LogPlayerDMDeath(targ, attacker, "rocket");
if (attacker.super_damage_finished > 0 && targ.health < -40)
{
rnum = random();
if (rnum < 0.3)
{
bprint("$qc_death_rl_quad1", targ.netname, attacker.netname);
return;
}
else if (rnum < 0.6)
{
bprint("$qc_death_rl_quad2", targ.netname, attacker.netname);
return;
}
else
{
bprint("$qc_death_rl1", targ.netname, attacker.netname);
return;
}
}
else
{
if (targ.health < -40)
{
bprint("$qc_death_rl2", targ.netname, attacker.netname);
return;
}
else
{
bprint("$qc_death_rl3", targ.netname, attacker.netname);
return;
}
}
}
if (rnum == IT_LIGHTNING)
{
LogPlayerDMDeath(targ, attacker, "lightning");
if (attacker.waterlevel > 1)
{
bprint("$qc_death_lg1", targ.netname, attacker.netname);
if (attacker.invincible_finished)
{
msg_entity = attacker;
WriteByte (MSG_ONE, SVC_ACHIEVEMENT);
WriteString(MSG_ONE, "ACH_SURVIVE_DISCHARGE");
}
}
else
bprint("$qc_death_lg2", targ.netname, attacker.netname);
return;
}
}
return;
}
else
{
targ.frags = targ.frags - 1; // killed self
rnum = targ.watertype;
if (rnum == -3)
{
LogPlayerDMDeath(targ, attacker, "drowned");
if (random() < 0.5)
bprint("$qc_death_drown1", targ.netname);
else
bprint("$qc_death_drown2", targ.netname);
return;
}
else if (rnum == -4)
{
LogPlayerDMDeath(targ, attacker, "slimed");
if (random() < 0.5)
bprint("$qc_death_slime1", targ.netname);
else
bprint("$qc_death_slime2", targ.netname);
return;
}
else if (rnum == -5)
{
LogPlayerDMDeath(targ, attacker, "melted");
if (targ.health < -15)
{
bprint("$qc_death_lava1", targ.netname);
return;
}
if (random() < 0.5)
bprint("$qc_death_lava2", targ.netname);
else
bprint("$qc_death_lava3", targ.netname);
return;
}
if (attacker.solid == SOLID_BSP && attacker != world)
{
bprint("$qc_death_squish", targ.netname);
LogPlayerDMDeath(targ, attacker, "squished");
return;
}
if (targ.deathtype == "falling")
{
targ.deathtype = string_null;
bprint("$qc_death_fall", targ.netname);
LogPlayerDMDeath(targ, attacker, "falling");
return;
}
bprint("$qc_death_died", targ.netname);
LogPlayerDMDeath(targ, attacker, "died");
}
}
};
Reference in a new issue View git blame Copy permalink