yquake2/yquake2remaster
0
0
Fork 0
mirror of https://github.com/yquake2/yquake2remaster.git synced 2024-11-10 07:12:07 +00:00
Code Issues Projects Releases Packages Wiki Activity

Rework g_utils.c and fix the removal of some entity classes

Browse source
This commit is contained in:
Yamagi Burmeister 2011-10-02 08:33:36 +00:00
parent ce3602c663
commit e9220c468a
2 changed files with 765 additions and 472 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

561
src/game/baseq2/g_turret.c
View file

@ -1,244 +1,376 @@
/* /*
Copyright (C) 1997-2001 Id Software, Inc. * Copyright (C) 1997-2001 Id Software, Inc.
*
This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or modify
modify it under the terms of the GNU General Public License * it under the terms of the GNU General Public License as published by
as published by the Free Software Foundation; either version 2 * the Free Software Foundation; either version 2 of the License, or (at
of the License, or (at your option) any later version. * your option) any later version.
*
This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful, but
but WITHOUT ANY WARRANTY; without even the implied warranty of * WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
See the GNU General Public License for more details. * See the GNU General Public License for more details.
*
You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*/ *
// g_turret.c * =======================================================================
*
* Turrets aka big cannons with a driver.
*
* =======================================================================
*/
#include "g_local.h" #include "g_local.h"
void infantry_die(edict_t *self, edict_t *inflictor, edict_t *attacker,
void AnglesNormalize(vec3_t vec) int damage);
void infantry_stand(edict_t *self);
void monster_use(edict_t *self, edict_t *other, edict_t *activator);
qboolean FindTarget(edict_t *self);
void
AnglesNormalize(vec3_t vec)
{ {
while(vec[0] > 360) while (vec[0] > 360)
{
vec[0] -= 360; vec[0] -= 360;
while(vec[0] < 0) }
while (vec[0] < 0)
{
vec[0] += 360; vec[0] += 360;
while(vec[1] > 360) }
while (vec[1] > 360)
{
vec[1] -= 360; vec[1] -= 360;
while(vec[1] < 0) }
while (vec[1] < 0)
{
vec[1] += 360; vec[1] += 360;
}
} }
float SnapToEights(float x) float
SnapToEights(float x)
{ {
x *= 8.0; x *= 8.0;
if (x > 0.0) if (x > 0.0)
{
x += 0.5; x += 0.5;
}
else else
{
x -= 0.5; x -= 0.5;
}
return 0.125 * (int)x; return 0.125 * (int)x;
} }
void
void turret_blocked(edict_t *self, edict_t *other) turret_blocked(edict_t *self, edict_t *other)
{ {
edict_t *attacker; edict_t *attacker;
if (!self || !other)
{
return;
}
if (other->takedamage) if (other->takedamage)
{ {
if (self->teammaster->owner) if (self->teammaster->owner)
{
attacker = self->teammaster->owner; attacker = self->teammaster->owner;
}
else else
{
attacker = self->teammaster; attacker = self->teammaster;
T_Damage (other, self, attacker, vec3_origin, other->s.origin, vec3_origin, self->teammaster->dmg, 10, 0, MOD_CRUSH); }
T_Damage(other, self, attacker, vec3_origin, other->s.origin,
vec3_origin, self->teammaster->dmg, 10, 0, MOD_CRUSH);
} }
} }
/*QUAKED turret_breach (0 0 0) ? /*
This portion of the turret can change both pitch and yaw. * QUAKED turret_breach (0 0 0) ?
The model should be made with a flat pitch. * This portion of the turret can change both pitch and yaw.
It (and the associated base) need to be oriented towards 0. * The model should be made with a flat pitch.
Use "angle" to set the starting angle. * It (and the associated base) need to be oriented towards 0.
* Use "angle" to set the starting angle.
"speed" default 50 *
"dmg" default 10 * "speed" default 50
"angle" point this forward * "dmg" default 10
"target" point this at an info_notnull at the muzzle tip * "angle" point this forward
"minpitch" min acceptable pitch angle : default -30 * "target" point this at an info_notnull at the muzzle tip
"maxpitch" max acceptable pitch angle : default 30 * "minpitch" min acceptable pitch angle : default -30
"minyaw" min acceptable yaw angle : default 0 * "maxpitch" max acceptable pitch angle : default 30
"maxyaw" max acceptable yaw angle : default 360 * "minyaw" min acceptable yaw angle : default 0
*/ * "maxyaw" max acceptable yaw angle : default 360
*/
void turret_breach_fire (edict_t *self) void
turret_breach_fire(edict_t *self)
{ {
vec3_t f, r, u; vec3_t f, r, u;
vec3_t start; vec3_t start;
int damage; int damage;
int speed; int speed;
AngleVectors (self->s.angles, f, r, u); if (!self)
VectorMA (self->s.origin, self->move_origin[0], f, start); {
VectorMA (start, self->move_origin[1], r, start); return;
VectorMA (start, self->move_origin[2], u, start); }
AngleVectors(self->s.angles, f, r, u);
VectorMA(self->s.origin, self->move_origin[0], f, start);
VectorMA(start, self->move_origin[1], r, start);
VectorMA(start, self->move_origin[2], u, start);
damage = 100 + random() * 50; damage = 100 + random() * 50;
speed = 550 + 50 * skill->value; speed = 550 + 50 * skill->value;
fire_rocket (self->teammaster->owner, start, f, damage, speed, 150, damage); fire_rocket(self->teammaster->owner, start, f, damage, speed, 150, damage);
gi.positioned_sound (start, self, CHAN_WEAPON, gi.soundindex("weapons/rocklf1a.wav"), 1, ATTN_NORM, 0); gi.positioned_sound(start, self, CHAN_WEAPON,
gi.soundindex("weapons/rocklf1a.wav"), 1, ATTN_NORM, 0);
} }
void turret_breach_think (edict_t *self) void
turret_breach_think(edict_t *self)
{ {
edict_t *ent; edict_t *ent;
vec3_t current_angles; vec3_t current_angles;
vec3_t delta; vec3_t delta;
VectorCopy (self->s.angles, current_angles); if (!self)
{
return;
}
VectorCopy(self->s.angles, current_angles);
AnglesNormalize(current_angles); AnglesNormalize(current_angles);
AnglesNormalize(self->move_angles); AnglesNormalize(self->move_angles);
if (self->move_angles[PITCH] > 180) if (self->move_angles[PITCH] > 180)
self->move_angles[PITCH] -= 360;
// clamp angles to mins & maxs
if (self->move_angles[PITCH] > self->pos1[PITCH])
self->move_angles[PITCH] = self->pos1[PITCH];
else if (self->move_angles[PITCH] < self->pos2[PITCH])
self->move_angles[PITCH] = self->pos2[PITCH];
if ((self->move_angles[YAW] < self->pos1[YAW]) || (self->move_angles[YAW] > self->pos2[YAW]))
{ {
float dmin, dmax; self->move_angles[PITCH] -= 360;
dmin = fabs(self->pos1[YAW] - self->move_angles[YAW]);
if (dmin < -180)
dmin += 360;
else if (dmin > 180)
dmin -= 360;
dmax = fabs(self->pos2[YAW] - self->move_angles[YAW]);
if (dmax < -180)
dmax += 360;
else if (dmax > 180)
dmax -= 360;
if (fabs(dmin) < fabs(dmax))
self->move_angles[YAW] = self->pos1[YAW];
else
self->move_angles[YAW] = self->pos2[YAW];
} }
VectorSubtract (self->move_angles, current_angles, delta); /* clamp angles to mins & maxs */
if (self->move_angles[PITCH] > self->pos1[PITCH])
{
self->move_angles[PITCH] = self->pos1[PITCH];
}
else if (self->move_angles[PITCH] < self->pos2[PITCH])
{
self->move_angles[PITCH] = self->pos2[PITCH];
}
if ((self->move_angles[YAW] < self->pos1[YAW]) ||
(self->move_angles[YAW] > self->pos2[YAW]))
{
float dmin, dmax;
dmin = fabs(self->pos1[YAW] - self->move_angles[YAW]);
if (dmin < -180)
{
dmin += 360;
}
else if (dmin > 180)
{
dmin -= 360;
}
dmax = fabs(self->pos2[YAW] - self->move_angles[YAW]);
if (dmax < -180)
{
dmax += 360;
}
else if (dmax > 180)
{
dmax -= 360;
}
if (fabs(dmin) < fabs(dmax))
{
self->move_angles[YAW] = self->pos1[YAW];
}
else
{
self->move_angles[YAW] = self->pos2[YAW];
}
}
VectorSubtract(self->move_angles, current_angles, delta);
if (delta[0] < -180) if (delta[0] < -180)
{
delta[0] += 360; delta[0] += 360;
}
else if (delta[0] > 180) else if (delta[0] > 180)
{
delta[0] -= 360; delta[0] -= 360;
}
if (delta[1] < -180) if (delta[1] < -180)
{
delta[1] += 360; delta[1] += 360;
}
else if (delta[1] > 180) else if (delta[1] > 180)
{
delta[1] -= 360; delta[1] -= 360;
}
delta[2] = 0; delta[2] = 0;
if (delta[0] > self->speed * FRAMETIME) if (delta[0] > self->speed * FRAMETIME)
{
delta[0] = self->speed * FRAMETIME; delta[0] = self->speed * FRAMETIME;
if (delta[0] < -1 * self->speed * FRAMETIME) }
delta[0] = -1 * self->speed * FRAMETIME;
if (delta[1] > self->speed * FRAMETIME)
delta[1] = self->speed * FRAMETIME;
if (delta[1] < -1 * self->speed * FRAMETIME)
delta[1] = -1 * self->speed * FRAMETIME;
VectorScale (delta, 1.0/FRAMETIME, self->avelocity); if (delta[0] < -1 * self->speed * FRAMETIME)
{
delta[0] = -1 * self->speed * FRAMETIME;
}
if (delta[1] > self->speed * FRAMETIME)
{
delta[1] = self->speed * FRAMETIME;
}
if (delta[1] < -1 * self->speed * FRAMETIME)
{
delta[1] = -1 * self->speed * FRAMETIME;
}
VectorScale(delta, 1.0 / FRAMETIME, self->avelocity);
self->nextthink = level.time + FRAMETIME; self->nextthink = level.time + FRAMETIME;
for (ent = self->teammaster; ent; ent = ent->teamchain) for (ent = self->teammaster; ent; ent = ent->teamchain)
{
ent->avelocity[1] = self->avelocity[1]; ent->avelocity[1] = self->avelocity[1];
}
// if we have adriver, adjust his velocities /* if we have adriver, adjust his velocities */
if (self->owner) if (self->owner)
{ {
float angle; float angle;
float target_z; float target_z;
float diff; float diff;
vec3_t target; vec3_t target;
vec3_t dir; vec3_t dir;
// angular is easy, just copy ours /* angular is easy, just copy ours */
self->owner->avelocity[0] = self->avelocity[0]; self->owner->avelocity[0] = self->avelocity[0];
self->owner->avelocity[1] = self->avelocity[1]; self->owner->avelocity[1] = self->avelocity[1];
// x & y /* x & y */
angle = self->s.angles[1] + self->owner->move_origin[1]; angle = self->s.angles[1] + self->owner->move_origin[1];
angle *= (M_PI*2 / 360); angle *= (M_PI * 2 / 360);
target[0] = SnapToEights(self->s.origin[0] + cos(angle) * self->owner->move_origin[0]); target[0] = SnapToEights(self->s.origin[0] + cos(
target[1] = SnapToEights(self->s.origin[1] + sin(angle) * self->owner->move_origin[0]); angle) * self->owner->move_origin[0]);
target[1] = SnapToEights(self->s.origin[1] + sin(
angle) * self->owner->move_origin[0]);
target[2] = self->owner->s.origin[2]; target[2] = self->owner->s.origin[2];
VectorSubtract (target, self->owner->s.origin, dir); VectorSubtract(target, self->owner->s.origin, dir);
self->owner->velocity[0] = dir[0] * 1.0 / FRAMETIME; self->owner->velocity[0] = dir[0] * 1.0 / FRAMETIME;
self->owner->velocity[1] = dir[1] * 1.0 / FRAMETIME; self->owner->velocity[1] = dir[1] * 1.0 / FRAMETIME;
// z /* z */
angle = self->s.angles[PITCH] * (M_PI*2 / 360); angle = self->s.angles[PITCH] * (M_PI * 2 / 360);
target_z = SnapToEights(self->s.origin[2] + self->owner->move_origin[0] * tan(angle) + self->owner->move_origin[2]); target_z = SnapToEights(
self->s.origin[2] + self->owner->move_origin[0] * tan(
angle) + self->owner->move_origin[2]);
diff = target_z - self->owner->s.origin[2]; diff = target_z - self->owner->s.origin[2];
self->owner->velocity[2] = diff * 1.0 / FRAMETIME; self->owner->velocity[2] = diff * 1.0 / FRAMETIME;
if (self->spawnflags & 65536) if (self->spawnflags & 65536)
{ {
turret_breach_fire (self); turret_breach_fire(self);
self->spawnflags &= ~65536; self->spawnflags &= ~65536;
} }
} }
} }
void turret_breach_finish_init (edict_t *self) void
{ turret_breach_finish_init(edict_t *self)
// get and save info for muzzle location {
if (!self)
{
return;
}
/* get and save info for muzzle location */
if (!self->target) if (!self->target)
{ {
gi.dprintf("%s at %s needs a target\n", self->classname, vtos(self->s.origin)); gi.dprintf("%s at %s needs a target\n", self->classname,
vtos(self->s.origin));
} }
else else
{ {
self->target_ent = G_PickTarget (self->target); self->target_ent = G_PickTarget(self->target);
VectorSubtract (self->target_ent->s.origin, self->s.origin, self->move_origin); VectorSubtract(self->target_ent->s.origin,
self->s.origin, self->move_origin);
G_FreeEdict(self->target_ent); G_FreeEdict(self->target_ent);
} }
self->teammaster->dmg = self->dmg; self->teammaster->dmg = self->dmg;
self->think = turret_breach_think; self->think = turret_breach_think;
self->think (self); self->think(self);
} }
void SP_turret_breach (edict_t *self) void
{ SP_turret_breach(edict_t *self)
{
if (!self)
{
return;
}
self->solid = SOLID_BSP; self->solid = SOLID_BSP;
self->movetype = MOVETYPE_PUSH; self->movetype = MOVETYPE_PUSH;
gi.setmodel (self, self->model); gi.setmodel(self, self->model);
if (!self->speed) if (!self->speed)
{
self->speed = 50; self->speed = 50;
}
if (!self->dmg) if (!self->dmg)
{
self->dmg = 10; self->dmg = 10;
}
if (!st.minpitch) if (!st.minpitch)
{
st.minpitch = -30; st.minpitch = -30;
}
if (!st.maxpitch) if (!st.maxpitch)
{
st.maxpitch = 30; st.maxpitch = 30;
}
if (!st.maxyaw) if (!st.maxyaw)
{
st.maxyaw = 360; st.maxyaw = 360;
}
self->pos1[PITCH] = -1 * st.minpitch; self->pos1[PITCH] = -1 * st.minpitch;
self->pos1[YAW] = st.minyaw; self->pos1[YAW] = st.minyaw;
self->pos2[PITCH] = -1 * st.maxpitch; self->pos2[PITCH] = -1 * st.maxpitch;
self->pos2[YAW] = st.maxyaw; self->pos2[YAW] = st.maxyaw;
self->ideal_yaw = self->s.angles[YAW]; self->ideal_yaw = self->s.angles[YAW];
self->move_angles[YAW] = self->ideal_yaw; self->move_angles[YAW] = self->ideal_yaw;
@ -247,44 +379,56 @@ void SP_turret_breach (edict_t *self)
self->think = turret_breach_finish_init; self->think = turret_breach_finish_init;
self->nextthink = level.time + FRAMETIME; self->nextthink = level.time + FRAMETIME;
gi.linkentity (self); gi.linkentity(self);
} }
/*
* QUAKED turret_base (0 0 0) ?
* This portion of the turret changes yaw only.
* MUST be teamed with a turret_breach.
*/
/*QUAKED turret_base (0 0 0) ? void
This portion of the turret changes yaw only. SP_turret_base(edict_t *self)
MUST be teamed with a turret_breach. {
*/ if (!self)
{
void SP_turret_base (edict_t *self) return;
{ }
self->solid = SOLID_BSP; self->solid = SOLID_BSP;
self->movetype = MOVETYPE_PUSH; self->movetype = MOVETYPE_PUSH;
gi.setmodel (self, self->model); gi.setmodel(self, self->model);
self->blocked = turret_blocked; self->blocked = turret_blocked;
gi.linkentity (self); gi.linkentity(self);
} }
/*
/*QUAKED turret_driver (1 .5 0) (-16 -16 -24) (16 16 32) * QUAKED turret_driver (1 .5 0) (-16 -16 -24) (16 16 32)
Must NOT be on the team with the rest of the turret parts. * Must NOT be on the team with the rest of the turret parts.
Instead it must target the turret_breach. * Instead it must target the turret_breach.
*/ */
void
void infantry_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage); turret_driver_die(edict_t *self, edict_t *inflictor, edict_t *attacker,
void infantry_stand (edict_t *self); int damage, vec3_t point /* unused */)
void monster_use (edict_t *self, edict_t *other, edict_t *activator);
void turret_driver_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
{ {
edict_t *ent; edict_t *ent;
// level the gun if (!self || !inflictor || !attacker)
{
return;
}
/* level the gun */
self->target_ent->move_angles[0] = 0; self->target_ent->move_angles[0] = 0;
// remove the driver from the end of them team chain /* remove the driver from the end of them team chain */
for (ent = self->target_ent->teammaster; ent->teamchain != self; ent = ent->teamchain) for (ent = self->target_ent->teammaster;
; ent->teamchain != self;
ent = ent->teamchain)
{
}
ent->teamchain = NULL; ent->teamchain = NULL;
self->teammaster = NULL; self->teammaster = NULL;
self->flags &= ~FL_TEAMSLAVE; self->flags &= ~FL_TEAMSLAVE;
@ -292,32 +436,41 @@ void turret_driver_die (edict_t *self, edict_t *inflictor, edict_t *attacker, in
self->target_ent->owner = NULL; self->target_ent->owner = NULL;
self->target_ent->teammaster->owner = NULL; self->target_ent->teammaster->owner = NULL;
infantry_die (self, inflictor, attacker, damage); infantry_die(self, inflictor, attacker, damage);
} }
qboolean FindTarget (edict_t *self); void
turret_driver_think(edict_t *self)
void turret_driver_think (edict_t *self)
{ {
vec3_t target; vec3_t target;
vec3_t dir; vec3_t dir;
float reaction_time; float reaction_time;
if (!self)
{
return;
}
self->nextthink = level.time + FRAMETIME; self->nextthink = level.time + FRAMETIME;
if (self->enemy && (!self->enemy->inuse || self->enemy->health <= 0)) if (self->enemy && (!self->enemy->inuse || (self->enemy->health <= 0)))
{
self->enemy = NULL; self->enemy = NULL;
}
if (!self->enemy) if (!self->enemy)
{ {
if (!FindTarget (self)) if (!FindTarget(self))
{
return; return;
}
self->monsterinfo.trail_time = level.time; self->monsterinfo.trail_time = level.time;
self->monsterinfo.aiflags &= ~AI_LOST_SIGHT; self->monsterinfo.aiflags &= ~AI_LOST_SIGHT;
} }
else else
{ {
if (visible (self, self->enemy)) if (visible(self, self->enemy))
{ {
if (self->monsterinfo.aiflags & AI_LOST_SIGHT) if (self->monsterinfo.aiflags & AI_LOST_SIGHT)
{ {
@ -332,71 +485,91 @@ void turret_driver_think (edict_t *self)
} }
} }
// let the turret know where we want it to aim /* let the turret know where we want it to aim */
VectorCopy (self->enemy->s.origin, target); VectorCopy(self->enemy->s.origin, target);
target[2] += self->enemy->viewheight; target[2] += self->enemy->viewheight;
VectorSubtract (target, self->target_ent->s.origin, dir); VectorSubtract(target, self->target_ent->s.origin, dir);
vectoangles (dir, self->target_ent->move_angles); vectoangles(dir, self->target_ent->move_angles);
// decide if we should shoot /* decide if we should shoot */
if (level.time < self->monsterinfo.attack_finished) if (level.time < self->monsterinfo.attack_finished)
{
return; return;
}
reaction_time = (3 - skill->value) * 1.0; reaction_time = (3 - skill->value) * 1.0;
if ((level.time - self->monsterinfo.trail_time) < reaction_time) if ((level.time - self->monsterinfo.trail_time) < reaction_time)
{
return; return;
}
self->monsterinfo.attack_finished = level.time + reaction_time + 1.0; self->monsterinfo.attack_finished = level.time + reaction_time + 1.0;
//FIXME how do we really want to pass this along?
self->target_ent->spawnflags |= 65536; self->target_ent->spawnflags |= 65536;
} }
void turret_driver_link (edict_t *self) void
turret_driver_link(edict_t *self)
{ {
vec3_t vec; vec3_t vec;
edict_t *ent; edict_t *ent;
if (!self)
{
return;
}
self->think = turret_driver_think; self->think = turret_driver_think;
self->nextthink = level.time + FRAMETIME; self->nextthink = level.time + FRAMETIME;
self->target_ent = G_PickTarget (self->target); self->target_ent = G_PickTarget(self->target);
self->target_ent->owner = self; self->target_ent->owner = self;
self->target_ent->teammaster->owner = self; self->target_ent->teammaster->owner = self;
VectorCopy (self->target_ent->s.angles, self->s.angles); VectorCopy(self->target_ent->s.angles, self->s.angles);
vec[0] = self->target_ent->s.origin[0] - self->s.origin[0]; vec[0] = self->target_ent->s.origin[0] - self->s.origin[0];
vec[1] = self->target_ent->s.origin[1] - self->s.origin[1]; vec[1] = self->target_ent->s.origin[1] - self->s.origin[1];
vec[2] = 0; vec[2] = 0;
self->move_origin[0] = VectorLength(vec); self->move_origin[0] = VectorLength(vec);
VectorSubtract (self->s.origin, self->target_ent->s.origin, vec); VectorSubtract(self->s.origin, self->target_ent->s.origin, vec);
vectoangles (vec, vec); vectoangles(vec, vec);
AnglesNormalize(vec); AnglesNormalize(vec);
self->move_origin[1] = vec[1]; self->move_origin[1] = vec[1];
self->move_origin[2] = self->s.origin[2] - self->target_ent->s.origin[2]; self->move_origin[2] = self->s.origin[2] - self->target_ent->s.origin[2];
// add the driver to the end of them team chain /* add the driver to the end of them team chain */
for (ent = self->target_ent->teammaster; ent->teamchain; ent = ent->teamchain) for (ent = self->target_ent->teammaster;
; ent->teamchain;
ent = ent->teamchain)
{
}
ent->teamchain = self; ent->teamchain = self;
self->teammaster = self->target_ent->teammaster; self->teammaster = self->target_ent->teammaster;
self->flags |= FL_TEAMSLAVE; self->flags |= FL_TEAMSLAVE;
} }
void SP_turret_driver (edict_t *self) void
{ SP_turret_driver(edict_t *self)
{
if (!self)
{
return;
}
if (deathmatch->value) if (deathmatch->value)
{ {
G_FreeEdict (self); G_FreeEdict(self);
return; return;
} }
self->movetype = MOVETYPE_PUSH; self->movetype = MOVETYPE_PUSH;
self->solid = SOLID_BBOX; self->solid = SOLID_BBOX;
self->s.modelindex = gi.modelindex("models/monsters/infantry/tris.md2"); self->s.modelindex = gi.modelindex("models/monsters/infantry/tris.md2");
VectorSet (self->mins, -16, -16, -24); VectorSet(self->mins, -16, -16, -24);
VectorSet (self->maxs, 16, 16, 32); VectorSet(self->maxs, 16, 16, 32);
self->health = 100; self->health = 100;
self->gib_health = 0; self->gib_health = 0;
@ -415,19 +588,23 @@ void SP_turret_driver (edict_t *self)
self->takedamage = DAMAGE_AIM; self->takedamage = DAMAGE_AIM;
self->use = monster_use; self->use = monster_use;
self->clipmask = MASK_MONSTERSOLID; self->clipmask = MASK_MONSTERSOLID;
VectorCopy (self->s.origin, self->s.old_origin); VectorCopy(self->s.origin, self->s.old_origin);
self->monsterinfo.aiflags |= AI_STAND_GROUND|AI_DUCKED; self->monsterinfo.aiflags |= AI_STAND_GROUND | AI_DUCKED;
if (st.item) if (st.item)
{ {
self->item = FindItemByClassname (st.item); self->item = FindItemByClassname(st.item);
if (!self->item) if (!self->item)
gi.dprintf("%s at %s has bad item: %s\n", self->classname, vtos(self->s.origin), st.item); {
gi.dprintf("%s at %s has bad item: %s\n", self->classname,
vtos(self->s.origin), st.item);
}
} }
self->think = turret_driver_link; self->think = turret_driver_link;
self->nextthink = level.time + FRAMETIME; self->nextthink = level.time + FRAMETIME;
gi.linkentity (self); gi.linkentity(self);
} }

676
src/game/baseq2/g_utils.c
View file

@ -1,125 +1,158 @@
/* /*
Copyright (C) 1997-2001 Id Software, Inc. * Copyright (C) 1997-2001 Id Software, Inc.
*
This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or modify
modify it under the terms of the GNU General Public License * it under the terms of the GNU General Public License as published by
as published by the Free Software Foundation; either version 2 * the Free Software Foundation; either version 2 of the License, or (at
of the License, or (at your option) any later version. * your option) any later version.
*
This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful, but
but WITHOUT ANY WARRANTY; without even the implied warranty of * WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
See the GNU General Public License for more details. * See the GNU General Public License for more details.
*
You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*/ *
// g_utils.c -- misc utility functions for game module * =======================================================================
*
* Misc. utility functions for the game logic.
*
* =======================================================================
*/
#include "g_local.h" #include "g_local.h"
#define MAXCHOICES 8
void G_ProjectSource (vec3_t point, vec3_t distance, vec3_t forward, vec3_t right, vec3_t result) void
G_ProjectSource(vec3_t point, vec3_t distance, vec3_t forward,
vec3_t right, vec3_t result)
{ {
result[0] = point[0] + forward[0] * distance[0] + right[0] * distance[1]; result[0] = point[0] + forward[0] * distance[0] + right[0] * distance[1];
result[1] = point[1] + forward[1] * distance[0] + right[1] * distance[1]; result[1] = point[1] + forward[1] * distance[0] + right[1] * distance[1];
result[2] = point[2] + forward[2] * distance[0] + right[2] * distance[1] + distance[2]; result[2] = point[2] + forward[2] * distance[0] + right[2] * distance[1] +
distance[2];
} }
/* /*
============= * Searches all active entities for the next
G_Find * one that holds the matching string at fieldofs
* (use the FOFS() macro) in the structure.
Searches all active entities for the next one that holds *
the matching string at fieldofs (use the FOFS() macro) in the structure. * Searches beginning at the edict after from, or
* the beginning. If NULL, NULL will be returned
Searches beginning at the edict after from, or the beginning if NULL * if the end of the list is reached.
NULL will be returned if the end of the list is reached. */
edict_t *
============= G_Find(edict_t *from, int fieldofs, char *match)
*/
edict_t *G_Find (edict_t *from, int fieldofs, char *match)
{ {
char *s; char *s;
if (!from) if (!from)
{
from = g_edicts; from = g_edicts;
}
else else
{
from++; from++;
}
for ( ; from < &g_edicts[globals.num_edicts] ; from++) if (!match)
{
return NULL;
}
for ( ; from < &g_edicts[globals.num_edicts]; from++)
{ {
if (!from->inuse) if (!from->inuse)
{
continue; continue;
s = *(char **) ((byte *)from + fieldofs); }
s = *(char **)((byte *)from + fieldofs);
if (!s) if (!s)
{
continue; continue;
if (!Q_stricmp (s, match)) }
if (!Q_stricmp(s, match))
{
return from; return from;
}
} }
return NULL; return NULL;
} }
/* /*
================= * Returns entities that have origins
findradius * within a spherical area
*/
Returns entities that have origins within a spherical area edict_t *
findradius(edict_t *from, vec3_t org, float rad)
findradius (origin, radius)
=================
*/
edict_t *findradius (edict_t *from, vec3_t org, float rad)
{ {
vec3_t eorg; vec3_t eorg;
int j; int j;
if (!from) if (!from)
{
from = g_edicts; from = g_edicts;
}
else else
{
from++; from++;
}
for ( ; from < &g_edicts[globals.num_edicts]; from++) for ( ; from < &g_edicts[globals.num_edicts]; from++)
{ {
if (!from->inuse) if (!from->inuse)
{
continue; continue;
}
if (from->solid == SOLID_NOT) if (from->solid == SOLID_NOT)
{
continue; continue;
for (j=0 ; j<3 ; j++) }
eorg[j] = org[j] - (from->s.origin[j] + (from->mins[j] + from->maxs[j])*0.5);
for (j = 0; j < 3; j++)
{
eorg[j] = org[j] - (from->s.origin[j] +
(from->mins[j] + from->maxs[j]) * 0.5);
}
if (VectorLength(eorg) > rad) if (VectorLength(eorg) > rad)
{
continue; continue;
}
return from; return from;
} }
return NULL; return NULL;
} }
/* /*
============= * Searches all active entities for
G_PickTarget * the next one that holds the matching
* string at fieldofs (use the FOFS() macro)
Searches all active entities for the next one that holds * in the structure.
the matching string at fieldofs (use the FOFS() macro) in the structure. *
* Searches beginning at the edict after from,
Searches beginning at the edict after from, or the beginning if NULL * or the beginning. If NULL, NULL will be
NULL will be returned if the end of the list is reached. * returned if the end of the list is reached.
*/
============= edict_t *
*/ G_PickTarget(char *targetname)
#define MAXCHOICES 8
edict_t *G_PickTarget (char *targetname)
{ {
edict_t *ent = NULL; edict_t *ent = NULL;
int num_choices = 0; int num_choices = 0;
edict_t *choice[MAXCHOICES]; edict_t *choice[MAXCHOICES];
if (!targetname) if (!targetname)
{ {
@ -127,14 +160,21 @@ edict_t *G_PickTarget (char *targetname)
return NULL; return NULL;
} }
while(1) while (1)
{ {
ent = G_Find (ent, FOFS(targetname), targetname); ent = G_Find(ent, FOFS(targetname), targetname);
if (!ent) if (!ent)
{
break; break;
}
choice[num_choices++] = ent; choice[num_choices++] = ent;
if (num_choices == MAXCHOICES) if (num_choices == MAXCHOICES)
{
break; break;
}
} }
if (!num_choices) if (!num_choices)
@ -146,75 +186,103 @@ edict_t *G_PickTarget (char *targetname)
return choice[rand() % num_choices]; return choice[rand() % num_choices];
} }
void
Think_Delay(edict_t *ent)
void Think_Delay (edict_t *ent) {
{ if (!ent)
G_UseTargets (ent, ent->activator); {
G_FreeEdict (ent); return;
}
G_UseTargets(ent, ent->activator);
G_FreeEdict(ent);
} }
/* /*
============================== * The global "activator" should be set to
G_UseTargets * the entity that initiated the firing.
*
the global "activator" should be set to the entity that initiated the firing. * If self.delay is set, a DelayedUse entity
* will be created that will actually do the
If self.delay is set, a DelayedUse entity will be created that will actually * SUB_UseTargets after that many seconds have passed.
do the SUB_UseTargets after that many seconds have passed. *
* Centerprints any self.message to the activator.
Centerprints any self.message to the activator. *
* Search for (string)targetname in all entities that
Search for (string)targetname in all entities that * match (string)self.target and call their .use function
match (string)self.target and call their .use function */
void
============================== G_UseTargets(edict_t *ent, edict_t *activator)
*/
void G_UseTargets (edict_t *ent, edict_t *activator)
{ {
edict_t *t; edict_t *t;
// if (!ent || !activator)
// check for a delay {
// return;
}
/* check for a delay */
if (ent->delay) if (ent->delay)
{ {
// create a temp object to fire at a later time /* create a temp object to fire at a later time */
t = G_Spawn(); t = G_Spawn();
t->classname = "DelayedUse"; t->classname = "DelayedUse";
t->nextthink = level.time + ent->delay; t->nextthink = level.time + ent->delay;
t->think = Think_Delay; t->think = Think_Delay;
t->activator = activator; t->activator = activator;
if (!activator) if (!activator)
gi.dprintf ("Think_Delay with no activator\n"); {
gi.dprintf("Think_Delay with no activator\n");
}
t->message = ent->message; t->message = ent->message;
t->target = ent->target; t->target = ent->target;
t->killtarget = ent->killtarget; t->killtarget = ent->killtarget;
return; return;
} }
/* print the message */
//
// print the message
//
if ((ent->message) && !(activator->svflags & SVF_MONSTER)) if ((ent->message) && !(activator->svflags & SVF_MONSTER))
{ {
gi.centerprintf (activator, "%s", ent->message); gi.centerprintf(activator, "%s", ent->message);
if (ent->noise_index) if (ent->noise_index)
gi.sound (activator, CHAN_AUTO, ent->noise_index, 1, ATTN_NORM, 0); {
gi.sound(activator, CHAN_AUTO, ent->noise_index, 1, ATTN_NORM, 0);
}
else else
gi.sound (activator, CHAN_AUTO, gi.soundindex ("misc/talk1.wav"), 1, ATTN_NORM, 0); {
gi.sound(activator, CHAN_AUTO, gi.soundindex(
"misc/talk1.wav"), 1, ATTN_NORM, 0);
}
} }
// /* kill killtargets */
// kill killtargets
//
if (ent->killtarget) if (ent->killtarget)
{ {
t = NULL; t = NULL;
while ((t = G_Find (t, FOFS(targetname), ent->killtarget)))
while ((t = G_Find(t, FOFS(targetname), ent->killtarget)))
{ {
G_FreeEdict (t); /* decrement secret count if target_secret is removed */
if (!Q_stricmp(t->classname,"target_secret"))
{
level.total_secrets--;
}
/* same deal with target_goal, but also turn off CD music if applicable */
else if (!Q_stricmp(t->classname,"target_goal"))
{
level.total_goals--;
if (level.found_goals >= level.total_goals)
{
gi.configstring (CS_CDTRACK, "0");
}
}
G_FreeEdict(t);
if (!ent->inuse) if (!ent->inuse)
{ {
gi.dprintf("entity was removed while using killtargets\n"); gi.dprintf("entity was removed while using killtargets\n");
@ -223,28 +291,33 @@ void G_UseTargets (edict_t *ent, edict_t *activator)
} }
} }
// /* fire targets */
// fire targets
//
if (ent->target) if (ent->target)
{ {
t = NULL; t = NULL;
while ((t = G_Find (t, FOFS(targetname), ent->target)))
while ((t = G_Find(t, FOFS(targetname), ent->target)))
{ {
// doors fire area portals in a specific way /* doors fire area portals in a specific way */
if (!Q_stricmp(t->classname, "func_areaportal") && if (!Q_stricmp(t->classname, "func_areaportal") &&
(!Q_stricmp(ent->classname, "func_door") || !Q_stricmp(ent->classname, "func_door_rotating"))) (!Q_stricmp(ent->classname, "func_door") ||
!Q_stricmp(ent->classname, "func_door_rotating")))
{
continue; continue;
}
if (t == ent) if (t == ent)
{ {
gi.dprintf ("WARNING: Entity used itself.\n"); gi.dprintf("WARNING: Entity used itself.\n");
} }
else else
{ {
if (t->use) if (t->use)
t->use (t, ent, activator); {
t->use(t, ent, activator);
}
} }
if (!ent->inuse) if (!ent->inuse)
{ {
gi.dprintf("entity was removed while using targets\n"); gi.dprintf("entity was removed while using targets\n");
@ -254,25 +327,22 @@ void G_UseTargets (edict_t *ent, edict_t *activator)
} }
} }
/* /*
============= * This is just a convenience function
TempVector * for making temporary vectors for function calls
*/
This is just a convenience function float *
for making temporary vectors for function calls tv(float x, float y, float z)
=============
*/
float *tv (float x, float y, float z)
{ {
static int index; static int index;
static vec3_t vecs[8]; static vec3_t vecs[8];
float *v; float *v;
// use an array so that multiple tempvectors won't collide /* use an array so that multiple
// for a while tempvectors won't collide
for a while */
v = vecs[index]; v = vecs[index];
index = (index + 1)&7; index = (index + 1) & 7;
v[0] = x; v[0] = x;
v[1] = y; v[1] = y;
@ -281,106 +351,127 @@ float *tv (float x, float y, float z)
return v; return v;
} }
/* /*
============= * This is just a convenience function
VectorToString * for printing vectors
*/
This is just a convenience function char *
for printing vectors vtos(vec3_t v)
=============
*/
char *vtos (vec3_t v)
{ {
static int index; static int index;
static char str[8][32]; static char str[8][32];
char *s; char *s;
// use an array so that multiple vtos won't collide /* use an array so that multiple vtos won't collide */
s = str[index]; s = str[index];
index = (index + 1)&7; index = (index + 1) & 7;
Com_sprintf (s, 32, "(%i %i %i)", (int)v[0], (int)v[1], (int)v[2]); Com_sprintf(s, 32, "(%i %i %i)", (int)v[0], (int)v[1], (int)v[2]);
return s; return s;
} }
vec3_t VEC_UP = {0, -1, 0};
vec3_t MOVEDIR_UP = {0, 0, 1};
vec3_t VEC_DOWN = {0, -2, 0};
vec3_t MOVEDIR_DOWN = {0, 0, -1};
vec3_t VEC_UP = {0, -1, 0}; void
vec3_t MOVEDIR_UP = {0, 0, 1}; G_SetMovedir(vec3_t angles, vec3_t movedir)
vec3_t VEC_DOWN = {0, -2, 0};
vec3_t MOVEDIR_DOWN = {0, 0, -1};
void G_SetMovedir (vec3_t angles, vec3_t movedir)
{ {
if (VectorCompare (angles, VEC_UP)) if (VectorCompare(angles, VEC_UP))
{ {
VectorCopy (MOVEDIR_UP, movedir); VectorCopy(MOVEDIR_UP, movedir);
} }
else if (VectorCompare (angles, VEC_DOWN)) else if (VectorCompare(angles, VEC_DOWN))
{ {
VectorCopy (MOVEDIR_DOWN, movedir); VectorCopy(MOVEDIR_DOWN, movedir);
} }
else else
{ {
AngleVectors (angles, movedir, NULL, NULL); AngleVectors(angles, movedir, NULL, NULL);
} }
VectorClear (angles); VectorClear(angles);
} }
float
float vectoyaw (vec3_t vec) vectoyaw(vec3_t vec)
{ {
float yaw; float yaw;
if (/*vec[YAW] == 0 &&*/ vec[PITCH] == 0) if (vec[PITCH] == 0)
{ {
yaw = 0; yaw = 0;
if (vec[YAW] > 0) if (vec[YAW] > 0)
{
yaw = 90; yaw = 90;
}
else if (vec[YAW] < 0) else if (vec[YAW] < 0)
{
yaw = -90; yaw = -90;
} }
}
else else
{ {
yaw = (int) (atan2(vec[YAW], vec[PITCH]) * 180 / M_PI); yaw = (int)(atan2(vec[YAW], vec[PITCH]) * 180 / M_PI);
if (yaw < 0) if (yaw < 0)
{
yaw += 360; yaw += 360;
}
} }
return yaw; return yaw;
} }
void
void vectoangles (vec3_t value1, vec3_t angles) vectoangles(vec3_t value1, vec3_t angles)
{ {
float forward; float forward;
float yaw, pitch; float yaw, pitch;
if (value1[1] == 0 && value1[0] == 0) if ((value1[1] == 0) && (value1[0] == 0))
{ {
yaw = 0; yaw = 0;
if (value1[2] > 0) if (value1[2] > 0)
{
pitch = 90; pitch = 90;
}
else else
{
pitch = 270; pitch = 270;
}
} }
else else
{ {
if (value1[0]) if (value1[0])
yaw = (int) (atan2(value1[1], value1[0]) * 180 / M_PI); {
yaw = (int)(atan2(value1[1], value1[0]) * 180 / M_PI);
}
else if (value1[1] > 0) else if (value1[1] > 0)
{
yaw = 90; yaw = 90;
}
else else
{
yaw = -90; yaw = -90;
if (yaw < 0) }
yaw += 360;
if (yaw < 0)
{
yaw += 360;
}
forward = sqrt(value1[0] * value1[0] + value1[1] * value1[1]);
pitch = (int)(atan2(value1[2], forward) * 180 / M_PI);
forward = sqrt (value1[0]*value1[0] + value1[1]*value1[1]);
pitch = (int) (atan2(value1[2], forward) * 180 / M_PI);
if (pitch < 0) if (pitch < 0)
{
pitch += 360; pitch += 360;
}
} }
angles[PITCH] = -pitch; angles[PITCH] = -pitch;
@ -388,17 +479,18 @@ void vectoangles (vec3_t value1, vec3_t angles)
angles[ROLL] = 0; angles[ROLL] = 0;
} }
char *G_CopyString (char *in) char *
G_CopyString(char *in)
{ {
char *out; char *out;
out = gi.TagMalloc (strlen(in)+1, TAG_LEVEL); out = gi.TagMalloc(strlen(in) + 1, TAG_LEVEL);
strcpy (out, in); strcpy(out, in);
return out; return out;
} }
void
void G_InitEdict (edict_t *e) G_InitEdict(edict_t *e)
{ {
e->inuse = true; e->inuse = true;
e->classname = "noclass"; e->classname = "noclass";
@ -407,159 +499,183 @@ void G_InitEdict (edict_t *e)
} }
/* /*
================= * Either finds a free edict, or allocates a
G_Spawn * new one. Try to avoid reusing an entity
* that was recently freed, because it can
Either finds a free edict, or allocates a new one. * cause the client to think the entity
Try to avoid reusing an entity that was recently freed, because it * morphed into something else instead of
can cause the client to think the entity morphed into something else * being removed and recreated, which can
instead of being removed and recreated, which can cause interpolated * cause interpolated angles and bad trails.
angles and bad trails. */
================= edict_t *
*/ G_Spawn(void)
edict_t *G_Spawn (void)
{ {
int i; int i;
edict_t *e; edict_t *e;
e = &g_edicts[(int)maxclients->value+1]; e = &g_edicts[(int)maxclients->value + 1];
for ( i=maxclients->value+1 ; i<globals.num_edicts ; i++, e++)
for (i = maxclients->value + 1; i < globals.num_edicts; i++, e++)
{ {
// the first couple seconds of server time can involve a lot of /* the first couple seconds of
// freeing and allocating, so relax the replacement policy server time can involve a lot of
if (!e->inuse && ( e->freetime < 2 || level.time - e->freetime > 0.5 ) ) freeing and allocating, so relax
the replacement policy */
if (!e->inuse && ((e->freetime < 2) || (level.time - e->freetime > 0.5)))
{ {
G_InitEdict (e); G_InitEdict(e);
return e; return e;
} }
} }
if (i == game.maxentities) if (i == game.maxentities)
gi.error ("ED_Alloc: no free edicts"); {
gi.error("ED_Alloc: no free edicts");
}
globals.num_edicts++; globals.num_edicts++;
G_InitEdict (e); G_InitEdict(e);
return e; return e;
} }
/* /*
================= * Marks the edict as free
G_FreeEdict */
void
Marks the edict as free G_FreeEdict(edict_t *ed)
=================
*/
void G_FreeEdict (edict_t *ed)
{ {
gi.unlinkentity (ed); // unlink from world gi.unlinkentity(ed); /* unlink from world */
if ((ed - g_edicts) <= (maxclients->value + BODY_QUEUE_SIZE)) if ((ed - g_edicts) <= (maxclients->value + BODY_QUEUE_SIZE))
{ {
return; return;
} }
memset (ed, 0, sizeof(*ed)); memset(ed, 0, sizeof(*ed));
ed->classname = "freed"; ed->classname = "freed";
ed->freetime = level.time; ed->freetime = level.time;
ed->inuse = false; ed->inuse = false;
} }
void
/* G_TouchTriggers(edict_t *ent)
============
G_TouchTriggers
============
*/
void G_TouchTriggers (edict_t *ent)
{ {
int i, num; int i, num;
edict_t *touch[MAX_EDICTS], *hit; edict_t *touch[MAX_EDICTS], *hit;
// dead things don't activate triggers! if (!ent)
if ((ent->client || (ent->svflags & SVF_MONSTER)) && (ent->health <= 0)) {
return; return;
}
/* dead things don't activate triggers! */
if ((ent->client || (ent->svflags & SVF_MONSTER)) && (ent->health <= 0))
{
return;
}
num = gi.BoxEdicts (ent->absmin, ent->absmax, touch num = gi.BoxEdicts(ent->absmin, ent->absmax, touch,
, MAX_EDICTS, AREA_TRIGGERS); MAX_EDICTS, AREA_TRIGGERS);
// be careful, it is possible to have an entity in this /* be careful, it is possible to have an entity in this
// list removed before we get to it (killtriggered) list removed before we get to it (killtriggered) */
for (i=0 ; i<num ; i++) for (i = 0; i < num; i++)
{ {
hit = touch[i]; hit = touch[i];
if (!hit->inuse) if (!hit->inuse)
{
continue; continue;
}
if (!hit->touch) if (!hit->touch)
{
continue; continue;
hit->touch (hit, ent, NULL, NULL); }
hit->touch(hit, ent, NULL, NULL);
} }
} }
/* /*
============ * Call after linking a new trigger
G_TouchSolids * in during gameplay to force all
* entities it covers to immediately
Call after linking a new trigger in during gameplay * touch it
to force all entities it covers to immediately touch it */
============ void
*/ G_TouchSolids(edict_t *ent)
void G_TouchSolids (edict_t *ent)
{ {
int i, num; int i, num;
edict_t *touch[MAX_EDICTS], *hit; edict_t *touch[MAX_EDICTS], *hit;
if (!ent)
{
return;
}
num = gi.BoxEdicts(ent->absmin, ent->absmax, touch,
MAX_EDICTS, AREA_SOLID);
num = gi.BoxEdicts (ent->absmin, ent->absmax, touch /* be careful, it is possible to have an entity in this
, MAX_EDICTS, AREA_SOLID); list removed before we get to it (killtriggered) */
for (i = 0; i < num; i++)
// be careful, it is possible to have an entity in this
// list removed before we get to it (killtriggered)
for (i=0 ; i<num ; i++)
{ {
hit = touch[i]; hit = touch[i];
if (!hit->inuse) if (!hit->inuse)
{
continue; continue;
}
if (ent->touch) if (ent->touch)
ent->touch (hit, ent, NULL, NULL); {
ent->touch(hit, ent, NULL, NULL);
}
if (!ent->inuse) if (!ent->inuse)
{
break; break;
}
} }
} }
/* /*
============================================================================== * Kills all entities that would touch the
* proposed new positioning of ent. Ent s
Kill box * hould be unlinked before calling this!
*/
============================================================================== qboolean
*/ KillBox(edict_t *ent)
/*
=================
KillBox
Kills all entities that would touch the proposed new positioning
of ent. Ent should be unlinked before calling this!
=================
*/
qboolean KillBox (edict_t *ent)
{ {
trace_t tr; trace_t tr;
if (!ent)
{
return false;
}
while (1) while (1)
{ {
tr = gi.trace (ent->s.origin, ent->mins, ent->maxs, ent->s.origin, NULL, MASK_PLAYERSOLID); tr = gi.trace(ent->s.origin, ent->mins, ent->maxs, ent->s.origin,
NULL, MASK_PLAYERSOLID);
if (!tr.ent) if (!tr.ent)
{
break; break;
}
// nail it /* nail it */
T_Damage (tr.ent, ent, ent, vec3_origin, ent->s.origin, vec3_origin, 100000, 0, DAMAGE_NO_PROTECTION, MOD_TELEFRAG); T_Damage(tr.ent, ent, ent, vec3_origin, ent->s.origin, vec3_origin,
100000, 0, DAMAGE_NO_PROTECTION, MOD_TELEFRAG);
// if we didn't kill it, fail /* if we didn't kill it, fail */
if (tr.ent->solid) if (tr.ent->solid)
{
return false; return false;
}
} }
return true; // all clear return true; /* all clear */
} }