PlanetQuake | Code3Arena | Tutorials | << Prev | Tutorial 19 | Next >>


  • Home/News
  • ModSource
  • Compiling
  • Help!!!
  • Submission
  • Contributors
  • Staff
  • Downloads

    < Index >
    1. Mod making 101
    2. Up 'n running
    3. Hello, QWorld!
    4. Infinite Haste
    5. Armor Piercing Rails
    6. Bouncing Rockets
    7. Cloaking
    8. Ladders
    9. Favourite Server
    10. Flame Thrower
    11. Vortex Grenades
    12. Grapple
    13. Lightning Discharge
    14. Locational Damage
    15. Leg Shots
    16. Weapon Switching
    17. Scoreboard frag-rate
    18. Vortex Grenades II
    19. Vulnerable Missiles
    20. Creating Classes
    21. Scrolling Credits
    22. Weapon Dropping
    23. Anti-Gravity Boots
    24. HUD scoreboard
    25. Flashlight and laser
    26. Weapon Positioning
    27. Weapon Reloading
    28. Progressive Zooming
    29. Rotating Doors
    30. Beheading (headshot!)
    31. Alt Weapon Fire
    32. Popup Menus I
    33. Popup Menus II
    34. Cluster Grenades
    35. Homing Rockets
    36. Spreadfire Powerup
    37. Instagib gameplay
    38. Accelerating rockets
    39. Server only Instagib
    40. Advanced Grapple Hook
    41. Unlagging your mod

    < Index >
    1. Entities
    2. Vectors
    3. Good Coding
    4. Compilers I
    5. Compilers II
    6. UI Menu Primer I
    7. UI Menu Primer II
    8. UI Menu Primer III
    9. QVM Communication, Cvars, commands
    10. Metrowerks CodeWarrior
    11. 1.27g code, bugs, batch


  • Quake3 Files
  • Quake3 Forums
  • Q3A Editing Message Board
  • Quake3 Editing


  • SumFuka
  • Calrathan
  • HypoThermia
  • WarZone

    Site Design by:
    ICEmosis Design

    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:


    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.


    Add the following function in g_missile.c just after G_ExplodeMissile.
    Lancer - Destroy a missile
    void G_MissileDie( gentity_t *self, gentity_t *inflictor,
            gentity_t *attacker, int damage, int mod ) {
            if (inflictor == self)
            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.


    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 );
            VectorScale( dir, 100, bolt->s.pos.trDelta );


    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:
    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.


    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 );
    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 );
    // 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!

    PlanetQuake | Code3Arena | Tutorials | << Prev | Tutorial 19 | Next >>