mirror of
https://git.code.sf.net/p/quake/game-source
synced 2024-11-26 13:51:15 +00:00
430 lines
13 KiB
C++
430 lines
13 KiB
C++
/*
|
|
#FILENAME#
|
|
|
|
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:
|
|
|
|
Free Software Foundation, Inc.
|
|
59 Temple Place - Suite 330
|
|
Boston, MA 02111-1307, USA
|
|
|
|
$Id$
|
|
*/
|
|
|
|
/*
|
|
===========================================================================
|
|
grapple.qc 12/29/96
|
|
|
|
Quakeworld-friendly grapple hook code by Wedge (Steve Bond)
|
|
visit Quake Command http://www.nuc.net/quake
|
|
|
|
|
|
Original 'Morning Star' (Grapple Hook) by "Mike" <amichael@asu.alasu.edu>
|
|
I took care to preserve the speed and damage values of the original
|
|
Morning Star. Depending on latency, performance should be near exact.
|
|
===========================================================================
|
|
*/
|
|
|
|
// prototypes for WEAPONS.QC functions
|
|
float() crandom;
|
|
void(vector org, float damage) SpawnBlood;
|
|
|
|
//
|
|
// Reset_Grapple - Removes the hook and resets its owner's state.
|
|
// expects a pointer to the hook
|
|
//
|
|
void (entity rhook) Reset_Grapple =
|
|
{
|
|
if (rhook.owner == world)
|
|
return;
|
|
|
|
sound (rhook.owner, CHAN_NO_PHS_ADD+CHAN_WEAPON, "weapons/bounce2.wav", 1, ATTN_NORM);
|
|
rhook.owner.on_hook = FALSE;
|
|
rhook.owner.hook_out = FALSE;
|
|
rhook.owner.weaponframe = 0;
|
|
rhook.owner.attack_finished = time + 0.25;
|
|
|
|
rhook.think = SUB_Remove;
|
|
rhook.nextthink = time;
|
|
};
|
|
|
|
//
|
|
// Grapple_Track - Constantly updates the hook's position relative to
|
|
// what it's hooked to. Inflicts damage if attached to
|
|
// a player that is not on the same team as the hook's
|
|
// owner.
|
|
//
|
|
void () Grapple_Track =
|
|
{
|
|
// Release dead targets
|
|
if (self.enemy.classname == "player" && self.enemy.health <= 0)
|
|
{
|
|
self.owner.on_hook = FALSE;
|
|
self.owner.attack_finished = time +0.75;
|
|
}
|
|
|
|
// drop the hook if owner is dead or has released the button
|
|
if (!self.owner.on_hook || self.owner.health <= 0)
|
|
{
|
|
Reset_Grapple (self);
|
|
return;
|
|
}
|
|
|
|
// bring the pAiN!
|
|
if (self.enemy.classname == "player")
|
|
{
|
|
|
|
// 4.1, if we can't see our enemy, unlock
|
|
if (!CanDamage(self.enemy, self.owner)) {
|
|
Reset_Grapple(self);
|
|
return;
|
|
}
|
|
|
|
|
|
// move the hook along with the player. It's invisible, but
|
|
// we need this to make the sound come from the right spot
|
|
setorigin(self, self.enemy.origin);
|
|
|
|
sound (self, CHAN_WEAPON, "blob/land1.wav", 1, ATTN_NORM);
|
|
T_Damage (self.enemy, self, self.owner, 1);
|
|
makevectors (self.v_angle);
|
|
SpawnBlood(self.enemy.origin, 1);
|
|
}
|
|
|
|
// If the hook is not attached to the player, constantly copy
|
|
// copy the target's velocity. Velocity copying DOES NOT work properly
|
|
// for a hooked client.
|
|
if (self.enemy.classname != "player")
|
|
self.velocity = self.enemy.velocity;
|
|
|
|
self.nextthink = time + 0.1;
|
|
};
|
|
|
|
//
|
|
// MakeLink - spawns the chain link entities
|
|
//
|
|
entity (float head) MakeLink =
|
|
{
|
|
newmis = spawn ();
|
|
|
|
newmis.movetype = MOVETYPE_FLYMISSILE;
|
|
newmis.solid = SOLID_NOT;
|
|
newmis.owner = self;// SELF is the hook!
|
|
|
|
newmis.avelocity = '200 200 200';
|
|
|
|
setmodel (newmis, "progs/bit.mdl");
|
|
setorigin (newmis, self.origin);
|
|
setsize (newmis, '0 0 0' , '0 0 0');
|
|
|
|
return newmis;
|
|
};
|
|
|
|
//
|
|
// Remove_Chain - Removes all chain link entities; this is a separate
|
|
// function because CLIENT also needs to be able
|
|
// to remove the chain. Only one function required to
|
|
// remove all links.
|
|
//
|
|
void () Remove_Chain =
|
|
{
|
|
self.think = SUB_Remove;
|
|
self.nextthink = time;
|
|
|
|
if (self.goalentity)
|
|
{
|
|
self.goalentity.think = SUB_Remove;
|
|
self.goalentity.nextthink = time;
|
|
|
|
if (self.goalentity.goalentity)
|
|
{
|
|
self.goalentity.goalentity.think = SUB_Remove;
|
|
self.goalentity.goalentity.nextthink = time;
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
//
|
|
// Update_Chain - Repositions the chain links each frame. This single function
|
|
// maintains the positions of all of the links. Only one link
|
|
// is thinking every frame.
|
|
//
|
|
void () Update_Chain =
|
|
{
|
|
local vector temp;
|
|
|
|
if (!self.owner.hook_out)
|
|
{
|
|
self.think = Remove_Chain;
|
|
self.nextthink = time;
|
|
return;
|
|
}
|
|
|
|
temp = (self.owner.hook.origin - self.owner.origin);
|
|
|
|
// These numbers are correct assuming 3 links.
|
|
// 4 links would be *20 *40 *60 and *80
|
|
setorigin (self, self.owner.origin + temp * 0.25);
|
|
setorigin (self.goalentity, self.owner.origin + temp * 0.5);
|
|
setorigin (self.goalentity.goalentity, self.owner.origin + temp * 0.75);
|
|
|
|
self.nextthink = time + 0.1;
|
|
};
|
|
|
|
//
|
|
// Build_Chain - Builds the chain (linked list)
|
|
//
|
|
void () Build_Chain =
|
|
{
|
|
self.goalentity = MakeLink();
|
|
self.goalentity.think = Update_Chain;
|
|
self.goalentity.nextthink = time + 0.1;
|
|
self.goalentity.owner = self.owner;
|
|
|
|
self.goalentity.goalentity = MakeLink();
|
|
self.goalentity.goalentity.goalentity = MakeLink();
|
|
};
|
|
|
|
//
|
|
// Check_Overhead - Makes sure there is sufficient headroom above the player
|
|
// so that setorigin doesn't stick them into a wall. I tried
|
|
// to compare pointcontents, but that was too flaky.
|
|
//
|
|
float () Check_Overhead =
|
|
{
|
|
local vector src;
|
|
local vector end;
|
|
|
|
makevectors (self.owner.angles);
|
|
|
|
// The following comparisons could be optimized by doing away with
|
|
// SRC and END, and plugging the values directly into the traceline
|
|
// function calls. Using SRC and END made debugging easier. You
|
|
// decide if it's worth it.
|
|
|
|
// quick check right above head
|
|
src = self.owner.origin - '0 0 24';
|
|
end = self.owner.origin - '0 0 24';
|
|
traceline (src, end, FALSE, self.owner);
|
|
if (trace_fraction != 1.0)
|
|
return FALSE;
|
|
|
|
src = self.owner.origin - '0 0 24' - v_forward * 16;
|
|
end = self.owner.origin - '0 0 24' - v_forward * 16 + '0 0 58';
|
|
traceline (src, end, FALSE, self.owner);
|
|
if (trace_fraction != 1.0)
|
|
return FALSE;
|
|
|
|
src = self.owner.origin - '0 0 24' + v_forward * 16;
|
|
end = self.owner.origin - '0 0 24' + v_forward * 16 + '0 0 58';
|
|
traceline (src, end, FALSE, self.owner);
|
|
if (trace_fraction != 1.0)
|
|
return FALSE;
|
|
|
|
src = self.owner.origin - '0 0 24' - v_right * 16;
|
|
end = self.owner.origin - '0 0 24' - v_right * 16 + '0 0 58';
|
|
traceline (src, end, FALSE, self.owner);
|
|
if (trace_fraction != 1.0)
|
|
return FALSE;
|
|
|
|
src = self.owner.origin - '0 0 24' + v_right * 16;
|
|
end = self.owner.origin - '0 0 24' + v_right * 16 + '0 0 58';
|
|
traceline (src, end, FALSE, self.owner);
|
|
if (trace_fraction != 1.0)
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
};
|
|
|
|
|
|
//
|
|
// Anchor_Grapple - Tries to anchor the grapple to whatever it touches
|
|
//
|
|
void () Anchor_Grapple =
|
|
{
|
|
local float test;
|
|
|
|
if (other == self.owner)
|
|
return;
|
|
|
|
// DO NOT allow the grapple to hook to any projectiles, no matter WHAT!
|
|
// if you create new types of projectiles, make sure you use one of the
|
|
// classnames below or write code to exclude your new classname so
|
|
// grapples will not stick to them.
|
|
if (other.classname == "missile" || other.classname == "grenade" ||
|
|
other.classname == "spike" || other.classname == "hook")
|
|
return;
|
|
|
|
// Don't stick the the sky.
|
|
if (pointcontents(self.origin) == CONTENT_SKY)
|
|
{
|
|
Reset_Grapple (self);
|
|
return;
|
|
}
|
|
|
|
if (other.classname == "player")
|
|
{
|
|
// glance off of teammates
|
|
if (other.steam == self.owner.steam)
|
|
return;
|
|
|
|
sound (self, CHAN_WEAPON, "player/axhit1.wav", 1, ATTN_NORM);
|
|
T_Damage (other, self, self.owner, 10);
|
|
|
|
// make hook invisible since we will be pulling directly
|
|
// towards the player the hook hit. Quakeworld makes it
|
|
// too quirky to try to match hook's velocity with that of
|
|
// the client that it hit.
|
|
setmodel (self, "");
|
|
}
|
|
else if (other.classname != "player")
|
|
{
|
|
sound (self, CHAN_WEAPON, "player/axhit2.wav", 1, ATTN_NORM);
|
|
|
|
// One point of damage inflicted upon impact. Subsequent
|
|
// damage will only be done to PLAYERS... this way secret
|
|
// doors and triggers will only be damaged once.
|
|
if (other.takedamage)
|
|
T_Damage (other, self, self.owner, 1);
|
|
|
|
self.velocity = '0 0 0';
|
|
self.avelocity = '0 0 0';
|
|
}
|
|
|
|
// conveniently clears the sound channel of the CHAIN1 sound,
|
|
// which is a looping sample and would continue to play. Tink1 is
|
|
// the least offensive choice, ass NULL.WAV loops and clogs the
|
|
// channel with silence
|
|
sound (self.owner, CHAN_NO_PHS_ADD+CHAN_WEAPON, "weapons/tink1.wav", 1, ATTN_NORM);
|
|
|
|
if (!self.owner.button0)
|
|
{
|
|
Reset_Grapple (self);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
// our last chance to avoid being picked up off of the ground.
|
|
// check over the client's head to make sure there is one unit
|
|
// clearance so we can lift him off of the ground.
|
|
test = Check_Overhead ();
|
|
if (!test)
|
|
{
|
|
Reset_Grapple (self);
|
|
return;
|
|
}
|
|
|
|
*/
|
|
|
|
if (self.owner.flags & FL_ONGROUND)
|
|
{
|
|
self.owner.flags = self.owner.flags - FL_ONGROUND;
|
|
// setorigin(self.owner,self.owner.origin + '0 0 1');
|
|
}
|
|
|
|
self.owner.on_hook = TRUE;
|
|
|
|
sound (self.owner, CHAN_WEAPON, "weapons/chain2.wav", 1, ATTN_NORM);
|
|
|
|
// CHAIN2 is a looping sample. Use LEFTY as a flag so that client.qc
|
|
// will know to only play the tink sound ONCE to clear the weapons
|
|
// sound channel. (Lefty is a leftover from AI.QC, so I reused it to
|
|
// avoid adding a field)
|
|
self.owner.lefty = TRUE;
|
|
|
|
self.enemy = other;// remember this guy!
|
|
self.think = Grapple_Track;
|
|
self.nextthink = time;
|
|
self.solid = SOLID_NOT;
|
|
self.touch = SUB_Null;
|
|
};
|
|
|
|
|
|
//
|
|
// Throw_Grapple - called from WEAPONS.QC, 'fires' the grapple
|
|
//
|
|
void () Throw_Grapple =
|
|
{
|
|
if (self.hook_out)// reject subsequent calls from player.qc
|
|
return;
|
|
|
|
msg_entity = self;
|
|
WriteByte (MSG_ONE, SVC_SMALLKICK);
|
|
|
|
// chain out sound (loops)
|
|
sound (self, CHAN_WEAPON, "weapons/chain1.wav", 1, ATTN_NORM);
|
|
|
|
newmis = spawn();
|
|
newmis.movetype = MOVETYPE_FLYMISSILE;
|
|
newmis.solid = SOLID_BBOX;
|
|
newmis.owner = self;// newmis belongs to me
|
|
self.hook = newmis;// This is my newmis
|
|
newmis.classname = "hook";
|
|
|
|
makevectors (self.v_angle);
|
|
newmis.velocity = v_forward * 800;
|
|
newmis.avelocity = '0 0 -500';
|
|
|
|
newmis.touch = Anchor_Grapple;
|
|
newmis.think = Build_Chain;
|
|
newmis.nextthink = time + 0.1;// don't jam newmis and links into same packet
|
|
|
|
setmodel (newmis,"progs/star.mdl");
|
|
setorigin (newmis, self.origin + v_forward * 16 + '0 0 16');
|
|
setsize(newmis, '0 0 0' , '0 0 0 ');
|
|
|
|
self.hook_out = TRUE;
|
|
};
|
|
|
|
//
|
|
// Service_Grapple - called each frame by CLIENT.QC if client is ON_HOOK
|
|
//
|
|
void () Service_Grapple =
|
|
{
|
|
local vector hook_dir;
|
|
|
|
// drop the hook if player lets go of button
|
|
if (!self.button0)
|
|
{
|
|
if (self.weapon == IT_GRAPPLE) {
|
|
Reset_Grapple (self.hook);
|
|
return;
|
|
}
|
|
}
|
|
// If hooked to a player, track them directly!
|
|
if (self.hook.enemy.classname == "player")
|
|
hook_dir = (self.hook.enemy.origin - self.origin);
|
|
// else, track to hook
|
|
else if (self.hook.enemy.classname != "player")
|
|
hook_dir = (self.hook.origin - self.origin);
|
|
|
|
self.velocity = normalize(hook_dir) * 750;
|
|
if ( vlen(hook_dir) <= 100 && self.lefty)// cancel chain sound
|
|
{
|
|
// If there is a chain, ditch it now. We're
|
|
// close enough. Having extra entities lying around
|
|
// is never a good idea.
|
|
if (self.hook.goalentity)
|
|
{
|
|
self.hook.goalentity.think = Remove_Chain;
|
|
self.hook.goalentity.nextthink = time;
|
|
}
|
|
|
|
sound(self, CHAN_NO_PHS_ADD+CHAN_WEAPON, "weapons/chain3.wav", 1, ATTN_NORM);
|
|
self.lefty = FALSE;// we've reset the sound channel.
|
|
}
|
|
};
|
|
|
|
|