raven/quake4-sdk
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
quake4-sdk/source/game/Item.cpp

2376 lines
57 KiB
C++
Raw Normal View History

as released 2007-06-15
2007-06-15 00:00:00 +00:00
// RAVEN BEGIN
// bdube: note that this file is no longer merged with Doom3 updates
//
// MERGE_DATE 09/30/2004
#include "../idlib/precompiled.h"
#pragma hdrstop
#include "Game_local.h"
/*
===============================================================================
idItem
===============================================================================
*/
const idEventDef EV_DropToFloor( "<dropToFloor>" );
const idEventDef EV_RespawnItem( "respawn" );
const idEventDef EV_RespawnFx( "<respawnFx>" );
const idEventDef EV_GetPlayerPos( "<getplayerpos>" );
const idEventDef EV_HideObjective( "<hideobjective>", "e" );
const idEventDef EV_CamShot( "<camshot>" );
// RAVEN BEGIN
// abahr:
const idEventDef EV_SetGravity( "<setGravity>" );
// RAVEN END
CLASS_DECLARATION( idEntity, idItem )
EVENT( EV_DropToFloor, idItem::Event_DropToFloor )
EVENT( EV_Touch, idItem::Event_Touch )
EVENT( EV_Activate, idItem::Event_Trigger )
EVENT( EV_RespawnItem, idItem::Event_Respawn )
EVENT( EV_RespawnFx, idItem::Event_RespawnFx )
// RAVEN BEGIN
// abahr
EVENT( EV_SetGravity, idItem::Event_SetGravity )
// RAVEN END
END_CLASS
/*
================
idItem::idItem
================
*/
idItem::idItem() {
spin = false;
inView = false;
skin = NULL;
pickupSkin = NULL;
inViewTime = 0;
lastCycle = 0;
lastRenderViewTime = -1;
itemShellHandle = -1;
shellMaterial = NULL;
orgOrigin.Zero();
canPickUp = true;
fl.networkSync = true;
trigger = NULL;
syncPhysics = false;
srvReady = -1;
clReady = -1;
effectIdle = NULL;
itemPVSArea = 0;
effectIdle = NULL;
simpleItem = false;
pickedUp = false;
}
/*
================
idItem::~idItem
================
*/
idItem::~idItem() {
// remove the highlight shell
if ( itemShellHandle != -1 ) {
gameRenderWorld->FreeEntityDef( itemShellHandle );
}
if ( trigger ) {
delete trigger;
}
SetPhysics( NULL );
}
/*
================
idItem::Save
================
*/
void idItem::Save( idSaveGame *savefile ) const {
savefile->WriteClipModel( trigger );
savefile->WriteBool( spin );
savefile->WriteSkin( skin );
savefile->WriteSkin( pickupSkin );
savefile->WriteVec3( orgOrigin );
savefile->WriteBool( pulse );
savefile->WriteBool( canPickUp );
savefile->WriteStaticObject( physicsObj );
// savefile->WriteInt(itemShellHandle); // cnicholson: Set at end of Restore, do not save
savefile->WriteMaterial( shellMaterial );
savefile->WriteBool( inView );
savefile->WriteInt( inViewTime );
savefile->WriteInt( lastCycle );
savefile->WriteInt( lastRenderViewTime );
}
/*
================
idItem::Restore
================
*/
void idItem::Restore( idRestoreGame *savefile ) {
savefile->ReadClipModel( trigger );
savefile->ReadBool( spin );
savefile->ReadSkin( skin );
savefile->ReadSkin( pickupSkin );
savefile->ReadVec3( orgOrigin );
savefile->ReadBool( pulse );
savefile->ReadBool( canPickUp );
savefile->ReadStaticObject ( physicsObj );
// savefile->ReadInt(itemShellHandle); // cnicholson: Set at end of function, do not restore
savefile->ReadMaterial( shellMaterial );
savefile->ReadBool( inView );
savefile->ReadInt( inViewTime );
savefile->ReadInt( lastCycle );
savefile->ReadInt( lastRenderViewTime );
RestorePhysics( &physicsObj );
physicsObj.SetSelf( this );
itemShellHandle = -1;
}
/*
================
idItem::UpdateRenderEntity
================
*/
bool idItem::UpdateRenderEntity( renderEntity_s *renderEntity, const renderView_t *renderView ) const {
if( simpleItem ) {
return false;
}
if ( lastRenderViewTime == renderView->time ) {
return false;
}
lastRenderViewTime = renderView->time;
// check for glow highlighting if near the center of the view
idVec3 dir = renderEntity->origin - renderView->vieworg;
dir.Normalize();
float d = dir * renderView->viewaxis[0];
// two second pulse cycle
float cycle = ( renderView->time - inViewTime ) / 2000.0f;
if ( d > 0.94f ) {
if ( !inView ) {
inView = true;
if ( cycle > lastCycle ) {
// restart at the beginning
inViewTime = renderView->time;
cycle = 0.0f;
}
}
} else {
if ( inView ) {
inView = false;
lastCycle = ceil( cycle );
}
}
// fade down after the last pulse finishes
if ( !inView && cycle > lastCycle ) {
renderEntity->shaderParms[4] = 0.0f;
} else {
// pulse up in 1/4 second
cycle -= (int)cycle;
if ( cycle < 0.1f ) {
renderEntity->shaderParms[4] = cycle * 10.0f;
} else if ( cycle < 0.2f ) {
renderEntity->shaderParms[4] = 1.0f;
} else if ( cycle < 0.3f ) {
renderEntity->shaderParms[4] = 1.0f - ( cycle - 0.2f ) * 10.0f;
} else {
// stay off between pulses
renderEntity->shaderParms[4] = 0.0f;
}
}
// update every single time this is in view
return true;
}
/*
================
idItem::UpdateTrigger
================
*/
void idItem::UpdateTrigger ( void ) {
// update trigger position
// RAVEN BEGIN
// ddynerman: multiple clip worlds
trigger->Link( this, 0, GetPhysics()->GetOrigin(), mat3_identity );
// RAVEN END
}
/*
================
idItem::ModelCallback
================
*/
bool idItem::ModelCallback( renderEntity_t *renderEntity, const renderView_t *renderView ) {
const idItem *ent;
// this may be triggered by a model trace or other non-view related source
if ( !renderView ) {
return false;
}
ent = static_cast<idItem *>(gameLocal.entities[ renderEntity->entityNum ]);
if ( !ent ) {
gameLocal.Error( "idItem::ModelCallback: callback with NULL game entity" );
}
return ent->UpdateRenderEntity( renderEntity, renderView );
}
/*
================
idItem::GetPhysicsToVisualTransform
================
*/
bool idItem::GetPhysicsToVisualTransform( idVec3 &origin, idMat3 &axis ) {
if( simpleItem ) {
if ( gameLocal.GetLocalPlayer() && gameLocal.GetLocalPlayer()->GetRenderView() ) {
if( gameLocal.GetLocalPlayer()->spectating ) {
idPlayer* spec = (idPlayer*)gameLocal.entities[ gameLocal.GetLocalPlayer()->spectator ];
if( spec && spec->GetRenderView() ) {
axis = spec->GetRenderView()->viewaxis;
}
} else {
axis = gameLocal.GetLocalPlayer()->GetRenderView()->viewaxis;
}
} else {
// dedicated server for instance
axis = mat3_identity;
}
origin = idVec3( 0.0f, 0.0f, 32.0f );
return true;
}
if( !spin || (gameLocal.isServer && !gameLocal.isListenServer) ) {
return false;
}
idAngles ang;
ang.pitch = ang.roll = 0.0f;
ang.yaw = ( gameLocal.time & 4095 ) * 360.0f / -4096.0f;
axis = ang.ToMat3() * GetPhysics()->GetAxis();
float scale = 0.005f;
float offset = entityNumber * 0.685145f; // rjohnson: just a random number here to shift the cos curve
origin.Zero();
origin += GetPhysics()->GetAxis()[2] * (4.0f + idMath::Cos( ( ( gameLocal.time + 1000 ) * scale ) + offset ) * 4.0f);
return true;
}
// RAVEN BEGIN
// mekberg: added
/*
================
idItem::Collide
================
*/
bool idItem::Collide( const trace_t &collision, const idVec3 &velocity ) {
idEntity* lol = gameLocal.entities[ collision.c.entityNum ];
if ( gameLocal.isMultiplayer && collision.c.contents & CONTENTS_ITEMCLIP && lol && !lol->IsType( idItem::GetClassType() ) ) {
PostEventMS( &EV_Remove, 0 );
}
return false;
}
// RAVEN END
/*
================
idItem::Think
================
*/
void idItem::Think( void ) {
if ( thinkFlags & TH_PHYSICS ) {
RunPhysics();
UpdateTrigger();
}
if ( gameLocal.IsMultiplayer() && g_skipItemShadowsMP.GetBool() ) {
renderEntity.suppressShadowInViewID = gameLocal.localClientNum + 1;
} else {
renderEntity.suppressShadowInViewID = 0;
}
if( !(simpleItem && pickedUp) ) {
UpdateVisuals();
Present();
}
}
/*
================
idItem::Present
================
*/
void idItem::Present( void ) {
idEntity::Present();
if ( !fl.hidden && pulse ) {
// also add a highlight shell model
renderEntity_t shell;
shell = renderEntity;
// we will mess with shader parms when the item is in view
// to give the "item pulse" effect
shell.callback = idItem::ModelCallback;
shell.entityNum = entityNumber;
shell.customShader = shellMaterial;
if ( itemShellHandle == -1 ) {
itemShellHandle = gameRenderWorld->AddEntityDef( &shell );
} else {
gameRenderWorld->UpdateEntityDef( itemShellHandle, &shell );
}
}
}
/*
================
idItem::InstanceJoin
================
*/
void idItem::InstanceJoin( void ) {
idEntity::InstanceJoin();
UpdateModelTransform();
if ( !simpleItem && spawnArgs.GetString( "fx_idle" ) ) {
PlayEffect( "fx_idle", renderEntity.origin, renderEntity.axis, true );
}
}
/*
================
idItem::InstanceLeave
================
*/
void idItem::InstanceLeave( void ) {
idEntity::InstanceLeave();
StopEffect( "fx_idle", true );
}
/*
================
idItem::Spawn
================
*/
void idItem::Spawn( void ) {
idStr giveTo;
idEntity * ent;
idVec3 vSize;
idBounds bounds(vec3_origin);
// check for triggerbounds, which allows for non-square triggers (useful for, say, a CTF flag)
if ( spawnArgs.GetVector( "triggerbounds", "16 16 16", vSize )) {
bounds.AddPoint(idVec3( vSize.x*0.5f, vSize.y*0.5f, 0.0f));
bounds.AddPoint(idVec3(-vSize.x*0.5f, -vSize.y*0.5f, vSize.z));
}
else {
// create a square trigger for item pickup
float tsize;
spawnArgs.GetFloat( "triggersize", "16.0", tsize );
bounds.ExpandSelf( tsize );
}
// RAVEN BEGIN
// mwhitlock: Dynamic memory consolidation
RV_PUSH_HEAP_MEM(this);
// RAVEN END
trigger = new idClipModel( idTraceModel( bounds ));
// RAVEN BEGIN
// mwhitlock: Dynamic memory consolidation
RV_POP_HEAP();
// RAVEN END
// RAVEN BEGIN
// ddynerman: multiple clip worlds
trigger->Link( this, 0, GetPhysics()->GetOrigin(), GetPhysics()->GetAxis() );
// RAVEN END
physicsObj.SetSelf ( this );
// RAVEN BEGIN
// mwhitlock: Dynamic memory consolidation
RV_PUSH_HEAP_MEM(this);
// RAVEN END
physicsObj.SetClipModel( new idClipModel( GetPhysics()->GetClipModel() ), 1.0f );
// RAVEN BEGIN
// mwhitlock: Dynamic memory consolidation
RV_POP_HEAP();
// RAVEN END
physicsObj.SetOrigin( GetPhysics()->GetOrigin() );
physicsObj.SetAxis( GetPhysics()->GetAxis() );
physicsObj.SetGravity( gameLocal.GetGravity() );
physicsObj.SetContents( 0 );
physicsObj.SetClipMask( MASK_SOLID );
physicsObj.SetFriction( 0.0f, 0.0f, 6.0f );
SetPhysics( &physicsObj );
if ( spawnArgs.GetBool( "start_off" ) ) {
trigger->SetContents( 0 );
Hide();
} else {
trigger->SetContents( CONTENTS_TRIGGER );
}
giveTo = spawnArgs.GetString( "owner" );
if ( giveTo.Length() ) {
ent = gameLocal.FindEntity( giveTo );
if ( !ent ) {
gameLocal.Error( "Item couldn't find owner '%s'", giveTo.c_str() );
}
PostEventMS( &EV_Touch, 0, ent, NULL );
}
if ( spawnArgs.GetBool( "spin" ) || gameLocal.isMultiplayer ) {
spin = true;
BecomeActive( TH_THINK );
}
// pulse ( and therefore itemShellHandle ) was taken out and shot. do not sync
//pulse = !spawnArgs.GetBool( "nopulse" );
pulse = false;
orgOrigin = GetPhysics()->GetOrigin();
canPickUp = !( spawnArgs.GetBool( "triggerFirst" ) || spawnArgs.GetBool( "no_touch" ) );
inViewTime = -1000;
lastCycle = -1;
itemShellHandle = -1;
// RAVEN BEGIN
// abahr: move texture to def file for precaching
shellMaterial = declManager->FindMaterial( spawnArgs.GetString("mtr_highlight", "_default") );
PostEventMS( &EV_SetGravity, 0 );
// RAVEN END
if ( spawnArgs.GetString( "skin", NULL ) ) {
skin = declManager->FindSkin( spawnArgs.GetString( "skin" ), false );
if( skin ) {
SetSkin( skin );
srvReady = 1;
}
} else {
skin = NULL;
}
if ( spawnArgs.GetString( "skin_pickup", NULL ) ) {
pickupSkin = declManager->FindSkin( spawnArgs.GetString( "skin_pickup" ), false );
} else {
pickupSkin = NULL;
}
syncPhysics = spawnArgs.GetBool( "net_syncPhysics", "0" );
if ( srvReady == -1 ) {
srvReady = IsHidden() ? 0 : 1;
}
// RAVEN BEGIN
// mekberg: added for removing pickups in mp in pits
if ( gameLocal.isMultiplayer ) {
trigger->SetContents( trigger->GetContents() | CONTENTS_ITEMCLIP );
}
// RAVEN END
if( gameLocal.isMultiplayer ) {
itemPVSArea = gameLocal.pvs.GetPVSArea( GetPhysics()->GetOrigin() );
} else {
itemPVSArea = 0;
}
simpleItem = g_simpleItems.GetBool() && gameLocal.isMultiplayer && !IsType( rvItemCTFFlag::GetClassType() );
if( simpleItem ) {
memset( &renderEntity, 0, sizeof( renderEntity ) );
renderEntity.axis = mat3_identity;
renderEntity.shaderParms[ SHADERPARM_RED ] = 1.0f;
renderEntity.shaderParms[ SHADERPARM_GREEN ] = 1.0f;
renderEntity.shaderParms[ SHADERPARM_BLUE ] = 1.0f;
renderEntity.shaderParms[ SHADERPARM_ALPHA ] = 1.0f;
renderEntity.shaderParms[ SHADERPARM_SPRITE_WIDTH ] = 32.0f;
renderEntity.shaderParms[ SHADERPARM_SPRITE_HEIGHT ] = 32.0f;
renderEntity.hModel = renderModelManager->FindModel( "_sprite" );
renderEntity.callback = NULL;
renderEntity.numJoints = 0;
renderEntity.joints = NULL;
renderEntity.customSkin = 0;
renderEntity.noShadow = true;
renderEntity.noSelfShadow = true;
renderEntity.customShader = declManager->FindMaterial( spawnArgs.GetString( "mtr_simple_icon" ) );
renderEntity.referenceShader = 0;
renderEntity.bounds = renderEntity.hModel->Bounds( &renderEntity );
SetAxis( mat3_identity );
} else {
if ( spawnArgs.GetString( "fx_idle" ) ) {
UpdateModelTransform();
effectIdle = PlayEffect( "fx_idle", renderEntity.origin, renderEntity.axis, true );
}
}
GetPhysics( )->SetClipMask( GetPhysics( )->GetClipMask( ) | CONTENTS_ITEMCLIP );
pickedUp = false;
}
/*
================
idItem::Event_SetGravity
================
*/
void idItem::Event_SetGravity() {
// If the item isnt a dropped item then see if it should settle itself
// to the floor or not
if ( !spawnArgs.GetBool( "dropped" ) ) {
if ( spawnArgs.GetBool( "nodrop" ) ) {
physicsObj.PutToRest();
} else {
PostEventMS( &EV_DropToFloor, 0 );
}
}
}
// RAVEN END
/*
================
idItem::GetAttributes
================
*/
void idItem::GetAttributes( idDict &attributes ) {
int i;
const idKeyValue *arg;
for( i = 0; i < spawnArgs.GetNumKeyVals(); i++ ) {
arg = spawnArgs.GetKeyVal( i );
if ( arg->GetKey().Left( 4 ) == "inv_" ) {
attributes.Set( arg->GetKey().Right( arg->GetKey().Length() - 4 ), arg->GetValue() );
}
}
}
/*
================
idItem::GiveToPlayer
================
*/
bool idItem::GiveToPlayer( idPlayer *player ) {
if ( player == NULL ) {
return false;
}
if ( spawnArgs.GetBool( "inv_carry" ) ) {
return player->GiveInventoryItem( &spawnArgs );
}
// Handle the special ammo pickup that gives ammo for the weapon the player currently has
if ( spawnArgs.GetBool( "item_currentWeaponAmmo" ) ) {
const char *ammoName = player->weapon->GetAmmoNameForIndex(player->weapon->GetAmmoType());
if ( player->weapon->TotalAmmoCount() != player->weapon->maxAmmo && player->weapon->AmmoRequired() ) {
player->GiveItem(ammoName);
player->GiveInventoryItem( &spawnArgs );
return true;
}
return false;
}
return player->GiveItem( this );
}
/*
===============
idItem::SendPickupMsg
===============
*/
void idItem::SendPickupMsg( int clientNum ) {
idBitMsg msg;
byte msgBuf[MAX_GAME_MESSAGE_SIZE];
msg.Init( msgBuf, sizeof( msgBuf ) );
msg.WriteByte( GAME_UNRELIABLE_MESSAGE_EVENT );
msg.WriteBits( gameLocal.GetSpawnId( this ), 32 );
msg.WriteByte( EVENT_PICKUP );
msg.WriteByte( clientNum );
// send as unreliable to client picking up the item, so it can play HUD things
gameLocal.SendUnreliableMessagePVS( msg, this, itemPVSArea );
}
/*
================
idItem::Pickup
================
*/
bool idItem::Pickup( idPlayer *player ) {
//dropped weapon?
bool dropped = spawnArgs.GetBool( "dropped" );
if ( gameLocal.isMultiplayer && !dropped && spawnArgs.FindKey( "weaponclass" )
&& gameLocal.IsWeaponsStayOn() && gameLocal.time > player->lastPickupTime + 1000 ) {
idDict attr;
GetAttributes( attr );
const idKeyValue* arg = attr.FindKey( "weapon" );
if ( arg ) {
if ( !player->inventory.Give( player, player->spawnArgs, arg->GetKey(), arg->GetValue(), NULL, false, dropped, true ) ) {
StartSound( "snd_noacquire", SND_CHANNEL_ITEM, 0, false, NULL );
}
}
}
// only predict noacquire on client
if ( gameLocal.isClient ) {
return false;
}
int givenToPlayer = spawnArgs.GetInt( "givenToPlayer", "-1" );
if ( player == NULL || ( givenToPlayer != -1 && givenToPlayer != player->entityNumber ) ) {
// idPlayer::GiveItem spawns an idItem for pickup, which appears at the origin before being picked
// and could sometimes be picked by someone else, particularly in buy mode when there is a play spawn sitting on the origin ;-)
return false;
}
if ( !GiveToPlayer( player ) ) {
return false;
}
if ( gameLocal.isServer ) {
SendPickupMsg( player->entityNumber );
}
// Check for global acquire sounds in multiplayer
if ( gameLocal.isMultiplayer && spawnArgs.GetBool( "globalAcquireSound" ) ) {
gameLocal.mpGame.PlayGlobalItemAcquireSound( entityDefNumber );
} else {
StartSound( "snd_acquire", SND_CHANNEL_ITEM, 0, false, NULL );
}
// trigger our targets
ActivateTargets( player );
player->lastPickupTime = gameLocal.time;
//if a placed item and si_weaponStay is on and we're a weapon, don't remove and respawn
if ( gameLocal.IsMultiplayer() ) {
if ( !dropped ) {
if ( spawnArgs.FindKey( "weaponclass" ) ) {
if ( gameLocal.IsWeaponsStayOn() ) {
return true;
}
}
}
}
// clear our contents so the object isn't picked up twice
GetPhysics()->SetContents( 0 );
// hide the model, or switch to the pickup skin
if ( pickupSkin ) {
SetSkin( pickupSkin );
srvReady = 0;
} else {
Hide();
BecomeInactive( TH_THINK );
}
pickedUp = true;
// allow SetSkin or Hide() to get called regardless of simpleitem mode
if( simpleItem ) {
FreeModelDef();
UpdateVisuals();
}
// remove the highlight shell
if ( itemShellHandle != -1 ) {
gameRenderWorld->FreeEntityDef( itemShellHandle );
itemShellHandle = -1;
}
// asalmon: Added option for a differnt respawn rate based on gametype.
float respawn = spawnArgs.GetFloat(va("respawn_%s",gameLocal.serverInfo.GetString( "si_gameType" )), "-1.0");
if( respawn == -1.0f ) {
respawn = spawnArgs.GetFloat( "respawn", "5.0" );
}
bool no_respawn = spawnArgs.GetBool( "no_respawn" );
if ( !gameLocal.isMultiplayer ) {
respawn = 0.0f;
} else if ( gameLocal.mpGame.IsBuyingAllowedInTheCurrentGameMode() ) {
if ( givenToPlayer != -1 ) {
respawn = 0.0f;
}
}
if ( respawn && !dropped && !no_respawn ) {
const char *sfx = spawnArgs.GetString( "fx_Respawn" );
if ( sfx && *sfx ) {
PostEventSec( &EV_RespawnFx, respawn - 0.5f );
}
PostEventSec( &EV_RespawnItem, respawn );
} else if ( !spawnArgs.GetBool( "inv_objective" ) && !no_respawn ) {
// give some time for the pickup sound to play
// FIXME: Play on the owner
if ( !spawnArgs.GetBool( "inv_carry" ) ) {
PostEventMS( &EV_Remove, 5000 );
}
}
trigger->SetContents( 0 );
StopEffect( "fx_idle" );
return true;
}
/*
================
idItem::Hide
================
*/
void idItem::Hide( void ) {
srvReady = 0;
idEntity::Hide( );
trigger->SetContents( 0 );
}
/*
================
idItem::Show
================
*/
void idItem::Show( void ) {
srvReady = 1;
idEntity::Show( );
trigger->SetContents( CONTENTS_TRIGGER );
}
/*
================
idItem::ClientStale
================
*/
bool idItem::ClientStale( void ) {
idEntity::ClientStale();
StopEffect( "fx_idle" );
return false;
}
/*
================
idItem::ClientUnstale
================
*/
void idItem::ClientUnstale( void ) {
idEntity::ClientUnstale();
UpdateModelTransform();
if ( !simpleItem && spawnArgs.GetString( "fx_idle" ) ) {
PlayEffect( "fx_idle", renderEntity.origin, renderEntity.axis, true );
}
}
/*
================
idItem::ClientPredictionThink
================
*/
void idItem::ClientPredictionThink( void ) {
// only think forward because the state is not synced through snapshots
if ( !gameLocal.isNewFrame ) {
return;
}
Think();
}
/*
================
idItem::WriteFromSnapshot
================
*/
void idItem::WriteToSnapshot( idBitMsgDelta &msg ) const {
if ( syncPhysics ) {
physicsObj.WriteToSnapshot( msg );
}
assert( srvReady != -1 );
msg.WriteBits( ( srvReady == 1 ), 1 );
}
/*
================
idItem::ReadFromSnapshot
================
*/
void idItem::ReadFromSnapshot( const idBitMsgDelta &msg ) {
if ( syncPhysics ) {
physicsObj.ReadFromSnapshot( msg );
}
int newReady = ( msg.ReadBits( 1 ) != 0 );
idVec3 resetOrigin( 0, 0, 0 );
// client spawns the ent with ready == -1 so the state set happens at least once
if ( newReady != clReady ) {
if ( newReady ) {
// g_simpleItems might force a hide even with a pickup skin
if ( pickupSkin ) {
SetSkin( skin );
} else {
SetSkin( skin );
Show();
}
if( simpleItem ) {
UpdateVisuals();
}
pickedUp = false;
if ( effectIdle.GetEntity( ) ) {
UpdateModelTransform();
effectIdle->SetOrigin( resetOrigin );
} else if ( spawnArgs.GetString( "fx_idle" ) && !simpleItem ) {
UpdateModelTransform();
effectIdle = PlayEffect( "fx_idle", renderEntity.origin, renderEntity.axis, true );
}
} else {
if ( pickupSkin ) {
SetSkin( pickupSkin );
} else {
Hide();
}
if( simpleItem ) {
FreeModelDef();
UpdateVisuals();
}
pickedUp = true;
StopEffect( "fx_idle" );
effectIdle = NULL;
}
}
clReady = newReady;
}
/*
================
idItem::Event_Pickup
================
*/
void idItem::Event_Pickup( int clientNum ) {
idPlayer *player;
assert( gameLocal.isClient );
// play pickup sound
if ( !spawnArgs.GetBool( "globalAcquireSound" ) ) {
StartSound( "snd_acquire", SND_CHANNEL_ITEM, 0, false, NULL );
}
if( clientNum == gameLocal.localClientNum ) {
player = (idPlayer*)gameLocal.entities[ clientNum ];
player->lastPickupTime = gameLocal.time;
if ( player ) {
player->GiveItem( this );
}
}
}
/*
================
idItem::ClientReceiveEvent
================
*/
bool idItem::ClientReceiveEvent( int event, int time, const idBitMsg &msg ) {
switch( event ) {
case EVENT_PICKUP: {
int clientNum = msg.ReadByte();
if( clientNum >= 0 && clientNum < MAX_CLIENTS ) {
Event_Pickup( clientNum );
}
return true;
}
case EVENT_RESPAWNFX: {
Event_RespawnFx();
return true;
}
default: {
return idEntity::ClientReceiveEvent( event, time, msg );
}
}
//unreachable
// return false;
}
/*
================
idItem::Event_DropToFloor
================
*/
void idItem::Event_DropToFloor( void ) {
// don't drop the floor if bound to another entity
if ( GetBindMaster() != NULL && GetBindMaster() != this ) {
return;
}
physicsObj.DropToFloor( );
}
/*
================
idItem::Event_Touch
================
*/
void idItem::Event_Touch( idEntity *other, trace_t *trace ) {
// RAVEN BEGIN
// jnewquist: Use accessor for static class type
if ( !other->IsType( idPlayer::GetClassType() ) ) {
// RAVEN END
return;
}
if ( !canPickUp ) {
return;
}
Pickup( static_cast<idPlayer *>(other) );
}
/*
================
idItem::Event_Trigger
================
*/
void idItem::Event_Trigger( idEntity *activator ) {
if ( !canPickUp && spawnArgs.GetBool( "triggerFirst" ) ) {
canPickUp = true;
return;
}
// RAVEN BEGIN
// jnewquist: Use accessor for static class type
if ( activator && activator->IsType( idPlayer::GetClassType() ) ) {
// RAVEN END
Pickup( static_cast<idPlayer *>( activator ) );
}
}
/*
================
idItem::Event_Respawn
================
*/
void idItem::Event_Respawn( void ) {
// with simple items, re-show the item, but still set srvReady to true to let clients
// know how to deal
if ( pickupSkin ) {
srvReady = true;
if( !simpleItem ) {
SetSkin( skin );
}
}
if( !pickupSkin ) {
BecomeActive( TH_THINK );
Show();
}
if( simpleItem ) {
Show();
}
pickedUp = false;
inViewTime = -1000;
lastCycle = -1;
trigger->SetContents ( CONTENTS_TRIGGER );
SetOrigin( orgOrigin );
StartSound( "snd_respawn", SND_CHANNEL_ITEM, 0, false, NULL );
PostEventMS( &EV_SetGravity, 0 );
CancelEvents( &EV_RespawnItem ); // don't double respawn
if ( !simpleItem && spawnArgs.GetString( "fx_idle" ) ) {
UpdateModelTransform();
PlayEffect( "fx_idle", renderEntity.origin, renderEntity.axis, true );
}
}
/*
================
idItem::Event_RespawnFx
================
*/
void idItem::Event_RespawnFx( void ) {
idBitMsg msg;
byte msgBuf[MAX_GAME_MESSAGE_SIZE];
if ( gameLocal.isServer ) {
msg.Init( msgBuf, sizeof( msgBuf ) );
msg.WriteByte( GAME_UNRELIABLE_MESSAGE_EVENT );
msg.WriteBits( gameLocal.GetSpawnId( this ), 32 );
msg.WriteByte( EVENT_RESPAWNFX );
// send unreliable PVS-sensitive
gameLocal.SendUnreliableMessagePVS( msg, this, gameLocal.pvs.GetPVSArea( GetPhysics()->GetOrigin() ) );
}
if( !simpleItem ) {
gameLocal.PlayEffect( spawnArgs, "fx_respawn", GetPhysics()->GetOrigin(), idVec3(0,0,1).ToMat3(), false, vec3_origin );
}
}
/*
===============================================================================
idItemPowerup
===============================================================================
*/
/*
===============
idItemPowerup
===============
*/
CLASS_DECLARATION( idItem, idItemPowerup )
END_CLASS
/*
================
idItemPowerup::idItemPowerup
================
*/
idItemPowerup::idItemPowerup() {
time = 0;
type = 0;
droppedTime = 0;
unique = false;
}
/*
================
idItemPowerup::Save
================
*/
void idItemPowerup::Save( idSaveGame *savefile ) const {
savefile->WriteInt( time );
savefile->WriteInt( type );
savefile->WriteInt( droppedTime ); // cnicholson: Added unsaved var
}
/*
================
idItemPowerup::Restore
================
*/
void idItemPowerup::Restore( idRestoreGame *savefile ) {
savefile->ReadInt( time );
savefile->ReadInt( type );
savefile->ReadInt( droppedTime ); // cnicholson: Added unrestored var
}
/*
================
idItemPowerup::Spawn
================
*/
void idItemPowerup::Spawn( void ) {
time = SEC2MS( spawnArgs.GetInt( "time", "30" ) );
// SEC2MS screws up when we want -1 time (no expiration)
if( spawnArgs.GetInt( "time" ) == -1 ) {
time = -1;
}
type = spawnArgs.GetInt( "type", "0" );
// If the powerup was dropped then make it dissapear using its remaining time.
if ( spawnArgs.GetBool( "dropped" ) && time != -1 ) {
droppedTime = gameLocal.time + time;
PostEventMS( &EV_Remove, time );
}
// unique powerpus won't respawn while a player has them
unique = spawnArgs.GetBool( "unique", "0" );
if( unique ) {
spawnArgs.SetBool( "no_respawn", true );
}
if ( !idStr::Icmp( spawnArgs.GetString( "team" ), "strogg" ) ) {
team = TEAM_STROGG;
} else if( !idStr::Icmp( spawnArgs.GetString( "team" ), "marine" ) ) {
team = TEAM_MARINE;
} else {
team = -1;
}
}
/*
================
idItemPowerup::GiveToPlayer
================
*/
bool idItemPowerup::GiveToPlayer( idPlayer *player ) {
if ( player == NULL || player->spectating ) {
return false;
}
// only one arena CTF powerup at a time
if ( type >= POWERUP_AMMOREGEN && type <= POWERUP_SCOUT ) {
if ( ( player->inventory.powerups & ARENA_POWERUP_MASK ) != 0 ) {
return false;
}
}
// in flavours of arena CTF (or are idItemPowerups only used in Arena? or even, are idItemPowerups MP only?),
// ensure that items with a team can only be picked up by members of that team
if ( gameLocal.IsMultiplayer() && gameLocal.IsTeamGame() && team >= 0 ) {
if( team != player->team ) {
return false;
}
}
if ( droppedTime > 0 ) {
player->GivePowerUp( type, droppedTime - gameLocal.time );
} else {
player->GivePowerUp( type, time );
}
// also call idItem::GiveToPlayer so any inv_* keywords get applied
idItem::GiveToPlayer( player );
return true;
}
/*
================
idItemPowerup::Think
================
*/
void idItemPowerup::Think( void ) {
int i;
// idItem::Think() only needs to be called if we're spawned in
if( !IsHidden() || (pickupSkin && GetSkin() != pickupSkin ) ) {
// only get here if spawned in
idItem::Think();
return;
}
if( !unique ) {
// non-unique despawned powerups don't need to think
return;
}
for( i = 0; i < gameLocal.numClients; i++ ) {
idPlayer* p = (idPlayer*)gameLocal.entities[ i ];
if( p == NULL ) {
continue;
}
// only spawn back in if noone on your team has the powerup
if( p->PowerUpActive( type ) && p->team == team ) {
break;
}
}
if( i >= gameLocal.numClients ) {
PostEventMS( &EV_RespawnItem, 0 );
}
}
/*
================
idItemPowerup::Pickup
================
*/
bool idItemPowerup::Pickup( idPlayer* player ) {
// regular pickup routine, but unique items need to think to know when to respawn
bool pickup;
if( gameLocal.isClient ) {
// no client-side powerup prediction
return false;
}
pickup = idItem::Pickup( player );
if( unique ) {
BecomeActive( TH_THINK );
}
return pickup;
}
/*
===============================================================================
idObjective
===============================================================================
*/
CLASS_DECLARATION( idItem, idObjective )
EVENT( EV_Activate, idObjective::Event_Trigger )
EVENT( EV_HideObjective, idObjective::Event_HideObjective )
EVENT( EV_GetPlayerPos, idObjective::Event_GetPlayerPos )
EVENT( EV_CamShot, idObjective::Event_CamShot )
END_CLASS
/*
================
idObjective::idObjective
================
*/
idObjective::idObjective() {
playerPos.Zero();
// RAVEN BEGIN
// mekberg: store triggered time for timed removal.
triggerTime = 0;
// RAVEN END
}
/*
================
idObjective::Save
================
*/
void idObjective::Save( idSaveGame *savefile ) const {
savefile->WriteVec3( playerPos );
}
/*
================
idObjective::Restore
================
*/
void idObjective::Restore( idRestoreGame *savefile ) {
savefile->ReadVec3( playerPos );
// RAVEN BEGIN
// jnewquist: Don't do this on Xenon, we want prebuilt textures
#ifndef _XENON
PostEventMS( &EV_CamShot, 250 );
#endif
// RAVEN END
}
/*
================
idObjective::Spawn
================
*/
void idObjective::Spawn( void ) {
Hide();
// RAVEN BEGIN
// jnewquist: Only post a camshot event if the spawn args request it
#ifndef _XENON
const char *camName;
if ( spawnArgs.GetString( "camShot", "", &camName ) ) {
common->Warning( "SpawnArg camShot on %s is not recommended.", spawnArgs.GetString( "name" ) );
PostEventMS( &EV_CamShot, 250 );
}
#endif
// RAVEN END
}
/*
================
idObjective::Event_Screenshot
================
*/
void idObjective::Event_CamShot( ) {
const char *camName;
// RAVEN BEGIN
// bdube: changed screenshot location
idStr shotName = "gfx/objectives/";
shotName += spawnArgs.GetString( "screenshot" );
shotName.SetFileExtension( ".tga" );
// RAVEN END
if ( spawnArgs.GetString( "camShot", "", &camName ) ) {
idEntity *ent = gameLocal.FindEntity( camName );
if ( ent && ent->cameraTarget ) {
const renderView_t *view = ent->cameraTarget->GetRenderView();
renderView_t fullView = *view;
fullView.width = SCREEN_WIDTH;
fullView.height = SCREEN_HEIGHT;
// draw a view to a texture
renderSystem->CropRenderSize( 256, 256, true );
gameRenderWorld->RenderScene( &fullView );
// TTimo: I don't think this jives with SMP code, but I grepped through the final maps and didn't see any using it
renderSystem->CaptureRenderToFile( shotName );
renderSystem->UnCrop();
}
}
}
/*
================
idObjective::Event_Trigger
================
*/
void idObjective::Event_Trigger( idEntity *activator ) {
idPlayer *player = gameLocal.GetLocalPlayer();
if ( player ) {
if ( spawnArgs.GetString( "inv_objective", NULL ) ) {
// RAVEN BEGIN
// abahr: changed player->hud to player->GetHud so when in a vehicle we update the vehicle hud
// twhitaker: changed player->hud to player->GetObjectiveHud(), to resolve all issues
if ( player && player->GetObjectiveHud() ) {
// bdube: changed screenshot location
idStr shotName = spawnArgs.GetString( "screenshot" );
player->GetObjectiveHud()->SetStateString( "screenshot", shotName );
player->GetObjectiveHud()->SetStateString( "objective", "1" );
player->GetObjectiveHud()->SetStateString( "objectivetext", common->GetLocalizedString( spawnArgs.GetString( "objectivetext" ) ) );
player->GetObjectiveHud()->SetStateString( "objectivetitle", common->GetLocalizedString( spawnArgs.GetString( "objectivetitle" ) ) );
// RAVEN END
player->GiveObjective( spawnArgs.GetString( "objectivetitle" ), spawnArgs.GetString( "objectivetext" ), shotName );
// a tad slow but keeps from having to update all objectives in all maps with a name ptr
for( int i = 0; i < gameLocal.num_entities; i++ ) {
// RAVEN BEGIN
// jnewquist: Use accessor for static class type
if ( gameLocal.entities[ i ] && gameLocal.entities[ i ]->IsType( idObjectiveComplete::GetClassType() ) ) {
// RAVEN END
if ( idStr::Icmp( spawnArgs.GetString( "objectivetitle" ), gameLocal.entities[ i ]->spawnArgs.GetString( "objectivetitle" ) ) == 0 ){
gameLocal.entities[ i ]->spawnArgs.SetBool( "objEnabled", true );
break;
}
}
}
PostEventMS( &EV_GetPlayerPos, 2000 );
// RAVEN BEGIN
// mekberg: store triggered time for timed removal.
triggerTime = gameLocal.time;
// RAVEN END
}
}
}
}
/*
================
idObjective::Event_GetPlayerPos
================
*/
void idObjective::Event_GetPlayerPos() {
idPlayer *player = gameLocal.GetLocalPlayer();
if ( player ) {
playerPos = player->GetPhysics()->GetOrigin();
PostEventMS( &EV_HideObjective, 100, player );
}
}
/*
================
idObjective::Event_HideObjective
================
*/
void idObjective::Event_HideObjective(idEntity *e) {
idPlayer *player = gameLocal.GetLocalPlayer();
if ( player ) {
idVec3 v = player->GetPhysics()->GetOrigin() - playerPos;
// RAVEN BEGIN
// mekberg: hide time done internally now
if ( v.Length() > 64.0f || gameLocal.time > triggerTime + 5000 ) {
// RAVEN END
player->HideObjective ( );
PostEventMS( &EV_Remove, 0 );
} else {
PostEventMS( &EV_HideObjective, 100, player );
}
}
}
/*
===============================================================================
idMoveableItem
===============================================================================
*/
CLASS_DECLARATION( idItem, idMoveableItem )
EVENT( EV_Gib, idMoveableItem::Event_Gib )
END_CLASS
/*
================
idMoveableItem::idMoveableItem
================
*/
idMoveableItem::idMoveableItem() {
}
/*
================
idMoveableItem::~idMoveableItem
================
*/
idMoveableItem::~idMoveableItem() {
// If this entity has been allocated, but not spawned, the physics object will
// not have a self pointer, and will not unregister itself from the entity.
SetPhysics( NULL );
}
/*
================
idMoveableItem::Save
================
*/
void idMoveableItem::Save( idSaveGame *savefile ) const {
savefile->WriteStaticObject( physicsObj );
}
/*
================
idMoveableItem::Restore
================
*/
void idMoveableItem::Restore( idRestoreGame *savefile ) {
savefile->ReadStaticObject ( physicsObj );
RestorePhysics ( &physicsObj );
}
/*
================
idMoveableItem::Spawn
================
*/
void idMoveableItem::Spawn( void ) {
idTraceModel trm;
float density, friction, bouncyness;
idStr clipModelName;
idBounds bounds;
// if the model should be shrinked
if ( spawnArgs.GetBool( "clipshrink" ) ) {
trm.Shrink( CM_CLIP_EPSILON );
}
// get rigid body properties
spawnArgs.GetFloat( "density", "0.5", density );
density = idMath::ClampFloat( 0.001f, 1000.0f, density );
spawnArgs.GetFloat( "friction", "0.05", friction );
friction = idMath::ClampFloat( 0.0f, 1.0f, friction );
spawnArgs.GetFloat( "bouncyness", "0.6", bouncyness );
bouncyness = idMath::ClampFloat( 0.0f, 1.0f, bouncyness );
// setup the physics
physicsObj.SetSelf( this );
// RAVEN BEGIN
// mwhitlock: Dynamic memory consolidation
RV_PUSH_HEAP_MEM(this);
// check if a clip model is set
spawnArgs.GetString( "itemclipmodel", "", clipModelName );
if ( clipModelName[0] ) {
if ( collisionModelManager->TrmFromModel( gameLocal.GetMapName(), clipModelName, trm ) ) {
physicsObj.SetClipModel( new idClipModel( trm ), density );
} else {
// fallback
physicsObj.SetClipModel( new idClipModel( GetPhysics()->GetClipModel() ), density );
}
} else {
// fallback
physicsObj.SetClipModel( new idClipModel( GetPhysics()->GetClipModel() ), density );
}
// mwhitlock: Dynamic memory consolidation
RV_POP_HEAP();
// RAVEN END
physicsObj.SetOrigin( GetPhysics()->GetOrigin() );
physicsObj.SetAxis( GetPhysics()->GetAxis() );
physicsObj.SetBouncyness( bouncyness );
physicsObj.SetFriction( 0.6f, 0.6f, friction );
physicsObj.SetGravity( gameLocal.GetGravity() );
physicsObj.SetContents( CONTENTS_RENDERMODEL );
physicsObj.SetClipMask( MASK_SOLID | CONTENTS_MOVEABLECLIP );
SetPhysics( &physicsObj );
// RAVEN BEGIN
// mekberg: added
if ( spawnArgs.GetBool( "noimpact" ) || spawnArgs.GetBool( "notPushable" ) ) {
physicsObj.DisableImpact();
}
// RAVEN END
}
/*
================
idMoveableItem::Think
================
*/
void idMoveableItem::Think( void ) {
RunPhysics();
UpdateTrigger( );
Present();
}
/*
================
idMoveableItem::DropItem
================
*/
idEntity *idMoveableItem::DropItem( const char *classname, const idVec3 &origin, const idMat3 &axis, const idVec3 &velocity, int activateDelay, int removeDelay ) {
idDict args;
idEntity *item;
args.Set( "classname", classname );
args.Set( "dropped", "1" );
// we sometimes drop idMoveables here, so set 'nodrop' to 1 so that it doesn't get put on the floor
args.Set( "nodrop", "1" );
if ( activateDelay ) {
args.SetBool( "triggerFirst", true );
}
gameLocal.SpawnEntityDef( args, &item );
if ( item ) {
// set item position
item->GetPhysics()->SetOrigin( origin );
item->GetPhysics()->SetAxis( axis );
item->GetPhysics()->SetLinearVelocity( velocity );
item->UpdateVisuals();
if ( activateDelay ) {
item->PostEventMS( &EV_Activate, activateDelay, item );
}
if ( !removeDelay ) {
removeDelay = 5 * 60 * 1000;
}
// always remove a dropped item after 5 minutes in case it dropped to an unreachable location
item->PostEventMS( &EV_Remove, removeDelay );
}
return item;
}
/*
================
idMoveableItem::DropItems
The entity should have the following key/value pairs set:
"def_drop<type>Item" "item def"
"drop<type>ItemJoint" "joint name"
"drop<type>ItemRotation" "pitch yaw roll"
"drop<type>ItemOffset" "x y z"
"skin_drop<type>" "skin name"
To drop multiple items the following key/value pairs can be used:
"def_drop<type>Item<X>" "item def"
"drop<type>Item<X>Joint" "joint name"
"drop<type>Item<X>Rotation" "pitch yaw roll"
"drop<type>Item<X>Offset" "x y z"
where <X> is an aribtrary string.
================
*/
void idMoveableItem::DropItems( idAnimatedEntity *ent, const char *type, idList<idEntity *> *list ) {
const idKeyValue *kv;
const char *skinName, *c, *jointName;
idStr key, key2;
idVec3 origin;
idMat3 axis;
idAngles angles;
const idDeclSkin *skin;
jointHandle_t joint;
idEntity *item;
// drop all items
kv = ent->spawnArgs.MatchPrefix( va( "def_drop%sItem", type ), NULL );
while ( kv ) {
c = kv->GetKey().c_str() + kv->GetKey().Length();
if ( idStr::Icmp( c - 5, "Joint" ) != 0 && idStr::Icmp( c - 8, "Rotation" ) != 0 ) {
key = kv->GetKey().c_str() + 4;
key2 = key;
key += "Joint";
key2 += "Offset";
jointName = ent->spawnArgs.GetString( key );
joint = ent->GetAnimator()->GetJointHandle( jointName );
if ( !ent->GetJointWorldTransform( joint, gameLocal.time, origin, axis ) ) {
gameLocal.Warning( "%s refers to invalid joint '%s' on entity '%s'\n", key.c_str(), jointName, ent->name.c_str() );
origin = ent->GetPhysics()->GetOrigin();
axis = ent->GetPhysics()->GetAxis();
}
if ( g_dropItemRotation.GetString()[0] ) {
angles.Zero();
sscanf( g_dropItemRotation.GetString(), "%f %f %f", &angles.pitch, &angles.yaw, &angles.roll );
} else {
key = kv->GetKey().c_str() + 4;
key += "Rotation";
ent->spawnArgs.GetAngles( key, "0 0 0", angles );
}
axis *= angles.ToMat3() * axis;
origin += ent->spawnArgs.GetVector( key2, "0 0 0" );
item = DropItem( kv->GetValue(), origin, axis, vec3_origin, 0, 0 );
if ( list && item ) {
list->Append( item );
}
}
kv = ent->spawnArgs.MatchPrefix( va( "def_drop%sItem", type ), kv );
}
// change the skin to hide all items
skinName = ent->spawnArgs.GetString( va( "skin_drop%s", type ) );
if ( skinName[0] ) {
skin = declManager->FindSkin( skinName );
ent->SetSkin( skin );
}
}
/*
======================
idMoveableItem::WriteToSnapshot
======================
*/
void idMoveableItem::WriteToSnapshot( idBitMsgDelta &msg ) const {
physicsObj.WriteToSnapshot( msg );
}
/*
======================
idMoveableItem::ReadFromSnapshot
======================
*/
void idMoveableItem::ReadFromSnapshot( const idBitMsgDelta &msg ) {
physicsObj.ReadFromSnapshot( msg );
if ( msg.HasChanged() ) {
UpdateVisuals();
}
}
/*
============
idMoveableItem::Gib
============
*/
void idMoveableItem::Gib( const idVec3 &dir, const char *damageDefName ) {
// remove the entity
PostEventMS( &EV_Remove, 0 );
}
/*
============
idMoveableItem::Event_Gib
============
*/
void idMoveableItem::Event_Gib( const char *damageDefName ) {
Gib( idVec3( 0, 0, 1 ), damageDefName );
}
/*
===============================================================================
idItemRemover
===============================================================================
*/
CLASS_DECLARATION( idEntity, idItemRemover )
EVENT( EV_Activate, idItemRemover::Event_Trigger )
END_CLASS
/*
================
idItemRemover::Spawn
================
*/
void idItemRemover::Spawn( void ) {
}
/*
================
idItemRemover::RemoveItem
================
*/
void idItemRemover::RemoveItem( idPlayer *player ) {
const char *remove;
remove = spawnArgs.GetString( "remove" );
player->RemoveInventoryItem( remove );
}
/*
================
idItemRemover::Event_Trigger
================
*/
void idItemRemover::Event_Trigger( idEntity *activator ) {
// RAVEN BEGIN
// jnewquist: Use accessor for static class type
if ( activator->IsType( idPlayer::GetClassType() ) ) {
// RAVEN END
RemoveItem( static_cast<idPlayer *>(activator) );
}
}
/*
===============================================================================
idObjectiveComplete
===============================================================================
*/
CLASS_DECLARATION( idItemRemover, idObjectiveComplete )
EVENT( EV_Activate, idObjectiveComplete::Event_Trigger )
EVENT( EV_HideObjective, idObjectiveComplete::Event_HideObjective )
EVENT( EV_GetPlayerPos, idObjectiveComplete::Event_GetPlayerPos )
END_CLASS
/*
================
idObjectiveComplete::idObjectiveComplete
================
*/
idObjectiveComplete::idObjectiveComplete() {
playerPos.Zero();
// RAVEN BEGIN
// mekberg: store triggered time for timed removal.
triggerTime = 0;
// RAVEN END
}
/*
================
idObjectiveComplete::Save
================
*/
void idObjectiveComplete::Save( idSaveGame *savefile ) const {
savefile->WriteVec3( playerPos );
}
/*
================
idObjectiveComplete::Restore
================
*/
void idObjectiveComplete::Restore( idRestoreGame *savefile ) {
savefile->ReadVec3( playerPos );
}
/*
================
idObjectiveComplete::Spawn
================
*/
void idObjectiveComplete::Spawn( void ) {
spawnArgs.SetBool( "objEnabled", false );
Hide();
}
/*
================
idObjectiveComplete::Event_Trigger
================
*/
void idObjectiveComplete::Event_Trigger( idEntity *activator ) {
if ( !spawnArgs.GetBool( "objEnabled" ) ) {
return;
}
idPlayer *player = gameLocal.GetLocalPlayer();
if ( player ) {
RemoveItem( player );
if ( spawnArgs.GetString( "inv_objective", NULL ) ) {
// RAVEN BEGIN
// abahr: changed player->hud to player->GetHud so if in a vehicle we update that hud
// twhitaker: moved objective system to it's own hud, to solve vehicle hud issues.
if ( player->GetObjectiveHud() ) {
player->GetObjectiveHud()->SetStateString( "objective", "2" );
player->GetObjectiveHud()->SetStateString( "objectivetext", common->GetLocalizedString( spawnArgs.GetString( "objectivetext" ) ) );
player->GetObjectiveHud()->SetStateString( "objectivetitle", common->GetLocalizedString( spawnArgs.GetString( "objectivetitle" ) ) );
// RAVEN END
player->CompleteObjective( spawnArgs.GetString( "objectivetitle" ) );
PostEventMS( &EV_GetPlayerPos, 2000 );
// RAVEN BEGIN
// mekberg: store triggered time for timed removal.
triggerTime = gameLocal.time;
// RAVEN END
}
}
}
}
/*
================
idObjectiveComplete::Event_GetPlayerPos
================
*/
void idObjectiveComplete::Event_GetPlayerPos() {
idPlayer *player = gameLocal.GetLocalPlayer();
if ( player ) {
playerPos = player->GetPhysics()->GetOrigin();
PostEventMS( &EV_HideObjective, 100, player );
}
}
/*
================
idObjectiveComplete::Event_HideObjective
================
*/
void idObjectiveComplete::Event_HideObjective( idEntity *e ) {
idPlayer *player = gameLocal.GetLocalPlayer();
if ( player && player->GetObjectiveHud() ) {
idVec3 v = player->GetPhysics()->GetOrigin();
v -= playerPos;
// RAVEN BEGIN
// mekberg: hide time done internally now
if ( v.Length() > 64.0f || gameLocal.time > triggerTime + 5000 ) {
// RAVEN END
player->HideObjective ( );
PostEventMS( &EV_Remove, 0 );
} else {
PostEventMS( &EV_HideObjective, 100, player );
}
}
}
/*
===============================================================================
rvObjectiveFailed
===============================================================================
*/
CLASS_DECLARATION( idItemRemover, rvObjectiveFailed )
EVENT( EV_Activate, rvObjectiveFailed::Event_Trigger )
END_CLASS
rvObjectiveFailed::rvObjectiveFailed ( void ) {
}
/*
================
rvObjectiveFailed::Event_Trigger
================
*/
void rvObjectiveFailed::Event_Trigger( idEntity *activator ) {
idPlayer *player = gameLocal.GetLocalPlayer();
if ( !player || !player->GetObjectiveHud() ) {
return;
}
if ( !spawnArgs.GetString( "inv_objective", NULL ) ) {
return;
}
player->GetObjectiveHud()->SetStateString( "objective", "2" );
player->GetObjectiveHud()->SetStateString( "objectivetext", common->GetLocalizedString( spawnArgs.GetString( "objectivetext" ) ) );
player->GetObjectiveHud()->SetStateString( "objectivetitle", common->GetLocalizedString( spawnArgs.GetString( "objectivetitle" ) ) );
player->FailObjective( spawnArgs.GetString( "objectivetitle" ) );
}
/*
===============================================================================
rvItemCTFFlag
===============================================================================
*/
const idEventDef EV_ResetFlag ( "<resetflag>" );
const idEventDef EV_LinkTrigger( "<linktrigger>" );
CLASS_DECLARATION( idItem, rvItemCTFFlag )
EVENT( EV_ResetFlag, rvItemCTFFlag::Event_ResetFlag )
EVENT( EV_LinkTrigger, rvItemCTFFlag::Event_LinkTrigger )
END_CLASS
/*
================
rvItemCTFFlag::rvItemCTFFlag
================
*/
rvItemCTFFlag::rvItemCTFFlag() {
}
/*
================
rvItemCTFFlag::Spawn
================
*/
void rvItemCTFFlag::Spawn () {
/* rjohnson: I fixed the crash so we don't need to remove them...
//don't spawn outside of CTF games
if( (gameLocal.gameType != GAME_CTF) && (gameLocal.gameType != GAME_1F_CTF) &&
(gameLocal.gameType != GAME_ARENA_CTF) && (gameLocal.gameType != GAME_ARENA_1F_CTF) ){
//don't spawn!
gameLocal.Error("Flag spawn on in non-CTF gametype.");
PostEventMS ( &EV_Remove, 0 );
return;
}
*/
spawnArgs.GetBool ( "dropped", "0", dropped );
spawnArgs.GetInt ( "team", "0", team );
bool reset = false;
spawnArgs.GetBool ( "reset", "0", reset );
switch ( team ) {
case TEAM_MARINE: {
powerup = POWERUP_CTF_MARINEFLAG;
gameLocal.mpGame.SetFlagEntity( this, TEAM_MARINE );
break;
}
case TEAM_STROGG: {
powerup = POWERUP_CTF_STROGGFLAG;
gameLocal.mpGame.SetFlagEntity( this, TEAM_STROGG );
break;
}
case TEAM_MAX: {
powerup = POWERUP_CTF_ONEFLAG;
break;
}
default:
gameLocal.Warning ( "Unknown ctf flag team '%d' on entity '%s'", team, name.c_str() );
PostEventMS ( &EV_Remove, 0 );
return;
}
if ( dropped ) {
if ( !gameLocal.isClient ) {
((rvCTFGameState*)gameLocal.mpGame.GetGameState())->SetFlagState( team, FS_DROPPED );
}
if ( reset ) {
//PostEventSec( &EV_ResetFlag, 1 );
} else {
PostEventSec( &EV_ResetFlag, 30 );
}
// Let powerups settle for a frame before allowing them to be picked up - we need to
// make sure we hit the dropped state for VO, etc to work properly
trigger->SetContents( 0 );
PostEventSec( &EV_LinkTrigger, 0 );
} else {
if ( !gameLocal.isClient ) {
((rvCTFGameState*)gameLocal.mpGame.GetGameState())->SetFlagState( team, FS_AT_BASE );
}
}
GetPhysics( )->SetClipMask( GetPhysics( )->GetClipMask( ) | CONTENTS_ITEMCLIP );
spin = false;
}
/*
================
rvItemCTFFlag::Event_LinkTrigger
================
*/
void rvItemCTFFlag::Event_LinkTrigger( void ) {
trigger->SetContents( CONTENTS_TRIGGER | CONTENTS_ITEMCLIP );
}
/*
================
rvItemCTFFlag::GiveToPlayer
================
*/
bool rvItemCTFFlag::GiveToPlayer( idPlayer* player ) {
if ( !gameLocal.IsMultiplayer() ) {
return false;
}
if ( player->spectating || ((gameLocal.mpGame.GetGameState())->GetMPGameState() != GAMEON && (gameLocal.mpGame.GetGameState())->GetMPGameState() != SUDDENDEATH && !cvarSystem->GetCVarBool( "g_testCTF" )) ) {
return false;
}
int teamPowerup;
int enemyPowerup;
bool canPickup = ( team == player->team );
switch ( player->team ) {
default:
case TEAM_MARINE:
teamPowerup = POWERUP_CTF_MARINEFLAG;
enemyPowerup = POWERUP_CTF_STROGGFLAG;
break;
case TEAM_STROGG:
teamPowerup = POWERUP_CTF_STROGGFLAG;
enemyPowerup = POWERUP_CTF_MARINEFLAG;
break;
}
if( gameLocal.gameType == GAME_1F_CTF || gameLocal.gameType == GAME_ARENA_1F_CTF ) {
// in one flag CTF, we score touching the enemy's flag
canPickup = ( team == gameLocal.mpGame.OpposingTeam( player->team ) );
enemyPowerup = POWERUP_CTF_ONEFLAG;
}
// If the player runs over their own flag the only thing they
// can do is score or return it.
// when the player touches the one flag, he always gets it
if ( canPickup ) {
// If the flag was dropped, return it
if ( dropped ) {
gameLocal.mpGame.AddPlayerTeamScore( player, 2 );
statManager->FlagReturned( player );
ResetFlag ( teamPowerup );
// RITUAL BEGIN
// squirrel: Mode-agnostic buymenus
player->GiveCash( (float)gameLocal.mpGame.mpBuyingManager.GetIntValueForKey( "playerCashAward_flagReturned", 0 ) );
// RITUAL END
} else if ( player->PowerUpActive ( enemyPowerup ) ) {
// If they have the enemy flag then they score
if ( !gameLocal.mpGame.CanCapture ( player->team ) ) {
return false;
}
ResetFlag( enemyPowerup );
gameLocal.mpGame.FlagCaptured( player );
}
return false;
}
// only pickup one flag in arena CTF
if( ( gameLocal.gameType == GAME_1F_CTF || gameLocal.gameType == GAME_ARENA_1F_CTF ) && team != TEAM_MAX ) {
return false;
}
player->GivePowerUp( enemyPowerup, -1 );
// RITUAL BEGIN
// squirrel: Mode-agnostic buymenus
player->GiveCash( (float)gameLocal.mpGame.mpBuyingManager.GetIntValueForKey( "playerCashAward_flagStolen", 0 ) );
// RITUAL END
return true;
}
/*
================
rvItemCTFFlag::Pickup
================
*/
bool rvItemCTFFlag::Pickup( idPlayer *player ) {
if( gameLocal.isClient ) {
// no client-side CTF flag prediction
return false;
}
if ( !GiveToPlayer( player ) ) {
return false;
}
// ServerSendEvent( EVENT_PICKUP, NULL, false, -1 );
if ( gameLocal.isServer ) {
SendPickupMsg( player->entityNumber );
}
// Check for global acquire sounds in multiplayer
if ( gameLocal.isMultiplayer && spawnArgs.GetBool( "globalAcquireSound" ) ) {
gameLocal.mpGame.PlayGlobalItemAcquireSound( entityDefNumber );
} else {
StartSound( "snd_acquire", SND_CHANNEL_ITEM, 0, false, NULL );
}
// trigger our targets
ActivateTargets( player );
// clear our contents so the object isn't picked up twice
GetPhysics()->SetContents( 0 );
// hide the model
Hide();
gameLocal.mpGame.SetFlagEntity( NULL, team );
gameLocal.mpGame.AddPlayerTeamScore( player, 1 );
if( gameLocal.gameType == GAME_CTF || gameLocal.gameType == GAME_ARENA_CTF ) {
((rvCTFGameState*)gameLocal.mpGame.GetGameState())->SetFlagState( team, FS_TAKEN );
} else if( gameLocal.gameType == GAME_1F_CTF || gameLocal.gameType == GAME_ARENA_1F_CTF ) {
((rvCTFGameState*)gameLocal.mpGame.GetGameState())->SetFlagState( team, (player->team == TEAM_MARINE ? FS_TAKEN_MARINE : FS_TAKEN_STROGG) );
}
((rvCTFGameState*)gameLocal.mpGame.GetGameState())->SetFlagCarrier( team, player->entityNumber );
if ( spawnArgs.GetBool( "dropped" ) ) {
PostEventMS( &EV_Remove, 0 );
}
BecomeInactive( TH_THINK );
return true;
}
/*
================
rvItemCTFFlag::ResetFlag
================
*/
void rvItemCTFFlag::ResetFlag( int powerup ) {
idEntity* ent;
for ( ent = gameLocal.spawnedEntities.Next(); ent != NULL; ent = ent->spawnNode.Next() ) {
// Make sure no players have the flag anymore
// RAVEN BEGIN
// jnewquist: Use accessor for static class type
if ( ent->IsType ( idPlayer::GetClassType() ) ) {
// RAVEN END
static_cast<idPlayer*>(ent)->ClearPowerup ( powerup );
continue;
}
// If its not a CTF flag item then skip it
if ( !ent->IsType( rvItemCTFFlag::Type ) ) {
continue;
}
// Make sure its the right type first
rvItemCTFFlag* flag;
flag = static_cast<rvItemCTFFlag*>(ent);
if ( flag->powerup != powerup ) {
continue;
}
if ( flag->dropped ) {
flag->PostEventMS( &EV_Remove, 0 );
} else {
flag->PostEventMS( &EV_RespawnItem, 0 );
gameLocal.mpGame.SetFlagEntity( flag, flag->team );
}
}
if ( !gameLocal.isClient ) {
int team = -1;
if ( powerup == POWERUP_CTF_MARINEFLAG ) {
team = TEAM_MARINE;
} else if ( powerup == POWERUP_CTF_STROGGFLAG ) {
team = TEAM_STROGG;
} else if ( powerup == POWERUP_CTF_ONEFLAG ) {
team = TEAM_MAX;
}
((rvCTFGameState*)gameLocal.mpGame.GetGameState())->SetFlagState( team, FS_AT_BASE );
}
}
/*
================
rvItemCTFFlag::Event_ResetFlag
================
*/
void rvItemCTFFlag::Event_ResetFlag( void ) {
ResetFlag( powerup );
}
void rvItemCTFFlag::Think( void ) {
idItem::Think();
}
/*
================
rvItemCTFFlag::Collide
================
*/
bool rvItemCTFFlag::Collide( const trace_t &collision, const idVec3 &velocity ) {
idEntity* lol = gameLocal.entities[ collision.c.entityNum ];
if ( collision.c.contents & CONTENTS_ITEMCLIP && lol && !lol->IsType( idItem::GetClassType() ) ) {
ResetFlag( powerup );
}
return false;
}
// RAVEN END
const idEventDef EV_ResetSpawn ( "<resetspawn>" );
CLASS_DECLARATION( idItemPowerup, riDeadZonePowerup )
EVENT( EV_ResetSpawn, riDeadZonePowerup::Event_ResetSpawn )
END_CLASS
/*
================
riDeadZonePowerup::idItemPowerup
================
*/
riDeadZonePowerup::riDeadZonePowerup() {
}
/*
================
riDeadZonePowerup::Save
================
*/
void riDeadZonePowerup::Save( idSaveGame *savefile ) const {
}
/*
================
riDeadZonePowerup::Restore
================
*/
void riDeadZonePowerup::Restore( idRestoreGame *savefile ) {
}
/*
================
riDeadZonePowerup::Show
================
*/
void riDeadZonePowerup::Show()
{
idItem::Show();
}
/*
================
riDeadZonePowerup::Spawn
================
*/
void riDeadZonePowerup::Spawn( void ) {
powerup = POWERUP_DEADZONE;
time = SEC2MS( gameLocal.serverInfo.GetInt("si_deadZonePowerupTime") );
if ( spawnArgs.GetBool( "dropped" ) ) {
time = SEC2MS( spawnArgs.GetInt( "time", "10" ) );
if ( time > SEC2MS(10) )
time = SEC2MS(10);
Show();
CancelEvents(&EV_Remove);
PostEventSec( &EV_ResetSpawn, MS2SEC(time) );
}
else
Hide();
}
/*
================
riDeadZonePowerup::Pickup
================
*/
bool riDeadZonePowerup::Pickup( idPlayer* player ) {
// regular pickup routine, but unique items need to think to know when to respawn
bool pickup;
if ( player->PowerUpActive(POWERUP_DEADZONE) )
return false;
pickup = idItemPowerup::Pickup( player );
if ( spawnArgs.GetBool( "dropped" ) ) {
// Cancel the respawn so the powerup doesn't get removed
// from the player that just picked it up.
PostEventMS( &EV_Remove, 0 );
CancelEvents( &EV_ResetSpawn );
}
return pickup;
}
/*
================
riDeadZonePowerup::ResetSpawn
================
*/
void riDeadZonePowerup::ResetSpawn( int powerup ) {
int count = 1;
idEntity* ent;
riDeadZonePowerup* spawnSpot = 0;
for ( ent = gameLocal.spawnedEntities.Next(); ent != NULL; ent = ent->spawnNode.Next() ) {
// If its not a DeadZone powerup then skip it
if ( !ent->IsType( riDeadZonePowerup::Type ) ) {
continue;
}
// Make sure its the right type first
riDeadZonePowerup* flag;
flag = static_cast<riDeadZonePowerup*>(ent);
if ( flag->powerup != powerup ) {
continue;
}
if ( flag->spawnArgs.GetBool("dropped", "0") && flag == this ) {
flag->PostEventMS( &EV_Remove, 0 );
} else {
if ( !flag->IsVisible() ) {
if ( !(rand()%count) ) {
spawnSpot = flag;
if ( flag->spawnArgs.GetBool("dropped", "0") )
gameLocal.DPrintf("WARNING: Trying to spawn a powerup at a DROPPED location!");
}
count++;
}
}
}
if ( spawnSpot ) {
spawnSpot->Show();
spawnSpot->PostEventMS( &EV_RespawnItem, 0 );
}
else {
gameLocal.DPrintf("WARNING: Failed to find a valid spawn spot!");
}
}
/*
================
riDeadZonePowerup::Collide
================
*/
bool riDeadZonePowerup::Collide( const trace_t &collision, const idVec3 &velocity ) {
idEntity* lol = gameLocal.entities[ collision.c.entityNum ];
if ( gameLocal.isMultiplayer && collision.c.contents & CONTENTS_ITEMCLIP && lol && !lol->IsType( idItem::GetClassType() ) ) {
PostEventMS( &EV_ResetSpawn, 0 ); // Just respawn it.
}
return false;
}
/*
================
riDeadZonePowerup::Event_ResetFlag
================
*/
void riDeadZonePowerup::Event_ResetSpawn( void ) {
ResetSpawn( POWERUP_DEADZONE );
}
Reference in a new issue Copy permalink