Date : 01/18/99 Author(s) : SpK Skill(s) : Medium Source Project(s) : Game Revision : 1.0

With this tutorial, we'll learn how to handle the client prediction in Q3:A, with the Guided Rockets (tm). Basically, client prediction is used to avoid too much net traffic. In Quake2, the server had to send to all the clients packets holding the origins of the rocket, so the client's renderer (quake2.exe) could display it using those coords. Okey, that was fun, but now there's something better ! We're gonna tells Q3 from where our rocket is fired, and what direction our rocket is taking, and we'll let the Q3 renderer calculate where the rocket will explode !

In q_shared.h, you'll find the following structures :

typedef enum { TR_STATIONARY, TR_INTERPOLATE, // non-parametric, but interpolate between snapshots TR_LINEAR, TR_LINEAR_STOP, TR_SINE, // value = base + sin( time / duration ) * delta TR_GRAVITY } trType_t; typedef struct { trType_t trType; int trTime; int trDuration; // if non 0, trTime + trDuration = stop time vec3_t trBase; vec3_t trDelta; // velocity, etc } trajectory_t;

 

The trajectory_t structure will be used when we'll have to give a movement to an entity. The main fields will be trDelta, the old Q2's ent->velocity (the velocity vector), and trBase, the origin of the movement/trajectory.

Now, let's write our guided rocket code. Open up g_missile.c, and write this just above the fire_rocket() function :

void Guided_Missile_Think (gentity_t *missile) { vec3_t forward, right, up; vec3_t muzzle; float dist; gentity_t *player = missile->parent; // If our owner can't be found, just return if (!player) { G_Printf ("Guided_Missile_Think : missile has no owner!\n"); return; } // Get our forward, right, up vector from the view angle of the player AngleVectors (player->client->ps.viewangles, forward, right, up); // Calculate the player's eyes origin, and store this origin in muzzle CalcMuzzlePoint ( player, forward, right, up, muzzle ); // Tells the engine that our movement starts at the current missile's origin VectorCopy (missile->r.currentOrigin, missile->s.pos.trBase ); // Trajectory type setup (linear move - fly) missile->s.pos.trType = TR_LINEAR; missile->s.pos.trTime = level.time - 50; // Get the dir vector between the player's point of view and the rocket // and store it into muzzle again VectorSubtract (muzzle, missile->r.currentOrigin, muzzle); // Add some range to our "line" so we can go behind blocks // We could have used a trace function here, but the rocket would // have come back if player was aiming on a block while the rocket is behind it // as the trace stops on solid blocks dist = VectorLength (muzzle) + 400; //give the range of our muzzle vector + 400 units VectorScale (forward, dist, forward); // line straight forward VectorAdd (forward, muzzle, muzzle); // Normalize the vector so it's 1 unit long, but keep its direction VectorNormalize (muzzle); // Slow the rocket down a bit, so we can handle it VectorScale (muzzle, 300, forward); // Set the rockets's velocity so it'll move toward our new direction VectorCopy (forward, missile->s.pos.trDelta); // Change the rocket's angle so it'll point toward the new direction vectoangles (muzzle, missile->s.angles); // This should "save net bandwidth" =D SnapVector( missile->s.pos.trDelta ); // Call this function in 0,1 s missile->nextthink = level.time + FRAMETIME; }

Then move to the fire_rocket(...) function just under our new one, and modify it so it looks like this :

gentity_t *fire_rocket (gentity_t *self, vec3_t start, vec3_t dir) { gentity_t *bolt; VectorNormalize (dir); bolt = G_Spawn(); bolt->classname = "rocket"; //### NEW ### //bolt->nextthink = level.time + 10000; //bolt->think = G_ExplodeMissile; if (self->client) // && check for bots { bolt->think = Guided_Missile_Think; bolt->nextthink = level.time + FRAMETIME; } else { bolt->nextthink = level.time + 10000; bolt->think = G_ExplodeMissile; } //### END NEW ### bolt->s.eType = ET_MISSILE; bolt->r.svFlags = SVF_USE_CURRENT_ORIGIN; .......... .......... }

So what we're doing here is replacing the regular rocket think function (goes straight ahead and explode once it touchs something) by our own think function, Guided_Missile_Think. So when the player will shoot a rocket, he'll be able to aim his rocket wherever he wants with his mouse. However, we're testing if "self" is really a client, just in case... Bots will also be able to use guided rockets as they use the same firing function.

Compile your code, and run the game. Take the rocket launcher, and fire... Add some bots and kick their ass around the map... Who said "soooo easy !" ? ;)

Okey now stop playing... Let's study our code. In our think function, we've played with client prediction. Everytime we change the direction of the rocket, we tells the engine that we're also changing the rocket's behaviour, so the client's renderer knows he has to change the rocket's movement. We're using the current rocket's origin to setup the origin of our new direction change, and then we also change the velocity and angle of the rocket so it's going to the direction where we're aiming at. Now, on the client side, the renderer (well, the cgame part) will calculate where the rocket should go, thanks to our trBase and trDelta informations. Just try removing those datas from our new code, and you'll see your rockets going in VERY strange directions ;)

---