ubergames
/
ef2gamesource
mirror of https://github.com/UberGames/EF2GameSource.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
ef2gamesource/dlls/game/item.cpp

1136 lines
21 KiB
C++
Raw Blame History

//-----------------------------------------------------------------------------
//
// $Logfile:: /EF2/Code/DLLs/game/item.cpp $
// $Revision:: 56 $
// $Author:: Singlis $
// $Date:: 9/26/03 2:36p $
//
// Copyright (C) 1997 by Ritual Entertainment, Inc.
// All rights reserved.
//
// This source is may not be distributed and/or modified without
// expressly written permission by Ritual Entertainment, Inc.
//
//
// DESCRIPTION:
// Base class for respawnable, carryable objects.
//
#include "_pch_cpp.h"
#include "entity.h"
#include "trigger.h"
#include "item.h"
#include "inventoryitem.h"
#include "scriptmaster.h"
#include "health.h"
#include "mp_manager.hpp"
#include <qcommon/gameplaymanager.h>
// for bot code
#include "g_local.h"
#include "botlib.h"
#include "be_aas.h"
#include "be_ea.h"
#include "be_ai_char.h"
#include "be_ai_chat.h"
#include "be_ai_gen.h"
#include "be_ai_goal.h"
#include "be_ai_move.h"
#include "be_ai_weap.h"
#include "ai_main.h"
extern bot_state_t *botstates[MAX_CLIENTS];
Event EV_Item_Pickup
(
"item_pickup",
EV_CODEONLY,
"e",
"item",
"Pickup the specified item."
);
Event EV_Item_DropToFloor
(
"item_droptofloor",
EV_CODEONLY,
NULL,
NULL,
"Drops the item to the ground."
);
Event EV_Item_Respawn
(
"respawn",
EV_CODEONLY,
NULL,
NULL,
"Respawns the item."
);
Event EV_Item_SetRespawn
(
"set_respawn",
EV_DEFAULT,
"i",
"respawn",
"Turns respawn on or off."
);
Event EV_Item_SetRespawnTime
(
"set_respawn_time",
EV_DEFAULT,
"f",
"respawn_time",
"Sets the respawn time."
);
Event EV_Item_SetAmount
(
"amount",
EV_DEFAULT,
"i",
"amount",
"Sets the amount of the item."
);
Event EV_Item_SetMaxAmount
(
"maxamount",
EV_DEFAULT,
"i",
"max_amount",
"Sets the max amount of the item."
);
Event EV_Item_SetItemName
(
"name",
EV_DEFAULT,
"s",
"item_name",
"Sets the item name."
);
Event EV_Item_RespawnSound
(
"respawnsound",
EV_DEFAULT,
NULL,
NULL,
"Turns on the respawn sound for this item."
);
Event EV_Item_DialogNeeded
(
"dialogneeded",
EV_DEFAULT,
"s",
"dialog_needed",
"Sets the dialog needed string."
);
Event EV_Item_NoRemove
(
"no_remove",
EV_DEFAULT,
NULL,
NULL,
"Makes it so the item is not removed from the world when it is picked up."
);
Event EV_Item_RespawnDone
(
"respawn_done",
EV_CODEONLY,
NULL,
NULL,
"Called when the item respawn is done."
);
Event EV_Item_PickupDone
(
"pickup_done",
EV_CODEONLY,
NULL,
NULL,
"Called when the item pickup is done."
);
Event EV_Item_SetPickupThread
(
"pickup_thread",
EV_SCRIPTONLY,
"s",
"labelName",
"A thread that is called when an item is picked up."
);
Event EV_Item_SetBotInventoryIndex
(
"bot_inventory",
EV_TIKIONLY,
"i",
"botInventoryIndex",
"sets the index used for bot inventory pickups"
);
Event EV_Item_CoolItem
(
"coolitem",
EV_DEFAULT,
"SS",
"dialog anim_to_play",
"Specify that this is a cool item when we pick it up for the first time.\n"
"If dialog is specified, than the dialog will be played during the pickup.\n"
"If anim_to_play is specified, than the specified anim will be played after\n"
"the initial cinematic."
);
Event EV_Item_ForceCoolItem
(
"forcecoolitem",
EV_DEFAULT,
"SS",
"dialog anim_to_play",
"Specify that this is a cool item when we pick it up regardless of whether or not we have it.\n"
"If dialog is specified, than the dialog will be played during the pickup.\n"
"If anim_to_play is specified, than the specified anim will be played after\n"
"the initial cinematic."
);
Event EV_Item_IconName
(
"iconName",
EV_DEFAULT,
"s",
"iconName",
"Sets the name of the icon to use for this item."
);
Event EV_Item_SetMissingSkin
(
"missingSkin",
EV_TIKIONLY,
"i",
"skinNum",
"Sets the skin number to use when its been picked up and is missing"
);
Event EV_Item_PostSpawn
(
"itemPostSpawn",
EV_CODEONLY,
NULL,
NULL,
"Tells the item that it had spawned successfully"
);
CLASS_DECLARATION( Trigger, Item, NULL )
{
{ &EV_Trigger_Effect, &Item::ItemTouch },
{ &EV_Item_DropToFloor, &Item::DropToFloor },
{ &EV_Item_Respawn, &Item::Respawn },
{ &EV_Item_SetAmount, &Item::SetAmountEvent },
{ &EV_Item_SetMaxAmount, &Item::SetMaxAmount },
{ &EV_Item_SetItemName, &Item::SetItemName },
{ &EV_Item_Pickup, &Item::Pickup },
{ &EV_Use, &Item::TriggerStuff },
{ &EV_Item_RespawnSound, &Item::RespawnSound },
{ &EV_Item_DialogNeeded, &Item::DialogNeeded },
{ &EV_Item_NoRemove, &Item::SetNoRemove },
{ &EV_Item_RespawnDone, &Item::RespawnDone },
{ &EV_Item_PickupDone, &Item::PickupDone },
{ &EV_Item_SetRespawn, &Item::setRespawn },
{ &EV_Item_SetRespawnTime, &Item::setRespawnTime },
{ &EV_Item_SetPickupThread, &Item::SetPickupThread },
{ &EV_Item_CoolItem, &Item::CoolItemEvent },
{ &EV_Item_ForceCoolItem, &Item::ForceCoolItemEvent },
{ &EV_Item_SetBotInventoryIndex, &Item::SetBotInventoryIndex },
{ &EV_Stop, &Item::Landed },
{ &EV_SetAngle, &Item::SetAngleEvent },
{ &EV_Item_IconName, &Item::iconNameEvent },
{ &EV_Item_SetMissingSkin, &Item::setMissingSkin },
{ &EV_Item_PostSpawn, &Item::postSpawn },
{ NULL, NULL }
};
//--------------------------------------------------------------
// Name: Item()
// Class: Item
//
// Description: Constructor
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
Item::Item()
{
str fullname;
animate = new Animate( this );
if ( LoadingSavegame )
return;
setSolidType( SOLID_NOT );
// Set default respawn behavior
// Derived classes should use setRespawn
// if they want to override the default behavior
setRespawn( false );
setRespawnTime( 20 );
if ( multiplayerManager.inMultiplayer() )
{
setRespawn( true );
edict->s.renderfx |= RF_FULLBRIGHT;
}
//
// we want the bounds of this model auto-rotated
//
flags |= FL_ROTATEDBOUNDS;
//
// set a minimum mins and maxs for the model
//
if ( size.length() < 10.0f )
{
mins = Vector(-10, -10, 0);
maxs = Vector(10, 10, 20);
}
//
// reset the mins and maxs to pickup the FL_ROTATEDBOUNDS flag
//
setSize( mins, maxs );
if ( !LoadingSavegame )
{
// Items can't be immediately dropped to floor, because they might
// be on an entity that hasn't spawned yet.
PostEvent( EV_Item_DropToFloor, EV_POSTSPAWN );
}
respondto = TRIGGER_PLAYERS;
// items should collide with everything that the player does
edict->clipmask = MASK_PLAYERSOLID;
bot_inventory_index = 0; // INVENTORY_NONE
item_index = 0;
maximum_amount = 1.0f;
playrespawn = false;
// this is an item entity
if ( g_gametype->integer == GT_SINGLE_PLAYER )
edict->s.eType = ET_MODELANIM;
else
edict->s.eType = ET_ITEM;
// Set our default skill level
_skillLevel = 1.0f;
amount = 1.0f;
no_remove = false;
setName( "Unknown Item" );
look_at_me = true;
coolitem = false;
coolitemforced = false;
has_been_looked_at = false;
_nextPickupTime = 0.0f;
_mpItemType = MP_ITEM_TYPE_NORMAL;
_iconIndex = -1;
_missingSkin = 0;
if ( !LoadingSavegame )
{
PostEvent( EV_Item_PostSpawn, EV_POSTSPAWN );
}
}
Item::~Item()
{
if ( owner )
{
owner->RemoveItem( this );
owner = NULL;
}
}
void Item::postSpawn( Event *ev )
{
cacheStrings();
}
void Item::SetNoRemove( Event *ev )
{
no_remove = true;
}
/*
============
PlaceItem
Puts an item back in the world
============
*/
void Item::PlaceItem( void )
{
GameplayManager *gpm = GameplayManager::getTheGameplayManager();
if ( gpm->hasProperty(getArchetype(), "noautopickup") )
{
setContents( CONTENTS_USABLE );
setSolidType( SOLID_BBOX );
}
else
{
setSolidType( SOLID_TRIGGER );
}
setMoveType( MOVETYPE_TOSS );
showModel();
groundentity = NULL;
}
/*
============
DropToFloor
plants the object on the floor
============
*/
void Item::DropToFloor( Event *ev )
{
str fullname;
Vector save;
PlaceItem();
addOrigin( Vector(0, 0, 1) );
save = origin;
if ( gravity > 0.0f )
{
if ( !droptofloor( 8192.0f ) )
{
gi.WDPrintf( "%s (%d) stuck in world at '%5.1f %5.1f %5.1f'\n",
getClassID(), entnum, origin.x, origin.y, origin.z );
setOrigin( save );
setMoveType( MOVETYPE_NONE );
}
else
{
setMoveType( MOVETYPE_NONE );
}
}
//
// if the our global variable doesn't exist, lets zero it out
//
fullname = str( "playeritem_" ) + getName();
if ( !gameVars.VariableExists( fullname.c_str() ) )
{
gameVars.SetVariable( fullname.c_str(), 0 );
}
if ( !levelVars.VariableExists( fullname.c_str() ) )
{
levelVars.SetVariable( fullname.c_str(), 0 );
}
if ( multiplayerManager.inMultiplayer() && gi.Anim_NumForName( edict->s.modelindex, "idle_onground" ) >= 0 )
{
animate->RandomAnimate( "idle_onground" );
edict->s.eType = ET_MODELANIM;
}
}
qboolean Item::Drop( void )
{
if ( !owner )
{
return false;
}
setOrigin( owner->origin + Vector( "0 0 40" ) );
// drop the item
PlaceItem();
velocity = owner->velocity * 0.5f + Vector( G_CRandom( 50.0f ), G_CRandom( 50.0f ), 100.0f );
setAngles( owner->angles );
avelocity = Vector( 0.0f, G_CRandom( 360.0f ), 0.0f );
trigger_time = level.time + 1.0f;
if ( owner->isClient() )
{
spawnflags |= DROPPED_PLAYER_ITEM;
}
else
{
spawnflags |= DROPPED_ITEM;
}
// Remove this from the owner's item list
owner->RemoveItem( this );
owner = NULL;
return true;
}
void Item::ItemTouch( Event *ev )
{
Entity *other;
Event *e;
if ( owner )
{
// Don't respond to trigger events after item is picked up.
// we really don't need to see this.
//gi.DPrintf( "%s with targetname of %s was triggered unexpectedly.\n", getClassID(), TargetName() );
return;
}
other = ev->GetEntity( 1 );
e = new Event( EV_Item_Pickup );
e->AddEntity( other );
ProcessEvent( e );
}
void Item::SetOwner( Sentient *ent )
{
assert( ent );
if ( !ent )
{
// return to avoid any buggy behaviour
return;
}
owner = ent;
edict->s.parent = ent->entnum;
setRespawn( false );
setSolidType( SOLID_NOT );
hideModel();
CancelEventsOfType( EV_Touch );
CancelEventsOfType( EV_Item_DropToFloor );
CancelEventsOfType( EV_Remove );
// ItemPickup( ent );
}
void Item::SetBotInventoryIndex( Event *ev )
{
bot_inventory_index = ev->GetInteger(1);
}
int Item::GetBotInventoryIndex( void )
{
return bot_inventory_index;
}
Sentient *Item::GetOwner( void ) const
{
return owner;
}
Item * Item::ItemPickup( Entity *other, qboolean add_to_inventory, qboolean checkautopickup )
{
Sentient * sent;
Item * item = NULL;
str realname;
// Query the gameplay manager and see if we should not auto-pickup this item
if ( checkautopickup )
{
GameplayManager *gpm = GameplayManager::getTheGameplayManager();
if ( gpm->hasProperty(getArchetype(), "noautopickup") )
return NULL;
}
if ( !Pickupable( other ) )
{
return NULL;
}
sent = ( Sentient * )other;
if ( add_to_inventory )
{
item = sent->giveItem( model, getAmount(), true );
if ( !item )
return NULL;
}
else
{
item = this;
}
//
// make sure to copy over the coolness factor :)
//
item->coolitem = coolitem;
item->cool_dialog = cool_dialog;
item->cool_anim = cool_anim;
item->coolitemforced = coolitemforced;
//
// let our sent know they received it
// we put this here so we can transfer information from the original item we picked up
//
if ( !isSubclassOf( Weapon ) || add_to_inventory )
sent->ReceivedItem( item );
realname = GetRandomAlias( "snd_pickup" );
if ( realname.length() > 1 )
sent->Sound( realname, CHAN_ITEM );
if ( !Removable() )
{
// leave the item for others to pickup
return item;
}
look_at_me = false;
CancelEventsOfType( EV_Item_DropToFloor );
CancelEventsOfType( EV_Item_Respawn );
CancelEventsOfType( EV_FadeOut );
setSolidType( SOLID_NOT );
if ( animate && animate->HasAnim( "pickup" ) )
animate->RandomAnimate( "pickup", EV_Item_PickupDone );
else
{
if ( !no_remove )
{
if ( _missingSkin )
{
ChangeSkin( _missingSkin, true );
}
else
{
hideModel();
}
if ( !Respawnable() )
PostEvent( EV_Remove, FRAMETIME );
}
}
if ( Respawnable() )
PostEvent( EV_Item_Respawn, RespawnTime() );
// fire off any pickup_thread's
if ( pickup_thread.length() )
{
ExecuteThread( pickup_thread );
}
if ( item && multiplayerManager.checkFlag( MP_FLAG_INSTANT_ITEMS ) )
{
Event *ev;
ev = new Event( EV_InventoryItem_Use );
ev->AddEntity( other );
item->ProcessEvent( ev );
}
return item;
}
void Item::Respawn( Event *ev )
{
if ( _missingSkin )
{
ChangeSkin( _missingSkin, false );
}
else
{
showModel();
}
// allow it to be touched again
setSolidType( SOLID_TRIGGER );
// play respawn sound
if ( playrespawn )
{
Sound( "snd_itemspawn" );
}
setOrigin();
if ( animate->HasAnim( "respawn" ) )
animate->RandomAnimate( "respawn", EV_Item_RespawnDone );
look_at_me = true;
has_been_looked_at = false;
}
void Item::setRespawn( Event *ev )
{
if ( ev->NumArgs() < 1 )
return;
setRespawn( ev->GetInteger( 1 ) );
}
void Item::setRespawnTime( Event *ev )
{
if ( ev->NumArgs() < 1 )
return;
setRespawnTime( ev->GetFloat( 1 ) );
}
void Item::RespawnDone( Event *ev )
{
animate->RandomAnimate( "idle" );
}
void Item::PickupDone( Event *ev )
{
if ( !no_remove )
{
hideModel();
if ( !Respawnable() )
PostEvent( EV_Remove, FRAMETIME );
}
else
{
if ( animate->HasAnim( "pickup_idle" ) )
animate->RandomAnimate( "pickup_idle" );
else
animate->RandomAnimate( "pickup" );
}
}
void Item::setRespawn( qboolean flag )
{
respawnable = flag;
}
qboolean Item::Respawnable( void )
{
return respawnable;
}
void Item::setRespawnTime( float time )
{
respawntime = time;
}
float Item::RespawnTime( void )
{
if ( multiplayerManager.inMultiplayer() )
return respawntime * multiplayerManager.getItemRespawnMultiplayer();
else
return respawntime;
}
float Item::getAmount( void )
{
return amount;
}
float Item::MaxAmount( void )
{
return maximum_amount;
}
qboolean Item::Pickupable( Entity *other )
{
if ( level.time < _nextPickupTime )
return false;
if ( multiplayerManager.inMultiplayer() && other->isSubclassOf( Player ) )
{
if ( !multiplayerManager.canPickup( (Player *)other, getMultiplayerItemType(), getName().c_str() ) )
return false;
}
if ( getSolidType() == SOLID_NOT )
{
return NULL;
}
if ( !other->isSubclassOf( Sentient ) )
{
return false;
}
else
{
Sentient * sent;
Item * item;
sent = ( Sentient * )other;
if ( sent->deadflag || sent->health <= 0.0f )
{
return false;
}
item = sent->FindItem( getName() );
if ( item && ( item->getAmount() >= item->MaxAmount() ) )
{
return false;
}
// TODO : fixme
// If deathmatch and already in a powerup, don't pickup anymore when DF_INSTANT_ITEMS is on
/* if ( multiplayerManager.checkFlag( MP_FLAG_INSTANT_ITEMS ) &&
this->isSubclassOf( InventoryItem ) &&
sent->PowerupActive()
)
{
return false;
} */
}
return true;
}
void Item::Pickup( Event * ev )
{
ItemPickup( ev->GetEntity( 1 ) );
}
void Item::setName( const char *i )
{
item_name = i;
item_index = gi.itemindex( i );
strcpy( edict->entname, i );
}
const str Item::getName( void ) const
{
return( item_name );
}
int Item::getIndex( void )
{
return item_index;
}
void Item::setAmount( float startamount )
{
amount = startamount;
if ( amount >= MaxAmount() )
{
SetMax( (int) amount );
}
}
void Item::SetMax( int maxamount )
{
maximum_amount = maxamount;
}
void Item::SetAmountEvent( Event *ev )
{
setAmount( ev->GetInteger( 1 ) );
}
void Item::SetMaxAmount( Event *ev )
{
SetMax( ev->GetInteger( 1 ) );
}
void Item::SetItemName( Event *ev )
{
setName( ev->GetString( 1 ) );
}
void Item::Add( int num )
{
amount += num;
if ( amount >= MaxAmount() )
amount = MaxAmount();
}
void Item::Remove( int num )
{
amount -= num;
if (amount < 0)
amount = 0;
}
qboolean Item::Use( int num )
{
if ( num > amount )
{
return false;
}
amount -= num;
return true;
}
qboolean Item::Removable( void )
{
return true;
}
void Item::RespawnSound( Event *ev )
{
playrespawn = true;
}
void Item::DialogNeeded( Event *ev )
{
//
// if this item is needed for a trigger, play this dialog
//
dialog_needed = ev->GetString( 1 );
}
str Item::GetDialogNeeded( void )
{
return dialog_needed;
}
//
// once item has landed on the floor, go to movetype none
//
void Item::Landed( Event *ev )
{
if ( groundentity && ( groundentity->entity != world ) )
{
warning( "Item::Landed", "Item %d has landed on an entity that might move\n", entnum );
}
setMoveType( MOVETYPE_NONE );
}
void Item::SetPickupThread( Event *ev )
{
pickup_thread = ev->GetString( 1 );
}
void Item::SetCoolItem( qboolean cool, const str &dialog, const str &anim )
{
coolitem = cool;
cool_dialog = dialog;
if ( cool_dialog.length() )
{
CacheResource( cool_dialog, this );
}
CacheResource( "models/fx_coolitem.tik", this );
CacheResource( "models/fx_coolitem_reverse.tik", this );
cool_anim = anim;
}
void Item::CoolItemEvent( Event *ev )
{
qboolean cool;
str dialog, anim;
cool = true;
if ( ev->NumArgs() > 0 )
{
dialog = ev->GetString( 1 );
}
if ( ev->NumArgs() > 1 )
{
anim = ev->GetString( 2 );
}
SetCoolItem( cool, dialog, anim );
}
void Item::ForceCoolItemEvent( Event *ev )
{
coolitemforced = true;
CoolItemEvent( ev );
}
qboolean Item::IsItemCool( str * dialog, str * anim, qboolean * forced )
{
*dialog = cool_dialog;
*anim = cool_anim;
*forced = coolitemforced;
return coolitem;
}
MultiplayerItemType Item::getMultiplayerItemType( void )
{
return _mpItemType;
}
void Item::iconNameEvent( Event *ev )
{
str iconName;
iconName = ev->GetString( 1 );
_iconIndex = gi.imageindex( iconName.c_str() );
}
void Item::setMissingSkin( Event *ev )
{
_missingSkin = ev->GetInteger( 1 );
}
void Item::ChangeSkin( int skinNum, qboolean state )
{
str command;
// Build the command
if ( state )
command = "+";
else
command = "-";
command += "skin";
command += skinNum;
// Change the skin
SurfaceCommand( "all", command.c_str() );
}
void Item::cacheStrings( void )
{
G_FindConfigstringIndex( va( "$$PickedUp$$ %d $$Item-%s$$\n", (int)getAmount(), getName().c_str() ), CS_GENERAL_STRINGS, MAX_GENERAL_STRINGS, true );
G_FindConfigstringIndex( va( "$$PickedUp$$ %d $$Item-%s$$s\n", (int)getAmount(), getName().c_str() ), CS_GENERAL_STRINGS, MAX_GENERAL_STRINGS, true );
G_FindConfigstringIndex( va( "$$PickedUpThe$$ $$Item-%s$$\n", getName().c_str() ), CS_GENERAL_STRINGS, MAX_GENERAL_STRINGS, true );
}
CLASS_DECLARATION( Item, MultiplayerItem, NULL )
{
{ &EV_Trigger_Effect, &MultiplayerItem::notifyMultiplayerItemTriggered },
{ &EV_Killed, &MultiplayerItem::notifyMultiplayerItemDestroyed },
{ &EV_Use, &MultiplayerItem::notifyMultiplayerItemUsed },
{ &EV_Damage, &MultiplayerItem::damageEvent },
{ NULL, NULL }
};
MultiplayerItem::MultiplayerItem()
{
edict->s.eType = ET_MODELANIM;
}
void MultiplayerItem::notifyMultiplayerItemTriggered( Event *ev )
{
Entity *entity;
entity = ev->GetEntity( 1 );
if ( entity->isSubclassOf( Player ) )
multiplayerManager.itemTouched( (Player *)entity, this );
}
void MultiplayerItem::notifyMultiplayerItemDestroyed( Event *ev )
{
Entity *entity;
entity = ev->GetEntity( 1 );
if ( entity->isSubclassOf( Player ) )
multiplayerManager.itemDestroyed( (Player *)entity, this );
}
void MultiplayerItem::notifyMultiplayerItemUsed( Event *ev )
{
Entity *entity;
entity = ev->GetEntity( 1 );
multiplayerManager.itemUsed( entity, this );
}
void MultiplayerItem::damageEvent( Event *ev )
{
Entity *attacker;
int meansOfDeath;
float originalDamage;
float realDamage;
// Get the parms
originalDamage = ev->GetFloat( 1 );
attacker = ev->GetEntity( 3 );
meansOfDeath = ev->GetInteger( 9 );
// See what the real damage done is
realDamage = originalDamage;
if ( attacker->isSubclassOf( Player ) )
{
realDamage = multiplayerManager.itemDamaged( this, (Player *)attacker, originalDamage, meansOfDeath );
// Change the event if the damage has changed
if ( realDamage != originalDamage )
{
ev->SetFloat( 1, realDamage );
}
}
if ( realDamage == 0.0f )
return;
// Do the real damage here
Entity::DamageEvent( ev );
}
void MultiplayerItem::cacheStrings( void )
{
}
CLASS_DECLARATION( Item, SecretItem, NULL )
{
{ NULL, NULL }
};
SecretItem::SecretItem()
{
if ( LoadingSavegame )
return;
level.total_specialItems++;
levelVars.SetVariable( "total_specialItems" , level.total_specialItems );
edict->s.eType = ET_ITEM;
}
Item* SecretItem::ItemPickup( Entity *other, qboolean add_to_inventory = true, qboolean checkautopickup = true )
{
str pickupSoundName;
PostEvent( EV_Remove, 0.0f );
level.found_specialItems++;
levelVars.SetVariable( "found_specialItems" , level.found_specialItems );
gi.centerprintf ( other->edict, CENTERPRINT_IMPORTANCE_NORMAL, "$$FoundSecretItem$$" );
pickupSoundName = GetRandomAlias( "snd_pickup" );
if ( pickupSoundName.length() > 1 )
{
other->Sound( pickupSoundName, CHAN_ITEM );
}
if ( other && other->isSubclassOf( Player ) )
{
Player *player = (Player *)other;
player->incrementSecretsFound();
}
return NULL;
}
void SecretItem::cacheStrings( void )
{
}
Reference in New Issue View Git Blame Copy Permalink