TUTORIAL 19 - Vulnerable Missiles
by Lancer
Thanks go to
Chris Hilton for his Q2 Vulnerable
Rockets Tutorial on QDevels upon which
much of this tutorial is based.
This
tutorial explains how to make rockets or grenades or any missile in
general, vulnerable to being shot and destroyed. I was trying
to do this myself, and after checking various forums noticed that a
few people had some small problems with it. Once I got it
working, I decided I might as well share what I've found. The
process is actually quite easy and only a few changes have to be
made.
Files
modified:
g_missile.c
g_weapon.c
1. ENTITY FUNCTION POINTERS First off, let's look at g_local.h to
get an idea of how Q3A deals with entities.
Take a look
at the gentitys_t struct at about line 111:
void (*think)(gentity_t *self);
void (*reached)(gentity_t *self);
// movers call this when hitting endpoint
void (*blocked)(gentity_t *self, gentity_t *other);
void (*touch)(gentity_t *self, gentity_t *other, trace_t *trace);
void (*use)(gentity_t *self, gentity_t *other, gentity_t *activator);
void (*pain)(gentity_t *self, gentity_t *attacker, int damage);
void (*die)(gentity_t *self, gentity_t *inflictor, gentity_t *attacker,
int damage, int mod);
These
are different function types that get executed when the entity is in
a certain situation. I will not explain what all of these are
for, except that the one we are concerned with is the die function
pointer. die gets called when an entity's health goes to or
below 0 after being damaged. You can confirm this for yourself
by checking out the end of G_Damage function in the g_combat.c
file.
2. CREATING A DIE FUNCTION Add the following function in
g_missile.c just after G_ExplodeMissile.
/*
================
G_MissileDie
Lancer - Destroy a missile
================
*/
void G_MissileDie( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod ) {
if (inflictor == self)
return;
self->takedamage = qfalse;
self->think = G_ExplodeMissile;
self->nextthink = level.time + 10;
}
All this
function does is catch when a missile has been killed and set the
missile to explode within a short period of time. We ignore
the case where the inflictor of the damage is the same missile
suffering the damage. This case should already be avoided, but
this will cover your @$$ in case something weird happens. We
also stop it from taking damage again, since it's possible that
hitting it persistently will cause it to take forever to
die.
You can
adjust the nextthink time frame to whatever you want. I simply
chose the one from the Q2 Vulnerable
Rockets tutorial by Chris
Hilton on the QDevels board, since
it seemed very reasonable.
Note that
I've also set the think function to G_ExplodeMissile. While
this is redundant in this mod, if you set the think function of your
missile to anything else (for whatever reason) in your mod, this
will ensure that the next think the missile does is to
explode.
3. GIVING LIFE TO OUR MISSILES So now we have the
means of death, let's make a missile destructible! In this
case, I'm going to look at making a rocket vulnerable, though any
other sort of missile (grenade, bfg, plasma) can be changed in the
same way. Go to fire_rocket in g_missile.c, and find this
segment of code:
bolt->nextthink = level.time + 10000;
bolt->think = G_ExplodeMissile;
Now add
the following:
bolt->nextthink = level.time + 10000;
bolt->think = G_ExplodeMissile; // Lancer
bolt->health = 5;
bolt->takedamage = qtrue;
bolt->die = G_MissileDie;
bolt->r.contents = CONTENTS_BODY;
VectorSet(bolt->r.mins, -10, -3, 0);
VectorCopy(bolt->r.mins, bolt->r.absmin);
VectorSet(bolt->r.maxs, 10, 3, 6);
VectorCopy(bolt->r.maxs, bolt->r.absmax);
The
first thing we add is some health to the rocket. 5 is enough
for just about anything in Quake to kill it. We also must
allow this entity to takedamage in the game, and then we point the
die function pointer to our G_MissileDie function. These 3
lines were added primarily for the sake of the G_Damage function, so
that it will damage the rocket, subtract health, and call the die
function once it has been killed.
The next
five lines are for the sake of the trap_Trace function which just
about every weapon in the game uses. The first line gives the
object a solid body, so-to-speak. CONTENTS_BODY will intercept
all kinds of fire. You could choose CONTENTS_CORPSE here too,
but the only real difference is that the one launching the rocket
will be able to clip through it on the CONTENTS_CORPSE
setting. CONTENTS_BODY gives it a solid feel (eg: if you were
modifying a grenade, you'd feel like you were actually stepping on
something if you walked over it (I don't recommend walking over
grenades though)).
The next
four lines define a bounding box which sets the dimensions that the
trap_Trace function will clip against. Think of it as mins
being one corner of a box, and the maxs being the opposing
corner. Again, the values I used for these vectors were taken
from the Q2 Vulnerable
Rockets tutorial by Chris
Hilton. I also copy each vector to the corresponding
absmin/absmax vectors for safety's sake.
And for
testing, let's slow down the rockets so they makes an easy
target. Change the following line near the end of fire_rocket
from: VectorScale( dir, 900, bolt->s.pos.trDelta ); to: VectorScale( dir, 100, bolt->s.pos.trDelta );
4. IS THAT ALL THERE IS? This is actually all you need for your
basic vulnerable missile. However, if you try compiling and
running it, you will notice that if you fire a rocket and try to
shoot it down with your machinegun, it won't blow up! On the
otherhand, if you either blow something else up near it (like firing
a rocket at the ground), or load up some bots to fire rockets for
you to shoot, you will find that they *do* blow up. So we know
that our code is working, but why can't we shoot them down
ourselves?
Go into
g_weapon.c and take a look on the Bullet_Fire function at this
line: trap_Trace (&tr, muzzle, NULL, NULL, end,
ent->s.number, MASK_SHOT); This system call
traces a line for a certain distance and stops at the first entity
it encounters. Notice the second last paramter
though: ent->s.number This identifies the
client number, or essentially skips the owner of the entity.
This means you're not going to be able to shoot down your own
missiles! Change the line to: trap_Trace (&tr, muzzle, NULL, NULL, end,
ENTITYNUM_NONE, MASK_SHOT); Now your rockets
become a valid target (and technically so do you), but only for your
machinegun bullets. You'd have to change the trap_Trace
function for every weapon you want to be able to shoot your own
missiles down with. But since there's really no reason to
shoot at your own missiles, let's just use the machinegun this way
to look at our handiwork.
5. FINISHING TOUCHES Now if you compile and run, you'll be
able to shoot down your own rockets like the slow slugs they
are. But without any Bots hounding us, you might notice that
whenever your rocket hits a wall the "hit" sound gets played.
This seems out of place.
If you think
about it a little, you'll realize what's happening. The only
thing that's actually getting hit is your own rocket. The way
Quake 3 Arena seems to work is that the rocket explodes before the
entity is cleared away. Therefore, even though the rocket hits
a wall and explodes, it's within its own blast-radius and attempts
to damage itself. This registers a "hit"
sound.
This can
easily be fixed. A rocket can explode in two ways, either it
hits a wall or it explodes after its nextthink time is
reached. Open up g_missile.c again, and we'll add a single
line in two places.
In
G_MissileImpact look for: // check for bounce
if ( !other->takedamage &&
( ent->s.eFlags & ( EF_BOUNCE | EF_BOUNCE_HALF ) ) ) {
G_BounceMissile( ent, trace );
G_AddEvent( ent, EV_GRENADE_BOUNCE, 0 );
return;
}and add in: // check for bounce
if ( !other->takedamage &&
( ent->s.eFlags & ( EF_BOUNCE | EF_BOUNCE_HALF ) ) ) {
G_BounceMissile( ent, trace );
G_AddEvent( ent, EV_GRENADE_BOUNCE, 0 );
return;
}
// Lancer
ent->takedamage = qfalse;G_MissileImpact is
what happens whenever a missile hits anything, be it floor, wall or
Quake d00d. If we turn off takedamage here, it will ensure
that the only hit registered is that of another player being
hit.
Note that
this line is inserted after a bouncing object leaves the function,
so that grenades don't become indestructible after the first
bounce.
Now look in
G_Explode, right after the vector declarations:
vec3_t dir;
vec3_t origin; and add
in: vec3_t dir;
vec3_t origin;
// Lancer
ent->takedamage = qfalse; This is the only
other place that missiles seem to explode. Therefore, turn the
takedamage boolean off so we don't register a hit because of our
exploding missile.
If you
compile and run now, no longer will you hear those "bip" sounds when
your rockets impact walls. Now you're all set to try and
either dodge those incoming missiles, or shoot 'em down! Also, feel
free to set your rocket speed to whatever you want (since 100 is way
too slow in a practical game). To make grenades or other
missile objects shootable, just copy what you've got in fire_rocket
now and stick it into the corresponding missile's fire
function. Play with the vectors a bit, compile and blow 'em
up!
Shoot
straight and have
fun! | 
