tiberium/CnC_Renegade
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
This repository has been archived on 2025-02-27. You can view files and clone it, but cannot push or open issues or pull requests.
CnC_Renegade/Code/Combat/bullet.cpp

1074 lines
33 KiB
C++
Raw Permalink Normal View History

Initial commit of Command & Conquer Renegade source code.
2025-02-27 16:39:46 +00:00
/*
** Command & Conquer Renegade(tm)
** Copyright 2025 Electronic Arts Inc.
**
** This program 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.
**
** This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
/***********************************************************************************************
*** Confidential - Westwood Studios ***
***********************************************************************************************
* *
* Project Name : Commando *
* *
* $Archive:: /Commando/Code/Combat/bullet.cpp $*
* *
* $Author:: Byon_g $*
* *
* $Modtime:: 3/13/02 5:22p $*
* *
* $Revision:: 164 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "bullet.h"
#include "projectile.h"
#include "combat.h" // for collision groups (should be damage.h?)
#include "pscene.h"
#include "weaponmanager.h"
#include "assets.h"
#include "debug.h"
#include "armedgameobj.h"
#include "crandom.h"
#include "surfaceeffects.h"
#include "mesh.h"
#include "wwaudio.h"
#include "explosion.h"
#include "building.h"
#include "persistfactory.h"
#include "wwphysids.h"
#include "damageablestaticphys.h"
#include "wwprofile.h"
#include "part_emt.h"
#include "realcrc.h"
#include "soldier.h"
#include "segline.h"
#include "timeddecophys.h"
#include "simplegameobj.h"
#include "c4.h"
/*
** Constants for this module
*/
const float _INSTANT_BULLET_THRESHHOLD = 400; // If speed is >= _INSTANT_BULLET_THRESHHOLD m/s, treat it an an instant bullet
/**
** BeamEffectManagerClass
** This is a static object that simply manages the active beam effect. Its job is to cache un-used beams
** so that we aren't allocating them at run time and to add new beam effects to the scene when needed.
*/
class BeamEffectManagerClass : public CombatPhysObserverClass
{
public:
void Init( void ) {}
void Shutdown( void );
/*
** Create a beam effect and put it in the scene. Whenever possible, this function
** tries to recycle a previously created beam effect
*/
void Create_Beam_Effect(const AmmoDefinitionClass * ammo_def,const Vector3 & p0,const Vector3 & p1);
/*
** PhysObserver Interface - whenever a beam expires, we put it into a list so we can
** recycle it next time we need a beam effect
*/
virtual void Object_Removed_From_Scene(PhysClass * observed_obj);
private:
void Internal_Get_New_Beam(SegmentedLineClass ** beam_model,TimedDecorationPhysClass ** beam_wrapper);
RefMultiListClass<TimedDecorationPhysClass> UnusedBeamList;
};
static BeamEffectManagerClass _TheBeamEffectManager;
void BeamEffectManagerClass::Shutdown( void )
{
while (UnusedBeamList.Peek_Head()) {
UnusedBeamList.Release_Head();
}
}
void BeamEffectManagerClass::Create_Beam_Effect(const AmmoDefinitionClass * ammo_def,const Vector3 & p0,const Vector3 & p1)
{
SegmentedLineClass * beam_model = NULL;
TimedDecorationPhysClass * beam_wrapper = NULL;
Internal_Get_New_Beam(&beam_model,&beam_wrapper);
// line effect from "start" to "data.Position"
static Vector3 points[2];
points[0] = p0;
points[1] = p1;
const int BEAM_SUBDIVISION = 4;
const float BASE_AMPLITUDE = 0.3f;
const float AMPLITUDE_PER_METER = 0.04f;
/*
** User controlled settings
*/
TextureClass * beam_texture = Get_Texture_From_Filename(ammo_def->BeamTexture);
beam_model->Set_Texture(beam_texture);
REF_PTR_RELEASE(beam_texture);
beam_model->Set_Points(2,points);
beam_model->Set_Width(ammo_def->BeamWidth);
beam_model->Set_Color(ammo_def->BeamColor);
beam_model->Set_UV_Offset_Rate(Vector2(0,1.0f / ammo_def->BeamTime));
if (ammo_def->BeamSubdivisionEnabled) {
beam_model->Set_Noise_Amplitude((BASE_AMPLITUDE + AMPLITUDE_PER_METER * (p1-p0).Quick_Length()) * ammo_def->BeamSubdivisionScale);
beam_model->Set_Subdivision_Levels(BEAM_SUBDIVISION);
} else {
beam_model->Set_Noise_Amplitude(0.0f);
beam_model->Set_Subdivision_Levels(0);
}
/*
** Constants; I don't let the user control these for now
*/
beam_model->Set_Texture_Tile_Factor(1.0f); // Only relevant for TILED_TEXTURE_MAP mode
beam_model->Set_Texture_Mapping_Mode(SegLineRendererClass::UNIFORM_WIDTH_TEXTURE_MAP);
beam_model->Set_Opacity(1.0f);
beam_model->Set_Shader(ShaderClass::_PresetAdditiveShader);
beam_model->Set_Merge_Abort_Factor(1.0f);
beam_model->Set_Merge_Intersections(false);
beam_model->Set_Disable_Sorting(false);
beam_model->Set_Freeze_Random(ammo_def->BeamSubdivisionFrozen);
beam_model->Set_End_Caps(ammo_def->BeamEndCaps);
beam_model->Reset_Line();
beam_wrapper->Set_Lifetime(ammo_def->BeamTime);
beam_wrapper->Set_Transform(Matrix3D(1));
beam_wrapper->Enable_Is_Pre_Lit(true);
COMBAT_SCENE->Add_Dynamic_Object(beam_wrapper);
REF_PTR_RELEASE(beam_wrapper);
REF_PTR_RELEASE(beam_model);
REF_PTR_RELEASE(beam_texture);
}
void BeamEffectManagerClass::Object_Removed_From_Scene(PhysClass * observed_obj)
{
/*
** One of the "beams" that we are observing expired and was removed from the scene so
** lets put it in the list for future re-use
*/
UnusedBeamList.Add((TimedDecorationPhysClass *)observed_obj);
}
void BeamEffectManagerClass::Internal_Get_New_Beam(SegmentedLineClass ** set_beam_model,TimedDecorationPhysClass ** set_beam_wrapper)
{
if (UnusedBeamList.Is_Empty()) {
SegmentedLineClass * beam_model = NEW_REF(SegmentedLineClass,());
TimedDecorationPhysClass * beam_wrapper = NEW_REF(TimedDecorationPhysClass,());
beam_wrapper->Enable_Dont_Save(true);
beam_wrapper->Set_Collision_Group(UNCOLLIDEABLE_GROUP);
beam_wrapper->Set_Model(beam_model);
beam_wrapper->Set_Observer(this);
*set_beam_model = beam_model;
*set_beam_wrapper = beam_wrapper; // refs returned to the caller
} else {
*set_beam_wrapper = UnusedBeamList.Remove_Head(); // refs returned to the caller
*set_beam_model = (SegmentedLineClass *)((*set_beam_wrapper)->Get_Model());
}
}
/*
** Core Bullet Data for simulation
*/
class BulletDataClass {
public:
BulletDataClass( const AmmoDefinitionClass * def = NULL, const ArmedGameObj * owner = NULL,
const Vector3 & position = Vector3(0,0,0), const Vector3 & velocity = Vector3(0,0,0) ) :
AmmoDefinition( def ),
Owner( owner ),
Position( position ),
Velocity( velocity ),
SoftPierceCount( 0 ),
Destroy( false ),
DidExplode( false ),
LastHitID( 0 ),
GrenadeSafetyTimer( 0 )
{}
ArmedGameObj * Get_Owner( void ) const { return (ArmedGameObj *)Owner.Get_Ptr(); }
CollisionReactionType Bullet_Collision_Occurred( const CollisionEventClass & event );
ExpirationReactionType Bullet_Expired();
const AmmoDefinitionClass *AmmoDefinition;
GameObjReference Owner;
Vector3 Position;
Vector3 Velocity;
int SoftPierceCount;
bool Destroy;
bool DidExplode;
int LastHitID;
float GrenadeSafetyTimer;
};
/*
** Bullet_Collision_Occured
*/
CollisionReactionType BulletDataClass::Bullet_Collision_Occurred( const CollisionEventClass & event )
{
WWPROFILE( "Bullet Collision Occurred" );
WWASSERT(event.OtherObj);
WWASSERT(event.CollisionResult != NULL);
// WWDEBUG_SAY(( "Bullet Collision\n" ));
//
// Pre-calculate some useful variables
//
CollisionReactionType return_value = COLLISION_REACTION_DEFAULT;
OffenseObjectClass offense( AmmoDefinition->Damage, (int)AmmoDefinition->Warhead, Get_Owner() );
offense.EnableClientDamage = true; // Only bullets apply to client damage;
const Vector3 & collision_point = event.CollisionResult->ContactPoint;
const Vector3 & collision_normal = event.CollisionResult->Normal;
PhysicalGameObj * other = NULL;
BuildingGameObj * building = NULL;
if ( event.OtherObj->Get_Observer() != NULL ) {
other = ((CombatPhysObserverClass *)event.OtherObj->Get_Observer())->As_PhysicalGameObj();
building = ((CombatPhysObserverClass *)event.OtherObj->Get_Observer())->As_BuildingGameObj();
}
//
// If the bullet hits its owner or its owner's vehicle, allow it to continue
// Also, if it is a simple "Hidden Object", allow the bullet to continue
//
if ( other != NULL && Get_Owner() != NULL ) {
SimpleGameObj * simple = other->As_SimpleGameObj();
VehicleGameObj * vehicle = other->As_VehicleGameObj();
SoldierGameObj * soldier = Get_Owner()->As_SoldierGameObj();
if ( vehicle != NULL && soldier != NULL && vehicle == soldier->Get_Vehicle() ) {
// Debug_Say(( "Bullet Hitting its owner's vehicle\n" ));
return COLLISION_REACTION_NO_BOUNCE;
}
if ( other == Get_Owner() ) {
// Debug_Say(( "Bullet Hitting its owner\n" ));
return COLLISION_REACTION_NO_BOUNCE;
}
if ((simple != NULL) && (simple->Is_Hidden_Object())) {
return COLLISION_REACTION_NO_BOUNCE;
}
}
//
// Apply Graphical Effects.
// If the mesh is shatterable it is shattered, Apply a surface effect depending on the surface type
// that was collided with. In the case that the mesh was shattered, we disable surface effect decals.
//
bool shattered = false;
if ((event.CollidedRenderObj != NULL) && (event.CollidedRenderObj->Class_ID() == RenderObjClass::CLASSID_MESH)) {
MeshClass * mesh = (MeshClass *)event.CollidedRenderObj;
if ((mesh->Get_W3D_Flags() & W3D_MESH_FLAG_SHATTERABLE) && (mesh->Is_Not_Hidden_At_All())) {
PhysicsSceneClass::Get_Instance()->Shatter_Mesh( mesh,
collision_point,
collision_normal,
Velocity );
// remeber that we shattered the mesh so that we don't create decals later
shattered = true;
// Bullets always pass through shattered objects because we sometimes have two-layered
// windows that have different materials on the two sides. We don't want bullets to ever
// shatter only one "side" of a window!
return_value = COLLISION_REACTION_NO_BOUNCE;
}
}
// Ignore backfaces (after shattering for windows)
float dot = Vector3::Dot_Product( event.CollisionResult->Normal, Velocity );
if ( dot > 0 ) {
return COLLISION_REACTION_NO_BOUNCE;
}
//
// Apply Damage
// There are several types of objects that can be damaged: normal dynamic game objects, damageable static
// physics objects, and buildings. A building is damaged whenever any of its meshes or aggregates are
// hit by a bullet.
// Also, we only apply damage if the mesh wasn't shattered. Bullets pretend like nothing happened
// if they shatter something.
//
if (!shattered) {
const char * collided_obj_name = NULL;
if ( event.CollidedRenderObj != NULL ) {
collided_obj_name = event.CollidedRenderObj->Get_Name();
}
if ( other ) { // if hitting a game object,
if ( other->Get_ID() == LastHitID ) {
// Debug_Say(( "Double Hit\n" ));
return COLLISION_REACTION_NO_BOUNCE;
}
if ( GrenadeSafetyTimer > 0 ) {
// only if the other is not an enemy
if ( other && Get_Owner() && !other->Is_Enemy( Get_Owner() ) ) {
return COLLISION_REACTION_DEFAULT; // Just bounce
}
}
LastHitID = other->Get_ID();
// Apply Bullet Damage to a game object
// Allow it to happen for clients, so we can get the repair effect
// if ( CombatManager::I_Am_Server() ) {
other->Apply_Damage_Extended( offense, 1.0f, Velocity, collided_obj_name );
// If the bullet is hitting C4, also apply damage to the object the C4 is
// attached to. This is a fix for the "C4 armor" exploit.
if (other->As_C4GameObj() != NULL) {
ScriptableGameObj * host = other->As_C4GameObj()->Get_Stuck_Object();
if ((host != NULL) && (host->As_PhysicalGameObj() != NULL)) {
host->As_PhysicalGameObj()->Apply_Damage_Extended( offense, 1.0f, Velocity, NULL );
}
}
// }
if ( ( !other->Is_Soft() ) ||
( ++SoftPierceCount >= AmmoDefinition->SoftPierceLimit ) ) {
if ( AmmoDefinition->ExplosionDefID ) {
ExplosionManager::Create_Explosion_At( AmmoDefinition->ExplosionDefID, collision_point, Get_Owner(), -collision_normal, other );
}
Destroy = true;
return_value = COLLISION_REACTION_STOP_MOTION;
} else {
return_value = COLLISION_REACTION_NO_BOUNCE;
}
} else { // if hitting terain
if ( GrenadeSafetyTimer > 0 ) {
Debug_Say(( "Safety\n" ));
return COLLISION_REACTION_DEFAULT; // Just bounce
}
// If hitting a building, apply damage to it
if ( building != NULL ) { // && CombatManager::I_Am_Server() ) {
building->Apply_Damage_Building( offense, event.OtherObj->As_StaticPhysClass() );
}
// Check for damage to a DamageableStaticPhys object
// For now I'm using the persist factory chunk-ID for RTTI... If a better solution
// turns up we should change this.
if ( event.OtherObj->Get_Factory().Chunk_ID() == PHYSICS_CHUNKID_DAMAGEABLESTATICPHYS
// && CombatManager::I_Am_Server()
)
{
DamageableStaticPhysClass * damphys = (DamageableStaticPhysClass *)event.OtherObj;
OffenseObjectClass offense( AmmoDefinition->Damage, (int)AmmoDefinition->Warhead, Get_Owner() );
offense.EnableClientDamage = true; // Only bullets apply to client damage;
damphys->Apply_Damage_Static( offense );
}
// check for a non-stopping surface
if ( !SurfaceEffectsManager::Does_Surface_Stop_Bullets( event.CollisionResult->SurfaceType ) ) {
return_value = COLLISION_REACTION_NO_BOUNCE;
} else {
// If the ammo explodes when it hits terrain, then create an explosion and kill the bullet
if ( AmmoDefinition->TerrainActivated ) {
if ( AmmoDefinition->ExplosionDefID ) {
ExplosionManager::Create_Explosion_At( AmmoDefinition->ExplosionDefID, collision_point, Get_Owner(), -collision_normal, building );
DidExplode = true;
}
Destroy = true;
return_value = COLLISION_REACTION_STOP_MOTION;
}
}
}
}
// Only make a bullet hit if it doesn't make an explosion
if ( !DidExplode ) {
Matrix3D surface_tm;
surface_tm.Look_At(collision_point,collision_point-collision_normal,FreeRandom.Get_Float(0,DEG_TO_RADF(360)));
int my_type = AmmoDefinition->HitterType;
bool allow_decals = (shattered == false);
if ( (float)AmmoDefinition->Damage < 0.0f ) {
allow_decals = false;
}
SurfaceEffectsManager::Apply_Effect( event.CollisionResult->SurfaceType, my_type, surface_tm, event.OtherObj, Get_Owner(), allow_decals );
}
return return_value;
}
ExpirationReactionType BulletDataClass::Bullet_Expired( void )
{
Destroy = true;
if ( AmmoDefinition->TimeActivated && AmmoDefinition->ExplosionDefID && !DidExplode ) {
ExplosionManager::Create_Explosion_At( AmmoDefinition->ExplosionDefID, Position, Get_Owner() );
}
return EXPIRATION_DENIED; // Don't let it die, I'll pull it from the scene later
}
/*
** BulletClass (for non-instant bullets)
*/
class BulletClass : public CombatPhysObserverClass, public MultiListObjectClass, public PostLoadableClass {
public:
~BulletClass( void );
void Init( const BulletDataClass & data, float progress_time, const Vector3 & target, DamageableGameObj * target_object = NULL );
void Shutdown( void );
void Think( void );
// Save / Load
virtual bool Save( ChunkSaveClass & csave );
virtual bool Load( ChunkLoadClass & cload );
virtual void On_Post_Load(void);
bool Is_Valid( void ) { return BulletData.AmmoDefinition != NULL; }
// Collision
virtual CollisionReactionType Collision_Occurred( const CollisionEventClass & event );
virtual ExpirationReactionType Object_Expired( PhysClass * observed_obj );
private:
BulletDataClass BulletData;
ProjectileClass * Projectile; // for physics
Vector3 TargetVector;
GameObjReference TargetObject;
float TrackingErrorTimer;
Vector3 TrackingError;
long ModelNameCRC;
BulletClass( void );
friend class BulletManager;
};
BulletClass::BulletClass( void ) :
Projectile( NULL ),
TargetVector( 0,0,0 ),
TrackingErrorTimer( 0 ),
TrackingError( 0,0,0 ),
ModelNameCRC( 0 )
{
WWASSERT( Projectile == NULL );
Projectile = NEW_REF( ProjectileClass, () );
Projectile->Set_Collision_Group( BULLET_COLLISION_GROUP );
}
BulletClass::~BulletClass( void )
{
if ( Projectile != NULL ) {
Projectile->Set_Observer(NULL);
Projectile->Release_Ref();
Projectile = NULL;
}
}
void BulletClass::Init( const BulletDataClass & data, float progress_time, const Vector3 & target, DamageableGameObj * target_object )
{
WWPROFILE( "Bullet Init" );
BulletData.AmmoDefinition = data.AmmoDefinition;
BulletData.Owner = data.Get_Owner();
BulletData.SoftPierceCount = data.SoftPierceCount;
BulletData.Destroy = data.Destroy;
BulletData.LastHitID = 0; // We haven't hit anyone yet.
BulletData.DidExplode = false;
BulletData.GrenadeSafetyTimer = data.GrenadeSafetyTimer;
if ( data.AmmoDefinition ) {
BulletData.GrenadeSafetyTimer = data.AmmoDefinition->GrenadeSafetyTime;
}
TargetVector = target;
TargetObject = target_object;
TrackingErrorTimer = 0;
TrackingError = Vector3( 0,0,0 );
Projectile->Set_Observer( this );
Projectile->Set_Bounce_Count( BulletData.AmmoDefinition->MaxBounces );
if ( BulletData.AmmoDefinition ) {
Projectile->Set_Gravity_Multiplier( BulletData.AmmoDefinition->Gravity );
Projectile->Set_Elasticity( BulletData.AmmoDefinition->Elasticity );
}
Projectile->Enable_Is_Pre_Lit(true); // bullets don't get lighting.
if ( Projectile->Peek_Model() != NULL &&
Projectile->Peek_Model()->Get_Name() != NULL &&
BulletData.AmmoDefinition->ModelName.Compare_No_Case( Projectile->Peek_Model()->Get_Name() ) == 0 ) {
// We don't need to do anything
} else {
RenderObjClass * model = NULL;
model = WW3DAssetManager::Get_Instance ()->Create_Render_Obj( BulletData.AmmoDefinition->ModelName );
// If no name is given, lets create the NULL render obj
if ( model == NULL ) {
Debug_Say(( "Bullet Not Found \"%s\" \n", BulletData.AmmoDefinition->ModelName ));
model = WW3DAssetManager::Get_Instance ()->Create_Render_Obj( "NULL" );
}
Projectile->Set_Model( model );
if (model) {
if ( BulletData.AmmoDefinition->ModelName.Compare_No_Case( model->Get_Name() ) != 0 ) {
Debug_Say(( "Possible bullet twiddler!! %s %s\n", BulletData.AmmoDefinition->ModelName, model->Get_Name() ));
}
// ModelNameCRC = CRC_Stringi( model->Get_Name() );
ModelNameCRC = CRC_Stringi( BulletData.AmmoDefinition->ModelName );
model->Release_Ref();
}
else {
ModelNameCRC = 0xFFFFFFFF;
}
}
if (Projectile->Get_Gravity_Multiplier() < 0.1f) {
Projectile->Set_Orientation_Mode_Aligned_Fixed();
} else {
Projectile->Set_Orientation_Mode_Aligned();
}
COMBAT_SCENE->Add_Dynamic_Object( Projectile );
float duration = (float) BulletData.AmmoDefinition->Range / (float) BulletData.AmmoDefinition->Velocity;
if (duration <= 0.0) {
Debug_Say(( "NULL DURATION\n" ));
}
Projectile->Set_Lifetime( duration * 1.2f );
Projectile->Set_Position( data.Position );
WWASSERT(data.Velocity.Is_Valid());
Projectile->Set_Velocity( data.Velocity );
// If there are any emitters in this model, reset them for our new position
RenderObjClass * model = Projectile->Peek_Model();
model->Restart();
// Timestep last, incase it gets shutdown during this call
if ( data.Get_Owner() != NULL ) {
data.Get_Owner()->Peek_Physical_Object()->Inc_Ignore_Counter();
}
Projectile->Timestep( progress_time );
if ( data.Get_Owner() != NULL ) {
data.Get_Owner()->Peek_Physical_Object()->Dec_Ignore_Counter();
}
}
void BulletClass::Shutdown( void )
{
if ( Projectile != NULL ) {
COMBAT_SCENE->Remove_Object( Projectile );
Projectile->Set_Observer( NULL );
}
BulletData.AmmoDefinition = NULL;
BulletData.Owner = NULL;
}
/*
** BulletClass Save and Load
*/
enum {
CHUNKID_VARIABLES = 910991544,
CHUNKID_OWNER,
CHUNKID_TARGET_OBJECT,
MICROCHUNKID_AMMO_DEFINITION_ID = 1,
MICROCHUNKID_PROJECTILE,
MICROCHUNKID_SOFT_PIERCE_COUNT,
MICROCHUNKID_DESTROY,
MICROCHUNKID_TARGET_VECTOR,
MICROCHUNKID_TRACKING_ERROR_TIMER,
MICROCHUNKID_TRACKING_ERROR,
MICROCHUNKID_MODEL_NAME_CRC,
};
bool BulletClass::Save( ChunkSaveClass & csave )
{
csave.Begin_Chunk( CHUNKID_VARIABLES );
WWASSERT( BulletData.AmmoDefinition != NULL );
int def_id = BulletData.AmmoDefinition->Get_ID();
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_AMMO_DEFINITION_ID, def_id );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_PROJECTILE, Projectile );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_SOFT_PIERCE_COUNT, BulletData.SoftPierceCount );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_DESTROY, BulletData.Destroy );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_TARGET_VECTOR, TargetVector );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_TRACKING_ERROR_TIMER, TrackingErrorTimer );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_TRACKING_ERROR, TrackingError );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_MODEL_NAME_CRC, ModelNameCRC );
csave.End_Chunk();
if ( BulletData.Get_Owner() != NULL ) {
csave.Begin_Chunk( CHUNKID_OWNER );
BulletData.Owner.Save( csave );
csave.End_Chunk();
}
if ( TargetObject.Get_Ptr() != NULL ) {
csave.Begin_Chunk( CHUNKID_TARGET_OBJECT );
TargetObject.Save( csave );
csave.End_Chunk();
}
return true;
}
bool BulletClass::Load( ChunkLoadClass & cload )
{
while (cload.Open_Chunk()) {
switch(cload.Cur_Chunk_ID()) {
case CHUNKID_VARIABLES:
{
int def_id = 0;
while (cload.Open_Micro_Chunk()) {
switch(cload.Cur_Micro_Chunk_ID()) {
READ_MICRO_CHUNK( cload, MICROCHUNKID_AMMO_DEFINITION_ID, def_id );
READ_MICRO_CHUNK( cload, MICROCHUNKID_PROJECTILE, Projectile );
READ_MICRO_CHUNK( cload, MICROCHUNKID_SOFT_PIERCE_COUNT, BulletData.SoftPierceCount );
READ_MICRO_CHUNK( cload, MICROCHUNKID_DESTROY, BulletData.Destroy );
READ_MICRO_CHUNK( cload, MICROCHUNKID_TARGET_VECTOR, TargetVector );
READ_MICRO_CHUNK( cload, MICROCHUNKID_TRACKING_ERROR_TIMER, TrackingErrorTimer );
READ_MICRO_CHUNK( cload, MICROCHUNKID_TRACKING_ERROR, TrackingError );
READ_MICRO_CHUNK( cload, MICROCHUNKID_MODEL_NAME_CRC, ModelNameCRC );
default:
Debug_Say(("Unhandled Micro Chunk:%d File:%s Line:%d\r\n",cload.Cur_Micro_Chunk_ID(),__FILE__,__LINE__));
break;
}
cload.Close_Micro_Chunk();
}
WWASSERT( BulletData.AmmoDefinition == NULL );
BulletData.AmmoDefinition = WeaponManager::Find_Ammo_Definition( def_id );
WWASSERT( BulletData.AmmoDefinition != NULL );
WWASSERT( Projectile != NULL );
if ( Projectile != NULL ) {
REQUEST_REF_COUNTED_POINTER_REMAP( (RefCountClass **)&Projectile );
}
break;
}
case CHUNKID_OWNER:
BulletData.Owner.Load( cload );
break;
case CHUNKID_TARGET_OBJECT:
TargetObject.Load( cload );
break;
default:
Debug_Say(("Unhandled Chunk:%d File:%s Line:%d\r\n",cload.Cur_Chunk_ID(),__FILE__,__LINE__));
break;
}
cload.Close_Chunk();
}
SaveLoadSystemClass::Register_Post_Load_Callback(this);
return true;
}
void BulletClass::On_Post_Load (void)
{
// Plug ourselves back into the physics object as an observer
WWASSERT(Projectile != NULL);
Projectile->Set_Observer(this);
return ;
}
CollisionReactionType BulletClass::Collision_Occurred( const CollisionEventClass & event )
{
// Copy the data from the Projectile
Projectile->Get_Velocity( &BulletData.Velocity );
Projectile->Get_Position( &BulletData.Position );
CollisionReactionType result = BulletData.Bullet_Collision_Occurred( event );
if ( BulletData.Destroy ) {
Shutdown();
}
return result;
}
ExpirationReactionType BulletClass::Object_Expired(PhysClass * observed_obj)
{
// Copy the data from the Projectile
Projectile->Get_Velocity( &BulletData.Velocity );
Projectile->Get_Position( &BulletData.Position );
ExpirationReactionType result = BulletData.Bullet_Expired();
if ( BulletData.Destroy ) {
Shutdown();
}
return result;
}
#define RANDOM_VECTOR( spread ) Vector3( FreeRandom.Get_Float( -(spread), (spread) ), \
FreeRandom.Get_Float( -(spread), (spread) ), \
FreeRandom.Get_Float( 0, (spread) ) )
void BulletClass::Think( void )
{
WWPROFILE( "Bullet Think" );
// Count down safety timer
BulletData.GrenadeSafetyTimer -= TimeManager::Get_Frame_Seconds();
if ( BulletData.GrenadeSafetyTimer < 0 ) {
BulletData.GrenadeSafetyTimer = 0;
}
// Handle Homing Bullets
if ( BulletData.AmmoDefinition->IsTracking ) {
// Track your target object
DamageableGameObj * target_obj = (DamageableGameObj *)TargetObject.Get_Ptr();
if ( target_obj != NULL ) {
if ( target_obj->As_PhysicalGameObj() ) {
TargetVector = target_obj->As_PhysicalGameObj()->Get_Bullseye_Position();
} else {
target_obj->Get_Position( &TargetVector );
}
}
Vector3 target_vector = TargetVector;
Vector3 obj_pos;
Projectile->Get_Transform().Get_Translation( &obj_pos );
// Debug_Say(( "Bullet Tracking %f %f %f\n", obj_pos.X, obj_pos.Y, obj_pos.Z ));
target_vector -= obj_pos;
// Find distance to target
float target_distance = target_vector.Length();
TrackingErrorTimer -= TimeManager::Get_Frame_Seconds();
if ( TrackingErrorTimer < 0 ) {
TrackingErrorTimer = FreeRandom.Get_Float( 0.1f, 0.4f );
TrackingError = RANDOM_VECTOR( BulletData.AmmoDefinition->RandomTrackingScale * target_distance / 2 );
}
target_vector += TrackingError;
target_vector.Normalize();
Vector3 current_vector;
Projectile->Get_Velocity( &current_vector );
current_vector.Normalize();
Vector3 cross = Vector3::Cross_Product( current_vector, target_vector );
// only re-aim if cross product not near zero
if ( cross.Length() > WWMATH_EPSILON ) {
float dot = Vector3::Dot_Product( target_vector, current_vector );
if ( WWMath::Fabs(dot) >= 1.0f ) {
// No turning needed
} else {
float angle = WWMath::Fast_Acos( dot );
float allowed_turn = BulletData.AmmoDefinition->TurnRate * TimeManager::Get_Frame_Seconds();
if ( angle > allowed_turn ) {
angle = allowed_turn;
}
cross.Normalize();
Matrix3D tm(cross,angle);
Vector3 current_vector;
Projectile->Get_Velocity( &current_vector );
WWASSERT(current_vector.Is_Valid());
current_vector = tm.Rotate_Vector( current_vector );
WWASSERT(current_vector.Is_Valid());
Projectile->Set_Velocity( current_vector );
}
}
}
}
/*
** Instant Bullet Code
*/
void Simulate_Instant_Bullet( BulletDataClass & data, float progress_time )
{
WWPROFILE("Simulate_Instant_Bullet");
// WWASSERT(data.Position.Is_Valid());
// WWASSERT(data.Velocity.Is_Valid());
Vector3 start = data.Position;
Vector3 end = data.Velocity;
end.Normalize();
end = start + (end * data.AmmoDefinition->Range);
// This is that last object we choose to ignore
PhysClass *blocker = NULL;
// Always ignore the owner
if ( data.Get_Owner() != NULL ) {
if ( data.Get_Owner()->Peek_Physical_Object() != NULL ) {
data.Get_Owner()->Peek_Physical_Object()->Inc_Ignore_Counter();
}
}
bool done = false;
int hit_counter = 0;
const int MAX_HITS = 5;
while ( !done && (hit_counter < MAX_HITS)) {
hit_counter++;
// Check for collisions in the path of the object
CastResultStruct res;
LineSegClass ray( data.Position, end );
PhysRayCollisionTestClass raytest(ray,&res,BULLET_COLLISION_GROUP,COLLISION_TYPE_PROJECTILE);
{WWPROFILE("Cast_Ray");
PhysicsSceneClass::Get_Instance()->Cast_Ray(raytest);
}
// If the result was a "startbad", we are done
if (raytest.Result->StartBad) {
// Debug_Say(( "Simulate_Instant_Bullet Startbad\n" ));
done = true;
} else {
if (raytest.Result->Fraction < 1.0f) {
// If there was a collision, set us at the point of collision
// Also, fill in the cast result struct.
ray.Compute_Point(raytest.Result->Fraction,&(raytest.Result->ContactPoint));
data.Position = raytest.Result->ContactPoint;
// Notify the parties involved
WWASSERT(raytest.CollidedPhysObj != NULL);
CollisionReactionType reaction = COLLISION_REACTION_DEFAULT;
CollisionEventClass event;
event.CollisionResult = raytest.Result;
event.CollidedRenderObj = raytest.CollidedRenderObj;
event.OtherObj = raytest.CollidedPhysObj;
reaction |= data.Bullet_Collision_Occurred(event);
if ( reaction & COLLISION_REACTION_NO_BOUNCE ) {
// We were requested to fly through. Mark the current blocker as ignore
// so we collide with him no more this pass
if ( blocker ) { // Stop ignoring the last blocker
blocker->Dec_Ignore_Counter();
}
blocker = raytest.CollidedPhysObj;
if ( blocker ) { // Start ignoring this blocker
blocker->Inc_Ignore_Counter();
}
} else {
done = true;
}
} else {
done = true;
data.Position = end;
}
}
}
if ( blocker ) { // Stop ignoring the last blocker
blocker->Dec_Ignore_Counter();
}
// stop ignoring the owner
if ( data.Get_Owner() != NULL ) {
if ( data.Get_Owner()->Peek_Physical_Object() != NULL ) {
data.Get_Owner()->Peek_Physical_Object()->Dec_Ignore_Counter();
}
}
// If not destroyed, Expire..
if ( !data.Destroy ) {
data.Bullet_Expired();
}
// If the definition requests a beam effect, launch it
if (data.AmmoDefinition->BeamEnabled) {
_TheBeamEffectManager.Create_Beam_Effect(data.AmmoDefinition,start,data.Position);
}
}
/*
** BulletManager
*/
MultiListClass<BulletClass> LiveBulletList;
MultiListClass<BulletClass> DeadBulletList;
void BulletManager::Init( void )
{
_TheBeamEffectManager.Init();
}
void BulletManager::Shutdown( void )
{
while ( !LiveBulletList.Is_Empty() ) {
delete LiveBulletList.Remove_Head();
}
while ( !DeadBulletList.Is_Empty() ) {
delete DeadBulletList.Remove_Head();
}
_TheBeamEffectManager.Shutdown();
}
void BulletManager::Update( void )
{
MultiListIterator<BulletClass> it( &LiveBulletList );;
while (!it.Is_Done()) {
BulletClass * bullet = it.Peek_Obj();
if (bullet->BulletData.Destroy) {
bullet->Shutdown();
it.Remove_Current_Object();
DeadBulletList.Add( bullet );
} else {
bullet->Think();
it.Next();
}
}
}
#define BULLET_SPEED_CHEAT 0
void BulletManager::Create_Bullet( const AmmoDefinitionClass * def, const Vector3 & position,
const Vector3 & velocity, const ArmedGameObj * owner, float progress_time, const Vector3 & target,
DamageableGameObj * target_obj )
{
WWASSERT(velocity.Is_Valid());
BulletDataClass data( def, owner, position, velocity );
#if BULLET_SPEED_CHEAT
if ( (float)def->Velocity >= _INSTANT_BULLET_THRESHHOLD/3 ) {
#else
if ( (float)def->Velocity >= _INSTANT_BULLET_THRESHHOLD ) {
#endif
Simulate_Instant_Bullet( data, progress_time );
return;
}
WWPROFILE( "Create Bullet" );
BulletClass * bullet = NULL;
// Find a bullet
long crc = CRC_Stringi( def->ModelName );
MultiListIterator<BulletClass> it( &DeadBulletList );;
while ( !it.Is_Done() && bullet == NULL ) {
BulletClass * test_bullet = it.Peek_Obj();
if ( test_bullet->ModelNameCRC == crc ) {
bullet = test_bullet;
it.Remove_Current_Object();
} else {
it.Next();
}
}
if ( bullet == NULL ) {
bullet = new BulletClass();
}
if ( bullet != NULL ) {
bullet->Init( data, progress_time, target, target_obj );
LiveBulletList.Add( bullet );
}
}
/*
** Save & Load
*/
enum {
CHUNKID_BULLET = 916991653,
};
bool BulletManager::Save( ChunkSaveClass &csave )
{
MultiListIterator<BulletClass> it( &LiveBulletList );;
while (!it.Is_Done()) {
BulletClass * bullet = it.Peek_Obj();
// Only save valid bullets
if ( bullet->Is_Valid() ) {
csave.Begin_Chunk( CHUNKID_BULLET );
bullet->Save( csave );
csave.End_Chunk();
}
it.Next();
}
return true;
}
bool BulletManager::Load( ChunkLoadClass &cload )
{
while (cload.Open_Chunk()) {
switch(cload.Cur_Chunk_ID()) {
case CHUNKID_BULLET:
{
BulletClass * bullet = new BulletClass();
bullet->Load( cload );
LiveBulletList.Add( bullet );
break;
}
default:
Debug_Say(( "Unrecognized BulletManager chunkID %d\n", cload.Cur_Chunk_ID() ));
break;
}
cload.Close_Chunk();
}
return true;
}
Reference in a new issue Copy permalink