2015/sin-2015
0
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity
sin-2015/specialfx.cpp
archive 03d62e8675 as released 1999-04-22
1999-04-22 00:00:00 +00:00

1788 lines
40 KiB
C++
Raw Permalink Blame History

// Copyright (C) 1997 by Ritual Entertainment, Inc.
// All rights reserved.
//
// This source is may not be distributed and/or modified without
// expressly written permission by Ritual Entertainment, Inc.
//
// DESCRIPTION:
// Special fx
//
#include "g_local.h"
#include "entity.h"
#include "trigger.h"
#include "explosion.h"
#include "misc.h"
#include "light.h"
#include "specialfx.h"
#include "player.h"
#include "g_utils.h"
#include "surface.h"
/*
================
SpawnBlastDamage
================
*/
void SpawnBlastDamage
(
trace_t *trace,
int damage,
Entity *attacker
)
{
Entity *blastmark;
Vector norm;
assert( trace );
assert( attacker );
if ( !trace )
{
return;
}
if ( !attacker )
{
attacker = world;
}
surfaceManager.DamageSurface( trace, damage, attacker );
//### don't make the blast marks in DM to save on net bandwidth
// if ( trace->ent && trace->ent->entity && trace->ent->entity->flags & FL_BLASTMARK )
if ( !deathmatch->value && trace->ent && trace->ent->entity && trace->ent->entity->flags & FL_BLASTMARK )
{
blastmark = new Entity;
blastmark->setMoveType( MOVETYPE_NONE );
blastmark->setSolidType( SOLID_NOT );
blastmark->setModel( "sprites/blastmark.spr" );
blastmark->setSize( "0 0 0", "0 0 0" );
blastmark->edict->s.scale = G_Random() + 0.7;
norm = trace->plane.normal;
norm.x = -norm.x;
norm.y = -norm.y;
blastmark->angles = norm.toAngles();
blastmark->angles.z = G_Random( 360 );
blastmark->setAngles( blastmark->angles );
blastmark->setOrigin( Vector( trace->endpos ) + ( Vector( trace->plane.normal ) * 0.2 ) );
blastmark->PostEvent( EV_FadeOut, 5 );
}
}
/*
================
Particles
================
*/
void Particles
(
Vector org,
Vector norm,
int count,
int lightstyle,
int flags
)
{
if (count>255) count = 255;
gi.WriteByte( svc_temp_entity );
gi.WriteByte( TE_PARTICLES );
gi.WritePosition( org.vec3() );
gi.WriteDir( norm.vec3() );
gi.WriteByte( lightstyle );
gi.WriteByte( count );
gi.WriteByte( flags );
gi.multicast( org.vec3(), MULTICAST_PVS );
}
/*
================
SpawnBlood
================
*/
void SpawnBlood
(
Vector org,
Vector norm,
int damage
)
{
if (damage > 150) damage = 150;
Particles( org, norm, damage, 121, 0 );
}
/*
================
SpawnSparks
================
*/
void SpawnSparks
(
Vector org,
Vector norm,
int count
)
{
Particles( org, norm, count, 122, PARTICLE_OVERBRIGHT );
}
/*
==============
SpawnPulseBeam
==============
*/
void SpawnBeam
(
Vector start,
Vector end,
int parent_entnum,
int modelindex,
float alpha,
float life,
int flags
)
{
byte sendflags;
sendflags = 0;
if ( alpha != 1.0f )
sendflags |= BM_ALPHA;
if ( life != 30 )
sendflags |= BM_LIFE;
if ( flags )
sendflags |= BM_FLAGS;
gi.WriteByte( svc_temp_entity );
gi.WriteByte( TE_BEAM );
gi.WriteByte( sendflags );
gi.WritePosition( start.vec3() );
gi.WritePosition( end.vec3() );
gi.WriteShort( modelindex );
if ( sendflags & BM_ALPHA )
gi.WriteByte( alpha*255 );
if ( sendflags & BM_FLAGS )
gi.WriteByte( flags );
if ( sendflags & BM_LIFE )
gi.WriteShort( life );
gi.multicast( start.vec3(), MULTICAST_PVS );
}
/*
================
SpawnRocketExplosion
================
*/
void SpawnRocketExplosion
(
Vector org
)
{
gi.WriteByte( svc_temp_entity );
gi.WriteByte( TE_ROCKET_EXPLOSION );
gi.WritePosition( org.vec3() );
gi.multicast( org.vec3(), MULTICAST_PVS );
}
/*
================
SpawnScaledExplosion
================
*/
void SpawnScaledExplosion
(
Vector org,
float scale
)
{
scale *= 64;
if ( scale > 255 )
scale = 255;
else if ( scale < 0 )
return;
gi.WriteByte( svc_temp_entity );
gi.WriteByte( TE_SCALED_EXPLOSION );
gi.WritePosition( org.vec3() );
gi.WriteByte( scale );
gi.multicast( org.vec3(), MULTICAST_PVS );
}
/*
================
SpawnTempDlight
================
*/
void SpawnTempDlight
(
Vector org,
float r,
float g,
float b,
float radius,
float decay,
float life
)
{
gi.WriteByte( svc_temp_entity );
gi.WriteByte( TE_DLIGHT );
gi.WritePosition( org.vec3() );
gi.WriteByte( r*255.0f );
gi.WriteByte( g*255.0f );
gi.WriteByte( b*255.0f );
gi.WriteByte( radius/4 );
gi.WriteByte( decay*255.0f );
gi.WriteByte( life*25.5f );
gi.multicast( org.vec3(), MULTICAST_PVS );
}
/*
===================
SpawnTeleportEffect
===================
*/
void SpawnTeleportEffect
(
Vector org,
int lightstyle
)
{
gi.WriteByte( svc_temp_entity );
gi.WriteByte( TE_TELEPORT_EFFECT );
gi.WritePosition( org.vec3() );
gi.WriteByte( lightstyle );
gi.multicast( org.vec3(), MULTICAST_PVS );
}
/*
================
BurnWall
================
*/
void BurnWall
(
Vector org,
Vector end,
int amount
)
{
gi.WriteByte( svc_temp_entity );
gi.WriteByte( TE_BURNWALL );
gi.WritePosition( org.vec3() );
gi.WritePosition( end.vec3() );
gi.WriteByte( amount );
gi.multicast( org.vec3(), MULTICAST_ALL );
}
/*
================
TempModel
================
*/
void TempModel
(
Entity * parent,
Vector origin,
Vector angles,
const char * modelname,
int anim,
float scale,
float alpha,
int flags,
float life
)
{
byte sendflags;
int modelindex;
sendflags = 0;
// encode sendflags
if (origin[0] || origin[1] || origin[2])
sendflags |= TM_ORIGIN;
if (angles[0] || angles[1] || angles[2])
sendflags |= TM_ANGLES;
if (anim)
sendflags |= TM_ANIM;
if (scale != 1.0f)
sendflags |= TM_SCALE;
if (flags != 0)
sendflags |= TM_FLAGS;
if (life != 0.1f)
sendflags |= TM_LIFE;
if (parent)
sendflags |= TM_OWNER;
if (alpha != 1.0f)
sendflags |= TM_ALPHA;
modelindex = gi.modelindex( modelname );
//
// send the stuff out
//
gi.WriteByte( svc_temp_entity );
gi.WriteByte( TE_TEMPMODEL );
gi.WriteByte( sendflags );
if (sendflags & TM_ORIGIN)
gi.WritePosition( origin.vec3() );
if (sendflags & TM_ANGLES)
gi.WritePosition( angles.vec3() );
if (sendflags & TM_ANIM)
gi.WriteByte( anim );
if (sendflags & TM_SCALE)
gi.WriteShort( scale*256 );
if (sendflags & TM_ALPHA)
gi.WriteByte( alpha*255 );
if (sendflags & TM_FLAGS)
gi.WriteByte( flags );
if (sendflags & TM_OWNER)
gi.WriteShort( parent->entnum );
if (sendflags & TM_LIFE)
gi.WriteShort( life*1000.0f );
gi.WriteShort( modelindex );
if (parent)
{
gi.multicast( parent->worldorigin.vec3(), MULTICAST_ALL );
}
else
{
gi.multicast( origin.vec3(), MULTICAST_ALL );
}
}
/*
================
TesselateModel
================
*/
void TesselateModel
(
Entity * ent,
int min_size,
int max_size,
Vector dir,
float power,
float percentage,
int thickness,
Vector origin,
int type,
int lightstyle
)
{
short sendflags;
sendflags = 0;
if (power > 255) power = 255;
if (power < 0) power = 0;
if (thickness > 255 ) thickness = 255;
if (thickness < 0 ) thickness = 0;
if (percentage < 0) percentage = 0;
if (percentage > 1) percentage = 1;
if (min_size > 255) min_size = 255;
if (min_size < 0) min_size = 0;
if (max_size > 255) max_size = 255;
if (max_size < 0) max_size = 0;
// encode sendflags
if ( origin[0] || origin[1] || origin[2] )
sendflags |= TESS_ORIGIN;
if ( dir[0] || dir[1] || dir[2] )
sendflags |= TESS_DIR;
if ( ent && ent->edict )
sendflags |= TESS_ENTNUM;
if ( min_size != TESS_DEFAULT_MIN_SIZE )
sendflags |= TESS_MINSIZE;
if ( max_size != TESS_DEFAULT_MAX_SIZE )
sendflags |= TESS_MAXSIZE;
if ( power != TESS_DEFAULT_POWER )
sendflags |= TESS_POWER;
if ( percentage != TESS_DEFAULT_PERCENT )
sendflags |= TESS_PERCENT;
if ( thickness != min_size )
sendflags |= TESS_THICK;
if (lightstyle != TESS_DEFAULT_LIGHTSTYLE)
sendflags |= TESS_LIGHTSTYLE;
if (type != TESS_DEFAULT_TYPE)
sendflags |= TESS_TYPE;
//
// send the stuff out
//
gi.WriteByte( svc_temp_entity );
gi.WriteByte( TE_TESSELATE );
gi.WriteShort( sendflags );
if (sendflags & TESS_ORIGIN)
gi.WritePosition( origin.vec3() );
if (sendflags & TESS_DIR)
gi.WriteDir( dir.vec3() );
if (sendflags & TESS_ENTNUM)
gi.WriteShort( ent->entnum );
if (sendflags & TESS_MINSIZE)
gi.WriteByte( min_size );
if (sendflags & TESS_MAXSIZE)
gi.WriteByte( max_size );
if (sendflags & TESS_POWER)
gi.WriteByte( power );
if (sendflags & TESS_PERCENT)
gi.WriteByte( percentage * 255.0f );
if (sendflags & TESS_THICK)
gi.WriteByte( thickness );
if (sendflags & TESS_LIGHTSTYLE)
gi.WriteByte( lightstyle );
if (sendflags & TESS_TYPE)
gi.WriteByte( type );
if (ent)
{
if (gi.IsModel( ent->edict->s.modelindex ))
gi.multicast( ((ent->absmax+ent->absmin)*0.5).vec3(), MULTICAST_PVS );
else
gi.multicast( ent->worldorigin.vec3(), MULTICAST_ALL );
}
else
{
gi.multicast( origin.vec3(), MULTICAST_ALL );
}
}
CLASS_DECLARATION( Entity, Bubble, NULL )
Event EV_Bubble_Think( "think" );
ResponseDef Bubble::Responses[] =
{
{ &EV_Bubble_Think, ( Response )Bubble::Think },
//{ &EV_Touch, ( Response )Bubble::Touch },
{ NULL, NULL }
};
EXPORT_FROM_DLL void Bubble::Touch
(
Event *ev
)
{
edict->s.scale *= 0.8f;
velocity[ 0 ] = G_CRandom( 30 );
velocity[ 1 ] = G_CRandom( 30 );
velocity[ 2 ] = -G_Random( 30 );
}
EXPORT_FROM_DLL void Bubble::Think
(
Event *ev
)
{
velocity[ 0 ] *= 0.8f;
velocity[ 1 ] *= 0.8f;
velocity[ 2 ] += 10;
if ( ( edict->s.scale > 0.2f ) || ( edict->s.scale < 0.02f ) || !waterlevel )
{
PostEvent( EV_Remove, 0 );
return;
}
PostEvent( EV_Bubble_Think, 0.1 );
}
void Bubble::Setup
(
Vector pos
)
{
setSolidType( SOLID_NOT );
setMoveType( MOVETYPE_FLY );
setModel( "sprites/bubble.spr" );
setOrigin( pos );
worldorigin.copyTo( edict->s.old_origin );
mass = 0;
watertype = gi.pointcontents( worldorigin.vec3() );
PostEvent( EV_Bubble_Think, 0.1 );
velocity[ 0 ] = G_CRandom( 30 );
velocity[ 1 ] = G_CRandom( 30 );
velocity[ 2 ] = -G_Random( 30 );
edict->s.scale = 0.05f + G_CRandom( 0.04f );
}
CLASS_DECLARATION( ScriptSlave, FuncBeam, "func_beam" );
Event EV_FuncBeam_Activate( "activate" );
Event EV_FuncBeam_Deactivate( "deactivate" );
Event EV_FuncBeam_Diameter( "diameter" );
Event EV_FuncBeam_Lightstyle( "beamstyle" );
Event EV_FuncBeam_Maxoffset( "maxoffset" );
Event EV_FuncBeam_Minoffset( "minoffset" );
Event EV_FuncBeam_Color( "color" );
Event EV_FuncBeam_SetTarget( "settarget" );
ResponseDef FuncBeam::Responses[] =
{
{ &EV_Activate, ( Response )FuncBeam::Activate },
{ &EV_FuncBeam_Activate, ( Response )FuncBeam::Activate },
{ &EV_FuncBeam_Deactivate, ( Response )FuncBeam::Deactivate },
{ &EV_FuncBeam_Diameter, ( Response )FuncBeam::SetDiameter },
{ &EV_FuncBeam_Lightstyle, ( Response )FuncBeam::SetLightstyle },
{ &EV_FuncBeam_Maxoffset, ( Response )FuncBeam::SetMaxoffset },
{ &EV_FuncBeam_Minoffset, ( Response )FuncBeam::SetMinoffset },
{ &EV_FuncBeam_Color, ( Response )FuncBeam::SetColor },
{ &EV_FuncBeam_SetTarget, ( Response )FuncBeam::SetTarget },
{ NULL, NULL }
};
void FuncBeam::SetColor
(
Event *ev
)
{
Vector color = ev->GetVector( 1 );
edict->s.color_r = color[0];
edict->s.color_g = color[1];
edict->s.color_b = color[2];
}
void FuncBeam::SetMaxoffset
(
Event *ev
)
{
edict->s.frame = ev->GetFloat( 1 );
}
void FuncBeam::SetMinoffset
(
Event *ev
)
{
edict->s.radius = ev->GetFloat( 1 );
}
void FuncBeam::SetDiameter
(
Event *ev
)
{
edict->s.frame = ev->GetFloat( 1 );
}
void FuncBeam::SetLightstyle
(
Event *ev
)
{
edict->s.skinnum = ev->GetInteger( 1 );
}
void FuncBeam::Deactivate
(
Event *ev
)
{
hideModel();
// Cancel all of the events to activate
CancelEventsOfType( EV_FuncBeam_Activate );
CancelEventsOfType( EV_Activate );
}
void FuncBeam::Shoot
(
Vector start,
Vector end,
int radius
)
{
trace_t trace;
Vector dir;
Vector b1=vec_zero, b2=vec_zero;
dir = end - start;
if ( edict->s.effects & EF_BEAMEFFECT )
{
b1 = Vector( -radius, -radius, -radius );
b2 = Vector( radius, radius, radius );
}
trace = G_FullTrace( start, b1, b2, end, radius, this, MASK_SHOT, "FuncBeam::Activate" );
if ( trace.ent->entity && trace.ent->entity->takedamage )
{
if ( trace.intersect.valid )
{
// We hit a valid group so send in location based damage
trace.ent->entity->Damage( this,
this,
damage,
trace.endpos,
dir,
trace.plane.normal,
0,
0,
MOD_BEAM,
trace.intersect.parentgroup,
-1,
trace.intersect.damage_multiplier );
}
else
{
// We didn't hit any groups, so send in generic damage
trace.ent->entity->Damage( this,
this,
damage,
trace.endpos,
dir,
trace.plane.normal,
0,
0,
MOD_BEAM,
-1,
-1,
1 );
}
}
}
void FuncBeam::Activate
(
Event *ev
)
{
Vector forward,endpoint;
trace_t trace;
showModel();
// An entity is targeted
if ( end )
{
VectorCopy( end->origin, edict->s.old_origin );
}
else
{
worldangles.AngleVectors( &forward, NULL, NULL );
endpoint = forward * 8192;
trace = G_Trace( origin, vec_zero, vec_zero, endpoint, this, MASK_SOLID, "FuncBeam::Activate" );
VectorCopy( trace.endpos, edict->s.old_origin );
}
if ( damage )
Shoot( origin, edict->s.old_origin, edict->s.frame );
// If life is set, then post a deactivate message
if ( life > 0 && !EventPending( EV_FuncBeam_Deactivate ) )
{
PostEvent( EV_FuncBeam_Deactivate, life );
return;
}
// Shoot beam and cause damage
PostEvent( EV_Activate, 0.1 );
}
void FuncBeam::SetTarget
(
Event *ev
)
{
const char *target;
int num;
// Set the end position if there is a target set.
target = Target();
if ( target && strlen( target ) )
{
if ( num = G_FindTarget( 0, target ) )
{
end = G_GetEntity( num );
assert( end );
VectorCopy( end->origin.vec3(), edict->s.old_origin );
}
}
}
/*****************************************************************************/
/*SINED func_beam (0 .8 .5) (-8 -8 -8) (8 8 8) START_ON ANIMATE FAST ROLL RANDSTART ELECTRIC RANDALPHA
This creates a beam effect from the origin to the target's origin. If no
target is specified, uses angles and projects beam out from there.
"model" Specifies the model to use as the beam
"overlap" Specifies the amount of overlap each beam link should have. Use this to fill
in the cracks when using electric on beams. (Default is 0)
"minoffset" Amount of electrical variation at the endpoints of beam (Default is 5)
"maxoffset" Amount of electrical variation in the middle of beam (Default is 25)
"color" Vector specifiying the red,green, and blue components. (Default is "1 1 1")
"alpha" Alpha of the beam (Default is 1.0)
"damage" Amount of damage the beam inflicts if beam hits someone (Default is 0)
"angles" Sets the angle of the beam if no target is specified.
"life" Deactivates the beam life seconds after the beam is activated. If not set, beam
will not be deactivated.
"beamstyle" Sets the style for this beam to cycle through. This applies only
to beams without models. sample styles (121 blood, 120 gunsmoke, 123 orangeglow, 124 blueyellow,
125 debris trail, 128 oil, 129 waterspray 130 blue-yellow-blue) See global0.scr for
more style numbers
START_ON - Starts the beam on
ANIMATE - Plays animation of the model
FAST - Plays the animation at 20 frames/sec
ROLL - Rolls the beam
RANDSTART - Starts each segment of the beam's animation on a different frame
ELECTRIC - Applies a random electric efffect to the beam
RANDALPHA - Randomly generate the alpha for the beam
If the model field is not set, then a straight beam will be created using the color
specified. color, minoffset, maxoffset ,ANIMATE, FAST, ROLL, RANDSTART,
ELECTRIC, and RANDALPHA are not applicable if the model is not set.
/*****************************************************************************/
FuncBeam::FuncBeam()
{
Vector color;
const char *target;
trace_t trace;
Vector endpoint, forward;
const char *model=0;
qboolean setangles;
setSolidType( SOLID_NOT );
setOrigin( origin );
end = NULL;
target = Target();
if ( target )
PostEvent( EV_FuncBeam_SetTarget, 0 );
else
// No target specified, so use angles to get direction and do a trace to get endpoint.
{
setangles = ( G_GetSpawnArg( "angle" ) || G_GetSpawnArg( "angles" ) );
if ( setangles )
{
float angle;
angle = G_GetFloatArg( "angle", 0 );
angles = G_GetVectorArg( "angles", Vector( 0, angle, 0 ) );
setAngles( angles );
angles.AngleVectors( &forward, NULL, NULL );
setAngles( angles );
endpoint = forward * 8192;
trace = G_Trace( origin, vec_zero, vec_zero, endpoint, this, MASK_SOLID, "FuncBeam" );
VectorCopy( trace.endpos, edict->s.old_origin );
}
else // Nothing specified. Remove this thing
{
gi.dprintf( "No target or angles set on FuncBeam.\n" );
PostEvent( EV_Remove, 0 );
return;
}
}
// Check for a model and use the beam models if it is set
model = G_GetSpawnArg( "model" );
if ( model && strlen( model ) )
{
setModel( model );
edict->s.effects |= EF_BEAMEFFECT;
edict->s.frame = G_GetFloatArg( "maxoffset", 25 );
edict->s.radius = G_GetFloatArg( "minoffset", 5 );
edict->s.lightofs = G_GetIntArg( "overlap", 0 );
// skinnum will hold the flags
edict->s.skinnum = 0;
if ( spawnflags & 0x0002 )
edict->s.skinnum |= BEAM_AUTO_ANIMATE;
if ( spawnflags & 0x0004 )
edict->s.skinnum |= BEAM_ANIMATE_FAST;
if ( spawnflags & 0x0008 )
edict->s.skinnum |= BEAM_ROLL;
if ( spawnflags & 0x0010 )
edict->s.skinnum |= BEAM_ANIMATE_RANDOM_START;
if ( spawnflags & 0x0020 )
edict->s.skinnum |= BEAM_LIGHTNING_EFFECT;
if ( spawnflags & 0x0040 )
edict->s.skinnum |= BEAM_RANDOM_ALPHA;
}
else // Otherwise do a Quake2 style beam
{
edict->s.renderfx |= RF_BEAM;
edict->s.frame = G_GetIntArg( "diameter", 4 );
edict->s.skinnum = G_GetIntArg( "beamstyle", 255 );;
color = G_GetVectorArg( "color", Vector( 1,1,1 ) );
edict->s.color_r = color.x;
edict->s.color_g = color.y;
edict->s.color_b = color.z;
edict->s.modelindex = 1; // must be non-zero
}
edict->s.alpha = G_GetFloatArg( "alpha", 1 );
damage = G_GetFloatArg( "damage", 0 );
life = G_GetFloatArg( "life", 0 );
if ( spawnflags & 0x0001 ) // Start On
{
PostEvent( EV_Activate, 0 );
}
else
{
hideModel();
}
}
CLASS_DECLARATION( Entity, Beam, NULL );
ResponseDef Beam::Responses[] =
{
{ NULL, NULL }
};
Beam::Beam()
{
hideModel();
edict->s.frame = 0;
edict->s.skinnum = 0;
setMoveType( MOVETYPE_NONE );
setSolidType( SOLID_NOT );
edict->s.renderfx |= RF_BEAM;
edict->s.modelindex = 1; // must be non-zero
}
void Beam::setBeam
(
Vector startpos,
Vector endpos,
int diameter,
float r,
float g,
float b,
float alpha,
float lifespan
)
{
showModel();
if ( lifespan )
{
PostEvent( EV_Remove, lifespan );
}
start = startpos;
end = endpos;
setOrigin( start );
edict->s.old_origin[ 0 ] = end[ 0 ];
edict->s.old_origin[ 1 ] = end[ 1 ];
edict->s.old_origin[ 2 ] = end[ 2 ];
edict->s.frame = diameter;
edict->s.skinnum = 255;
edict->s.color_r = r;
edict->s.color_g = g;
edict->s.color_b = b;
edict->s.alpha = alpha;
link();
}
CLASS_DECLARATION( Entity, Projectile, NULL );
ResponseDef Projectile::Responses[] =
{
{ NULL, NULL }
};
Projectile::Projectile()
{
flags |= FL_FATPROJECTILE;
}
void Projectile::Setup
(
Entity *owner,
Vector pos,
Vector dir
)
{
// This should never be called, but just in case.
assert( 0 );
PostEvent( EV_Remove, 0 );
}
//### return pointer to projectile's owner
Entity *Projectile::Owner(void)
{
return G_GetEntity(owner);
}
//###
/*****************************************************************************/
/*SINED fx_fire (0 .8 .5) (-8 -8 -8) (8 8 8) SINGLE STAR PARALLEL
This creates a fire sprite, it defaults to the cross shape
SINGLE - Only one sprite orientated
STAR - 4 sprites in a star shape
If you want flickering
Set style to the identifier contained in groupname in the surfaces to control.
"on_style" light style to set to when "on" (default is a flicker)
"off_style" light style to set to when "off" (default is "a")
/*****************************************************************************/
#define SINGLE (1<<0)
#define STAR (1<<1)
#define PARALLEL (1<<2)
CLASS_DECLARATION( Light, FireSprite, "fx_fire" )
ResponseDef FireSprite::Responses[] =
{
{ NULL, NULL }
};
FireSprite::FireSprite()
{
if ( on_style == str( "m" ) )
on_style = str( "kkllmmnnmmllkkonnmmkkllonnmmkkllnnoonnmmllkkonnnnmmllkko" );
ProcessEvent( EV_Light_TurnOn );
setMoveType( MOVETYPE_NONE );
setSolidType( SOLID_NOT );
showModel();
edict->svflags &= ~SVF_NOCLIENT;
edict->s.effects |= EF_AUTO_ANIMATE;
if ( spawnflags & SINGLE )
{
setModel( "sprites/fire.spr" );
}
else if ( spawnflags & STAR )
{
setModel( "sprites/fire_star.spr" );
}
else if ( spawnflags & PARALLEL )
{
setModel( "sprites/fire_single.spr" );
}
else
{
setModel( "sprites/fire_cross.spr" );
}
RandomGlobalEntitySound( "snd_fire" );
}
FireSprite::~FireSprite()
{
ProcessEvent( EV_Light_TurnOff );
detach();
//
// spawn an explosion
//
if ( world )
CreateExplosion( worldorigin, 100, edict->s.scale * 0.5f, true, this, this, this );
}
CLASS_DECLARATION( Trigger, Sprite, "fx_sprite" )
Event EV_Sprite_Activate( "activate" );
Event EV_Sprite_Deactivate( "deactivate" );
ResponseDef Sprite::Responses[] =
{
{ &EV_Activate, ( Response )FuncBeam::Activate },
{ &EV_Sprite_Activate, ( Response )FuncBeam::Activate },
{ &EV_Sprite_Deactivate, ( Response )FuncBeam::Deactivate },
{ NULL, NULL }
};
void Sprite::Activate
(
Event *ev
)
{
showModel();
}
void Sprite::Deactivate
(
Event *ev
)
{
hideModel();
}
Sprite::Sprite()
{
str model;
qboolean setangles;
Vector dir;
Vector color;
model = G_GetStringArg( "sprite", "" );
edict->s.frame = G_GetIntArg( "frame", 0 );
edict->s.scale = G_GetFloatArg( "scale", 1.0 );
edict->s.alpha = G_GetFloatArg( "alpha", 1.0 );
color = G_GetVectorArg("color",Vector(1,1,1));
edict->s.color_r = color.x;
edict->s.color_g = color.y;
edict->s.color_b = color.z;
if ( !model.length() )
{
gi.dprintf( "fx_sprite: sprite not defined, removing.\n" );
PostEvent( EV_Remove, 0 );
}
setModel( model.c_str() );
setMoveType( MOVETYPE_NONE );
setSolidType( SOLID_NOT );
showModel();
edict->svflags &= ~SVF_NOCLIENT;
if ( spawnflags & 1 )
edict->s.effects |= EF_AUTO_ANIMATE;
setangles = ( G_GetSpawnArg( "angle" ) || G_GetSpawnArg( "angles" ) );
if ( setangles )
{
float angle;
angle = G_GetFloatArg( "angle", 0 );
setAngles( G_GetVectorArg( "angles", Vector( 0, angle, 0 ) ) );
}
// If trace to surface, apply sprite and remove this.
if ( spawnflags & 2 )
{
Vector dir,end,norm;
trace_t trace;
Entity *splat;
dir = G_GetMovedir();
end = worldorigin + dir * 8192;
trace = G_Trace( worldorigin, vec_zero, vec_zero, end, this, MASK_SOLIDNONFENCE, "Sprite::Sprite" );
if ( HitSky( &trace ) || ( trace.ent->solid != SOLID_BSP ) )
{
PostEvent( EV_Remove, 0 );
return;
}
splat = new Entity;
splat->setMoveType( MOVETYPE_NONE );
splat->setSolidType( SOLID_NOT );
splat->setModel( model.c_str() );
splat->edict->s.frame = edict->s.frame;
splat->edict->s.scale = edict->s.scale;
splat->edict->s.alpha = edict->s.alpha;
splat->edict->s.color_r = edict->s.color_r;
splat->edict->s.color_g = edict->s.color_g;
splat->edict->s.color_b = edict->s.color_b;
if ( spawnflags & 1 )
splat->edict->s.effects |= EF_AUTO_ANIMATE;
norm = trace.plane.normal;
norm.x = -norm.x;
norm.y = -norm.y;
splat->angles = norm.toAngles();
splat->setAngles( splat->angles );
splat->setOrigin( Vector( trace.endpos ) + ( Vector( trace.plane.normal ) * 0.2 ) );
PostEvent( EV_Remove, 0.1f );
}
}
void ChangeMusic
(
const char *current,
const char *fallback,
qboolean force
)
{
int j;
edict_t *other;
if ( current || fallback )
{
for( j = 1; j <= game.maxclients; j++ )
{
other = &g_edicts[ j ];
if ( other->inuse && other->client )
{
Player * client;
client = ( Player * )other->entity;
client->ChangeMusic( current, fallback, force );
}
}
}
}
void ChangeSoundtrack
(
const char * soundtrack
)
{
gi.configstring( CS_SOUNDTRACK, soundtrack );
}
//
//### 2015 specialfx
//
/*
================
SpawnThrowerFlame
================
*/
void SpawnThrowerFlame(Vector org, Vector dest)
{
int i, j;
gi.WriteByte(svc_temp_entity);
gi.WriteByte(TE_FLAMETHROWER);
gi.WritePosition(org.vec3());
if(org == dest)
{
gi.WriteByte(0);
gi.WriteByte(0);
gi.WriteByte(0);
}
else
{
for(i = 0; i < 3; i++)
{
j = (dest[i] - org[i])*0.5 + 128;
if(j > 255)
j = 255;
else if(j < 0)
j = 0;
gi.WriteByte(j);
}
}
gi.multicast(org.vec3(), MULTICAST_PVS);
}
/*
================
SpawnThrowerFlameRow
================
*/
void SpawnThrowerFlameRow(Vector org, Vector dest, Vector org2, Vector dest2)
{
int i, j;
gi.WriteByte(svc_temp_entity);
gi.WriteByte(TE_FLAMETHROWERROW);
gi.WritePosition(org.vec3());
// write out first destination offset
if(org == dest)
{
gi.WriteByte(0);
gi.WriteByte(0);
gi.WriteByte(0);
}
else
{
for(i = 0; i < 3; i++)
{
j = (dest[i] - org[i])*0.5 + 128;
if(j > 255)
j = 255;
else if(j < 0)
j = 0;
gi.WriteByte(j);
}
}
// write out second start position offset
if(org2 == org)
{
gi.WriteByte(0);
gi.WriteByte(0);
gi.WriteByte(0);
}
else
{
for(i = 0; i < 3; i++)
{
j = (org2[i] - org[i])*0.5 + 128;
if(j > 255)
j = 255;
else if(j < 0)
j = 0;
gi.WriteByte(j);
}
}
// write out second destination offset
if(dest2 == org2)
{
gi.WriteByte(0);
gi.WriteByte(0);
gi.WriteByte(0);
}
else
{
for(i = 0; i < 3; i++)
{
j = (dest2[i] - org2[i])*0.5 + 128;
if(j > 255)
j = 255;
else if(j < 0)
j = 0;
gi.WriteByte(j);
}
}
gi.multicast(org.vec3(), MULTICAST_PVS);
}
/*
================
SpawnThrowerFlameHit
================
*/
void SpawnThrowerFlameHit(Vector org, Vector dir)
{
gi.WriteByte(svc_temp_entity);
gi.WriteByte(TE_FLAMETHROWERHIT);
gi.WritePosition(org.vec3());
gi.WriteDir(dir.vec3());
gi.multicast(org.vec3(), MULTICAST_PVS);
}
/*
================
SpawnFlame
================
*/
void SpawnFlame(Vector org, Vector dira, Vector dest, Vector dirb, int count, int style, int size)
{
Vector direction;
int speed;
int i, j;
gi.WriteByte(svc_temp_entity);
gi.WriteByte(TE_FLAME);
gi.WritePosition(org.vec3());
if(org == dest)
{
gi.WriteByte(128);
gi.WriteByte(128);
gi.WriteByte(128);
}
else
{
for(i = 0; i < 3; i++)
{
j = (dest[i] - org[i])*0.5 + 128;
if(j > 255)
j = 255;
else if(j < 0)
j = 0;
gi.WriteByte(j);
}
}
direction = dira;
speed = direction.normalize2()*0.5;
if(speed > 255)
speed = 255;
gi.WriteDir(direction.vec3());
gi.WriteByte(speed);
direction = dirb;
speed = direction.normalize2()*0.5;
if(speed > 255)
speed = 255;
gi.WriteDir(direction.vec3());
gi.WriteByte(speed);
gi.WriteByte(style);
if(count > 255)
count = 255;
gi.WriteByte(count);
if(size > 255)
size = 255;
gi.WriteByte(size);
gi.multicast(org.vec3(), MULTICAST_PVS);
}
/*
================
SpawnHoverBoost
================
*/
void SpawnHoverBoost(Vector org, int yaw)
{
if(yaw < 0)
yaw += 360;
if(yaw > 360)
yaw -= 360;
yaw /= 2;
gi.WriteByte(svc_temp_entity);
gi.WriteByte(TE_HOVERBOOSTER);
gi.WritePosition(org.vec3());
gi.WriteByte(yaw);
gi.multicast(org.vec3(), MULTICAST_PVS);
}
/*
================
SpawnNukeExplosion
================
*/
void SpawnNukeExplosion(Vector org, int size, int lightstyle)
{
if(size < 0)
size = 0;
if(size > 2040)
size = 2040;
size *= 0.125;
gi.WriteByte(svc_temp_entity);
gi.WriteByte(TE_NUKE_EXPLOSION);
gi.WritePosition(org.vec3());
gi.WriteByte(size);
gi.WriteByte(lightstyle);
gi.multicast(org.vec3(), MULTICAST_PVS);
}
/*
================
SpawnBowExplosion
================
*/
void SpawnBowExplosion(Vector org, int size)
{
if(size < 0)
size = 0;
if(size > 2040)
size = 2040;
size *= 0.125;
gi.WriteByte(svc_temp_entity);
gi.WriteByte(TE_BOW_EXPLOSION);
gi.WritePosition(org.vec3());
gi.WriteByte(size);
gi.multicast(org.vec3(), MULTICAST_PVS);
}
/*
================
SizedParticles
================
*/
void SizedParticles
(
Vector org,
Vector norm,
int count,
int lightstyle,
int flags,
int size,
int growrate
)
{
if (count>255) count = 255;
if (size>255) size = 255;
growrate += 128;
if(growrate < 0)
growrate = 0;
else if(growrate > 255)
growrate = 255;
gi.WriteByte( svc_temp_entity );
gi.WriteByte( TE_SIZED_PARTICLES );
gi.WritePosition( org.vec3() );
gi.WriteDir( norm.vec3() );
gi.WriteByte( lightstyle );
gi.WriteByte( count );
gi.WriteByte( flags );
gi.WriteByte( size );
gi.WriteByte( growrate );
gi.multicast( org.vec3(), MULTICAST_PVS );
}
/*
================
FullParticles
================
*/
void FullParticles
(
Vector org,
Vector norm,
int count,
int lightstyle,
int flags,
int size,
int growrate,
int speed,
int spread,
Vector accel
)
{
int i, a;
if (count>255) count = 255;
if (size>255) size = 255;
growrate += 128;
if(growrate < 0)
growrate = 0;
else if(growrate > 255)
growrate = 255;
speed *= 0.5;
if(speed < 0)
speed = 0;
else if(speed > 255)
speed = 255;
spread *= 0.5;
if(spread < 0)
spread = 0;
else if(spread > 255)
spread = 255;
gi.WriteByte( svc_temp_entity );
gi.WriteByte( TE_PARTICLES_FULL );
gi.WritePosition( org.vec3() );
gi.WriteDir( norm.vec3() );
gi.WriteByte( lightstyle );
gi.WriteByte( count );
gi.WriteByte( flags );
gi.WriteByte( size );
gi.WriteByte( growrate );
gi.WriteByte( speed );
gi.WriteByte( spread );
for(i = 0; i < 3; i++)
{
a = accel[i] + 128;
if(a < 0)
a = 0;
else if(a > 255)
a = 255;
gi.WriteByte( a );
}
gi.multicast( org.vec3(), MULTICAST_PVS );
}
CLASS_DECLARATION( Trigger, FireHurtField, "trigger_firehurtfield" );
ResponseDef FireHurtField::Responses[] =
{
{ &EV_Activate, ( Response )FireHurtField::SetHurt },
{ &EV_Trigger_Effect, ( Response )FireHurtField::Hurt },
{ NULL, NULL }
};
FireHurtField::FireHurtField()
{
damage = 1;
fireon = true;
respondto = TRIGGER_PLAYERS | TRIGGER_MONSTERS;
}
void FireHurtField::SetHurt (Event *ev)
{
int i;
if(ev->NumArgs() == 1)
{
i = ev->GetInteger(1);
if(i)
fireon = true;
else
fireon = false;
}
else
{
if(fireon)
fireon = false;
else
fireon = true;
}
}
void FireHurtField::Hurt (Event *ev)
{
Entity *other;
if(!fireon)
{
return;
}
// check that parent is still there
if(parentfire && !parentfire->edict->inuse)
{
PostEvent(EV_Remove, 0);
return;
}
other = ev->GetEntity( 1 );
if((damage != 0) && !other->deadflag && !(other->flags & FL_GODMODE))
{
other->Damage( this, other, damage, other->origin, vec_zero, vec_zero, 0, DAMAGE_NO_ARMOR|DAMAGE_NO_KNOCKBACK, MOD_FLAMETHROWER, -1, -1, 1.0f );
}
}
void FireHurtField::Setup(Vector minpos, Vector maxpos, int firedamage)
{
Vector newpos, newmin, newmax;
newpos = (minpos + maxpos) * 0.5;
newmin = minpos - newpos;
newmax = maxpos - newpos;
setOrigin(newpos);
setSize(newmin, newmax);
damage = firedamage;
}
/*****************************************************************************/
/*SINED func_fire (0 0.5 0) (-4 -4 -4) (4 4 4) START_OFF NO_SOUND
Makes a triggerable particle flame. These flames do not cause any damage.
They can be positioned as a single spot of fire, or a row of fire.
START_OFF starts the flame entity in the off state
NO_DAMAGE makes it not create a damage field around it
count = specifies the density of the flame. Default is 1.
lightstyle = the lightstyle type of the flame. Valid values are from 150 to 159. Default is 151.
offset = a vector offset that flame are made to. Example: If you specified '64 0 0', then
flames would be made between the entity's origin and the point 64 away on the X-axis, resulting
in a solid row of flames. Default is '0 0 0'.
size = the size of the flame particles to make. Default is 20;
startdir = the velocity that the begining flames are given.Example: the default of '0 0 32' would give the flames
a velocity of 32 straight up.
enddir = the velocity that the ending flames are given.Example: the default '0 0 32' would give the flames
a velocity of 324 straight up.
rate = the time delay between each time the flame is updated. Default is 0.2
randomrate = the amount of random time delay there is for the flame updating. Default is 0;
damage = amount of damage the hurt field should do. default is 1
/*****************************************************************************/
CLASS_DECLARATION(TriggerPlaySound, FuncFire, "func_fire");
Event EV_Flame_Animate("flame_animate");
ResponseDef FuncFire::Responses[] =
{
{&EV_Activate, (Response)FuncFire::ToggleFlame},
{&EV_Flame_Animate, (Response)FuncFire::Animate},
{NULL, NULL}
};
void FuncFire::ToggleFlame(Event *ev)
{
if(flaming)
{
flaming = 0;
CancelEventsOfType(EV_Flame_Animate);
}
else
{
flaming = 1;
ProcessEvent(EV_Flame_Animate);
}
// put hurt field into proper state
if(hurtfield)
{
Event *e;
e = new Event(EV_Activate);
e->AddInteger(flaming);
hurtfield->ProcessEvent(e);
}
}
void FuncFire::Animate(Event *ev)
{
float timer;
SpawnFlame(origin, flamevela, flameend, flamevelb, flamecount, flametype, flamesize);
if(flamerandom)
timer = flamedelay + floor(G_Random(flamerandom))*0.1;
else
timer = flamedelay;
PostEvent(EV_Flame_Animate, timer);
}
FuncFire::FuncFire()
{
// don't hang around in multiplayer
if(deathmatch->value)
{
PostEvent(EV_Remove, 0);
return;
}
setOrigin(origin);
setSolidType(SOLID_NOT);
setMoveType(MOVETYPE_NONE);
hideModel();
flamecount = G_GetIntArg("count", 1);
flameend = G_GetVectorArg("offset", vec_zero);
flameend += worldorigin;
flamevela = G_GetVectorArg("startdir", Vector(0, 0, 32));
flamevelb = G_GetVectorArg("enddir", Vector(0, 0, 32));
flamedelay = G_GetFloatArg("rate", 0.2);
if(flamedelay <= 0)
flamedelay = 0.1;
flamerandom = (G_GetFloatArg("randomrate", 0)*10);
if(flamerandom)
flamerandom += 1;
flametype = G_GetIntArg("lightstyle", 151);
flamesize = G_GetIntArg("size", 20);
if(flamesize < 1)
flamesize = 1;
flamedamage = G_GetIntArg("damage", 1);
if(flamedamage > 0)
{
Vector hurtmins, hurtmaxs, tmpvec;
// set hurt field size
hurtmins = worldorigin + Vector(-1, -1, -1);
hurtmaxs = worldorigin + Vector(1, 1, 1);
tmpvec = worldorigin + Vector(flamesize, flamesize, flamesize)*0.5;
AddPointToBounds(tmpvec.vec3(), hurtmins.vec3(), hurtmaxs.vec3());
tmpvec = worldorigin - Vector(flamesize, flamesize, flamesize)*0.5;
AddPointToBounds(tmpvec.vec3(), hurtmins.vec3(), hurtmaxs.vec3());
tmpvec = flameend + Vector(flamesize, flamesize, flamesize)*0.5;
AddPointToBounds(tmpvec.vec3(), hurtmins.vec3(), hurtmaxs.vec3());
tmpvec = flameend - Vector(flamesize, flamesize, flamesize)*0.5;
AddPointToBounds(tmpvec.vec3(), hurtmins.vec3(), hurtmaxs.vec3());
// spawn hurt field
hurtfield = new FireHurtField;
hurtfield->Setup(hurtmins, hurtmaxs, flamedamage);
}
if(spawnflags & 1)
{
flaming = 0;
}
else
{
flaming = 1;
PostEvent(EV_Flame_Animate, 0.3);
}
// put hurt field into proper state
if(hurtfield)
{
Event *e;
e = new Event(EV_Activate);
e->AddInteger(flaming);
hurtfield->ProcessEvent(e);
}
}
void SpawnCrawlerSpitDamage (trace_t *trace, int damage, Entity *attacker)
{
Entity *blastmark;
Vector norm;
assert( trace );
assert( attacker );
if ( !trace )
{
return;
}
if ( !attacker )
{
attacker = world;
}
surfaceManager.DamageSurface( trace, damage, attacker );
if ( trace->ent && trace->ent->entity && trace->ent->entity->flags & FL_BLASTMARK )
{
blastmark = new Entity;
blastmark->setMoveType( MOVETYPE_NONE );
blastmark->setSolidType( SOLID_NOT );
blastmark->setModel( "sprites/crawlerspitmark.spr" );
blastmark->setSize( "0 0 0", "0 0 0" );
blastmark->edict->s.scale = G_Random(0.5) + 0.5;
norm = trace->plane.normal;
norm.x = -norm.x;
norm.y = -norm.y;
blastmark->angles = norm.toAngles();
blastmark->angles.z = G_Random( 360 );
blastmark->setAngles( blastmark->angles );
blastmark->setOrigin( Vector( trace->endpos ) + ( Vector( trace->plane.normal ) * 0.2 ) );
blastmark->PostEvent( EV_FadeOut, 5 );
}
}
Reference in a new issue View git blame Copy permalink