/*QUAKED func_explosive (0 .5 .8) ? Trigger_Spawn ANIMATED ANIMATED_FAST
Any brush that you want to explode or break apart. If you want an
ex0plosion, set dmg and it will do a radius explosion of that amount
at the center of the bursh.
If targeted it will not be shootable.
health defaults to 100.
mass defaults to 75. This determines how much debris is emitted when
it explodes. You get one large chunk per 100 of mass (up to 8) and
one small chunk per 25 of mass (up to 16). So 800 gives the most.
*/
void func_explosive_explode(edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
{
vec3_t origin;
vec3_t chunkorigin;
vec3_t size;
int count;
int mass;
// bmodel origins are (0 0 0), we need to adjust that here
VectorScale(self->size, 0.5f, size);
VectorAdd(self->absmin, size, origin);
VectorCopy(origin, self->s.origin);
self->takedamage = DAMAGE_NO;
if (self->dmg)
T_RadiusDamage(self, attacker, self->dmg, NULL, self->dmg + 40, MOD_EXPLOSIVE);
VectorSubtract(self->s.origin, inflictor->s.origin, self->velocity);
VectorNormalize(self->velocity);
VectorScale(self->velocity, 150, self->velocity);
// start chunks towards the center
VectorScale(size, 0.5f, size);
mass = self->mass;
if (!mass)
mass = 75;
// big chunks
if (mass >= 100) {
count = mass / 100;
if (count > 8)
count = 8;
while (count--) {
chunkorigin[0] = origin[0] + crandom() * size[0];
chunkorigin[1] = origin[1] + crandom() * size[1];
chunkorigin[2] = origin[2] + crandom() * size[2];
ThrowDebris(self, "models/objects/debris1/tris.md2", 1, chunkorigin);
}
}
// small chunks
count = mass / 25;
if (count > 16)
count = 16;
while (count--) {
chunkorigin[0] = origin[0] + crandom() * size[0];
chunkorigin[1] = origin[1] + crandom() * size[1];
chunkorigin[2] = origin[2] + crandom() * size[2];
ThrowDebris(self, "models/objects/debris2/tris.md2", 2, chunkorigin);
}
G_UseTargets(self, attacker);
if (self->dmg)
BecomeExplosion1(self);
else
G_FreeEdict(self);
}
void Plasmaball_Explode (edict_t *ent)
{
//FIXME: if we are onground then raise our Z just a bit since we are a point?
if (ent->enemy)
{
float points;
vec3_t v;
vec3_t dir;
VectorAdd (ent->enemy->mins, ent->enemy->maxs, v);
VectorMA (ent->enemy->s.origin, 0.5, v, v);
VectorSubtract (ent->s.origin, v, v);
points = ent->dmg - 0.5 * VectorLength (v);
VectorSubtract (ent->enemy->s.origin, ent->s.origin, dir);
T_Damage (ent->enemy, ent, ent->owner, dir, ent->s.origin, vec3_origin, (int)points, (int)points, DAMAGE_RADIUS, MOD_UNKNOWN);
}
T_RadiusDamage(ent, ent->owner, ent->dmg, ent->enemy, ent->dmg_radius, MOD_UNKNOWN);
VectorMA (ent->s.origin, -0.02, ent->velocity, ent->s.origin);
VectorClear(ent->velocity);
ent->movetype = MOVETYPE_NONE;
ent->s.modelindex = gi.modelindex("models/objects/b_explode/tris.md2");
ent->s.effects &= ~EF_BFG & ~EF_ANIM_ALLFAST;
ent->s.frame = 0;
ent->s.skinnum = 6;
// ent->s.renderfx = RF_TRANSLUCENT | RF_FULLBRIGHT;
// ent->s.renderfx = RF_TRANSLUCENT;
gi.sound (ent, CHAN_AUTO, sound_plamsaballexplode, 1, ATTN_NORM, 0);
ent->think = PlasmaballBlastAnim;
ent->nextthink = level.time + FRAMETIME;
}
void monster_autocannon_explode (edict_t *ent)
{
vec3_t origin;
T_RadiusDamage(ent, ent, AC_EXPLODE_DMG, ent->enemy, AC_EXPLODE_RADIUS, MOD_TRIPBOMB);
VectorMA (ent->s.origin, -0.02, ent->velocity, origin);
gi.WriteByte (svc_temp_entity);
if (ent->waterlevel)
{
if (ent->groundentity)
gi.WriteByte (TE_GRENADE_EXPLOSION_WATER);
else
gi.WriteByte (TE_ROCKET_EXPLOSION_WATER);
}
else
{
if (ent->groundentity)
gi.WriteByte (TE_GRENADE_EXPLOSION);
else
gi.WriteByte (TE_ROCKET_EXPLOSION);
}
gi.WritePosition (origin);
gi.multicast (ent->s.origin, MULTICAST_PHS);
// set the pain skin
ent->chain->chain->s.skinnum = 1; // pain
ent->chain->chain->rideWith[0] = NULL;
ent->chain->chain->rideWith[1] = NULL;
G_FreeEdict(ent->chain);
G_FreeEdict(ent);
}
void plasma_touch (edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *surf)
{
vec3_t origin;
if (other == ent->owner)
return;
if (surf && (surf->flags & SURF_SKY))
{
G_FreeEdict (ent);
return;
}
if (ent->owner->client)
PlayerNoise(ent->owner, ent->s.origin, PNOISE_IMPACT);
// calculate position for the explosion entity
VectorMA (ent->s.origin, -0.02, ent->velocity, origin);
if (other->takedamage)
{
T_Damage (other, ent, ent->owner, ent->velocity, ent->s.origin, plane->normal, ent->dmg, 0, 0, MOD_PHALANX);
}
T_RadiusDamage(ent, ent->owner, ent->radius_dmg, other, ent->dmg_radius, MOD_PHALANX);
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_PLASMA_EXPLOSION);
gi.WritePosition (origin);
gi.multicast (ent->s.origin, MULTICAST_PVS);
G_FreeEdict (ent);
}
void bfg_touch(edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
if (other == self->owner)
return;
if (surf && (surf->flags & SURF_SKY)) {
G_FreeEdict(self);
return;
}
// core explosion - prevents firing it into the wall/floor
if (other->takedamage)
T_Damage(other, self, self->owner, self->velocity, self->s.origin, plane->normal, 200, 0, 0, MOD_BFG_BLAST);
T_RadiusDamage(self, self->owner, 200, other, 100, MOD_BFG_BLAST);
gi.sound(self, CHAN_VOICE, gi.soundindex("weapons/bfg__x1b.wav"), 1, ATTN_NORM, 0);
self->solid = SOLID_NOT;
self->touch = NULL;
VectorMA(self->s.origin, -1 * FRAMETIME, self->velocity, self->s.origin);
VectorClear(self->velocity);
self->s.modelindex = gi.modelindex("sprites/s_bfg3.sp2");
self->s.frame = 0;
self->s.sound = 0;
self->s.effects &= ~EF_ANIM_ALLFAST;
NEXT_KEYFRAME(self, bfg_explode);
self->enemy = other;
gi.WriteByte(svc_temp_entity);
gi.WriteByte(TE_BFG_BIGEXPLOSION);
gi.WritePosition(self->s.origin);
gi.multicast(self->s.origin, MULTICAST_PVS);
}
/* ** wicked ** fire_pipebomb declaration*
=================
fire_pipebomb
=================
*/
void Pipe_Think (edict_t *ent)
{
vec3_t origin;
int mod;
if (ent->owner->client)
PlayerNoise(ent->owner, ent->s.origin, PNOISE_IMPACT);
//FIXME: if we are onground then raise our Z just a bit since we are a point?
if (ent->enemy)
{
float points;
vec3_t v;
vec3_t dir;
VectorAdd (ent->enemy->mins, ent->enemy->maxs, v);
VectorMA (ent->enemy->s.origin, 0.5, v, v);
VectorSubtract (ent->s.origin, v, v);
points = ent->dmg - 0.5 * VectorLength (v);
VectorSubtract (ent->enemy->s.origin, ent->s.origin, dir);
if (ent->spawnflags & 1)
mod = MOD_HANDGRENADE;
else
mod = MOD_GRENADE;
T_Damage (ent->enemy, ent, ent->owner, dir, ent->s.origin, vec3_origin, (int)points, (int)points, DAMAGE_RADIUS, mod);
}
if (ent->spawnflags & 2)
mod = MOD_HELD_GRENADE;
else if (ent->spawnflags & 1)
mod = MOD_HG_SPLASH;
else
mod = MOD_PIPE_SPLASH;
T_RadiusDamage(ent, ent->owner, ent->dmg, ent->enemy, ent->dmg_radius, mod);
VectorMA (ent->s.origin, -0.02, ent->velocity, origin);
gi.WriteByte (svc_temp_entity);
if (ent->waterlevel)
{
if (ent->groundentity)
gi.WriteByte (TE_GRENADE_EXPLOSION_WATER);
else
gi.WriteByte (TE_ROCKET_EXPLOSION_WATER);
}
else
{
if (ent->groundentity)
gi.WriteByte (TE_GRENADE_EXPLOSION);
else
gi.WriteByte (TE_ROCKET_EXPLOSION);
}
gi.WritePosition (origin);
gi.multicast (ent->s.origin, MULTICAST_PHS);
G_FreeEdict (ent);
}
/*QUAKED misc_viper_bomb (1 0 0) (-8 -8 -8) (8 8 8)
"dmg" how much boom should the bomb make?
*/
void misc_viper_bomb_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
G_UseTargets (self, self->activator);
self->s.origin[2] = self->absmin[2] + 1;
T_RadiusDamage (self, self, self->dmg, NULL, self->dmg+40, MOD_BOMB);
BecomeExplosion2 (self);
}
/* ** wicked ** Cluster Spread2 *
=================
Cluster Spread2
divide the new cluster into 5 clusters again
=================
*/
void Cluster_Spread2 (edict_t *ent)
{
vec3_t origin;
int mod;
//Sean added these 4 vectors
vec3_t grenade1;
vec3_t grenade2;
vec3_t grenade3;
vec3_t grenade4;
vec3_t grenade5;
mod = MOD_CLUSTER;
if (ent->owner->client)
PlayerNoise(ent->owner, ent->s.origin, PNOISE_IMPACT);
//FIXME: if we are onground then raise our Z just a bit since we are a point?
T_RadiusDamage(ent, ent->owner, ent->dmg, NULL, ent->dmg_radius, mod);
VectorMA (ent->s.origin, -0.02, ent->velocity, origin);
gi.WriteByte (svc_temp_entity);
if (ent->waterlevel)
{
if (ent->groundentity)
gi.WriteByte (TE_GRENADE_EXPLOSION_WATER);
else
gi.WriteByte (TE_ROCKET_EXPLOSION_WATER);
}
else
{
if (ent->groundentity)
gi.WriteByte (TE_GRENADE_EXPLOSION);
else
gi.WriteByte (TE_ROCKET_EXPLOSION);
}
gi.WritePosition (origin);
gi.multicast (ent->s.origin, MULTICAST_PVS);
// SumFuka did this bit : give grenades up/outwards velocities
//VectorSet(grenade1, 10, 20, 0);
VectorSet(grenade1, 30, 0, 30);
VectorSet(grenade2, 0,-30, 30);
VectorSet(grenade3,-30, 0, 30);
VectorSet(grenade4, 0, 30, 30);
VectorSet(grenade5, 0, 0, 30);
// Sean : explode the four grenades outwards
fire_cluster3(ent, origin, grenade1, 80, 8, 1.0, 120);
fire_cluster3(ent, origin, grenade2, 80, 8, 1.0, 120);
fire_cluster3(ent, origin, grenade3, 80, 8, 1.0, 120);
fire_cluster3(ent, origin, grenade4, 80, 8, 1.0, 120);
fire_cluster3(ent, origin, grenade5, 100, 0, 1.0, 150);
G_FreeEdict (ent);
}
//mxd
void fake_flyer_touch(edict_t *self, edict_t *other, cplane_t* p, csurface_t* s)
{
// Ingnore baaad touches and tracers...
if (strcmp(other->classname, "freed") != 0 && strcmp(other->classname, "tracer") != 0)
{
T_RadiusDamage(self, self, 45 + 5 * skill->value, NULL, 128 + 16 * skill->value, MOD_EXPLOSIVE, -2.0 / (4.0 + skill->value));
flyer_spawn_gibs(self, self->dmg); // Removes self, must be called last
}
}
void supplystation_explode (edict_t *self, char *message)
{
if (self->creator && self->creator->inuse)
{
safe_cprintf(self->creator, PRINT_HIGH, message);
self->creator->supplystation = NULL;
T_RadiusDamage(self, self->creator, 150, self, 150, MOD_SUPPLYSTATION);
}
BecomeExplosion1(self);
}
void Cmd_Nova_f (edict_t *ent, int frostLevel, float skill_mult, float cost_mult)
{
int damage, cost=NOVA_COST*cost_mult;
if (!G_CanUseAbilities(ent, ent->myskills.abilities[NOVA].current_level, cost))
return;
if (ent->myskills.abilities[NOVA].disable)
return;
damage = (NOVA_DEFAULT_DAMAGE+NOVA_ADDON_DAMAGE*ent->myskills.abilities[NOVA].current_level)*skill_mult;
T_RadiusDamage(ent, ent, damage, ent, NOVA_RADIUS, MOD_NOVA);
//Talent: Frost Nova
if(frostLevel > 0)
{
edict_t *target = NULL;
while ((target = findradius(target, ent->s.origin, FROSTNOVA_RADIUS)) != NULL)
{
if (target == ent)
continue;
if (!target->takedamage)
continue;
if (!visible1(ent, target))
continue;
//curse with holyfreeze
target->chill_level = 2 * frostLevel;
target->chill_time = level.time + 3.0; //3 second duration
if (random() > 0.5)
gi.sound(target, CHAN_ITEM, gi.soundindex("spells/blue1.wav"), 1, ATTN_NORM, 0);
else
gi.sound(target, CHAN_ITEM, gi.soundindex("spells/blue3.wav"), 1, ATTN_NORM, 0);
}
}
// write a nice effect so everyone knows we've cast a spell
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_TELEPORT_EFFECT);
gi.WritePosition (ent->s.origin);
gi.multicast (ent->s.origin, MULTICAST_PVS);
NovaExplosionEffect(ent->s.origin);
gi.sound (ent, CHAN_WEAPON, gi.soundindex("spells/novaelec.wav"), 1, ATTN_NORM, 0);
ent->client->ability_delay = level.time + NOVA_DELAY/* * cost_mult*/;
ent->client->pers.inventory[power_cube_index] -= cost;
// calling entity made a sound, used to alert monsters
ent->lastsound = level.framenum;
}
//mxd. ROGUE - kamikaze stuff
void flyer_kamikaze_explode(edict_t *self)
{
vec3_t dir;
if (self->enemy)
{
VectorSubtract(self->enemy->s.origin, self->s.origin, dir);
T_RadiusDamage(self, self, 45 + 5 * skill->value, NULL, 128 + 16 * skill->value, MOD_EXPLOSIVE, -2.0 / (4.0 + skill->value)); //mxd. We can explode when stuck, so no direct damage to the target
}
flyer_die(self, NULL, NULL, 0, dir);
}
void
bfg_touch ( edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf )
{
if ( !self || !other ) {
G_FreeEdict ( self );
return;
}
if ( other == self->owner ) {
return;
}
if ( surf && ( surf->flags & SURF_SKY ) ) {
G_FreeEdict ( self );
return;
}
if ( self->owner && self->owner->client ) {
PlayerNoise ( self->owner, self->s.origin, PNOISE_IMPACT );
}
/* core explosion - prevents firing it into the wall/floor */
if ( other->takedamage ) {
if ( plane ) {
T_Damage ( other, self, self->owner, self->velocity, self->s.origin,
plane->normal, 200, 0, 0, MOD_BFG_BLAST );
} else {
T_Damage ( other, self, self->owner, self->velocity, self->s.origin,
vec3_origin, 200, 0, 0, MOD_BFG_BLAST );
}
}
T_RadiusDamage ( self, self->owner, 200, other, 100, MOD_BFG_BLAST );
gi.sound ( self, CHAN_VOICE, gi.soundindex (
"weapons/bfg__x1b.wav" ), 1, ATTN_NORM, 0 );
self->solid = SOLID_NOT;
self->touch = NULL;
VectorMA ( self->s.origin, -1 * FRAMETIME, self->velocity, self->s.origin );
VectorClear ( self->velocity );
self->s.modelindex = gi.modelindex ( "sprites/s_bfg3.sp2" );
self->s.frame = 0;
self->s.sound = 0;
self->s.effects &= ~EF_ANIM_ALLFAST;
self->think = bfg_explode;
self->nextthink = level.time + FRAMETIME;
self->enemy = other;
gi.WriteByte ( svc_temp_entity );
gi.WriteByte ( TE_BFG_BIGEXPLOSION );
gi.WritePosition ( self->s.origin );
gi.multicast ( self->s.origin, MULTICAST_PVS );
}
void
sphere_touch(edict_t *self, edict_t *other, cplane_t *plane,
csurface_t *surf, int mod)
{
if (!self || !other || !plane || !surf)
{
return;
}
if (self->spawnflags & SPHERE_DOPPLEGANGER)
{
if (other == self->teammaster)
{
return;
}
self->takedamage = DAMAGE_NO;
self->owner = self->teammaster;
self->teammaster = NULL;
}
else
{
if (other == self->owner)
{
return;
}
/* Don't blow up on bodies */
if (!strcmp(other->classname, "bodyque"))
{
return;
}
}
if (surf && (surf->flags & SURF_SKY))
{
G_FreeEdict(self);
return;
}
if (other->takedamage)
{
T_Damage(other, self, self->owner, self->velocity, self->s.origin,
plane->normal, 10000, 1, DAMAGE_DESTROY_ARMOR, mod);
}
else
{
T_RadiusDamage(self, self->owner, 512, self->owner, 256, mod);
}
sphere_think_explode(self);
}
/*
=================
fire_rocket
=================
*/
void rocket_touch (edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *surf)
{
vec3_t origin;
int n;
if (other == ent->owner)
return;
if (surf && (surf->flags & SURF_SKY))
{
G_FreeEdict (ent);
return;
}
if (ent->owner->client)
PlayerNoise(ent->owner, ent->s.origin, PNOISE_IMPACT);
// calculate position for the explosion entity
VectorMA (ent->s.origin, -0.02, ent->velocity, origin);
fire_grenade3 (ent, ent->s.origin, ent->s.origin, 150, 0, 2.5, 200);
if (other->takedamage)
{
T_Damage (other, ent, ent->owner, ent->velocity, ent->s.origin, plane->normal, ent->dmg, 0, 0, MOD_ROCKET);
}
else
{
// don't throw any debris in net games
if (!deathmatch->value && !coop->value)
{
if ((surf) && !(surf->flags & (SURF_WARP|SURF_TRANS33|SURF_TRANS66|SURF_FLOWING)))
{
n = rand() % 5;
while(n--)
ThrowDebris (ent, "models/objects/debris2/tris.md2", 2, ent->s.origin);
}
}
}
T_RadiusDamage(ent, ent->owner, ent->radius_dmg, other, ent->dmg_radius, MOD_R_SPLASH);
gi.WriteByte (svc_temp_entity);
if (ent->waterlevel)
gi.WriteByte (TE_ROCKET_EXPLOSION_WATER);
else
gi.WriteByte (TE_ROCKET_EXPLOSION);
gi.WritePosition (origin);
gi.multicast (ent->s.origin, MULTICAST_PHS);
G_FreeEdict (ent);
}
void barrel_explode( )
{
vec3_t v;
self->s.v.takedamage = DAMAGE_NO;
self->s.v.classname = "explo_box";
// did say self.owner
T_RadiusDamage( self, self, 160, world );
VectorCopy( self->s.v.origin, v); v[2] += 32;
TempEffectCoord( v, TE_EXPLOSION );
ent_remove( self );
}
void use_target_splash (edict_t *self, edict_t *other, edict_t *activator)
{
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_SPLASH);
gi.WriteByte (self->count);
gi.WritePosition (self->s.origin);
gi.WriteDir (self->movedir);
gi.WriteByte (self->sounds);
gi.multicast (self->s.origin, MULTICAST_PVS);
if (self->dmg)
T_RadiusDamage (self, activator, self->dmg, NULL, self->dmg+40, MOD_SPLASH);
}
//=========================================================================
// Ammo/Weapon exploded by the EMP grenade
void EMPExplode( )
{
float expsize;
expsize = 10;
if ( self->s.v.touch == ( func_t ) weapon_touch )
expsize = 60;
else
{
if ( streq( self->s.v.classname, "item_shells" ) )
expsize = 50 + self->aflag;
else
{
if ( streq( self->s.v.classname, "item_spikes" ) )
expsize = 40;
else
{
if ( streq( self->s.v.classname, "item_rockets" ) )
expsize = 100 + self->aflag * 4;
else
{
if ( streq( self->s.v.classname, "item_cells" ) )
expsize = 100 + self->aflag * 3;
else
{
if ( streq( self->s.v.classname, "item_weapon" ) )
expsize = 60;
else
{
G_dprintf( "EMPExplode: Attempting to explode a %s\n", self->s.v.classname );
return;
}
}
}
}
}
}
tf_data.deathmsg = DMSG_GREN_EMP_AMMO;
T_RadiusDamage( self, PROG_TO_EDICT( self->s.v.enemy ), expsize, world );
trap_WriteByte( MSG_MULTICAST, SVC_TEMPENTITY );
trap_WriteByte( MSG_MULTICAST, TE_EXPLOSION );
trap_WriteCoord( MSG_MULTICAST, self->s.v.origin[0] );
trap_WriteCoord( MSG_MULTICAST, self->s.v.origin[1] );
trap_WriteCoord( MSG_MULTICAST, self->s.v.origin[2] );
trap_multicast( PASSVEC3( self->s.v.origin ), 1 );
// Respawn
Respawn_Item( self, PROG_TO_EDICT( self->s.v.enemy ) );
}
/*QUAKED target_explosion (1 0 0) (-8 -8 -8) (8 8 8)
Spawns an explosion temporary entity when used.
"delay" wait this long before going off
"dmg" how much radius damage should be done, defaults to 0
*/
void target_explosion_explode (edict_t *self)
{
float save;
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_EXPLOSION1);
gi.WritePosition (self->s.origin);
gi.multicast (self->s.origin, MULTICAST_PHS);
T_RadiusDamage (self, self->activator, self->dmg, NULL, self->dmg+40, MOD_EXPLOSIVE);
save = self->delay;
self->delay = 0;
G_UseTargets (self, self->activator);
self->delay = save;
}
void barrel_explode()
{
self->s.v.takedamage = DAMAGE_NO;
self->classname = "explo_box";
// did say self.owner
T_RadiusDamage(self, self, 160, world, dtEXPLO_BOX);
WriteByte( MSG_MULTICAST, SVC_TEMPENTITY );
WriteByte( MSG_MULTICAST, TE_EXPLOSION );
WriteCoord( MSG_MULTICAST, self->s.v.origin[0] );
WriteCoord( MSG_MULTICAST, self->s.v.origin[1] );
WriteCoord( MSG_MULTICAST, self->s.v.origin[2] + 32 );
trap_multicast( PASSVEC3( self->s.v.origin ), MULTICAST_PHS );
ent_remove( self );
}
void wall_rocket_think(edict_t *ent)
{
vec3_t origin;
VectorMA(ent->s.origin, -0.02, ent->velocity, origin);
T_RadiusDamage(ent, ent->owner, ent->radius_dmg, ent->owner, ent->dmg_radius, MOD_R_SPLASH);
gi.WriteByte(svc_temp_entity);
if (ent->waterlevel)
gi.WriteByte(TE_ROCKET_EXPLOSION_WATER);
else
gi.WriteByte(TE_ROCKET_EXPLOSION);
gi.WritePosition(origin);
gi.multicast(ent->s.origin, MULTICAST_PHS);
G_FreeEdict(ent);
}
void GrenadeExplode()
{
if ( self->voided )
{
return;
}
self->voided = 1;
T_RadiusDamage( self, PROG_TO_EDICT( self->s.v.owner ), 120, world, "grenade" );
trap_WriteByte( MSG_MULTICAST, SVC_TEMPENTITY );
trap_WriteByte( MSG_MULTICAST, TE_EXPLOSION );
trap_WriteCoord( MSG_MULTICAST, self->s.v.origin[0] );
trap_WriteCoord( MSG_MULTICAST, self->s.v.origin[1] );
trap_WriteCoord( MSG_MULTICAST, self->s.v.origin[2] );
trap_multicast( PASSVEC3( self->s.v.origin ), MULTICAST_PHS );
ent_remove( self );
}
void Sentry_Explode( )
{
ThrowGib( "progs/tgib1.mdl", -70 );
ThrowGib( "progs/tgib2.mdl", -70 );
ThrowGib( "progs/tgib3.mdl", -70 );
if ( self->real_owner->has_disconnected != 1 )
{
tf_data.deathmsg = DMSG_SG_EXPLODION;
T_RadiusDamage( self, self->real_owner, 75 + self->s.v.ammo_rockets * 8, self );
}
if ( streq( self->s.v.classname, "building_sentrygun_base" ) )
{
if ( self->oldenemy )
dremove( self->oldenemy );
} else
dremove( self->trigger_field );
TempEffectCoord( self->s.v.origin , TE_EXPLOSION );
BecomeExplosion( );
}
void flyer_detonate(edict_t *self) {
int damage;
if (self->radius_dmg)
damage = (150 + 26 * self->monsterinfo.skill);
else
damage = (75 + 13 * self->monsterinfo.skill);
if (self->radius_dmg && self->monsterinfo.ability & GIEX_MABILITY_DAMAGE) {
damage *= 2;
}
T_RadiusDamage(NULL, self, self, damage, damage * 0.5, self, 120 + 5 * self->monsterinfo.skill, true, MOD_R_SPLASH);
gi.sound (self, CHAN_VOICE, sound_die, 1, ATTN_NORM, 0);
BecomeExplosion1(self);
if (!(self->monsterinfo.aiflags & AI_GOOD_GUY)) {
if (self->monsterinfo.ability & GIEX_MABILITY_STEALTH) {
removeStealth();
}
level.killed_monsters++;
}
}
/*QUAKED target_explosion (1 0 0) (-8 -8 -8) (8 8 8)
Spawns an explosion temporary entity when used.
"delay" wait this long before going off
"dmg" how much radius damage should be done, defaults to 0
"fxdensity" size of explosion 1 - 100 (default is 10)
*/
void target_explosion_explode (edict_t *self)
{
float save;
vec3_t vec;
VectorClear(vec);
vec[2] = 1;
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_EXPLOSION1B);
gi.WritePosition (self->s.origin);
gi.WriteDir( vec );
gi.WriteByte( (int)(self->dmg / 2) );
gi.WriteByte (self->fxdensity);
gi.multicast (self->s.origin, MULTICAST_PVS);
{
edict_t *breakit;
breakit = G_Spawn();
if (breakit)
{
VectorCopy (self->s.origin, breakit->s.origin);
gi.linkentity(breakit);
gi.sound (breakit, CHAN_VOICE, gi.soundindex("world/explosion1.wav"), 1, ATTN_NORM, 0);
breakit->think = G_FreeEdict;
breakit->nextthink = level.time + 5.0;
}
}
T_RadiusDamage (self, self->activator, self->dmg, NULL, self->dmg+40, MOD_EXPLOSIVE);
save = self->delay;
self->delay = 0;
G_UseTargets (self, self->activator);
self->delay = save;
}
void Dispenser_Explode( )
{
float sdmg;
if ( self->real_owner->has_disconnected != 1 )
{
tf_data.deathmsg = DMSG_DISP_EXPLODION;
sdmg = 25 + self->s.v.ammo_rockets * 1.5 + self->s.v.ammo_cells;
if ( sdmg > 250 )
sdmg = 250;
T_RadiusDamage( self, self->real_owner, sdmg, self );
}
ThrowGib( "progs/dgib1.mdl", -30 );
ThrowGib( "progs/dgib2.mdl", -50 );
ThrowGib( "progs/dgib3.mdl", -50 );
trap_WriteByte( MSG_MULTICAST, SVC_TEMPENTITY );
trap_WriteByte( MSG_MULTICAST, TE_EXPLOSION );
trap_WriteCoord( MSG_MULTICAST, self->s.v.origin[0] );
trap_WriteCoord( MSG_MULTICAST, self->s.v.origin[1] );
trap_WriteCoord( MSG_MULTICAST, self->s.v.origin[2] );
trap_multicast( PASSVEC3( self->s.v.origin ), 1 );
BecomeExplosion( );
}
/*
=====================
Laser Defense
=====================
*/
void laser_cleanup(edict_t *self)
{
vec3_t origin;
if (self->owner->client)
PlayerNoise(self->owner, self->s.origin, PNOISE_IMPACT);
T_RadiusDamage(self, self->owner, self->dmg, NULL, self->dmg_radius, MOD_LASER_DEFENSE);
VectorMA (self->s.origin, -0.02, self->velocity, origin);
gi.WriteByte (svc_temp_entity);
if (self->waterlevel)
{
if (self->groundentity)
gi.WriteByte (TE_GRENADE_EXPLOSION_WATER);
else
gi.WriteByte (TE_ROCKET_EXPLOSION_WATER);
}
else
{
if (self->groundentity)
gi.WriteByte (TE_GRENADE_EXPLOSION);
else
gi.WriteByte (TE_ROCKET_EXPLOSION);
}
gi.WritePosition (origin);
gi.multicast (self->s.origin, MULTICAST_PVS);
self->owner->num_lasers--; //GHz: Decrement counter
//Remove laser
if (self->creator)
G_FreeEdict (self->creator);
//Remove grenade
G_FreeEdict (self);
}
/*
=================
fire_rocket
=================
*/
void rocket_touch(edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *surf)
{
vec3_t origin;
if (other == ent->owner)
return;
if (surf && (surf->flags & SURF_SKY)) {
G_FreeEdict(ent);
return;
}
// calculate position for the explosion entity
VectorMA(ent->s.origin, -0.02f, ent->velocity, origin);
G_BeginDamage();
if (other->takedamage) {
T_Damage(other, ent, ent->owner, ent->velocity, ent->s.origin, plane->normal, ent->dmg, 0, 0, MOD_ROCKET);
} else {
// don't throw any debris in net games
}
T_RadiusDamage(ent, ent->owner, ent->radius_dmg, other, ent->dmg_radius, MOD_R_SPLASH);
G_EndDamage();
gi.WriteByte(svc_temp_entity);
if (ent->waterlevel)
gi.WriteByte(TE_ROCKET_EXPLOSION_WATER);
else
gi.WriteByte(TE_ROCKET_EXPLOSION);
gi.WritePosition(origin);
gi.multicast(ent->s.origin, MULTICAST_PHS);
G_FreeEdict(ent);
}
void Sentry_Die( )
{
G_sprint( self->real_owner, 2, "Your sentry gun was destroyed.\n" );
if ( self->has_sentry && tfset(tg_enabled) )
{
self->s.v.health = 0;
setmodel( self, "" );
setmodel( self->trigger_field, "" );
self->s.v.think = ( func_t ) SG_Static;
self->s.v.nextthink = g_globalvars.time + 0.5;
self->s.v.effects = self->s.v.effects - ( (int)self->s.v.effects & 8 );
self->s.v.movetype = MOVETYPE_NONE;
self->s.v.solid = SOLID_NOT;
self->trigger_field->s.v.movetype = MOVETYPE_NONE;
self->trigger_field->s.v.solid = SOLID_NOT;
ThrowGib( "progs/tgib1.mdl", -70 );
ThrowGib( "progs/tgib2.mdl", -70 );
ThrowGib( "progs/tgib3.mdl", -70 );
tf_data.deathmsg = DMSG_SG_EXPLODION;
T_RadiusDamage( self, self->real_owner, 75 + self->s.v.ammo_rockets * 8, self );
TempEffectCoord( self->s.v.origin , TE_EXPLOSION );
} else
{
self->real_owner->has_sentry -= 1;
#ifdef HAS_SENTRY_CHECK
if(!tfset(tg_enabled) && self->real_owner->has_sentry)
{
G_dprintf("Error SentryDie owner->has_sentry !=0 %d\n",self->real_owner->has_sentry);
G_sprint(self->real_owner,2,"Error SentryDie owner->has_sentry !=0 %d\n",self->real_owner->has_sentry);
self->real_owner->has_sentry = 0;
}
#endif
self->s.v.think = ( func_t ) Sentry_Explode;
self->s.v.nextthink = g_globalvars.time + 0.1;
}
}
void barrel_explode (edict_t *self)
{
vec3_t org;
float spd;
vec3_t save;
T_RadiusDamage (self, self->activator, self->dmg, NULL, self->dmg+40, MOD_BARREL);
VectorCopy (self->s.origin, save);
VectorMA (self->absmin, 0.5, self->size, self->s.origin);
// a few big chunks
spd = 1.5 * (float)self->dmg / 200.0;
org[0] = self->s.origin[0] + crandom() * self->size[0];
org[1] = self->s.origin[1] + crandom() * self->size[1];
org[2] = self->s.origin[2] + crandom() * self->size[2];
ThrowDebris (self, "models/objects/debris1/tris.md2", spd, org);
org[0] = self->s.origin[0] + crandom() * self->size[0];
org[1] = self->s.origin[1] + crandom() * self->size[1];
org[2] = self->s.origin[2] + crandom() * self->size[2];
ThrowDebris (self, "models/objects/debris1/tris.md2", spd, org);
// bottom corners
spd = 1.75 * (float)self->dmg / 200.0;
VectorCopy (self->absmin, org);
ThrowDebris (self, "models/objects/debris3/tris.md2", spd, org);
VectorCopy (self->absmin, org);
org[0] += self->size[0];
ThrowDebris (self, "models/objects/debris3/tris.md2", spd, org);
VectorCopy (self->absmin, org);
org[1] += self->size[1];
ThrowDebris (self, "models/objects/debris3/tris.md2", spd, org);
VectorCopy (self->absmin, org);
org[0] += self->size[0];
org[1] += self->size[1];
ThrowDebris (self, "models/objects/debris3/tris.md2", spd, org);
// a bunch of little chunks
spd = 2 * self->dmg / 200;
org[0] = self->s.origin[0] + crandom() * self->size[0];
org[1] = self->s.origin[1] + crandom() * self->size[1];
org[2] = self->s.origin[2] + crandom() * self->size[2];
ThrowDebris (self, "models/objects/debris2/tris.md2", spd, org);
org[0] = self->s.origin[0] + crandom() * self->size[0];
org[1] = self->s.origin[1] + crandom() * self->size[1];
org[2] = self->s.origin[2] + crandom() * self->size[2];
ThrowDebris (self, "models/objects/debris2/tris.md2", spd, org);
org[0] = self->s.origin[0] + crandom() * self->size[0];
org[1] = self->s.origin[1] + crandom() * self->size[1];
org[2] = self->s.origin[2] + crandom() * self->size[2];
ThrowDebris (self, "models/objects/debris2/tris.md2", spd, org);
org[0] = self->s.origin[0] + crandom() * self->size[0];
org[1] = self->s.origin[1] + crandom() * self->size[1];
org[2] = self->s.origin[2] + crandom() * self->size[2];
ThrowDebris (self, "models/objects/debris2/tris.md2", spd, org);
org[0] = self->s.origin[0] + crandom() * self->size[0];
org[1] = self->s.origin[1] + crandom() * self->size[1];
org[2] = self->s.origin[2] + crandom() * self->size[2];
ThrowDebris (self, "models/objects/debris2/tris.md2", spd, org);
org[0] = self->s.origin[0] + crandom() * self->size[0];
org[1] = self->s.origin[1] + crandom() * self->size[1];
org[2] = self->s.origin[2] + crandom() * self->size[2];
ThrowDebris (self, "models/objects/debris2/tris.md2", spd, org);
org[0] = self->s.origin[0] + crandom() * self->size[0];
org[1] = self->s.origin[1] + crandom() * self->size[1];
org[2] = self->s.origin[2] + crandom() * self->size[2];
ThrowDebris (self, "models/objects/debris2/tris.md2", spd, org);
org[0] = self->s.origin[0] + crandom() * self->size[0];
org[1] = self->s.origin[1] + crandom() * self->size[1];
org[2] = self->s.origin[2] + crandom() * self->size[2];
ThrowDebris (self, "models/objects/debris2/tris.md2", spd, org);
VectorCopy (save, self->s.origin);
if (self->groundentity)
BecomeExplosion2 (self);
else
BecomeExplosion1 (self);
}
