4156 lines
113 KiB
C++
4156 lines
113 KiB
C++
//-----------------------------------------------------------------------------
|
|
//
|
|
// $Logfile:: /EF2/Code/DLLs/game/mp_modifiers.cpp $
|
|
// $Revision:: 172 $
|
|
// $Author:: Singlis $
|
|
// $Date:: 9/26/03 2:36p $
|
|
//
|
|
// Copyright (C) 2002 by Ritual Entertainment, Inc.
|
|
// All rights reserved.
|
|
//
|
|
// This source may not be distributed and/or modified without
|
|
// expressly written permission by Ritual Entertainment, Inc.
|
|
//
|
|
// Description:
|
|
//
|
|
|
|
#include "_pch_cpp.h"
|
|
#include "mp_manager.hpp"
|
|
#include "mp_modifiers.hpp"
|
|
#include "equipment.h"
|
|
#include "powerups.h"
|
|
#include "weaputils.h"
|
|
#include "health.h"
|
|
#include "armor.h"
|
|
|
|
// Setup constants
|
|
|
|
const float ModifierInstantKill::_instantKillDamage = 1000.0f;
|
|
|
|
const float ModifierInstantKill::_regenTime = 0.1f;
|
|
const int ModifierInstantKill::_regenAmount = 1;
|
|
|
|
ModifierInstantKill::ModifierInstantKill()
|
|
{
|
|
_lastRegenTime = 0.0f;
|
|
}
|
|
|
|
void ModifierInstantKill::init( int maxPlayers )
|
|
{
|
|
multiplayerManager.cacheMultiplayerFiles( "mp_instantKill" );
|
|
}
|
|
|
|
float ModifierInstantKill::playerDamaged( Player *damagedPlayer, Player *attackingPlayer, float damage, int meansOfDeath )
|
|
{
|
|
float realDamage = 0.0f;
|
|
|
|
if ( damage > 0.0f )
|
|
{
|
|
switch( meansOfDeath )
|
|
{
|
|
case MOD_COMP_RIFLE:
|
|
case MOD_IMOD_PRIMARY:
|
|
case MOD_IMOD_SECONDARY:
|
|
case MOD_DISRUPTOR:
|
|
case MOD_SNIPER:
|
|
case MOD_MELEE:
|
|
realDamage = _instantKillDamage;
|
|
break;
|
|
default:
|
|
realDamage = damage;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return realDamage;
|
|
}
|
|
|
|
bool ModifierInstantKill::canGivePlayerItem( int entnum, const str &itemName )
|
|
{
|
|
if ( strstr( itemName.c_str(), "phaser.tik" ) )
|
|
return false;
|
|
else if ( strstr( itemName.c_str(), "batleth.tik" ) )
|
|
return false;
|
|
else if ( strstr( itemName.c_str(), "compressionrifle.tik" ) )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ModifierInstantKill::checkRule( const char *rule, bool defaultValue, Player *player )
|
|
{
|
|
if ( stricmp( rule, "dropWeapons" ) == 0 )
|
|
return false;
|
|
else
|
|
return defaultValue;
|
|
}
|
|
|
|
void ModifierInstantKill::playerSpawned( Player *player )
|
|
{
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-sniperrifle.tik" );
|
|
multiplayerManager.usePlayerItem( player->entnum, "FederationSniperRifle" );
|
|
|
|
//multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-compressionrifle.tik" );
|
|
//multiplayerManager.usePlayerItem( player->entnum, "CompressionRifle" );
|
|
|
|
//multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-imod.tik" );
|
|
//multiplayerManager.usePlayerItem( player->entnum, "I-Mod" );
|
|
|
|
player->GiveAmmo( "Fed", 400, false );
|
|
}
|
|
|
|
bool ModifierInstantKill::shouldKeepNormalItem( Item *item )
|
|
{
|
|
if ( item->isSubclassOf( Weapon ) )
|
|
return false;
|
|
else if ( item->isSubclassOf( Health ) )
|
|
return false;
|
|
else if ( item->isSubclassOf( Armor ) )
|
|
return false;
|
|
else if ( item->isSubclassOf( AmmoEntity ) )
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
|
|
void ModifierInstantKill::update( float frameTime )
|
|
{
|
|
int i;
|
|
Player *player;
|
|
|
|
if ( _lastRegenTime + _regenTime < multiplayerManager.getTime() )
|
|
{
|
|
for ( i = 0 ; i < multiplayerManager.getMaxPlayers() ; i++ )
|
|
{
|
|
player = multiplayerManager.getPlayer( i );
|
|
|
|
if ( !player )
|
|
continue;
|
|
|
|
player->GiveAmmo( "Fed", _regenAmount, false );
|
|
//player->GiveAmmo( "Plasma", _regenAmount, false );
|
|
}
|
|
|
|
_lastRegenTime = multiplayerManager.getTime();
|
|
}
|
|
}
|
|
|
|
// Setup constants
|
|
|
|
const float ModifierDestruction::_defaultObjectHealth = 500.0f;
|
|
const int ModifierDestruction::_pointsForDestroyingObject = 100;
|
|
const float ModifierDestruction::_objectHealRate = 75.0f;
|
|
const float ModifierDestruction::_maxGuardingDist = 1000.0f;
|
|
|
|
const float ModifierDestruction::_minDamageForPoints = 100.0f;
|
|
const float ModifierDestruction::_minHealingForPoints = 100.0f;
|
|
|
|
const int ModifierDestruction::_pointsForDamage = 5;
|
|
const int ModifierDestruction::_pointsForHealing = 5;
|
|
const int ModifierDestruction::_pointsForDestroying = 25;
|
|
const int ModifierDestruction::_pointsForGuarding = 10;
|
|
|
|
ModifierDestruction::ModifierDestruction()
|
|
{
|
|
_redDestructionObject = NULL;
|
|
_blueDestructionObject = NULL;
|
|
|
|
_destructionPlayerData = NULL;
|
|
|
|
_redLastDamageSoundTime = 0.0f;
|
|
_blueLastDamageSoundTime = 0.0f;
|
|
|
|
_respawnTime = 0.0f;
|
|
|
|
_blueObjectDestroyed = false;
|
|
_redObjectDestroyed = false;
|
|
}
|
|
|
|
ModifierDestruction::~ModifierDestruction()
|
|
{
|
|
delete [] _destructionPlayerData;
|
|
}
|
|
|
|
void ModifierDestruction::init( int maxPlayers )
|
|
{
|
|
_maxPlayers = maxPlayers;
|
|
|
|
_destructionPlayerData = new DestructionPlayerData[ _maxPlayers ];
|
|
|
|
multiplayerManager.cacheMultiplayerFiles( "mp_destruction" );
|
|
}
|
|
|
|
void ModifierDestruction::addPlayer( Player *player )
|
|
{
|
|
// Put the destruction ui on the player's screen
|
|
|
|
gi.SendServerCommand( player->entnum, "stufftext \"ui_addhud mp_destruction\"\n" );
|
|
|
|
_destructionPlayerData[ player->entnum ].reset();
|
|
}
|
|
|
|
void ModifierDestruction::playerSpawned( Player *player )
|
|
{
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-tricorder.tik" );
|
|
}
|
|
|
|
void ModifierDestruction::playerKilled( Player *killedPlayer, Player *attackingPlayer, Entity *inflictor, int meansOfDeath )
|
|
{
|
|
Team *victimsTeam;
|
|
Team *killersTeam;
|
|
float distance;
|
|
str printString;
|
|
bool objectGuarded;
|
|
|
|
if ( !attackingPlayer || ( killedPlayer == attackingPlayer ) )
|
|
return;
|
|
|
|
victimsTeam = multiplayerManager.getPlayersTeam( killedPlayer );
|
|
killersTeam = multiplayerManager.getPlayersTeam( attackingPlayer );
|
|
|
|
if ( victimsTeam && killersTeam && ( victimsTeam == killersTeam ) )
|
|
return;
|
|
|
|
// See if the player was guarding a object (either he or the killed player was close to his object)
|
|
|
|
objectGuarded = false;
|
|
|
|
distance = findDistanceToTeamsObject( killersTeam->getName(), attackingPlayer->origin );
|
|
|
|
if ( ( distance > 0 ) && ( distance < _maxGuardingDist ) )
|
|
{
|
|
objectGuarded = true;
|
|
}
|
|
else
|
|
{
|
|
distance = findDistanceToTeamsObject( killersTeam->getName(), killedPlayer->origin );
|
|
|
|
if ( ( distance > 0 ) && ( distance < _maxGuardingDist ) )
|
|
{
|
|
objectGuarded = true;
|
|
}
|
|
}
|
|
|
|
if ( objectGuarded )
|
|
{
|
|
//multiplayerManager.playerEventNotification( "controlpoint-guarded", "", attackingPlayer );
|
|
|
|
printString = "$$ObjectGuarded$$ ";
|
|
printString += attackingPlayer->client->pers.netname;
|
|
|
|
multiplayerManager.playerSound( attackingPlayer->entnum, "localization/sound/dialog/dm/comp_objectguarded.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, 1.2f );
|
|
|
|
multiplayerManager.centerPrintTeamClients( attackingPlayer, printString, CENTERPRINT_IMPORTANCE_HIGH );
|
|
|
|
// Give points to the player for guarding his teams objects
|
|
|
|
multiplayerManager.addPoints( attackingPlayer->entnum, _pointsForGuarding );
|
|
}
|
|
}
|
|
|
|
float ModifierDestruction::findDistanceToTeamsObject( const str &teamName, const Vector &position )
|
|
{
|
|
Vector diff;
|
|
float distance = -1.0f;
|
|
MultiplayerItem *destructionObject = NULL;
|
|
|
|
|
|
// Figure out which object to use
|
|
|
|
if ( teamName == "Red" )
|
|
destructionObject = _redDestructionObject;
|
|
else if ( teamName == "Blue" )
|
|
destructionObject = _blueDestructionObject;
|
|
|
|
// Get the distance from the object to the specified point
|
|
|
|
if ( destructionObject )
|
|
{
|
|
diff = position - destructionObject->origin;
|
|
distance = diff.length();
|
|
}
|
|
|
|
// Return the distance
|
|
|
|
return distance;
|
|
}
|
|
|
|
int ModifierDestruction::getStat( Player *player, int statNum, int value )
|
|
{
|
|
float floatRealValue;
|
|
|
|
if ( statNum == STAT_MP_GENERIC1 )
|
|
{
|
|
// Return the health of the red team's object
|
|
|
|
if ( _redDestructionObject )
|
|
{
|
|
floatRealValue = ( _redDestructionObject->health / _redDestructionObject->max_health ) * 100.0f;
|
|
|
|
if ( ( floatRealValue < 1.0f ) && ( _redDestructionObject->health > 1.0f ) )
|
|
{
|
|
floatRealValue = 1.0f;
|
|
}
|
|
|
|
return ( (int)floatRealValue );
|
|
|
|
}
|
|
}
|
|
else if ( statNum == STAT_MP_GENERIC2 )
|
|
{
|
|
// Return the health of the blue team's object
|
|
|
|
if ( _blueDestructionObject )
|
|
{
|
|
floatRealValue = ( _blueDestructionObject->health / _blueDestructionObject->max_health ) * 100.0f;
|
|
|
|
if ( ( floatRealValue < 1.0f ) && ( _blueDestructionObject->health > 1.0f ) )
|
|
{
|
|
floatRealValue = 1.0f;
|
|
}
|
|
|
|
return ( (int)floatRealValue );
|
|
|
|
}
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
bool ModifierDestruction::shouldKeepItem( MultiplayerItem *item )
|
|
{
|
|
Event *event;
|
|
|
|
// See if we care about this item
|
|
|
|
if ( strnicmp( item->getName().c_str(), "DestructionObject", sizeof( "DestructionObject" ) - 1 ) == 0 )
|
|
{
|
|
// It's a destruction object
|
|
|
|
if ( stricmp( item->getName().c_str(), "DestructionObject-red" ) == 0 )
|
|
_redDestructionObject = item;
|
|
else if ( stricmp( item->getName().c_str(), "DestructionObject-blue" ) == 0 )
|
|
_blueDestructionObject = item;
|
|
|
|
// Change the multiplayer item to suit our needs
|
|
|
|
item->setSolidType( SOLID_BBOX );
|
|
item->setContents( CONTENTS_SOLID );
|
|
item->takedamage = DAMAGE_YES;
|
|
|
|
event = new Event( EV_Trigger_SetDestructible );
|
|
event->AddInteger( true );
|
|
item->ProcessEvent( event );
|
|
|
|
if ( item->health == 0 )
|
|
{
|
|
item->setMaxHealth( _defaultObjectHealth );
|
|
item->setHealth( _defaultObjectHealth );
|
|
}
|
|
|
|
if ( stricmp( item->getName().c_str(), "DestructionObject-red" ) == 0 )
|
|
_redObjectLasthealth = item->health;
|
|
else if ( stricmp( item->getName().c_str(), "DestructionObject-blue" ) == 0 )
|
|
_blueObjectLasthealth = item->health;
|
|
|
|
|
|
// Tell the manager to keep the item
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
float ModifierDestruction::itemDamaged( MultiplayerItem *item, Player *attackingPlayer, float damage, int meansOfDeath )
|
|
{
|
|
Team *team;
|
|
|
|
team = multiplayerManager.getPlayersTeam( attackingPlayer );
|
|
|
|
if ( !team )
|
|
return damage;
|
|
|
|
if ( ( ( item == _redDestructionObject ) && ( team->getName() == "Red" ) ) ||
|
|
( ( item == _blueDestructionObject ) && ( team->getName() == "Blue" ) ) )
|
|
{
|
|
// Can't hurt our own object
|
|
|
|
return 0.0f;
|
|
}
|
|
|
|
if ( ( _respawnTime > 0.0f ) && ( _respawnTime > multiplayerManager.getTime() ) )
|
|
{
|
|
return 0.0f;
|
|
}
|
|
|
|
if ( _blueObjectDestroyed || _redObjectDestroyed )
|
|
return 0.0f;
|
|
|
|
_destructionPlayerData[ attackingPlayer->entnum ]._damageDone += damage;
|
|
|
|
while( _destructionPlayerData[ attackingPlayer->entnum ]._damageDone > _minDamageForPoints )
|
|
{
|
|
_destructionPlayerData[ attackingPlayer->entnum ]._damageDone -= _minDamageForPoints;
|
|
|
|
multiplayerManager.addPoints( attackingPlayer->entnum, _pointsForDamage );
|
|
}
|
|
|
|
// Play a sound to tell everyone the object was damaged
|
|
|
|
if ( ( item == _redDestructionObject ) && ( multiplayerManager.getTime() > _redLastDamageSoundTime + 0.5 ) )
|
|
{
|
|
item->Sound( "impact_singularity", CHAN_AUTO, 1.0f, 500 );
|
|
_redLastDamageSoundTime = multiplayerManager.getTime();
|
|
}
|
|
else if ( ( item == _blueDestructionObject ) && ( multiplayerManager.getTime() > _blueLastDamageSoundTime + 0.5 ) )
|
|
{
|
|
item->Sound( "impact_singularity", CHAN_AUTO, 1.0f, 500 );
|
|
_blueLastDamageSoundTime = multiplayerManager.getTime();
|
|
}
|
|
|
|
// Scale the damage done to the singularity inversely to the number of players in the game
|
|
|
|
damage /= (float)multiplayerManager.getTotalPlayers( false ) + 2.0f;
|
|
|
|
return damage;
|
|
}
|
|
|
|
void ModifierDestruction::itemDestroyed( Player *player, MultiplayerItem *item )
|
|
{
|
|
Team *team;
|
|
|
|
if ( strnicmp( item->getName().c_str(), "DestructionObject", sizeof( "DestructionObject" ) - 1 ) == 0 )
|
|
{
|
|
// Snap health to 0
|
|
|
|
item->setHealth( 0.0f );
|
|
|
|
if ( item->animate && item->animate->HasAnim( "idle" ) )
|
|
{
|
|
item->animate->RandomAnimate( "idle" );
|
|
}
|
|
|
|
if ( stricmp( item->getName().c_str(), "DestructionObject-red" ) == 0 )
|
|
_redObjectLasthealth = item->health;
|
|
else if ( stricmp( item->getName().c_str(), "DestructionObject-blue" ) == 0 )
|
|
_blueObjectLasthealth = item->health;
|
|
|
|
item->SpawnEffect( "models/fx/fx-explosion-singularity.tik", item->origin, item->angles, 1.0f );
|
|
|
|
// Give the team points
|
|
|
|
team = multiplayerManager.getPlayersTeam( player );
|
|
|
|
// Give the player points
|
|
|
|
multiplayerManager.addPoints( player->entnum, _pointsForDestroying );
|
|
|
|
if ( ( ( team->getName() == "Red" ) && ( item == _blueDestructionObject ) ) ||
|
|
( ( team->getName() == "Blue" ) && ( item == _redDestructionObject ) ) )
|
|
{
|
|
team->addPoints( NULL, _pointsForDestroyingObject );
|
|
|
|
if ( team->getName() == "Red" )
|
|
{
|
|
multiplayerManager.centerPrintAllClients( "$$BlueObjectDestroyed$$!", CENTERPRINT_IMPORTANCE_NORMAL );
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_btsestroy.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, NULL, 1.5f );
|
|
_blueObjectDestroyed = true;
|
|
}
|
|
else
|
|
{
|
|
multiplayerManager.centerPrintAllClients( "$$RedObjectDestroyed$$!", CENTERPRINT_IMPORTANCE_NORMAL );
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_rtsestroy.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, NULL, 1.5f );
|
|
_redObjectDestroyed = true;
|
|
}
|
|
|
|
multiplayerManager.playerEventNotification( "destruction", item->getName().c_str(), player );
|
|
|
|
// Respawn all of the players in a few seconds
|
|
|
|
_respawnTime = multiplayerManager.getTime() + 3.0f;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ModifierDestruction::itemUsed( Entity *entity, MultiplayerItem *item )
|
|
{
|
|
Player *player;
|
|
Equipment *equipment;
|
|
Team * team;
|
|
|
|
|
|
// Can't heal singularity during respawn time
|
|
|
|
if ( _blueObjectDestroyed || _redObjectDestroyed )
|
|
return;
|
|
|
|
if ( ( _respawnTime > 0.0f ) && ( _respawnTime >= multiplayerManager.getTime() ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// We only care about equipment using stuff (tricorders to be exact)
|
|
|
|
if ( entity && entity->isSubclassOf( Player ) )
|
|
{
|
|
player = (Player *)entity;
|
|
|
|
if ( !( player->edict->svflags & SVF_BOT ) )
|
|
{
|
|
player->loadUseItem( "tricorder" );
|
|
}
|
|
return;
|
|
}
|
|
|
|
if ( !entity || entity->isSubclassOf( Player ) )
|
|
return;
|
|
|
|
if ( !entity->isSubclassOf( Equipment ) )
|
|
return;
|
|
|
|
equipment = (Equipment *)entity;
|
|
|
|
if ( stricmp( equipment->getTypeName().c_str(), "tricorder" ) != 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// The tricorder must have a player as the owner
|
|
|
|
if ( !equipment->GetOwner() || !equipment->GetOwner()->isSubclassOf( Player ) )
|
|
return;
|
|
|
|
player = (Player *)equipment->GetOwner();
|
|
team = multiplayerManager.getPlayersTeam( player );
|
|
|
|
if ( !team )
|
|
return;
|
|
|
|
// Heal the destruction object if everything is ok
|
|
|
|
if ( ( ( item == _redDestructionObject ) && ( team->getName() == "Red" ) ) ||
|
|
( ( item == _blueDestructionObject ) && ( team->getName() == "Blue" ) ) )
|
|
{
|
|
if ( _destructionPlayerData[ player->entnum ]._lastHealTime != level.time )
|
|
{
|
|
_destructionPlayerData[ player->entnum ]._lastHealTime = level.time;
|
|
|
|
// Scale the healed damage done to the singularity inversely to the number of players in the game
|
|
|
|
item->addHealth( _objectHealRate * level.frametime / ( multiplayerManager.getTotalPlayers( false ) + 2.0f ) );
|
|
|
|
// Give points to player for healing object
|
|
|
|
_destructionPlayerData[ player->entnum ]._healthHealed += _objectHealRate * level.frametime;
|
|
|
|
while( _destructionPlayerData[ player->entnum ]._healthHealed > _minHealingForPoints )
|
|
{
|
|
_destructionPlayerData[ player->entnum ]._healthHealed -= _minHealingForPoints;
|
|
|
|
multiplayerManager.addPoints( player->entnum, _pointsForHealing );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ModifierDestruction::update( float frameTime )
|
|
{
|
|
float redHealth;
|
|
float redMaxHealth;
|
|
float blueHealth;
|
|
float blueMaxHealth;
|
|
int currentStage;
|
|
int lastStage;
|
|
|
|
|
|
if ( _redDestructionObject )
|
|
{
|
|
redHealth = _redDestructionObject->health;
|
|
redMaxHealth = _redDestructionObject->max_health;
|
|
|
|
updateObjectAnim( _redDestructionObject, redHealth, _redObjectLasthealth, redMaxHealth );
|
|
|
|
currentStage = getStage( redHealth, redMaxHealth );
|
|
lastStage = getStage( _redObjectLasthealth, redMaxHealth );
|
|
|
|
if ( currentStage > lastStage )
|
|
{
|
|
if ( currentStage == 4 )
|
|
{
|
|
multiplayerManager.centerPrintAllClients( "$$RedObjectCritical$$", CENTERPRINT_IMPORTANCE_NORMAL );
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_rtscl.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, NULL, 1.5f );
|
|
}
|
|
else if ( currentStage == 3 )
|
|
{
|
|
multiplayerManager.centerPrintAllClients( "$$RedObject25$$", CENTERPRINT_IMPORTANCE_NORMAL );
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_rts25.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, NULL, 1.5f );
|
|
}
|
|
else if ( currentStage == 2 )
|
|
{
|
|
multiplayerManager.centerPrintAllClients( "$$RedObject50$$", CENTERPRINT_IMPORTANCE_NORMAL );
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_rts50.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, NULL, 1.5f );
|
|
}
|
|
}
|
|
|
|
_redObjectLasthealth = redHealth;
|
|
}
|
|
|
|
if ( _blueDestructionObject )
|
|
{
|
|
blueHealth = _blueDestructionObject->health;
|
|
blueMaxHealth = _blueDestructionObject->max_health;
|
|
|
|
updateObjectAnim( _blueDestructionObject, blueHealth, _blueObjectLasthealth, blueMaxHealth );
|
|
|
|
currentStage = getStage( blueHealth, blueMaxHealth );
|
|
lastStage = getStage( _blueObjectLasthealth, blueMaxHealth );
|
|
|
|
if ( currentStage > lastStage )
|
|
{
|
|
if ( currentStage == 4 )
|
|
{
|
|
multiplayerManager.centerPrintAllClients( "$$BlueObjectCritical$$", CENTERPRINT_IMPORTANCE_NORMAL );
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_btscl.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, NULL, 1.5f );
|
|
}
|
|
else if ( currentStage == 3 )
|
|
{
|
|
multiplayerManager.centerPrintAllClients( "$$BlueObject25$$", CENTERPRINT_IMPORTANCE_NORMAL );
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_bts25.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, NULL, 1.5f );
|
|
}
|
|
else if ( currentStage == 2 )
|
|
{
|
|
multiplayerManager.centerPrintAllClients( "$$BlueObject50$$", CENTERPRINT_IMPORTANCE_NORMAL );
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_bts50.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, NULL, 1.5f );
|
|
}
|
|
}
|
|
|
|
_blueObjectLasthealth = blueHealth;
|
|
}
|
|
|
|
// See if we should respawn everyone
|
|
|
|
if ( ( _respawnTime > 0.0f ) && ( _respawnTime < multiplayerManager.getTime() ) )
|
|
{
|
|
multiplayerManager.respawnAllPlayers();
|
|
_respawnTime = 0.0f;
|
|
|
|
// Reset health back up to the max for which ever singularity was destroyed
|
|
|
|
if ( _blueObjectDestroyed )
|
|
{
|
|
_blueDestructionObject->setHealth( _blueDestructionObject->max_health );
|
|
_blueObjectDestroyed = false;
|
|
}
|
|
|
|
if ( _redObjectDestroyed )
|
|
{
|
|
_redDestructionObject->setHealth( _redDestructionObject->max_health );
|
|
_redObjectDestroyed = false;
|
|
}
|
|
|
|
}
|
|
|
|
// Regenerate some health
|
|
|
|
/* if ( _redDestructionObject && ( _redDestructionObject->health < _redDestructionObject->max_health ) )
|
|
{
|
|
_redDestructionObject->addHealth( 1 * frameTime );
|
|
}
|
|
|
|
if ( _blueDestructionObject && ( _blueDestructionObject->health < _blueDestructionObject->max_health ) )
|
|
{
|
|
_blueDestructionObject->addHealth( 1 * frameTime );
|
|
} */
|
|
}
|
|
|
|
void ModifierDestruction::updateObjectAnim( MultiplayerItem *destructionObject, float health, float lastHealth, float maxHealth )
|
|
{
|
|
int currentStage;
|
|
int lastStage;
|
|
str animName;
|
|
|
|
|
|
// Make sure everything is ok
|
|
|
|
if ( !destructionObject )
|
|
return;
|
|
|
|
// Get the current and the last stage
|
|
|
|
currentStage = getStage( health, maxHealth );
|
|
lastStage = getStage( lastHealth, maxHealth );
|
|
|
|
// See if we have changed stages
|
|
|
|
if ( currentStage != lastStage )
|
|
{
|
|
// Figure out the correct animation to play
|
|
|
|
if ( currentStage == 1 )
|
|
animName = "idle";
|
|
else if ( currentStage == 2 )
|
|
animName = "stage2";
|
|
else if ( currentStage == 3 )
|
|
animName = "stage3";
|
|
else if ( currentStage == 4 )
|
|
animName = "stage4";
|
|
|
|
// Play the new animation if it exists
|
|
|
|
if ( destructionObject->animate && destructionObject->animate->HasAnim( animName ) )
|
|
{
|
|
destructionObject->animate->RandomAnimate( animName );
|
|
}
|
|
}
|
|
}
|
|
|
|
int ModifierDestruction::getStage( float health, float maxHealth )
|
|
{
|
|
if ( health < maxHealth * 0.1f )
|
|
return 4;
|
|
else if ( health < maxHealth * 0.25f )
|
|
return 3;
|
|
else if ( health < maxHealth * 0.5f )
|
|
return 2;
|
|
else
|
|
return 1;
|
|
}
|
|
|
|
bool ModifierDestruction::checkRule( const char *rule, bool defaultValue, Player *player )
|
|
{
|
|
// We want team spawnpoints
|
|
|
|
if ( stricmp( rule, "spawnpoints-team" ) == 0 )
|
|
return true;
|
|
else if ( stricmp( rule, "keepflags" ) == 0 )
|
|
return false;
|
|
else
|
|
return defaultValue;
|
|
}
|
|
|
|
bool ModifierDestruction::checkGameType( const char *gameType )
|
|
{
|
|
if ( stricmp( gameType, "destruction" ) == 0 )
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
bool ModifierOneFlag::shouldKeepItem( MultiplayerItem *item )
|
|
{
|
|
// We need to keep the one flag
|
|
|
|
if ( ( stricmp( item->getName().c_str(), "ctfflag-one" ) == 0 ) ||
|
|
( stricmp( item->getName().c_str(), "ctfflag-baseone" ) == 0 ) )
|
|
{
|
|
if ( !multiplayerManager.checkRule ( "keepflags", true ) )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ModifierOneFlag::checkRule( const char *rule, bool defaultValue, Player *player )
|
|
{
|
|
// Check to see if we care about this rule
|
|
|
|
if ( strnicmp( rule, "flagscore-", sizeof( "flagscore-" ) - 1 ) == 0 )
|
|
{
|
|
// See if this flag touch should generate a flag score
|
|
|
|
if ( stricmp( rule, "flagscore-teamflag" ) == 0 )
|
|
return false;
|
|
else if ( stricmp( rule, "flagscore-enemyflag" ) == 0 )
|
|
return true;
|
|
}
|
|
else if ( strnicmp( rule, "flagpickup-", sizeof( "flagpickup-" ) - 1 ) == 0 )
|
|
{
|
|
// See if this flag touch should generate a flag pickup
|
|
|
|
if ( stricmp( rule, "flagpickup-enemyflag" ) == 0 )
|
|
return false;
|
|
else if ( stricmp( rule, "flagpickup-otherflag-ctfflag-one" ) == 0 )
|
|
return true;
|
|
}
|
|
|
|
return defaultValue;
|
|
}
|
|
|
|
bool ModifierOneFlag::checkGameType( const char *gameType )
|
|
{
|
|
if ( stricmp( gameType, "oneflag" ) == 0 )
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
void ModifierOneFlag::addPlayer( Player *player )
|
|
{
|
|
gi.SendServerCommand( player->entnum, "stufftext \"ui_addhud mp_oneflagstatus\"\n" );
|
|
}
|
|
|
|
const int ModifierElimination::_pointsForBeingLastAlive = 5;
|
|
|
|
ModifierElimination::ModifierElimination()
|
|
{
|
|
_respawning = false;
|
|
_playerEliminated = false;
|
|
|
|
_playerEliminationData = NULL;
|
|
|
|
_eliminatedIconIndex = gi.imageindex( "sysimg/icons/mp/elimination_eliminated" );
|
|
|
|
_needPlayers = true;
|
|
|
|
_eliminatedTextIndex = G_FindConfigstringIndex( "$$EliminatedWait$$", CS_GENERAL_STRINGS, MAX_GENERAL_STRINGS, true ) + CS_GENERAL_STRINGS;;
|
|
_nextRoundTextIndex = G_FindConfigstringIndex( "$$NextRoundWait$$", CS_GENERAL_STRINGS, MAX_GENERAL_STRINGS, true ) + CS_GENERAL_STRINGS;;
|
|
}
|
|
|
|
ModifierElimination::~ModifierElimination()
|
|
{
|
|
delete [] _playerEliminationData;
|
|
}
|
|
|
|
void ModifierElimination::init( int maxPlayers )
|
|
{
|
|
_maxPlayers = maxPlayers;
|
|
_playerEliminationData = new EliminationPlayerData[ maxPlayers ];
|
|
|
|
multiplayerManager.cacheMultiplayerFiles( "mp_elimination" );
|
|
}
|
|
|
|
void ModifierElimination::reset( void )
|
|
{
|
|
int i;
|
|
|
|
_playerEliminated = false;
|
|
_matchOver = false;
|
|
|
|
for ( i = 0 ; i < _maxPlayers ; i++ )
|
|
{
|
|
_playerEliminationData[ i ].reset();
|
|
}
|
|
}
|
|
|
|
bool ModifierElimination::checkRule( const char *rule, bool defaultValue, Player *player )
|
|
{
|
|
// Only let players respawn between matches
|
|
|
|
if ( ( stricmp( rule, "respawnPlayer" ) == 0 ) )
|
|
{
|
|
if ( !player || _playerEliminationData[ player->entnum ]._eliminated )
|
|
return false;
|
|
}
|
|
else if ( ( stricmp( rule, "spawnPlayer" ) == 0 ) || ( stricmp( rule, "changeTeams" ) == 0 ) )
|
|
{
|
|
// Don't spawn him if he has been eliminated
|
|
|
|
if ( player && _playerEliminationData[ player->entnum ]._eliminated )
|
|
return false;
|
|
|
|
// Ok if in first 30 seconds of match
|
|
|
|
if ( _matchStartTime + 5 > multiplayerManager.getTime() )
|
|
return defaultValue;
|
|
|
|
// See if we still need players
|
|
|
|
if ( _needPlayers )
|
|
{
|
|
return defaultValue;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return defaultValue;
|
|
}
|
|
|
|
void ModifierElimination::addPlayer( Player *player )
|
|
{
|
|
_playerEliminationData[ player->entnum ].reset();
|
|
|
|
if ( multiplayerManager.checkGameType( "dm" ) )
|
|
gi.SendServerCommand( player->entnum, "stufftext \"ui_addhud mp_elimination\"\n" );
|
|
else
|
|
gi.SendServerCommand( player->entnum, "stufftext \"ui_addhud mp_eliminationteam\"\n" );
|
|
|
|
if ( multiplayerManager.isPlayerSpectator( player ) && !multiplayerManager.isPlayerSpectatorByChoice( player ) )
|
|
{
|
|
_playerEliminationData[ player->entnum ]._eliminated = true;
|
|
}
|
|
}
|
|
|
|
void ModifierElimination::playerKilled( Player *killedPlayer, Player *attackingPlayer, Entity *inflictor, int meansOfDeath )
|
|
{
|
|
Team *team;
|
|
|
|
if ( !killedPlayer )
|
|
return;
|
|
|
|
_playerEliminated = true;
|
|
|
|
_playerEliminationData[ killedPlayer->entnum ]._eliminated = true;
|
|
|
|
team = multiplayerManager.getPlayersTeam( killedPlayer );
|
|
|
|
if ( !team || ( numPlayersAliveOnTeam( team->getName() ) > 0 ) )
|
|
{
|
|
multiplayerManager.HUDPrintAllClients( va( "%s $$Eliminated$$\n", killedPlayer->client->pers.netname ) );
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_pyelim.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, NULL, 1.0f );
|
|
}
|
|
}
|
|
|
|
int ModifierElimination::getScoreIcon( Player *player, int index, int value )
|
|
{
|
|
if ( index == SCOREICON3 )
|
|
{
|
|
if ( _playerEliminationData[ player->entnum ]._eliminated )
|
|
return _eliminatedIconIndex;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
int ModifierElimination::getStat( Player *player, int statNum, int value )
|
|
{
|
|
int numAlive = 0;
|
|
Team *team;
|
|
Player *currentPlayer;
|
|
gentity_t *edict;
|
|
int i;
|
|
|
|
if ( statNum == STAT_MP_GENERIC5 )
|
|
{
|
|
if ( multiplayerManager.checkGameType( "dm" ) )
|
|
{
|
|
for( i = 0 ; i < game.maxclients ; i++ )
|
|
{
|
|
edict = &g_entities[ i ];
|
|
|
|
// Make sure this edict is a valid player
|
|
|
|
if ( !edict->inuse || !edict->entity || !edict->entity->isSubclassOf( Player ) )
|
|
continue;
|
|
|
|
currentPlayer = ( Player * )edict->entity;
|
|
|
|
if ( !_playerEliminationData[ currentPlayer->entnum ]._eliminated && !multiplayerManager.isPlayerSpectator( currentPlayer ) )
|
|
numAlive++;
|
|
}
|
|
|
|
return numAlive;
|
|
}
|
|
else
|
|
{
|
|
for( i = 0 ; i < game.maxclients ; i++ )
|
|
{
|
|
edict = &g_entities[ i ];
|
|
|
|
// Make sure this edict is a valid player
|
|
|
|
if ( !edict->inuse || !edict->entity || !edict->entity->isSubclassOf( Player ) )
|
|
continue;
|
|
|
|
currentPlayer = ( Player * )edict->entity;
|
|
|
|
// Get the player's team
|
|
|
|
team = multiplayerManager.getPlayersTeam( currentPlayer );
|
|
|
|
if ( team && team->getName() == "Red" && !_playerEliminationData[ currentPlayer->entnum ]._eliminated &&
|
|
!multiplayerManager.isPlayerSpectator( currentPlayer ) )
|
|
{
|
|
numAlive++;
|
|
}
|
|
}
|
|
|
|
return numAlive;
|
|
}
|
|
}
|
|
else if ( statNum == STAT_MP_GENERIC6 )
|
|
{
|
|
if ( !multiplayerManager.checkGameType( "dm" ) )
|
|
{
|
|
for( i = 0 ; i < game.maxclients ; i++ )
|
|
{
|
|
edict = &g_entities[ i ];
|
|
|
|
// Make sure this edict is a valid player
|
|
|
|
if ( !edict->inuse || !edict->entity || !edict->entity->isSubclassOf( Player ) )
|
|
continue;
|
|
|
|
currentPlayer = ( Player * )edict->entity;
|
|
|
|
// Get the player's team
|
|
|
|
team = multiplayerManager.getPlayersTeam( currentPlayer );
|
|
|
|
if ( team && team->getName() == "Blue" && !_playerEliminationData[ currentPlayer->entnum ]._eliminated &&
|
|
!multiplayerManager.isPlayerSpectator( currentPlayer ) )
|
|
{
|
|
numAlive++;
|
|
}
|
|
}
|
|
|
|
return numAlive;
|
|
}
|
|
}
|
|
else if ( statNum == STAT_MP_STATE )
|
|
{
|
|
if ( _playerEliminationData[ player->entnum ]._eliminated )
|
|
return _eliminatedTextIndex;
|
|
|
|
if ( multiplayerManager.isPlayerSpectator( player ) && multiplayerManager.isFightingAllowed() )
|
|
return _nextRoundTextIndex;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
void ModifierElimination::matchStarting( void )
|
|
{
|
|
reset();
|
|
|
|
_matchStartTime = multiplayerManager.getTime();
|
|
_needPlayers = true;
|
|
}
|
|
|
|
int ModifierElimination::numPlayersAliveOnTeam( const str &teamName )
|
|
{
|
|
int i;
|
|
Player *player;
|
|
gentity_t *edict;
|
|
int numPlayers;
|
|
Team *team;
|
|
|
|
|
|
numPlayers = 0;
|
|
|
|
for( i = 0 ; i < game.maxclients ; i++ )
|
|
{
|
|
edict = &g_entities[ i ];
|
|
|
|
// Make sure this edict is a valid player
|
|
|
|
if ( !edict->inuse || !edict->entity || edict->entity->isSubclassOf( Player ) )
|
|
continue;
|
|
|
|
player = ( Player * )edict->entity;
|
|
|
|
// Get the player's team
|
|
|
|
team = multiplayerManager.getPlayersTeam( player );
|
|
|
|
if ( team && ( team->getName() == teamName ) && !_playerEliminationData[ player->entnum ]._eliminated )
|
|
{
|
|
numPlayers++;
|
|
}
|
|
}
|
|
|
|
return numPlayers;
|
|
}
|
|
|
|
void ModifierElimination::update( float frameTime )
|
|
{
|
|
int numAlive = 0;
|
|
int numRedTeamAlive = 0;
|
|
int numBlueTeamAlive = 0;
|
|
Team *team;
|
|
bool redTeam = false;
|
|
bool blueTeam = false;
|
|
bool usingTeams = false;
|
|
bool respawnEveryone;
|
|
Player *playerAlive = NULL;
|
|
Player *player;
|
|
Entity *entity;
|
|
gentity_t *edict;
|
|
int i;
|
|
|
|
|
|
if ( _matchOver )
|
|
return;
|
|
|
|
// Gather number of people alive and dead
|
|
|
|
for( i = 0 ; i < game.maxclients ; i++ )
|
|
{
|
|
edict = &g_entities[ i ];
|
|
|
|
// Make sure this edict is a valid player
|
|
|
|
if ( !edict->inuse || !edict->entity )
|
|
continue;
|
|
|
|
entity = edict->entity;
|
|
|
|
if ( !entity->isSubclassOf( Player ) )
|
|
continue;
|
|
|
|
player = ( Player * )entity;
|
|
|
|
// Get the player's team
|
|
|
|
team = multiplayerManager.getPlayersTeam( player );
|
|
|
|
redTeam = false;
|
|
blueTeam = false;
|
|
|
|
if ( team )
|
|
{
|
|
if ( stricmp( team->getName().c_str(), "red" ) == 0 )
|
|
{
|
|
redTeam = true;
|
|
usingTeams = true;
|
|
}
|
|
else if ( stricmp( team->getName().c_str(), "blue" ) == 0 )
|
|
{
|
|
blueTeam = true;
|
|
usingTeams = true;
|
|
}
|
|
}
|
|
|
|
// Calculate number of people alive on each team
|
|
|
|
if ( !_playerEliminationData[ player->entnum ]._eliminated && !multiplayerManager.isPlayerSpectator( player ) )
|
|
{
|
|
numAlive++;
|
|
|
|
playerAlive = player;
|
|
|
|
if ( redTeam )
|
|
numRedTeamAlive++;
|
|
else if ( blueTeam )
|
|
numBlueTeamAlive++;
|
|
}
|
|
}
|
|
|
|
// See if we need players
|
|
|
|
if ( usingTeams )
|
|
{
|
|
if ( numRedTeamAlive == 0 || numBlueTeamAlive == 0 )
|
|
_needPlayers = true;
|
|
else
|
|
_needPlayers = false;
|
|
|
|
}
|
|
else
|
|
{
|
|
if ( numAlive < 2 )
|
|
_needPlayers = true;
|
|
else
|
|
_needPlayers = false;
|
|
}
|
|
|
|
if ( !_playerEliminated )
|
|
return;
|
|
|
|
// See if the round is over
|
|
|
|
respawnEveryone = false;
|
|
|
|
if ( usingTeams )
|
|
{
|
|
// Determine if only one team is alive
|
|
|
|
if ( ( numRedTeamAlive > 0 ) && ( numBlueTeamAlive == 0 ) )
|
|
{
|
|
multiplayerManager.centerPrintAllClients( "$$BlueTeamEliminated$$", CENTERPRINT_IMPORTANCE_NORMAL );
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_btelim.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, NULL, 1.2f );
|
|
|
|
if ( multiplayerManager.checkRule ( "endmatch-elimination-blue", true, NULL ) )
|
|
{
|
|
respawnEveryone = true;
|
|
multiplayerManager.addTeamPoints( "Red", 1 );
|
|
}
|
|
else
|
|
{
|
|
_matchOver = true;
|
|
}
|
|
}
|
|
else if ( ( numBlueTeamAlive > 0 ) && ( numRedTeamAlive == 0 ) )
|
|
{
|
|
multiplayerManager.centerPrintAllClients( "$$RedTeamEliminated$$", CENTERPRINT_IMPORTANCE_NORMAL );
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_rtelim.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, NULL, 1.2f );
|
|
|
|
if ( multiplayerManager.checkRule ( "endmatch-elimination-red", true, NULL ) )
|
|
{
|
|
respawnEveryone = true;
|
|
multiplayerManager.addTeamPoints( "Blue", 1 );
|
|
}
|
|
else
|
|
{
|
|
_matchOver = true;
|
|
}
|
|
}
|
|
else if ( ( numBlueTeamAlive == 0 ) && ( numRedTeamAlive == 0 ) )
|
|
{
|
|
multiplayerManager.centerPrintAllClients( "$$NoOneWinsRound$$!", CENTERPRINT_IMPORTANCE_NORMAL );
|
|
|
|
if ( multiplayerManager.checkRule ( "endmatch-elimination-both", true, NULL ) )
|
|
{
|
|
respawnEveryone = true;
|
|
}
|
|
else
|
|
{
|
|
_matchOver = true;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Determine if one person won the match
|
|
|
|
if ( numAlive == 1 )
|
|
{
|
|
str stringToPrint;
|
|
|
|
stringToPrint = playerAlive->client->pers.netname;
|
|
stringToPrint += " $$WinsRound$$!";
|
|
|
|
multiplayerManager.centerPrintAllClients( stringToPrint.c_str(), CENTERPRINT_IMPORTANCE_NORMAL );
|
|
respawnEveryone = true;
|
|
|
|
multiplayerManager.addPoints( playerAlive->entnum, _pointsForBeingLastAlive );
|
|
}
|
|
else if ( numAlive == 0 )
|
|
{
|
|
multiplayerManager.centerPrintAllClients( "$$NoOneWinsRound$$!", CENTERPRINT_IMPORTANCE_NORMAL );
|
|
respawnEveryone = true;
|
|
}
|
|
}
|
|
|
|
if ( respawnEveryone )
|
|
{
|
|
// The match has been won, restart the match
|
|
|
|
multiplayerManager.endMatch();
|
|
//multiplayerManager.restartMatch();
|
|
|
|
_matchOver = true;
|
|
}
|
|
}
|
|
|
|
// Setup constants
|
|
|
|
const float ModifierDiffusion::_timeNeededToArmBomb = 5.0f;
|
|
const float ModifierDiffusion::_timeNeededToDisarmBomb = 5.0f;
|
|
const float ModifierDiffusion::_maxGuardingDist = 750.0f;
|
|
|
|
const float ModifierDiffusion::_maxArmingPause = 1.0f;
|
|
const float ModifierDiffusion::_maxDisarmingPause = 1.0f;
|
|
|
|
const float ModifierDiffusion::_maxBombOnGroundTime = 30.0f;
|
|
|
|
const int ModifierDiffusion::_pointsForArmingBomb = 25;
|
|
const int ModifierDiffusion::_pointsForExplodingBomb = 50;
|
|
const int ModifierDiffusion::_pointsForDisarmingBomb = 50;
|
|
const int ModifierDiffusion::_pointsForGuardingBase = 5;
|
|
const int ModifierDiffusion::_pointsForGuardingTheBomber = 5;
|
|
const int ModifierDiffusion::_pointsForGuardingBomb = 5;
|
|
const int ModifierDiffusion::_pointsForKillingTheBomber = 10;
|
|
|
|
const int ModifierDiffusion::_teamPointsForBombing = 250;
|
|
|
|
DiffusionBombPlace::DiffusionBombPlace()
|
|
{
|
|
_item = NULL;
|
|
reset();
|
|
}
|
|
|
|
void DiffusionBombPlace::reset()
|
|
{
|
|
_armed = false;
|
|
|
|
_totalArmingTime = 0.0f;
|
|
_totalDisarmingTime = 0.0f;
|
|
|
|
_lastArmingTime = 0.0f;
|
|
_lastDisarmingTime = 0.0f;
|
|
|
|
_totalArmedTime = 0.0f;
|
|
};
|
|
|
|
ModifierDiffusion::ModifierDiffusion()
|
|
{
|
|
_bomber = -1;
|
|
_bombArmedByPlayer = -1;
|
|
|
|
_lastBomber = -1;
|
|
_bombDroppedTime = 0.0f;
|
|
|
|
_bomb = NULL;
|
|
_tempBombItem = NULL;
|
|
|
|
_bomberIconIndex = gi.imageindex( "sysimg/icons/mp/diffusion_bomber" );
|
|
|
|
_redBombPlaceArmedIconIndex = gi.imageindex( "sysimg/icons/mp/diffusion_bombArmed-red" );
|
|
_blueBombPlaceArmedIconIndex = gi.imageindex( "sysimg/icons/mp/diffusion_bombArmed-blue" );
|
|
|
|
_bombCarriedByRedTeamIconIndex = gi.imageindex( "sysimg/icons/mp/diffusion_bombTaken-red" );
|
|
_bombCarriedByBlueTeamIconIndex = gi.imageindex( "sysimg/icons/mp/diffusion_bombTaken-blue" );
|
|
|
|
_bombInBaseIconIndex = gi.imageindex( "sysimg/icons/mp/diffusion_bombNormal" );
|
|
_bombOnGroundIconIndex = gi.imageindex( "sysimg/icons/mp/diffusion_bombOnground" );
|
|
|
|
_respawnTime = 0.0f;
|
|
}
|
|
|
|
ModifierDiffusion::~ModifierDiffusion()
|
|
{
|
|
multiplayerManager.resetRespawnTime();
|
|
}
|
|
|
|
void ModifierDiffusion::init( int maxPlayers )
|
|
{
|
|
_maxPlayers = maxPlayers;
|
|
|
|
_timeNeededForBombToExplode = mp_bombTime->value;
|
|
|
|
if ( multiplayerManager.getRespawnTime() < 0.0f )
|
|
{
|
|
multiplayerManager.setRespawnTime( 5.0f );
|
|
}
|
|
|
|
multiplayerManager.cacheMultiplayerFiles( "mp_diffusion" );
|
|
}
|
|
|
|
void ModifierDiffusion::playerSpawned( Player *player )
|
|
{
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-tricorder.tik" );
|
|
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-compressionrifle.tik" );
|
|
multiplayerManager.usePlayerItem( player->entnum, "CompressionRifle" );
|
|
}
|
|
|
|
void ModifierDiffusion::playerEventNotification( const char *eventName, const char *eventItemName, Player *eventPlayer )
|
|
{
|
|
if ( stricmp( eventName, "use-HoldableItem" ) == 0 )
|
|
{
|
|
if ( stricmp( eventItemName, "Transporter" ) == 0 )
|
|
{
|
|
dropBomb( eventPlayer );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool ModifierDiffusion::checkRule( const char *rule, bool defaultValue, Player *player )
|
|
{
|
|
// We want team spawnpoints
|
|
|
|
if ( stricmp( rule, "spawnpoints-team" ) == 0 )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return defaultValue;
|
|
}
|
|
|
|
bool ModifierDiffusion::shouldKeepItem( MultiplayerItem *item )
|
|
{
|
|
if ( strnicmp( item->getName().c_str(), "Diffusion-", strlen( "Diffusion-" ) ) == 0 )
|
|
{
|
|
// This is a diffusion item so keep track of it
|
|
|
|
if ( stricmp( item->getName().c_str(), "Diffusion-bombplace-red" ) == 0 )
|
|
_redBombPlace._item = item;
|
|
else if ( stricmp( item->getName().c_str(), "Diffusion-bombplace-blue" ) == 0 )
|
|
_blueBombPlace._item = item;
|
|
else if ( stricmp( item->getName().c_str(), "Diffusion-bomb" ) == 0 )
|
|
_bomb = item;
|
|
else
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void ModifierDiffusion::itemTouched( Player *player, MultiplayerItem *item )
|
|
{
|
|
str printString;
|
|
|
|
|
|
// Can't pickup bomb during respawn period
|
|
|
|
if ( _respawnTime > 0.0f )
|
|
return;
|
|
|
|
// Make sure this is a bomb
|
|
|
|
if ( ( item != _bomb ) && ( item != _tempBombItem ) )
|
|
return;
|
|
|
|
// Make sure this isn't a bot
|
|
|
|
if ( player->edict->svflags & SVF_BOT )
|
|
return;
|
|
|
|
// Make sure we can't pickup the bomb right after we dropped it
|
|
|
|
if ( ( player->entnum == _lastBomber ) && ( _bombDroppedTime + 0.5 > multiplayerManager.getTime() ) )
|
|
return;
|
|
|
|
// Give the bomb to the player
|
|
|
|
makeBomber( player );
|
|
|
|
// Tell everyone that the bomb has been picked up
|
|
|
|
printString = "$$BombTaken$$ ";
|
|
printString += player->client->pers.netname;
|
|
|
|
printString += " ($$";
|
|
printString += multiplayerManager.getPlayersTeam( player )->getName();
|
|
printString += "$$ $$Team$$)!";
|
|
|
|
multiplayerManager.centerPrintAllClients( printString, CENTERPRINT_IMPORTANCE_HIGH );
|
|
|
|
if ( multiplayerManager.getPlayersTeam( player )->getName() == "Red" )
|
|
{
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_bombtakenred.mp3", CHAN_AUTO, DEFAULT_VOL,
|
|
DEFAULT_MIN_DIST, player, 1.5f );
|
|
}
|
|
else
|
|
{
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_bombtakenblue.mp3", CHAN_AUTO, DEFAULT_VOL,
|
|
DEFAULT_MIN_DIST, player, 1.5f );
|
|
}
|
|
|
|
if ( item == _tempBombItem )
|
|
{
|
|
// Get rid of the temporary bomb
|
|
|
|
_tempBombItem->PostEvent( EV_Remove, 0.0f );
|
|
_tempBombItem = NULL;
|
|
}
|
|
else
|
|
{
|
|
// Hide the item picked up
|
|
|
|
_bomb->setSolidType( SOLID_NOT );
|
|
_bomb->hideModel();
|
|
}
|
|
}
|
|
|
|
void ModifierDiffusion::dropBomb( Player *player )
|
|
{
|
|
MultiplayerItem *newBomb;
|
|
str printString;
|
|
|
|
// Make sure everything is ok
|
|
|
|
if ( player != getBomber() )
|
|
return;
|
|
|
|
// Create a new bomb to put on the ground
|
|
|
|
newBomb = new MultiplayerItem;
|
|
|
|
newBomb->setModel( _bomb->model );
|
|
|
|
newBomb->angles = player->angles;
|
|
newBomb->setAngles();
|
|
|
|
newBomb->setOrigin( player->origin );
|
|
|
|
newBomb->CancelEventsOfType( EV_ProcessInitCommands );
|
|
newBomb->ProcessInitCommands( newBomb->edict->s.modelindex );
|
|
|
|
newBomb->setName( "Diffusion-bomb-temp" );
|
|
|
|
// Setup the _tempBombItem stuff
|
|
|
|
_tempBombItem = newBomb;
|
|
_tempBombItemTime = multiplayerManager.getTime();
|
|
|
|
// Change the player back to not being a bomber
|
|
|
|
clearBomber();
|
|
_bombDroppedTime = multiplayerManager.getTime();
|
|
|
|
// Tell the team that the bomb was dropped
|
|
|
|
printString = "$$BombDropped$$";
|
|
|
|
multiplayerManager.centerPrintAllClients( printString, CENTERPRINT_IMPORTANCE_HIGH );
|
|
}
|
|
|
|
void ModifierDiffusion::respawnBomb( bool quiet )
|
|
{
|
|
str printString;
|
|
|
|
if ( _tempBombItem )
|
|
{
|
|
_tempBombItem->PostEvent( EV_Remove, 0.0f );
|
|
_tempBombItem = NULL;
|
|
}
|
|
|
|
if ( _bomb )
|
|
{
|
|
_bomb->showModel();
|
|
_bomb->setSolidType( SOLID_TRIGGER );
|
|
}
|
|
|
|
if ( !quiet )
|
|
{
|
|
printString = "$$BombReturnedToBase$$";
|
|
multiplayerManager.centerPrintAllClients( printString, CENTERPRINT_IMPORTANCE_HIGH );
|
|
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_bombbase.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, NULL, 1.5f );
|
|
}
|
|
}
|
|
|
|
void ModifierDiffusion::itemUsed( Entity *entity, MultiplayerItem *item )
|
|
{
|
|
Equipment *equipment;
|
|
Sentient *owner;
|
|
Player *player;
|
|
bool offense;
|
|
bool defense;
|
|
Team *team;
|
|
DiffusionBombPlace *enemyBombPlace;
|
|
DiffusionBombPlace *teamBombPlace;
|
|
str printString;
|
|
|
|
if ( entity && entity->isSubclassOf( Player ) )
|
|
{
|
|
player = (Player *)entity;
|
|
|
|
if ( !( player->edict->svflags & SVF_BOT ) )
|
|
{
|
|
player->loadUseItem( "tricorder" );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if ( !entity || !entity->isSubclassOf( Equipment ) )
|
|
return;
|
|
|
|
// Get the use info
|
|
|
|
equipment = (Equipment *)entity;
|
|
|
|
owner = equipment->GetOwner();
|
|
|
|
if ( !owner || !owner->isSubclassOf( Player ) )
|
|
return;
|
|
|
|
player = (Player *)owner;
|
|
|
|
if ( stricmp( equipment->getTypeName().c_str(), "tricorder" ) != 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Figure out if the player is on offense or defense
|
|
|
|
team = multiplayerManager.getPlayersTeam( player );
|
|
|
|
if ( !team )
|
|
return;
|
|
|
|
offense = false;
|
|
defense = false;
|
|
|
|
enemyBombPlace = NULL;
|
|
teamBombPlace = NULL;
|
|
|
|
if ( team->getName() == "Red" )
|
|
{
|
|
if ( item == _redBombPlace._item )
|
|
defense = true;
|
|
else if ( item == _blueBombPlace._item )
|
|
offense = true;
|
|
|
|
enemyBombPlace = &_blueBombPlace;
|
|
teamBombPlace = &_redBombPlace;
|
|
}
|
|
else if ( team->getName() == "Blue" )
|
|
{
|
|
if ( item == _blueBombPlace._item )
|
|
defense = true;
|
|
else if ( item == _redBombPlace._item )
|
|
offense = true;
|
|
|
|
enemyBombPlace = &_redBombPlace;
|
|
teamBombPlace = &_blueBombPlace;
|
|
}
|
|
|
|
if ( offense )
|
|
{
|
|
// Must be the bomber
|
|
|
|
if ( player->entnum != _bomber )
|
|
return;
|
|
|
|
if ( !enemyBombPlace->_armed && ( enemyBombPlace->_lastArmingTime != level.time ) )
|
|
{
|
|
enemyBombPlace->_lastArmingTime = level.time;
|
|
|
|
enemyBombPlace->_totalArmingTime += level.frametime;
|
|
|
|
if ( enemyBombPlace->_totalArmingTime > _timeNeededToArmBomb )
|
|
{
|
|
SpawnArgs args;
|
|
int tagNum;
|
|
|
|
_bombArmedByPlayer = player->entnum;
|
|
|
|
enemyBombPlace->_armed = true;
|
|
|
|
enemyBombPlace->_lastDisarmingTime = 0.0f;
|
|
enemyBombPlace->_totalDisarmingTime = 0.0f;
|
|
enemyBombPlace->_totalArmedTime = 0.0f;
|
|
|
|
clearBomber();
|
|
|
|
// Tell everyone the bomb has been armed
|
|
|
|
printString = "$$BombArmed$$ ";
|
|
printString += player->client->pers.netname;
|
|
printString += " ($$";
|
|
printString += multiplayerManager.getPlayersTeam( player )->getName();
|
|
printString += "$$ $$Team$$)!";
|
|
|
|
multiplayerManager.centerPrintAllClients( printString, CENTERPRINT_IMPORTANCE_NORMAL );
|
|
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_bomba.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, NULL, 1.0f );
|
|
|
|
// Spawn a bomb in the bomb place
|
|
|
|
args.setArg( "model", "models/item/mp_diffusion_bomb.tik" );
|
|
|
|
_attachedBomb = args.Spawn();
|
|
|
|
if ( !_attachedBomb )
|
|
return;
|
|
|
|
tagNum = gi.Tag_NumForName( enemyBombPlace->_item->edict->s.modelindex, "tag_bomb" );
|
|
|
|
if ( tagNum >= 0 )
|
|
{
|
|
_attachedBomb->attach( enemyBombPlace->_item->entnum, tagNum );
|
|
}
|
|
else
|
|
{
|
|
_attachedBomb->setOrigin( enemyBombPlace->_item->origin );
|
|
}
|
|
|
|
_attachedBomb->ProcessPendingEvents();
|
|
|
|
_attachedBomb->setSolidType( SOLID_NOT );
|
|
|
|
_attachedBomb->SetTargetName( "attachedDiffusionBomb" );
|
|
|
|
if ( !_attachedBomb->animate )
|
|
_attachedBomb->animate = new Animate( _attachedBomb );
|
|
|
|
_attachedBomb->animate->RandomAnimate( "idle" );
|
|
}
|
|
}
|
|
}
|
|
else if ( defense )
|
|
{
|
|
// Make sure the player's team's bomb place has been armed
|
|
|
|
if ( !teamBombPlace->_armed )
|
|
return;
|
|
|
|
if ( teamBombPlace->_lastDisarmingTime != level.time )
|
|
{
|
|
teamBombPlace->_lastDisarmingTime = level.time;
|
|
|
|
teamBombPlace->_totalDisarmingTime += level.frametime;
|
|
|
|
if ( teamBombPlace->_totalDisarmingTime > _timeNeededToDisarmBomb )
|
|
{
|
|
// Disarmed the bomb
|
|
|
|
teamBombPlace->_armed = false;
|
|
|
|
teamBombPlace->_item->removeAttachedModelByTargetname( "attachedDiffusionBomb" );
|
|
|
|
makeBomber( player );
|
|
|
|
// Tell everyone the bomb has been armed
|
|
|
|
printString = "$$BombDisarmed$$ ";
|
|
printString += player->client->pers.netname;
|
|
printString += " ($$";
|
|
printString += multiplayerManager.getPlayersTeam( player )->getName();
|
|
printString += "$$ $$Team$$)!";
|
|
|
|
multiplayerManager.centerPrintAllClients( printString, CENTERPRINT_IMPORTANCE_NORMAL );
|
|
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_bombdisarmed.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, player, 1.0f );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ModifierDiffusion::playerChangedModel( Player *player )
|
|
{
|
|
if ( player->entnum == _bomber )
|
|
{
|
|
attachBomb( player );
|
|
}
|
|
}
|
|
|
|
void ModifierDiffusion::attachBomb( Player *player )
|
|
{
|
|
Event *attachEvent;
|
|
str tagName;
|
|
|
|
player->removeAttachedModelByTargetname( "attachedDiffusionBomb" );
|
|
|
|
if ( gi.Tag_NumForName( player->edict->s.modelindex, "Bip01 spine2" ) >= 0 )
|
|
tagName = "Bip01 spine2";
|
|
else if ( gi.Tag_NumForName( player->edict->s.modelindex, "Bip01 spine1" ) >= 0 )
|
|
tagName = "Bip01 spine1";
|
|
else if ( gi.Tag_NumForName( player->edict->s.modelindex, "Bip01 Head" ) >= 0 )
|
|
tagName = "Bip01 Head";
|
|
|
|
attachEvent = new Event( EV_AttachModel );
|
|
|
|
attachEvent->AddString( "models/item/mp_diffusion_bomb.tik" );
|
|
attachEvent->AddString( tagName );
|
|
attachEvent->AddFloat( 1.0f );
|
|
attachEvent->AddString( "attachedDiffusionBomb" );
|
|
attachEvent->AddInteger( 0 );
|
|
attachEvent->AddFloat( -1.0f );
|
|
attachEvent->AddFloat( 0.0f );
|
|
attachEvent->AddFloat( -1.0f );
|
|
attachEvent->AddFloat( -1.0f );
|
|
attachEvent->AddVector( player->getBackpackAttachOffset() );
|
|
attachEvent->AddVector( player->getBackpackAttachAngles() );
|
|
|
|
player->ProcessEvent( attachEvent );
|
|
}
|
|
|
|
int ModifierDiffusion::getStat( Player *player, int statNum, int value )
|
|
{
|
|
if ( statNum == STAT_MP_GENERIC1 )
|
|
{
|
|
if ( _redBombPlace._armed )
|
|
{
|
|
return (int)( 100.0f - ( _redBombPlace._totalDisarmingTime / _timeNeededToDisarmBomb ) * 100.0f );
|
|
}
|
|
else
|
|
{
|
|
return (int)( ( _redBombPlace._totalArmingTime / _timeNeededToArmBomb ) * 100.0f );
|
|
}
|
|
}
|
|
else if ( statNum == STAT_MP_GENERIC3 )
|
|
{
|
|
if ( _blueBombPlace._armed )
|
|
{
|
|
return (int)( 100.0f - ( _blueBombPlace._totalDisarmingTime / _timeNeededToDisarmBomb ) * 100.0f );
|
|
}
|
|
else
|
|
{
|
|
return (int)( ( _blueBombPlace._totalArmingTime / _timeNeededToArmBomb ) * 100.0f );
|
|
}
|
|
}
|
|
else if ( statNum == STAT_MP_GENERIC2 )
|
|
{
|
|
|
|
if ( _redBombPlace._armed )
|
|
{
|
|
return (int)ceil( _timeNeededForBombToExplode - _redBombPlace._totalArmedTime );
|
|
}
|
|
else if ( _blueBombPlace._armed )
|
|
{
|
|
return (int)ceil( _timeNeededForBombToExplode - _blueBombPlace._totalArmedTime );
|
|
}
|
|
else
|
|
{
|
|
return 999;
|
|
}
|
|
}
|
|
else if ( statNum == STAT_MP_GENERIC7 )
|
|
{
|
|
Player *bomber = getBomber();
|
|
str bomberTeamName;
|
|
|
|
if ( bomber )
|
|
{
|
|
bomberTeamName = multiplayerManager.getPlayersTeam( bomber )->getName();
|
|
}
|
|
|
|
if ( _redBombPlace._armed )
|
|
return _redBombPlaceArmedIconIndex;
|
|
else if ( _blueBombPlace._armed )
|
|
return _blueBombPlaceArmedIconIndex;
|
|
else if ( bomber && ( bomberTeamName == "Red" ) )
|
|
return _bombCarriedByRedTeamIconIndex;
|
|
else if ( bomber && ( bomberTeamName == "Blue" ) )
|
|
return _bombCarriedByBlueTeamIconIndex;
|
|
else if ( _bomb->getSolidType() != SOLID_NOT )
|
|
return _bombInBaseIconIndex;
|
|
else
|
|
return _bombOnGroundIconIndex;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
void ModifierDiffusion::addPlayer( Player *player )
|
|
{
|
|
gi.SendServerCommand( player->entnum, "stufftext \"ui_addhud mp_diffusion\"\n" );
|
|
}
|
|
|
|
void ModifierDiffusion::removePlayer( Player *player )
|
|
{
|
|
// Put any items back that are necessary
|
|
|
|
if ( player->entnum == _bomber )
|
|
{
|
|
dropBomb( player );
|
|
}
|
|
|
|
if ( _bombArmedByPlayer == player->entnum )
|
|
{
|
|
_bombArmedByPlayer = -1;
|
|
}
|
|
}
|
|
|
|
void ModifierDiffusion::playerKilled( Player *killedPlayer, Player *attackingPlayer, Entity *inflictor, int meansOfDeath )
|
|
{
|
|
bool victimWasBomber;
|
|
|
|
if ( killedPlayer->entnum == _bomber )
|
|
{
|
|
dropBomb( killedPlayer );
|
|
|
|
victimWasBomber = true;
|
|
}
|
|
else
|
|
{
|
|
victimWasBomber = false;
|
|
}
|
|
|
|
// Make sure this was a good kill
|
|
|
|
if ( !attackingPlayer || ( attackingPlayer == killedPlayer ) )
|
|
return;
|
|
|
|
if ( multiplayerManager.getPlayersTeam( killedPlayer ) && multiplayerManager.getPlayersTeam( attackingPlayer ) &&
|
|
( multiplayerManager.getPlayersTeam( killedPlayer ) == multiplayerManager.getPlayersTeam( attackingPlayer ) ) )
|
|
return;
|
|
|
|
// Award extra points (if any)
|
|
|
|
if ( victimWasBomber )
|
|
{
|
|
// Give points to the player that killed the bomber
|
|
|
|
multiplayerManager.addPoints( attackingPlayer->entnum, _pointsForKillingTheBomber );
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_bomberKilled.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, NULL, 1.0f );
|
|
}
|
|
|
|
// Give more points possibly
|
|
|
|
if ( playerGuardedBomber( attackingPlayer, killedPlayer ) )
|
|
{
|
|
// Give points to the player that guarded the bomber
|
|
|
|
multiplayerManager.addPoints( attackingPlayer->entnum, _pointsForGuardingTheBomber );
|
|
multiplayerManager.playerSound( attackingPlayer->entnum, "localization/sound/dialog/dm/comp_bomberguarded.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, 1.2f );
|
|
}
|
|
else if ( playerGuardedBase( attackingPlayer, killedPlayer ) )
|
|
{
|
|
// Give points to the player that guarded the armed bomb
|
|
|
|
multiplayerManager.addPoints( attackingPlayer->entnum, _pointsForGuardingBase );
|
|
multiplayerManager.playerSound( attackingPlayer->entnum, "localization/sound/dialog/dm/comp_baseguarded.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, 1.2f );
|
|
}
|
|
else if ( playerGuardedBomb( attackingPlayer, killedPlayer ) )
|
|
{
|
|
// Give points to the player that guarded the armed bomb
|
|
|
|
multiplayerManager.addPoints( attackingPlayer->entnum, _pointsForGuardingBomb );
|
|
multiplayerManager.playerSound( attackingPlayer->entnum, "localization/sound/dialog/dm/comp_bombguarded.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, 1.2f );
|
|
}
|
|
}
|
|
|
|
Player *ModifierDiffusion::getBomber( void )
|
|
{
|
|
if ( _bomber >= 0 )
|
|
return multiplayerManager.getPlayer( _bomber );
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
bool ModifierDiffusion::playerGuardedBomber( Player *attackingPlayer, Player *killedPlayer )
|
|
{
|
|
Player *bomber;
|
|
|
|
// Get the bomber
|
|
|
|
bomber = getBomber();
|
|
|
|
if ( !bomber )
|
|
return false;
|
|
|
|
// Make sure bomber is on the same team as the attacker
|
|
|
|
if ( multiplayerManager.getPlayersTeam( attackingPlayer ) != multiplayerManager.getPlayersTeam( bomber ) )
|
|
return false;
|
|
|
|
// See if the attacking or killed player is within the guarding distance of the bomber
|
|
|
|
if ( withinGuardDistance( bomber->origin, attackingPlayer->origin ) ||
|
|
withinGuardDistance( bomber->origin, killedPlayer->origin ) )
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
bool ModifierDiffusion::playerGuardedBase( Player *attackingPlayer, Player *killedPlayer )
|
|
{
|
|
MultiplayerItem *bombPlace;
|
|
Team *team;
|
|
|
|
team = multiplayerManager.getPlayersTeam( attackingPlayer );
|
|
|
|
if ( !team )
|
|
return false;
|
|
|
|
// Get the player's bomb place
|
|
|
|
if ( team->getName() == "Red" )
|
|
bombPlace = _redBombPlace._item;
|
|
else
|
|
bombPlace = _blueBombPlace._item;
|
|
|
|
if ( !bombPlace )
|
|
return false;
|
|
|
|
// See if the attacking or killed player is within the guarding distance of the bomb place
|
|
|
|
if ( withinGuardDistance( bombPlace->origin, attackingPlayer->origin ) ||
|
|
withinGuardDistance( bombPlace->origin, killedPlayer->origin ) )
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
bool ModifierDiffusion::playerGuardedBomb( Player *attackingPlayer, Player *killedPlayer )
|
|
{
|
|
DiffusionBombPlace *bombPlace;
|
|
Team *team;
|
|
|
|
team = multiplayerManager.getPlayersTeam( attackingPlayer );
|
|
|
|
if ( !team )
|
|
return false;
|
|
|
|
// Get the player's bomb place
|
|
|
|
if ( team->getName() == "Red" )
|
|
bombPlace = &_blueBombPlace;
|
|
else
|
|
bombPlace = &_redBombPlace;
|
|
|
|
if ( !bombPlace )
|
|
return false;
|
|
|
|
if ( !bombPlace->_armed )
|
|
return false;
|
|
|
|
// See if the attacking or killed player is within the guarding distance of the bomb
|
|
|
|
if ( withinGuardDistance( bombPlace->_item->origin, attackingPlayer->origin ) ||
|
|
withinGuardDistance( bombPlace->_item->origin, killedPlayer->origin ) )
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
bool ModifierDiffusion::withinGuardDistance( const Vector &origin1, const Vector &origin2 )
|
|
{
|
|
Vector diff;
|
|
float distance;
|
|
|
|
diff = origin1 - origin2;
|
|
distance = diff.length();
|
|
|
|
if ( distance < _maxGuardingDist )
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
|
|
void ModifierDiffusion::playerCommand( Player *player, const char *command, const char *parm )
|
|
{
|
|
if ( stricmp( command, "dropItem" ) == 0 )
|
|
{
|
|
if ( player == getBomber() )
|
|
{
|
|
dropBomb( player );
|
|
}
|
|
}
|
|
}
|
|
|
|
void ModifierDiffusion::makeBomber( Player *player )
|
|
{
|
|
_bomber = player->entnum;
|
|
_lastBomber = player->entnum;
|
|
|
|
multiplayerManager.playerSound( player->entnum, "localization/sound/dialog/dm/comp_bomber.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, 1.5f );
|
|
|
|
// Attach the bomb to the player
|
|
|
|
attachBomb( player );
|
|
}
|
|
|
|
void ModifierDiffusion::clearBomber( void )
|
|
{
|
|
if ( _bomber >= 0 )
|
|
{
|
|
Player *player;
|
|
|
|
player = multiplayerManager.getPlayer( _bomber );
|
|
|
|
if ( player )
|
|
{
|
|
player->removeAttachedModelByTargetname( "attachedDiffusionBomb" );
|
|
}
|
|
}
|
|
|
|
_bomber = -1;
|
|
}
|
|
|
|
void ModifierDiffusion::update( float frameTime )
|
|
{
|
|
float currentTime;
|
|
|
|
|
|
currentTime = multiplayerManager.getTime();
|
|
|
|
// Make sure the red bomb place has been armed recently enough
|
|
|
|
if ( _redBombPlace._lastArmingTime + _maxArmingPause < currentTime )
|
|
{
|
|
_redBombPlace._lastArmingTime = 0.0f;
|
|
_redBombPlace._totalArmingTime = 0.0f;
|
|
}
|
|
|
|
// Make sure the red bomb place has been diffused recently enough
|
|
|
|
if ( _redBombPlace._lastDisarmingTime + _maxDisarmingPause < currentTime )
|
|
{
|
|
_redBombPlace._lastDisarmingTime = 0.0f;
|
|
_redBombPlace._totalDisarmingTime = 0.0f;
|
|
}
|
|
|
|
// Make sure the blue bomb place has been armed recently enough
|
|
|
|
if ( _blueBombPlace._lastArmingTime + _maxArmingPause < currentTime )
|
|
{
|
|
_blueBombPlace._lastArmingTime = 0.0f;
|
|
_blueBombPlace._totalArmingTime = 0.0f;
|
|
}
|
|
|
|
// Make sure the blue bomb place has been diffused recently enough
|
|
|
|
if ( _blueBombPlace._lastDisarmingTime + _maxDisarmingPause < currentTime )
|
|
{
|
|
_blueBombPlace._lastDisarmingTime = 0.0f;
|
|
_blueBombPlace._totalDisarmingTime = 0.0f;
|
|
}
|
|
|
|
// Return the bomb back to the base if it has been sitting on the ground too long
|
|
|
|
if ( _tempBombItem && ( _tempBombItemTime + _maxBombOnGroundTime < multiplayerManager.getTime() ) )
|
|
{
|
|
respawnBomb();
|
|
}
|
|
|
|
// See if the bomb has exploded
|
|
|
|
if ( _redBombPlace._armed || _blueBombPlace._armed )
|
|
{
|
|
int lastTimeLeft;
|
|
int timeLeft;
|
|
DiffusionBombPlace *armedBombPlace;
|
|
|
|
if ( _redBombPlace._armed )
|
|
armedBombPlace = &_redBombPlace;
|
|
else
|
|
armedBombPlace = &_blueBombPlace;
|
|
|
|
lastTimeLeft = (int )( _timeNeededForBombToExplode - armedBombPlace->_totalArmedTime + 1 );
|
|
|
|
armedBombPlace->_totalArmedTime += frameTime;
|
|
|
|
timeLeft = (int)( _timeNeededForBombToExplode - armedBombPlace->_totalArmedTime + 1 );
|
|
|
|
// Play computer dialog for time left (if any)
|
|
|
|
if ( ( timeLeft <= 1 ) && ( lastTimeLeft > 1 ) && ( _timeNeededForBombToExplode > 1 ) )
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_1.mp3", CHAN_AUTO, DEFAULT_VOL,
|
|
DEFAULT_MIN_DIST, NULL, 0.5f );
|
|
else if ( ( timeLeft <= 2 ) && ( lastTimeLeft > 2 ) && ( _timeNeededForBombToExplode > 2 ) )
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_2.mp3", CHAN_AUTO, DEFAULT_VOL,
|
|
DEFAULT_MIN_DIST, NULL, 0.5f );
|
|
else if ( ( timeLeft <= 3 ) && ( lastTimeLeft > 3 ) && ( _timeNeededForBombToExplode > 3 ) )
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_3.mp3", CHAN_AUTO, DEFAULT_VOL,
|
|
DEFAULT_MIN_DIST, NULL, 0.5f );
|
|
else if ( ( timeLeft <= 4 ) && ( lastTimeLeft > 4 ) && ( _timeNeededForBombToExplode > 4 ) )
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_4.mp3", CHAN_AUTO, DEFAULT_VOL,
|
|
DEFAULT_MIN_DIST, NULL, 0.5f );
|
|
else if ( ( timeLeft <= 5 ) && ( lastTimeLeft > 5 ) && ( _timeNeededForBombToExplode > 5 ) )
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_5.mp3", CHAN_AUTO, DEFAULT_VOL,
|
|
DEFAULT_MIN_DIST, NULL, 0.5f );
|
|
else if ( ( timeLeft <= 7 ) && ( lastTimeLeft > 7 ) && ( _timeNeededForBombToExplode > 7 ) )
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_bombtime.mp3", CHAN_AUTO, DEFAULT_VOL,
|
|
DEFAULT_MIN_DIST, NULL, 0.5f );
|
|
else if ( ( timeLeft <= 15 ) && ( lastTimeLeft > 15 ) && ( _timeNeededForBombToExplode > 15 ) )
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_bombtime15.mp3" );
|
|
else if ( ( timeLeft <= 30 ) && ( lastTimeLeft > 30 ) && ( _timeNeededForBombToExplode > 30 ) )
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_bombtime30.mp3" );
|
|
|
|
if ( armedBombPlace->_totalArmedTime > _timeNeededForBombToExplode )
|
|
{
|
|
str printString;
|
|
|
|
// The bomb has exploded
|
|
|
|
armedBombPlace->_item->SpawnEffect( "models/fx/fx-explosion-bomb.tik", armedBombPlace->_item->origin, armedBombPlace->_item->angles, 1.0f );
|
|
|
|
if ( _bombArmedByPlayer >= 0 )
|
|
{
|
|
// Give points to the player that armed the bomb
|
|
|
|
multiplayerManager.addPoints( _bombArmedByPlayer, _pointsForExplodingBomb );
|
|
}
|
|
|
|
// Give the bombing team a lot of points and tell everyone what happened
|
|
|
|
if ( armedBombPlace == &_redBombPlace )
|
|
{
|
|
multiplayerManager.addTeamPoints( "Blue", _teamPointsForBombing );
|
|
|
|
multiplayerManager.centerPrintAllClients( "$$RedBaseDestroyed$$", CENTERPRINT_IMPORTANCE_NORMAL );
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_bombexplodered.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, NULL, 2.0f );
|
|
}
|
|
else
|
|
{
|
|
multiplayerManager.addTeamPoints( "Red", _teamPointsForBombing );
|
|
|
|
multiplayerManager.centerPrintAllClients( "$$BlueBaseDestroyed$$", CENTERPRINT_IMPORTANCE_NORMAL );
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_bombexplodeblue.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, NULL, 2.0f );
|
|
}
|
|
|
|
armedBombPlace->_armed = false;
|
|
|
|
respawnBomb( true );
|
|
|
|
armedBombPlace->_item->removeAttachedModelByTargetname( "attachedDiffusionBomb" );
|
|
_attachedBomb->PostEvent( EV_Remove, 0.0f );
|
|
_attachedBomb = NULL;
|
|
|
|
armedBombPlace->_totalArmedTime = 0.0f;
|
|
armedBombPlace->_lastArmingTime = 0.0f;
|
|
armedBombPlace->_lastDisarmingTime = 0.0f;
|
|
|
|
// Respawn all of the players in a few seconds
|
|
|
|
_respawnTime = multiplayerManager.getTime() + 3.0f;
|
|
}
|
|
}
|
|
|
|
// See if we should respawn everyone
|
|
|
|
if ( ( _respawnTime > 0.0f ) && ( _respawnTime < multiplayerManager.getTime() ) )
|
|
{
|
|
multiplayerManager.respawnAllPlayers();
|
|
_respawnTime = 0.0f;
|
|
}
|
|
}
|
|
|
|
int ModifierDiffusion::getIcon( Player *player, int statNum, int value )
|
|
{
|
|
if ( statNum == STAT_MP_MODE_ICON )
|
|
{
|
|
// Return the icon for the player's specialty
|
|
|
|
if ( player == getBomber() )
|
|
return _bomberIconIndex;
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
int ModifierDiffusion::getScoreIcon( Player *player, int index, int value )
|
|
{
|
|
if ( index == SCOREICON5 )
|
|
{
|
|
if ( player == getBomber() )
|
|
return _bomberIconIndex;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
void ModifierDiffusion::matchStarted( void )
|
|
{
|
|
if ( _bomb )
|
|
{
|
|
_bomb->showModel();
|
|
_bomb->setSolidType( SOLID_TRIGGER );
|
|
}
|
|
|
|
if ( _redBombPlace._item )
|
|
{
|
|
_redBombPlace._item->showModel();
|
|
_redBombPlace._item->setSolidType( SOLID_BBOX );
|
|
}
|
|
|
|
if ( _blueBombPlace._item )
|
|
{
|
|
_blueBombPlace._item->showModel();
|
|
_blueBombPlace._item->setSolidType( SOLID_BBOX );
|
|
}
|
|
}
|
|
|
|
// Setup constants
|
|
|
|
const float ModifierSpecialties::_infiltratorMinRespawnTime = 0.0f;
|
|
const float ModifierSpecialties::_medicMinRespawnTime = 30.0f;
|
|
const float ModifierSpecialties::_technicianMinRespawnTime = 30.0f;
|
|
const float ModifierSpecialties::_demolitionistMinRespawnTime = 15.0f;
|
|
const float ModifierSpecialties::_heavyweaponsMinRespawnTime = 0.0f;
|
|
const float ModifierSpecialties::_sniperMinRespawnTime = 0.0f;
|
|
|
|
const float ModifierSpecialties::_startingInfiltratorHealth = 100.0f;
|
|
const float ModifierSpecialties::_startingInfiltratorMassModifier = 0.5f;
|
|
const float ModifierSpecialties::_startingMedicArmor = 75.0f;
|
|
const float ModifierSpecialties::_startingTechnicianArmor = 50.0f;
|
|
const float ModifierSpecialties::_startingDemolitionistArmor = 50.0f;
|
|
const float ModifierSpecialties::_startingHeavyWeaponsHealth = 200.0f;
|
|
const float ModifierSpecialties::_startingHeavyWeaponsArmor = 100.0f;
|
|
const float ModifierSpecialties::_startingHeavyWeaponsMassModifier = 2.0f;
|
|
const float ModifierSpecialties::_startingSniperArmor = 25.0f;
|
|
const float ModifierSpecialties::_startingNormalHealth = 100.0f;
|
|
|
|
const float ModifierSpecialties::_medicHealOtherRate = 20.0f;
|
|
const float ModifierSpecialties::_medicHealSelfRate = 2.0f;
|
|
const float ModifierSpecialties::_infiltratorMoveSpeedModifier = 1.25f;
|
|
const float ModifierSpecialties::_heavyWeaponsMoveSpeedModifier = .75f;
|
|
const float ModifierSpecialties::_infiltratorJumpSpeedModifier = 1.1f;
|
|
const float ModifierSpecialties::_infiltratorAirAccelerationModifier = 1.5f;
|
|
|
|
const float ModifierSpecialties::_technicianHoldableItemRegenTime = 20.0f;
|
|
const float ModifierSpecialties::_demolitionistHoldableItemRegenTime = 20.0f;
|
|
|
|
const bool ModifierSpecialties::_medicCanSeeEnemyHealth = true;
|
|
|
|
const float ModifierSpecialties::_amountOfHealingForPoints = 10.0f;
|
|
const int ModifierSpecialties::_pointsForHealing = 1;
|
|
|
|
const bool ModifierSpecialties::_removeItems = false;
|
|
|
|
const SpecialtyType SpecialtyPlayerData::_defaultSpecialty = SPECIALTY_INFILTRATOR;
|
|
|
|
SpecialtyPlayerData::SpecialtyPlayerData()
|
|
{
|
|
_forced = false;
|
|
reset();
|
|
}
|
|
void SpecialtyPlayerData::reset( void )
|
|
{
|
|
if ( _forced )
|
|
return;
|
|
|
|
_specialty = _defaultSpecialty;
|
|
_item = NULL;
|
|
_lastUseTime = 0.0f;
|
|
_amountOfHealing = 0.0f;
|
|
_lastPlayer = -1;
|
|
}
|
|
|
|
ModifierSpecialties::ModifierSpecialties()
|
|
{
|
|
_playerSpecialtyData = NULL;
|
|
|
|
_infiltratorIconIndex = gi.imageindex( "sysimg/icons/mp/specialty_infiltrator" );
|
|
_medicIconIndex = gi.imageindex( "sysimg/icons/mp/specialty_medic" );
|
|
_technicianIconIndex = gi.imageindex( "sysimg/icons/mp/specialty_technician" );
|
|
_demolitionistIconIndex = gi.imageindex( "sysimg/icons/mp/specialty_demolitionist" );
|
|
_heavyweaponsIconIndex = gi.imageindex( "sysimg/icons/mp/specialty_heavyweapons" );
|
|
_sniperIconIndex = gi.imageindex( "sysimg/icons/mp/specialty_sniper" );
|
|
|
|
_specialtyItems.FreeObjectList();
|
|
}
|
|
|
|
ModifierSpecialties::~ModifierSpecialties()
|
|
{
|
|
delete [] _playerSpecialtyData;
|
|
_playerSpecialtyData = NULL;
|
|
|
|
_specialtyItems.FreeObjectList();
|
|
}
|
|
|
|
void ModifierSpecialties::init( int maxPlayers )
|
|
{
|
|
_maxPlayers = maxPlayers;
|
|
_playerSpecialtyData = new SpecialtyPlayerData[ maxPlayers ];
|
|
|
|
multiplayerManager.cacheMultiplayerFiles( "mp_specialties" );
|
|
}
|
|
|
|
bool ModifierSpecialties::checkRule( const char *rule, bool defaultValue, Player *player )
|
|
{
|
|
// We want team spawn points
|
|
|
|
if ( stricmp( rule, "spawnpoints-team" ) == 0 )
|
|
return true;
|
|
else if ( stricmp( rule, "dropWeapons" ) == 0 )
|
|
return false;
|
|
else if ( stricmp( rule, "spawnpoints-special" ) == 0 )
|
|
{
|
|
// We want special spawnpoints in this mode but not for bots
|
|
|
|
if ( player->edict->svflags & SVF_BOT )
|
|
return defaultValue;
|
|
else
|
|
return true;
|
|
}
|
|
else
|
|
return defaultValue;
|
|
}
|
|
|
|
str ModifierSpecialties::getSpawnPointType( Player *player )
|
|
{
|
|
Team *team;
|
|
|
|
team = multiplayerManager.getPlayersTeam( player );
|
|
|
|
if ( team && team->getName() == "Red" )
|
|
return "specialty-red";
|
|
else if ( team && team->getName() == "Blue" )
|
|
return "specialty-blue";
|
|
else
|
|
return "specialty";
|
|
}
|
|
|
|
void ModifierSpecialties::playerCommand( Player *player, const char *command, const char *parm )
|
|
{
|
|
if ( stricmp( command, "setSpecialty" ) == 0 )
|
|
{
|
|
SpecialtyType specialty;
|
|
|
|
// Figure out which specialty we want to set
|
|
|
|
if ( stricmp( parm, "infiltrator" ) == 0 )
|
|
specialty = SPECIALTY_INFILTRATOR;
|
|
else if ( stricmp( parm, "medic" ) == 0 )
|
|
specialty = SPECIALTY_MEDIC;
|
|
else if ( stricmp( parm, "technician" ) == 0 )
|
|
specialty = SPECIALTY_TECHNICIAN;
|
|
else if ( stricmp( parm, "demolitionist" ) == 0 )
|
|
specialty = SPECIALTY_DEMOLITIONIST;
|
|
else if ( ( stricmp( parm, "heavyweapons" ) == 0 ) || ( stricmp( parm, "heavy" ) == 0 ) )
|
|
specialty = SPECIALTY_HEAVY_WEAPONS;
|
|
else if ( stricmp( parm, "sniper" ) == 0 )
|
|
specialty = SPECIALTY_SNIPER;
|
|
else
|
|
specialty = SPECIALTY_NONE;
|
|
|
|
// Setup the specialty
|
|
|
|
if ( ( specialty == SPECIALTY_NONE ) || ( player->edict->svflags & SVF_BOT ) )
|
|
{
|
|
setupSpecialty( player, specialty, true );
|
|
|
|
_playerSpecialtyData[ player->entnum ]._specialty = specialty;
|
|
|
|
if ( specialty == SPECIALTY_NONE )
|
|
_playerSpecialtyData[ player->entnum ]._forced = false;
|
|
else
|
|
_playerSpecialtyData[ player->entnum ]._forced = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool ModifierSpecialties::shouldKeepItem( MultiplayerItem *item )
|
|
{
|
|
str itemName;
|
|
const char *dash1;
|
|
const char *dash2;
|
|
|
|
itemName = item->getName();
|
|
|
|
if ( strnicmp( itemName.c_str(), "specialty-", strlen( "specialty-" ) ) == 0 )
|
|
{
|
|
SpecialtyItem specialtyItem;
|
|
|
|
// This is a specialty item so keep track of it
|
|
|
|
specialtyItem._item = item;
|
|
specialtyItem._needToRespawn = false;
|
|
specialtyItem._respawnTime = 0.0f;
|
|
specialtyItem._pickedupTime = 0.0f;
|
|
|
|
if ( strnicmp( itemName.c_str(), "specialty-infiltrator-", strlen( "specialty-infiltrator-" ) ) == 0 )
|
|
{
|
|
specialtyItem._type = SPECIALTY_INFILTRATOR;
|
|
specialtyItem._minimumRespawnTime = _infiltratorMinRespawnTime;
|
|
}
|
|
else if ( strnicmp( itemName.c_str(), "specialty-medic-", strlen( "specialty-medic-" ) ) == 0 )
|
|
{
|
|
specialtyItem._type = SPECIALTY_MEDIC;
|
|
specialtyItem._minimumRespawnTime = _medicMinRespawnTime;
|
|
}
|
|
else if ( strnicmp( itemName.c_str(), "specialty-technician-", strlen( "specialty-technician-" ) ) == 0 )
|
|
{
|
|
specialtyItem._type = SPECIALTY_TECHNICIAN;
|
|
specialtyItem._minimumRespawnTime = _technicianMinRespawnTime;
|
|
}
|
|
else if ( strnicmp( itemName.c_str(), "specialty-demolitionist-", strlen( "specialty-demolitionist-" ) ) == 0 )
|
|
{
|
|
specialtyItem._type = SPECIALTY_DEMOLITIONIST;
|
|
specialtyItem._minimumRespawnTime = _demolitionistMinRespawnTime;
|
|
}
|
|
else if ( strnicmp( itemName.c_str(), "specialty-heavyweapons-", strlen( "specialty-heavyweapons-" ) ) == 0 )
|
|
{
|
|
specialtyItem._type = SPECIALTY_HEAVY_WEAPONS;
|
|
specialtyItem._minimumRespawnTime = _heavyweaponsMinRespawnTime;
|
|
}
|
|
else if ( strnicmp( itemName.c_str(), "specialty-sniper-", strlen( "specialty-sniper-" ) ) == 0 )
|
|
{
|
|
specialtyItem._type = SPECIALTY_SNIPER;
|
|
specialtyItem._minimumRespawnTime = _sniperMinRespawnTime;
|
|
}
|
|
else
|
|
{
|
|
specialtyItem._type = SPECIALTY_NONE;
|
|
}
|
|
|
|
// Get the team name
|
|
|
|
dash1 = strstr( itemName.c_str(), "-" );
|
|
|
|
if ( dash1 )
|
|
{
|
|
dash2 = strstr( dash1 + 1, "-" );
|
|
|
|
if ( dash2 )
|
|
{
|
|
specialtyItem._teamName = dash2 + 1;
|
|
}
|
|
}
|
|
|
|
// Add the item to the list
|
|
|
|
_specialtyItems.AddObject( specialtyItem );
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ModifierSpecialties::shouldKeepNormalItem( Item *item )
|
|
{
|
|
if ( item->isSubclassOf( Weapon ) )
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
|
|
SpecialtyItem *ModifierSpecialties::findSpecialtyItem( MultiplayerItem *item )
|
|
{
|
|
int i;
|
|
SpecialtyItem *specialtyItem;
|
|
|
|
// Go through the list and find the item
|
|
|
|
for ( i = 1 ; i <= _specialtyItems.NumObjects() ; i++ )
|
|
{
|
|
specialtyItem = &_specialtyItems.ObjectAt( i );
|
|
|
|
if ( specialtyItem->_item == item )
|
|
{
|
|
return specialtyItem;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void ModifierSpecialties::addPlayer( Player *player )
|
|
{
|
|
putItemBack( player );
|
|
|
|
_playerSpecialtyData[ player->entnum ].reset();
|
|
|
|
if ( _playerSpecialtyData[ player->entnum ]._forced )
|
|
{
|
|
setupSpecialty( player, _playerSpecialtyData[ player->entnum ]._specialty, false );
|
|
}
|
|
|
|
gi.SendServerCommand( player->entnum, "stufftext \"ui_addhud mp_specialties\"\n" );
|
|
}
|
|
|
|
void ModifierSpecialties::itemTouched( Player *player, MultiplayerItem *item )
|
|
{
|
|
SpecialtyType specialty;
|
|
bool sameTeam = false;
|
|
Team *team;
|
|
const char *teamName;
|
|
SpecialtyItem *specialtyItem;
|
|
|
|
// Make sure player doesn't already have a class
|
|
|
|
//if ( _playerSpecialtyData[ player->entnum ]._specialty != SPECIALTY_NONE )
|
|
// return;
|
|
|
|
// Make sure this isn't a bot
|
|
|
|
if ( player->edict->svflags & SVF_BOT )
|
|
return;
|
|
|
|
// Make sure this is a specialty item
|
|
|
|
specialtyItem = findSpecialtyItem( item );
|
|
|
|
if ( !specialtyItem )
|
|
return;
|
|
|
|
specialty = specialtyItem->_type;
|
|
|
|
// Only bother if the player isn't already the new specialty
|
|
|
|
if ( _playerSpecialtyData[ player->entnum ]._specialty == specialty )
|
|
return;
|
|
|
|
// Make sure the item and the player are on the same team
|
|
|
|
team = multiplayerManager.getPlayersTeam( player );
|
|
|
|
if ( !team )
|
|
return;
|
|
|
|
teamName = team->getName().c_str();
|
|
|
|
if ( stricmp( teamName, specialtyItem->_teamName ) == 0 )
|
|
sameTeam = true;
|
|
|
|
if ( !sameTeam )
|
|
return;
|
|
|
|
if ( !multiplayerManager.checkRule ( "specialty-pickup", true, player ) )
|
|
return;
|
|
|
|
if ( _playerSpecialtyData[ player->entnum ]._specialty != SPECIALTY_NONE )
|
|
{
|
|
putItemBack( player );
|
|
}
|
|
|
|
// Pickup the item and change the player's specialty
|
|
|
|
_playerSpecialtyData[ player->entnum ]._specialty = specialty;
|
|
_playerSpecialtyData[ player->entnum ]._item = item;
|
|
|
|
specialtyItem->_pickedupTime = multiplayerManager.getTime();
|
|
|
|
setupSpecialty( player, specialty, true );
|
|
|
|
removeItem( item );
|
|
}
|
|
|
|
void ModifierSpecialties::setupSpecialty( Player *player, SpecialtyType specialty, bool chosen )
|
|
{
|
|
float armorToGive;
|
|
Event *event;
|
|
bool hadTricorder;
|
|
str specialtyName;
|
|
str specialtySoundName;
|
|
|
|
armorToGive = 0.0f;
|
|
|
|
// Change the player based on the specialty
|
|
|
|
|
|
// Take away holdable item
|
|
|
|
player->removeHoldableItem();
|
|
|
|
// Take away all of the weapons except the tricorder
|
|
|
|
if ( player->FindItemByModelname( "models/weapons/worldmodel-tricorder.tik" ) )
|
|
hadTricorder = true;
|
|
else
|
|
hadTricorder = false;
|
|
|
|
if ( !( player->edict->svflags & SVF_BOT ) )
|
|
{
|
|
player->FreeInventory();
|
|
}
|
|
|
|
multiplayerManager.resetPlayerStateMachine( player );
|
|
|
|
if ( hadTricorder )
|
|
{
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-tricorder.tik" );
|
|
}
|
|
|
|
// Take away any armor
|
|
|
|
Event *armorEvent = new Event( EV_Sentient_SetMyArmorAmount );
|
|
armorEvent->AddFloat( 0.0f );
|
|
player->ProcessEvent( armorEvent );
|
|
|
|
_playerSpecialtyData[ player->entnum ]._regenHoldableItemTime = 0.0f;
|
|
|
|
switch( specialty )
|
|
{
|
|
case SPECIALTY_NONE :
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-phaser.tik" );
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-batleth.tik" );
|
|
multiplayerManager.usePlayerItem( player->entnum, "Phaser" );
|
|
|
|
player->setMaxHealth( _startingNormalHealth );
|
|
|
|
if ( player->getHealth() > _startingNormalHealth )
|
|
player->setHealth( _startingNormalHealth );
|
|
|
|
break;
|
|
case SPECIALTY_INFILTRATOR :
|
|
|
|
specialtyName = "$$Infiltrator$$\n";
|
|
specialtySoundName = "localization/sound/dialog/dm/comp_infil.mp3";
|
|
|
|
player->setMaxHealth( _startingInfiltratorHealth );
|
|
|
|
if ( player->getHealth() > _startingInfiltratorHealth )
|
|
player->setHealth( (int)_startingInfiltratorHealth );
|
|
|
|
player->mass *= (int)_startingInfiltratorMassModifier;
|
|
|
|
event = new Event( EV_Sentient_AddResistance );
|
|
event->AddString( "falling" );
|
|
event->AddInteger( 100 );
|
|
player->ProcessEvent( event );
|
|
|
|
player->setHoldableItem( HoldableItem::createHoldableItem( "Transporter", "models/item/holdable_transporter.tik", player ) );
|
|
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-phaser.tik" );
|
|
//multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-batleth.tik" );
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-compressionrifle.tik" );
|
|
multiplayerManager.givePlayerItem( player->entnum, "weapons/worldmodel-imod.tik" );
|
|
multiplayerManager.usePlayerItem( player->entnum, "CompressionRifle" );
|
|
|
|
player->GiveAmmo( "Plasma", 400, false, 400 );
|
|
|
|
break;
|
|
case SPECIALTY_MEDIC :
|
|
|
|
specialtyName = "$$Medic$$\n";
|
|
specialtySoundName = "localization/sound/dialog/dm/comp_medic.mp3";
|
|
|
|
player->setMaxHealth( _startingNormalHealth );
|
|
|
|
if ( player->getHealth() > _startingNormalHealth )
|
|
player->setHealth( _startingNormalHealth );
|
|
|
|
armorToGive = _startingMedicArmor;
|
|
|
|
//player->setHoldableItem( HoldableItem::createHoldableItem( "Health", "models/item/holdable_medkit.tik", player ) );
|
|
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-phaser.tik" );
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-tricorder.tik" );
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-batleth.tik" );
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-burstrifle.tik" );
|
|
multiplayerManager.usePlayerItem( player->entnum, "BurstRifle" );
|
|
|
|
player->GiveAmmo( "Plasma", 400, false, 400 );
|
|
|
|
break;
|
|
case SPECIALTY_TECHNICIAN :
|
|
|
|
specialtyName = "$$Technician$$\n";
|
|
specialtySoundName = "localization/sound/dialog/dm/comp_tech.mp3";
|
|
|
|
player->setMaxHealth( _startingNormalHealth );
|
|
|
|
if ( player->getHealth() > _startingNormalHealth )
|
|
player->setHealth( _startingNormalHealth );
|
|
|
|
armorToGive = _startingTechnicianArmor;
|
|
|
|
//event = new Event( EV_Sentient_AddResistance );
|
|
//event->AddString( "drown" );
|
|
//event->AddInteger( 100 );
|
|
//player->ProcessEvent( event );
|
|
|
|
//player->setHoldableItem( HoldableItem::createHoldableItem( "Protection", "models/item/holdable_forcefield.tik", player ) );
|
|
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-phaser.tik" );
|
|
//multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-batleth.tik" );
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-attrex-rifle.tik" );
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-rom-disruptor.tik" );
|
|
multiplayerManager.usePlayerItem( player->entnum, "AttrexianRifle" );
|
|
|
|
_playerSpecialtyData[ player->entnum ]._regenHoldableItemTime = multiplayerManager.getTime() + _technicianHoldableItemRegenTime;
|
|
|
|
player->GiveAmmo( "Idryll", 400, false, 400 );
|
|
|
|
break;
|
|
case SPECIALTY_DEMOLITIONIST :
|
|
|
|
specialtyName = "$$Demolitionist$$\n";
|
|
specialtySoundName = "localization/sound/dialog/dm/comp_demoli.mp3";
|
|
|
|
player->setMaxHealth( _startingNormalHealth );
|
|
|
|
if ( player->getHealth() > _startingNormalHealth )
|
|
player->setHealth( _startingNormalHealth );
|
|
|
|
armorToGive = _startingDemolitionistArmor;
|
|
|
|
player->setHoldableItem( HoldableItem::createHoldableItem( "Explosive", "models/item/holdable_explosive.tik", player ) );
|
|
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-phaser.tik" );
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-batleth.tik" );
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-fieldassaultrifle.tik" );
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-grenadelauncher.tik" );
|
|
multiplayerManager.usePlayerItem( player->entnum, "GrenadeLauncher" );
|
|
|
|
player->GiveAmmo( "Fed", 400, false, 400 );
|
|
|
|
break;
|
|
case SPECIALTY_HEAVY_WEAPONS :
|
|
|
|
specialtyName = "$$HeavyWeapons$$\n";
|
|
specialtySoundName = "localization/sound/dialog/dm/comp_hw.mp3";
|
|
|
|
player->setMaxHealth( _startingHeavyWeaponsHealth );
|
|
|
|
if ( player->getHealth() > _startingHeavyWeaponsHealth )
|
|
player->setHealth( _startingHeavyWeaponsHealth );
|
|
|
|
armorToGive = (int) _startingHeavyWeaponsArmor;
|
|
player->mass *= (int)_startingHeavyWeaponsMassModifier;
|
|
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-phaser.tik" );
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-batleth.tik" );
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-tetryon.tik" );
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-photon.tik" );
|
|
multiplayerManager.usePlayerItem( player->entnum, "PhotonBurst" );
|
|
|
|
player->GiveAmmo( "Fed", 400, false, 400 );
|
|
player->GiveAmmo( "Plasma", 100, false, 400 );
|
|
|
|
break;
|
|
case SPECIALTY_SNIPER :
|
|
|
|
specialtyName = "$$Sniper$$\n";
|
|
specialtySoundName = "localization/sound/dialog/dm/comp_sniper.mp3";
|
|
|
|
player->setMaxHealth( _startingNormalHealth );
|
|
|
|
if ( player->getHealth() > _startingNormalHealth )
|
|
player->setHealth( _startingNormalHealth );
|
|
|
|
armorToGive = _startingSniperArmor;
|
|
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-phaser.tik" );
|
|
//multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-batleth.tik" );
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-sniperrifle.tik" );
|
|
multiplayerManager.givePlayerItem( player->entnum, "models/weapons/worldmodel-compressionrifle.tik" );
|
|
multiplayerManager.usePlayerItem( player->entnum, "FederationSniperRifle" );
|
|
|
|
player->GiveAmmo( "Fed", 400, false, 400 );
|
|
|
|
// TODO decoy ?
|
|
//player->giveItem( "models/item/decoy.tik", 1, false );
|
|
break;
|
|
}
|
|
|
|
// Give the player some armor
|
|
|
|
if ( armorToGive > 0.0f )
|
|
{
|
|
Event *armorEvent;
|
|
|
|
armorEvent = new Event( EV_Sentient_GiveArmor );
|
|
armorEvent->AddString( "BasicArmor" );
|
|
armorEvent->AddFloat( armorToGive );
|
|
armorEvent->AddInteger( false );
|
|
|
|
player->ProcessEvent( armorEvent );
|
|
}
|
|
|
|
// Tell the player his specialty
|
|
|
|
if ( !multiplayerManager.isPlayerSpectator( player ) )
|
|
{
|
|
if ( specialtyName.length() > 0 )
|
|
{
|
|
// Tell player his new specialty
|
|
|
|
multiplayerManager.centerPrint( player->entnum, specialtyName.c_str(), CENTERPRINT_IMPORTANCE_HIGH );
|
|
|
|
// Tell teammates his new specialty
|
|
|
|
if ( chosen )
|
|
{
|
|
str stringToPrint;
|
|
|
|
stringToPrint = player->client->pers.netname;
|
|
stringToPrint += " $$BecomesA$$ ";
|
|
stringToPrint += specialtyName;
|
|
|
|
multiplayerManager.HUDPrintTeamClients( player, stringToPrint.c_str() );
|
|
}
|
|
}
|
|
|
|
if ( ( specialtySoundName.length() > 0 ) && ( chosen ) )
|
|
{
|
|
multiplayerManager.playerSound( player->entnum, specialtySoundName, CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, 1.0f );
|
|
}
|
|
}
|
|
|
|
attachBackpack( player );
|
|
}
|
|
|
|
void ModifierSpecialties::playerChangedModel( Player *player )
|
|
{
|
|
attachBackpack( player );
|
|
}
|
|
|
|
void ModifierSpecialties::attachBackpack( Player *player )
|
|
{
|
|
str attachModelName;
|
|
str tagName;
|
|
|
|
player->removeAttachedModelByTargetname( "attachedSpecialityBackpack" );
|
|
|
|
switch( _playerSpecialtyData[ player->entnum ]._specialty )
|
|
{
|
|
case SPECIALTY_INFILTRATOR :
|
|
attachModelName = "models/item/mp_specialty_infiltrator.tik";
|
|
break;
|
|
case SPECIALTY_MEDIC :
|
|
attachModelName = "models/item/mp_specialty_medic.tik";
|
|
break;
|
|
case SPECIALTY_TECHNICIAN :
|
|
attachModelName = "models/item/mp_specialty_technician.tik";
|
|
break;
|
|
case SPECIALTY_DEMOLITIONIST :
|
|
attachModelName = "models/item/mp_specialty_demolitionist.tik";
|
|
break;
|
|
case SPECIALTY_HEAVY_WEAPONS :
|
|
attachModelName = "models/item/mp_specialty_heavyweapons.tik";
|
|
break;
|
|
case SPECIALTY_SNIPER :
|
|
attachModelName = "models/item/mp_specialty_sniper.tik";
|
|
break;
|
|
}
|
|
|
|
if ( gi.Tag_NumForName( player->edict->s.modelindex, "Bip01 spine2" ) >= 0 )
|
|
tagName = "Bip01 spine2";
|
|
else if ( gi.Tag_NumForName( player->edict->s.modelindex, "Bip01 spine1" ) >= 0 )
|
|
tagName = "Bip01 spine1";
|
|
else if ( gi.Tag_NumForName( player->edict->s.modelindex, "Bip01 Head" ) >= 0 )
|
|
tagName = "Bip01 Head";
|
|
|
|
if ( attachModelName.length() )
|
|
{
|
|
Event *attachEvent;
|
|
|
|
attachEvent = new Event( EV_AttachModel );
|
|
attachEvent->AddString( attachModelName.c_str() );
|
|
attachEvent->AddString( tagName );
|
|
attachEvent->AddFloat( 1.0f );
|
|
attachEvent->AddString( "attachedSpecialityBackpack" );
|
|
attachEvent->AddInteger( 0 );
|
|
attachEvent->AddFloat( -1.0f );
|
|
attachEvent->AddFloat( 0.0f );
|
|
attachEvent->AddFloat( -1.0f );
|
|
attachEvent->AddFloat( -1.0f );
|
|
attachEvent->AddVector( player->getBackpackAttachOffset() );
|
|
attachEvent->AddVector( player->getBackpackAttachAngles() );
|
|
|
|
player->ProcessEvent( attachEvent );
|
|
}
|
|
}
|
|
|
|
void ModifierSpecialties::playerUsed( Player *usedPlayer, Player *usingPlayer, Equipment *equipment )
|
|
{
|
|
// Make sure everything is ok
|
|
|
|
if ( !usedPlayer || !usingPlayer || !equipment )
|
|
return;
|
|
|
|
// Give health to the player if everything is ok and this is a medic
|
|
|
|
if ( ( _playerSpecialtyData[ usingPlayer->entnum ]._specialty == SPECIALTY_MEDIC ) &&
|
|
( _playerSpecialtyData[ usingPlayer->entnum ]._lastUseTime < multiplayerManager.getTime() ) &&
|
|
( multiplayerManager.getPlayersTeam( usedPlayer ) == multiplayerManager.getPlayersTeam( usingPlayer ) ) &&
|
|
( stricmp( equipment->getTypeName().c_str(), "tricorder" ) == 0 ) &&
|
|
( usedPlayer != usingPlayer ) )
|
|
{
|
|
float healthToAdd;
|
|
float originalHealth;
|
|
float healthAdded;
|
|
|
|
|
|
_playerSpecialtyData[ usingPlayer->entnum ]._lastUseTime = multiplayerManager.getTime();
|
|
|
|
healthToAdd = _medicHealOtherRate * level.frametime;
|
|
|
|
originalHealth = usedPlayer->getHealth();
|
|
|
|
usedPlayer->addHealth( healthToAdd, 100.0f );
|
|
|
|
healthAdded = usedPlayer->getHealth() - originalHealth;
|
|
|
|
// Give the healing player some points if necessary
|
|
|
|
_playerSpecialtyData[ usingPlayer->entnum ]._amountOfHealing += healthAdded;
|
|
|
|
while ( _playerSpecialtyData[ usingPlayer->entnum ]._amountOfHealing >= _amountOfHealingForPoints )
|
|
{
|
|
_playerSpecialtyData[ usingPlayer->entnum ]._amountOfHealing -= _amountOfHealingForPoints;
|
|
multiplayerManager.addPoints( usingPlayer->entnum, _pointsForHealing );
|
|
}
|
|
}
|
|
/* else if ( ( _playerSpecialtyData[ usingPlayer->entnum ]._specialty == SPECIALTY_TECHNICIAN ) &&
|
|
( multiplayerManager.getPlayersTeam( usedPlayer ) == multiplayerManager.getPlayersTeam( usingPlayer ) ) )
|
|
{
|
|
if ( _playerSpecialtyData[ usingPlayer->entnum ]._lastUseTime == 0.0f )
|
|
{
|
|
Powerup *powerup;
|
|
|
|
_playerSpecialtyData[ usingPlayer->entnum ]._lastUseTime = multiplayerManager.getTime();
|
|
|
|
powerup = Powerup::CreatePowerup( "Invisibility", "models/item/powerup_invisibility.tik", usedPlayer );
|
|
|
|
if ( powerup )
|
|
{
|
|
powerup->CancelEventsOfType( EV_ProcessInitCommands );
|
|
powerup->ProcessInitCommands( powerup->edict->s.modelindex );
|
|
|
|
usedPlayer->setPowerup( powerup );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
usingPlayer->Sound( "snd_noammo" );
|
|
}
|
|
} */
|
|
}
|
|
|
|
void ModifierSpecialties::update( float frameTime )
|
|
{
|
|
Player *player;
|
|
Entity *entity;
|
|
gentity_t *edict;
|
|
int i;
|
|
SpecialtyItem *specialtyItem;
|
|
HoldableItem *holdableItem;
|
|
|
|
// Update all of the players based on their specialty
|
|
|
|
for( i = 0 ; i < game.maxclients ; i++ )
|
|
{
|
|
edict = &g_entities[ i ];
|
|
|
|
if ( !edict->inuse || !edict->entity )
|
|
continue;
|
|
|
|
entity = edict->entity;
|
|
|
|
if ( !entity->isSubclassOf( Player ) )
|
|
continue;
|
|
|
|
player = ( Player * )entity;
|
|
|
|
if ( _playerSpecialtyData[ player->entnum ]._specialty == SPECIALTY_MEDIC )
|
|
{
|
|
player->addHealth( _medicHealSelfRate * frameTime );
|
|
}
|
|
else if ( _playerSpecialtyData[ player->entnum ]._specialty == SPECIALTY_TECHNICIAN )
|
|
{
|
|
Event *newEvent = new Event( EV_Sentient_SetViewMode );
|
|
newEvent->AddString( "forcevisible" );
|
|
newEvent->AddInteger( 0 );
|
|
player->ProcessEvent( newEvent );
|
|
}
|
|
|
|
// Respawn holdable items
|
|
|
|
holdableItem = player->getHoldableItem();
|
|
|
|
if ( !holdableItem )
|
|
{
|
|
if ( _playerSpecialtyData[ player->entnum ]._regenHoldableItemTime > 0.0f )
|
|
{
|
|
if ( _playerSpecialtyData[ player->entnum ]._regenHoldableItemTime < multiplayerManager.getTime() )
|
|
{
|
|
// Respawn holdable items
|
|
|
|
if ( _playerSpecialtyData[ player->entnum ]._specialty == SPECIALTY_DEMOLITIONIST )
|
|
{
|
|
player->setHoldableItem( HoldableItem::createHoldableItem( "Explosive", "models/item/holdable_explosive.tik", player ) );
|
|
}
|
|
else if ( _playerSpecialtyData[ player->entnum ]._specialty == SPECIALTY_TECHNICIAN )
|
|
{
|
|
float randomNum;
|
|
|
|
randomNum = G_Random( 1 );
|
|
|
|
if ( randomNum < 0.25f )
|
|
player->setHoldableItem( HoldableItem::createHoldableItem( "SpawnPowerup", "models/item/holdable_spawnInvis.tik", player ) );
|
|
else if ( randomNum < 0.50f )
|
|
player->setHoldableItem( HoldableItem::createHoldableItem( "SpawnPowerup", "models/item/holdable_spawnRegen.tik", player ) );
|
|
else if ( randomNum < 0.75f )
|
|
player->setHoldableItem( HoldableItem::createHoldableItem( "SpawnPowerup", "models/item/holdable_spawnSpeed.tik", player ) );
|
|
else
|
|
player->setHoldableItem( HoldableItem::createHoldableItem( "SpawnPowerup", "models/item/holdable_spawnStrength.tik", player ) );
|
|
}
|
|
|
|
_playerSpecialtyData[ player->entnum ]._regenHoldableItemTime = 0.0f;
|
|
|
|
player->Sound( "snd_holdableRespawn" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// The player has no holdable item and no timer is setup
|
|
|
|
if ( _playerSpecialtyData[ player->entnum ]._specialty == SPECIALTY_DEMOLITIONIST )
|
|
{
|
|
_playerSpecialtyData[ player->entnum ]._regenHoldableItemTime = multiplayerManager.getTime() +
|
|
_demolitionistHoldableItemRegenTime;
|
|
}
|
|
else if ( _playerSpecialtyData[ player->entnum ]._specialty == SPECIALTY_TECHNICIAN )
|
|
{
|
|
_playerSpecialtyData[ player->entnum ]._regenHoldableItemTime = multiplayerManager.getTime() +
|
|
_technicianHoldableItemRegenTime;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Respawn any specialty items that need to be
|
|
|
|
for ( i = 1 ; i <= _specialtyItems.NumObjects() ; i++ )
|
|
{
|
|
specialtyItem = &_specialtyItems.ObjectAt( i );
|
|
|
|
if ( specialtyItem->_needToRespawn && ( specialtyItem->_respawnTime < multiplayerManager.getTime() ) )
|
|
{
|
|
specialtyItem->_needToRespawn = false;
|
|
specialtyItem->_item->showModel();
|
|
specialtyItem->_item->setSolidType( SOLID_TRIGGER );
|
|
}
|
|
}
|
|
}
|
|
|
|
void ModifierSpecialties::removePlayer( Player *player )
|
|
{
|
|
int i;
|
|
|
|
putItemBack( player );
|
|
|
|
// Wipe out any saved data for the player
|
|
|
|
for ( i = 0 ; i < _maxPlayers ; i++ )
|
|
{
|
|
_playerSpecialtyData[ player->entnum ]._lastPlayer = -1;
|
|
}
|
|
}
|
|
|
|
void ModifierSpecialties::playerKilled( Player *killedPlayer, Player *attackingPlayer, Entity *inflictor, int meansOfDeath )
|
|
{
|
|
putItemBack( killedPlayer );
|
|
}
|
|
|
|
void ModifierSpecialties::playerSpawned( Player *player )
|
|
{
|
|
if ( _playerSpecialtyData[ player->entnum ]._forced )
|
|
{
|
|
setupSpecialty( player, _playerSpecialtyData[ player->entnum ]._specialty, false );
|
|
}
|
|
else
|
|
{
|
|
putItemBack( player );
|
|
|
|
_playerSpecialtyData[ player->entnum ].reset();
|
|
|
|
setupSpecialty( player, _playerSpecialtyData[ player->entnum ]._specialty, false );
|
|
}
|
|
}
|
|
|
|
void ModifierSpecialties::applySpeedModifiers( Player *player, int *moveSpeed )
|
|
{
|
|
if ( _playerSpecialtyData[ player->entnum ]._specialty == SPECIALTY_INFILTRATOR )
|
|
*moveSpeed *= (int) (_infiltratorMoveSpeedModifier);
|
|
else if ( _playerSpecialtyData[ player->entnum ]._specialty == SPECIALTY_HEAVY_WEAPONS )
|
|
*moveSpeed = (int)( *moveSpeed * _heavyWeaponsMoveSpeedModifier );
|
|
}
|
|
|
|
void ModifierSpecialties::applyJumpModifiers( Player *player, int *jumpSpeed )
|
|
{
|
|
if ( _playerSpecialtyData[ player->entnum ]._specialty == SPECIALTY_INFILTRATOR )
|
|
*jumpSpeed = (int)( *jumpSpeed * _infiltratorJumpSpeedModifier );
|
|
}
|
|
|
|
void ModifierSpecialties::applyAirAccelerationModifiers( Player *player, int *airAcceleration )
|
|
{
|
|
if ( _playerSpecialtyData[ player->entnum ]._specialty == SPECIALTY_INFILTRATOR )
|
|
*airAcceleration = (int)( *airAcceleration * _infiltratorAirAccelerationModifier );
|
|
}
|
|
|
|
bool ModifierSpecialties::canPickup( Player *player, MultiplayerItemType itemType, const char *item_name )
|
|
{
|
|
// The infiltrator can't pickup the speed powerup
|
|
|
|
if ( itemType == MP_ITEM_TYPE_ARMOR )
|
|
{
|
|
if ( _playerSpecialtyData[ player->entnum ]._specialty == SPECIALTY_INFILTRATOR )
|
|
{
|
|
// Infiltrator can't pick up armor
|
|
|
|
return false;
|
|
}
|
|
}
|
|
else if ( itemType == MP_ITEM_TYPE_POWERUP )
|
|
{
|
|
/* if ( _playerSpecialtyData[ player->entnum ]._specialty == SPECIALTY_INFILTRATOR )
|
|
{
|
|
if ( stricmp( item_name, "Speed" ) == 0 )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// No one can pickup the strength powerup except the heavy weapons class
|
|
|
|
if ( stricmp( item_name, "Strength" ) == 0 )
|
|
{
|
|
if ( _playerSpecialtyData[ player->entnum ]._specialty != SPECIALTY_HEAVY_WEAPONS )
|
|
{
|
|
return false;
|
|
}
|
|
} */
|
|
}
|
|
else if ( itemType == MP_ITEM_TYPE_WEAPON )
|
|
{
|
|
// Specialities can't pickup any weapons (they have already been given the weapons their allowed to have)
|
|
|
|
if ( _playerSpecialtyData[ player->entnum ]._specialty != SPECIALTY_NONE )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void ModifierSpecialties::removeItem( MultiplayerItem *item )
|
|
{
|
|
if ( !_removeItems )
|
|
return;
|
|
|
|
if ( item )
|
|
{
|
|
item->setSolidType( SOLID_NOT );
|
|
item->hideModel();
|
|
}
|
|
}
|
|
|
|
void ModifierSpecialties::putItemBack( Player *player )
|
|
{
|
|
MultiplayerItem *item;
|
|
SpecialtyItem *specialtyItem;
|
|
|
|
if ( _playerSpecialtyData[ player->entnum ]._forced )
|
|
return;
|
|
|
|
if ( _removeItems )
|
|
{
|
|
// Find the item in question
|
|
|
|
item = _playerSpecialtyData[ player->entnum ]._item;
|
|
|
|
specialtyItem = findSpecialtyItem( item );
|
|
|
|
// Put the item back
|
|
|
|
if ( specialtyItem )
|
|
{
|
|
HoldableItem* holdableItem;
|
|
bool respawnNow = false;
|
|
|
|
holdableItem = player->getHoldableItem();
|
|
|
|
if ( holdableItem )
|
|
{
|
|
if ( specialtyItem->_type == SPECIALTY_DEMOLITIONIST )
|
|
{
|
|
if ( holdableItem->getName() == "Explosive" )
|
|
respawnNow = true;
|
|
}
|
|
else if ( specialtyItem->_type == SPECIALTY_MEDIC )
|
|
{
|
|
if ( ( holdableItem->getName() == "Health" ) && ( _playerSpecialtyData[ player->entnum ]._lastUseTime == 0.0f ) )
|
|
respawnNow = true;
|
|
}
|
|
/* else if ( specialtyItem->_type == SPECIALTY_TECHNICIAN )
|
|
{
|
|
if ( ( holdableItem->getName() == "Protection" ) && ( _playerSpecialtyData[ player->entnum ]._lastUseTime == 0.0f ) )
|
|
respawnNow = true;
|
|
} */
|
|
}
|
|
|
|
if ( respawnNow )
|
|
specialtyItem->_respawnTime = specialtyItem->_pickedupTime + 0.0f;
|
|
else
|
|
specialtyItem->_respawnTime = specialtyItem->_pickedupTime + specialtyItem->_minimumRespawnTime;
|
|
|
|
specialtyItem->_needToRespawn = true;
|
|
}
|
|
}
|
|
|
|
_playerSpecialtyData[ player->entnum ].reset();
|
|
}
|
|
|
|
int ModifierSpecialties::getStat( Player *player, int statNum, int value )
|
|
{
|
|
Entity *target;
|
|
Player *targetPlayer;
|
|
int lastPlayer;
|
|
float lastPlayerTime;
|
|
|
|
if ( statNum == STAT_MP_GENERIC4 )
|
|
{
|
|
if ( _playerSpecialtyData[ player->entnum ]._specialty == SPECIALTY_MEDIC )
|
|
{
|
|
lastPlayer = _playerSpecialtyData[ player->entnum ]._lastPlayer;
|
|
lastPlayerTime = _playerSpecialtyData[ player->entnum ]._lastPlayerTime;
|
|
|
|
target = player->GetTargetedEntity();
|
|
|
|
if ( target && target->isSubclassOf( Player ) &&
|
|
( ( multiplayerManager.getPlayersTeam( player ) == multiplayerManager.getPlayersTeam( (Player*)target ) ) ||
|
|
( _medicCanSeeEnemyHealth ) ) )
|
|
{
|
|
_playerSpecialtyData[ player->entnum ]._lastPlayer = target->entnum;
|
|
_playerSpecialtyData[ player->entnum ]._lastPlayerTime = multiplayerManager.getTime();
|
|
|
|
return (int)( target->getHealth() + 0.99f );
|
|
}
|
|
else if ( ( lastPlayer >= 0 ) && ( lastPlayerTime + 1.0f > multiplayerManager.getTime() ) )
|
|
{
|
|
targetPlayer = multiplayerManager.getPlayer( lastPlayer );
|
|
|
|
if ( targetPlayer )
|
|
{
|
|
return (int)( targetPlayer->getHealth() + 0.99f );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_playerSpecialtyData[ player->entnum ]._lastPlayer = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
int ModifierSpecialties::getIcon( Player *player, int statNum, int value )
|
|
{
|
|
if ( statNum == STAT_MP_SPECIALTY_ICON )
|
|
{
|
|
// Return the icon for the player's specialty
|
|
|
|
switch( _playerSpecialtyData[ player->entnum ]._specialty )
|
|
{
|
|
case SPECIALTY_NONE :
|
|
return value;
|
|
case SPECIALTY_INFILTRATOR :
|
|
return _infiltratorIconIndex;
|
|
case SPECIALTY_MEDIC :
|
|
return _medicIconIndex;
|
|
case SPECIALTY_TECHNICIAN :
|
|
return _technicianIconIndex;
|
|
case SPECIALTY_DEMOLITIONIST :
|
|
return _demolitionistIconIndex;
|
|
case SPECIALTY_HEAVY_WEAPONS :
|
|
return _heavyweaponsIconIndex;
|
|
case SPECIALTY_SNIPER :
|
|
return _sniperIconIndex;
|
|
}
|
|
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
int ModifierSpecialties::getScoreIcon( Player *player, int index, int value )
|
|
{
|
|
if ( index == SCOREICON4 )
|
|
{
|
|
// Return the icon for the player's specialty
|
|
|
|
switch( _playerSpecialtyData[ player->entnum ]._specialty )
|
|
{
|
|
case SPECIALTY_NONE :
|
|
return value;
|
|
case SPECIALTY_INFILTRATOR :
|
|
return _infiltratorIconIndex;
|
|
case SPECIALTY_MEDIC :
|
|
return _medicIconIndex;
|
|
case SPECIALTY_TECHNICIAN :
|
|
return _technicianIconIndex;
|
|
case SPECIALTY_DEMOLITIONIST :
|
|
return _demolitionistIconIndex;
|
|
case SPECIALTY_HEAVY_WEAPONS :
|
|
return _heavyweaponsIconIndex;
|
|
case SPECIALTY_SNIPER :
|
|
return _sniperIconIndex;
|
|
}
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
// Setup constants
|
|
|
|
const float ModifierControlPoints::_timeNeededToControl = 5.0f;
|
|
|
|
const int ModifierControlPoints::_maxNumberAwardsForPlayerCapture = 5;
|
|
const int ModifierControlPoints::_pointsForEachAwardForCapture = 5;
|
|
const int ModifierControlPoints::_pointsForProtectingControlPoint = 5;
|
|
const int ModifierControlPoints::_maxGuardingDist = 750;
|
|
|
|
ModifierControlPoints::ModifierControlPoints()
|
|
{
|
|
_alphaControlPointRedControlledIndex = gi.imageindex( "sysimg/icons/mp/cp_alpha_red" );
|
|
_alphaControlPointBlueControlledIndex = gi.imageindex( "sysimg/icons/mp/cp_alpha_blue" );
|
|
_alphaControlPointNeutralControlledIndex = gi.imageindex( "sysimg/icons/mp/cp_alpha_neutral" );
|
|
|
|
_betaControlPointRedControlledIndex = gi.imageindex( "sysimg/icons/mp/cp_beta_red" );
|
|
_betaControlPointBlueControlledIndex = gi.imageindex( "sysimg/icons/mp/cp_beta_blue" );
|
|
_betaControlPointNeutralControlledIndex = gi.imageindex( "sysimg/icons/mp/cp_beta_neutral" );
|
|
|
|
_deltaControlPointRedControlledIndex = gi.imageindex( "sysimg/icons/mp/cp_delta_red" );
|
|
_deltaControlPointBlueControlledIndex = gi.imageindex( "sysimg/icons/mp/cp_delta_blue" );
|
|
_deltaControlPointNeutralControlledIndex = gi.imageindex( "sysimg/icons/mp/cp_delta_neutral" );
|
|
|
|
_gammaControlPointRedControlledIndex = gi.imageindex( "sysimg/icons/mp/cp_gamma_red" );
|
|
_gammaControlPointBlueControlledIndex = gi.imageindex( "sysimg/icons/mp/cp_gamma_blue" );
|
|
_gammaControlPointNeutralControlledIndex = gi.imageindex( "sysimg/icons/mp/cp_gamma_neutral" );
|
|
}
|
|
|
|
ModifierControlPoints::~ModifierControlPoints()
|
|
{
|
|
_controlPoints.FreeObjectList();
|
|
}
|
|
|
|
void ModifierControlPoints::init( int maxPlayers )
|
|
{
|
|
multiplayerManager.cacheMultiplayerFiles( "mp_controlPoints" );
|
|
}
|
|
|
|
void ModifierControlPoints::addPlayer( Player *player )
|
|
{
|
|
gi.SendServerCommand( player->entnum, "stufftext \"ui_addhud mp_control\"\n" );
|
|
}
|
|
|
|
str ModifierControlPoints::getSpawnPointType( Player *player )
|
|
{
|
|
return "control";
|
|
}
|
|
|
|
bool ModifierControlPoints::checkRule( const char *rule, bool defaultValue, Player *player )
|
|
{
|
|
if ( stricmp( rule, "spawnpoints-special" ) == 0 )
|
|
return true;
|
|
else
|
|
return defaultValue;
|
|
}
|
|
|
|
/* int ModifierControlPoints::getStat( Player *player, int statNum, int value )
|
|
{
|
|
int redControlPoints;
|
|
int blueControlPoints;
|
|
int i;
|
|
ControlPointData *controlPoint;
|
|
|
|
if ( statNum == STAT_MP_GENERIC1 )
|
|
{
|
|
// Return the number of control points controlled by the red team
|
|
|
|
redControlPoints = 0;
|
|
|
|
for ( i = 1 ; i <= _controlPoints.NumObjects() ; i++ )
|
|
{
|
|
controlPoint = _controlPoints.AddressOfObjectAt( i );
|
|
|
|
if ( controlPoint && controlPoint->_controllingTeam && controlPoint->_controllingTeam->getName() == "Red" )
|
|
{
|
|
redControlPoints++;
|
|
}
|
|
}
|
|
|
|
return redControlPoints;
|
|
}
|
|
else if ( statNum == STAT_MP_GENERIC2 )
|
|
{
|
|
// Return the number of control points controlled by the blue team
|
|
|
|
blueControlPoints = 0;
|
|
|
|
for ( i = 1 ; i <= _controlPoints.NumObjects() ; i++ )
|
|
{
|
|
controlPoint = _controlPoints.AddressOfObjectAt( i );
|
|
|
|
if ( controlPoint && controlPoint->_controllingTeam && controlPoint->_controllingTeam->getName() == "Blue" )
|
|
{
|
|
blueControlPoints++;
|
|
}
|
|
}
|
|
|
|
return blueControlPoints;
|
|
}
|
|
|
|
return value;
|
|
} */
|
|
|
|
bool ModifierControlPoints::shouldKeepItem( MultiplayerItem *item )
|
|
{
|
|
ControlPointData controlPoint;
|
|
|
|
if ( strnicmp( item->getName().c_str(), "controlpoint-", strlen( "controlpoint-" ) ) == 0 )
|
|
//if ( strnicmp( item->getName().c_str(), "controlpoint", strlen( "controlpoint" ) ) == 0 )
|
|
{
|
|
// This is a control point, add it to the list
|
|
|
|
controlPoint._controlPoint = item;
|
|
controlPoint._controllingTeam = NULL;
|
|
controlPoint._lastControllingTeam = NULL;
|
|
controlPoint._lastTime = 0.0f;
|
|
|
|
controlPoint._controlPointType = getControlPointType( item->getName() );
|
|
//controlPoint._controlPointType = (ControlPointType)( _controlPoints.NumObjects() + 1);
|
|
|
|
_controlPoints.AddObject( controlPoint );
|
|
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
ControlPointType ModifierControlPoints::getControlPointType( const str &name )
|
|
{
|
|
if ( name == "controlpoint-alpha" )
|
|
return CONTROL_POINT_ALPHA;
|
|
else if ( name == "controlpoint-beta" )
|
|
return CONTROL_POINT_BETA;
|
|
else if ( name == "controlpoint-delta" )
|
|
return CONTROL_POINT_DELTA;
|
|
else if ( name == "controlpoint-gamma" )
|
|
return CONTROL_POINT_GAMMA;
|
|
else
|
|
return CONTROL_POINT_NONE;
|
|
}
|
|
|
|
void ModifierControlPoints::itemTouched( Player *player, MultiplayerItem *item )
|
|
{
|
|
int i;
|
|
ControlPointData *controlPoint;
|
|
Team *team;
|
|
str animName;
|
|
str printString;
|
|
|
|
// Find the control point
|
|
|
|
for ( i = 1 ; i <= _controlPoints.NumObjects() ; i++ )
|
|
{
|
|
controlPoint = _controlPoints.AddressOfObjectAt( i );
|
|
|
|
if ( controlPoint->_controlPoint == item )
|
|
{
|
|
// This is the control point that was touched
|
|
|
|
team = multiplayerManager.getPlayersTeam( player );
|
|
|
|
// Transfer control if a different team
|
|
|
|
if ( team != controlPoint->_controllingTeam )
|
|
{
|
|
controlPoint->_controllingTeam = team;
|
|
controlPoint->_lastTime = multiplayerManager.getTime();
|
|
// TODO, clear this if the player quits
|
|
controlPoint->_lastPlayerToTouch = player->entnum;
|
|
controlPoint->_playerPointsAwardedForCapture = 0;
|
|
|
|
// Change the control point based on who controls it
|
|
|
|
animName = "control_";
|
|
animName += controlPoint->_controllingTeam->getName();
|
|
|
|
controlPoint->_controlPoint->animate->RandomAnimate( animName );
|
|
|
|
multiplayerManager.playerSound( player->entnum, "localization/sound/dialog/dm/comp_ctrltaken.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, 1.2f );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ModifierControlPoints::update( float frameTime )
|
|
{
|
|
int i;
|
|
ControlPointData *controlPoint;
|
|
|
|
// Loop through all control points
|
|
|
|
for ( i = 1 ; i <= _controlPoints.NumObjects() ; i++ )
|
|
{
|
|
controlPoint = _controlPoints.AddressOfObjectAt( i );
|
|
|
|
// See if this control point is controlled by a team
|
|
|
|
if ( controlPoint->_controllingTeam )
|
|
{
|
|
if ( multiplayerManager.getTime() > controlPoint->_lastTime + _timeNeededToControl )
|
|
{
|
|
// The team has controlled it for long enough
|
|
|
|
controlPoint->_controllingTeam->addPoints( NULL, 1 );
|
|
|
|
controlPoint->_lastTime = multiplayerManager.getTime();
|
|
|
|
if ( controlPoint->_playerPointsAwardedForCapture < _maxNumberAwardsForPlayerCapture )
|
|
{
|
|
if ( controlPoint->_playerPointsAwardedForCapture == 0 )
|
|
{
|
|
if ( controlPoint->_controllingTeam && ( controlPoint->_lastControllingTeam != controlPoint->_controllingTeam ) )
|
|
{
|
|
str soundName;
|
|
|
|
if ( controlPoint->_controllingTeam->getName() == "Red" )
|
|
{
|
|
if ( controlPoint->_controlPointType == CONTROL_POINT_ALPHA )
|
|
soundName = "localization/sound/dialog/dm/comp_ctrlredalpha.mp3";
|
|
else if ( controlPoint->_controlPointType == CONTROL_POINT_BETA )
|
|
soundName = "localization/sound/dialog/dm/comp_ctrlredbeta.mp3";
|
|
else if ( controlPoint->_controlPointType == CONTROL_POINT_DELTA )
|
|
soundName = "localization/sound/dialog/dm/comp_ctrlreddelta.mp3";
|
|
else if ( controlPoint->_controlPointType == CONTROL_POINT_GAMMA )
|
|
soundName = "localization/sound/dialog/dm/comp_ctrlredgamma.mp3";
|
|
}
|
|
else
|
|
{
|
|
if ( controlPoint->_controlPointType == CONTROL_POINT_ALPHA )
|
|
soundName = "localization/sound/dialog/dm/comp_ctrlbluealpha.mp3";
|
|
else if ( controlPoint->_controlPointType == CONTROL_POINT_BETA )
|
|
soundName = "localization/sound/dialog/dm/comp_ctrlbluebeta.mp3";
|
|
else if ( controlPoint->_controlPointType == CONTROL_POINT_DELTA )
|
|
soundName = "localization/sound/dialog/dm/comp_ctrlbluedelta.mp3";
|
|
else if ( controlPoint->_controlPointType == CONTROL_POINT_GAMMA )
|
|
soundName = "localization/sound/dialog/dm/comp_ctrlbluegamma.mp3";
|
|
}
|
|
|
|
multiplayerManager.broadcastSound( soundName, CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, NULL, 1.5f );
|
|
}
|
|
}
|
|
|
|
controlPoint->_lastControllingTeam = controlPoint->_controllingTeam;
|
|
|
|
controlPoint->_playerPointsAwardedForCapture++;
|
|
|
|
if ( controlPoint->_lastPlayerToTouch >= 0 )
|
|
{
|
|
multiplayerManager.addPoints( controlPoint->_lastPlayerToTouch, _pointsForEachAwardForCapture );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ModifierControlPoints::playerKilled( Player *killedPlayer, Player *attackingPlayer, Entity *inflictor, int meansOfDeath )
|
|
{
|
|
Team *victimsTeam;
|
|
Team *killersTeam;
|
|
float distance;
|
|
str printString;
|
|
bool controlPointGuarded;
|
|
|
|
if ( !attackingPlayer || ( killedPlayer == attackingPlayer ) )
|
|
return;
|
|
|
|
victimsTeam = multiplayerManager.getPlayersTeam( killedPlayer );
|
|
killersTeam = multiplayerManager.getPlayersTeam( attackingPlayer );
|
|
|
|
if ( victimsTeam && killersTeam && ( victimsTeam == killersTeam ) )
|
|
return;
|
|
|
|
// See if the player was guarding a control point (either he or the killed player was close to his flag)
|
|
|
|
controlPointGuarded = false;
|
|
|
|
distance = findNearestControlledControlPoint( killersTeam->getName(), attackingPlayer->origin );
|
|
|
|
if ( ( distance > 0 ) && ( distance < _maxGuardingDist ) )
|
|
{
|
|
controlPointGuarded = true;
|
|
}
|
|
else
|
|
{
|
|
distance = findNearestControlledControlPoint( killersTeam->getName(), killedPlayer->origin );
|
|
|
|
if ( ( distance > 0 ) && ( distance < _maxGuardingDist ) )
|
|
{
|
|
controlPointGuarded = true;
|
|
}
|
|
}
|
|
|
|
if ( controlPointGuarded )
|
|
{
|
|
//multiplayerManager.playerEventNotification( "controlpoint-guarded", "", attackingPlayer );
|
|
|
|
printString = "$$ControlPointGuarded$$ ";
|
|
printString += attackingPlayer->client->pers.netname;
|
|
|
|
multiplayerManager.playerSound( attackingPlayer->entnum, "localization/sound/dialog/dm/comp_ctrlguarded.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, 1.5f );
|
|
|
|
multiplayerManager.centerPrintTeamClients( attackingPlayer, printString, CENTERPRINT_IMPORTANCE_HIGH );
|
|
|
|
// Give points to the player
|
|
|
|
multiplayerManager.addPoints( attackingPlayer->entnum, _pointsForProtectingControlPoint );
|
|
}
|
|
}
|
|
|
|
float ModifierControlPoints::findNearestControlledControlPoint( const str &teamName, const Vector &position )
|
|
{
|
|
int i;
|
|
float nearestDistance = -1.0f;
|
|
Vector diff;
|
|
float distance;
|
|
ControlPointData *controlPoint;
|
|
ControlPointData *nearestControlledControlPoint = NULL;
|
|
|
|
// Loop through all of the control points
|
|
|
|
for ( i = 1 ; i <= _controlPoints.NumObjects() ; i++ )
|
|
{
|
|
controlPoint = _controlPoints.AddressOfObjectAt( i );
|
|
|
|
// See if this control point is controlled by the specified team
|
|
|
|
if ( controlPoint->_controllingTeam && ( controlPoint->_controllingTeam->getName() == teamName ) &&
|
|
( controlPoint->_playerPointsAwardedForCapture > 0 ) )
|
|
{
|
|
// Get the distance from the control point to the specified point
|
|
|
|
diff = position - controlPoint->_controlPoint->origin;
|
|
distance = diff.length();
|
|
|
|
// See if this is the nearest controlled control point
|
|
|
|
if ( !nearestControlledControlPoint || ( distance < nearestDistance ) )
|
|
{
|
|
nearestControlledControlPoint = controlPoint;
|
|
nearestDistance = distance;
|
|
}
|
|
}
|
|
}
|
|
|
|
return nearestDistance;
|
|
}
|
|
|
|
int ModifierControlPoints::getStat( Player *player, int statNum, int value )
|
|
{
|
|
int redControlledIndex;
|
|
int blueControlledIndex;
|
|
int neutralControlledIndex;
|
|
ControlPointData *controlPoint;
|
|
int i;
|
|
ControlPointType controlPointType;
|
|
|
|
|
|
// Figure out which control point we are referring to (if any) and the set of icons to use
|
|
|
|
if ( ( statNum == STAT_MP_GENERIC5 ) )
|
|
{
|
|
controlPointType = CONTROL_POINT_ALPHA;
|
|
redControlledIndex = _alphaControlPointRedControlledIndex;
|
|
blueControlledIndex = _alphaControlPointBlueControlledIndex;
|
|
neutralControlledIndex = _alphaControlPointNeutralControlledIndex;
|
|
}
|
|
else if ( ( statNum == STAT_MP_GENERIC6 ) )
|
|
{
|
|
controlPointType = CONTROL_POINT_BETA;
|
|
redControlledIndex = _betaControlPointRedControlledIndex;
|
|
blueControlledIndex = _betaControlPointBlueControlledIndex;
|
|
neutralControlledIndex = _betaControlPointNeutralControlledIndex;
|
|
}
|
|
else if ( ( statNum == STAT_MP_GENERIC7 ) )
|
|
{
|
|
controlPointType = CONTROL_POINT_DELTA;
|
|
redControlledIndex = _deltaControlPointRedControlledIndex;
|
|
blueControlledIndex = _deltaControlPointBlueControlledIndex;
|
|
neutralControlledIndex = _deltaControlPointNeutralControlledIndex;
|
|
}
|
|
else if ( ( statNum == STAT_MP_GENERIC8 ) )
|
|
{
|
|
controlPointType = CONTROL_POINT_GAMMA;
|
|
redControlledIndex = _gammaControlPointRedControlledIndex;
|
|
blueControlledIndex = _gammaControlPointBlueControlledIndex;
|
|
neutralControlledIndex = _gammaControlPointNeutralControlledIndex;
|
|
}
|
|
else
|
|
{
|
|
return value;
|
|
}
|
|
|
|
// Find this control point
|
|
|
|
for ( i = 1 ; i <= _controlPoints.NumObjects() ; i++ )
|
|
{
|
|
controlPoint = _controlPoints.AddressOfObjectAt( i );
|
|
|
|
if ( controlPoint->_controlPointType == controlPointType )
|
|
{
|
|
// Return the correct index based on which team controls this control point
|
|
|
|
if ( !controlPoint->_controllingTeam )
|
|
{
|
|
return neutralControlledIndex;
|
|
}
|
|
else if ( controlPoint->_controllingTeam->getName() == "Red" )
|
|
{
|
|
return redControlledIndex;
|
|
}
|
|
else if ( controlPoint->_controllingTeam->getName() == "Blue" )
|
|
{
|
|
return blueControlledIndex;
|
|
}
|
|
}
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
/* int ModifierControlPoints::getPointsForKill( Player *killedPlayer, Player *attackingPlayer, Entity *inflictor, int meansOfDeath, int points )
|
|
{
|
|
// Players do not get points for kills in control points mode
|
|
return 0;
|
|
} */
|
|
|
|
// Setup constants
|
|
|
|
const float ModifierAutoHandicap::_attackerHandicapModifier = 1.05f;
|
|
const float ModifierAutoHandicap::_victimHandicapModifier = 1.05f;
|
|
|
|
ModifierAutoHandicap::ModifierAutoHandicap()
|
|
{
|
|
_playerHandicapData = NULL;
|
|
}
|
|
|
|
ModifierAutoHandicap::~ModifierAutoHandicap()
|
|
{
|
|
delete [] _playerHandicapData;
|
|
_playerHandicapData = NULL;
|
|
}
|
|
|
|
void ModifierAutoHandicap::init( int maxPlayers )
|
|
{
|
|
_playerHandicapData = new HandicapPlayerData[ maxPlayers ];
|
|
}
|
|
|
|
void ModifierAutoHandicap::addPlayer( Player *player )
|
|
{
|
|
_playerHandicapData[ player->entnum ].reset();
|
|
}
|
|
|
|
float ModifierAutoHandicap::playerDamaged( Player *damagedPlayer, Player *attackingPlayer, float damage, int meansOfDeath )
|
|
{
|
|
if ( damagedPlayer == attackingPlayer )
|
|
return damage;
|
|
|
|
// Change the damage based on the damaged and the attacking player's current handicap
|
|
|
|
return damage * _playerHandicapData[ attackingPlayer->entnum ]._handicap /
|
|
_playerHandicapData[ damagedPlayer->entnum ]._handicap;
|
|
}
|
|
|
|
void ModifierAutoHandicap::playerKilled( Player *killedPlayer, Player *attackingPlayer, Entity *inflictor, int meansOfDeath )
|
|
{
|
|
if ( killedPlayer == attackingPlayer || !attackingPlayer )
|
|
return;
|
|
|
|
// Make it harder for the attacker to get another kill
|
|
|
|
_playerHandicapData[ attackingPlayer->entnum ]._handicap /= _attackerHandicapModifier;
|
|
|
|
// Make it easier for the victim to get kills
|
|
|
|
_playerHandicapData[ killedPlayer->entnum ]._handicap *= _victimHandicapModifier;
|
|
}
|
|
|
|
// Setup constants
|
|
|
|
const float ModifierActionHero::_actionHeroRegenRate = 5.0f;
|
|
const int ModifierActionHero::_extraPointsForKillingActionHero = 4;
|
|
|
|
ModifierActionHero::ModifierActionHero()
|
|
{
|
|
_actionHeroNum = -1;
|
|
_healthRegenRate = _actionHeroRegenRate;
|
|
|
|
_actionHeroIconIndex = gi.imageindex( "sysimg/icons/mp/actionhero" );
|
|
_actionHeroInfoIconIndex = gi.imageindex( "sysimg/icons/mp/actionhero_icon" );
|
|
}
|
|
|
|
void ModifierActionHero::init( int maxPlayers )
|
|
{
|
|
multiplayerManager.cacheMultiplayerFiles( "mp_actionhero" );
|
|
}
|
|
|
|
void ModifierActionHero::matchStarting( void )
|
|
{
|
|
_actionHeroNum = -1;
|
|
}
|
|
|
|
void ModifierActionHero::removePlayer( Player *player )
|
|
{
|
|
if ( player->entnum == _actionHeroNum )
|
|
{
|
|
// Action hero left the game so make action hero up for grabs
|
|
|
|
multiplayerManager.centerPrintAllClients( "$$ActionHeroLeft$$", CENTERPRINT_IMPORTANCE_NORMAL );
|
|
|
|
_actionHeroNum = -1;
|
|
}
|
|
}
|
|
|
|
void ModifierActionHero::update( float frameTime )
|
|
{
|
|
float healthToRegen;
|
|
Player *player;
|
|
|
|
// Regen the action hero's health a little
|
|
|
|
if ( _actionHeroNum != -1 )
|
|
{
|
|
healthToRegen = _healthRegenRate * frameTime;
|
|
|
|
player = multiplayerManager.getPlayer( _actionHeroNum );
|
|
|
|
if ( player )
|
|
{
|
|
if ( player->canRegenerate() )
|
|
{
|
|
multiplayerManager.addPlayerHealth( _actionHeroNum, healthToRegen );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ModifierActionHero::playerKilled( Player *killedPlayer, Player *attackingPlayer, Entity *inflictor, int meansOfDeath )
|
|
{
|
|
// Make sure everything is ok
|
|
|
|
if ( !killedPlayer )
|
|
return;
|
|
|
|
// Always stop being the action hero if you die for any reason
|
|
|
|
if ( killedPlayer->entnum == _actionHeroNum )
|
|
{
|
|
Event *removeAttachedModel = new Event( EV_RemoveAttachedModelByTargetname );
|
|
removeAttachedModel->AddString( "actionHero" );
|
|
killedPlayer->ProcessEvent( removeAttachedModel );
|
|
}
|
|
|
|
if ( !attackingPlayer || ( killedPlayer == attackingPlayer ) )
|
|
{
|
|
if ( killedPlayer->entnum == _actionHeroNum )
|
|
{
|
|
_actionHeroNum = -1;
|
|
|
|
multiplayerManager.centerPrintAllClients( "$$ActionHeroDead$$", CENTERPRINT_IMPORTANCE_NORMAL );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if ( ( _actionHeroNum == -1 ) || ( killedPlayer->entnum == _actionHeroNum ) )
|
|
{
|
|
// This is either the first kill or the attacking player killed the action hero, either way we have
|
|
// a new actio hero
|
|
|
|
// Give extra points if the last action hero was killed
|
|
|
|
if ( _actionHeroNum != -1 )
|
|
{
|
|
multiplayerManager.addPoints( attackingPlayer->entnum, _extraPointsForKillingActionHero );
|
|
}
|
|
|
|
// Make the killer the action hero
|
|
|
|
_actionHeroNum = attackingPlayer->entnum;
|
|
|
|
multiplayerManager.givePlayerItem( attackingPlayer->entnum, "models/weapons/worldmodel-attrex-rifle.tik" );
|
|
multiplayerManager.givePlayerItem( attackingPlayer->entnum, "models/weapons/worldmodel-burstrifle.tik" );
|
|
multiplayerManager.givePlayerItem( attackingPlayer->entnum, "models/weapons/worldmodel-compressionrifle.tik" );
|
|
multiplayerManager.givePlayerItem( attackingPlayer->entnum, "models/weapons/worldmodel-drull-staff.tik" );
|
|
multiplayerManager.givePlayerItem( attackingPlayer->entnum, "models/weapons/worldmodel-fieldassaultrifle.tik" );
|
|
multiplayerManager.givePlayerItem( attackingPlayer->entnum, "models/weapons/worldmodel-grenadelauncher.tik" );
|
|
multiplayerManager.givePlayerItem( attackingPlayer->entnum, "models/weapons/worldmodel-imod.tik" );
|
|
multiplayerManager.givePlayerItem( attackingPlayer->entnum, "models/weapons/worldmodel-photon.tik" );
|
|
multiplayerManager.givePlayerItem( attackingPlayer->entnum, "models/weapons/worldmodel-rom-disruptor.tik" );
|
|
multiplayerManager.givePlayerItem( attackingPlayer->entnum, "models/weapons/worldmodel-rom-radgun.tik" );
|
|
multiplayerManager.givePlayerItem( attackingPlayer->entnum, "models/weapons/worldmodel-sniperrifle.tik" );
|
|
multiplayerManager.givePlayerItem( attackingPlayer->entnum, "models/weapons/worldmodel-tetryon.tik" );
|
|
multiplayerManager.givePlayerItem( attackingPlayer->entnum, "models/weapons/worldmodel-tricorder.tik" );
|
|
|
|
attackingPlayer->GiveAmmo( "Plasma", 400, false, 400 );
|
|
attackingPlayer->GiveAmmo( "Fed", 400, false, 400 );
|
|
attackingPlayer->GiveAmmo( "Idryll", 400, false, 400 );
|
|
|
|
multiplayerManager.centerPrintAllClients( va( "%s $$NowActionHero$$", attackingPlayer->client->pers.netname ), CENTERPRINT_IMPORTANCE_NORMAL );
|
|
multiplayerManager.broadcastSound( "localization/sound/dialog/dm/comp_nah.mp3", CHAN_AUTO, DEFAULT_VOL, DEFAULT_MIN_DIST, NULL, 1.2f );
|
|
|
|
Event *attachModel = new Event( EV_AttachModel );
|
|
attachModel->AddString( "models/fx/fx-actionHero.tik" );
|
|
attachModel->AddString( "Bip01" );
|
|
attachModel->AddFloat( 1.0f );
|
|
attachModel->AddString( "actionHero" );
|
|
attackingPlayer->ProcessEvent( attachModel );
|
|
|
|
// Max the player's health
|
|
|
|
attackingPlayer->addHealth( 100.0f );
|
|
|
|
// Max the player's armor
|
|
|
|
Event *armorEvent = new Event( EV_Sentient_GiveArmor );
|
|
armorEvent->AddString( "BasicArmor" );
|
|
armorEvent->AddFloat( 200.0f );
|
|
armorEvent->AddInteger( false );
|
|
attackingPlayer->ProcessEvent( armorEvent );
|
|
}
|
|
}
|
|
|
|
int ModifierActionHero::getIcon( Player *player, int statNum, int value )
|
|
{
|
|
if ( statNum == STAT_MP_SPECIALTY_ICON )
|
|
{
|
|
// Return the action hero icon if this player is the action hero
|
|
|
|
if ( _actionHeroNum == player->entnum )
|
|
return _actionHeroIconIndex;
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
int ModifierActionHero::getInfoIcon( Player *player )
|
|
{
|
|
if ( _actionHeroNum == player->entnum )
|
|
return _actionHeroInfoIconIndex;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
int ModifierActionHero::getScoreIcon( Player *player, int index, int value )
|
|
{
|
|
if ( index == SCOREICON2 )
|
|
{
|
|
if ( _actionHeroNum == player->entnum )
|
|
return _actionHeroIconIndex;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
ModifierPointsPerWeapon::~ModifierPointsPerWeapon()
|
|
{
|
|
_weapons.FreeObjectList();
|
|
_projectiles.FreeObjectList();
|
|
}
|
|
|
|
void ModifierPointsPerWeapon::init( int maxPlayers )
|
|
{
|
|
// Read in all of the projectile/weapon points data
|
|
|
|
readMultiplayerConfig( "global/mp_PointsPerWeapon.cfg" );
|
|
}
|
|
|
|
void ModifierPointsPerWeapon::readMultiplayerConfig( const char *configName )
|
|
{
|
|
Script buffer;
|
|
const char *token;
|
|
|
|
// Make sure the file exists
|
|
|
|
if ( !gi.FS_Exists( configName ) )
|
|
return;
|
|
|
|
// Load the file
|
|
|
|
buffer.LoadFile( configName );
|
|
|
|
// Parse the file
|
|
|
|
while ( buffer.TokenAvailable( true ) )
|
|
{
|
|
token = buffer.GetToken( true );
|
|
|
|
if ( !parseConfigToken( token, &buffer ) )
|
|
{
|
|
gi.DPrintf( "Token %s from %s not handled by anyone\n", token, configName );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool ModifierPointsPerWeapon::parseConfigToken( const char *key, Script *buffer )
|
|
{
|
|
PointsPerWeaponData pointsPerWeaponData;
|
|
|
|
if ( stricmp( key, "projectile" ) == 0 )
|
|
{
|
|
// Get projectile name
|
|
|
|
if ( !buffer->TokenAvailable( false ) )
|
|
return false;
|
|
|
|
pointsPerWeaponData._name = buffer->GetToken( false );
|
|
|
|
// Get points for this projectile
|
|
|
|
if ( !buffer->TokenAvailable( false ) )
|
|
return false;
|
|
|
|
pointsPerWeaponData._points = atoi( buffer->GetToken( false ) );
|
|
|
|
// Add projectile to the projectile list
|
|
|
|
_projectiles.AddObject( pointsPerWeaponData );
|
|
|
|
return true;
|
|
}
|
|
else if ( stricmp( key, "weapon" ) == 0 )
|
|
{
|
|
// Get weapon name
|
|
|
|
if ( !buffer->TokenAvailable( false ) )
|
|
return false;
|
|
|
|
pointsPerWeaponData._name = buffer->GetToken( false );
|
|
|
|
// Get points for this projectile
|
|
|
|
if ( !buffer->TokenAvailable( false ) )
|
|
return false;
|
|
|
|
pointsPerWeaponData._points = atoi( buffer->GetToken( false ) );
|
|
|
|
// Add weapon to the weapon list
|
|
|
|
_weapons.AddObject( pointsPerWeaponData );
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
int ModifierPointsPerWeapon::getPointsForKill( Player *killedPlayer, Player *attackingPlayer, Entity *inflictor, int meansOfDeath, int points )
|
|
{
|
|
PointsPerWeaponData *pointsPerWeaponData;
|
|
int i;
|
|
|
|
// Make sure everything is ok
|
|
|
|
if ( killedPlayer == attackingPlayer )
|
|
return points;
|
|
|
|
if ( points <= 0 )
|
|
return points;
|
|
|
|
// See if the kill was by a projectile or directly from a weapon
|
|
|
|
if ( inflictor && inflictor->isSubclassOf( Projectile ) )
|
|
{
|
|
Projectile *proj;
|
|
|
|
proj = (Projectile *)inflictor;
|
|
|
|
// Determine the points based off of the projectile
|
|
|
|
for ( i = 1 ; i <= _projectiles.NumObjects() ; i++ )
|
|
{
|
|
pointsPerWeaponData = &_projectiles.ObjectAt( i );
|
|
|
|
if ( stricmp( proj->model.c_str(), pointsPerWeaponData->_name.c_str() ) == 0 )
|
|
return pointsPerWeaponData->_points;
|
|
}
|
|
|
|
// Didn't find it so just return the default
|
|
|
|
return points;
|
|
}
|
|
else
|
|
{
|
|
str weaponName;
|
|
|
|
// Get the name of the weapon
|
|
|
|
attackingPlayer->getActiveWeaponName( WEAPON_ANY, weaponName );
|
|
|
|
// Determine the points based off of the weapon
|
|
|
|
for ( i = 1 ; i <= _weapons.NumObjects() ; i++ )
|
|
{
|
|
pointsPerWeaponData = &_weapons.ObjectAt( i );
|
|
|
|
if ( stricmp( weaponName.c_str(), pointsPerWeaponData->_name.c_str() ) == 0 )
|
|
return pointsPerWeaponData->_points;
|
|
}
|
|
|
|
// Didn't find it so just return the default
|
|
|
|
return points;
|
|
}
|
|
}
|
|
|