id
/
doom3
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
doom3/neo/d3xp/Grabber.cpp

736 lines
20 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
#ifdef _D3XP
#include "Game_local.h"
#include "Misc.h"
#define MAX_DRAG_TRACE_DISTANCE 384.0f
#define TRACE_BOUNDS_SIZE 3.f
#define HOLD_DISTANCE 72.f
#define FIRING_DELAY 1000.0f
#define DRAG_FAIL_LEN 64.f
#define THROW_SCALE 1000
#define MAX_PICKUP_VELOCITY 1500 * 1500
#define MAX_PICKUP_SIZE 96
/*
===============================================================================
Allows entities to be dragged through the world with physics.
===============================================================================
*/
CLASS_DECLARATION( idEntity, idGrabber )
END_CLASS
/*
==============
idGrabber::idGrabber
==============
*/
idGrabber::idGrabber( void ) {
dragEnt = NULL;
owner = NULL;
beam = NULL;
beamTarget = NULL;
oldUcmdFlags = 0;
shakeForceFlip = false;
holdingAF = false;
endTime = 0;
lastFiredTime = -FIRING_DELAY;
dragFailTime = 0;
startDragTime = 0;
warpId = -1;
dragTraceDist = MAX_DRAG_TRACE_DISTANCE;
}
/*
==============
idGrabber::~idGrabber
==============
*/
idGrabber::~idGrabber( void ) {
StopDrag( true );
if ( beam ) {
delete beam;
}
if ( beamTarget ) {
delete beamTarget;
}
}
/*
==============
idGrabber::Save
==============
*/
void idGrabber::Save( idSaveGame *savefile ) const {
dragEnt.Save( savefile );
savefile->WriteStaticObject( drag );
savefile->WriteVec3( saveGravity );
savefile->WriteInt( id );
savefile->WriteVec3( localPlayerPoint );
owner.Save( savefile );
savefile->WriteBool( holdingAF );
savefile->WriteBool( shakeForceFlip );
savefile->WriteInt( endTime );
savefile->WriteInt( lastFiredTime );
savefile->WriteInt( dragFailTime );
savefile->WriteInt( startDragTime );
savefile->WriteFloat( dragTraceDist );
savefile->WriteInt( savedContents );
savefile->WriteInt( savedClipmask );
savefile->WriteObject( beam );
savefile->WriteObject( beamTarget );
savefile->WriteInt( warpId );
}
/*
==============
idGrabber::Restore
==============
*/
void idGrabber::Restore( idRestoreGame *savefile ) {
//Spawn the beams
Initialize();
dragEnt.Restore( savefile );
savefile->ReadStaticObject( drag );
savefile->ReadVec3( saveGravity );
savefile->ReadInt( id );
// Restore the drag force's physics object
if ( dragEnt.IsValid() ) {
drag.SetPhysics( dragEnt.GetEntity()->GetPhysics(), id, dragEnt.GetEntity()->GetPhysics()->GetOrigin() );
}
savefile->ReadVec3( localPlayerPoint );
owner.Restore( savefile );
savefile->ReadBool( holdingAF );
savefile->ReadBool( shakeForceFlip );
savefile->ReadInt( endTime );
savefile->ReadInt( lastFiredTime );
savefile->ReadInt( dragFailTime );
savefile->ReadInt( startDragTime );
savefile->ReadFloat( dragTraceDist );
savefile->ReadInt( savedContents );
savefile->ReadInt( savedClipmask );
savefile->ReadObject( reinterpret_cast<idClass *&>(beam) );
savefile->ReadObject( reinterpret_cast<idClass *&>(beamTarget) );
savefile->ReadInt( warpId );
}
/*
==============
idGrabber::Initialize
==============
*/
void idGrabber::Initialize( void ) {
if ( !gameLocal.isMultiplayer ) {
idDict args;
if ( !beamTarget ) {
args.SetVector( "origin", vec3_origin );
args.SetBool( "start_off", true );
beamTarget = ( idBeam * )gameLocal.SpawnEntityType( idBeam::Type, &args );
}
if ( !beam ) {
args.Clear();
args.Set( "target", beamTarget->name.c_str() );
args.SetVector( "origin", vec3_origin );
args.SetBool( "start_off", true );
args.Set( "width", "6" );
args.Set( "skin", "textures/smf/flareSizeable" );
args.Set( "_color", "0.0235 0.843 0.969 0.2" );
beam = ( idBeam * )gameLocal.SpawnEntityType( idBeam::Type, &args );
beam->SetShaderParm( 6, 1.0f );
}
endTime = 0;
dragTraceDist = MAX_DRAG_TRACE_DISTANCE;
}
else {
beam = NULL;
beamTarget = NULL;
endTime = 0;
dragTraceDist = MAX_DRAG_TRACE_DISTANCE;
};
}
/*
==============
idGrabber::SetDragDistance
==============
*/
void idGrabber::SetDragDistance( float dist ) {
dragTraceDist = dist;
}
/*
==============
idGrabber::StartDrag
==============
*/
void idGrabber::StartDrag( idEntity *grabEnt, int id ) {
int clipModelId = id;
idPlayer *thePlayer = owner.GetEntity();
holdingAF = false;
dragFailTime = gameLocal.slow.time;
startDragTime = gameLocal.slow.time;
oldUcmdFlags = thePlayer->usercmd.flags;
// set grabbed state for networking
grabEnt->SetGrabbedState( true );
// This is the new object to drag around
dragEnt = grabEnt;
// Show the beams!
UpdateBeams();
if ( beam ) {
beam->Show();
}
if ( beamTarget ) {
beamTarget->Show();
}
// Move the object to the fast group (helltime)
grabEnt->timeGroup = TIME_GROUP2;
// Handle specific class types
if ( grabEnt->IsType( idProjectile::Type ) ) {
idProjectile* p = (idProjectile*)grabEnt;
p->CatchProjectile( thePlayer, "_catch" );
// Make the projectile non-solid to other projectiles/enemies (special hack for helltime hunter)
if ( !idStr::Cmp( grabEnt->GetEntityDefName(), "projectile_helltime_killer" ) ) {
savedContents = CONTENTS_PROJECTILE;
savedClipmask = MASK_SHOT_RENDERMODEL|CONTENTS_PROJECTILE;
} else {
savedContents = grabEnt->GetPhysics()->GetContents();
savedClipmask = grabEnt->GetPhysics()->GetClipMask();
}
grabEnt->GetPhysics()->SetContents( 0 );
grabEnt->GetPhysics()->SetClipMask( CONTENTS_SOLID|CONTENTS_BODY );
} else if ( grabEnt->IsType( idExplodingBarrel::Type ) ) {
idExplodingBarrel *ebarrel = static_cast<idExplodingBarrel*>(grabEnt);
ebarrel->StartBurning();
} else if ( grabEnt->IsType( idAFEntity_Gibbable::Type ) ) {
holdingAF = true;
clipModelId = 0;
if ( grabbableAI( grabEnt->spawnArgs.GetString( "classname" ) ) ) {
idAI *aiEnt = static_cast<idAI*>(grabEnt);
aiEnt->StartRagdoll();
}
} else if ( grabEnt->IsType( idMoveableItem::Type ) ) {
grabEnt->PostEventMS( &EV_Touch, 250, thePlayer, NULL );
}
// Get the current physics object to manipulate
idPhysics *phys = grabEnt->GetPhysics();
// Turn off gravity on object
saveGravity = phys->GetGravity();
phys->SetGravity( vec3_origin );
// hold it directly in front of player
localPlayerPoint = ( thePlayer->firstPersonViewAxis[0] * HOLD_DISTANCE ) * thePlayer->firstPersonViewAxis.Transpose();
// Set the ending time for the hold
endTime = gameLocal.time + g_grabberHoldSeconds.GetFloat() * 1000;
// Start up the Force_Drag to bring it in
drag.Init( g_grabberDamping.GetFloat() );
drag.SetPhysics( phys, clipModelId, thePlayer->firstPersonViewOrigin + localPlayerPoint * thePlayer->firstPersonViewAxis);
// start the screen warp
warpId = thePlayer->playerView.AddWarp( phys->GetOrigin(), SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, 160, 2000 );
}
/*
==============
idGrabber::StopDrag
==============
*/
void idGrabber::StopDrag( bool dropOnly ) {
idPlayer *thePlayer = owner.GetEntity();
if ( beam ) {
beam->Hide();
}
if ( beamTarget ) {
beamTarget->Hide();
}
if ( dragEnt.IsValid() ) {
idEntity *ent = dragEnt.GetEntity();
// set grabbed state for networking
ent->SetGrabbedState( false );
// If a cinematic has started, allow dropped object to think in cinematics
if ( gameLocal.inCinematic ) {
ent->cinematic = true;
}
// Restore Gravity
ent->GetPhysics()->SetGravity( saveGravity );
// Move the object back to the slow group (helltime)
ent->timeGroup = TIME_GROUP1;
if ( holdingAF ) {
idAFEntity_Gibbable *af = static_cast<idAFEntity_Gibbable *>(ent);
idPhysics_AF *af_Phys = static_cast<idPhysics_AF*>(af->GetPhysics());
if ( grabbableAI( ent->spawnArgs.GetString( "classname" ) ) ) {
idAI *aiEnt = static_cast<idAI*>(ent);
aiEnt->Damage( thePlayer, thePlayer, vec3_origin, "damage_suicide", 1.0f, INVALID_JOINT );
}
af->SetThrown( !dropOnly );
// Reset timers so that it isn't forcibly put to rest in mid-air
af_Phys->PutToRest();
af_Phys->Activate();
af_Phys->SetTimeScaleRamp( MS2SEC(gameLocal.slow.time) - 1.5f, MS2SEC(gameLocal.slow.time) + 1.0f );
}
// If the object isn't near its goal, just drop it in place.
if ( !ent->IsType( idProjectile::Type ) && ( dropOnly || drag.GetDistanceToGoal() > DRAG_FAIL_LEN ) ) {
ent->GetPhysics()->SetLinearVelocity( vec3_origin );
thePlayer->StartSoundShader( declManager->FindSound( "grabber_maindrop" ), SND_CHANNEL_WEAPON, 0, false, NULL );
if ( ent->IsType( idExplodingBarrel::Type ) ) {
idExplodingBarrel *ebarrel = static_cast<idExplodingBarrel*>(ent);
ebarrel->SetStability( true );
ebarrel->StopBurning();
}
} else {
// Shoot the object forward
ent->ApplyImpulse( thePlayer, 0, ent->GetPhysics()->GetOrigin(), thePlayer->firstPersonViewAxis[0] * THROW_SCALE * ent->GetPhysics()->GetMass() );
thePlayer->StartSoundShader( declManager->FindSound( "grabber_release" ), SND_CHANNEL_WEAPON, 0, false, NULL );
// Orient projectiles away from the player
if ( ent->IsType( idProjectile::Type ) ) {
idPlayer *player = owner.GetEntity();
idAngles ang = player->firstPersonViewAxis[0].ToAngles();
ang.pitch += 90.f;
ent->GetPhysics()->SetAxis( ang.ToMat3() );
ent->GetPhysics()->SetAngularVelocity( vec3_origin );
// Restore projectile contents
ent->GetPhysics()->SetContents( savedContents );
ent->GetPhysics()->SetClipMask( savedClipmask );
} else if ( ent->IsType( idMoveable::Type ) ) {
// Turn on damage for this object
idMoveable *obj = static_cast<idMoveable*>(ent);
obj->EnableDamage( true, 2.5f );
obj->SetAttacker( thePlayer );
if ( ent->IsType( idExplodingBarrel::Type ) ) {
idExplodingBarrel *ebarrel = static_cast<idExplodingBarrel*>(ent);
ebarrel->SetStability( false );
}
} else if ( ent->IsType( idMoveableItem::Type ) ) {
ent->GetPhysics()->SetClipMask( MASK_MONSTERSOLID );
}
}
// Remove the Force_Drag's control of the entity
drag.RemovePhysics( ent->GetPhysics() );
}
if ( warpId != -1 ) {
thePlayer->playerView.FreeWarp( warpId );
warpId = -1;
}
lastFiredTime = gameLocal.time;
dragEnt = NULL;
endTime = 0;
}
/*
==============
idGrabber::Update
==============
*/
int idGrabber::Update( idPlayer *player, bool hide ) {
trace_t trace;
idEntity *newEnt;
// pause before allowing refire
if ( lastFiredTime + FIRING_DELAY > gameLocal.time ) {
return 3;
}
// Dead players release the trigger
if ( hide || player->health <= 0 ) {
StopDrag( true );
if ( hide ) {
lastFiredTime = gameLocal.time - FIRING_DELAY + 250;
}
return 3;
}
// Check if object being held has been removed (dead demon, projectile, etc.)
if ( endTime > gameLocal.time ) {
bool abort = !dragEnt.IsValid();
if ( !abort && dragEnt.GetEntity()->IsType( idProjectile::Type ) ) {
idProjectile *proj = (idProjectile *)dragEnt.GetEntity();
if ( proj->GetProjectileState() >= 3 ) {
abort = true;
}
}
if ( !abort && dragEnt.GetEntity()->IsHidden() ) {
abort = true;
}
// Not in multiplayer :: Pressing "reload" lets you carefully drop an item
if ( !gameLocal.isMultiplayer && !abort && (( player->usercmd.flags & UCF_IMPULSE_SEQUENCE ) != ( oldUcmdFlags & UCF_IMPULSE_SEQUENCE )) && (player->usercmd.impulse == IMPULSE_13) ) {
abort = true;
}
if ( abort ) {
StopDrag( true );
return 3;
}
}
owner = player;
// if no entity selected for dragging
if ( !dragEnt.GetEntity() ) {
idBounds bounds;
idVec3 end = player->firstPersonViewOrigin + player->firstPersonViewAxis[0] * dragTraceDist;
bounds.Zero();
bounds.ExpandSelf( TRACE_BOUNDS_SIZE );
gameLocal.clip.TraceBounds( trace, player->firstPersonViewOrigin, end, bounds, MASK_SHOT_RENDERMODEL|CONTENTS_PROJECTILE|CONTENTS_MOVEABLECLIP, player );
// If the trace hit something
if ( trace.fraction < 1.0f ) {
newEnt = gameLocal.entities[ trace.c.entityNum ];
// if entity is already being grabbed then bypass
if ( gameLocal.isMultiplayer && newEnt->IsGrabbed() ) {
return 0;
}
// Check if this is a valid entity to hold
if ( newEnt && ( newEnt->IsType( idMoveable::Type ) ||
newEnt->IsType( idMoveableItem::Type ) ||
newEnt->IsType( idProjectile::Type ) ||
newEnt->IsType( idAFEntity_Gibbable::Type ) ) &&
newEnt->noGrab == false &&
newEnt->GetPhysics()->GetBounds().GetRadius() < MAX_PICKUP_SIZE &&
newEnt->GetPhysics()->GetLinearVelocity().LengthSqr() < MAX_PICKUP_VELOCITY ) {
bool validAF = true;
if ( newEnt->IsType( idAFEntity_Gibbable::Type ) ) {
idAFEntity_Gibbable *afEnt = static_cast<idAFEntity_Gibbable*>(newEnt);
if ( grabbableAI( newEnt->spawnArgs.GetString( "classname" ) ) ) {
// Make sure it's also active
if ( !afEnt->IsActive() ) {
validAF = false;
}
} else if ( !afEnt->IsActiveAF() ) {
validAF = false;
}
}
if ( validAF && player->usercmd.buttons & BUTTON_ATTACK ) {
// Grab this entity and start dragging it around
StartDrag( newEnt, trace.c.id );
} else if ( validAF ) {
// A holdable object is ready to be grabbed
return 1;
}
}
}
}
// check backwards server time in multiplayer
bool allow = true;
if ( gameLocal.isMultiplayer ) {
// if we've marched backwards
if ( gameLocal.slow.time < startDragTime ) {
allow = false;
}
}
// if there is an entity selected for dragging
if ( dragEnt.GetEntity() && allow ) {
idPhysics *entPhys = dragEnt.GetEntity()->GetPhysics();
idVec3 goalPos;
// If the player lets go of attack, or time is up
if ( !( player->usercmd.buttons & BUTTON_ATTACK ) ) {
StopDrag( false );
return 3;
}
if ( gameLocal.time > endTime ) {
StopDrag( true );
return 3;
}
// Check if the player is standing on the object
if ( !holdingAF ) {
idBounds playerBounds;
idBounds objectBounds = entPhys->GetAbsBounds();
idVec3 newPoint = player->GetPhysics()->GetOrigin();
// create a bounds at the players feet
playerBounds.Clear();
playerBounds.AddPoint( newPoint );
newPoint.z -= 1.f;
playerBounds.AddPoint( newPoint );
playerBounds.ExpandSelf( 8.f );
// If it intersects the object bounds, then drop it
if ( playerBounds.IntersectsBounds( objectBounds ) ) {
StopDrag( true );
return 3;
}
}
// Shake the object at the end of the hold
if ( g_grabberEnableShake.GetBool() && !gameLocal.isMultiplayer ) {
ApplyShake();
}
// Set and evaluate drag force
goalPos = player->firstPersonViewOrigin + localPlayerPoint * player->firstPersonViewAxis;
drag.SetGoalPosition( goalPos );
drag.Evaluate( gameLocal.time );
// If an object is flying too fast toward the player, stop it hard
if ( g_grabberHardStop.GetBool() ) {
idPlane theWall;
idVec3 toPlayerVelocity, objectCenter;
float toPlayerSpeed;
toPlayerVelocity = -player->firstPersonViewAxis[0];
toPlayerSpeed = entPhys->GetLinearVelocity() * toPlayerVelocity;
if ( toPlayerSpeed > 64.f ) {
objectCenter = entPhys->GetAbsBounds().GetCenter();
theWall.SetNormal( player->firstPersonViewAxis[0] );
theWall.FitThroughPoint( goalPos );
if ( theWall.Side( objectCenter, 0.1f ) == PLANESIDE_BACK ) {
int i, num;
num = entPhys->GetNumClipModels();
for ( i=0; i<num; i++ ) {
entPhys->SetLinearVelocity( vec3_origin, i );
}
}
}
// Make sure the object isn't spinning too fast
const float MAX_ROTATION_SPEED = 12.f;
idVec3 angVel = entPhys->GetAngularVelocity();
float rotationSpeed = angVel.LengthFast();
if ( rotationSpeed > MAX_ROTATION_SPEED ) {
angVel.NormalizeFast();
angVel *= MAX_ROTATION_SPEED;
entPhys->SetAngularVelocity( angVel );
}
}
// Orient projectiles away from the player
if ( dragEnt.GetEntity()->IsType( idProjectile::Type ) ) {
idAngles ang = player->firstPersonViewAxis[0].ToAngles();
ang.pitch += 90.f;
entPhys->SetAxis( ang.ToMat3() );
}
// Some kind of effect from gun to object?
UpdateBeams();
// If the object is stuck away from its intended position for more than 500ms, let it go.
if ( drag.GetDistanceToGoal() > DRAG_FAIL_LEN ) {
if ( dragFailTime < (gameLocal.slow.time - 500) ) {
StopDrag( true );
return 3;
}
} else {
dragFailTime = gameLocal.slow.time;
}
// Currently holding an object
return 2;
}
// Not holding, nothing to hold
return 0;
}
/*
======================
idGrabber::UpdateBeams
======================
*/
void idGrabber::UpdateBeams( void ) {
jointHandle_t muzzle_joint;
idVec3 muzzle_origin;
idMat3 muzzle_axis;
renderEntity_t *re;
if ( !beam ) {
return;
}
if ( dragEnt.IsValid() ) {
idPlayer *thePlayer = owner.GetEntity();
if ( beamTarget ) {
beamTarget->SetOrigin( dragEnt.GetEntity()->GetPhysics()->GetAbsBounds().GetCenter() );
}
muzzle_joint = thePlayer->weapon.GetEntity()->GetAnimator()->GetJointHandle( "particle_upper" );
if ( muzzle_joint != INVALID_JOINT ) {
thePlayer->weapon.GetEntity()->GetJointWorldTransform( muzzle_joint, gameLocal.time, muzzle_origin, muzzle_axis );
} else {
muzzle_origin = thePlayer->GetPhysics()->GetOrigin();
}
beam->SetOrigin( muzzle_origin );
re = beam->GetRenderEntity();
re->origin = muzzle_origin;
beam->UpdateVisuals();
beam->Present();
}
}
/*
==============
idGrabber::ApplyShake
==============
*/
void idGrabber::ApplyShake( void ) {
float u = 1 - (float)( endTime - gameLocal.time ) / ( g_grabberHoldSeconds.GetFloat() * 1000 );
if ( u >= 0.8f ) {
idVec3 point, impulse;
float shakeForceMagnitude = 450.f;
float mass = dragEnt.GetEntity()->GetPhysics()->GetMass();
shakeForceFlip = !shakeForceFlip;
// get point to rotate around
point = dragEnt.GetEntity()->GetPhysics()->GetOrigin();
point.y += 1;
// Articulated figures get less violent shake
if ( holdingAF ) {
shakeForceMagnitude = 120.f;
}
// calc impulse
if ( shakeForceFlip ) {
impulse.Set( 0, 0, shakeForceMagnitude * u * mass );
}
else {
impulse.Set( 0, 0, -shakeForceMagnitude * u * mass );
}
dragEnt.GetEntity()->ApplyImpulse( NULL, 0, point, impulse );
}
}
/*
==============
idGrabber::grabbableAI
==============
*/
bool idGrabber::grabbableAI( const char *aiName ) {
// skip "monster_"
aiName += 8;
if (!idStr::Cmpn( aiName, "flying_lostsoul", 15 ) ||
!idStr::Cmpn( aiName, "demon_trite", 11 ) ||
!idStr::Cmp( aiName, "flying_forgotten" ) ||
!idStr::Cmp( aiName, "demon_cherub" ) ||
!idStr::Cmp( aiName, "demon_tick" )) {
return true;
}
return false;
}
#endif
Reference in New Issue View Git Blame Copy Permalink