blendo/quadrilateralcowboy
0
0
Fork 0
mirror of https://github.com/blendogames/quadrilateralcowboy.git synced 2024-11-10 06:41:36 +00:00
Code Issues Projects Releases Packages Wiki Activity
quadrilateralcowboy/d3xp/Projectile.cpp
brendon 47a1010d23 Initial commit
2020-06-12 14:06:25 -07:00

2965 lines
80 KiB
C++
Raw Blame History

/*
===========================================================================
Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).
Doom 3 Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Doom 3 Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
===========================================================================
*/
#include "../idlib/precompiled.h"
#pragma hdrstop
#include "Game_local.h"
/*
===============================================================================
idProjectile
===============================================================================
*/
static const int BFG_DAMAGE_FREQUENCY = 333;
static const float BOUNCE_SOUND_MIN_VELOCITY = 100.0f;
static const float BOUNCE_SOUND_MAX_VELOCITY = 400.0f;
const idEventDef EV_Explode( "<explode>", NULL );
const idEventDef EV_Fizzle( "<fizzle>", NULL );
const idEventDef EV_RadiusDamage( "<radiusdmg>", "e" );
const idEventDef EV_GetProjectileState( "getProjectileState", NULL, 'd' );
#ifdef _D3XP
const idEventDef EV_CreateProjectile( "projectileCreateProjectile", "evv" );
const idEventDef EV_LaunchProjectile( "projectileLaunchProjectile", "vvv" );
const idEventDef EV_SetGravity( "setGravity", "f" );
#endif
CLASS_DECLARATION( idEntity, idProjectile )
EVENT( EV_Explode, idProjectile::Event_Explode )
EVENT( EV_Fizzle, idProjectile::Event_Fizzle )
EVENT( EV_Touch, idProjectile::Event_Touch )
EVENT( EV_RadiusDamage, idProjectile::Event_RadiusDamage )
EVENT( EV_GetProjectileState, idProjectile::Event_GetProjectileState )
#ifdef _D3XP
EVENT( EV_CreateProjectile, idProjectile::Event_CreateProjectile )
EVENT( EV_LaunchProjectile, idProjectile::Event_LaunchProjectile )
EVENT( EV_SetGravity, idProjectile::Event_SetGravity )
#endif
END_CLASS
/*
================
idProjectile::idProjectile
================
*/
idProjectile::idProjectile( void ) {
owner = NULL;
lightDefHandle = -1;
thrust = 0.0f;
thrust_end = 0;
smokeFly = NULL;
smokeFlyTime = 0;
state = SPAWNED;
lightOffset = vec3_zero;
lightStartTime = 0;
lightEndTime = 0;
lightColor = vec3_zero;
state = SPAWNED;
damagePower = 1.0f;
memset( &projectileFlags, 0, sizeof( projectileFlags ) );
memset( &renderLight, 0, sizeof( renderLight ) );
// note: for net_instanthit projectiles, we will force this back to false at spawn time
fl.networkSync = true;
netSyncPhysics = false;
startOrigin.Zero();
//bc
stickyState = 0;
facing.Zero();
md5model = NULL;
}
/*
================
idProjectile::Spawn
================
*/
void idProjectile::Spawn( void ) {
physicsObj.SetSelf( this );
physicsObj.SetClipModel( new idClipModel( GetPhysics()->GetClipModel() ), 1.0f );
physicsObj.SetContents( 0 );
physicsObj.SetClipMask( 0 );
physicsObj.PutToRest();
SetPhysics( &physicsObj );
md5model = NULL;
if (spawnArgs.GetString("md5model"))
{
idDict args;
args.Clear();
args.SetVector( "origin", this->GetPhysics()->GetOrigin() );
args.Set( "model", spawnArgs.GetString("md5model"));
md5model = ( idAnimatedEntity * )gameLocal.SpawnEntityType( idAnimatedEntity::Type, &args );
md5model->SetAxis( this->GetPhysics()->GetAxis() );
md5model->Bind(this, true);
}
}
/*
================
idProjectile::Save
================
*/
void idProjectile::Save( idSaveGame *savefile ) const {
owner.Save( savefile );
projectileFlags_s flags = projectileFlags;
LittleBitField( &flags, sizeof( flags ) );
savefile->Write( &flags, sizeof( flags ) );
savefile->WriteFloat( thrust );
savefile->WriteInt( thrust_end );
savefile->WriteRenderLight( renderLight );
savefile->WriteInt( (int)lightDefHandle );
savefile->WriteVec3( lightOffset );
savefile->WriteInt( lightStartTime );
savefile->WriteInt( lightEndTime );
savefile->WriteVec3( lightColor );
savefile->WriteParticle( smokeFly );
savefile->WriteInt( smokeFlyTime );
#ifdef _D3XP
savefile->WriteInt( originalTimeGroup );
#endif
savefile->WriteInt( (int)state );
savefile->WriteFloat( damagePower );
savefile->WriteStaticObject( physicsObj );
savefile->WriteStaticObject( thruster );
}
/*
================
idProjectile::Restore
================
*/
void idProjectile::Restore( idRestoreGame *savefile ) {
owner.Restore( savefile );
savefile->Read( &projectileFlags, sizeof( projectileFlags ) );
LittleBitField( &projectileFlags, sizeof( projectileFlags ) );
savefile->ReadFloat( thrust );
savefile->ReadInt( thrust_end );
savefile->ReadRenderLight( renderLight );
savefile->ReadInt( (int &)lightDefHandle );
savefile->ReadVec3( lightOffset );
savefile->ReadInt( lightStartTime );
savefile->ReadInt( lightEndTime );
savefile->ReadVec3( lightColor );
savefile->ReadParticle( smokeFly );
savefile->ReadInt( smokeFlyTime );
#ifdef _D3XP
savefile->ReadInt( originalTimeGroup );
#endif
savefile->ReadInt( (int &)state );
savefile->ReadFloat( damagePower );
savefile->ReadStaticObject( physicsObj );
RestorePhysics( &physicsObj );
savefile->ReadStaticObject( thruster );
thruster.SetPhysics( &physicsObj );
if ( smokeFly != NULL ) {
idVec3 dir;
dir = physicsObj.GetLinearVelocity();
dir.NormalizeFast();
gameLocal.smokeParticles->EmitSmoke( smokeFly, gameLocal.time, gameLocal.random.RandomFloat(), GetPhysics()->GetOrigin(), GetPhysics()->GetAxis(), timeGroup /*_D3XP*/ );
}
#ifdef _D3XP
if ( lightDefHandle >= 0 ) {
lightDefHandle = gameRenderWorld->AddLightDef( &renderLight );
}
#endif
}
/*
================
idProjectile::GetOwner
================
*/
idEntity *idProjectile::GetOwner( void ) const {
return owner.GetEntity();
}
/*
================
idProjectile::Create
================
*/
void idProjectile::Create( idEntity *owner, const idVec3 &start, const idVec3 &dir ) {
idDict args;
idStr shaderName;
idVec3 light_color;
idVec3 light_offset;
idVec3 tmp;
idMat3 axis;
Unbind();
//bc
startOrigin = start;
// align z-axis of model with the direction
axis = dir.ToMat3();
tmp = axis[2];
axis[2] = axis[0];
axis[0] = -tmp;
physicsObj.SetOrigin( start );
physicsObj.SetAxis( axis );
physicsObj.GetClipModel()->SetOwner( owner );
this->owner = owner;
memset( &renderLight, 0, sizeof( renderLight ) );
shaderName = spawnArgs.GetString( "mtr_light_shader" );
if ( *(const char *)shaderName ) {
renderLight.shader = declManager->FindMaterial( shaderName, false );
renderLight.pointLight = true;
renderLight.lightRadius[0] =
renderLight.lightRadius[1] =
renderLight.lightRadius[2] = spawnArgs.GetFloat( "light_radius" );
spawnArgs.GetVector( "light_color", "1 1 1", light_color );
renderLight.shaderParms[0] = light_color[0];
renderLight.shaderParms[1] = light_color[1];
renderLight.shaderParms[2] = light_color[2];
renderLight.shaderParms[3] = 1.0f;
}
spawnArgs.GetVector( "light_offset", "0 0 0", lightOffset );
lightStartTime = 0;
lightEndTime = 0;
smokeFlyTime = 0;
damagePower = 1.0f;
#ifdef _D3XP
if(spawnArgs.GetBool("reset_time_offset", "0")) {
renderEntity.shaderParms[ SHADERPARM_TIMEOFFSET ] = -MS2SEC( gameLocal.time );
}
#endif
UpdateVisuals();
state = CREATED;
if ( spawnArgs.GetBool( "net_fullphysics" ) ) {
netSyncPhysics = true;
}
}
/*
=================
idProjectile::~idProjectile
=================
*/
idProjectile::~idProjectile() {
StopSound( SND_CHANNEL_ANY, false );
FreeLightDef();
}
/*
=================
idProjectile::FreeLightDef
=================
*/
void idProjectile::FreeLightDef( void ) {
if ( lightDefHandle != -1 ) {
gameRenderWorld->FreeLightDef( lightDefHandle );
lightDefHandle = -1;
}
}
/*
=================
idProjectile::Launch
=================
*/
void idProjectile::Launch( const idVec3 &start, const idVec3 &dir, const idVec3 &pushVelocity, const float timeSinceFire, const float launchPower, const float dmgPower ) {
float fuse;
float startthrust;
float endthrust;
idVec3 velocity;
idAngles angular_velocity;
float linear_friction;
float angular_friction;
float contact_friction;
float bounce;
float mass;
float speed;
float gravity;
idVec3 gravVec;
idVec3 tmp;
idMat3 axis;
int thrust_start;
int contents;
int clipMask;
// allow characters to throw projectiles during cinematics, but not the player
if ( owner.GetEntity() && !owner.GetEntity()->IsType( idPlayer::Type ) ) {
cinematic = owner.GetEntity()->cinematic;
} else {
cinematic = false;
}
thrust = spawnArgs.GetFloat( "thrust" );
startthrust = spawnArgs.GetFloat( "thrust_start" );
endthrust = spawnArgs.GetFloat( "thrust_end" );
spawnArgs.GetVector( "velocity", "0 0 0", velocity );
speed = velocity.Length() * launchPower;
damagePower = dmgPower;
spawnArgs.GetAngles( "angular_velocity", "0 0 0", angular_velocity );
linear_friction = spawnArgs.GetFloat( "linear_friction" );
angular_friction = spawnArgs.GetFloat( "angular_friction" );
contact_friction = spawnArgs.GetFloat( "contact_friction" );
bounce = spawnArgs.GetFloat( "bounce" );
mass = spawnArgs.GetFloat( "mass" );
gravity = spawnArgs.GetFloat( "gravity" );
fuse = spawnArgs.GetFloat( "fuse" );
projectileFlags.detonate_on_world = spawnArgs.GetBool( "detonate_on_world" );
projectileFlags.detonate_on_actor = spawnArgs.GetBool( "detonate_on_actor" );
projectileFlags.randomShaderSpin = spawnArgs.GetBool( "random_shader_spin" );
if ( mass <= 0 ) {
gameLocal.Error( "Invalid mass on '%s'\n", GetEntityDefName() );
}
thrust *= mass;
thrust_start = SEC2MS( startthrust ) + gameLocal.time;
thrust_end = SEC2MS( endthrust ) + gameLocal.time;
lightStartTime = 0;
lightEndTime = 0;
if ( health ) {
fl.takedamage = true;
}
gravVec = gameLocal.GetGravity();
gravVec.NormalizeFast();
Unbind();
// align z-axis of model with the direction
axis = dir.ToMat3();
tmp = axis[2];
axis[2] = axis[0];
axis[0] = -tmp;
contents = 0;
clipMask = MASK_SHOT_RENDERMODEL;
if ( spawnArgs.GetBool( "detonate_on_trigger" ) ) {
contents |= CONTENTS_TRIGGER;
}
if ( !spawnArgs.GetBool( "no_contents" ) ) {
contents |= CONTENTS_PROJECTILE;
clipMask |= CONTENTS_PROJECTILE;
}
#ifdef _D3XP
if ( !idStr::Cmp( this->GetEntityDefName(), "projectile_helltime_killer" ) ) {
contents = CONTENTS_MOVEABLECLIP;
clipMask = CONTENTS_MOVEABLECLIP;
}
#endif
// don't do tracers on client, we don't know origin and direction
//if ( spawnArgs.GetBool( "tracers" ) && gameLocal.random.RandomFloat() > 0.5f )
if ( spawnArgs.GetBool( "tracers" ) ) //BC always do tracers.
{
SetModel( spawnArgs.GetString( "model_tracer" ) );
projectileFlags.isTracer = true;
}
physicsObj.SetMass( mass );
physicsObj.SetFriction( linear_friction, angular_friction, contact_friction );
if ( contact_friction == 0.0f ) {
physicsObj.NoContact();
}
physicsObj.SetBouncyness( bounce );
physicsObj.SetGravity( gravVec * gravity );
physicsObj.SetContents( contents );
physicsObj.SetClipMask( clipMask );
physicsObj.SetLinearVelocity( axis[ 2 ] * speed + pushVelocity );
physicsObj.SetAngularVelocity( angular_velocity.ToAngularVelocity() * axis );
physicsObj.SetOrigin( start );
physicsObj.SetAxis( axis );
thruster.SetPosition( &physicsObj, 0, idVec3( GetPhysics()->GetBounds()[ 0 ].x, 0, 0 ) );
if ( !gameLocal.isClient ) {
if ( fuse <= 0 ) {
// run physics for 1 second
RunPhysics();
PostEventMS( &EV_Remove, spawnArgs.GetInt( "remove_time", "1500" ) );
} else if ( spawnArgs.GetBool( "detonate_on_fuse" ) ) {
fuse -= timeSinceFire;
if ( fuse < 0.0f ) {
fuse = 0.0f;
}
PostEventSec( &EV_Explode, fuse );
if (md5model)
{
md5model->PostEventSec( &EV_Remove, fuse );
}
}
else
{
fuse -= timeSinceFire;
if ( fuse < 0.0f ) {
fuse = 0.0f;
}
PostEventSec( &EV_Fizzle, fuse );
}
}
if ( projectileFlags.isTracer ) {
StartSound( "snd_tracer", SND_CHANNEL_BODY, 0, false, NULL );
} else {
StartSound( "snd_fly", SND_CHANNEL_BODY2, 0, false, NULL );
}
smokeFlyTime = 0;
const char *smokeName = spawnArgs.GetString( "smoke_fly" );
if ( *smokeName != '\0' ) {
smokeFly = static_cast<const idDeclParticle *>( declManager->FindType( DECL_PARTICLE, smokeName ) );
smokeFlyTime = gameLocal.time;
}
#ifdef _D3XP
originalTimeGroup = timeGroup;
#endif
// used for the plasma bolts but may have other uses as well
if ( projectileFlags.randomShaderSpin ) {
float f = gameLocal.random.RandomFloat();
f *= 0.5f;
renderEntity.shaderParms[SHADERPARM_DIVERSITY] = f;
}
UpdateVisuals();
state = LAUNCHED;
}
/*
================
idProjectile::Think
================
*/
void idProjectile::Think( void ) {
if ( thinkFlags & TH_THINK ) {
if ( thrust && ( gameLocal.time < thrust_end ) ) {
// evaluate force
thruster.SetForce( GetPhysics()->GetAxis()[ 0 ] * thrust );
thruster.Evaluate( gameLocal.time );
}
}
// run physics
if (stickyState <= 0)
{
RunPhysics();
}
Present();
// add the particles
if ( smokeFly != NULL && smokeFlyTime && !IsHidden() && stickyState <= 0)
{
idVec3 dir = -GetPhysics()->GetLinearVelocity();
dir.Normalize();
#ifdef _D3XP
SetTimeState ts(originalTimeGroup);
#endif
if ( !gameLocal.smokeParticles->EmitSmoke( smokeFly, smokeFlyTime, gameLocal.random.RandomFloat(), GetPhysics()->GetOrigin(), dir.ToMat3(), timeGroup /*_D3XP*/ ) ) {
smokeFlyTime = gameLocal.time;
}
}
// add the light
if ( renderLight.lightRadius.x > 0.0f && g_projectileLights.GetBool() ) {
renderLight.origin = GetPhysics()->GetOrigin() + GetPhysics()->GetAxis() * lightOffset;
renderLight.axis = GetPhysics()->GetAxis();
if ( ( lightDefHandle != -1 ) ) {
if ( lightEndTime > 0 && gameLocal.time <= lightEndTime + gameLocal.GetMSec() ) {
idVec3 color( 0, 0, 0 );
if ( gameLocal.time < lightEndTime ) {
float frac = ( float )( gameLocal.time - lightStartTime ) / ( float )( lightEndTime - lightStartTime );
color.Lerp( lightColor, color, frac );
}
renderLight.shaderParms[SHADERPARM_RED] = color.x;
renderLight.shaderParms[SHADERPARM_GREEN] = color.y;
renderLight.shaderParms[SHADERPARM_BLUE] = color.z;
}
gameRenderWorld->UpdateLightDef( lightDefHandle, &renderLight );
} else {
lightDefHandle = gameRenderWorld->AddLightDef( &renderLight );
}
}
}
/*
=================
idProjectile::Collide
=================
*/
bool idProjectile::Collide( const trace_t &collision, const idVec3 &velocity ) {
idEntity *ent;
idEntity *ignore;
const char *damageDefName;
idVec3 dir;
float push;
float damageScale;
if ( state == EXPLODED || state == FIZZLED ) {
return true;
}
//BC 4-15-2016 make player drop held items.
//BC 7-16-2016 only drop item if projectile has push ability.
ent = gameLocal.entities[ collision.c.entityNum ];
if (gameLocal.GetLocalPlayer()->pickerWeapon.dragEnt.IsValid() && ent->IsType( idPlayer::Type ) && spawnArgs.GetInt("pushamount") > 0)
{
idEntity *dragee;
dragee = gameLocal.GetLocalPlayer()->pickerWeapon.dragEnt.GetEntity();
gameLocal.GetLocalPlayer()->pickerWeapon.StopDrag(true, false);
}
// predict the explosion
if ( gameLocal.isClient ) {
if ( ClientPredictionCollide( this, spawnArgs, collision, velocity, !spawnArgs.GetBool( "net_instanthit" ) ) )
{
Explode( collision, NULL );
//bc 2-15-2016 possibly hit player that is attached to deck.
//knock player off deck.
ent = gameLocal.entities[ collision.c.entityNum ];
if ( ent->IsType( idPlayer::Type ))
{
if (gameLocal.GetLocalPlayer()->inDeck)
{
gameLocal.GetLocalPlayer()->ExitDeck(true);
gameLocal.isClient = false;
}
}
return true;
}
return false;
}
// remove projectile when a 'noimpact' surface is hit
if ( ( collision.c.material != NULL ) && ( collision.c.material->GetSurfaceFlags() & SURF_NOIMPACT ) ) {
PostEventMS( &EV_Remove, 0 );
common->DPrintf( "Projectile collision no impact\n" );
return true;
}
// get the entity the projectile collided with
ent = gameLocal.entities[ collision.c.entityNum ];
if ( ent == owner.GetEntity() ) {
assert( 0 );
return true;
}
// just get rid of the projectile when it hits a player in noclip
if ( ent->IsType( idPlayer::Type ) && static_cast<idPlayer *>( ent )->noclip ) {
PostEventMS( &EV_Remove, 0 );
return true;
}
// direction of projectile
dir = velocity;
dir.Normalize();
facing = dir;
// projectiles can apply an additional impulse next to the rigid body physics impulse
if ( spawnArgs.GetFloat( "push", "0", push ) && push > 0.0f ) {
ent->ApplyImpulse( this, collision.c.id, collision.c.point, push * dir );
}
// MP: projectiles open doors
if ( gameLocal.isMultiplayer && ent->IsType( idDoor::Type ) && !static_cast< idDoor * >(ent)->IsOpen() && !ent->spawnArgs.GetBool( "no_touch" ) ) {
ent->ProcessEvent( &EV_Activate , this );
}
if ( ent->IsType( idActor::Type ) || ( ent->IsType( idAFAttachment::Type ) && static_cast<const idAFAttachment*>(ent)->GetBody()->IsType( idActor::Type ) ) ) {
if ( !projectileFlags.detonate_on_actor ) {
return false;
}
}
else if (spawnArgs.GetBool("sticky"))
{
//Sticky projectile has collided into world.
idDict args;
args.Clear();
args.SetVector( "origin", this->GetPhysics()->GetOrigin());
args.Set( "model", spawnArgs.GetString("smoke_stickyhit") );
args.SetBool( "start_off", false );
gameLocal.SpawnEntityType( idExplodable::Type, &args );
//attach to the world.
//GetPhysics()->UnlinkClip();
//ignore = NULL;
physicsObj.SetContents( 0 );
if (ent->IsType( idWorldspawn::Type ) || ent->IsType( idPlayer::Type ))
{
stickyState = 1;
}
else
{
this->Bind(ent, true);
}
float stickyfuse = spawnArgs.GetFloat("stickyfuse");
PostEventSec( &EV_Explode, stickyfuse );
if (md5model)
{
md5model->PostEventSec( &EV_Remove, stickyfuse );
int anim;
int channel = 0;
int animBlendFrames = 4;
anim = md5model->GetAnimator()->GetAnim( spawnArgs.GetString("stickyanim") );
if (anim)
{
md5model->GetAnimator()->PlayAnim( channel, anim, gameLocal.time, FRAME2MS( animBlendFrames ) );
}
}
StopSound( SND_CHANNEL_ANY, false );
StartSound( "snd_stickyhit", SND_CHANNEL_BODY2, 0, false, NULL );
StartSound( "snd_stickyidle", SND_CHANNEL_BODY3, 0, false, NULL );
const char *sticky_damage = spawnArgs.GetString( "def_sticky_damage" );
gameLocal.RadiusDamage( physicsObj.GetOrigin(), this, owner.GetEntity(), NULL, this, sticky_damage, damagePower );
return false;
}
else if ( !projectileFlags.detonate_on_world )
{
if ( !StartSound( "snd_ricochet", SND_CHANNEL_ITEM, 0, true, NULL ) )
{
float len = velocity.Length();
if ( len > BOUNCE_SOUND_MIN_VELOCITY )
{
SetSoundVolume( len > BOUNCE_SOUND_MAX_VELOCITY ? 1.0f : idMath::Sqrt( len - BOUNCE_SOUND_MIN_VELOCITY ) * ( 1.0f / idMath::Sqrt( BOUNCE_SOUND_MAX_VELOCITY - BOUNCE_SOUND_MIN_VELOCITY ) ) );
StartSound( "snd_bounce", SND_CHANNEL_ANY, 0, true, NULL );
}
}
return false;
}
SetOrigin( collision.endpos );
SetAxis( collision.endAxis );
// unlink the clip model because we no longer need it
GetPhysics()->UnlinkClip();
damageDefName = spawnArgs.GetString( "def_damage" );
ignore = NULL;
// if the hit entity takes damage
if ( ent->fl.takedamage ) {
if ( damagePower ) {
damageScale = damagePower;
} else {
damageScale = 1.0f;
}
// if the projectile owner is a player
if ( owner.GetEntity() && owner.GetEntity()->IsType( idPlayer::Type ) ) {
// if the projectile hit an actor
if ( ent->IsType( idActor::Type ) ) {
idPlayer *player = static_cast<idPlayer *>( owner.GetEntity() );
player->AddProjectileHits( 1 );
damageScale *= player->PowerUpModifier( PROJECTILE_DAMAGE );
}
}
if ( damageDefName[0] != '\0' ) {
ent->Damage( this, owner.GetEntity(), dir, damageDefName, damageScale, CLIPMODEL_ID_TO_JOINT_HANDLE( collision.c.id ) );
ignore = ent;
}
}
// if the projectile causes a damage effect
if ( spawnArgs.GetBool( "impact_damage_effect" ) ) {
// if the hit entity has a special damage effect
if ( ent->spawnArgs.GetBool( "bleed" ) ) {
ent->AddDamageEffect( collision, velocity, damageDefName );
} else {
AddDefaultDamageEffect( collision, velocity );
}
}
Explode( collision, ignore );
return true;
}
/*
=================
idProjectile::DefaultDamageEffect
=================
*/
void idProjectile::DefaultDamageEffect( idEntity *soundEnt, const idDict &projectileDef, const trace_t &collision, const idVec3 &velocity ) {
const char *decal, *sound, *typeName;
surfTypes_t materialType;
if ( collision.c.material != NULL ) {
materialType = collision.c.material->GetSurfaceType();
} else {
materialType = SURFTYPE_METAL;
}
// get material type name
typeName = gameLocal.sufaceTypeNames[ materialType ];
// play impact sound
sound = projectileDef.GetString( va( "snd_%s", typeName ) );
if ( *sound == '\0' ) {
sound = projectileDef.GetString( "snd_impact" );
}
if ( *sound == '\0' ) {
sound = projectileDef.GetString( "snd_metal" );
}
if ( *sound != '\0' ) {
soundEnt->StartSoundShader( declManager->FindSound( sound ), SND_CHANNEL_BODY, 0, false, NULL );
}
// project decal
decal = projectileDef.GetString( va( "mtr_detonate_%s", typeName ) );
if ( *decal == '\0' ) {
decal = projectileDef.GetString( "mtr_detonate" );
}
if ( *decal != '\0' ) {
gameLocal.ProjectDecal( collision.c.point, -collision.c.normal, 8.0f, true, projectileDef.GetFloat( "decal_size", "6.0" ), decal );
}
}
/*
=================
idProjectile::AddDefaultDamageEffect
=================
*/
void idProjectile::AddDefaultDamageEffect( const trace_t &collision, const idVec3 &velocity ) {
DefaultDamageEffect( this, spawnArgs, collision, velocity );
if ( gameLocal.isServer && fl.networkSync ) {
idBitMsg msg;
byte msgBuf[MAX_EVENT_PARAM_SIZE];
int excludeClient;
if ( spawnArgs.GetBool( "net_instanthit" ) ) {
excludeClient = owner.GetEntityNum();
} else {
excludeClient = -1;
}
msg.Init( msgBuf, sizeof( msgBuf ) );
msg.BeginWriting();
msg.WriteFloat( collision.c.point[0] );
msg.WriteFloat( collision.c.point[1] );
msg.WriteFloat( collision.c.point[2] );
msg.WriteDir( collision.c.normal, 24 );
msg.WriteLong( ( collision.c.material != NULL ) ? gameLocal.ServerRemapDecl( -1, DECL_MATERIAL, collision.c.material->Index() ) : -1 );
msg.WriteFloat( velocity[0], 5, 10 );
msg.WriteFloat( velocity[1], 5, 10 );
msg.WriteFloat( velocity[2], 5, 10 );
ServerSendEvent( EVENT_DAMAGE_EFFECT, &msg, false, excludeClient );
}
}
/*
================
idProjectile::Killed
================
*/
void idProjectile::Killed( idEntity *inflictor, idEntity *attacker, int damage, const idVec3 &dir, int location ) {
if ( spawnArgs.GetBool( "detonate_on_death" ) ) {
trace_t collision;
memset( &collision, 0, sizeof( collision ) );
collision.endAxis = GetPhysics()->GetAxis();
collision.endpos = GetPhysics()->GetOrigin();
collision.c.point = GetPhysics()->GetOrigin();
collision.c.normal.Set( 0, 0, 1 );
Explode( collision, NULL );
physicsObj.ClearContacts();
physicsObj.PutToRest();
} else {
Fizzle();
}
}
/*
================
idProjectile::Fizzle
================
*/
void idProjectile::Fizzle( void ) {
if ( state == EXPLODED || state == FIZZLED ) {
return;
}
StopSound( SND_CHANNEL_BODY, false );
StartSound( "snd_fizzle", SND_CHANNEL_BODY, 0, false, NULL );
// fizzle FX
const char *psystem = spawnArgs.GetString( "smoke_fuse" );
if ( psystem && *psystem ) {
//FIXME:SMOKE gameLocal.particles->SpawnParticles( GetPhysics()->GetOrigin(), vec3_origin, psystem );
}
// we need to work out how long the effects last and then remove them at that time
// for example, bullets have no real effects
if ( smokeFly && smokeFlyTime ) {
smokeFlyTime = 0;
}
fl.takedamage = false;
physicsObj.SetContents( 0 );
physicsObj.GetClipModel()->Unlink();
physicsObj.PutToRest();
Hide();
FreeLightDef();
state = FIZZLED;
if ( gameLocal.isClient ) {
return;
}
CancelEvents( &EV_Fizzle );
PostEventMS( &EV_Remove, spawnArgs.GetInt( "remove_time", "1500" ) );
}
/*
================
idProjectile::Event_RadiusDamage
================
*/
void idProjectile::Event_RadiusDamage( idEntity *ignore ) {
const char *splash_damage = spawnArgs.GetString( "def_splash_damage" );
if ( splash_damage[0] != '\0' ) {
gameLocal.RadiusDamage( physicsObj.GetOrigin(), this, owner.GetEntity(), ignore, this, splash_damage, damagePower );
}
}
/*
================
idProjectile::Event_RadiusDamage
================
*/
void idProjectile::Event_GetProjectileState( void ) {
idThread::ReturnInt( state );
}
/*
================
idProjectile::Explode
================
*/
void idProjectile::Explode( const trace_t &collision, idEntity *ignore ) {
const char *fxname, *light_shader, *sndExplode;
float light_fadetime;
idVec3 normal;
int removeTime;
if ( state == EXPLODED || state == FIZZLED ) {
return;
}
// stop sound
StopSound( SND_CHANNEL_BODY2, false );
StopSound( SND_CHANNEL_BODY3, false );
// play explode sound
switch ( ( int ) damagePower ) {
case 2: sndExplode = "snd_explode2"; break;
case 3: sndExplode = "snd_explode3"; break;
case 4: sndExplode = "snd_explode4"; break;
default: sndExplode = "snd_explode"; break;
}
StartSound( sndExplode, SND_CHANNEL_BODY, 0, true, NULL );
// we need to work out how long the effects last and then remove them at that time
// for example, bullets have no real effects
if ( smokeFly && smokeFlyTime ) {
smokeFlyTime = 0;
}
Hide();
FreeLightDef();
if ( spawnArgs.GetVector( "detonation_axis", "", normal ) ) {
GetPhysics()->SetAxis( normal.ToMat3() );
}
GetPhysics()->SetOrigin( collision.endpos + 2.0f * collision.c.normal );
// default remove time
removeTime = spawnArgs.GetInt( "remove_time", "1500" );
// change the model, usually to a PRT
fxname = NULL;
if ( g_testParticle.GetInteger() == TEST_PARTICLE_IMPACT ) {
fxname = g_testParticleName.GetString();
} else {
fxname = spawnArgs.GetString( "model_detonate" );
}
int surfaceType = collision.c.material != NULL ? collision.c.material->GetSurfaceType() : SURFTYPE_METAL;
if ( !( fxname && *fxname ) ) {
if (surfaceType == SURFTYPE_METAL )
{
fxname = spawnArgs.GetString( "model_metal" );
}
else if ( ( surfaceType == SURFTYPE_NONE ) || ( surfaceType == SURFTYPE_STONE ) ) {
fxname = spawnArgs.GetString( "model_smokespark" );
} else if ( surfaceType == SURFTYPE_RICOCHET ) {
fxname = spawnArgs.GetString( "model_ricochet" );
} else {
fxname = spawnArgs.GetString( "model_smoke" );
}
}
#ifdef _D3XP
// If the explosion is in liquid, spawn a particle splash
idVec3 testOrg = GetPhysics()->GetOrigin();
int testC = gameLocal.clip.Contents( testOrg, NULL, mat3_identity, CONTENTS_WATER, this );
if ( testC & CONTENTS_WATER ) {
idFuncEmitter *splashEnt;
idDict splashArgs;
splashArgs.Set( "model", "sludgebulletimpact.prt" );
splashArgs.Set( "start_off", "1" );
splashEnt = static_cast<idFuncEmitter *>( gameLocal.SpawnEntityType( idFuncEmitter::Type, &splashArgs ) );
splashEnt->GetPhysics()->SetOrigin( testOrg );
splashEnt->PostEventMS( &EV_Activate, 0, this );
splashEnt->PostEventMS( &EV_Remove, 1500 );
// HACK - if this is a chaingun bullet, don't do the normal effect
if ( !idStr::Cmp( spawnArgs.GetString( "def_damage" ), "damage_bullet_chaingun" ) ) {
fxname = NULL;
}
}
#endif
if ( fxname && *fxname ) {
SetModel( fxname );
renderEntity.shaderParms[SHADERPARM_RED] =
renderEntity.shaderParms[SHADERPARM_GREEN] =
renderEntity.shaderParms[SHADERPARM_BLUE] =
renderEntity.shaderParms[SHADERPARM_ALPHA] = 1.0f;
renderEntity.shaderParms[SHADERPARM_TIMEOFFSET] = -MS2SEC( gameLocal.time );
renderEntity.shaderParms[SHADERPARM_DIVERSITY] = gameLocal.random.CRandomFloat();
Show();
removeTime = ( removeTime > 3000 ) ? removeTime : 3000;
}
// explosion light
light_shader = spawnArgs.GetString( "mtr_explode_light_shader" );
#ifdef CTF
if ( gameLocal.mpGame.IsGametypeFlagBased() && gameLocal.serverInfo.GetBool("si_midnight") )
{
light_shader = "lights/midnight_grenade";
}
#endif
if ( *light_shader ) {
renderLight.shader = declManager->FindMaterial( light_shader, false );
renderLight.pointLight = true;
renderLight.lightRadius[0] =
renderLight.lightRadius[1] =
renderLight.lightRadius[2] = spawnArgs.GetFloat( "explode_light_radius" );
#ifdef CTF
// Midnight ctf
if ( gameLocal.mpGame.IsGametypeFlagBased() && gameLocal.serverInfo.GetBool("si_midnight") )
{
renderLight.lightRadius[0] =
renderLight.lightRadius[1] =
renderLight.lightRadius[2] = spawnArgs.GetFloat( "explode_light_radius" ) * 2;
}
#endif
spawnArgs.GetVector( "explode_light_color", "1 1 1", lightColor );
renderLight.shaderParms[SHADERPARM_RED] = lightColor.x;
renderLight.shaderParms[SHADERPARM_GREEN] = lightColor.y;
renderLight.shaderParms[SHADERPARM_BLUE] = lightColor.z;
renderLight.shaderParms[SHADERPARM_ALPHA] = 1.0f;
renderLight.shaderParms[SHADERPARM_TIMEOFFSET] = -MS2SEC( gameLocal.time );
#ifdef CTF
// Midnight ctf
if ( gameLocal.mpGame.IsGametypeFlagBased() && gameLocal.serverInfo.GetBool("si_midnight") )
{
light_fadetime = 3.0f;
}
else
#endif
light_fadetime = spawnArgs.GetFloat( "explode_light_fadetime", "0.5" );
lightStartTime = gameLocal.time;
lightEndTime = gameLocal.time + SEC2MS( light_fadetime );
BecomeActive( TH_THINK );
}
fl.takedamage = false;
physicsObj.SetContents( 0 );
physicsObj.PutToRest();
state = EXPLODED;
if (gameLocal.entities[collision.c.entityNum]->IsType(idMoveableItem::Type) || gameLocal.entities[collision.c.entityNum]->IsType(idMoveable::Type))
{
idDict args;
args.Clear();
args.SetVector( "origin", collision.endpos);
args.Set( "model", spawnArgs.GetString("model_hitmoveable", "sparkburst6.prt") );
args.SetBool( "start_off", false );
gameLocal.SpawnEntityType( idExplodable::Type, &args );
}
if (spawnArgs.GetBool("fractures", "0"))
{
if (gameLocal.entities[ collision.c.entityNum ]->IsType( idBrittleFracture::Type ) || gameLocal.entities[ collision.c.entityNum ]->IsType( idQGlass::Type ))
{
gameLocal.entities[ collision.c.entityNum ]->AddForce(this, this->entityNumber, collision.endpos, collision.c.normal);
//BC
//projectiles penetrate multiple levels of fracture glass.
idVec3 movedir = physicsObj.GetOrigin() - startOrigin;
movedir.Normalize();
int i;
idVec3 hitpoint = physicsObj.GetOrigin();
int maxGlassPanes = 32;
for (i = 0; i < maxGlassPanes; i++)
{
trace_t tr;
//common->Printf("hit %d\n", i);
idVec3 startTrace = hitpoint + (movedir * 1.0f);
gameLocal.clip.TracePoint( tr, startTrace, startTrace + (movedir * 4096), MASK_SOLID | MASK_SHOT_RENDERMODEL, this );
if (developer.GetBool())
gameRenderWorld->DebugArrow( colorRed, startTrace, tr.endpos, 4, 30000 );
HandleHit(tr);
idEntity *hitent;
// get the entity the projectile collided with
hitent = gameLocal.entities[ tr.c.entityNum ];
if ( hitent != NULL )
{
//common->Printf("hit ent %s\n", hitent->name.c_str());
if (gameLocal.entities[ tr.c.entityNum ]->IsType( idBrittleFracture::Type ) || gameLocal.entities[ tr.c.entityNum ]->IsType( idQGlass::Type ))
{
//shatter it.
gameLocal.entities[ tr.c.entityNum ]->AddForce(this, this->entityNumber, tr.endpos, tr.c.normal);
hitpoint = tr.endpos;
continue;
}
else if (gameLocal.entities[ tr.c.entityNum ]->IsType( idTrembler::Type ))
{
static_cast< idTrembler * >( gameLocal.entities[ tr.c.entityNum ] )->Event_Touch(NULL, NULL);
}
}
break;
}
}
}
HandleHit(collision);
if ( gameLocal.isClient ) {
return;
}
// alert the ai
gameLocal.AlertAI( owner.GetEntity() );
// bind the projectile to the impact entity if necesary
if ( gameLocal.entities[collision.c.entityNum] && spawnArgs.GetBool( "bindOnImpact" ) ) {
Bind( gameLocal.entities[collision.c.entityNum], true );
}
// splash damage
if ( !projectileFlags.noSplashDamage ) {
float delay = spawnArgs.GetFloat( "delay_splash" );
if ( delay ) {
if ( removeTime < delay * 1000 ) {
removeTime = ( delay + 0.10 ) * 1000;
}
PostEventSec( &EV_RadiusDamage, delay, ignore );
} else {
Event_RadiusDamage( ignore );
}
}
// spawn debris entities
int fxdebris = spawnArgs.GetInt( "debris_count" );
if ( fxdebris ) {
const idDict *debris = gameLocal.FindEntityDefDict( "projectile_debris", false );
if ( debris ) {
int amount = gameLocal.random.RandomInt( fxdebris );
for ( int i = 0; i < amount; i++ ) {
idEntity *ent;
idVec3 dir;
dir.x = gameLocal.random.CRandomFloat() * 4.0f;
dir.y = gameLocal.random.CRandomFloat() * 4.0f;
dir.z = gameLocal.random.RandomFloat() * 8.0f;
dir.Normalize();
gameLocal.SpawnEntityDef( *debris, &ent, false );
if ( !ent || !ent->IsType( idDebris::Type ) ) {
gameLocal.Error( "'projectile_debris' is not an idDebris" );
}
idDebris *debris = static_cast<idDebris *>(ent);
debris->Create( owner.GetEntity(), physicsObj.GetOrigin(), dir.ToMat3() );
debris->Launch();
}
}
debris = gameLocal.FindEntityDefDict( "projectile_shrapnel", false );
if ( debris ) {
int amount = gameLocal.random.RandomInt( fxdebris );
for ( int i = 0; i < amount; i++ ) {
idEntity *ent;
idVec3 dir;
dir.x = gameLocal.random.CRandomFloat() * 8.0f;
dir.y = gameLocal.random.CRandomFloat() * 8.0f;
dir.z = gameLocal.random.RandomFloat() * 8.0f + 8.0f;
dir.Normalize();
gameLocal.SpawnEntityDef( *debris, &ent, false );
if ( !ent || !ent->IsType( idDebris::Type ) ) {
gameLocal.Error( "'projectile_shrapnel' is not an idDebris" );
}
idDebris *debris = static_cast<idDebris *>(ent);
debris->Create( owner.GetEntity(), physicsObj.GetOrigin(), dir.ToMat3() );
debris->Launch();
}
}
}
idEntity *markerEnt = gameLocal.FindEntity( spawnArgs.GetString( "markername" ) );
if (markerEnt)
{
markerEnt->PostEventMS( &EV_Remove, 0);
}
idEntity *beamEnt = gameLocal.FindEntity( spawnArgs.GetString( "beamname" ) );
if (beamEnt)
{
beamEnt->PostEventMS( &EV_Remove, 0);
}
CancelEvents( &EV_Explode );
PostEventMS( &EV_Remove, removeTime );
}
void idProjectile::HandleHit(const trace_t &collision)
{
if (gameLocal.entities[ collision.c.entityNum ])
{
if (gameLocal.entities[ collision.c.entityNum ]->IsType(idFrobCube::Type) || gameLocal.entities[ collision.c.entityNum ]->IsType(idStaticEntity::Type))
{
idStr scriptName = gameLocal.entities[ collision.c.entityNum ]->spawnArgs.GetString( "calldamage" );
const function_t *scriptFunction;
scriptFunction = gameLocal.program.FindFunction( scriptName );
if ( scriptFunction )
{
idThread *thread;
thread = new idThread( scriptFunction );
thread->DelayedStart( 0 );
}
}
}
//BC
//frob stuff.
if (spawnArgs.GetBool( "frobber" ))
{
if (ENTITYNUM_WORLD != collision.c.entityNum && collision.c.entityNum >= 0)
{
if (gameLocal.entities[ collision.c.entityNum ])
{
//common->Printf("Hit object: %s\n", gameLocal.entities[ collision.c.entityNum ]->GetName());
if (gameLocal.entities[ collision.c.entityNum ]->spawnArgs.GetInt("sentryhittable") )
{
gameLocal.GetLocalPlayer()->DoFrob(gameLocal.entities[ collision.c.entityNum ]);
idDict args;
args.Clear();
args.SetVector( "origin", collision.endpos);
args.Set( "model", "sparkburst5.prt" );
args.SetBool( "start_off", false );
idEntity *zapParticles = gameLocal.SpawnEntityType( idExplodable::Type, &args );
idAngles ang = this->GetPhysics()->GetAxis().ToAngles();
ang.yaw += 180;
zapParticles->SetAngles(ang);
}
}
}
}
//bc push physical things.
int pushAmount = spawnArgs.GetInt( "pushamount" );
if (pushAmount > 0)
{
if (ENTITYNUM_WORLD != collision.c.entityNum && collision.c.entityNum >= 0)
{
if (gameLocal.entities[ collision.c.entityNum ])
{
//common->Printf("hit %s\n", gameLocal.entities[ collision.c.entityNum ]->GetName());
if (gameLocal.entities[ collision.c.entityNum ]->IsType( idMoveable::Type ) || gameLocal.entities[ collision.c.entityNum ]->IsType( idMoveableItem::Type))
{
//BC 9-10-2015 if player is holding item, then make player drop the item.
if (gameLocal.GetLocalPlayer()->pickerWeapon.dragEnt.IsValid())
{
if (gameLocal.GetLocalPlayer()->pickerWeapon.dragEnt.GetEntity()->IsGrabbed())
{
if (gameLocal.GetLocalPlayer()->pickerWeapon.dragEnt.GetEntity()->entityNumber == collision.c.entityNum)
{
//drop the item.
gameLocal.GetLocalPlayer()->pickerWeapon.StopDrag(true, false);
}
}
}
gameLocal.entities[ collision.c.entityNum ]->GetPhysics()->SetLinearVelocity(facing * pushAmount);
}
}
}
}
}
/*
================
idProjectile::GetVelocity
================
*/
idVec3 idProjectile::GetVelocity( const idDict *projectile ) {
idVec3 velocity;
projectile->GetVector( "velocity", "0 0 0", velocity );
return velocity;
}
/*
================
idProjectile::GetGravity
================
*/
idVec3 idProjectile::GetGravity( const idDict *projectile ) {
float gravity;
gravity = projectile->GetFloat( "gravity" );
return idVec3( 0, 0, -gravity );
}
/*
================
idProjectile::Event_Explode
================
*/
void idProjectile::Event_Explode( void ) {
trace_t collision;
memset( &collision, 0, sizeof( collision ) );
collision.endAxis = GetPhysics()->GetAxis();
collision.endpos = GetPhysics()->GetOrigin();
collision.c.point = GetPhysics()->GetOrigin();
collision.c.normal.Set( 0, 0, 1 );
AddDefaultDamageEffect( collision, collision.c.normal );
Explode( collision, NULL );
}
/*
================
idProjectile::Event_Fizzle
================
*/
void idProjectile::Event_Fizzle( void ) {
Fizzle();
}
/*
================
idProjectile::Event_Touch
================
*/
void idProjectile::Event_Touch( idEntity *other, trace_t *trace ) {
if ( IsHidden() ) {
return;
}
#ifdef CTF
// Projectiles do not collide with flags
if ( other->IsType( idItemTeam::Type ) )
return;
#endif
if ( other != owner.GetEntity() ) {
trace_t collision;
memset( &collision, 0, sizeof( collision ) );
collision.endAxis = GetPhysics()->GetAxis();
collision.endpos = GetPhysics()->GetOrigin();
collision.c.point = GetPhysics()->GetOrigin();
collision.c.normal.Set( 0, 0, 1 );
AddDefaultDamageEffect( collision, collision.c.normal );
Explode( collision, NULL );
}
}
#ifdef _D3XP
/*
================
idProjectile::CatchProjectile
================
*/
void idProjectile::CatchProjectile( idEntity* o, const char* reflectName ) {
idEntity *prevowner = owner.GetEntity();
owner = o;
physicsObj.GetClipModel()->SetOwner( o );
if ( this->IsType( idGuidedProjectile::Type ) ) {
idGuidedProjectile *proj = static_cast<idGuidedProjectile*>(this);
proj->SetEnemy( prevowner );
}
idStr s = spawnArgs.GetString( "def_damage" );
s += reflectName;
const idDict *damageDef = gameLocal.FindEntityDefDict( s, false );
if ( damageDef ) {
spawnArgs.Set( "def_damage", s );
}
}
/*
================
idProjectile::GetProjectileState
================
*/
int idProjectile::GetProjectileState( void ) {
return (int)state;
}
/*
================
idProjectile::Event_CreateProjectile
================
*/
void idProjectile::Event_CreateProjectile( idEntity *owner, const idVec3 &start, const idVec3 &dir ) {
Create(owner, start, dir);
}
/*
================
idProjectile::Event_LaunchProjectile
================
*/
void idProjectile::Event_LaunchProjectile( const idVec3 &start, const idVec3 &dir, const idVec3 &pushVelocity ) {
Launch(start, dir, pushVelocity);
}
/*
================
idProjectile::Event_SetGravity
================
*/
void idProjectile::Event_SetGravity( float gravity ) {
idVec3 gravVec;
gravVec = gameLocal.GetGravity();
gravVec.NormalizeFast();
physicsObj.SetGravity(gravVec * gravity);
}
#endif
/*
=================
idProjectile::ClientPredictionCollide
=================
*/
bool idProjectile::ClientPredictionCollide( idEntity *soundEnt, const idDict &projectileDef, const trace_t &collision, const idVec3 &velocity, bool addDamageEffect ) {
idEntity *ent;
// remove projectile when a 'noimpact' surface is hit
if ( collision.c.material && ( collision.c.material->GetSurfaceFlags() & SURF_NOIMPACT ) ) {
return false;
}
// get the entity the projectile collided with
ent = gameLocal.entities[ collision.c.entityNum ];
if ( ent == NULL ) {
return false;
}
// don't do anything if hitting a noclip player
if ( ent->IsType( idPlayer::Type ) && static_cast<idPlayer *>( ent )->noclip ) {
return false;
}
if ( ent->IsType( idActor::Type ) || ( ent->IsType( idAFAttachment::Type ) && static_cast<const idAFAttachment*>(ent)->GetBody()->IsType( idActor::Type ) ) ) {
if ( !projectileDef.GetBool( "detonate_on_actor" ) ) {
return false;
}
} else {
if ( !projectileDef.GetBool( "detonate_on_world" ) ) {
return false;
}
}
// if the projectile causes a damage effect
if ( addDamageEffect && projectileDef.GetBool( "impact_damage_effect" ) ) {
// if the hit entity does not have a special damage effect
if ( !ent->spawnArgs.GetBool( "bleed" ) ) {
// predict damage effect
DefaultDamageEffect( soundEnt, projectileDef, collision, velocity );
}
}
return true;
}
/*
================
idProjectile::ClientPredictionThink
================
*/
void idProjectile::ClientPredictionThink( void ) {
if ( !renderEntity.hModel ) {
return;
}
Think();
}
/*
================
idProjectile::WriteToSnapshot
================
*/
void idProjectile::WriteToSnapshot( idBitMsgDelta &msg ) const {
msg.WriteBits( owner.GetSpawnId(), 32 );
msg.WriteBits( state, 3 );
msg.WriteBits( fl.hidden, 1 );
if ( netSyncPhysics ) {
msg.WriteBits( 1, 1 );
physicsObj.WriteToSnapshot( msg );
} else {
msg.WriteBits( 0, 1 );
const idVec3 &origin = physicsObj.GetOrigin();
const idVec3 &velocity = physicsObj.GetLinearVelocity();
msg.WriteFloat( origin.x );
msg.WriteFloat( origin.y );
msg.WriteFloat( origin.z );
msg.WriteDeltaFloat( 0.0f, velocity[0], RB_VELOCITY_EXPONENT_BITS, RB_VELOCITY_MANTISSA_BITS );
msg.WriteDeltaFloat( 0.0f, velocity[1], RB_VELOCITY_EXPONENT_BITS, RB_VELOCITY_MANTISSA_BITS );
msg.WriteDeltaFloat( 0.0f, velocity[2], RB_VELOCITY_EXPONENT_BITS, RB_VELOCITY_MANTISSA_BITS );
}
}
/*
================
idProjectile::ReadFromSnapshot
================
*/
void idProjectile::ReadFromSnapshot( const idBitMsgDelta &msg ) {
projectileState_t newState;
owner.SetSpawnId( msg.ReadBits( 32 ) );
newState = (projectileState_t) msg.ReadBits( 3 );
if ( msg.ReadBits( 1 ) ) {
Hide();
} else {
Show();
}
while( state != newState ) {
switch( state ) {
case SPAWNED: {
Create( owner.GetEntity(), vec3_origin, idVec3( 1, 0, 0 ) );
break;
}
case CREATED: {
// the right origin and direction are required if you want bullet traces
Launch( vec3_origin, idVec3( 1, 0, 0 ), vec3_origin );
break;
}
case LAUNCHED: {
if ( newState == FIZZLED ) {
Fizzle();
} else {
trace_t collision;
memset( &collision, 0, sizeof( collision ) );
collision.endAxis = GetPhysics()->GetAxis();
collision.endpos = GetPhysics()->GetOrigin();
collision.c.point = GetPhysics()->GetOrigin();
collision.c.normal.Set( 0, 0, 1 );
Explode( collision, NULL );
}
break;
}
case FIZZLED:
case EXPLODED: {
StopSound( SND_CHANNEL_BODY2, false );
gameEdit->ParseSpawnArgsToRenderEntity( &spawnArgs, &renderEntity );
state = SPAWNED;
break;
}
}
}
if ( msg.ReadBits( 1 ) ) {
physicsObj.ReadFromSnapshot( msg );
} else {
idVec3 origin;
idVec3 velocity;
idVec3 tmp;
idMat3 axis;
origin.x = msg.ReadFloat();
origin.y = msg.ReadFloat();
origin.z = msg.ReadFloat();
velocity.x = msg.ReadDeltaFloat( 0.0f, RB_VELOCITY_EXPONENT_BITS, RB_VELOCITY_MANTISSA_BITS );
velocity.y = msg.ReadDeltaFloat( 0.0f, RB_VELOCITY_EXPONENT_BITS, RB_VELOCITY_MANTISSA_BITS );
velocity.z = msg.ReadDeltaFloat( 0.0f, RB_VELOCITY_EXPONENT_BITS, RB_VELOCITY_MANTISSA_BITS );
physicsObj.SetOrigin( origin );
physicsObj.SetLinearVelocity( velocity );
// align z-axis of model with the direction
velocity.NormalizeFast();
axis = velocity.ToMat3();
tmp = axis[2];
axis[2] = axis[0];
axis[0] = -tmp;
physicsObj.SetAxis( axis );
}
if ( msg.HasChanged() ) {
UpdateVisuals();
}
}
/*
================
idProjectile::ClientReceiveEvent
================
*/
bool idProjectile::ClientReceiveEvent( int event, int time, const idBitMsg &msg ) {
trace_t collision;
idVec3 velocity;
switch( event ) {
case EVENT_DAMAGE_EFFECT: {
memset( &collision, 0, sizeof( collision ) );
collision.c.point[0] = msg.ReadFloat();
collision.c.point[1] = msg.ReadFloat();
collision.c.point[2] = msg.ReadFloat();
collision.c.normal = msg.ReadDir( 24 );
int index = gameLocal.ClientRemapDecl( DECL_MATERIAL, msg.ReadLong() );
collision.c.material = ( index != -1 ) ? static_cast<const idMaterial *>( declManager->DeclByIndex( DECL_MATERIAL, index ) ) : NULL;
velocity[0] = msg.ReadFloat( 5, 10 );
velocity[1] = msg.ReadFloat( 5, 10 );
velocity[2] = msg.ReadFloat( 5, 10 );
DefaultDamageEffect( this, spawnArgs, collision, velocity );
return true;
}
default: {
return idEntity::ClientReceiveEvent( event, time, msg );
}
}
return false;
}
/*
===============================================================================
idGuidedProjectile
===============================================================================
*/
#ifdef _D3XP
const idEventDef EV_SetEnemy( "setEnemy", "E" );
#endif
CLASS_DECLARATION( idProjectile, idGuidedProjectile )
#ifdef _D3XP
EVENT( EV_SetEnemy, idGuidedProjectile::Event_SetEnemy )
#endif
END_CLASS
/*
================
idGuidedProjectile::idGuidedProjectile
================
*/
idGuidedProjectile::idGuidedProjectile( void ) {
enemy = NULL;
speed = 0.0f;
turn_max = 0.0f;
clamp_dist = 0.0f;
rndScale = ang_zero;
rndAng = ang_zero;
rndUpdateTime = 0;
angles = ang_zero;
burstMode = false;
burstDist = 0;
burstVelocity = 0.0f;
unGuided = false;
}
/*
=================
idGuidedProjectile::~idGuidedProjectile
=================
*/
idGuidedProjectile::~idGuidedProjectile( void ) {
}
/*
================
idGuidedProjectile::Spawn
================
*/
void idGuidedProjectile::Spawn( void ) {
}
/*
================
idGuidedProjectile::Save
================
*/
void idGuidedProjectile::Save( idSaveGame *savefile ) const {
enemy.Save( savefile );
savefile->WriteFloat( speed );
savefile->WriteAngles( rndScale );
savefile->WriteAngles( rndAng );
savefile->WriteInt( rndUpdateTime );
savefile->WriteFloat( turn_max );
savefile->WriteFloat( clamp_dist );
savefile->WriteAngles( angles );
savefile->WriteBool( burstMode );
savefile->WriteBool( unGuided );
savefile->WriteFloat( burstDist );
savefile->WriteFloat( burstVelocity );
}
/*
================
idGuidedProjectile::Restore
================
*/
void idGuidedProjectile::Restore( idRestoreGame *savefile ) {
enemy.Restore( savefile );
savefile->ReadFloat( speed );
savefile->ReadAngles( rndScale );
savefile->ReadAngles( rndAng );
savefile->ReadInt( rndUpdateTime );
savefile->ReadFloat( turn_max );
savefile->ReadFloat( clamp_dist );
savefile->ReadAngles( angles );
savefile->ReadBool( burstMode );
savefile->ReadBool( unGuided );
savefile->ReadFloat( burstDist );
savefile->ReadFloat( burstVelocity );
}
/*
================
idGuidedProjectile::GetSeekPos
================
*/
void idGuidedProjectile::GetSeekPos( idVec3 &out ) {
idEntity *enemyEnt = enemy.GetEntity();
if ( enemyEnt ) {
if ( enemyEnt->IsType( idActor::Type ) ) {
out = static_cast<idActor *>(enemyEnt)->GetEyePosition();
out.z -= 12.0f;
} else {
out = enemyEnt->GetPhysics()->GetOrigin();
}
} else {
out = GetPhysics()->GetOrigin() + physicsObj.GetLinearVelocity() * 2.0f;
}
}
/*
================
idGuidedProjectile::Think
================
*/
void idGuidedProjectile::Think( void ) {
idVec3 dir;
idVec3 seekPos;
idVec3 velocity;
idVec3 nose;
idVec3 tmp;
idMat3 axis;
idAngles dirAng;
idAngles diff;
float dist;
float frac;
int i;
if ( state == LAUNCHED && !unGuided ) {
GetSeekPos( seekPos );
if ( rndUpdateTime < gameLocal.time ) {
rndAng[ 0 ] = rndScale[ 0 ] * gameLocal.random.CRandomFloat();
rndAng[ 1 ] = rndScale[ 1 ] * gameLocal.random.CRandomFloat();
rndAng[ 2 ] = rndScale[ 2 ] * gameLocal.random.CRandomFloat();
rndUpdateTime = gameLocal.time + 200;
}
nose = physicsObj.GetOrigin() + 10.0f * physicsObj.GetAxis()[0];
dir = seekPos - nose;
dist = dir.Normalize();
dirAng = dir.ToAngles();
// make it more accurate as it gets closer
frac = dist / clamp_dist;
if ( frac > 1.0f ) {
frac = 1.0f;
}
diff = dirAng - angles + rndAng * frac;
// clamp the to the max turn rate
diff.Normalize180();
for( i = 0; i < 3; i++ ) {
if ( diff[ i ] > turn_max ) {
diff[ i ] = turn_max;
} else if ( diff[ i ] < -turn_max ) {
diff[ i ] = -turn_max;
}
}
angles += diff;
// make the visual model always points the dir we're traveling
dir = angles.ToForward();
velocity = dir * speed;
if ( burstMode && dist < burstDist ) {
unGuided = true;
velocity *= burstVelocity;
}
physicsObj.SetLinearVelocity( velocity );
// align z-axis of model with the direction
axis = dir.ToMat3();
tmp = axis[2];
axis[2] = axis[0];
axis[0] = -tmp;
GetPhysics()->SetAxis( axis );
}
idProjectile::Think();
}
/*
=================
idGuidedProjectile::Launch
=================
*/
void idGuidedProjectile::Launch( const idVec3 &start, const idVec3 &dir, const idVec3 &pushVelocity, const float timeSinceFire, const float launchPower, float dmgPower ) {
idProjectile::Launch( start, dir, pushVelocity, timeSinceFire, launchPower, dmgPower );
if ( owner.GetEntity() ) {
if ( owner.GetEntity()->IsType( idAI::Type ) ) {
enemy = static_cast<idAI *>( owner.GetEntity() )->GetEnemy();
} else if ( owner.GetEntity()->IsType( idPlayer::Type ) ) {
trace_t tr;
idPlayer *player = static_cast<idPlayer*>( owner.GetEntity() );
idVec3 start = player->GetEyePosition();
idVec3 end = start + player->viewAxis[0] * 1000.0f;
gameLocal.clip.TracePoint( tr, start, end, MASK_SHOT_RENDERMODEL | CONTENTS_BODY, owner.GetEntity() );
if ( tr.fraction < 1.0f ) {
enemy = gameLocal.GetTraceEntity( tr );
}
// ignore actors on the player's team
if ( enemy.GetEntity() == NULL || !enemy.GetEntity()->IsType( idActor::Type ) || ( static_cast<idActor *>( enemy.GetEntity() )->team == player->team ) ) {
enemy = player->EnemyWithMostHealth();
}
}
}
const idVec3 &vel = physicsObj.GetLinearVelocity();
angles = vel.ToAngles();
speed = vel.Length();
rndScale = spawnArgs.GetAngles( "random", "15 15 0" );
turn_max = spawnArgs.GetFloat( "turn_max", "180" ) / ( float )USERCMD_HZ;
clamp_dist = spawnArgs.GetFloat( "clamp_dist", "256" );
burstMode = spawnArgs.GetBool( "burstMode" );
unGuided = false;
burstDist = spawnArgs.GetFloat( "burstDist", "64" );
burstVelocity = spawnArgs.GetFloat( "burstVelocity", "1.25" );
UpdateVisuals();
}
#ifdef _D3XP
void idGuidedProjectile::SetEnemy( idEntity *ent ) {
enemy = ent;
}
void idGuidedProjectile::Event_SetEnemy(idEntity *ent) {
SetEnemy(ent);
}
#endif
/*
===============================================================================
idSoulCubeMissile
===============================================================================
*/
CLASS_DECLARATION( idGuidedProjectile, idSoulCubeMissile )
END_CLASS
/*
================
idSoulCubeMissile::Spawn( void )
================
*/
void idSoulCubeMissile::Spawn( void ) {
startingVelocity.Zero();
endingVelocity.Zero();
accelTime = 0.0f;
launchTime = 0;
killPhase = false;
returnPhase = false;
smokeKillTime = 0;
smokeKill = NULL;
}
/*
=================
idSoulCubeMissile::~idSoulCubeMissile
=================
*/
idSoulCubeMissile::~idSoulCubeMissile() {
}
/*
================
idSoulCubeMissile::Save
================
*/
void idSoulCubeMissile::Save( idSaveGame *savefile ) const {
savefile->WriteVec3( startingVelocity );
savefile->WriteVec3( endingVelocity );
savefile->WriteFloat( accelTime );
savefile->WriteInt( launchTime );
savefile->WriteBool( killPhase );
savefile->WriteBool( returnPhase );
savefile->WriteVec3( destOrg);
savefile->WriteInt( orbitTime );
savefile->WriteVec3( orbitOrg );
savefile->WriteInt( smokeKillTime );
savefile->WriteParticle( smokeKill );
}
/*
================
idSoulCubeMissile::Restore
================
*/
void idSoulCubeMissile::Restore( idRestoreGame *savefile ) {
savefile->ReadVec3( startingVelocity );
savefile->ReadVec3( endingVelocity );
savefile->ReadFloat( accelTime );
savefile->ReadInt( launchTime );
savefile->ReadBool( killPhase );
savefile->ReadBool( returnPhase );
savefile->ReadVec3( destOrg);
savefile->ReadInt( orbitTime );
savefile->ReadVec3( orbitOrg );
savefile->ReadInt( smokeKillTime );
savefile->ReadParticle( smokeKill );
}
/*
================
idSoulCubeMissile::KillTarget
================
*/
void idSoulCubeMissile::KillTarget( const idVec3 &dir ) {
idEntity *ownerEnt;
const char *smokeName;
idActor *act;
ReturnToOwner();
if ( enemy.GetEntity() && enemy.GetEntity()->IsType( idActor::Type ) ) {
act = static_cast<idActor*>( enemy.GetEntity() );
killPhase = true;
orbitOrg = act->GetPhysics()->GetAbsBounds().GetCenter();
orbitTime = gameLocal.time;
smokeKillTime = 0;
smokeName = spawnArgs.GetString( "smoke_kill" );
if ( *smokeName != '\0' ) {
smokeKill = static_cast<const idDeclParticle *>( declManager->FindType( DECL_PARTICLE, smokeName ) );
smokeKillTime = gameLocal.time;
}
ownerEnt = owner.GetEntity();
if ( ( act->health > 0 ) && ownerEnt && ownerEnt->IsType( idPlayer::Type ) && ( ownerEnt->health > 0 ) && !act->spawnArgs.GetBool( "boss" ) ) {
static_cast<idPlayer *>( ownerEnt )->GiveHealthPool( act->health );
}
act->Damage( this, owner.GetEntity(), dir, spawnArgs.GetString( "def_damage" ), 1.0f, INVALID_JOINT );
act->GetAFPhysics()->SetTimeScale( 0.25 );
StartSound( "snd_explode", SND_CHANNEL_BODY, 0, false, NULL );
}
}
/*
================
idSoulCubeMissile::Think
================
*/
void idSoulCubeMissile::Think( void ) {
float pct;
idVec3 seekPos;
idEntity *ownerEnt;
if ( state == LAUNCHED ) {
if ( killPhase ) {
// orbit the mob, cascading down
if ( gameLocal.time < orbitTime + 1500 ) {
if ( !gameLocal.smokeParticles->EmitSmoke( smokeKill, smokeKillTime, gameLocal.random.CRandomFloat(), orbitOrg, mat3_identity, timeGroup /*_D3XP*/ ) ) {
smokeKillTime = gameLocal.time;
}
}
} else {
if ( accelTime && gameLocal.time < launchTime + accelTime * 1000 ) {
pct = ( gameLocal.time - launchTime ) / ( accelTime * 1000 );
speed = ( startingVelocity + ( startingVelocity + endingVelocity ) * pct ).Length();
}
}
idGuidedProjectile::Think();
GetSeekPos( seekPos );
if ( ( seekPos - physicsObj.GetOrigin() ).Length() < 32.0f ) {
if ( returnPhase ) {
StopSound( SND_CHANNEL_ANY, false );
StartSound( "snd_return", SND_CHANNEL_BODY2, 0, false, NULL );
Hide();
PostEventSec( &EV_Remove, 2.0f );
ownerEnt = owner.GetEntity();
if ( ownerEnt && ownerEnt->IsType( idPlayer::Type ) ) {
static_cast<idPlayer *>( ownerEnt )->SetSoulCubeProjectile( NULL );
}
state = FIZZLED;
} else if ( !killPhase ){
KillTarget( physicsObj.GetAxis()[0] );
}
}
}
}
/*
================
idSoulCubeMissile::GetSeekPos
================
*/
void idSoulCubeMissile::GetSeekPos( idVec3 &out ) {
if ( returnPhase && owner.GetEntity() && owner.GetEntity()->IsType( idActor::Type ) ) {
idActor *act = static_cast<idActor*>( owner.GetEntity() );
out = act->GetEyePosition();
return;
}
if ( destOrg != vec3_zero ) {
out = destOrg;
return;
}
idGuidedProjectile::GetSeekPos( out );
}
/*
================
idSoulCubeMissile::Event_ReturnToOwner
================
*/
void idSoulCubeMissile::ReturnToOwner() {
speed *= 0.65f;
killPhase = false;
returnPhase = true;
smokeFlyTime = 0;
}
/*
=================
idSoulCubeMissile::Launch
=================
*/
void idSoulCubeMissile::Launch( const idVec3 &start, const idVec3 &dir, const idVec3 &pushVelocity, const float timeSinceFire, const float launchPower, float dmgPower ) {
idVec3 newStart;
idVec3 offs;
idEntity *ownerEnt;
// push it out a little
newStart = start + dir * spawnArgs.GetFloat( "launchDist" );
offs = spawnArgs.GetVector( "launchOffset", "0 0 -4" );
newStart += offs;
idGuidedProjectile::Launch( newStart, dir, pushVelocity, timeSinceFire, launchPower, dmgPower );
if ( enemy.GetEntity() == NULL || !enemy.GetEntity()->IsType( idActor::Type ) ) {
destOrg = start + dir * 256.0f;
} else {
destOrg.Zero();
}
physicsObj.SetClipMask( 0 ); // never collide.. think routine will decide when to detonate
startingVelocity = spawnArgs.GetVector( "startingVelocity", "15 0 0" );
endingVelocity = spawnArgs.GetVector( "endingVelocity", "1500 0 0" );
accelTime = spawnArgs.GetFloat( "accelTime", "5" );
physicsObj.SetLinearVelocity( startingVelocity.Length() * physicsObj.GetAxis()[2] );
launchTime = gameLocal.time;
killPhase = false;
UpdateVisuals();
ownerEnt = owner.GetEntity();
if ( ownerEnt && ownerEnt->IsType( idPlayer::Type ) ) {
static_cast<idPlayer *>( ownerEnt )->SetSoulCubeProjectile( this );
}
}
/*
===============================================================================
idBFGProjectile
===============================================================================
*/
const idEventDef EV_RemoveBeams( "<removeBeams>", NULL );
CLASS_DECLARATION( idProjectile, idBFGProjectile )
EVENT( EV_RemoveBeams, idBFGProjectile::Event_RemoveBeams )
END_CLASS
/*
=================
idBFGProjectile::idBFGProjectile
=================
*/
idBFGProjectile::idBFGProjectile() {
memset( &secondModel, 0, sizeof( secondModel ) );
secondModelDefHandle = -1;
nextDamageTime = 0;
}
/*
=================
idBFGProjectile::~idBFGProjectile
=================
*/
idBFGProjectile::~idBFGProjectile() {
FreeBeams();
if ( secondModelDefHandle >= 0 ) {
gameRenderWorld->FreeEntityDef( secondModelDefHandle );
secondModelDefHandle = -1;
}
}
/*
================
idBFGProjectile::Spawn
================
*/
void idBFGProjectile::Spawn( void ) {
beamTargets.Clear();
memset( &secondModel, 0, sizeof( secondModel ) );
secondModelDefHandle = -1;
const char *temp = spawnArgs.GetString( "model_two" );
if ( temp && *temp ) {
secondModel.hModel = renderModelManager->FindModel( temp );
secondModel.bounds = secondModel.hModel->Bounds( &secondModel );
secondModel.shaderParms[ SHADERPARM_RED ] =
secondModel.shaderParms[ SHADERPARM_GREEN ] =
secondModel.shaderParms[ SHADERPARM_BLUE ] =
secondModel.shaderParms[ SHADERPARM_ALPHA ] = 1.0f;
secondModel.noSelfShadow = true;
secondModel.noShadow = true;
}
nextDamageTime = 0;
damageFreq = NULL;
}
/*
================
idBFGProjectile::Save
================
*/
void idBFGProjectile::Save( idSaveGame *savefile ) const {
int i;
savefile->WriteInt( beamTargets.Num() );
for ( i = 0; i < beamTargets.Num(); i++ ) {
beamTargets[i].target.Save( savefile );
savefile->WriteRenderEntity( beamTargets[i].renderEntity );
savefile->WriteInt( beamTargets[i].modelDefHandle );
}
savefile->WriteRenderEntity( secondModel );
savefile->WriteInt( secondModelDefHandle );
savefile->WriteInt( nextDamageTime );
savefile->WriteString( damageFreq );
}
/*
================
idBFGProjectile::Restore
================
*/
void idBFGProjectile::Restore( idRestoreGame *savefile ) {
int i, num;
savefile->ReadInt( num );
beamTargets.SetNum( num );
for ( i = 0; i < num; i++ ) {
beamTargets[i].target.Restore( savefile );
savefile->ReadRenderEntity( beamTargets[i].renderEntity );
savefile->ReadInt( beamTargets[i].modelDefHandle );
if ( beamTargets[i].modelDefHandle >= 0 ) {
beamTargets[i].modelDefHandle = gameRenderWorld->AddEntityDef( &beamTargets[i].renderEntity );
}
}
savefile->ReadRenderEntity( secondModel );
savefile->ReadInt( secondModelDefHandle );
savefile->ReadInt( nextDamageTime );
savefile->ReadString( damageFreq );
if ( secondModelDefHandle >= 0 ) {
secondModelDefHandle = gameRenderWorld->AddEntityDef( &secondModel );
}
}
/*
=================
idBFGProjectile::FreeBeams
=================
*/
void idBFGProjectile::FreeBeams() {
for ( int i = 0; i < beamTargets.Num(); i++ ) {
if ( beamTargets[i].modelDefHandle >= 0 ) {
gameRenderWorld->FreeEntityDef( beamTargets[i].modelDefHandle );
beamTargets[i].modelDefHandle = -1;
}
}
idPlayer *player = gameLocal.GetLocalPlayer();
if ( player ) {
player->playerView.EnableBFGVision( false );
}
}
/*
================
idBFGProjectile::Think
================
*/
void idBFGProjectile::Think( void ) {
if ( state == LAUNCHED ) {
// update beam targets
for ( int i = 0; i < beamTargets.Num(); i++ ) {
if ( beamTargets[i].target.GetEntity() == NULL ) {
continue;
}
idPlayer *player = ( beamTargets[i].target.GetEntity()->IsType( idPlayer::Type ) ) ? static_cast<idPlayer*>( beamTargets[i].target.GetEntity() ) : NULL;
#ifdef _D3XP
// Major hack for end boss. :(
idAnimatedEntity *beamEnt;
idVec3 org;
bool forceDamage = false;
beamEnt = static_cast<idAnimatedEntity*>(beamTargets[i].target.GetEntity());
if ( !idStr::Cmp( beamEnt->GetEntityDefName(), "monster_boss_d3xp_maledict" ) ) {
SetTimeState ts( beamEnt->timeGroup );
idMat3 temp;
jointHandle_t bodyJoint;
bodyJoint = beamEnt->GetAnimator()->GetJointHandle( "Chest1" );
beamEnt->GetJointWorldTransform( bodyJoint, gameLocal.time, org, temp );
forceDamage = true;
} else {
org = beamEnt->GetPhysics()->GetAbsBounds().GetCenter();
}
#else
idVec3 org = beamTargets[i].target.GetEntity()->GetPhysics()->GetAbsBounds().GetCenter();
#endif
beamTargets[i].renderEntity.origin = GetPhysics()->GetOrigin();
beamTargets[i].renderEntity.shaderParms[ SHADERPARM_BEAM_END_X ] = org.x;
beamTargets[i].renderEntity.shaderParms[ SHADERPARM_BEAM_END_Y ] = org.y;
beamTargets[i].renderEntity.shaderParms[ SHADERPARM_BEAM_END_Z ] = org.z;
beamTargets[i].renderEntity.shaderParms[ SHADERPARM_RED ] =
beamTargets[i].renderEntity.shaderParms[ SHADERPARM_GREEN ] =
beamTargets[i].renderEntity.shaderParms[ SHADERPARM_BLUE ] =
beamTargets[i].renderEntity.shaderParms[ SHADERPARM_ALPHA ] = 1.0f;
if ( gameLocal.time > nextDamageTime ) {
bool bfgVision = true;
#ifdef _D3XP
if ( damageFreq && *(const char *)damageFreq && beamTargets[i].target.GetEntity() && ( forceDamage || beamTargets[i].target.GetEntity()->CanDamage( GetPhysics()->GetOrigin(), org ) ) ) {
#else
if ( damageFreq && *(const char *)damageFreq && beamTargets[i].target.GetEntity() && beamTargets[i].target.GetEntity()->CanDamage( GetPhysics()->GetOrigin(), org ) ) {
#endif
org = beamTargets[i].target.GetEntity()->GetPhysics()->GetOrigin() - GetPhysics()->GetOrigin();
org.Normalize();
beamTargets[i].target.GetEntity()->Damage( this, owner.GetEntity(), org, damageFreq, ( damagePower ) ? damagePower : 1.0f, INVALID_JOINT );
} else {
beamTargets[i].renderEntity.shaderParms[ SHADERPARM_RED ] =
beamTargets[i].renderEntity.shaderParms[ SHADERPARM_GREEN ] =
beamTargets[i].renderEntity.shaderParms[ SHADERPARM_BLUE ] =
beamTargets[i].renderEntity.shaderParms[ SHADERPARM_ALPHA ] = 0.0f;
bfgVision = false;
}
if ( player ) {
player->playerView.EnableBFGVision( bfgVision );
}
nextDamageTime = gameLocal.time + BFG_DAMAGE_FREQUENCY;
}
gameRenderWorld->UpdateEntityDef( beamTargets[i].modelDefHandle, &beamTargets[i].renderEntity );
}
if ( secondModelDefHandle >= 0 ) {
secondModel.origin = GetPhysics()->GetOrigin();
gameRenderWorld->UpdateEntityDef( secondModelDefHandle, &secondModel );
}
idAngles ang;
ang.pitch = ( gameLocal.time & 4095 ) * 360.0f / -4096.0f;
ang.yaw = ang.pitch;
ang.roll = 0.0f;
SetAngles( ang );
ang.pitch = ( gameLocal.time & 2047 ) * 360.0f / -2048.0f;
ang.yaw = ang.pitch;
ang.roll = 0.0f;
secondModel.axis = ang.ToMat3();
UpdateVisuals();
}
idProjectile::Think();
}
/*
=================
idBFGProjectile::Launch
=================
*/
void idBFGProjectile::Launch( const idVec3 &start, const idVec3 &dir, const idVec3 &pushVelocity, const float timeSinceFire, const float power, const float dmgPower ) {
idProjectile::Launch( start, dir, pushVelocity, 0.0f, power, dmgPower );
// dmgPower * radius is the target acquisition area
// acquisition should make sure that monsters are not dormant
// which will cut down on hitting monsters not actively fighting
// but saves on the traces making sure they are visible
// damage is not applied until the projectile explodes
idEntity * ent;
idEntity * entityList[ MAX_GENTITIES ];
int numListedEntities;
idBounds bounds;
idVec3 damagePoint;
float radius;
spawnArgs.GetFloat( "damageRadius", "512", radius );
bounds = idBounds( GetPhysics()->GetOrigin() ).Expand( radius );
float beamWidth = spawnArgs.GetFloat( "beam_WidthFly" );
const char *skin = spawnArgs.GetString( "skin_beam" );
memset( &secondModel, 0, sizeof( secondModel ) );
secondModelDefHandle = -1;
const char *temp = spawnArgs.GetString( "model_two" );
if ( temp && *temp ) {
secondModel.hModel = renderModelManager->FindModel( temp );
secondModel.bounds = secondModel.hModel->Bounds( &secondModel );
secondModel.shaderParms[ SHADERPARM_RED ] =
secondModel.shaderParms[ SHADERPARM_GREEN ] =
secondModel.shaderParms[ SHADERPARM_BLUE ] =
secondModel.shaderParms[ SHADERPARM_ALPHA ] = 1.0f;
secondModel.noSelfShadow = true;
secondModel.noShadow = true;
secondModel.origin = GetPhysics()->GetOrigin();
secondModel.axis = GetPhysics()->GetAxis();
secondModelDefHandle = gameRenderWorld->AddEntityDef( &secondModel );
}
idVec3 delta( 15.0f, 15.0f, 15.0f );
//physicsObj.SetAngularExtrapolation( extrapolation_t(EXTRAPOLATION_LINEAR|EXTRAPOLATION_NOSTOP), gameLocal.time, 0, physicsObj.GetAxis().ToAngles(), delta, ang_zero );
// get all entities touching the bounds
numListedEntities = gameLocal.clip.EntitiesTouchingBounds( bounds, CONTENTS_BODY, entityList, MAX_GENTITIES );
for ( int e = 0; e < numListedEntities; e++ ) {
ent = entityList[ e ];
assert( ent );
if ( ent == this || ent == owner.GetEntity() || ent->IsHidden() || !ent->IsActive() || !ent->fl.takedamage || ent->health <= 0 || !ent->IsType( idActor::Type ) ) {
continue;
}
if ( !ent->CanDamage( GetPhysics()->GetOrigin(), damagePoint ) ) {
continue;
}
if ( ent->IsType( idPlayer::Type ) ) {
idPlayer *player = static_cast<idPlayer*>( ent );
player->playerView.EnableBFGVision( true );
}
beamTarget_t bt;
memset( &bt.renderEntity, 0, sizeof( renderEntity_t ) );
bt.renderEntity.origin = GetPhysics()->GetOrigin();
bt.renderEntity.axis = GetPhysics()->GetAxis();
bt.renderEntity.shaderParms[ SHADERPARM_BEAM_WIDTH ] = beamWidth;
bt.renderEntity.shaderParms[ SHADERPARM_RED ] = 1.0f;
bt.renderEntity.shaderParms[ SHADERPARM_GREEN ] = 1.0f;
bt.renderEntity.shaderParms[ SHADERPARM_BLUE ] = 1.0f;
bt.renderEntity.shaderParms[ SHADERPARM_ALPHA ] = 1.0f;
bt.renderEntity.shaderParms[ SHADERPARM_DIVERSITY] = gameLocal.random.CRandomFloat() * 0.75;
bt.renderEntity.hModel = renderModelManager->FindModel( "_beam" );
bt.renderEntity.callback = NULL;
bt.renderEntity.numJoints = 0;
bt.renderEntity.joints = NULL;
bt.renderEntity.bounds.Clear();
bt.renderEntity.customSkin = declManager->FindSkin( skin );
bt.target = ent;
bt.modelDefHandle = gameRenderWorld->AddEntityDef( &bt.renderEntity );
beamTargets.Append( bt );
}
#ifdef _D3XP
// Major hack for end boss. :(
idAnimatedEntity *maledict = static_cast<idAnimatedEntity*>(gameLocal.FindEntity( "monster_boss_d3xp_maledict_1" ));
if ( maledict ) {
SetTimeState ts( maledict->timeGroup );
idVec3 realPoint;
idMat3 temp;
float dist;
jointHandle_t bodyJoint;
bodyJoint = maledict->GetAnimator()->GetJointHandle( "Chest1" );
maledict->GetJointWorldTransform( bodyJoint, gameLocal.time, realPoint, temp );
dist = idVec3( realPoint - GetPhysics()->GetOrigin() ).Length();
if ( dist < radius ) {
beamTarget_t bt;
memset( &bt.renderEntity, 0, sizeof( renderEntity_t ) );
bt.renderEntity.origin = GetPhysics()->GetOrigin();
bt.renderEntity.axis = GetPhysics()->GetAxis();
bt.renderEntity.shaderParms[ SHADERPARM_BEAM_WIDTH ] = beamWidth;
bt.renderEntity.shaderParms[ SHADERPARM_RED ] = 1.0f;
bt.renderEntity.shaderParms[ SHADERPARM_GREEN ] = 1.0f;
bt.renderEntity.shaderParms[ SHADERPARM_BLUE ] = 1.0f;
bt.renderEntity.shaderParms[ SHADERPARM_ALPHA ] = 1.0f;
bt.renderEntity.shaderParms[ SHADERPARM_DIVERSITY] = gameLocal.random.CRandomFloat() * 0.75;
bt.renderEntity.hModel = renderModelManager->FindModel( "_beam" );
bt.renderEntity.callback = NULL;
bt.renderEntity.numJoints = 0;
bt.renderEntity.joints = NULL;
bt.renderEntity.bounds.Clear();
bt.renderEntity.customSkin = declManager->FindSkin( skin );
bt.target = maledict;
bt.modelDefHandle = gameRenderWorld->AddEntityDef( &bt.renderEntity );
beamTargets.Append( bt );
numListedEntities++;
}
}
#endif
if ( numListedEntities ) {
StartSound( "snd_beam", SND_CHANNEL_BODY2, 0, false, NULL );
}
damageFreq = spawnArgs.GetString( "def_damageFreq" );
nextDamageTime = gameLocal.time + BFG_DAMAGE_FREQUENCY;
UpdateVisuals();
}
/*
================
idProjectile::Event_RemoveBeams
================
*/
void idBFGProjectile::Event_RemoveBeams() {
FreeBeams();
UpdateVisuals();
}
/*
================
idProjectile::Explode
================
*/
void idBFGProjectile::Explode( const trace_t &collision, idEntity *ignore ) {
int i;
idVec3 dmgPoint;
idVec3 dir;
float beamWidth;
float damageScale;
const char *damage;
idPlayer * player;
idEntity * ownerEnt;
ownerEnt = owner.GetEntity();
if ( ownerEnt && ownerEnt->IsType( idPlayer::Type ) ) {
player = static_cast< idPlayer * >( ownerEnt );
} else {
player = NULL;
}
beamWidth = spawnArgs.GetFloat( "beam_WidthExplode" );
damage = spawnArgs.GetString( "def_damage" );
for ( i = 0; i < beamTargets.Num(); i++ ) {
if ( ( beamTargets[i].target.GetEntity() == NULL ) || ( ownerEnt == NULL ) ) {
continue;
}
if ( !beamTargets[i].target.GetEntity()->CanDamage( GetPhysics()->GetOrigin(), dmgPoint ) ) {
continue;
}
beamTargets[i].renderEntity.shaderParms[SHADERPARM_BEAM_WIDTH] = beamWidth;
// if the hit entity takes damage
if ( damagePower ) {
damageScale = damagePower;
} else {
damageScale = 1.0f;
}
// if the projectile owner is a player
if ( player ) {
// if the projectile hit an actor
if ( beamTargets[i].target.GetEntity()->IsType( idActor::Type ) ) {
player->SetLastHitTime( gameLocal.time );
player->AddProjectileHits( 1 );
damageScale *= player->PowerUpModifier( PROJECTILE_DAMAGE );
}
}
if ( damage[0] && ( beamTargets[i].target.GetEntity()->entityNumber > gameLocal.numClients - 1 ) ) {
dir = beamTargets[i].target.GetEntity()->GetPhysics()->GetOrigin() - GetPhysics()->GetOrigin();
dir.Normalize();
beamTargets[i].target.GetEntity()->Damage( this, ownerEnt, dir, damage, damageScale, ( collision.c.id < 0 ) ? CLIPMODEL_ID_TO_JOINT_HANDLE( collision.c.id ) : INVALID_JOINT );
}
}
if ( secondModelDefHandle >= 0 ) {
gameRenderWorld->FreeEntityDef( secondModelDefHandle );
secondModelDefHandle = -1;
}
if ( ignore == NULL ) {
projectileFlags.noSplashDamage = true;
}
if ( !gameLocal.isClient ) {
if ( ignore != NULL ) {
PostEventMS( &EV_RemoveBeams, 750 );
} else {
PostEventMS( &EV_RemoveBeams, 0 );
}
}
return idProjectile::Explode( collision, ignore );
}
/*
===============================================================================
idDebris
===============================================================================
*/
CLASS_DECLARATION( idEntity, idDebris )
EVENT( EV_Explode, idDebris::Event_Explode )
EVENT( EV_Fizzle, idDebris::Event_Fizzle )
END_CLASS
/*
================
idDebris::Spawn
================
*/
void idDebris::Spawn( void ) {
owner = NULL;
smokeFly = NULL;
smokeFlyTime = 0;
}
/*
================
idDebris::Create
================
*/
void idDebris::Create( idEntity *owner, const idVec3 &start, const idMat3 &axis ) {
Unbind();
GetPhysics()->SetOrigin( start );
GetPhysics()->SetAxis( axis );
GetPhysics()->SetContents( 0 );
this->owner = owner;
smokeFly = NULL;
smokeFlyTime = 0;
sndBounce = NULL;
#ifdef _D3XP
noGrab = true;
#endif
UpdateVisuals();
}
/*
=================
idDebris::idDebris
=================
*/
idDebris::idDebris( void ) {
owner = NULL;
smokeFly = NULL;
smokeFlyTime = 0;
sndBounce = NULL;
}
/*
=================
idDebris::~idDebris
=================
*/
idDebris::~idDebris( void ) {
}
/*
=================
idDebris::Save
=================
*/
void idDebris::Save( idSaveGame *savefile ) const {
owner.Save( savefile );
savefile->WriteStaticObject( physicsObj );
savefile->WriteParticle( smokeFly );
savefile->WriteInt( smokeFlyTime );
savefile->WriteSoundShader( sndBounce );
}
/*
=================
idDebris::Restore
=================
*/
void idDebris::Restore( idRestoreGame *savefile ) {
owner.Restore( savefile );
savefile->ReadStaticObject( physicsObj );
RestorePhysics( &physicsObj );
savefile->ReadParticle( smokeFly );
savefile->ReadInt( smokeFlyTime );
savefile->ReadSoundShader( sndBounce );
}
/*
=================
idDebris::Launch
=================
*/
void idDebris::Launch( void ) {
float fuse;
idVec3 velocity;
idAngles angular_velocity;
float linear_friction;
float angular_friction;
float contact_friction;
float bounce;
float mass;
float gravity;
idVec3 gravVec;
bool randomVelocity;
idMat3 axis;
renderEntity.shaderParms[ SHADERPARM_TIMEOFFSET ] = -MS2SEC( gameLocal.time );
spawnArgs.GetVector( "velocity", "0 0 0", velocity );
spawnArgs.GetAngles( "angular_velocity", "0 0 0", angular_velocity );
linear_friction = spawnArgs.GetFloat( "linear_friction" );
angular_friction = spawnArgs.GetFloat( "angular_friction" );
contact_friction = spawnArgs.GetFloat( "contact_friction" );
bounce = spawnArgs.GetFloat( "bounce" );
mass = spawnArgs.GetFloat( "mass" );
gravity = spawnArgs.GetFloat( "gravity" );
fuse = spawnArgs.GetFloat( "fuse" );
randomVelocity = spawnArgs.GetBool ( "random_velocity" );
if ( mass <= 0 ) {
gameLocal.Error( "Invalid mass on '%s'\n", GetEntityDefName() );
}
if ( randomVelocity ) {
velocity.x *= gameLocal.random.RandomFloat() + 0.5f;
velocity.y *= gameLocal.random.RandomFloat() + 0.5f;
velocity.z *= gameLocal.random.RandomFloat() + 0.5f;
}
if ( health ) {
fl.takedamage = true;
}
gravVec = gameLocal.GetGravity();
gravVec.NormalizeFast();
axis = GetPhysics()->GetAxis();
Unbind();
physicsObj.SetSelf( this );
// check if a clip model is set
const char *clipModelName;
idTraceModel trm;
spawnArgs.GetString( "clipmodel", "", &clipModelName );
if ( !clipModelName[0] ) {
clipModelName = spawnArgs.GetString( "model" ); // use the visual model
}
// load the trace model
if ( !collisionModelManager->TrmFromModel( clipModelName, trm ) ) {
// default to a box
physicsObj.SetClipBox( renderEntity.bounds, 1.0f );
} else {
physicsObj.SetClipModel( new idClipModel( trm ), 1.0f );
}
physicsObj.GetClipModel()->SetOwner( owner.GetEntity() );
physicsObj.SetMass( mass );
physicsObj.SetFriction( linear_friction, angular_friction, contact_friction );
if ( contact_friction == 0.0f ) {
physicsObj.NoContact();
}
physicsObj.SetBouncyness( bounce );
physicsObj.SetGravity( gravVec * gravity );
physicsObj.SetContents( 0 );
physicsObj.SetClipMask( MASK_SOLID | CONTENTS_MOVEABLECLIP );
physicsObj.SetLinearVelocity( axis[ 0 ] * velocity[ 0 ] + axis[ 1 ] * velocity[ 1 ] + axis[ 2 ] * velocity[ 2 ] );
physicsObj.SetAngularVelocity( angular_velocity.ToAngularVelocity() * axis );
physicsObj.SetOrigin( GetPhysics()->GetOrigin() );
physicsObj.SetAxis( axis );
SetPhysics( &physicsObj );
if ( !gameLocal.isClient ) {
if ( fuse <= 0 ) {
// run physics for 1 second
RunPhysics();
PostEventMS( &EV_Remove, 0 );
} else if ( spawnArgs.GetBool( "detonate_on_fuse" ) ) {
if ( fuse < 0.0f ) {
fuse = 0.0f;
}
RunPhysics();
PostEventSec( &EV_Explode, fuse );
} else {
if ( fuse < 0.0f ) {
fuse = 0.0f;
}
PostEventSec( &EV_Fizzle, fuse );
}
}
StartSound( "snd_fly", SND_CHANNEL_BODY, 0, false, NULL );
smokeFly = NULL;
smokeFlyTime = 0;
const char *smokeName = spawnArgs.GetString( "smoke_fly" );
if ( *smokeName != '\0' ) {
smokeFly = static_cast<const idDeclParticle *>( declManager->FindType( DECL_PARTICLE, smokeName ) );
smokeFlyTime = gameLocal.time;
gameLocal.smokeParticles->EmitSmoke( smokeFly, smokeFlyTime, gameLocal.random.CRandomFloat(), GetPhysics()->GetOrigin(), GetPhysics()->GetAxis(), timeGroup /*_D3XP*/ );
}
const char *sndName = spawnArgs.GetString( "snd_bounce" );
if ( *sndName != '\0' ) {
sndBounce = declManager->FindSound( sndName );
}
UpdateVisuals();
}
/*
================
idDebris::Think
================
*/
void idDebris::Think( void ) {
// run physics
RunPhysics();
Present();
if ( smokeFly && smokeFlyTime ) {
if ( !gameLocal.smokeParticles->EmitSmoke( smokeFly, smokeFlyTime, gameLocal.random.CRandomFloat(), GetPhysics()->GetOrigin(), GetPhysics()->GetAxis(), timeGroup /*_D3XP*/ ) ) {
smokeFlyTime = 0;
}
}
}
/*
================
idDebris::Killed
================
*/
void idDebris::Killed( idEntity *inflictor, idEntity *attacker, int damage, const idVec3 &dir, int location ) {
if ( spawnArgs.GetBool( "detonate_on_death" ) ) {
Explode();
} else {
Fizzle();
}
}
/*
=================
idDebris::Collide
=================
*/
bool idDebris::Collide( const trace_t &collision, const idVec3 &velocity ) {
if ( sndBounce != NULL ) {
StartSoundShader( sndBounce, SND_CHANNEL_BODY, 0, false, NULL );
}
sndBounce = NULL;
return false;
}
/*
================
idDebris::Fizzle
================
*/
void idDebris::Fizzle( void ) {
if ( IsHidden() ) {
// already exploded
return;
}
StopSound( SND_CHANNEL_ANY, false );
StartSound( "snd_fizzle", SND_CHANNEL_BODY, 0, false, NULL );
// fizzle FX
const char *smokeName = spawnArgs.GetString( "smoke_fuse" );
if ( *smokeName != '\0' ) {
smokeFly = static_cast<const idDeclParticle *>( declManager->FindType( DECL_PARTICLE, smokeName ) );
smokeFlyTime = gameLocal.time;
gameLocal.smokeParticles->EmitSmoke( smokeFly, smokeFlyTime, gameLocal.random.CRandomFloat(), GetPhysics()->GetOrigin(), GetPhysics()->GetAxis(), timeGroup /*_D3XP*/ );
}
fl.takedamage = false;
physicsObj.SetContents( 0 );
physicsObj.PutToRest();
Hide();
if ( gameLocal.isClient ) {
return;
}
CancelEvents( &EV_Fizzle );
PostEventMS( &EV_Remove, 0 );
}
/*
================
idDebris::Explode
================
*/
void idDebris::Explode( void ) {
if ( IsHidden() ) {
// already exploded
return;
}
StopSound( SND_CHANNEL_ANY, false );
StartSound( "snd_explode", SND_CHANNEL_BODY, 0, false, NULL );
Hide();
// these must not be "live forever" particle systems
smokeFly = NULL;
smokeFlyTime = 0;
const char *smokeName = spawnArgs.GetString( "smoke_detonate" );
if ( *smokeName != '\0' ) {
smokeFly = static_cast<const idDeclParticle *>( declManager->FindType( DECL_PARTICLE, smokeName ) );
smokeFlyTime = gameLocal.time;
gameLocal.smokeParticles->EmitSmoke( smokeFly, smokeFlyTime, gameLocal.random.CRandomFloat(), GetPhysics()->GetOrigin(), GetPhysics()->GetAxis(), timeGroup /*_D3XP*/ );
}
fl.takedamage = false;
physicsObj.SetContents( 0 );
physicsObj.PutToRest();
CancelEvents( &EV_Explode );
PostEventMS( &EV_Remove, 0 );
}
/*
================
idDebris::Event_Explode
================
*/
void idDebris::Event_Explode( void ) {
Explode();
}
/*
================
idDebris::Event_Fizzle
================
*/
void idDebris::Event_Fizzle( void ) {
Fizzle();
}
Reference in a new issue View git blame Copy permalink