mv
/
q2wf-portable
1
0
Fork 0
Code Issues 4 Pull Requests Packages Projects Releases Wiki Activity
q2wf-portable/b_turret.c

1456 lines
37 KiB
C
Raw Permalink Normal View History

Extract original source code from wfsource421.zip, dated 1999
2024-09-02 07:03:07 -04:00
#include "g_local.h"
#include "m_player.h"
#include "bot_procs.h"
#define newTurret self->turret1
#define newTurret2 self->turret1->turret2
#define Level1Idle 0
#define Level1StartFirst 1
#define Level1StartEnd 2
#define Level1AttackFirst 3
#define Level1AttackEnd 6
#define Level23Idle 0
#define Level23AttackFirst 1
#define Level23AttackEnd 2
#define StatusIdle 0
#define StatusStart 1
#define StatusAttack 2
#define DIRECTION_LEFT 1
#define DIRECTION_CENTER 2
#define DIRECTION_RIGHT 3
#define LEVEL1_DAMAGE 6
#define LEVEL2_DAMAGE 8
#define LEVEL3_DAMAGE 12
#define max(a,b) (((a) > (b)) ? (a) : (b))
void BecomeExplosion1 (edict_t *self);
void SP_Turret (edict_t *self);
//void fire_bullet (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int kick, int hspread, int vspread);
void TurretFire1(edict_t *self);
void turret_self_remove(edict_t *ent);
void turret_remove(edict_t *ent);
void SentryReload(edict_t *ent, pmenu_t *p);
void SentryUpgrade(edict_t *ent, pmenu_t *p);
void SentryRepair(edict_t *ent, pmenu_t *p);
int PlayerChangeScore(edict_t *self, int points);
//Add or subtract ammo from sentry gun
void UpdateSentryAmmo(edict_t *ent, int change_amt)
{
ent->light_level += change_amt;
if (ent->light_level == 25)
{
safe_cprintf(ent->creator, PRINT_HIGH, "Warning: Your sentry gun is low on ammo.\n");
}
}
void turret_fire_rocket (edict_t *ent, int direction)
{
vec3_t forward, right, start, target, dir;
if(ent->light_level<1)
return;
UpdateSentryAmmo(ent, -1);
AngleVectors (ent->s.angles, forward, right, NULL);
if (direction == DIRECTION_LEFT)
{
start[0] = ent->s.origin[0] + forward[0] * 3 + right[0] * -0.5;
start[1] = ent->s.origin[1] + forward[1] * 3 + right[1] * -0.5;
start[2] = ent->s.origin[2] + forward[2] * 3 + right[2] * -0.5 +4;
}
else if (direction == DIRECTION_CENTER)
{
start[0] = ent->s.origin[0] + forward[0] * 3 ;
start[1] = ent->s.origin[1] + forward[1] * 3 ;
start[2] = ent->s.origin[2] + forward[2] * 3+4;
}
else // Right
{
start[0] = ent->s.origin[0] + forward[0] * 3 + right[0] * 0.5;
start[1] = ent->s.origin[1] + forward[1] * 3 + right[1] * 0.5;
start[2] = ent->s.origin[2] + forward[2] * 3 + right[2] * 0.5+4;
}
// calc direction to where we targetd
VectorMA (ent->enemy->s.origin, -0.05, ent->enemy->velocity, target);
VectorSubtract (target, start, dir);
VectorNormalize (dir);
fire_rocket (ent, start, dir, 25, 650, 25, 25, MOD_SENTRY_ROCKET);
// send muzzle flash
gi.WriteByte (svc_muzzleflash);
gi.WriteShort (ent - g_edicts);
gi.WriteByte (MZ_SHOTGUN );
gi.multicast (start, MULTICAST_PVS);
// gi.sound(ent, CHAN_VOICE, gi.soundindex("boss3/xfire.wav"), 1, ATTN_NORM, 0);
}
//New turret bullet firing code. Replaces fire_bullet and fire_rail
//Fires at ent->enemy
//direction = 1 (left), 2 (center), 3 (right)
void turret_fire_bullet (edict_t *ent, int direction)
{
vec3_t forward, right, start, target, dir;
vec3_t from;
vec3_t end;
trace_t tr;
edict_t *ignore;
int mask;
qboolean water;
int kick = 0;
int mod = MOD_SENTRY;
int damage;
float chance_of_hit;
float maxvelocity;
float r;
if (wfdebug) gi.dprintf("turret_fire_bullet\n");
if(ent->light_level<1) //do we have ammo?
return;
if (!ent->enemy)
return;
UpdateSentryAmmo(ent, -1);
//Calculate starting position
AngleVectors (ent->s.angles, forward, right, NULL);
if (direction == DIRECTION_LEFT)
{
start[0] = ent->s.origin[0] + forward[0] * 3 + right[0] * -0.5;
start[1] = ent->s.origin[1] + forward[1] * 3 + right[1] * -0.5;
start[2] = ent->s.origin[2] + forward[2] * 3 + right[2] * -0.5 +4;
}
else if (direction == DIRECTION_CENTER)
{
start[0] = ent->s.origin[0] + forward[0] * 3 ;
start[1] = ent->s.origin[1] + forward[1] * 3 ;
start[2] = ent->s.origin[2] + forward[2] * 3+4;
}
else // Right
{
start[0] = ent->s.origin[0] + forward[0] * 3 + right[0] * 0.5;
start[1] = ent->s.origin[1] + forward[1] * 3 + right[1] * 0.5;
start[2] = ent->s.origin[2] + forward[2] * 3 + right[2] * 0.5+4;
}
// calc direction to where we targetd
VectorMA (ent->enemy->s.origin, -0.05, ent->enemy->velocity, target);
//Adjust for height
// target[2] += ent->enemy->viewheight/1.5;
VectorSubtract (target, start, dir);
VectorNormalize (dir);
VectorMA (start, 8192, dir, end);
VectorCopy (start, from);
ignore = ent;
water = false;
mask = MASK_SHOT|CONTENTS_SLIME|CONTENTS_LAVA;
tr = gi.trace (from, NULL, NULL, end, ignore, mask);
if (tr.contents & (CONTENTS_SLIME|CONTENTS_LAVA))
{
mask &= ~(CONTENTS_SLIME|CONTENTS_LAVA);
water = true;
}
//Do damage
//Damage based on sentry level
chance_of_hit = 1;
if (ent->count == 1)
{
damage = LEVEL1_DAMAGE;
chance_of_hit = .85;
}
else if (ent->count == 2)
{
damage = LEVEL2_DAMAGE;
chance_of_hit = .90;
}
else if (ent->count == 3)
{
damage = LEVEL3_DAMAGE;
chance_of_hit = .95;
}
else
{
damage = 1; //don't know what level it is
chance_of_hit = 1.0; //always hit
}
//Moving reduces chance of being hit
maxvelocity = max( abs (ent->enemy->velocity[0]), abs (ent->enemy->velocity[1]) );
if (maxvelocity >= 320) //wierd setting for grappling
{
chance_of_hit = chance_of_hit * .65;
}
else if (maxvelocity >= 250) //running
{
chance_of_hit = chance_of_hit * .74;
}
else if (maxvelocity >= 150) //walking
{
chance_of_hit = chance_of_hit * .90;
}
r = random();
if (wfdebug) gi.dprintf("chance =%f, rnd = %f, takedamage? %d\n", chance_of_hit, r, ent->enemy->takedamage);
if ((ent->enemy->takedamage) && (r <= chance_of_hit))
// T_Damage (ent->enemy, ent, ent->creator, dir, tr.endpos, tr.plane.normal, damage, 0, 0, MOD_SENTRY);
T_Damage (ent->enemy, ent, ent, dir, tr.endpos, tr.plane.normal, damage, 0, 0, MOD_SENTRY);
//Do gunshot effect
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_GUNSHOT);
gi.WritePosition (tr.endpos);
gi.WriteDir (tr.plane.normal);
gi.multicast (tr.endpos, MULTICAST_PVS);
if (ent->client)
PlayerNoise(ent, tr.endpos, PNOISE_IMPACT);
// send muzzle flash
gi.WriteByte (svc_muzzleflash);
gi.WriteShort (ent - g_edicts);
gi.WriteByte (MZ_SHOTGUN );
gi.multicast (start, MULTICAST_PVS);
// gi.sound(ent, CHAN_VOICE, gi.soundindex("boss3/xfire.wav"), 1, ATTN_NORM, 0);
}
void TurretAnimate(edict_t *ent)
{
if(ent->count==1)
{
if(ent->delay==StatusIdle)
{
ent->s.frame = Level1Idle;
return;
}
else if(ent->delay==StatusStart)
{
if(ent->s.frame == Level1StartEnd)
{
ent->delay=StatusAttack;
ent->s.frame=Level1AttackFirst;
return;
}
else if(ent->s.frame==Level1Idle)
{
ent->s.frame = Level1StartFirst;
return;
}
else if(ent->s.frame==Level1StartFirst)
{
ent->s.frame++;
return;
}
else
{
ent->s.frame = Level1Idle;
return;
}
}
else
{
if(ent->delay==StatusAttack)
{
if(ent->s.frame==Level1AttackEnd)
{
ent->s.frame--;
return;
}
else
{
ent->s.frame++;
return;
}
}
}
}
else
{
if(ent->delay ==StatusIdle)
{
ent->s.frame = Level23Idle;
return;
}
else
{
if(ent->s.frame==Level23AttackEnd)
{
ent->s.frame = Level23AttackFirst;
return;
}
ent->s.frame++;
return;
}
}
}
void FireTurretLeft(edict_t *ent)
{
float f;
if (wfdebug) gi.dprintf("Sentry Fire Left\n");
//Fire bullet. For level 3 sentry's, fire rocket every 10th round
f = ent->light_level / 10;
if (((f * 10) == ent->light_level) && (ent->count == 3))
turret_fire_rocket (ent, DIRECTION_LEFT);
else
turret_fire_bullet (ent, DIRECTION_LEFT);
}
void FireTurretCenter(edict_t *ent)
{
float f;
if (wfdebug) gi.dprintf("Sentry Fire Center\n");
//Fire bullet. For level 3 sentry's, fire rocket every 10th round
f = ent->light_level / 10;
if (((f * 10) == ent->light_level) && (ent->count == 3))
turret_fire_rocket (ent, DIRECTION_CENTER);
else
turret_fire_bullet (ent, DIRECTION_CENTER);
}
void FireTurretRight(edict_t *ent)
{
float f;
if (wfdebug) gi.dprintf("Sentry Fire Right\n");
//Fire bullet. For level 3 sentry's, fire rocket every 10th round
f = ent->light_level / 10;
if (((f * 10) == ent->light_level) && (ent->count == 3))
turret_fire_rocket (ent, DIRECTION_RIGHT);
else
turret_fire_bullet (ent, DIRECTION_RIGHT);
}
void Turret_Think(edict_t *self)
{
static char Sentry[32];
static char Armor[32];
static char Ammo[32];
static char Level[32];
int range;
int light_level;
int max_dist;
edict_t *blip;
float dist;
int contents;
int ideal_yaw = 0;
vec3_t v;
trace_t tr;
// gitem_t *ammo;
// int max;
float checkyaw;
blip = NULL;
//If there is no client attached to this turret any more, it should be removed
//from the game
if (!self->creator) //There is no creator
{
turret_self_remove(self);
}
if (!self->creator->client) //Creator isn't a client
{
turret_self_remove(self);
}
//Make sure that the creator of this sentry gun also has an
//entry that points back to this sentry
if (!self->creator->sentry) //creator doesn't know about this sentry
{
turret_self_remove(self);
}
if (self->creator->sentry != self) //creator has a different sentry
{
turret_self_remove(self);
}
//If sentry or stand is in something solid, remove it
contents = (int)gi.pointcontents(self->s.origin);
if (contents & CONTENTS_SOLID)
{
safe_cprintf(self->creator, PRINT_HIGH, "Your sentry was in a bad map position, so it was removed.\n");
turret_self_remove(self);
return;
}
if (self->sentry) //stand
{
contents = (int)gi.pointcontents(self->sentry->s.origin);
if (contents & CONTENTS_SOLID)
{
safe_cprintf(self->creator, PRINT_HIGH, "Your sentry stand in a bad map position so it was removed.\n");
turret_self_remove(self);
return;
}
}
/*if (self->light_level!=self->gib_health)
{
if (self->PlasmaDelay<level.time)
{
max = self->gib_health;
if (self->count==3)
self->PlasmaDelay = level.time +0.1;
else if (self->count==2)
self->PlasmaDelay = level.time +0.2;
else
self->PlasmaDelay = level.time +0.4;
self->light_level++;
if (self->light_level > max)
self->light_level = max;
//GREGG gi.sound(self, CHAN_ITEM, gi.soundindex("misc/w_pkup.wav"), 1, ATTN_NORM, 0);
}
}*/
//Play sound if we are ready
/*
--self->turretsoundcountdown;
if (self->turretsoundcountdown<=0)
{
//Play a sound
if (self->count == 1)
gi.sound(self, CHAN_VOICE, gi.soundindex("medic/medsrch1.wav"), 1, ATTN_NORM, 0);
else if (self->count == 2)
gi.sound(self, CHAN_VOICE, gi.soundindex("floater/fltatck2.wav"), 1, ATTN_NORM, 0);
else if (self->count == 3)
gi.sound(self, CHAN_VOICE, gi.soundindex("tank/tnkatck4.wav"), 1, ATTN_NORM, 0);
self->turretsoundcountdown = 110; //same as 11 seconds
}
*/
// if (self->turretsoundcountdown == 40)//back to ambient sound
// self->s.sound = gi.soundindex ("world/amb3.wav");
if (self->count == 1)
{
range = 500;
light_level = 10;
max_dist = 300;
}
else if (self->count == 2)
{
range = 800;
light_level = 7;
max_dist = 500;
}
else if (self->count == 3)
{
range = 900;
light_level = 4;
max_dist = 700;
}
// Don't shoot frozen, dead, or non visible enemies
if ((self->enemy) &&
((self->enemy->health <= 0) || (!visible(self, self->enemy)) || (self->enemy->frozen)))
{
self->enemy = NULL;
}
if (!self->enemy)
{
// If we are going back to idle from some other status,
// copy the angles back to original
/*
if (self->delay != StatusIdle)
{
VectorCopy (self->orig_angles , self->s.angles);
self->sentrydelay =level.time+1;
}
*/
self->delay=StatusIdle;
while (blip = findradius (blip, self->s.origin, range))
{
if (!blip->inuse)
continue;
if (!(blip->svflags & SVF_MONSTER) && !blip->client)
{
//allow it to shoot decoys
if (strcmp(blip->classname, "decoy") )
continue; //not a decoy
}
if (strcmp(blip->classname, "hook") == 0 )
continue; //not a grapple
if (blip->solid == SOLID_NOT)
continue; //don't see observers
if (blip->health <= 0)
continue;
if (blip->frozen)
continue;
// if (blip == self->creator) //wont work for anarchy mode
// continue;
if (blip->disguised)
continue;
if ((blip->wf_team == self->wf_team) && (((int)wfflags->value & WF_ALLOW_FRIENDLY_FIRE)==0))
// if (blip->wf_team == self->wf_team)
continue;
// if (blip->light_level < light_level)
// continue;
tr = gi.trace (self->s.origin, NULL, NULL, blip->s.origin, self, MASK_SOLID);
if (tr.fraction != 1.0)
continue;
//Check the angle.
/* VectorSubtract (blip->s.origin, self->s.origin, v);
self->ideal_yaw = vectoyaw(v);
checkyaw = anglemod(self->s.angles[YAW]) - self->ideal_yaw;
if (checkyaw < -25 || checkyaw > 25)
continue;
VectorSubtract (self->s.origin, blip->s.origin, v);
*/
dist = VectorLength(v);
if (!visible(self, blip) && dist > max_dist)
continue;
self->enemy = blip;
}
}
else
{
VectorSubtract (self->enemy->s.origin, self->s.origin, v);
self->ideal_yaw = vectoyaw(v);
M_ChangeYaw(self);
checkyaw = anglemod(self->s.angles[YAW])-self->ideal_yaw;
if (checkyaw>-25 && checkyaw<25)
{
if (self->light_level>0)
{
if (visible(self, self->enemy))
{
if (self->s.frame != 1)
{
if (self->delay==StatusIdle)
self->delay = StatusStart;
if (self->count == 1)
{
if(self->s.frame == 3)
FireTurretRight(self);
if( (self->s.frame == 1) || (self->s.frame ==5) )
FireTurretLeft(self);
}
else if (self->count == 2)
{
FireTurretCenter(self);
}
else if (self->count == 3)
{
//Maybe this will reduce lag
// FireTurretRight(self);
// FireTurretLeft(self);
FireTurretCenter(self);
}
}
}
else
{
self->delay=StatusIdle;
self->enemy=NULL;
}
}
}
else
{
self->delay=StatusIdle;
self->enemy=NULL;
}
}
//Move the stand? (GREGG)
if (self->sentry)
VectorCopy(self->s.origin,self->sentry->s.origin);
// Move the sentry to stay with stand (TeT)
// if (self->sentry)
// VectorCopy(self->sentry->s.origin, self->s.origin);
TurretAnimate(self);
self->nextthink = level.time + 0.1;
if(self->delay==StatusIdle)
{
if(self->sentrydelay<level.time)
{
if(self->PlasmaDelay)
self->PlasmaDelay=0;
else
self->PlasmaDelay=1;
gi.sound(self, CHAN_VOICE, gi.soundindex("misc/comp_up.wav"), 0.1, ATTN_NORM, 0);
self->sentrydelay=level.time + 2;
}
if(self->PlasmaDelay)
self->s.angles[YAW]+=3.5;
else
self->s.angles[YAW]-=3.5;
if(self->s.angles[YAW]<0)
self->s.angles[YAW]+=360;
else if(self->s.angles[YAW]>360)
self->s.angles[YAW]-=360;
}
//if(self->health<self->max_health)
// self->health++;
}
//Ent = turret entity
void turret_self_remove(edict_t *ent)
{
//Clear client's pointer to sentry gun
if (ent->creator)
ent->creator->sentry = NULL;
//first free stand
if (ent->sentry) G_FreeEdict(ent->sentry);
//Then free the sentry gun
BecomeExplosion1 (ent);
// G_FreeEdict(ent);
}
//Ent = Player entity
void turret_remove(edict_t *ent)
{
if (ent->sentry)
{ //42 ebc
safe_cprintf(ent, PRINT_HIGH, "Sentry Gun off.\n");
//First free the stand
if (ent->sentry->sentry)
{
G_FreeEdict(ent->sentry->sentry);
ent->sentry->sentry = NULL;
}
//Then free the sentry gun
BecomeExplosion1 (ent->sentry);
// G_FreeEdict(ent->sentry);
ent->sentry = NULL;
if (ent->client->oldplayer)
G_FreeEdict(ent->client->oldplayer);
return;
}
}
void turret_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
{
vec3_t origin;
char *name1;
char *name2;
//42 sebc
edict_t *blip = NULL;
int i;
//42 bot sentry clear itemnode owner
if (self->creator->bot_client)
for (i=1, blip=g_edicts+i ; i < globals.num_edicts ; i++,blip++)
{
if (blip->owner == self->creator)
{
if (!strcmp(blip->classname, "item_sentryspot") )
{
blip->owner = NULL;
}
}
}
//42 end clear item owner
safe_cprintf(self->creator, PRINT_HIGH, "Sentry Gun Destroyed.\n");
//Give a frag to the attacker
if (attacker->client && attacker->wf_team != self->wf_team)
{
PlayerChangeScore(attacker,CTF_SENTRY_POINTS);
name1 = attacker->client->pers.netname;
if (self->creator->client)
name2 = self->creator->client->pers.netname;
else
name2 = "unknown player";
my_bprintf(PRINT_HIGH, "%s destroyed %s's sentry gun.\n", name1, name2);
}
VectorCopy (self->s.origin,origin);
origin[2]+= 0.5;
self->takedamage = DAMAGE_NO;
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_EXPLOSION1);
gi.WritePosition (origin);
gi.multicast (origin, MULTICAST_PVS);
turret_self_remove(self);
}
void SentryReload(edict_t *ent, pmenu_t *p)
{
int max, armorfill;
float dist;
vec3_t distance;
if (!ent->selectedsentry)
return;
distance[0]=ent->s.origin[0] - ent->selectedsentry->s.origin[0];
distance[1]=ent->s.origin[1] - ent->selectedsentry->s.origin[1];
distance[2]=ent->s.origin[2] - ent->selectedsentry->s.origin[2];
dist=VectorLength(distance);
if(dist>100)
{
safe_cprintf(ent, PRINT_HIGH, "Sentry too far away.\n");
PMenu_Close(ent);
return;
}
if (ent->selectedsentry->light_level!=ent->selectedsentry->gib_health)
{
max = ent->selectedsentry->gib_health;
armorfill=ent->selectedsentry->gib_health-ent->selectedsentry->light_level;
if(armorfill>75)
armorfill=75;
// if(armorfill>25)
// armorfill=25;
if (ent->client->pers.inventory[ITEM_INDEX(FindItem("Bullets"))] < 25)
{
safe_cprintf(ent, PRINT_HIGH, "You need 25 Bullets to reload the sentry gun.\n");
if (ent->selectedsentry) gi.sound(ent->selectedsentry, CHAN_VOICE, gi.soundindex("misc/keytry.wav"), 1, ATTN_NORM, 0);
PMenu_Close(ent);
return;
}
//25 player bullets will give 75 bullets to sentry gun (Gregg)
// if(armorfill > ent->client->pers.inventory[ITEM_INDEX(FindItem("Bullets"))])
// armorfill = ent->client->pers.inventory[ITEM_INDEX(FindItem("Bullets"))];
UpdateSentryAmmo(ent->selectedsentry, armorfill);
// ent->selectedsentry->light_level += armorfill;
ent->client->pers.inventory[ITEM_INDEX(FindItem("Bullets"))] -= 25;
if (ent->selectedsentry->light_level > max)
ent->selectedsentry->light_level = max;
gi.sound(ent->selectedsentry, CHAN_ITEM, gi.soundindex("misc/w_pkup.wav"), 1, ATTN_NORM, 0);
}
PMenu_Close(ent);
}
void AddArmorToSentry(edict_t *ent, int amt)
{
int max, armor;
if (ent->health < ent->max_health)
{
max = ent->max_health;
//How much armor is needed?
armor = ent->max_health - ent->health;
if (amt < armor)
armor = amt;
else
armor = 0;
ent->health+= armor;
if (ent->health > max)
ent->health = max;
if (ent->selectedsentry)
gi.sound(ent->selectedsentry, CHAN_ITEM, gi.soundindex("misc/w_pkup.wav"), 1, ATTN_NORM, 0);
}
}
void SentryRepair(edict_t *ent, pmenu_t *p)
{
int max, armor;
int cells, maxcells, currcells;
float dist;
vec3_t distance;
if (!ent->selectedsentry)
return;
distance[0]=ent->s.origin[0] - ent->selectedsentry->s.origin[0];
distance[1]=ent->s.origin[1] - ent->selectedsentry->s.origin[1];
distance[2]=ent->s.origin[2] - ent->selectedsentry->s.origin[2];
dist=VectorLength(distance);
if(dist>100)
{
safe_cprintf(ent, PRINT_HIGH, "Sentry too far away.\n");
PMenu_Close(ent);
return;
}
if (ent->selectedsentry->health<ent->selectedsentry->max_health)
{
max = ent->selectedsentry->max_health;
//How much armor is needed?
armor = ent->selectedsentry->max_health - ent->selectedsentry->health;
//Can't give more than 100 points armor in one shot
if(armor > 100) armor=100;
//Each cell gives 4 points armor
currcells = ent->client->pers.inventory[ITEM_INDEX(FindItem("Cells"))];
maxcells = armor / 4;
if (currcells ==0)
{
safe_cprintf(ent, PRINT_HIGH, "You need Cells to repair the sentry gun.\n");
if (ent->selectedsentry) gi.sound(ent->selectedsentry, CHAN_VOICE, gi.soundindex("misc/keytry.wav"), 1, ATTN_NORM, 0);
PMenu_Close(ent);
return;
}
//If we don't have enough cells, adjust the amount of armor to give
if(currcells < maxcells)
{
cells = currcells;
armor = cells * 4;
}
else
{
cells = maxcells;
}
ent->selectedsentry->health+= armor;
ent->client->pers.inventory[ITEM_INDEX(FindItem("Cells"))] -= cells;
if (ent->selectedsentry->health > max)
ent->selectedsentry->health = max;
gi.sound(ent->selectedsentry, CHAN_ITEM, gi.soundindex("misc/w_pkup.wav"), 1, ATTN_NORM, 0);
}
PMenu_Close(ent);
}
void SentryUpgrade(edict_t *ent, pmenu_t *p)
{
float dist;
vec3_t distance;
if (!ent->selectedsentry)
return;
distance[0]=ent->s.origin[0] - ent->selectedsentry->s.origin[0];
distance[1]=ent->s.origin[1] - ent->selectedsentry->s.origin[1];
distance[2]=ent->s.origin[2] - ent->selectedsentry->s.origin[2];
dist=VectorLength(distance);
if(dist>100)
{
safe_cprintf(ent, PRINT_HIGH, "Sentry too far away.\n");
PMenu_Close(ent);
return;
}
if (ent->selectedsentry->count == 3)
{
safe_cprintf(ent, PRINT_HIGH, "Sentry gun already at level 3\n");
return;
}
if (ent->client->pers.inventory[ITEM_INDEX(FindItem("Cells"))] < 60)
{
safe_cprintf(ent, PRINT_HIGH, "You need 60 cells to upgrade sentry gun.\n");
PMenu_Close(ent);
return;
}
if (ent->selectedsentry->count < 3)
ent->selectedsentry->count++;
ent->client->pers.inventory[ITEM_INDEX(FindItem("Cells"))] -= 60;
if (ent->selectedsentry->count == 2)
{
ent->selectedsentry->health= 200;
ent->selectedsentry->max_health =200;
ent->selectedsentry -> s.modelindex = gi.modelindex ("models/sentry/turret2/tris.md2");
ent->selectedsentry->delay = StatusIdle;
ent->selectedsentry->s.frame = 0;
ent->selectedsentry->yaw_speed = 40;
ent->selectedsentry->gib_health = 150;//Max Ammo
ent->selectedsentry->light_level = 150;
//ent->selectedsentry->turretsoundcountdown = 0;
gi.sound(ent->selectedsentry, CHAN_VOICE, gi.soundindex("misc/pc_up.wav"), 1, ATTN_NORM, 0);
}
if (ent->selectedsentry->count == 3)
{
ent->selectedsentry->health= 300;
ent->selectedsentry->max_health = 300;
ent->selectedsentry -> s.modelindex = gi.modelindex ("models/sentry/turret3/tris.md2");
ent->selectedsentry->delay = StatusIdle;
ent->selectedsentry->s.frame = 0;
ent->selectedsentry->yaw_speed = 45;
ent->selectedsentry->gib_health = 225;//Max Ammo
ent->selectedsentry->light_level = 225;
//ent->selectedsentry->turretsoundcountdown = 0;
gi.sound(ent->selectedsentry, CHAN_VOICE, gi.soundindex("misc/pc_up.wav"), 1, ATTN_NORM, 0);
}
PMenu_Close(ent);
}
void Sentry_Touch (edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *surf)
{
if (other->client) other->selectedsentry = ent;
//Skip if they already have a menu up
if ((other->client) && (other->client->menu))
return;
if(other->sentrydelay>level.time)
return;
//Only show menu a max of every 1 second
//Only allow team mates access to menu
if (!other->bot_client)//42
if (other->client && (other->wf_team == ent->wf_team) && (other->client->player_special & SPECIAL_SENTRY_GUN))
{
PMenu_Close(other);
sprintf(other->client->wfsentrystr[0], "*%s's Sentry", ent->standowner->client->pers.netname);
sprintf(other->client->wfsentrystr[1], " Armor:%d/%d", ent->health, ent->max_health);
sprintf(other->client->wfsentrystr[2], " Ammo:%d/%d", ent->light_level,ent->gib_health);
sprintf(other->client->wfsentrystr[3], " Level:%d", ent->count);
other->client->sentrymenu[0].text = other->client->wfsentrystr[0];
other->client->sentrymenu[0].SelectFunc = NULL;
other->client->sentrymenu[0].align = PMENU_ALIGN_CENTER;
other->client->sentrymenu[0].arg = 0;
other->client->sentrymenu[1].text = other->client->wfsentrystr[1];
other->client->sentrymenu[1].SelectFunc = NULL;
other->client->sentrymenu[1].align = PMENU_ALIGN_LEFT;
other->client->sentrymenu[1].arg = 0;
other->client->sentrymenu[2].text = other->client->wfsentrystr[2];
other->client->sentrymenu[2].SelectFunc = NULL;
other->client->sentrymenu[2].align = PMENU_ALIGN_LEFT;
other->client->sentrymenu[2].arg = 0;
other->client->sentrymenu[3].text = other->client->wfsentrystr[3];
other->client->sentrymenu[3].SelectFunc = NULL;
other->client->sentrymenu[3].align = PMENU_ALIGN_LEFT;
other->client->sentrymenu[3].arg = 0;
other->client->sentrymenu[4].text = "1. Upgrade";
other->client->sentrymenu[4].SelectFunc = SentryUpgrade;
other->client->sentrymenu[4].align = PMENU_ALIGN_LEFT;
other->client->sentrymenu[4].arg = 0;
other->client->sentrymenu[5].text = "2. Repair";
other->client->sentrymenu[5].SelectFunc = SentryRepair;
other->client->sentrymenu[5].align = PMENU_ALIGN_LEFT;
other->client->sentrymenu[5].arg = 0;
other->client->sentrymenu[6].text = "3. Reload";
other->client->sentrymenu[6].SelectFunc = SentryReload;
other->client->sentrymenu[6].align = PMENU_ALIGN_LEFT;
other->client->sentrymenu[6].arg = 0;
// other->selectedsentry = ent->standowner->sentry;
other->selectedsentry = ent;
PMenu_Open(other, other->client->sentrymenu, -1, sizeof(other->client->sentrymenu) / sizeof(pmenu_t), true, false);
other->sentrydelay = level.time + 3;
//Set timeout for menu (4 seconds)
if (other->client->menu) other->client->menu->MenuTimeout = level.time + 4;
}
}
//Stand think function
void Stand_Think (edict_t *ent)
{
//For some reason, entity needs a think function
if (ent->health <= 0)
G_FreeEdict(ent);
else
ent->nextthink = level.time + 5.0;
}
//Build the turret
void place_turret (edict_t *ent)
{
vec3_t forward,up,right,wallp, pos,try1,try2,try3,try4;
edict_t *blip = NULL;
int cells;
trace_t tr;
edict_t *sentrystand;
int armor;
int armorindex;
// valid ent ?
if ((!ent->client) || (ent->health<=0))
return;
if (ent->sentry)
{
turret_remove(ent);
if (ent->client->oldplayer)
G_FreeEdict(ent->client->oldplayer);
return;
}
// cells for sentry gun ?
if ((int)wfflags->value & WF_ANARCHY)
{
armor = 150;
armorindex = ArmorIndex (ent);
if (ent->client->pers.inventory[armorindex] < armor)
{
safe_cprintf(ent, PRINT_HIGH, "You need %d points of armor to create sentry gun.\n", armor);
return;
}
}
else
{
cells = 50;
if (ent->client->pers.inventory[ITEM_INDEX(FindItem("Cells"))] < cells)
{
safe_cprintf(ent, PRINT_HIGH, "You need %d cells to create sentry gun.\n", cells);
return;
}
}
// Setup "little look" to close wall
VectorCopy(ent->s.origin,wallp);
// Cast along view angle
AngleVectors (ent->client->v_angle, forward, right, up);
// Setup end point
pos[0]=ent->s.origin[0]+forward[0]*75;
pos[1]=ent->s.origin[1]+forward[1]*75;
pos[2]=ent->s.origin[2]+forward[2]*75+30;
wallp[0]=ent->s.origin[0]+forward[0]*150;
wallp[1]=ent->s.origin[1]+forward[1]*150;
wallp[2]=ent->s.origin[2]+forward[2]*150+30;
try1[0]=ent->s.origin[0]+forward[0]*150+right[0]*20;
try1[1]=ent->s.origin[1]+forward[1]*150+right[1]*20;
try1[2]=ent->s.origin[2]+forward[2]*150+30+right[2]*20;
try2[0]=ent->s.origin[0]+forward[0]*150+right[0]*-20;
try2[1]=ent->s.origin[1]+forward[1]*150+right[1]*-20;
try2[2]=ent->s.origin[2]+forward[2]*150+30+right[2]*-20;
try3[0]=ent->s.origin[0]+forward[0]*75+right[0]*20;
try3[1]=ent->s.origin[1]+forward[1]*75+right[1]*20;
try3[2]=ent->s.origin[2]+forward[2]*75+30+right[2]*20;
try4[0]=ent->s.origin[0]+forward[0]*75+right[0]*-20;
try4[1]=ent->s.origin[1]+forward[1]*75+right[1]*-20;
try4[2]=ent->s.origin[2]+forward[2]*75+30+right[2]*-20;
// trace
tr = gi.trace (ent->s.origin, NULL, NULL, wallp, ent, MASK_SOLID);
// Line complete ? (ie. no collision)
if (tr.fraction != 1.0)
{//42 ebc
safe_cprintf (ent, PRINT_HIGH, "Not enough room.\n");
return;
}
wallp[2]+=22;
tr = gi.trace (pos, NULL, NULL, wallp, ent, MASK_SOLID);
// Line complete ? (ie. no collision)
if (tr.fraction != 1.0)
{
safe_cprintf (ent, PRINT_HIGH, "Not enough room. Try aiming lower\n");
return;
}
wallp[2]-=40;
tr = gi.trace (pos, NULL, NULL, wallp, ent, MASK_SOLID);
// Line complete ? (ie. no collision)
if (tr.fraction != 1.0)
{
safe_cprintf (ent, PRINT_HIGH, "Not enough room. Try aiming higher\n");
return;
}
// trace
tr = gi.trace (ent->s.origin, NULL, NULL, try1, ent, MASK_SOLID);
if (tr.fraction != 1.0)
{
safe_cprintf (ent, PRINT_HIGH, "Not enough room.\n");
return;
}
// trace
tr = gi.trace (ent->s.origin, NULL, NULL, try2, ent, MASK_SOLID);
if (tr.fraction != 1.0)
{
safe_cprintf (ent, PRINT_HIGH, "Not enough room.\n");
return;
}
// trace
tr = gi.trace (ent->s.origin, NULL, NULL, try3, ent, MASK_SOLID);
if (tr.fraction != 1.0)
{
safe_cprintf (ent, PRINT_HIGH, "Not enough room.\n");
return;
}
// trace
tr = gi.trace (ent->s.origin, NULL, NULL, try4, ent, MASK_SOLID);
if (tr.fraction != 1.0)
{
safe_cprintf (ent, PRINT_HIGH, "Not enough room.\n");
return;
}
// Hit sky ?
if ((tr.surface) && (tr.surface->flags & SURF_SKY))
return;
while (blip = findradius (blip, pos, 50))
{
if ( (!strcmp(blip->classname, "item_flag_team1") )
|| (!strcmp(blip->classname, "item_flag_team2") )
|| (!strcmp(blip->classname, "worldspawn") )
|| (!strcmp(blip->classname, "info_player_start") )
|| (!strcmp(blip->classname, "info_player_deathmatch") )
|| (!strcmp(blip->classname, "item_flagreturn_team1") )
|| (!strcmp(blip->classname, "item_flagreturn_team2") )
|| (!strcmp(blip->classname, "misc_teleporter_dest") )
|| (!strcmp(blip->classname, "info_teleport_destination") ) )
{
safe_cprintf (ent, PRINT_HIGH, "Too Close to Items.\n");
return ;
}
}
if ((int)wfflags->value & WF_ANARCHY)
{
ent->client->pers.inventory[armorindex] -= armor;
}
else
{
ent->client->pers.inventory[ITEM_INDEX(FindItem("Cells"))] -= cells;
}
safe_cprintf(ent, PRINT_HIGH, "Sentry Gun on.\n");
ent->sentry = G_Spawn();
//ent->sentry->s.sound = gi.soundindex ("world/amb3.wav");
//ent->sentry->turretsoundcountdown = 0;
VectorClear (ent->sentry->mins);
VectorClear (ent->sentry->maxs);
VectorCopy (pos, ent->sentry->s.origin);
ent->sentry ->s.angles[0]=0;
// ent->sentry -> movetype = MOVETYPE_STEP;
// ent->sentry -> clipmask = MASK_SHOT;
ent->sentry -> movetype = MOVETYPE_TOSS;
ent->sentry -> clipmask = MASK_PLAYERSOLID;
ent->sentry->mass = 400;
ent->s.renderfx=RF_FRAMELERP|RF_TRANSLUCENT|RF_GLOW;
//grenade -> solid = SOLID_NOT;
ent->sentry->solid = SOLID_BBOX;
//GR - reduce size of bounding box since I reduced size of model
// VectorSet(ent->sentry->mins, -95,-44,-80);
// VectorSet(ent->sentry->maxs, 57, 41, 24);
VectorSet(ent->sentry->mins, -50,-20,-40);
VectorSet(ent->sentry->maxs, 30, 21, 22);
ent->sentry->takedamage=DAMAGE_YES;
ent->sentry -> s.modelindex = gi.modelindex ("models/sentry/turret1/tris.md2");
ent->sentry -> creator = ent;
ent->sentry ->sentrydelay =level.time + 1;
ent->sentry->standowner=ent;
ent->sentry->think = Turret_Think;
// ent->sentry->nextthink = level.time + 0.1;
ent->sentry->nextthink = level.time + 2.0;
ent->sentry->touch = Sentry_Touch;
ent->sentry->die = turret_die;
ent->sentry->health= 80;
ent->sentry->max_health = 100;
ent->sentry->count = 1;
ent->sentry->s.sound = gi.soundindex ("weapons/rg_hum.wav");
//ent->sentry->noise_index2 = gi.soundindex ("weapons/rg_hum.wav");
ent->sentry->attenuation =1;
ent->sentry->volume = 0.5;
ent->sentry->classname = "SentryGun";
ent->sentry->noteamdamage = true; //Don't let teammates damage it
ent->sentry->yaw_speed = 35;
ent->sentry->gib_health = 75;//Max Ammo
ent->sentry->light_level = 75;//Ammo Total
ent->sentry->delay=StatusIdle;
if ((int)wfflags->value & WF_ANARCHY)
{
ent->sentry->wf_team = 0; //fire at anybody
ent->sentry->count = 3;
ent->sentry->health= 300;
ent->sentry->max_health = 300;
ent->sentry -> s.modelindex = gi.modelindex ("models/sentry/turret3/tris.md2");
ent->sentry->s.frame = 0;
ent->sentry->yaw_speed = 45;
ent->sentry->gib_health = 225;//Max Ammo
ent->sentry->light_level = 225;
gi.sound(ent->sentry, CHAN_VOICE, gi.soundindex("misc/pc_up.wav"), 1, ATTN_NORM, 0);
}
else
ent->sentry->wf_team = ent->wf_team;
gi.linkentity (ent->sentry);
if (wfdebug)
{
ent->sentry->s.modelindex2 = gi.modelindex ("models/stand/tris.md2");
ent->sentry->sentry = NULL;
}
else
{
sentrystand = G_Spawn();
VectorClear (sentrystand->mins);
VectorClear (sentrystand->maxs);
VectorCopy (pos,sentrystand->s.origin);
sentrystand->s.angles[0]=0;
sentrystand->movetype = MOVETYPE_TOSS;
sentrystand->mass = 400;
//grenade -> solid = SOLID_NOT;
sentrystand->solid = SOLID_NOT;
VectorSet(sentrystand->mins, -45,-15,-40);
VectorSet(sentrystand->maxs, 25, 18, 18);
botDebugPrint("mins: %s\n", vtos(sentrystand->mins));
botDebugPrint("mins: %s\n", vtos(ent->sentry->s.origin));
botDebugPrint("mins: %s\n", vtos(sentrystand->s.origin));
botDebugPrint("mins: %s\n", vtos(ent->sentry->s.angles));
botDebugPrint("mins: %s\n", vtos(sentrystand->s.angles));
sentrystand->takedamage=DAMAGE_NO;
sentrystand->health = 10;
sentrystand->s.modelindex = gi.modelindex ("models/stand/tris.md2");
sentrystand->classname = "SentryStand";
sentrystand->creator = ent->sentry;
sentrystand->standowner = ent;
sentrystand->wf_team = ent->wf_team;
// sentrystand->touch = Sentry_Touch;//Touching it will then pop up a menu
sentrystand->noteamdamage = true; //Don't let teammates damage it
sentrystand->think = Stand_Think;
sentrystand->nextthink = level.time + 0.5;
gi.linkentity (sentrystand);
ent->sentry->sentry = sentrystand;
}
}
void UpgradeSentry(edict_t *self)
{
edict_t *blip;
trace_t tr;
qboolean found;
blip = NULL;
found = false;
// while (blip = findradius (blip, self->s.origin, 2048))
while (blip = findradius (blip, self->s.origin, 128))
{
if (Q_stricmp("SentryGun", blip->classname))
continue;
if (!self->bot_client)
if (self->client->pers.inventory[ITEM_INDEX(FindItem("Cells"))] < 60)
{//42 ebc
safe_cprintf(self, PRINT_HIGH, "You need 60 cells to upgrade sentry gun.\n");
return;
}
found = true;
tr = gi.trace (self->s.origin, NULL, NULL, blip->s.origin, self, MASK_SOLID);
if (tr.fraction != 1.0)
continue;
if (blip->creator != self)
continue;
if (blip->count == 3)//42 sbc
safe_cprintf(self, PRINT_HIGH, "Sentry gun already at level 3\n");
if (blip->count < 3)
blip->count++;
if(!self->bot_client)//42
self->client->pers.inventory[ITEM_INDEX(FindItem("Cells"))] -= 60;
if (blip->count == 2)
{
blip->health= 200;
blip->max_health =200;
blip -> s.modelindex = gi.modelindex ("models/sentry/turret2/tris.md2");
blip->delay = StatusIdle;
blip->s.frame = 0;
blip->yaw_speed = 40;
blip->gib_health = 150;//Max Ammo
blip->light_level = 150;//5/99 suggest removing this whole section and rework/use sentryupdate()
//blip->turretsoundcountdown = 110;
gi.sound(self, CHAN_VOICE, gi.soundindex("misc/pc_up.wav"), 1, ATTN_NORM, 0);
}
if (blip->count == 3)
{
blip->health= 300;
blip->max_health =300;
blip -> s.modelindex = gi.modelindex ("models/sentry/turret3/tris.md2");
blip->delay = StatusIdle;
blip->s.frame = 0;
blip->yaw_speed = 45;
blip->gib_health = 225;//Max Ammo
blip->light_level = 225;//5/99 suggest removing this whole section and rework/use sentryupdate()
//blip->turretsoundcountdown = 110;
gi.sound(self, CHAN_VOICE, gi.soundindex("misc/pc_up.wav"), 1, ATTN_NORM, 0);
}
}
if (found == false)//42 sbc
safe_cprintf(self, PRINT_HIGH, "Sorry, you aren't close enough.\n");
}
//test_Sentry() - see if there is a sentry close enough to work on
//Returns 0 if sentry does not exist or is too far away
//Returns 1 if sentry exists and is close enough
int test_Sentry (edict_t *ent)
{
float dist;
float tdist;
edict_t *sentry;
vec3_t distance;
edict_t *blip;
if (!ent->sentry)
{
safe_cprintf(ent, PRINT_HIGH, "Sentry not found.\n");
return 0;
}
blip = NULL;
dist = 0;
sentry = NULL;
while (blip = findradius (blip, ent->s.origin, 100))
{
if (strcmp(blip->classname, "SentryGun"))
continue; //Not a sentry gun
distance[0]=ent->s.origin[0] - blip->s.origin[0];
distance[1]=ent->s.origin[1] - blip->s.origin[1];
distance[2]=ent->s.origin[2] - blip->s.origin[2];
tdist=VectorLength(distance);
if ((dist == 0) || (tdist < dist))
{
dist = tdist;
sentry = blip;
}
}
if(dist>100 || sentry == NULL)
{
safe_cprintf(ent, PRINT_HIGH, "Sentry too far away.\n");
return 0;
}
else
{
ent->selectedsentry = sentry;
return 1;
}
}
void cmd_Sentry (edict_t *ent)
{
char *string;
string=gi.args();
if (!ent->client) return;
//argument = "build", "remove", "upgrade", "repair" and "reload"
if (Q_stricmp ( string, "build") == 0)
{
if (!ent->sentry)
place_turret(ent);
else
safe_cprintf(ent, PRINT_HIGH, "Sentry already exists.\n");
}
else if (Q_stricmp ( string, "remove") == 0)
{
if (ent->sentry)
turret_remove(ent);
else
safe_cprintf(ent, PRINT_HIGH, "Sentry not found.\n");
}
else if (Q_stricmp ( string, "upgrade") == 0)
{
if (test_Sentry(ent)) SentryUpgrade(ent, NULL);
}
else if (Q_stricmp ( string, "repair") == 0)
{
if (test_Sentry(ent)) SentryRepair(ent, NULL);
}
else if (Q_stricmp ( string, "reload") == 0)
{
if (test_Sentry(ent)) SentryReload(ent, NULL);
}
//Otherwise toggle on/off
else if (Q_stricmp ( string, "") == 0)
{
place_turret(ent);
}
else
safe_cprintf(ent, PRINT_HIGH, "Invalid sentry command.\n");
}