コード例 #1
0
ファイル: g_misc.c プロジェクト: AndreyNazarov/q2pro
/*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);
}
コード例 #2
0
ファイル: z_boss.c プロジェクト: ZwS/qudos
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;
}
コード例 #3
0
ファイル: acannon.c プロジェクト: yquake2/zaero
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);
}
コード例 #4
0
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);
}
コード例 #5
0
ファイル: g_weapon.c プロジェクト: AndreyNazarov/openffa
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);
}
コード例 #6
0
ファイル: wickedweapons.c プロジェクト: exhuma/WickedQ2
/* ** 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);
}
コード例 #7
0
ファイル: g_misc.c プロジェクト: AJenbo/Quake-2
/*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);
}
コード例 #8
0
ファイル: wickedweapons.c プロジェクト: exhuma/WickedQ2
/* ** 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);
}
コード例 #9
0
ファイル: m_flyer.c プロジェクト: m-x-d/Mission64-src
//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
	}
}
コード例 #10
0
ファイル: supplystation.c プロジェクト: zardoru/vrxcl
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);
}
コード例 #11
0
ファイル: nova.c プロジェクト: emmamai/vortex-indy
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;
}
コード例 #12
0
ファイル: m_flyer.c プロジェクト: m-x-d/Mission64-src
//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);
}
コード例 #13
0
ファイル: g_weapon.c プロジェクト: axltxl/hecatomb
 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 );
 }
コード例 #14
0
ファイル: g_sphere.c プロジェクト: basecq/q2dos
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);
}
コード例 #15
0
ファイル: g_weapon.c プロジェクト: pmm33/pmm33
/*
=================
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);
}
コード例 #16
0
ファイル: misc.c プロジェクト: angeld29/TF2003-qvm
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 );
}
コード例 #17
0
ファイル: g_target.c プロジェクト: AJenbo/Quake-2
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);
}
コード例 #18
0
ファイル: engineer.c プロジェクト: MrPnut/QHome
//=========================================================================
// 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 ) );
}
コード例 #19
0
ファイル: g_target.c プロジェクト: AJenbo/Quake-2
/*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;
}
コード例 #20
0
ファイル: misc.c プロジェクト: deurk/ktx
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 );
}
コード例 #21
0
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);
}
コード例 #22
0
ファイル: weapons.c プロジェクト: stayoutEE/qwprogs-qvm
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 );
}
コード例 #23
0
ファイル: sentry.c プロジェクト: angeld29/TF2003-qvm
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(  );
}
コード例 #24
0
ファイル: m_flyer.c プロジェクト: Chromozon/Quake2_Giex-G10
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++;
	}
}
コード例 #25
0
ファイル: g_target.c プロジェクト: MonkeyHarris/monkey-mod
/*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;
}
コード例 #26
0
ファイル: engineer.c プロジェクト: MrPnut/QHome
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(  );
}
コード例 #27
0
ファイル: laserstuff.c プロジェクト: zardoru/vrxcl
/*
=====================
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);
}
コード例 #28
0
ファイル: g_weapon.c プロジェクト: AndreyNazarov/openffa
/*
=================
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);
}
コード例 #29
0
ファイル: sentry.c プロジェクト: angeld29/TF2003-qvm
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;
    }
}
コード例 #30
0
ファイル: g_misc.c プロジェクト: AJenbo/Quake-2
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);
}