Quake Style - Quake 2 Tutorials
Tech Power Up Mayhem - Part 3
Defense Laser Rune

Defense Laser Rune:

Main credits for this one go to Yaya, whose original defense laser tutorial can be found here at Qdevels. We only need very few done to get it rolling, some of that are even points Yaya back then set on his to-do list. When finished, you'll have a hand-grenade you can stick to the wall, spawns a laser beam to the next (any distance) wall which kills everybody and lasts for some time (naturally, you can modify lifespan, damage and other parameters in the code if you want different settings than the ones I used).

Requirements:

The stuff we did in the previous parts of "Tech Power Up Mayhem". This series of tutorials builds up step-by-step and you must have done any previous pages before adding this one!

Add in the blue code and take out the pink code. Regular yellow code is Zoid's original stuff.

Let's make the big ones first: Here's Yaya's tut again, with all the needed modifications; put this in a new file called g_laser1.c, and make sure you include it in the makefile:

 
#include "g_local.h"
#include "g_laser1.h"
 
void PlaceLaser (edict_t *ent)
{
 edict_t *self, *grenade;
 vec3_t forward, wallp;
 trace_t tr;
 
 int laser_colour[] = {
 0xf2f2f0f0, // red 
 0xd0d1d2d3, // green
 0xf3f3f1f1, // blue  
 0xdcdddedf, // yellow
 0xe0e1e2e3 // bitty yellow strobe 
 };
 
 if ((!ent->client) || (ent->health<=0)) 
 return; 
 
 // modify this if-statement and the message
 // if you want a different number of max defense
 // laser which are possible at a certain time
 if (ent->client->rune_count > 5)
 {
 gi.cprintf(ent, PRINT_HIGH, "No more than 5 defense lasers at one time\n"); 
 return; 
 }
 ent->client->rune_count += 1;
 
 // Setup "little look" to close wall 
 VectorCopy(ent->s.origin,wallp); 
 
 // Cast along view angle
 AngleVectors (ent->client->v_angle, forward, NULL, NULL); 
 
 // Setup end point
 wallp[0] = ent->s.origin[0] + forward[0] * 50;
 wallp[1] = ent->s.origin[1] + forward[1] * 50;
 wallp[2] = ent->s.origin[2] + forward[2] * 50; 
 
 // trace
 tr = gi.trace (ent->s.origin, NULL, NULL, wallp, ent, MASK_SOLID);
 
 // Line complete ? (ie. no collision)
 if (tr.fraction == 1.0)
 {
 gi.cprintf (ent, PRINT_HIGH, "Too far away from wall\n");
 return;
 }
 
 // Hit sky ?
 if (tr.surface)
 if (tr.surface->flags & SURF_SKY) 
 return;
 
 // Ok, lets stick one on then ...
 gi.cprintf (ent, PRINT_HIGH, "Placed laser.\n");
 
 // -------------
 // Setup laser
 // -------------
 self = G_Spawn();
 self->movetype = MOVETYPE_NONE; 
 self->activator = ent;
 self->solid = SOLID_NOT;
 self->s.renderfx = RF_BEAM|RF_TRANSLUCENT;
 self->s.modelindex = 1;
 self->s.sound = gi.soundindex ("world/laser.wav");
 self->classname = "laser1";
 self->s.frame = 2;
 self->owner = self;
 self->s.skinnum = laser_colour[((int) (random() * 1000)) 5];
 self->dmg = LASER_DAMAGE-10;
 self->think = pre_target_laser_think;
 self->delay = level.time + LASER_TIME;
 
 // Set orgin of laser to point of contact with wall
 VectorCopy(tr.endpos, self->s.origin);
 
 // convert normal at point of contact to laser angles
 vectoangles(tr.plane.normal, self->s.angles);
 
 // setup laser movedir (projection of laser)
 G_SetMovedir (self->s.angles, self->movedir);
 VectorSet (self->mins, -8, -8, -8); 
 VectorSet (self->maxs, 8, 8, 8);
 
 // link to world 
 gi.linkentity (self); 
 
 // start off ...
 target_laser_off (self);
 
 // ... but make automatically come on
 self->nextthink = level.time + 2;
 
 grenade = G_Spawn(); 
 VectorClear (grenade->mins); 
 VectorClear (grenade->maxs);
 VectorCopy (tr.endpos, grenade->s.origin);
 vectoangles(tr.plane.normal,grenade -> s.angles);
 grenade->movetype = MOVETYPE_NONE; 
 grenade->clipmask = MASK_SHOT;
 grenade->solid = SOLID_NOT;
 grenade->s.modelindex = gi.modelindex ("models/objects/grenade2/tris.md2");
 grenade->owner = self;
 grenade->nextthink = level.time + LASER_TIME;
 grenade->think = G_FreeEdict; 
 gi.linkentity (grenade);
}
 
void pre_target_laser_think (edict_t *self)
{
 target_laser_on (self);
 
 self->think = laserbarriere_think;
}
 
void laserbarriere_think (edict_t *self)
{
 edict_t *ignore;
 edict_t *ent;
 vec3_t start;
 vec3_t end;
 trace_t tr;
 vec3_t point;
 vec3_t last_movedir;
 int count;
 
 // Defense Laser Rune
 if (strcmp(self->classname,"laser1") == 0)
 if (level.time > self->delay) 
 { 
 // bit of damage
 T_RadiusDamage (self, self->activator, LASER_MOUNT_DAMAGE_RADIUS, NULL, LASER_MOUNT_DAMAGE, MOD_LASER1);
 
 // BANG !
 gi.WriteByte (svc_temp_entity);
 gi.WriteByte (TE_EXPLOSION1);
 gi.WritePosition(self -> s.origin);
 gi.multicast (self->s.origin, MULTICAST_PVS); 
 
 // bye bye laser
 ent = self->activator;
 ent->client->rune_count=ent->client->rune_count-1;
 G_FreeEdict (self);
 return;
 }
 
 if (self->spawnflags & 0x80000000)
 count = 8;
 else
 count = 4;
 
 if (self->enemy)
 {
 VectorCopy (self->movedir, last_movedir);
 VectorMA (self->enemy->absmin, 0.5, self->enemy->size, point);
 VectorSubtract (point, self->s.origin, self->movedir);
 VectorNormalize (self->movedir);
 if (!VectorCompare(self->movedir, last_movedir))
 self->spawnflags |= 0x80000000;
 }
 
 ignore = self;
 
 VectorCopy (self->s.origin, start);
 VectorMA (start, 2048, self->movedir, end);
 while(1)
 {
 tr = gi.trace (start, NULL, NULL, end, ignore, CONTENTS_SOLID|CONTENTS_MONSTER|CONTENTS_DEADMONSTER);
 
 if (!tr.ent)
 break;
 
 // hurt it if we can
 if ((tr.ent->takedamage) && !(tr.ent->flags & FL_IMMUNE_LASER))
 T_Damage (tr.ent, self, self->activator, self->movedir, tr.endpos, vec3_origin, self->dmg, 1, DAMAGE_ENERGY, MOD_LASER1);
 
 // if we hit something that's not a monster or player or is immune to lasers, we're done
 if (!(tr.ent->svflags & SVF_MONSTER) && (!tr.ent->client))
 {
 if (self->spawnflags & 0x80000000)
 {
 self->spawnflags &= ~0x80000000;
 gi.WriteByte (svc_temp_entity);
 gi.WriteByte (TE_LASER_SPARKS);
 gi.WriteByte (count);
 gi.WritePosition (tr.endpos);
 gi.WriteDir (tr.plane.normal);
 gi.WriteByte (self->s.skinnum);
 gi.multicast (tr.endpos, MULTICAST_PVS);
 }
 break;
 }
 
 ignore = tr.ent;
 VectorCopy (tr.endpos, start);
 }
 
 VectorCopy (tr.endpos, self->s.old_origin);
 
 self->nextthink = level.time + FRAMETIME;
}
 

There are a handful of comments; the most interesting may be that through the if-statement re rune_count, you can control how many defense lasers are possible at a give time; note that after the laser "dies" (see seetings in g_laser.h), rune_count is set back by one and you can place another one. The second new file we need is g_laser1.h - insert the following:

 
/*
LASER DEFENSE RUNE
*/
 
// my functions 
void PlaceLaser (edict_t *ent);
void pre_target_laser_think (edict_t *self); 
void deathpak_think(edict_t *deathpak);
 
// controlling parameters
#define LASER_TIME 30
#define LASER_DAMAGE 80
#define LASER_MOUNT_DAMAGE 40
#define LASER_MOUNT_DAMAGE_RADIUS 64
 
// In-built Quake2 routines
 
void target_laser_use (edict_t *self, edict_t *other, edict_t *activator);
void laserbarriere_think (edict_t *self);
void target_laser_on (edict_t *self); 
void target_laser_off (edict_t *self);
 
// Laser Beam Color Codes
 
#define Laser_Red 0xf2f2f0f0 // bright red
 
#define Laser_Green 0xd0d1d2d3 // bright green
 
#define Laser_Blue 0xf3f3f1f1 // bright blue
 
#define Laser_Yellow 0xdcdddedf // bright yellow
 
#define Laser_YellowS 0xe0e1e2e3 // yellow strobe
 
#define Laser_DkPurple 0x80818283 // dark purple
 
#define Laser_LtBlue 0x70717273 // light blue
 
#define Laser_Green2 0x90919293 // different green
 
#define Laser_Purple 0xb0b1b2b3 // purple
 
#define Laser_Red2 0x40414243 // different red
 
#define Laser_Orange 0xe2e5e3e6 // orange
 
#define Laser_Mix 0xd0f1d3f3 // mixture
 
#define Laser_RedBlue 0xf2f3f0f1 // inner = red, outer = blue
 
#define Laser_BlueRed 0xf3f2f1f0 // inner = blue, outer = red
 
#define Laser_GreenY 0xdad0dcd2 // inner = green, outer = yellow
 
#define Laser_YellowG 0xd0dad2dc // inner = yellow, outer = green
 

The parameters should be self-explanatory; toy around with 'em until you're satisfied. As we want a specific MOD (means of death), we have to add one to g_local.h:

#define MOD_TARGET_LASER 30
#define MOD_TRIGGER_HURT 31
#define MOD_HIT 32
#define MOD_TARGET_BLASTER 33
#define MOD_GRAPPLE 34
#define MOD_LASER1 35

Then we gotta take care of the messages, which is done in p_client.c - look for the ClientObituary() function. There we have to add (as with all deaths) three messages. The first one will look a little differently than you're used to to make sure everything is credited properly. In the "if (deathmatch->value || coop->value)"-statement add the following:

 case MOD_TRIGGER_HURT:
 message = "was in the wrong place";
 break;
 case MOD_LASER1:
 //have to prevent this from checking for "MOD_LASER1"
 //since that assumes that it was a self inflicted death
 if(strcmp(inflictor->classname, "laser1") && (attacker != inflictor->activator))
 message = "got a defense laser up his butt";
 break;
 

Second, in the "if (attacker == self)"-statement, add:

 case MOD_BFG_BLAST:
 message = "should have used a smaller gun";
 break;
 case MOD_LASER1:
 message = "was killed by the own defense laser";
 break;
 default:
 if (IsFemale(self))
 message = "killed herself";
 else
 message = "killed himself";
 break;

Third, in the "if (attacker && attacker->client)"-statement, add this:

//ZOID
 case MOD_GRAPPLE:
 message = "was caught by";
 message2 = "'s grapple";
 break;
//ZOID
 case MOD_LASER1:
 message="got";
 message2="'s defense laser up his butt";
 break;
 }
 if (message)
 {
 gi.bprintf (PRINT_MEDIUM,"s s ss\n", self->client->pers.netname, message, attacker->client->pers.netname, message2);

Did we forget the item itself? Yep, so we should open g_items.c and add it at the very end of the itemlist[]:

 
/* Defense Laser */
 {
 "item_tech5",
 CTFPickup_Tech,
 NULL,
 CTFDrop_Tech, //Should this be null if we don't want players to drop it manually?
 NULL,
 "items/pkup.wav",
 "models/ctf/regeneration/tris.md2", EF_ROTATE,
 NULL,
/* icon */ "tech4",
/* pickup */ "Defense Laser [U]",
/* width */ 2,
 0,
 NULL,
 IT_TECH,
 // 0, // NOTE: activate/deactivate this line to set up for different source bases (CTF or 3.20)
 NULL,
 0,
/* precache */ "ctf/tech4.wav"
 },
 
 // end of list marker
 {NULL}
};

Important note: Depending on which source base you use, you may need to include the line above ("NOTE: activate/deactivate...") to make your compilation work without warnings. If you use the CTF source as used in our tut, you can leave it like above; if you added the CTF functionality to the 3.20 source yourself, you need to include this line in your source. (This is the Viewable Weapons ID line!)

Note: In case you change the pickup name, you also must change every other occurence of it (like in the Rune_Use() function).
Feel free to modify sounds and item models (see also my comment at the bottom of Part Two).

Last step: Open g_ctf.c and replace this:

 
static char *tnames[] = {
 "item_tech1", "item_tech2", "item_tech3", "item_tech4",
 NULL
};
 

with this:

 
static char *tnames[] = {
 "item_tech1", "item_tech2", "item_tech3", "item_tech4", "item_tech5",
 NULL
};
 

And before you compile, you need to extend the Rune_Use() function:

void Rune_Use(edict_t *ent)
{
 int index;
 gitem_t *it;
 
 char *rune_msg;
 
 // say "no rune or automatically activated rune" if there is no
 // special usage (=pressing a button) needed or if player
 // doesn't own a rune
 // otherwise just call the using function for that specific rune
 rune_msg="No rune or automatically activated rune";
 
 it = FindItem ("Defense Laser [U]"); 
 index = ITEM_INDEX (it);
 if (ent->client->pers.inventory[index])
 {
 PlaceLaser (ent);
 return;
 }
 
 gi.centerprintf(ent, "s\n",rune_msg);
}

Woops, done! Compile, try! Be sure to bind a key to "drop tech" (to throw away a rune if you want pick up a new one) and to "userune" (to use a rune like the one we just added).

Nick back to the tutorials page and have a look at the next tutorial in the sequence.

-- Credits:
   Tutorial by peter
QS Tutorials

-- Important:
   If you do use something from QuakeStyle in your mod, please give us credit.
   Our code is copyrighted, but we give permission to everyone to use it in any way they see fit, as long as we are recognized.