BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/game/shared/tf/tf_gamerules.cpp

21411 lines
680 KiB
C++
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: The TF Game rules
//
// $NoKeywords: $
//=============================================================================
#include "cbase.h"
#include "tf_gamerules.h"
#include "tf_classdata.h"
#include "ammodef.h"
#include "KeyValues.h"
#include "tf_weaponbase.h"
#include "tf_weaponbase_gun.h"
#include "tier0/icommandline.h"
#include "convar_serverbounded.h"
#include "econ_item_system.h"
#include "tf_weapon_grenadelauncher.h"
#include "tf_logic_robot_destruction.h"
#include "tf_logic_player_destruction.h"
#include "tf_matchmaking_shared.h"
#ifdef CLIENT_DLL
#include <game/client/iviewport.h>
#include "c_tf_player.h"
#include "c_tf_objective_resource.h"
#include <filesystem.h>
#include "c_tf_team.h"
#include "dt_utlvector_recv.h"
#include "tf_autorp.h"
#include "player_vs_environment/c_tf_upgrades.h"
#include "video/ivideoservices.h"
#include "tf_gc_client.h"
#include "c_tf_playerresource.h"
#else
#include "basemultiplayerplayer.h"
#include "voice_gamemgr.h"
#include "items.h"
#include "team.h"
#include "game.h"
#include "tf_bot_temp.h"
#include "tf_player.h"
#include "tf_team.h"
#include "player_resource.h"
#include "entity_tfstart.h"
#include "filesystem.h"
#include "minigames/tf_duel.h"
#include "tf_obj.h"
#include "tf_objective_resource.h"
#include "tf_player_resource.h"
#include "team_control_point_master.h"
#include "team_train_watcher.h"
#include "playerclass_info_parse.h"
#include "team_control_point_master.h"
#include "coordsize.h"
#include "entity_healthkit.h"
#include "tf_gamestats.h"
#include "entity_capture_flag.h"
#include "tf_player_resource.h"
#include "tf_obj_sentrygun.h"
#include "activitylist.h"
#include "AI_ResponseSystem.h"
#include "hl2orange.spa.h"
#include "hltvdirector.h"
#include "tf_projectile_arrow.h"
#include "func_suggested_build.h"
#include "tf_gc_api.h"
#include "tf_weaponbase_grenadeproj.h"
#include "engine/IEngineSound.h"
#include "soundenvelope.h"
#include "dt_utlvector_send.h"
#include "tf_tactical_mission.h"
#include "nav_mesh/tf_nav_area.h"
#include "bot/tf_bot.h"
#include "bot/tf_bot_manager.h"
#include "bot/map_entities/tf_bot_roster.h"
#include "econ_gcmessages.h"
#include "vgui/ILocalize.h"
#include "tier3/tier3.h"
#include "tf_ammo_pack.h"
#include "tf_gcmessages.h"
#include "vote_controller.h"
#include "tf_voteissues.h"
#include "halloween/headless_hatman.h"
#include "halloween/ghost/ghost.h"
#include "halloween/eyeball_boss/eyeball_boss.h"
#include "halloween/merasmus/merasmus.h"
#include "halloween/merasmus/merasmus_dancer.h"
#include "tf_extra_map_entity.h"
#include "tf_weapon_grenade_pipebomb.h"
#include "tf_weapon_flaregun.h"
#include "tf_weapon_sniperrifle.h"
#include "tf_weapon_knife.h"
#include "tf_weapon_jar.h"
#include "halloween/tf_weapon_spellbook.h"
#include "player_vs_environment/tf_population_manager.h"
#include "player_vs_environment/monster_resource.h"
#include "util_shared.h"
#include "gc_clientsystem.h"
#include "raid/tf_raid_logic.h"
#include "player_vs_environment/tf_boss_battle_logic.h"
#include "player_vs_environment/tf_mann_vs_machine_logic.h"
#include "player_vs_environment/tf_upgrades.h"
#include "tf_wheel_of_doom.h"
#include "tf_halloween_souls_pickup.h"
#include "halloween/zombie/zombie.h"
#include "teamplay_round_timer.h"
#include "halloween/spell/tf_spell_pickup.h"
#include "tf_weapon_laser_pointer.h"
#include "effect_dispatch_data.h"
#include "tf_fx.h"
#include "econ_game_account_server.h"
#include "tf_gc_server.h"
#include "tf_logic_halloween_2014.h"
#include "tf_obj_sentrygun.h"
#include "entity_halloween_pickup.h"
#include "entity_rune.h"
#include "func_powerupvolume.h"
#include "workshop/maps_workshop.h"
#include "tf_passtime_logic.h"
#include "cdll_int.h"
#include "halloween/halloween_gift_spawn_locations.h"
#include "tf_weapon_invis.h"
#include "tf_gc_server.h"
#include "gcsdk/msgprotobuf.h"
#include "tf_party.h"
#include "tf_autobalance.h"
#endif
#include "tf_mann_vs_machine_stats.h"
#include "tf_upgrades_shared.h"
#include "tf_item_powerup_bottle.h"
#include "tf_weaponbase_gun.h"
#include "tf_weaponbase_melee.h"
#include "tf_wearable_item_demoshield.h"
#include "tf_weapon_buff_item.h"
#include "tf_weapon_flamethrower.h"
#include "tf_weapon_medigun.h"
#include "econ_holidays.h"
#include "rtime.h"
#include "tf_revive.h"
#include "tf_duckleaderboard.h"
#include "passtime_convars.h"
#include "tier3/tier3.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#define ITEM_RESPAWN_TIME 10.0f
#define MASK_RADIUS_DAMAGE ( MASK_SHOT & ~( CONTENTS_HITBOX ) )
// Halloween 2013 VO defines for plr_hightower_event
#define HELLTOWER_TIMER_INTERVAL ( 60 + RandomInt( -30, 30 ) )
#define HELLTOWER_RARE_LINE_CHANCE 0.15 // 15%
#define HELLTOWER_MISC_CHANCE 0.50 // 50%
static int g_TauntCamRagdollAchievements[] =
{
0, // TF_CLASS_UNDEFINED
0, // TF_CLASS_SCOUT,
0, // TF_CLASS_SNIPER,
0, // TF_CLASS_SOLDIER,
0, // TF_CLASS_DEMOMAN,
ACHIEVEMENT_TF_MEDIC_FREEZECAM_RAGDOLL, // TF_CLASS_MEDIC,
0, // TF_CLASS_HEAVYWEAPONS,
0, // TF_CLASS_PYRO,
ACHIEVEMENT_TF_SPY_FREEZECAM_FLICK, // TF_CLASS_SPY,
0, // TF_CLASS_ENGINEER,
0, // TF_CLASS_CIVILIAN,
0, // TF_CLASS_COUNT_ALL,
};
static int g_TauntCamAchievements[] =
{
0, // TF_CLASS_UNDEFINED
0, // TF_CLASS_SCOUT,
ACHIEVEMENT_TF_SNIPER_FREEZECAM_HAT, // TF_CLASS_SNIPER,
ACHIEVEMENT_TF_SOLDIER_FREEZECAM_GIBS, // TF_CLASS_SOLDIER, (extra check to count the number of gibs onscreen)
ACHIEVEMENT_TF_DEMOMAN_FREEZECAM_SMILE, // TF_CLASS_DEMOMAN,
0, // TF_CLASS_MEDIC,
ACHIEVEMENT_TF_HEAVY_FREEZECAM_TAUNT, // TF_CLASS_HEAVYWEAPONS, (there's an extra check on this one to see if we're also invuln)
ACHIEVEMENT_TF_PYRO_FREEZECAM_TAUNTS, // TF_CLASS_PYRO,
0, // TF_CLASS_SPY,
ACHIEVEMENT_TF_ENGINEER_FREEZECAM_TAUNT, // TF_CLASS_ENGINEER,
0, // TF_CLASS_CIVILIAN,
0, // TF_CLASS_COUNT_ALL,
};
// used for classes that have more than one freeze cam achievement (example: Sniper)
static int g_TauntCamAchievements2[] =
{
0, // TF_CLASS_UNDEFINED
0, // TF_CLASS_SCOUT,
ACHIEVEMENT_TF_SNIPER_FREEZECAM_WAVE, // TF_CLASS_SNIPER,
ACHIEVEMENT_TF_SOLDIER_FREEZECAM_TAUNT, // TF_CLASS_SOLDIER,
ACHIEVEMENT_TF_DEMOMAN_FREEZECAM_RUMP, // TF_CLASS_DEMOMAN,
0, // TF_CLASS_MEDIC,
0, // TF_CLASS_HEAVYWEAPONS,
0, // TF_CLASS_PYRO,
0, // TF_CLASS_SPY,
0, // TF_CLASS_ENGINEER,
0, // TF_CLASS_CIVILIAN,
0, // TF_CLASS_COUNT_ALL,
};
struct MapInfo_t
{
const char *pDiskName;
const char *pDisplayName;
const char *pGameType;
};
static MapInfo_t s_ValveMaps[] = {
{ "ctf_2fort", "2Fort", "#Gametype_CTF" },
{ "cp_dustbowl", "Dustbowl", "#TF_AttackDefend" },
{ "cp_granary", "Granary", "#Gametype_CP" },
{ "cp_well", "Well", "#Gametype_CP" },
{ "cp_foundry", "Foundry", "#Gametype_CP" },
{ "cp_gravelpit", "Gravel Pit", "#TF_AttackDefend" },
{ "tc_hydro", "Hydro", "#TF_TerritoryControl" },
{ "ctf_well", "Well", "#Gametype_CTF" },
{ "cp_badlands", "Badlands", "#Gametype_CP" },
{ "pl_goldrush", "Gold Rush", "#Gametype_Escort" },
{ "pl_badwater", "Badwater Basin", "#Gametype_Escort" },
{ "plr_pipeline", "Pipeline", "#Gametype_EscortRace" },
{ "cp_gorge", "Gorge", "#TF_AttackDefend" },
{ "ctf_doublecross", "Double Cross", "#Gametype_CTF" },
{ "pl_thundermountain", "Thunder Mountain", "#Gametype_Escort" },
{ "tr_target", "Target", "#GameType_Training" },
{ "tr_dustbowl", "Dustbowl", "#GameType_Training" },
{ "cp_manor_event", "Mann Manor", "#TF_AttackDefend" },
{ "cp_mountainlab", "Mountain Lab", "#TF_AttackDefend" },
{ "cp_degrootkeep", "DeGroot Keep", "#TF_MedievalAttackDefend" },
{ "pl_barnblitz", "Barnblitz", "#Gametype_Escort" },
{ "pl_upward", "Upward", "#Gametype_Escort" },
{ "plr_hightower", "Hightower", "#Gametype_EscortRace" },
{ "koth_viaduct", "Viaduct", "#Gametype_Koth" },
{ "koth_viaduct_event", "Eyeaduct", "#Gametype_Koth" },
{ "koth_king", "Kong King", "#Gametype_Koth" },
{ "koth_lakeside_event", "Ghost Fort", "#Gametype_Koth" },
{ "plr_hightower_event", "Helltower", "#Gametype_EscortRace" },
{ "rd_asteroid", "Asteroid", "#Gametype_RobotDestruction" },
{ "pl_cactuscanyon", "Cactus Canyon", "#Gametype_Escort" },
{ "sd_doomsday", "Doomsday", "#Gametype_SD" },
{ "sd_doomsday_event", "Carnival of Carnage", "#Gametype_SD" },
};
static MapInfo_t s_CommunityMaps[] = {
{ "pl_borneo", "Borneo", "#Gametype_Escort" },
{ "koth_suijin", "Suijin", "#Gametype_Koth" },
{ "cp_snowplow", "Snowplow", "#TF_AttackDefend" },
{ "koth_probed", "Probed", "#Gametype_Koth" },
{ "pd_watergate", "Watergate", "#Gametype_PlayerDestruction" },
{ "arena_byre", "Byre", "#Gametype_Arena" },
{ "ctf_2fort_invasion", "2Fort Invasion", "#Gametype_CTF" },
{ "cp_sunshine_event", "Sinshine", "#Gametype_CP" },
{ "pl_millstone_event", "Hellstone", "#Gametype_Escort" },
{ "cp_gorge_event", "Gorge Event", "#TF_AttackDefend" },
{ "koth_moonshine_event", "Moonshine Event", "#Gametype_Koth" },
{ "pl_snowycoast", "Snowycoast", "#Gametype_Escort" },
{ "cp_vanguard", "Vanguard", "#Gametype_CP" },
{ "ctf_landfall", "Landfall", "#Gametype_CTF" },
{ "koth_highpass", "Highpass", "#Gametype_Koth" },
{ "koth_maple_ridge_event", "Maple Ridge Event", "#Gametype_Koth" },
{ "pl_fifthcurve_event", "Brimstone", "#Gametype_Escort" },
{ "pd_pit_of_death_event", "Pit of Death", "#Gametype_PlayerDestruction" },
};
/*
!! Commented out until we use this data, but we should keep updating it so its current when we need it
struct FeaturedWorkshopMap_t
{
// The name the map was shipped as in our files (e.g. it was available as maps/<this>.bsp)
// NOTE After maps are un-shipped we leave them here and don't change this value, this allows mapcycles that have
// this map to proper redirect to the workshop in the future
const char *pShippedName;
// The workshop ID of the map (The public one, not the the private upload they use to send us the sources)
PublishedFileId_t nWorkshopID;
};
static FeaturedWorkshopMap_t s_FeaturedWorkshopMaps[] = {
// !! DO NOT remove these after we stop shipping the file -- they exist to ensure users can refer to
// !! e.g. "koth_suijin" and get redirected to the workshop map once the file is no longer in our depots.
// Summer 2015 Operation
{ "pl_borneo", 454139147 },
{ "koth_suijin", 454188876 },
{ "cp_snowplow", 454116615 },
// September 2015 Invasion Community Update
{ "koth_probed", 454139808 },
{ "pd_watergate", 456016898 },
{ "arena_byre", 454142123 },
{ "ctf_2fort_invasion", FIXME }, // No public workshop entry yet
// Halloween 2015
{ "cp_sunshine_event", 532473747 },
{ "pl_millstone_event", 531384846 },
{ "cp_gorge_event", 527145539 },
{ "koth_moonshine_event", 534874830 },
// December 2015 Campaign
{ "pl_snowycoast", 469072819 },
{ "cp_vanguard", 462908782 },
{ "ctf_landfall", 459651881 },
{ "koth_highpass", 463803443 },
// Halloween 2016
{ "koth_maple_ridge_event", 537540619 },
{ "pl_fifthcurve_event", 764966851 },
{ "pd_pit_of_death_event", 537319626 },
};
*/
bool IsValveMap( const char *pMapName )
{
for ( int i = 0; i < ARRAYSIZE( s_ValveMaps ); ++i )
{
if ( !Q_stricmp( s_ValveMaps[i].pDiskName, pMapName ) )
{
return true;
}
}
return false;
}
extern ConVar mp_capstyle;
extern ConVar sv_turbophysics;
extern ConVar tf_vaccinator_small_resist;
extern ConVar tf_vaccinator_uber_resist;
extern ConVar tf_teleporter_fov_time;
extern ConVar tf_teleporter_fov_start;
#ifdef GAME_DLL
extern ConVar mp_holiday_nogifts;
extern ConVar tf_debug_damage;
extern ConVar tf_damage_range;
extern ConVar tf_damage_disablespread;
extern ConVar tf_populator_damage_multiplier;
extern ConVar tf_mm_trusted;
extern ConVar tf_weapon_criticals;
extern ConVar tf_weapon_criticals_melee;
extern ConVar mp_idledealmethod;
extern ConVar mp_idlemaxtime;
extern ConVar tf_mm_strict;
extern ConVar mp_autoteambalance;
// STAGING_SPY
ConVar tf_feign_death_activate_damage_scale( "tf_feign_death_activate_damage_scale", "0.25", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_feign_death_damage_scale( "tf_feign_death_damage_scale", "0.35", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_stealth_damage_reduction( "tf_stealth_damage_reduction", "0.8", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
// training
ConVar training_class( "training_class", "3", FCVAR_REPLICATED, "Class to use in training." );
ConVar training_can_build_sentry( "training_can_build_sentry", "1", FCVAR_REPLICATED, "Player can build sentry as engineer." );
ConVar training_can_build_dispenser( "training_can_build_dispenser", "1", FCVAR_REPLICATED, "Player can build dispenser as engineer." );
ConVar training_can_build_tele_entrance( "training_can_build_tele_entrance", "1", FCVAR_REPLICATED, "Player can build teleporter entrance as engineer." );
ConVar training_can_build_tele_exit( "training_can_build_tele_exit", "1", FCVAR_REPLICATED, "Player can build teleporter exit as engineer." );
ConVar training_can_destroy_buildings( "training_can_destroy_buildings", "1", FCVAR_REPLICATED, "Player can destroy buildings as engineer." );
ConVar training_can_pickup_sentry( "training_can_pickup_sentry", "1", FCVAR_REPLICATED, "Player can pickup sentry gun as engineer." );
ConVar training_can_pickup_dispenser( "training_can_pickup_dispenser", "1", FCVAR_REPLICATED, "Player can pickup dispenser as engineer." );
ConVar training_can_pickup_tele_entrance( "training_can_pickup_tele_entrance", "1", FCVAR_REPLICATED, "Player can pickup teleporter entrance as engineer." );
ConVar training_can_pickup_tele_exit( "training_can_pickup_tele_exit", "1", FCVAR_REPLICATED, "Player can pickup teleporter entrance as engineer." );
ConVar training_can_select_weapon_primary ( "training_can_select_weapon_primary", "1", FCVAR_REPLICATED, "In training player select primary weapon." );
ConVar training_can_select_weapon_secondary ( "training_can_select_weapon_secondary", "1", FCVAR_REPLICATED, "In training player select secondary weapon." );
ConVar training_can_select_weapon_melee ( "training_can_select_weapon_melee", "1", FCVAR_REPLICATED, "In training player select melee weapon." );
ConVar training_can_select_weapon_building ( "training_can_select_weapon_building", "1", FCVAR_REPLICATED, "In training player select building tool." );
ConVar training_can_select_weapon_pda ( "training_can_select_weapon_pda", "1", FCVAR_REPLICATED, "In training player select pda." );
ConVar training_can_select_weapon_item1 ( "training_can_select_weapon_item1", "1", FCVAR_REPLICATED, "In training player select item 1." );
ConVar training_can_select_weapon_item2 ( "training_can_select_weapon_item2", "1", FCVAR_REPLICATED, "In training player select item 2." );
ConVar tf_birthday_ball_chance( "tf_birthday_ball_chance", "100", FCVAR_REPLICATED, "Percent chance of a birthday beach ball spawning at each round start" );
ConVar tf_halloween_boss_spawn_interval( "tf_halloween_boss_spawn_interval", "480", FCVAR_CHEAT, "Average interval between boss spawns, in seconds" );
ConVar tf_halloween_boss_spawn_interval_variation( "tf_halloween_boss_spawn_interval_variation", "60", FCVAR_CHEAT, "Variation of spawn interval +/-" );
ConVar tf_halloween_eyeball_boss_spawn_interval( "tf_halloween_eyeball_boss_spawn_interval", "180", FCVAR_CHEAT, "Average interval between boss spawns, in seconds" );
ConVar tf_halloween_eyeball_boss_spawn_interval_variation( "tf_halloween_eyeball_boss_spawn_interval_variation", "30", FCVAR_CHEAT, "Variation of spawn interval +/-" );
ConVar tf_merasmus_spawn_interval( "tf_merasmus_spawn_interval", "180", FCVAR_CHEAT, "Average interval between boss spawns, in seconds" );
ConVar tf_merasmus_spawn_interval_variation( "tf_merasmus_spawn_interval_variation", "30", FCVAR_CHEAT, "Variation of spawn interval +/-" );
ConVar tf_halloween_zombie_mob_enabled( "tf_halloween_zombie_mob_enabled", "0", FCVAR_CHEAT, "If set to 1, spawn zombie mobs on non-Halloween Valve maps" );
ConVar tf_halloween_zombie_mob_spawn_interval( "tf_halloween_zombie_mob_spawn_interval", "180", FCVAR_CHEAT, "Average interval between zombie mob spawns, in seconds" );
ConVar tf_halloween_zombie_mob_spawn_count( "tf_halloween_zombie_mob_spawn_count", "20", FCVAR_CHEAT, "How many zombies to spawn" );
ConVar tf_halloween_allow_truce_during_boss_event( "tf_halloween_allow_truce_during_boss_event", "0", FCVAR_NOTIFY, "Determines if RED and BLU can damage each other while fighting Monoculus or Merasmus on non-Valve maps." );
ConVar tf_player_spell_drop_on_death_rate( "tf_player_spell_drop_on_death_rate", "0", FCVAR_REPLICATED );
ConVar tf_player_drop_bonus_ducks( "tf_player_drop_bonus_ducks", "-1", FCVAR_REPLICATED, "-1 Default (Holiday-based)\n0 - Force off\n1 - Force on" );
ConVar tf_player_name_change_time( "tf_player_name_change_time", "60", FCVAR_NOTIFY, "Seconds between name changes." );
ConVar tf_weapon_criticals_distance_falloff( "tf_weapon_criticals_distance_falloff", "0", FCVAR_CHEAT, "Critical weapon damage will take distance into account." );
ConVar tf_weapon_minicrits_distance_falloff( "tf_weapon_minicrits_distance_falloff", "0", FCVAR_CHEAT, "Mini-crit weapon damage will take distance into account." );
ConVar mp_spectators_restricted( "mp_spectators_restricted", "0", FCVAR_NONE, "Prevent players on game teams from joining team spectator if it would unbalance the teams." );
ConVar tf_test_special_ducks( "tf_test_special_ducks", "1", FCVAR_DEVELOPMENTONLY );
ConVar tf_mm_abandoned_players_per_team_max( "tf_mm_abandoned_players_per_team_max", "1", FCVAR_DEVELOPMENTONLY );
#endif // GAME_DLL
ConVar tf_mm_next_map_vote_time( "tf_mm_next_map_vote_time", "30", FCVAR_REPLICATED );
#ifdef STAGING_ONLY
#ifdef GAME_DLL
void cc_tf_truce_changed( IConVar *pConVar, const char *pOldString, float flOldValue )
{
if ( TFGameRules() )
{
TFGameRules()->RecalculateTruce();
}
}
#endif // GAME_DLL
ConVar tf_truce( "tf_truce", "0", FCVAR_REPLICATED, "Force a team truce on or off.", true, 0, true, 1
#ifdef GAME_DLL
, cc_tf_truce_changed
#endif // GAME_DLL
);
#endif // STAGING_ONLY
static float g_fEternaweenAutodisableTime = 0.0f;
ConVar tf_spec_xray( "tf_spec_xray", "1", FCVAR_NOTIFY | FCVAR_REPLICATED, "Allows spectators to see player glows. 1 = same team, 2 = both teams" );
ConVar tf_spawn_glows_duration( "tf_spawn_glows_duration", "10", FCVAR_NOTIFY | FCVAR_REPLICATED, "How long should teammates glow after respawning\n" );
#ifdef GAME_DLL
void cc_tf_forced_holiday_changed( IConVar *pConVar, const char *pOldString, float flOldValue )
{
// Tell the listeners to recalculate the holiday
IGameEvent *event = gameeventmanager->CreateEvent( "recalculate_holidays" );
if ( event )
{
gameeventmanager->FireEvent( event );
}
}
#endif // GAME_DLL
ConVar tf_forced_holiday( "tf_forced_holiday", "0", FCVAR_REPLICATED, "Forced holiday, \n Birthday = 1\n Halloween = 2\n" // Christmas = 3\n Valentines = 4\n MeetThePyro = 5\n FullMoon=6
#ifdef GAME_DLL
, cc_tf_forced_holiday_changed
#endif // GAME_DLL
);
ConVar tf_item_based_forced_holiday( "tf_item_based_forced_holiday", "0", FCVAR_REPLICATED, "" // like a clone of tf_forced_holiday, but controlled by client consumable item use
#ifdef GAME_DLL
, cc_tf_forced_holiday_changed
#endif // GAME_DLL
);
ConVar tf_force_holidays_off( "tf_force_holidays_off", "0", FCVAR_NOTIFY | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, ""
#ifdef GAME_DLL
, cc_tf_forced_holiday_changed
#endif // GAME_DLL
);
ConVar tf_birthday( "tf_birthday", "0", FCVAR_NOTIFY | FCVAR_REPLICATED );
ConVar tf_spells_enabled( "tf_spells_enabled", "0", FCVAR_NOTIFY | FCVAR_REPLICATED, "Enable to Allow Halloween Spells to be dropped and used by players" );
ConVar tf_caplinear( "tf_caplinear", "1", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "If set to 1, teams must capture control points linearly." );
ConVar tf_stalematechangeclasstime( "tf_stalematechangeclasstime", "20", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "Amount of time that players are allowed to change class in stalemates." );
ConVar mp_tournament_redteamname( "mp_tournament_redteamname", "RED", FCVAR_REPLICATED | FCVAR_HIDDEN );
ConVar mp_tournament_blueteamname( "mp_tournament_blueteamname", "BLU", FCVAR_REPLICATED | FCVAR_HIDDEN );
//tagES revisit this later
ConVar tf_attack_defend_map( "tf_attack_defend_map", "0", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY );
#ifdef GAME_DLL
void cc_tf_stopwatch_changed( IConVar *pConVar, const char *pOldString, float flOldValue )
{
IGameEvent *event = gameeventmanager->CreateEvent( "stop_watch_changed" );
if ( event )
{
gameeventmanager->FireEvent( event );
}
}
#endif // GAME_DLL
ConVar mp_tournament_stopwatch( "mp_tournament_stopwatch", "1", FCVAR_REPLICATED | FCVAR_NOTIFY, "Use Stopwatch mode while using Tournament mode (mp_tournament)"
#ifdef GAME_DLL
, cc_tf_stopwatch_changed
#endif
);
ConVar mp_tournament_readymode( "mp_tournament_readymode", "0", FCVAR_REPLICATED | FCVAR_NOTIFY, "Enable per-player ready status for tournament mode." );
ConVar mp_tournament_readymode_min( "mp_tournament_readymode_min", "2", FCVAR_REPLICATED | FCVAR_NOTIFY, "Minimum number of players required on the server before players can toggle ready status." );
ConVar mp_tournament_readymode_team_size( "mp_tournament_readymode_team_size", "0", FCVAR_REPLICATED | FCVAR_NOTIFY, "Minimum number of players required to be ready per-team before the game can begin." );
ConVar mp_tournament_readymode_countdown( "mp_tournament_readymode_countdown", "10", FCVAR_REPLICATED | FCVAR_NOTIFY, "The number of seconds before a match begins when both teams are ready." );
ConVar mp_windifference( "mp_windifference", "0", FCVAR_REPLICATED | FCVAR_NOTIFY, "Score difference between teams before server changes maps", true, 0, false, 0 );
ConVar mp_windifference_min( "mp_windifference_min", "0", FCVAR_REPLICATED | FCVAR_NOTIFY, "Minimum score needed for mp_windifference to be applied", true, 0, false, 0 );
ConVar tf_tournament_classlimit_scout( "tf_tournament_classlimit_scout", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Scouts.\n" );
ConVar tf_tournament_classlimit_sniper( "tf_tournament_classlimit_sniper", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Snipers.\n" );
ConVar tf_tournament_classlimit_soldier( "tf_tournament_classlimit_soldier", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Soldiers.\n" );
ConVar tf_tournament_classlimit_demoman( "tf_tournament_classlimit_demoman", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Demomenz.\n" );
ConVar tf_tournament_classlimit_medic( "tf_tournament_classlimit_medic", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Medics.\n" );
ConVar tf_tournament_classlimit_heavy( "tf_tournament_classlimit_heavy", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Heavies.\n" );
ConVar tf_tournament_classlimit_pyro( "tf_tournament_classlimit_pyro", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Pyros.\n" );
ConVar tf_tournament_classlimit_spy( "tf_tournament_classlimit_spy", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Spies.\n" );
ConVar tf_tournament_classlimit_engineer( "tf_tournament_classlimit_engineer", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Engineers.\n" );
ConVar tf_tournament_classchange_allowed( "tf_tournament_classchange_allowed", "1", FCVAR_REPLICATED, "Allow players to change class while the game is active?.\n" );
ConVar tf_tournament_classchange_ready_allowed( "tf_tournament_classchange_ready_allowed", "1", FCVAR_REPLICATED, "Allow players to change class after they are READY?.\n" );
ConVar tf_classlimit( "tf_classlimit", "0", FCVAR_REPLICATED | FCVAR_NOTIFY, "Limit on how many players can be any class (i.e. tf_class_limit 2 would limit 2 players per class).\n", true, 0.f, false, 0.f );
ConVar tf_player_movement_restart_freeze( "tf_player_movement_restart_freeze", "1", FCVAR_REPLICATED, "When set, prevent player movement during round restart" );
ConVar tf_autobalance_query_lifetime( "tf_autobalance_query_lifetime", "30", FCVAR_REPLICATED );
ConVar tf_autobalance_xp_bonus( "tf_autobalance_xp_bonus", "150", FCVAR_REPLICATED );
//tagES
#ifdef STAGING_ONLY
ConVar tf_test_match_summary( "tf_test_match_summary", "0", FCVAR_REPLICATED );
#ifdef GAME_DLL
void cc_tf_fake_mm_changed( IConVar *pConVar, const char *pOldString, float flOldValue )
{
ConVarRef var( pConVar );
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( (EMatchGroup)var.GetInt() );
if ( pMatchDesc )
{
pMatchDesc->InitServerSettingsForMatch( NULL );
}
}
#endif // GAME_DLL
ConVar tf_fake_mm_group( "tf_fake_mm_group", "-1", FCVAR_REPLICATED, "Fake what kind of MM group is being played"
#ifdef GAME_DLL
, cc_tf_fake_mm_changed
#endif // GAME_DLL
);
#endif // STAGING_ONLY
#ifdef GAME_DLL
static const float g_flStrangeEventBatchProcessInterval = 30.0f;
ConVar mp_humans_must_join_team("mp_humans_must_join_team", "any", FCVAR_REPLICATED, "Restricts human players to a single team {any, blue, red, spectator}" );
void cc_tf_medieval_changed( IConVar *pConVar, const char *pOldString, float flOldValue )
{
ConVarRef var( pConVar );
bool bOldValue = flOldValue > 0;
if ( var.IsValid() && ( bOldValue != var.GetBool() ) )
{
Msg( "Medieval mode changes take effect after the next map change.\n" );
}
}
#endif
ConVar tf_medieval( "tf_medieval", "0", FCVAR_REPLICATED | FCVAR_NOTIFY, "Enable Medieval Mode.\n", true, 0, true, 1
#ifdef GAME_DLL
, cc_tf_medieval_changed
#endif
);
ConVar tf_medieval_autorp( "tf_medieval_autorp", "1", FCVAR_REPLICATED | FCVAR_NOTIFY, "Enable Medieval Mode auto-roleplaying.\n", true, 0, true, 1 );
ConVar tf_sticky_radius_ramp_time( "tf_sticky_radius_ramp_time", "2.0", FCVAR_DEVELOPMENTONLY | FCVAR_CHEAT | FCVAR_REPLICATED, "Amount of time to get full radius after arming" );
ConVar tf_sticky_airdet_radius( "tf_sticky_airdet_radius", "0.85", FCVAR_DEVELOPMENTONLY | FCVAR_CHEAT | FCVAR_REPLICATED, "Radius Scale if detonated in the air" );
#ifdef STAGING_ONLY
ConVar tf_killstreak_alwayson( "tf_killstreak_alwayson", "0", FCVAR_REPLICATED, "enable to have killstreak effects for all players, bots included");
#ifdef GAME_DLL
// Bounty Mode
ConVar tf_bountymode_currency_starting( "tf_bountymode_currency_starting", "1000", FCVAR_ARCHIVE, "How much new players start with when playing Bounty Mode.\n" );
ConVar tf_bountymode_currency_limit( "tf_bountymode_currency_limit", "0", FCVAR_ARCHIVE, "The maximum amount a player can hold in Bounty Mode.\n" );
ConVar tf_bountymode_currency_penalty_ondeath( "tf_bountymode_currency_penalty_ondeath", "0", FCVAR_ARCHIVE, "The percentage of unspent money players lose when they die in Bounty Mode.\n" );
ConVar tf_bountymode_upgrades_wipeondeath( "tf_bountymode_upgrades_wipeondeath", "0", FCVAR_ARCHIVE, "If set to true, wipe player/item upgrades on death.\n" );
void cc_bountymode_changed( IConVar *pConVar, const char *pOldString, float flOldValue )
{
ConVarRef var( pConVar );
if ( var.IsValid() && TFGameRules() )
{
TFGameRules()->SetBountyMode( var.GetBool() );
if ( TFGameRules()->IsMannVsMachineMode() )
return;
mp_restartgame_immediate.SetValue( 1 );
if ( !g_pPopulationManager )
{
CreateEntityByName( "info_populator" );
}
int nCurrency = tf_bountymode_currency_starting.GetInt();
if ( nCurrency > 0 )
{
// Give everyone starting money
for ( int i = 0; i <= MAX_PLAYERS; ++i )
{
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( !pPlayer )
continue;
pPlayer->SetCurrency( nCurrency );
}
}
g_MannVsMachineUpgrades.LoadUpgradesFile();
IGameEvent *pEvent = gameeventmanager->CreateEvent( "upgrades_file_changed" );
if ( pEvent )
{
pEvent->SetString( "path", "" ); // Have the client load the default
gameeventmanager->FireEvent( pEvent );
}
}
}
#endif // GAME_DLL
ConVar tf_bountymode( "tf_bountymode", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_ARCHIVE, "Allow upgrades and award currency for mission objectives and killing enemy players.\n", true, 0, true, 1
#ifdef GAME_DLL
, cc_bountymode_changed
#endif // GAME_DLL
);
#endif // STAGING_ONLY
#ifndef GAME_DLL
extern ConVar cl_burninggibs;
extern ConVar english;
ConVar tf_particles_disable_weather( "tf_particles_disable_weather", "0", FCVAR_ARCHIVE, "Disable particles related to weather effects." );
#endif
// arena mode cvars
ConVar tf_arena_force_class( "tf_arena_force_class", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY | FCVAR_CHEAT, "Forces players to play a random class each time they spawn." );
ConVar tf_arena_change_limit( "tf_arena_change_limit", "1", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY | FCVAR_CHEAT, "Number of times players can change their class when mp_force_random_class is being used." );
ConVar tf_arena_override_cap_enable_time( "tf_arena_override_cap_enable_time", "-1", FCVAR_REPLICATED | FCVAR_NOTIFY, "Overrides the time (in seconds) it takes for the capture point to become enable, -1 uses the level designer specified time." );
ConVar tf_arena_override_team_size( "tf_arena_override_team_size", "0", FCVAR_REPLICATED, "Overrides the maximum team size in arena mode. Set to zero to keep the default behavior of 1/3 maxplayers.");
ConVar tf_arena_first_blood( "tf_arena_first_blood", "1", FCVAR_REPLICATED | FCVAR_NOTIFY, "Rewards the first player to get a kill each round." );
extern ConVar tf_arena_preround_time;
extern ConVar tf_arena_max_streak;
#if defined( _DEBUG ) || defined( STAGING_ONLY )
extern ConVar mp_developer;
#endif // _DEBUG || STAGING_ONLY
//=============================================================================
// HPE_BEGIN
// [msmith] Used for the client to tell the server that we're watching a movie or not.
// Also contains the name of a movie if it's an in game video.
//=============================================================================
// Training mode cvars
ConVar tf_training_client_message( "tf_training_client_message", "0", FCVAR_REPLICATED | FCVAR_CHEAT, "A simple way for the training client to communicate with the server." );
//=============================================================================
// HPE_END
//=============================================================================
#define TF_ARENA_MODE_FIRST_BLOOD_CRIT_TIME 5.0f
#define TF_ARENA_MODE_FAST_FIRST_BLOOD_TIME 20.0f
#define TF_ARENA_MODE_SLOW_FIRST_BLOOD_TIME 50.0f
#ifdef TF_RAID_MODE
// Raid mode
ConVar tf_gamemode_raid( "tf_gamemode_raid", "0", FCVAR_REPLICATED | FCVAR_NOTIFY ); // client needs access to this for IsRaidMode()
ConVar tf_raid_enforce_unique_classes( "tf_raid_enforce_unique_classes", "0", FCVAR_REPLICATED | FCVAR_NOTIFY );
ConVar tf_raid_respawn_time( "tf_raid_respawn_time", "5", FCVAR_REPLICATED | FCVAR_NOTIFY /*| FCVAR_CHEAT*/, "How long it takes for a Raider to respawn with his team after death." );
ConVar tf_raid_allow_all_classes( "tf_raid_allow_all_classes", "1", FCVAR_REPLICATED | FCVAR_NOTIFY );
ConVar tf_gamemode_boss_battle( "tf_gamemode_boss_battle", "0", FCVAR_REPLICATED | FCVAR_NOTIFY );
#ifdef GAME_DLL
ConVar tf_raid_allow_overtime( "tf_raid_allow_overtime", "0"/*, FCVAR_CHEAT*/ );
#endif // GAME_DLL
#endif // TF_RAID_MODE
enum { kMVM_MaxConnectedPlayers = 10, };
ConVar tf_mvm_min_players_to_start( "tf_mvm_min_players_to_start", "3", FCVAR_REPLICATED | FCVAR_NOTIFY, "Minimum number of players connected to start a countdown timer" );
ConVar tf_mvm_respec_enabled( "tf_mvm_respec_enabled", "1", FCVAR_CHEAT | FCVAR_REPLICATED, "Allow players to refund credits spent on player and item upgrades." );
ConVar tf_mvm_respec_limit( "tf_mvm_respec_limit", "0", FCVAR_CHEAT | FCVAR_REPLICATED, "The total number of respecs a player can earn. Default: 0 (no limit).", true, 0.f, true, 100.f );
ConVar tf_mvm_respec_credit_goal( "tf_mvm_respec_credit_goal", "2000", FCVAR_CHEAT | FCVAR_REPLICATED, "When tf_mvm_respec_limit is non-zero, the total amount of money the team must collect to earn a respec credit." );
#ifdef STAGING_ONLY
ConVar tf_mvm_buybacks_method( "tf_mvm_buybacks_method", "1", FCVAR_REPLICATED | FCVAR_HIDDEN, "When set to 0, use the traditional, currency-based system. When set to 1, use finite, charge-based system.", true, 0.0, true, 1.0 );
#else
ConVar tf_mvm_buybacks_method( "tf_mvm_buybacks_method", "0", FCVAR_REPLICATED | FCVAR_HIDDEN, "When set to 0, use the traditional, currency-based system. When set to 1, use finite, charge-based system.", true, 0.0, true, 1.0 );
#endif
ConVar tf_mvm_buybacks_per_wave( "tf_mvm_buybacks_per_wave", "3", FCVAR_REPLICATED | FCVAR_HIDDEN, "The fixed number of buybacks players can use per-wave." );
#ifdef GAME_DLL
enum { kMVM_CurrencyPackMinSize = 1, };
#endif // GAME_DLL
extern ConVar mp_tournament;
extern ConVar mp_tournament_post_match_period;
extern ConVar tf_flag_return_on_touch;
extern ConVar tf_flag_return_time_credit_factor;
ConVar tf_grapplinghook_enable( "tf_grapplinghook_enable", "0", FCVAR_REPLICATED );
#ifdef GAME_DLL
CUtlString s_strNextMvMPopFile;
CON_COMMAND_F( tf_mvm_popfile, "Change to a target popfile for MvM", FCVAR_GAMEDLL )
{
// Listenserver host or rcon access only!
if ( !UTIL_IsCommandIssuedByServerAdmin() )
return;
if ( args.ArgC() <= 1 )
{
if ( TFGameRules() && g_pPopulationManager )
{
const char *pszFile = g_pPopulationManager->GetPopulationFilename();
if ( pszFile && pszFile[0] )
{
Msg( "Current popfile is: %s\n", pszFile );
return;
}
}
Msg( "Missing Popfile name\n" );
return;
}
const char *pszShortName = args.Arg(1);
if ( !TFGameRules() || !g_pPopulationManager )
{
Warning( "Cannot set population file before map load.\n" );
return;
}
// Make sure we have a file system
if ( !g_pFullFileSystem )
{
Msg( "No File System to find Popfile to load\n" );
return;
}
// Form full path
CUtlString fullPath;
if ( g_pPopulationManager->FindPopulationFileByShortName( pszShortName, fullPath ) )
{
g_pPopulationManager->SetPopulationFilename( fullPath );
g_pPopulationManager->ResetMap();
return;
}
// Give them a message to make it clear what file we were looking for
Warning( "Could not find a population file matching: %s.\n", pszShortName );
}
#ifdef STAGING_ONLY
// Never ship this
CON_COMMAND_F( tf_competitive_mode_force_victory, "For testing.", FCVAR_GAMEDLL )
{
// Listenserver host or rcon access only!
if ( !UTIL_IsCommandIssuedByServerAdmin() )
return;
CTFPlayer *pPlayer = ToTFPlayer( UTIL_GetCommandClient() );
if ( !pPlayer )
return;
CSteamID steamIDForPlayer;
if ( !pPlayer->GetSteamID( &steamIDForPlayer ) )
return;
// TODO: Rewrite this based on the shipping version of comp/casual
}
#endif // STAGING_ONLY
#endif
static bool BIsCvarIndicatingHolidayIsActive( int iCvarValue, /*EHoliday*/ int eHoliday )
{
if ( iCvarValue == 0 )
return false;
// Unfortunately Holidays are not a proper bitfield
switch ( eHoliday )
{
case kHoliday_TFBirthday: return iCvarValue == kHoliday_TFBirthday;
case kHoliday_Halloween: return iCvarValue == kHoliday_Halloween || iCvarValue == kHoliday_HalloweenOrFullMoon || iCvarValue == kHoliday_HalloweenOrFullMoonOrValentines;
case kHoliday_Christmas: return iCvarValue == kHoliday_Christmas;
case kHoliday_Valentines: return iCvarValue == kHoliday_Valentines || iCvarValue == kHoliday_HalloweenOrFullMoonOrValentines;
case kHoliday_MeetThePyro: return iCvarValue == kHoliday_MeetThePyro;
case kHoliday_FullMoon: return iCvarValue == kHoliday_FullMoon || iCvarValue == kHoliday_HalloweenOrFullMoon || iCvarValue == kHoliday_HalloweenOrFullMoonOrValentines;
case kHoliday_HalloweenOrFullMoon: return iCvarValue == kHoliday_Halloween || iCvarValue == kHoliday_FullMoon || iCvarValue == kHoliday_HalloweenOrFullMoon || iCvarValue == kHoliday_HalloweenOrFullMoonOrValentines;
case kHoliday_HalloweenOrFullMoonOrValentines: return iCvarValue == kHoliday_Halloween || iCvarValue == kHoliday_FullMoon || iCvarValue == kHoliday_Valentines || iCvarValue == kHoliday_HalloweenOrFullMoon || iCvarValue == kHoliday_HalloweenOrFullMoonOrValentines;
case kHoliday_AprilFools: return iCvarValue == kHoliday_AprilFools;
case kHoliday_EOTL: return iCvarValue == kHoliday_EOTL;
case kHoliday_CommunityUpdate: return iCvarValue == kHoliday_CommunityUpdate;
}
return false;
}
// Fetch holiday setting taking into account convars, etc, but NOT
// taking into consideration the current game rules, map, etc.
//
// This version can be used outside of gameplay, ie., for matchmaking
bool TF_IsHolidayActive( /*EHoliday*/ int eHoliday )
{
if ( IsX360() || tf_force_holidays_off.GetBool() )
return false;
if ( BIsCvarIndicatingHolidayIsActive( tf_forced_holiday.GetInt(), eHoliday ) )
return true;
if ( BIsCvarIndicatingHolidayIsActive( tf_item_based_forced_holiday.GetInt(), eHoliday ) )
return true;
if ( ( eHoliday == kHoliday_TFBirthday ) && tf_birthday.GetBool() )
return true;
if ( TFGameRules() )
{
if ( eHoliday == kHoliday_HalloweenOrFullMoon )
{
if ( TFGameRules()->IsHolidayMap( kHoliday_Halloween ) )
return true;
if ( TFGameRules()->IsHolidayMap( kHoliday_FullMoon ) )
return true;
}
if ( TFGameRules()->IsHolidayMap( eHoliday ) )
{
return true;
}
}
return UTIL_IsHolidayActive( eHoliday );
}
#ifdef TF_CREEP_MODE
ConVar tf_gamemode_creep_wave( "tf_gamemode_creep_wave", "0", FCVAR_REPLICATED | FCVAR_NOTIFY );
ConVar tf_creep_wave_player_respawn_time( "tf_creep_wave_player_respawn_time", "10", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_CHEAT, "How long it takes for a player to respawn with his team after death." );
#endif
#ifdef GAME_DLL
// TF overrides the default value of this convar
#ifdef _DEBUG
#define WAITING_FOR_PLAYERS_FLAGS 0
#else
#define WAITING_FOR_PLAYERS_FLAGS FCVAR_DEVELOPMENTONLY
#endif
ConVar hide_server( "hide_server", "0", FCVAR_GAMEDLL, "Whether the server should be hidden from the master server" );
ConVar mp_waitingforplayers_time( "mp_waitingforplayers_time", (IsX360()?"15":"30"), FCVAR_GAMEDLL | WAITING_FOR_PLAYERS_FLAGS, "WaitingForPlayers time length in seconds" );
ConVar tf_gamemode_arena ( "tf_gamemode_arena", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_gamemode_cp ( "tf_gamemode_cp", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_gamemode_ctf ( "tf_gamemode_ctf", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_gamemode_sd ( "tf_gamemode_sd", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_gamemode_rd ( "tf_gamemode_rd", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_gamemode_pd ( "tf_gamemode_pd", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_gamemode_tc ( "tf_gamemode_tc", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_beta_content ( "tf_beta_content", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_gamemode_payload ( "tf_gamemode_payload", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_gamemode_mvm ( "tf_gamemode_mvm", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_gamemode_passtime ( "tf_gamemode_passtime", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_gamemode_misc ( "tf_gamemode_misc", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_bot_count( "tf_bot_count", "0", FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
#ifdef _DEBUG
ConVar tf_debug_ammo_and_health( "tf_debug_ammo_and_health", "0", FCVAR_CHEAT );
#endif // _DEBUG
static Vector s_BotSpawnPosition;
ConVar tf_gravetalk( "tf_gravetalk", "1", FCVAR_NOTIFY, "Allows living players to hear dead players using text/voice chat.", true, 0, true, 1 );
ConVar tf_ctf_bonus_time ( "tf_ctf_bonus_time", "10", FCVAR_NOTIFY, "Length of team crit time for CTF capture." );
#ifdef _DEBUG
ConVar mp_scrambleteams_debug( "mp_scrambleteams_debug", "0", FCVAR_NONE, "Debug spew." );
#endif // _DEBUG
#ifdef STAGING_ONLY
ConVar mp_tournament_readymode_bots_allowed( "mp_tournament_readymode_bots_allowed", "0", FCVAR_ARCHIVE, "Allow bot data to go through the system for debugging." );
#endif // STAGING_ONLY
extern ConVar tf_mm_servermode;
extern ConVar tf_flag_caps_per_round;
void cc_competitive_mode( IConVar *pConVar, const char *pOldString, float flOldValue )
{
IGameEvent *event = gameeventmanager->CreateEvent( "competitive_state_changed" );
if ( event )
{
// Server-side here. Client-side down below in the RecvProxy
gameeventmanager->FireEvent( event, true );
}
}
ConVar tf_competitive_preround_duration( "tf_competitive_preround_duration", "3", FCVAR_REPLICATED, "How long we stay in pre-round when in competitive games." );
ConVar tf_competitive_preround_countdown_duration( "tf_competitive_preround_countdown_duration", "10.5", FCVAR_HIDDEN, "How long we stay in countdown when in competitive games." );
ConVar tf_competitive_abandon_method( "tf_competitive_abandon_method", "0", FCVAR_HIDDEN );
ConVar tf_competitive_required_late_join_timeout( "tf_competitive_required_late_join_timeout", "120", FCVAR_DEVELOPMENTONLY,
"How long to wait for late joiners in matches requiring full player counts before canceling the match" );
ConVar tf_competitive_required_late_join_confirm_timeout( "tf_competitive_required_late_join_confirm_timeout", "30", FCVAR_DEVELOPMENTONLY,
"How long to wait for the GC to confirm we're in the late join pool before canceling the match" );
#endif // GAME_DLL
#ifdef GAME_DLL
void cc_powerup_mode( IConVar *pConVar, const char *pOldString, float flOldValue )
{
ConVarRef var( pConVar );
if ( var.IsValid() )
{
if ( !TFGameRules() )
return;
if ( var.GetBool() )
{
if ( TFGameRules()->IsMannVsMachineMode() )
return;
}
TFGameRules()->SetPowerupMode( var.GetBool() );
TFGameRules()->State_Transition( GR_STATE_PREROUND );
tf_flag_caps_per_round.SetValue( var.GetBool() ? 7 : 3 ); // Hack
}
}
ConVar tf_powerup_mode( "tf_powerup_mode", "0", FCVAR_NOTIFY, "Enable/disable powerup mode. Not compatible with Mann Vs Machine mode", cc_powerup_mode );
ConVar tf_powerup_mode_imbalance_delta( "tf_powerup_mode_imbalance_delta", "24", FCVAR_CHEAT, "Powerup kill score lead one team must have before imbalance measures are initiated" );
ConVar tf_skillrating_update_interval( "tf_skillrating_update_interval", "180", FCVAR_ARCHIVE, "How often to update the GC and OGS." );
extern ConVar mp_teams_unbalance_limit;
static bool g_bRandomMap = false;
void cc_RandomMap( const CCommand& args )
{
CTFGameRules *pRules = TFGameRules();
if ( pRules )
{
if ( !UTIL_IsCommandIssuedByServerAdmin() )
return;
g_bRandomMap = true;
}
else
{
// There's no game rules object yet, so let's load the map cycle and pick a map.
char mapcfile[MAX_PATH];
CMultiplayRules::DetermineMapCycleFilename( mapcfile, sizeof(mapcfile), true );
if ( !mapcfile[0] )
{
Msg( "No mapcyclefile specified. Cannot pick a random map.\n" );
return;
}
CUtlVector<char*> mapList;
// No gamerules entity yet, since we don't need the fixups to find a map just use the base version
CMultiplayRules::RawLoadMapCycleFileIntoVector ( mapcfile, mapList );
if ( !mapList.Count() )
{
Msg( "Map cycle file \"%s\" contains no valid maps or cannot be read. Cannot pick a random map.\n", mapcfile );
return;
}
int iMapIndex = RandomInt( 0, mapList.Count() - 1 );
Msg ( "randommap: selecting map %i out of %i\n", iMapIndex + 1, mapList.Count() );
engine->ServerCommand( UTIL_VarArgs( "map %s\n", mapList[iMapIndex] ) );
CMultiplayRules::FreeMapCycleFileVector( mapList );
}
}
// Simple class for tracking previous gamemode across level transitions
// Allows clean-up of UI/state when going between things like MvM and PvP
class CTFGameModeHistory : public CAutoGameSystem
{
public:
virtual bool Init()
{
m_nPrevState = 0;
return true;
}
void SetPrevState( int nState ) { m_nPrevState = nState; }
int GetPrevState( void ) { return m_nPrevState; }
private:
int m_nPrevState;
} g_TFGameModeHistory;
static ConCommand randommap( "randommap", cc_RandomMap, "Changelevel to a random map in the mapcycle file" );
#endif // GAME_DLL
#ifdef GAME_DLL
static bool PlayerHasDuckStreaks( CTFPlayer *pPlayer )
{
CEconItemView *pActionItem = pPlayer->GetEquippedItemForLoadoutSlot( LOADOUT_POSITION_ACTION );
if ( !pActionItem )
return false;
// Duck Badge Cooldown is based on badge level. Noisemaker is more like an easter egg
static CSchemaAttributeDefHandle pAttr_DuckStreaks( "duckstreaks active" );
uint32 iDuckStreaksActive = 0;
// Don't care about the level, just if the attribute is found
return FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pActionItem, pAttr_DuckStreaks, &iDuckStreaksActive ) && iDuckStreaksActive > 0;
}
void ValidateCapturesPerRound( IConVar *pConVar, const char *oldValue, float flOldValue )
{
ConVarRef var( pConVar );
if ( var.GetInt() <= 0 )
{
// reset the flag captures being played in the current round
int nTeamCount = TFTeamMgr()->GetTeamCount();
for ( int iTeam = FIRST_GAME_TEAM; iTeam < nTeamCount; ++iTeam )
{
CTFTeam *pTeam = GetGlobalTFTeam( iTeam );
if ( !pTeam )
continue;
pTeam->SetFlagCaptures( 0 );
}
}
}
static void Coaching_Start( CTFPlayer *pCoach, CTFPlayer *pStudent )
{
pCoach->SetIsCoaching( true );
pCoach->ForceChangeTeam( TEAM_SPECTATOR );
pCoach->SetObserverTarget( pStudent );
pCoach->StartObserverMode( OBS_MODE_CHASE );
pCoach->SetStudent( pStudent );
pStudent->SetCoach( pCoach );
}
static void Coaching_Stop( CTFPlayer *pCoach )
{
CTFPlayer *pStudent = pCoach->GetStudent();
if ( pStudent )
{
pStudent->SetCoach( NULL );
}
pCoach->SetIsCoaching( false );
pCoach->SetStudent( NULL );
pCoach->ForceChangeTeam( TEAM_SPECTATOR );
}
#endif
ConVar tf_flag_caps_per_round( "tf_flag_caps_per_round", "3", FCVAR_REPLICATED, "Number of captures per round on CTF and PASS Time maps. Set to 0 to disable.", true, 0, false, 0
#ifdef GAME_DLL
, ValidateCapturesPerRound
#endif
);
/**
* Player hull & eye position for standing, ducking, etc. This version has a taller
* player height, but goldsrc-compatible collision bounds.
*/
static CViewVectors g_TFViewVectors(
Vector( 0, 0, 72 ), //VEC_VIEW (m_vView) eye position
Vector(-24, -24, 0 ), //VEC_HULL_MIN (m_vHullMin) hull min
Vector( 24, 24, 82 ), //VEC_HULL_MAX (m_vHullMax) hull max
Vector(-24, -24, 0 ), //VEC_DUCK_HULL_MIN (m_vDuckHullMin) duck hull min
Vector( 24, 24, 62 ), //VEC_DUCK_HULL_MAX (m_vDuckHullMax) duck hull max
Vector( 0, 0, 45 ), //VEC_DUCK_VIEW (m_vDuckView) duck view
Vector( -10, -10, -10 ), //VEC_OBS_HULL_MIN (m_vObsHullMin) observer hull min
Vector( 10, 10, 10 ), //VEC_OBS_HULL_MAX (m_vObsHullMax) observer hull max
Vector( 0, 0, 14 ) //VEC_DEAD_VIEWHEIGHT (m_vDeadViewHeight) dead view height
);
Vector g_TFClassViewVectors[11] =
{
Vector( 0, 0, 72 ), // TF_CLASS_UNDEFINED
Vector( 0, 0, 65 ), // TF_CLASS_SCOUT, // TF_FIRST_NORMAL_CLASS
Vector( 0, 0, 75 ), // TF_CLASS_SNIPER,
Vector( 0, 0, 68 ), // TF_CLASS_SOLDIER,
Vector( 0, 0, 68 ), // TF_CLASS_DEMOMAN,
Vector( 0, 0, 75 ), // TF_CLASS_MEDIC,
Vector( 0, 0, 75 ), // TF_CLASS_HEAVYWEAPONS,
Vector( 0, 0, 68 ), // TF_CLASS_PYRO,
Vector( 0, 0, 75 ), // TF_CLASS_SPY,
Vector( 0, 0, 68 ), // TF_CLASS_ENGINEER,
Vector( 0, 0, 65 ), // TF_CLASS_CIVILIAN, // TF_LAST_NORMAL_CLASS
};
const CViewVectors *CTFGameRules::GetViewVectors() const
{
return &g_TFViewVectors;
}
REGISTER_GAMERULES_CLASS( CTFGameRules );
#ifdef CLIENT_DLL
void RecvProxy_MatchSummary( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
bool bMatchSummary = ( pData->m_Value.m_Int > 0 );
if ( bMatchSummary && !(*(bool*)(pOut)))
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer )
{
pLocalPlayer->TurnOffTauntCam();
pLocalPlayer->TurnOffTauntCam_Finish();;
}
IGameEvent *event = gameeventmanager->CreateEvent( "show_match_summary" );
if ( event )
{
gameeventmanager->FireEventClientSide( event );
}
}
*(bool*)(pOut) = bMatchSummary;
}
void RecvProxy_CompetitiveMode( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
*(bool*)(pOut) = ( pData->m_Value.m_Int > 0 );
IGameEvent *event = gameeventmanager->CreateEvent( "competitive_state_changed" );
if ( event )
{
// Client-side once it's actually happened
gameeventmanager->FireEventClientSide( event );
}
}
void RecvProxy_PlayerVotedForMap( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
if ( *(int*)(pOut) != pData->m_Value.m_Int )
{
*(int*)(pOut) = pData->m_Value.m_Int;
IGameEvent *event = gameeventmanager->CreateEvent( "player_next_map_vote_change" );
if ( event )
{
event->SetInt( "map_index", pData->m_Value.m_Int );
event->SetInt( "vote", pData->m_Value.m_Int );
// Client-side once it's actually happened
gameeventmanager->FireEventClientSide( event );
}
}
}
void RecvProxy_NewMapVoteStateChanged( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
bool bChange = *(int*)(pOut) != pData->m_Value.m_Int;
*(int*)(pOut) = pData->m_Value.m_Int;
if ( bChange )
{
IGameEvent *event = gameeventmanager->CreateEvent( "vote_maps_changed" );
if ( event )
{
// Client-side once it's actually happened
gameeventmanager->FireEventClientSide( event );
}
}
}
#endif
BEGIN_NETWORK_TABLE_NOBASE( CTFGameRules, DT_TFGameRules )
#ifdef CLIENT_DLL
RecvPropInt( RECVINFO( m_nGameType ) ),
RecvPropInt( RECVINFO( m_nStopWatchState ) ),
RecvPropString( RECVINFO( m_pszTeamGoalStringRed ) ),
RecvPropString( RECVINFO( m_pszTeamGoalStringBlue ) ),
RecvPropTime( RECVINFO( m_flCapturePointEnableTime ) ),
//=============================================================================
// HPE_BEGIN:
// [msmith] Training status and HUD Type.
//=============================================================================
RecvPropInt( RECVINFO( m_nHudType ) ),
RecvPropBool( RECVINFO( m_bIsInTraining ) ),
RecvPropBool( RECVINFO( m_bAllowTrainingAchievements ) ),
RecvPropBool( RECVINFO( m_bIsWaitingForTrainingContinue ) ),
//=============================================================================
// HPE_END
//=============================================================================
RecvPropBool( RECVINFO( m_bIsTrainingHUDVisible ) ),
RecvPropBool( RECVINFO( m_bIsInItemTestingMode ) ),
RecvPropEHandle( RECVINFO( m_hBonusLogic ) ),
RecvPropBool( RECVINFO( m_bPlayingKoth ) ),
RecvPropBool( RECVINFO( m_bPlayingMedieval ) ),
RecvPropBool( RECVINFO( m_bPlayingHybrid_CTF_CP ) ),
RecvPropBool( RECVINFO( m_bPlayingSpecialDeliveryMode ) ),
RecvPropBool( RECVINFO( m_bPlayingRobotDestructionMode ) ),
RecvPropEHandle( RECVINFO( m_hRedKothTimer ) ),
RecvPropEHandle( RECVINFO( m_hBlueKothTimer ) ),
RecvPropInt( RECVINFO( m_nMapHolidayType ) ),
RecvPropEHandle( RECVINFO( m_itHandle ) ),
RecvPropBool( RECVINFO( m_bPlayingMannVsMachine ) ),
RecvPropEHandle( RECVINFO( m_hBirthdayPlayer ) ),
RecvPropInt( RECVINFO( m_nBossHealth ) ),
RecvPropInt( RECVINFO( m_nMaxBossHealth ) ),
RecvPropInt( RECVINFO( m_fBossNormalizedTravelDistance ) ),
RecvPropBool( RECVINFO( m_bMannVsMachineAlarmStatus ) ),
RecvPropBool( RECVINFO( m_bHaveMinPlayersToEnableReady ) ),
RecvPropBool( RECVINFO( m_bBountyModeEnabled ) ),
RecvPropInt( RECVINFO( m_nHalloweenEffect ) ),
RecvPropFloat( RECVINFO( m_fHalloweenEffectStartTime ) ),
RecvPropFloat( RECVINFO( m_fHalloweenEffectDuration ) ),
RecvPropInt( RECVINFO( m_halloweenScenario ) ),
RecvPropBool( RECVINFO( m_bHelltowerPlayersInHell ) ),
RecvPropBool( RECVINFO( m_bIsUsingSpells ) ),
RecvPropBool( RECVINFO( m_bCompetitiveMode ), 0, RecvProxy_CompetitiveMode ),
RecvPropInt( RECVINFO( m_nMatchGroupType ) ),
RecvPropBool( RECVINFO( m_bMatchEnded ) ),
RecvPropBool( RECVINFO( m_bPowerupMode ) ),
RecvPropString( RECVINFO( m_pszCustomUpgradesFile ) ),
RecvPropBool( RECVINFO( m_bTruceActive ) ),
RecvPropBool( RECVINFO( m_bShowMatchSummary ), 0, RecvProxy_MatchSummary ),
RecvPropBool( RECVINFO_NAME( m_bShowMatchSummary, "m_bShowCompetitiveMatchSummary" ), 0, RecvProxy_MatchSummary ), // Renamed
RecvPropBool( RECVINFO( m_bTeamsSwitched ) ),
RecvPropBool( RECVINFO( m_bMapHasMatchSummaryStage ) ),
RecvPropBool( RECVINFO( m_bPlayersAreOnMatchSummaryStage ) ),
RecvPropBool( RECVINFO( m_bStopWatchWinner ) ),
RecvPropArray3( RECVINFO_ARRAY(m_ePlayerWantsRematch), RecvPropInt( RECVINFO(m_ePlayerWantsRematch[0]), 0, RecvProxy_PlayerVotedForMap ) ),
RecvPropInt( RECVINFO( m_eRematchState ) ),
RecvPropArray3( RECVINFO_ARRAY(m_nNextMapVoteOptions), RecvPropInt( RECVINFO(m_nNextMapVoteOptions[0]), 0, RecvProxy_NewMapVoteStateChanged ) ),
#else
SendPropInt( SENDINFO( m_nGameType ), 4, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_nStopWatchState ), 3, SPROP_UNSIGNED ),
SendPropString( SENDINFO( m_pszTeamGoalStringRed ) ),
SendPropString( SENDINFO( m_pszTeamGoalStringBlue ) ),
SendPropTime( SENDINFO( m_flCapturePointEnableTime ) ),
//=============================================================================
// HPE_BEGIN:
// [msmith] Training status and hud type.
//=============================================================================
SendPropInt( SENDINFO( m_nHudType ), 3, SPROP_UNSIGNED ),
SendPropBool( SENDINFO( m_bIsInTraining ) ),
SendPropBool( SENDINFO( m_bAllowTrainingAchievements ) ),
SendPropBool( SENDINFO( m_bIsWaitingForTrainingContinue ) ),
//=============================================================================
// HPE_END
//=============================================================================
SendPropBool( SENDINFO( m_bIsTrainingHUDVisible ) ),
SendPropBool( SENDINFO( m_bIsInItemTestingMode ) ),
SendPropEHandle( SENDINFO( m_hBonusLogic ) ),
SendPropBool( SENDINFO( m_bPlayingKoth ) ),
SendPropBool( SENDINFO( m_bPlayingMedieval ) ),
SendPropBool( SENDINFO( m_bPlayingHybrid_CTF_CP ) ),
SendPropBool( SENDINFO( m_bPlayingSpecialDeliveryMode ) ),
SendPropBool( SENDINFO( m_bPlayingRobotDestructionMode ) ),
SendPropEHandle( SENDINFO( m_hRedKothTimer ) ),
SendPropEHandle( SENDINFO( m_hBlueKothTimer ) ),
SendPropInt( SENDINFO( m_nMapHolidayType ), 3, SPROP_UNSIGNED ),
SendPropEHandle( SENDINFO( m_itHandle ) ),
SendPropBool( SENDINFO( m_bPlayingMannVsMachine ) ),
SendPropEHandle( SENDINFO( m_hBirthdayPlayer ) ),
SendPropInt( SENDINFO( m_nBossHealth ) ),
SendPropInt( SENDINFO( m_nMaxBossHealth ) ),
SendPropInt( SENDINFO( m_fBossNormalizedTravelDistance ) ),
SendPropBool( SENDINFO( m_bMannVsMachineAlarmStatus ) ),
SendPropBool( SENDINFO( m_bHaveMinPlayersToEnableReady ) ),
SendPropBool( SENDINFO( m_bBountyModeEnabled ) ),
SendPropInt( SENDINFO( m_nHalloweenEffect ) ),
SendPropFloat( SENDINFO( m_fHalloweenEffectStartTime ) ),
SendPropFloat( SENDINFO( m_fHalloweenEffectDuration ) ),
SendPropInt( SENDINFO( m_halloweenScenario ) ),
SendPropBool( SENDINFO( m_bHelltowerPlayersInHell ) ),
SendPropBool( SENDINFO( m_bIsUsingSpells ) ),
SendPropBool( SENDINFO( m_bCompetitiveMode ) ),
SendPropBool( SENDINFO( m_bPowerupMode ) ),
SendPropInt( SENDINFO( m_nMatchGroupType ) ),
SendPropBool( SENDINFO( m_bMatchEnded ) ),
SendPropString( SENDINFO( m_pszCustomUpgradesFile ) ),
SendPropBool( SENDINFO( m_bTruceActive ) ),
SendPropBool( SENDINFO( m_bShowMatchSummary ) ),
SendPropBool( SENDINFO( m_bTeamsSwitched ) ),
SendPropBool( SENDINFO( m_bMapHasMatchSummaryStage ) ),
SendPropBool( SENDINFO( m_bPlayersAreOnMatchSummaryStage ) ),
SendPropBool( SENDINFO( m_bStopWatchWinner ) ),
SendPropArray3( SENDINFO_ARRAY3(m_ePlayerWantsRematch), SendPropInt( SENDINFO_ARRAY(m_ePlayerWantsRematch), -1, SPROP_UNSIGNED | SPROP_VARINT ) ),
SendPropInt( SENDINFO( m_eRematchState ) ),
SendPropArray3( SENDINFO_ARRAY3(m_nNextMapVoteOptions), SendPropInt( SENDINFO_ARRAY(m_nNextMapVoteOptions), -1, SPROP_UNSIGNED | SPROP_VARINT ) ),
#endif
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_gamerules, CTFGameRulesProxy );
IMPLEMENT_NETWORKCLASS_ALIASED( TFGameRulesProxy, DT_TFGameRulesProxy )
#ifdef CLIENT_DLL
void RecvProxy_TFGameRules( const RecvProp *pProp, void **pOut, void *pData, int objectID )
{
CTFGameRules *pRules = TFGameRules();
Assert( pRules );
*pOut = pRules;
}
BEGIN_RECV_TABLE( CTFGameRulesProxy, DT_TFGameRulesProxy )
RecvPropDataTable( "tf_gamerules_data", 0, 0, &REFERENCE_RECV_TABLE( DT_TFGameRules ), RecvProxy_TFGameRules )
END_RECV_TABLE()
#else
void *SendProxy_TFGameRules( const SendProp *pProp, const void *pStructBase, const void *pData, CSendProxyRecipients *pRecipients, int objectID )
{
CTFGameRules *pRules = TFGameRules();
Assert( pRules );
pRecipients->SetAllRecipients();
return pRules;
}
BEGIN_SEND_TABLE( CTFGameRulesProxy, DT_TFGameRulesProxy )
SendPropDataTable( "tf_gamerules_data", 0, &REFERENCE_SEND_TABLE( DT_TFGameRules ), SendProxy_TFGameRules )
END_SEND_TABLE()
#endif
#ifdef GAME_DLL
BEGIN_DATADESC( CTFGameRulesProxy )
//=============================================================================
// HPE_BEGIN:
// [msmith] Training HUD type
//=============================================================================
DEFINE_KEYFIELD( m_nHudType, FIELD_INTEGER, "hud_type" ),
//=============================================================================
// HPE_END
//=============================================================================
DEFINE_KEYFIELD( m_bOvertimeAllowedForCTF, FIELD_BOOLEAN, "ctf_overtime" ),
// Inputs.
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetRedTeamRespawnWaveTime", InputSetRedTeamRespawnWaveTime ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetBlueTeamRespawnWaveTime", InputSetBlueTeamRespawnWaveTime ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "AddRedTeamRespawnWaveTime", InputAddRedTeamRespawnWaveTime ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "AddBlueTeamRespawnWaveTime", InputAddBlueTeamRespawnWaveTime ),
DEFINE_INPUTFUNC( FIELD_STRING, "SetRedTeamGoalString", InputSetRedTeamGoalString ),
DEFINE_INPUTFUNC( FIELD_STRING, "SetBlueTeamGoalString", InputSetBlueTeamGoalString ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetRedTeamRole", InputSetRedTeamRole ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetBlueTeamRole", InputSetBlueTeamRole ),
DEFINE_INPUTFUNC( FIELD_STRING, "SetRequiredObserverTarget", InputSetRequiredObserverTarget ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "AddRedTeamScore", InputAddRedTeamScore ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "AddBlueTeamScore", InputAddBlueTeamScore ),
DEFINE_INPUTFUNC( FIELD_VOID, "SetRedKothClockActive", InputSetRedKothClockActive ),
DEFINE_INPUTFUNC( FIELD_VOID, "SetBlueKothClockActive", InputSetBlueKothClockActive ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetCTFCaptureBonusTime", InputSetCTFCaptureBonusTime ),
DEFINE_INPUTFUNC( FIELD_STRING, "PlayVORed", InputPlayVORed ),
DEFINE_INPUTFUNC( FIELD_STRING, "PlayVOBlue", InputPlayVOBlue ),
DEFINE_INPUTFUNC( FIELD_STRING, "PlayVO", InputPlayVO ),
DEFINE_INPUTFUNC( FIELD_STRING, "HandleMapEvent", InputHandleMapEvent ),
DEFINE_INPUTFUNC( FIELD_STRING, "SetCustomUpgradesFile", InputSetCustomUpgradesFile ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetRoundRespawnFreezeEnabled", InputSetRoundRespawnFreezeEnabled ),
DEFINE_INPUTFUNC( FIELD_BOOLEAN, "SetMapForcedTruceDuringBossFight", InputSetMapForcedTruceDuringBossFight ),
DEFINE_OUTPUT( m_OnWonByTeam1, "OnWonByTeam1" ),
DEFINE_OUTPUT( m_OnWonByTeam2, "OnWonByTeam2" ),
DEFINE_OUTPUT( m_Team1PlayersChanged, "Team1PlayersChanged" ),
DEFINE_OUTPUT( m_Team2PlayersChanged, "Team2PlayersChanged" ),
DEFINE_OUTPUT( m_OnPowerupImbalanceTeam1, "OnPowerupImbalanceTeam1" ),
DEFINE_OUTPUT( m_OnPowerupImbalanceTeam2, "OnPowerupImbalanceTeam2" ),
DEFINE_OUTPUT( m_OnPowerupImbalanceMeasuresOver, "OnPowerupImbalanceMeasuresOver" ),
DEFINE_OUTPUT( m_OnStateEnterRoundRunning, "OnStateEnterRoundRunning" ),
DEFINE_OUTPUT( m_OnStateEnterBetweenRounds, "OnStateEnterBetweenRounds" ),
DEFINE_OUTPUT( m_OnStateEnterPreRound, "OnStateEnterPreRound" ),
DEFINE_OUTPUT( m_OnStateExitPreRound, "OnStateExitPreRound" ),
DEFINE_OUTPUT( m_OnMatchSummaryStart, "OnMatchSummaryStart" ),
DEFINE_OUTPUT( m_OnTruceStart, "OnTruceStart" ),
DEFINE_OUTPUT( m_OnTruceEnd, "OnTruceEnd" ),
END_DATADESC()
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFGameRulesProxy::CTFGameRulesProxy()
{
m_nHudType = TF_HUDTYPE_UNDEFINED;
m_bOvertimeAllowedForCTF = true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputAddRedTeamScore( inputdata_t &inputdata )
{
TFTeamMgr()->AddTeamScore( TF_TEAM_RED, inputdata.value.Int() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputAddBlueTeamScore( inputdata_t &inputdata )
{
TFTeamMgr()->AddTeamScore( TF_TEAM_BLUE, inputdata.value.Int() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetRedKothClockActive( inputdata_t &inputdata )
{
if ( TFGameRules() )
{
variant_t sVariant;
CTeamRoundTimer *pTimer = TFGameRules()->GetKothTeamTimer( TF_TEAM_BLUE );
if ( pTimer )
{
pTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 );
}
pTimer = TFGameRules()->GetKothTeamTimer( TF_TEAM_RED );
if ( pTimer )
{
pTimer->AcceptInput( "Resume", NULL, NULL, sVariant, 0 );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetCTFCaptureBonusTime( inputdata_t &inputdata )
{
if ( TFGameRules() )
{
TFGameRules()->SetCTFCaptureBonusTime( inputdata.value.Float() );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetBlueKothClockActive( inputdata_t &inputdata )
{
if ( TFGameRules() )
{
variant_t sVariant;
CTeamRoundTimer *pTimer = TFGameRules()->GetKothTeamTimer( TF_TEAM_BLUE );
if ( pTimer )
{
pTimer->AcceptInput( "Resume", NULL, NULL, sVariant, 0 );
}
pTimer = TFGameRules()->GetKothTeamTimer( TF_TEAM_RED );
if ( pTimer )
{
pTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetRequiredObserverTarget( inputdata_t &inputdata )
{
const char *pszEntName = inputdata.value.String();
CBaseEntity *pEnt = NULL;
if ( pszEntName && pszEntName[0] )
{
pEnt = gEntList.FindEntityByName( NULL, pszEntName );
}
TFGameRules()->SetRequiredObserverTarget( pEnt );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetRedTeamRespawnWaveTime( inputdata_t &inputdata )
{
TFGameRules()->SetTeamRespawnWaveTime( TF_TEAM_RED, inputdata.value.Float() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetBlueTeamRespawnWaveTime( inputdata_t &inputdata )
{
TFGameRules()->SetTeamRespawnWaveTime( TF_TEAM_BLUE, inputdata.value.Float() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputAddRedTeamRespawnWaveTime( inputdata_t &inputdata )
{
TFGameRules()->AddTeamRespawnWaveTime( TF_TEAM_RED, inputdata.value.Float() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputAddBlueTeamRespawnWaveTime( inputdata_t &inputdata )
{
TFGameRules()->AddTeamRespawnWaveTime( TF_TEAM_BLUE, inputdata.value.Float() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetRedTeamGoalString( inputdata_t &inputdata )
{
TFGameRules()->SetTeamGoalString( TF_TEAM_RED, inputdata.value.String() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetBlueTeamGoalString( inputdata_t &inputdata )
{
TFGameRules()->SetTeamGoalString( TF_TEAM_BLUE, inputdata.value.String() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetRedTeamRole( inputdata_t &inputdata )
{
CTFTeam *pTeam = TFTeamMgr()->GetTeam( TF_TEAM_RED );
if ( pTeam )
{
pTeam->SetRole( inputdata.value.Int() );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetBlueTeamRole( inputdata_t &inputdata )
{
CTFTeam *pTeam = TFTeamMgr()->GetTeam( TF_TEAM_BLUE );
if ( pTeam )
{
pTeam->SetRole( inputdata.value.Int() );
}
}
//-----------------------------------------------------------------------------
// Purpose: Pass in a VO sound entry to play for RED
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputPlayVORed( inputdata_t &inputdata )
{
const char *szSoundName = inputdata.value.String();
if ( szSoundName )
{
TFGameRules()->BroadcastSound( TF_TEAM_RED, szSoundName );
}
}
//-----------------------------------------------------------------------------
// Purpose: Pass in a VO sound entry to play for BLUE
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputPlayVOBlue( inputdata_t &inputdata )
{
const char *szSoundName = inputdata.value.String();
if ( szSoundName )
{
TFGameRules()->BroadcastSound( TF_TEAM_BLUE, szSoundName );
}
}
//-----------------------------------------------------------------------------
// Purpose: Pass in a VO sound entry to play
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputPlayVO( inputdata_t &inputdata )
{
const char *szSoundName = inputdata.value.String();
if ( szSoundName )
{
TFGameRules()->BroadcastSound( 255, szSoundName );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputHandleMapEvent( inputdata_t &inputdata )
{
if ( TFGameRules() )
{
TFGameRules()->HandleMapEvent( inputdata );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetCustomUpgradesFile( inputdata_t &inputdata )
{
if ( TFGameRules() )
{
TFGameRules()->SetCustomUpgradesFile( inputdata );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetRoundRespawnFreezeEnabled( inputdata_t &inputdata )
{
tf_player_movement_restart_freeze.SetValue( inputdata.value.Bool() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetMapForcedTruceDuringBossFight( inputdata_t &inputdata )
{
if ( TFGameRules() )
{
TFGameRules()->SetMapForcedTruceDuringBossFight( inputdata.value.Bool() );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::Activate()
{
TFGameRules()->Activate();
//=============================================================================
// HPE_BEGIN:
// [msmith] We added a HUDTYPE so that the objective and the HUD are independent.
// This lets us have a non training HUD on a training map. And a training
// HUD on another type of map.
//=============================================================================
if ( m_nHudType != TF_HUDTYPE_UNDEFINED )
{
TFGameRules()->SetHUDType( m_nHudType );
}
//=============================================================================
// HPE_END
//=============================================================================
TFGameRules()->SetOvertimeAllowedForCTF( m_bOvertimeAllowedForCTF );
ListenForGameEvent( "teamplay_round_win" );
BaseClass::Activate();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::TeamPlayerCountChanged( CTFTeam *pTeam )
{
if ( pTeam == TFTeamMgr()->GetTeam( TF_TEAM_RED ) )
{
m_Team1PlayersChanged.Set( pTeam->GetNumPlayers(), this, this );
}
else if ( pTeam == TFTeamMgr()->GetTeam( TF_TEAM_BLUE ) )
{
m_Team2PlayersChanged.Set( pTeam->GetNumPlayers(), this, this );
}
// Tell the clients
IGameEvent *event = gameeventmanager->CreateEvent( "teams_changed" );
if ( event )
{
gameeventmanager->FireEvent( event );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::PowerupTeamImbalance( int nTeam )
{
switch ( nTeam )
{
case TF_TEAM_RED:
m_OnPowerupImbalanceTeam1.FireOutput( this, this );
break;
case TF_TEAM_BLUE:
m_OnPowerupImbalanceTeam2.FireOutput( this, this );
break;
default:
m_OnPowerupImbalanceMeasuresOver.FireOutput( this, this );
break;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::StateEnterRoundRunning( void )
{
m_OnStateEnterRoundRunning.FireOutput( this, this );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::StateEnterBetweenRounds( void )
{
m_OnStateEnterBetweenRounds.FireOutput( this, this );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::StateEnterPreRound( void )
{
m_OnStateEnterPreRound.FireOutput( this, this );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::StateExitPreRound( void )
{
m_OnStateExitPreRound.FireOutput( this, this );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::MatchSummaryStart( void )
{
m_OnMatchSummaryStart.FireOutput( this, this );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::TruceStart( void )
{
m_OnTruceStart.FireOutput( this, this );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::TruceEnd( void )
{
m_OnTruceEnd.FireOutput( this, this );
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::FireGameEvent( IGameEvent *event )
{
#ifdef GAME_DLL
const char *pszEventName = event->GetName();
if ( FStrEq( pszEventName, "teamplay_round_win" ) )
{
int iWinningTeam = event->GetInt( "team" );
switch( iWinningTeam )
{
case TF_TEAM_RED:
m_OnWonByTeam1.FireOutput( this, this );
break;
case TF_TEAM_BLUE:
m_OnWonByTeam2.FireOutput( this, this );
break;
default:
break;
}
}
#endif
}
// (We clamp ammo ourselves elsewhere).
ConVar ammo_max( "ammo_max", "5000", FCVAR_REPLICATED );
#ifndef CLIENT_DLL
ConVar sk_plr_dmg_grenade( "sk_plr_dmg_grenade","0"); // Very lame that the base code needs this defined
#endif
//-----------------------------------------------------------------------------
// Purpose:
// Input : iDmgType -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CTFGameRules::Damage_IsTimeBased( int iDmgType )
{
// Damage types that are time-based.
return ( ( iDmgType & ( DMG_PARALYZE | DMG_NERVEGAS | DMG_DROWNRECOVER ) ) != 0 );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : iDmgType -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CTFGameRules::Damage_ShowOnHUD( int iDmgType )
{
// Damage types that have client HUD art.
return ( ( iDmgType & ( DMG_DROWN | DMG_BURN | DMG_NERVEGAS | DMG_SHOCK ) ) != 0 );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : iDmgType -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CTFGameRules::Damage_ShouldNotBleed( int iDmgType )
{
// Should always bleed currently.
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFGameRules::Damage_GetTimeBased( void )
{
int iDamage = ( DMG_PARALYZE | DMG_NERVEGAS | DMG_DROWNRECOVER );
return iDamage;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFGameRules::Damage_GetShowOnHud( void )
{
int iDamage = ( DMG_DROWN | DMG_BURN | DMG_NERVEGAS | DMG_SHOCK );
return iDamage;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFGameRules::Damage_GetShouldNotBleed( void )
{
return 0;
}
//-----------------------------------------------------------------------------
// Return true if we are playing a PvE mode
//-----------------------------------------------------------------------------
bool CTFGameRules::IsPVEModeActive( void ) const
{
#ifdef TF_RAID_MODE
if ( IsRaidMode() || IsBossBattleMode() )
return true;
#endif
if ( IsMannVsMachineMode() )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Return true for PvE opponents (ie: enemy bot team)
//-----------------------------------------------------------------------------
bool CTFGameRules::IsPVEModeControlled( CBaseEntity *who ) const
{
if ( !who )
{
return false;
}
#ifdef GAME_DLL
if ( IsMannVsMachineMode() )
{
return who->GetTeamNumber() == TF_TEAM_PVE_INVADERS ? true : false;
}
if ( IsPVEModeActive() )
{
return who->GetTeamNumber() == TF_TEAM_RED ? true : false;
}
#endif
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Return true if engineers can build quickly now
//-----------------------------------------------------------------------------
bool CTFGameRules::IsQuickBuildTime( void )
{
return IsMannVsMachineMode() && ( InSetup() || TFObjectiveResource()->GetMannVsMachineIsBetweenWaves() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::GameModeUsesUpgrades( void )
{
if ( IsMannVsMachineMode() || IsBountyMode() )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::CanPlayerUseRespec( CTFPlayer *pTFPlayer )
{
if ( !pTFPlayer )
return false;
bool bAllowed = IsMannVsMachineRespecEnabled() && State_Get() == GR_STATE_BETWEEN_RNDS;
#ifdef GAME_DLL
if ( !g_pPopulationManager )
return false;
bAllowed &= ( g_pPopulationManager->GetNumRespecsAvailableForPlayer( pTFPlayer ) ) ? true : false;
#else
if ( !g_TF_PR )
return false;
bAllowed &= ( g_TF_PR->GetNumRespecCredits( pTFPlayer->entindex() ) ) ? true : false;
#endif
return bAllowed;
}
bool CTFGameRules::IsCompetitiveMode( void ) const
{
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
if ( pMatchDesc )
{
return pMatchDesc->m_params.m_eMatchType == MATCH_TYPE_COMPETITIVE
|| pMatchDesc->m_params.m_eMatchType == MATCH_TYPE_CASUAL;
}
return false;
}
bool CTFGameRules::IsMatchTypeCasual( void ) const
{
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
if ( pMatchDesc )
{
return ( pMatchDesc->m_params.m_eMatchType == MATCH_TYPE_CASUAL );
}
return false;
}
bool CTFGameRules::IsMatchTypeCompetitive( void ) const
{
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
if ( pMatchDesc )
{
return ( pMatchDesc->m_params.m_eMatchType == MATCH_TYPE_COMPETITIVE );
}
return false;
}
bool CTFGameRules::BInMatchStartCountdown() const
{
if ( IsCompetitiveMode() )
{
float flTime = GetRoundRestartTime();
if ( ( flTime > 0.f ) && ( (int)( flTime - gpGlobals->curtime ) <= mp_tournament_readymode_countdown.GetInt() ) )
{
return true;
}
}
return false;
}
EMatchGroup CTFGameRules::GetCurrentMatchGroup() const
{
#if defined STAGING_ONLY && defined CLIENT_DLL
if ( tf_fake_mm_group.GetInt() != -1 )
{
return (EMatchGroup)tf_fake_mm_group.GetInt();
}
#endif
#ifdef GAME_DLL
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
return pMatch ? pMatch->m_eMatchGroup : k_nMatchGroup_Invalid;
#else
// Client
// We only care about what the server says if we are in an MM match. We pass false
// into BConnectedToMatch because we want the match group of the server EVEN IF
// the match is over, but we're still connected.
return GTFGCClientSystem()->BConnectedToMatchServer( false ) ? (EMatchGroup)m_nMatchGroupType.Get() : k_nMatchGroup_Invalid;
#endif
}
bool CTFGameRules::IsManagedMatchEnded() const
{
#ifdef GAME_DLL
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
return !pMatch || pMatch->BMatchTerminated();
#else
// Client
// We only care about what the server says if we are in an MM match. (Note that the GC client system calls this to
// determine if an MM server considers the match over, so beware circular logic)
return !GTFGCClientSystem()->BConnectedToMatchServer( true ) || m_bMatchEnded;
#endif
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
void CTFGameRules::SyncMatchSettings()
{
// These mirror the MatchInfo for the client's sake.
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
m_nMatchGroupType.Set( pMatch ? pMatch->m_eMatchGroup : k_nMatchGroup_Invalid );
m_bMatchEnded.Set( IsManagedMatchEnded() );
}
//-----------------------------------------------------------------------------
bool CTFGameRules::StartManagedMatch()
{
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
if ( !pMatch )
{
Warning( "Starting a managed match with no match info\n" );
return false;
}
// Cleanup
m_eRematchState = NEXT_MAP_VOTE_STATE_NONE;
/// Sync these before level change, so there's no race condition where clients may connect during/before the
/// changelevel and see that the match is ended or wrong.
SyncMatchSettings();
// Change the the correct map from the match. If no match specified, perform a fresh load of the current map
const char *pszMap = pMatch->GetMatchMap();
if ( !pszMap )
{
pszMap = STRING( gpGlobals->mapname );
Warning( "Managed match did not specify map, using current map (%s)\n", pszMap );
}
engine->ServerCommand( CFmtStr( "changelevel %s\n", pszMap ) );
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::SetCompetitiveMode( bool bValue )
{
m_bCompetitiveMode.Set( bValue );
//// Competitive mode is only supported on official servers.
//// It requires matchmaking, and doesn't allow ad-hoc connections.
//// If cheats are ever enabled, we force this mode off.
//tf_mm_trusted.SetValue( bValue );
//mp_tournament.SetValue( bValue );
//mp_tournament_readymode.SetValue( bValue );
//// No ad-hoc connections
//tf_mm_strict.SetValue( bValue );
//if ( bValue )
//{
// engine->ServerCommand( "exec server_ladder.cfg\n" );
// Assert( tf_mm_servermode.GetInt() == 1 );
//}
//// Any state toggle is a reset (so don't spam this call)
//State_Transition( GR_STATE_PREROUND );
//SetInWaitingForPlayers( bValue );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::StartCompetitiveMatch( void )
{
m_flSafeToLeaveTimer = -1.f;
SetInWaitingForPlayers( false );
RoundRespawn();
State_Transition( GR_STATE_RESTART );
ResetPlayerAndTeamReadyState();
}
//-----------------------------------------------------------------------------
// Purpose: Stops a match for some specified reason
//-----------------------------------------------------------------------------
void CTFGameRules::StopCompetitiveMatch( CMsgGC_Match_Result_Status nCode )
{
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
int nActiveMatchPlayers = pMatch->GetNumActiveMatchPlayers();
if ( BAttemptMapVoteRollingMatch() &&
nCode == CMsgGC_Match_Result_Status_MATCH_SUCCEEDED &&
nActiveMatchPlayers > 0 )
{
ChooseNextMapVoteOptions();
}
else
{
// If we're not attempting a rolling match, end it
// TODO ROLLING MATCHES: If we bail between now and RequestNewMatchForLobby, we need to call this or we'll get stuck.
if ( !IsManagedMatchEnded() )
{
GTFGCClientSystem()->EndManagedMatch( /* bKickPlayersToParties */ false );
Assert( IsManagedMatchEnded() );
m_bMatchEnded.Set( true );
}
}
if ( nCode == CMsgGC_Match_Result_Status_MATCH_SUCCEEDED )
{
IGameEvent *winEvent = gameeventmanager->CreateEvent( "competitive_victory" );
if ( winEvent )
{
gameeventmanager->FireEvent( winEvent );
}
//
// This determines new ratings and creates the GC messages
//
CMatchInfo *pInfo = GTFGCClientSystem()->GetMatch();
if ( pInfo )
{
pInfo->CalculateMatchSkillRatingAdjustments( m_iWinningTeam );
// Performance ranking with medals is currently server-side
if ( pInfo->CalculatePlayerMatchRankData() )
{
// Send scoreboard event with final data
int nPlayers = pInfo->GetNumTotalMatchPlayers();
for ( int idx = 0; idx < nPlayers; idx++ )
{
IGameEvent *pEvent = gameeventmanager->CreateEvent( "competitive_stats_update" );
if ( pEvent )
{
CMatchInfo::PlayerMatchData_t *pMatchRankData = pInfo->GetMatchDataForPlayer( idx );
CBasePlayer *pPlayer = UTIL_PlayerBySteamID( pMatchRankData->steamID );
if ( !pPlayer )
continue;
pEvent->SetInt( "index", pPlayer->entindex() );
pEvent->SetInt( "score_rank", pMatchRankData ? pMatchRankData->nScoreMedal : 0 ); // medal won (if any)
pEvent->SetInt( "kills_rank", pMatchRankData ? pMatchRankData->nKillsMedal : 0 ); //
pEvent->SetInt( "damage_rank", pMatchRankData ? pMatchRankData->nDamageMedal : 0 ); //
pEvent->SetInt( "healing_rank", pMatchRankData ? pMatchRankData->nHealingMedal : 0 ); //
pEvent->SetInt( "support_rank", pMatchRankData ? pMatchRankData->nSupportMedal : 0 ); //
gameeventmanager->FireEvent( pEvent );
}
}
}
}
else
{
Warning( "CalculatePlayerMatchRankData(): General failure (investigate).\n" );
}
ReportMatchResultsToGC( nCode );
}
else if ( nCode == CMsgGC_Match_Result_Status_MATCH_FAILED_ABANDON )
{
// This generates a "safe to leave" notification on clients
IGameEvent *pEvent = gameeventmanager->CreateEvent( "player_abandoned_match" );
if ( pEvent )
{
pEvent->SetBool( "game_over", ( tf_competitive_abandon_method.GetBool() || State_Get() == GR_STATE_BETWEEN_RNDS ) );
gameeventmanager->FireEvent( pEvent );
}
ReportMatchResultsToGC( nCode );
}
}
//-----------------------------------------------------------------------------
// Purpose: Fully completes the match
//-----------------------------------------------------------------------------
void CTFGameRules::EndCompetitiveMatch( void )
{
MatchSummaryEnd();
Log( "Competitive match ended. Kicking all players.\n" );
engine->ServerCommand( "kickall #TF_Competitive_Disconnect\n" );
// Prepare for next match
g_fGameOver = false;
m_bAllowBetweenRounds = true;
State_Transition( GR_STATE_RESTART );
SetInWaitingForPlayers( true );
}
//-----------------------------------------------------------------------------
// Purpose: Called during CTFGameRules::Think()
//-----------------------------------------------------------------------------
void CTFGameRules::ManageCompetitiveMode( void )
{
if ( !IsCompetitiveMode() )
return;
// Bring this back when we ship?
// // Security check
// if ( !tf_skillrating_debug.GetBool() )
// {
// m_bCompetitiveMode &= tf_mm_trusted.GetBool() &&
// IsInTournamentMode() &&
// !HaveCheatsBeenEnabledDuringLevel();
// }
// We lost trusted status
if ( !tf_mm_trusted.GetBool() )
{
m_nMatchGroupType.Set( k_nMatchGroup_Invalid );
StopCompetitiveMatch( CMsgGC_Match_Result_Status_MATCH_FAILED_TRUSTED );
UTIL_ClientPrintAll( HUD_PRINTCENTER, "Exiting Competitive Mode!" );
Log( "Server lost trusted status. Exiting Competitive Mode!" );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::ReportMatchResultsToGC( CMsgGC_Match_Result_Status nCode )
{
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
if ( !pMatch )
return false;
GCSDK::CProtoBufMsg< CMsgGC_Match_Result > *pMsg = new GCSDK::CProtoBufMsg< CMsgGC_Match_Result >( k_EMsgGC_Match_Result );
pMsg->Body().set_match_id( pMatch->m_nMatchID );
pMsg->Body().set_match_group( pMatch->m_eMatchGroup );
pMsg->Body().set_status( nCode );
pMsg->Body().set_duration( CTF_GameStats.m_currentMap.m_Header.m_iTotalTime + ( gpGlobals->curtime - m_flRoundStartTime ) );
CTeam *pTeam = GetGlobalTeam( TF_TEAM_RED );
pMsg->Body().set_red_score( pTeam ? pTeam->GetScore() : (uint32)-1 );
pTeam = GetGlobalTeam( TF_TEAM_BLUE );
pMsg->Body().set_blue_score( pTeam ? pTeam->GetScore() : (uint32)-1 );
Assert( m_iWinningTeam >= 0 );
pMsg->Body().set_winning_team( Max( 0, (int)m_iWinningTeam ) );
const MapDef_t *pMap = GetItemSchema()->GetMasterMapDefByName( STRING( gpGlobals->mapname ) );
pMsg->Body().set_map_index( ( pMap ) ? pMap->m_nDefIndex : 0 );
pMsg->Body().set_game_type( 1 ); // TODO: eMapGameType
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( pMatch->m_eMatchGroup );
if( !pMatchDesc || !pMatchDesc->m_pProgressionDesc )
return false;
int nTotalScore = 0;
CTFPlayerResource *pTFResource = dynamic_cast< CTFPlayerResource* >( g_pPlayerResource );
if ( pTFResource )
{
pTFResource->UpdatePlayerData();
for ( int i=0; i < MAX_PLAYERS; ++i )
{
nTotalScore += pTFResource->GetTotalScore( i );
}
}
float flBlueScoreRatio = 0.5f;
const CTFTeam* pTFTeamRed = GetGlobalTFTeam( TF_TEAM_RED );
const CTFTeam* pTFTeamBlue = GetGlobalTFTeam( TF_TEAM_BLUE );
// Figure out how much XP to give each team based on the game mode played
if ( HasMultipleTrains() )
{
// In PLR we want to use the distance along the tracks each of the
// trains were at the end of each round
flBlueScoreRatio = RemapValClamped( pTFTeamBlue->GetTotalPLRTrackPercentTraveled(), 0.f, pTFTeamBlue->GetTotalPLRTrackPercentTraveled() + pTFTeamRed->GetTotalPLRTrackPercentTraveled(), 0.f, 1.f );
}
else if ( !m_bPlayingKoth && !m_bPowerupMode && ( tf_gamemode_cp.GetInt() || tf_gamemode_sd.GetInt() || tf_gamemode_payload.GetInt() ) )
{
// Rounds Won
// CP - Points can flow back and forever, so we can't count total caps. And the
// state of the game is always the same at match end, so rounds won is our
// only real metric.
// SD - A flag cap is a round, so we could count caps or rounds here. Again, the
// flag can go back and forth forever, but the match end state is always the same.
// PL - Count the points captured by each team. We do this A/D style where each team has
// a chance to score points.
flBlueScoreRatio = RemapValClamped( pTFTeamBlue->GetScore(), 0.f, pTFTeamBlue->GetScore() + pTFTeamRed->GetScore() , 0.f, 1.f );
}
else if ( tf_gamemode_ctf.GetInt() || m_bPowerupMode || tf_gamemode_passtime.GetInt() )
{
// Flag captures
// Mannpower is a variant of CTF and Passtime effectively is CTF. In all of these modes
// we don't use rounds so our best metric is individual flag captures.
flBlueScoreRatio = RemapValClamped( pTFTeamBlue->GetTotalFlagCaptures(), 0.f, pTFTeamBlue->GetTotalFlagCaptures() + pTFTeamRed->GetTotalFlagCaptures(), 0.f, 1.f );
}
else if ( m_bPlayingKoth )
{
// Time capped
// Looking at the capped time for each team will let us give xp in a fair way. We can
// actually get as close as 50/50
float flBlueTimeCapped = pTFTeamBlue->GetKOTHTime();
float flRedTiemCapped = pTFTeamRed->GetKOTHTime();
flBlueScoreRatio = RemapValClamped( flBlueTimeCapped, 0.f, flBlueTimeCapped + flRedTiemCapped, 0.f, 1.f );
}
else if ( tf_gamemode_rd.GetInt() || tf_gamemode_pd.GetInt() )
{
CTFRobotDestructionLogic* pRDLogic = CTFRobotDestructionLogic::GetRobotDestructionLogic();
// Count bottles/cores scored by each team
flBlueScoreRatio = RemapValClamped( pRDLogic->GetScore( TF_TEAM_BLUE ), 0.f, pRDLogic->GetScore( TF_TEAM_BLUE ) + pRDLogic->GetScore( TF_TEAM_RED ), 0.f, 1.f );
}
else if ( tf_gamemode_tc.GetInt() )
{
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
int nBlueMiniRounds = 0;
int nRedMiniRounds = 0;
// Use the number of mini-rounds won by each team
for( int i=0; i < pMaster->GetNumRounds(); ++ i )
{
const CTeamControlPointRound* pRound = pMaster->GetRoundByIndex( i );
if ( pRound->RoundOwnedByTeam( TF_TEAM_RED ) )
{
++nRedMiniRounds;
}
else if ( pRound->RoundOwnedByTeam( TF_TEAM_BLUE ) )
{
++nBlueMiniRounds;
}
else
{
Assert( false );
}
}
flBlueScoreRatio = RemapValClamped( nBlueMiniRounds, 0.f, nBlueMiniRounds + nRedMiniRounds, 0.f, 1.f );
}
else
{
Assert( !"Game mode not handled for team XP bonus!" );
}
const float flRedScoreRatio = 1.f - flBlueScoreRatio;
const int nBlueTeamObjectiveBonus = flBlueScoreRatio * nTotalScore;
const int nRedTeamObjectiveBonus = flRedScoreRatio * nTotalScore;
// Player info
for ( int idxPlayer = 0; idxPlayer < pMatch->GetNumTotalMatchPlayers(); idxPlayer++ )
{
CMatchInfo::PlayerMatchData_t *pMatchPlayer = pMatch->GetMatchDataForPlayer( idxPlayer );
if ( !pMatchPlayer->steamID.BIndividualAccount() )
{
Assert( false );
continue;
}
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerBySteamID( pMatchPlayer->steamID ) );
PlayerStats_t *pStats = CTF_GameStats.FindPlayerStats( pTFPlayer );
CMsgGC_Match_Result_Player *pMsgPlayer = pMsg->Body().add_players();
int nTeam = GetGameTeamForGCTeam( pMatchPlayer->eGCTeam );
pMsgPlayer->set_steam_id( pMatchPlayer->steamID.ConvertToUint64() );
pMsgPlayer->set_team( nTeam );
if ( pTFResource && pTFPlayer )
{
pMsgPlayer->set_score( pTFResource->GetTotalScore( pTFPlayer->entindex() ) );
}
else
{
// They left
}
int nPing = 0;
int nPacketLoss = 0;
if ( pTFPlayer )
{
UTIL_GetPlayerConnectionInfo( pTFPlayer->entindex(), nPing, nPacketLoss );
}
pMsgPlayer->set_ping( nPing );
uint32 unPlayerFlags = 0U;
if ( pMatchPlayer->bDropped )
{
unPlayerFlags |= MATCH_FLAG_PLAYER_LEAVER;
}
if ( pMatchPlayer->bLateJoin )
{
unPlayerFlags |= MATCH_FLAG_PLAYER_LATEJOIN;
}
if ( pMatchPlayer->BDropWasAbandon() )
{
unPlayerFlags |= MATCH_FLAG_PLAYER_ABANDONER;
}
if ( pMatchPlayer->bPlayed )
{
unPlayerFlags |= MATCH_FLAG_PLAYER_PLAYED;
}
pMsgPlayer->set_flags( unPlayerFlags );
// server-side skill system
FixmeMMRatingBackendSwapping(); // Assuming skill rating is drillo
pMsgPlayer->set_classes_played( pMatchPlayer->unClassesPlayed );
pMsgPlayer->set_kills( pStats ? pStats->statsAccumulated.m_iStat[TFSTAT_KILLS] : 0 );
pMsgPlayer->set_damage( pStats ? pStats->statsAccumulated.m_iStat[TFSTAT_DAMAGE] : 0 );
pMsgPlayer->set_healing( pStats ? pStats->statsAccumulated.m_iStat[TFSTAT_HEALING] : 0 );
pMsgPlayer->set_support( pStats ? CalcPlayerSupportScore( &pStats->statsAccumulated, pTFPlayer->entindex() ) : 0 );
pMsgPlayer->set_score_medal( pMatchPlayer->nScoreMedal );
pMsgPlayer->set_kills_medal( pMatchPlayer->nKillsMedal );
pMsgPlayer->set_damage_medal( pMatchPlayer->nDamageMedal );
pMsgPlayer->set_healing_medal( pMatchPlayer->nHealingMedal );
pMsgPlayer->set_support_medal( pMatchPlayer->nSupportMedal );
FixmeMMRatingBackendSwapping(); // Assuming we're using skill rating for rank? Why even include this?
pMsgPlayer->set_rank( pMatchDesc->m_pProgressionDesc->GetLevelForExperience( pMatchPlayer->unMMSkillRating ).m_nLevelNum );
pMsgPlayer->set_deaths( pStats ? pStats->statsAccumulated.m_iStat[TFSTAT_DEATHS] : 0 );
pMsgPlayer->set_party_id( pMatchPlayer->uPartyID );
uint32 unLeaveTime = ( pMatchPlayer && ( pMatchPlayer->bDropped || pMatchPlayer->BDropWasAbandon() ) ) ?
pMatchPlayer->GetLastActiveEventTime() : 0u;
pMsgPlayer->set_leave_time( unLeaveTime );
pMsgPlayer->set_leave_reason( pMatchPlayer->GetDropReason() );
pMsgPlayer->set_connect_time( pMatchPlayer->rtJoinedMatch );
// Somebody won! Match finish bonus
if ( nCode == CMsgGC_Match_Result_Status_MATCH_SUCCEEDED )
{
// Give points based on team performance
int nPerformanceScore = RemapValClamped( pMsgPlayer->score(), 0, nTotalScore / 24, 0, nTeam == TF_TEAM_RED ? nRedTeamObjectiveBonus : nBlueTeamObjectiveBonus );
pMatch->GiveXPRewardToPlayerForAction( pMatchPlayer->steamID, CMsgTFXPSource::SOURCE_OBJECTIVE_BONUS, nPerformanceScore );
// Everyone gets base completion points
int nCompletionScore = RemapValClamped( pMsgPlayer->score(), 0, nTotalScore / 24, 0, nTotalScore );
pMatch->GiveXPRewardToPlayerForAction( pMatchPlayer->steamID, CMsgTFXPSource::SOURCE_COMPLETED_MATCH, nCompletionScore );
}
// Copy any pending XP sources they had ready to send up
for( int i=0; i < pMatchPlayer->GetXPSources().sources_size(); ++i )
{
CMsgTFXPSource* pXPSource = pMsgPlayer->add_xp_breakdown();
pXPSource->CopyFrom( pMatchPlayer->GetXPSources().sources( i ) );
}
}
pMsg->Body().set_win_reason( GetWinReason() );
uint32 unMatchFlags = 0u;
if ( pMatch->m_uLobbyFlags & LOBBY_FLAG_LOWPRIORITY )
{
unMatchFlags |= MATCH_FLAG_LOWPRIORITY;
}
if ( pMatch->m_uLobbyFlags & LOBBY_FLAG_REMATCH )
{
unMatchFlags |= MATCH_FLAG_REMATCH;
}
pMsg->Body().set_flags( unMatchFlags );
pMsg->Body().set_bots( pMatch->m_nBotsAdded );
GTFGCClientSystem()->SendCompetitiveMatchResult( pMsg );
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::MatchmakingShouldUseStopwatchMode()
{
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
bool bRetVal = !HasMultipleTrains() && ( tf_gamemode_payload.GetBool() || ( pMaster && ( pMaster->PlayingMiniRounds() || pMaster->ShouldSwitchTeamsOnRoundWin() ) ) );
tf_attack_defend_map.SetValue( bRetVal );
return bRetVal;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::SetPowerupMode( bool bValue )
{
// Powerup mode uses grapple and changes some gamerule variables.
if ( bValue )
{
tf_grapplinghook_enable.SetValue( 1 );
tf_flag_return_time_credit_factor.SetValue( 0 );
}
else
{
tf_grapplinghook_enable.SetValue( 0 );
tf_flag_return_time_credit_factor.SetValue( 1 );
}
m_bPowerupMode = bValue;
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
void CTFGameRules::EndManagedMvMMatch( bool bKickPlayersToParties )
{
// Primarily a pass through so we can ensure our match end state is sync'd -- CPopulationManager manages most of the
// MvM meta round state
if ( !IsManagedMatchEnded() )
{
GTFGCClientSystem()->EndManagedMatch( bKickPlayersToParties );
Assert( IsManagedMatchEnded() );
m_bMatchEnded.Set( true );
}
}
#endif // GAME_DLL
#ifdef STAGING_ONLY
//-----------------------------------------------------------------------------
// Purpose: Enable/Disable Bounty Mode
//-----------------------------------------------------------------------------
void CTFGameRules::SetBountyMode( bool bValue )
{
if ( m_bBountyModeEnabled.Get() != bValue )
{
m_bBountyModeEnabled.Set( bValue );
}
// If enabling, dynamically create an upgrade entity
if ( bValue )
{
if ( !g_hUpgradeEntity && !m_pUpgrades )
{
m_pUpgrades = CBaseEntity::Create( "func_upgradestation", vec3_origin, vec3_angle );
}
}
// If disabling, remove upgrade entity
if ( !bValue && m_pUpgrades )
{
UTIL_Remove( m_pUpgrades );
m_pUpgrades = NULL;
}
IGameEvent *event = gameeventmanager->CreateEvent( "bountymode_toggled" );
if ( event )
{
event->SetBool( "active", bValue );
gameeventmanager->FireEvent( event );
}
}
#endif // GAME_DLL
#endif // STAGING_ONLY
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::UsePlayerReadyStatusMode( void )
{
if ( IsMannVsMachineMode() )
return true;
if ( IsCompetitiveMode() )
return true;
if ( mp_tournament.GetBool() && mp_tournament_readymode.GetBool() )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::PlayerReadyStatus_HaveMinPlayersToEnable( void )
{
// we always have enough players if the match wants players to autoready
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
if ( pMatchDesc && pMatchDesc->m_params.m_bAutoReady )
return true;
#ifdef GAME_DLL
// Count connected players
int nNumPlayers = 0;
CUtlVector< CTFPlayer* > playerVector;
CollectPlayers( &playerVector );
FOR_EACH_VEC( playerVector, i )
{
if ( !playerVector[i] )
continue;
if ( playerVector[i]->IsFakeClient() )
continue;
#ifdef STAGING_ONLY
if ( !mp_tournament_readymode_bots_allowed.GetBool() && playerVector[i]->IsBot() )
continue;
#else
if ( playerVector[i]->IsBot() )
continue;
#endif
if ( playerVector[i]->IsHLTV() )
continue;
if ( playerVector[i]->IsReplay() )
continue;
nNumPlayers++;
}
// Default
int nMinPlayers = 1;
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
if ( pMatch && !pMatch->BMatchTerminated() && pMatchDesc->m_params.m_bRequireCompleteMatch )
{
nMinPlayers = pMatch->GetCanonicalMatchSize();
}
else if ( IsMannVsMachineMode() &&
( engine->IsDedicatedServer() || ( !engine->IsDedicatedServer() && nNumPlayers > 1 ) ) )
{
nMinPlayers = tf_mvm_min_players_to_start.GetInt();
}
else if ( UsePlayerReadyStatusMode() && engine->IsDedicatedServer() )
{
nMinPlayers = mp_tournament_readymode_min.GetInt();
}
// Should be renamed to m_bEnableReady, not sure why we encoded our criteria in the names of all associated functions and variables...
m_bHaveMinPlayersToEnableReady.Set( nNumPlayers >= nMinPlayers );
#endif
return m_bHaveMinPlayersToEnableReady;
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
bool CTFGameRules::PlayerReadyStatus_ArePlayersOnTeamReady( int iTeam )
{
if ( IsMannVsMachineMode() && iTeam == TF_TEAM_PVE_INVADERS )
return true;
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
if ( pMatch )
{
int nMatchPlayers = pMatch->GetNumTotalMatchPlayers();
if ( nMatchPlayers <= 0 )
return false;
int iPlayerReadyCount = 0;
for ( int i = 0; i < nMatchPlayers; i++ )
{
CMatchInfo::PlayerMatchData_t *pPlayerData = pMatch->GetMatchDataForPlayer( i );
if ( !pPlayerData->bDropped && GetGameTeamForGCTeam( pPlayerData->eGCTeam ) == iTeam )
{
CBasePlayer *pPlayer = UTIL_PlayerBySteamID( pPlayerData->steamID );
// XXX(JohnS): Not quite valid yet, We let them join first onto spectate, which is probably a bit
// confusing
//
// AssertMsg( !pPlayer || ToTFPlayer( pPlayer )->GetTeamNumber() == GetGameTeamForGCTeam( pPlayerData->eGCTeam ),
// "Player's GC assigned team does not match their current team" );
if ( !pPlayer || !m_bPlayerReady[ pPlayer->entindex() ] )
return false;
iPlayerReadyCount++;
}
}
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
if ( pMatchDesc && pMatchDesc->m_params.m_bAutoReady )
{
return iPlayerReadyCount > 0 || pMatch->GetNumTotalMatchPlayers() == 1 ;
}
else
{
int iTeamSize = IsMannVsMachineMode() ? pMatch->GetCanonicalMatchSize() : pMatch->GetCanonicalMatchSize() / 2;
return iPlayerReadyCount >= iTeamSize;
}
}
// Non-match
bool bAtLeastOneReady = false;
for ( int i = 1; i <= MAX_PLAYERS; ++i )
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
if ( !pPlayer || ToTFPlayer( pPlayer )->GetTeamNumber() != iTeam )
continue;
if ( !m_bPlayerReady[i] )
{
return false;
}
else
{
bAtLeastOneReady = true;
}
}
// Team isn't ready if there was nobody on it.
return bAtLeastOneReady;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::PlayerReadyStatus_ShouldStartCountdown( void )
{
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
#if defined( STAGING_ONLY )
// Local testing hack - allow match size of one where just that player is ready
if ( !IsMannVsMachineMode() && !pMatch && BHavePlayers() && ( IsTeamReady( TF_TEAM_RED ) || IsTeamReady( TF_TEAM_BLUE ) ) )
return true;
#endif // STAGING_ONLY
if ( IsMannVsMachineMode() )
{
if ( !IsTeamReady( TF_TEAM_PVE_DEFENDERS ) && m_flRestartRoundTime >= gpGlobals->curtime + mp_tournament_readymode_countdown.GetInt() )
{
bool bIsTeamReady = PlayerReadyStatus_ArePlayersOnTeamReady( TF_TEAM_PVE_DEFENDERS );
if ( bIsTeamReady )
{
SetTeamReadyState( true, TF_TEAM_PVE_DEFENDERS );
return true;
}
}
}
else if ( pMatch &&
PlayerReadyStatus_ArePlayersOnTeamReady( TF_TEAM_RED ) &&
PlayerReadyStatus_ArePlayersOnTeamReady( TF_TEAM_BLUE ) )
{
return true;
}
else if ( IsTeamReady( TF_TEAM_RED ) && IsTeamReady( TF_TEAM_BLUE ) )
{
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::PlayerReadyStatus_ResetState( void )
{
// Reset the players
ResetPlayerAndTeamReadyState();
// Reset the team
SetTeamReadyState( false, TF_TEAM_RED );
SetTeamReadyState( false, TF_TEAM_BLUE );
m_flRestartRoundTime.Set( -1.f );
mp_restartgame.SetValue( 0 );
m_bAwaitingReadyRestart = true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::PlayerReadyStatus_UpdatePlayerState( CTFPlayer *pTFPlayer, bool bState )
{
if ( !UsePlayerReadyStatusMode() )
return;
if ( !pTFPlayer )
return;
if ( pTFPlayer->GetTeamNumber() < FIRST_GAME_TEAM )
return;
if ( State_Get() != GR_STATE_BETWEEN_RNDS )
return;
// Don't allow toggling state in the final countdown
if ( GetRoundRestartTime() > 0.f && GetRoundRestartTime() <= gpGlobals->curtime + TOURNAMENT_NOCANCEL_TIME )
return;
// Make sure we have enough to allow ready mode commands
if ( !PlayerReadyStatus_HaveMinPlayersToEnable() )
return;
int nEntIndex = pTFPlayer->entindex();
// Already this state
if ( bState == IsPlayerReady( nEntIndex ) )
return;
SetPlayerReadyState( nEntIndex, bState );
if ( !bState )
{
// Slam team status to Not Ready for any player that sets Not Ready
m_bTeamReady.Set( pTFPlayer->GetTeamNumber(), false );
// If everyone cancels ready state, stop the clock
bool bAnyoneReady = false;
for ( int i = 1; i <= MAX_PLAYERS; ++i )
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
if ( !pPlayer )
continue;
if ( m_bPlayerReady[i] )
{
bAnyoneReady = true;
break;
}
}
if ( !bAnyoneReady )
{
m_flRestartRoundTime.Set( -1.f );
mp_restartgame.SetValue( 0 );
ResetPlayerAndTeamReadyState();
}
}
else
{
if ( IsMannVsMachineMode() || IsCompetitiveMode() )
{
// Reduce timer as each player hits Ready, but only once per-player
if ( !m_bPlayerReadyBefore[nEntIndex] && m_flRestartRoundTime > gpGlobals->curtime + 60.f )
{
float flReduceBy = 30.f;
if ( m_flRestartRoundTime < gpGlobals->curtime + 90.f )
{
// Never reduce below 60 seconds remaining
flReduceBy = m_flRestartRoundTime - gpGlobals->curtime - 60.f;
}
m_flRestartRoundTime -= flReduceBy;
}
else if ( m_flRestartRoundTime < 0 && !PlayerReadyStatus_ShouldStartCountdown() )
{
m_flRestartRoundTime.Set( gpGlobals->curtime + 150.f );
m_bAwaitingReadyRestart = false;
IGameEvent* pEvent = gameeventmanager->CreateEvent( "teamplay_round_restart_seconds" );
if ( pEvent )
{
pEvent->SetInt( "seconds", 150 );
gameeventmanager->FireEvent( pEvent );
}
}
}
// Unofficial modes set team ready state here
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
if ( !pMatch && !IsMannVsMachineMode() )
{
int nRed = 0;
int nRedCount = 0;
int nBlue = 0;
int nBlueCount = 0;
for ( int iTeam = FIRST_GAME_TEAM; iTeam < TFTeamMgr()->GetTeamCount(); iTeam++ )
{
CTFTeam *pTeam = GetGlobalTFTeam( iTeam );
if ( pTeam )
{
Assert( pTeam->GetTeamNumber() == TF_TEAM_RED || pTeam->GetTeamNumber() == TF_TEAM_BLUE );
for ( int i = 0; i < pTeam->GetNumPlayers(); ++i )
{
if ( !pTeam->GetPlayer(i) )
continue;
if ( pTeam->GetTeamNumber() == TF_TEAM_RED && IsPlayerReady( pTeam->GetPlayer(i)->entindex() ) )
{
if ( !nRedCount )
{
nRedCount = pTeam->GetNumPlayers();
}
nRed++;
}
else if ( pTeam->GetTeamNumber() == TF_TEAM_BLUE && IsPlayerReady( pTeam->GetPlayer(i)->entindex() ) )
{
if ( !nBlueCount )
{
nBlueCount = pTeam->GetNumPlayers();
}
nBlue++;
}
}
}
}
// Check for the convar that requires min team size, or just go with whatever each team has
int nRedMin = ( mp_tournament_readymode_team_size.GetInt() > 0 ) ? mp_tournament_readymode_team_size.GetInt() : Max( nRedCount, 1 );
int nBlueMin = ( mp_tournament_readymode_team_size.GetInt() > 0 ) ? mp_tournament_readymode_team_size.GetInt() : Max( nBlueCount, 1 );
SetTeamReadyState( ( nRed == nRedMin ), TF_TEAM_RED );
SetTeamReadyState( ( nBlue == nBlueMin ), TF_TEAM_BLUE );
}
m_bPlayerReadyBefore[nEntIndex] = true;
}
}
#endif // GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::IsDefaultGameMode( void )
{
if ( IsMannVsMachineMode() )
return false;
if ( IsInArenaMode() )
return false;
if ( IsInMedievalMode() )
return false;
if ( IsCompetitiveMode() )
return false;
if ( IsInTournamentMode() )
return false;
if ( IsInTraining() )
return false;
if ( IsInItemTestingMode() )
return false;
#ifdef STAGING_ONLY
if ( IsPVEModeActive() )
return false;
#endif // STAGING_ONLY
#ifdef TF_RAID_MODE
if ( IsRaidMode() )
return false;
if ( IsBossBattleMode() )
return false;
#endif // TF_RAID_MODE
#ifdef TF_CREEP_MODE
if ( IsCreepWaveMode() )
return false;
#endif // TF_CREEP_MODE
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Allows us to give situational discounts, such as secondary weapons
//-----------------------------------------------------------------------------
int CTFGameRules::GetCostForUpgrade( CMannVsMachineUpgrades *pUpgrade, int iItemSlot, int nClass, CTFPlayer *pPurchaser /*= NULL*/ )
{
Assert( pUpgrade );
if ( !pUpgrade )
return 0;
int iCost = pUpgrade->nCost;
CEconItemSchema *pSchema = ItemSystem()->GetItemSchema();
if ( pSchema )
{
const CEconItemAttributeDefinition *pAttr = pSchema->GetAttributeDefinitionByName( pUpgrade->szAttrib );
if ( pAttr )
{
if ( ( iItemSlot == LOADOUT_POSITION_PRIMARY && nClass == TF_CLASS_ENGINEER ) ||
( iItemSlot == LOADOUT_POSITION_SECONDARY && nClass != TF_CLASS_DEMOMAN ) ||
( iItemSlot == LOADOUT_POSITION_MELEE && nClass != TF_CLASS_SPY && nClass != TF_CLASS_ENGINEER ) )
{
switch ( pAttr->GetDefinitionIndex() )
{
case 4: // clip size bonus
case 6: // fire rate bonus
case 78: // maxammo secondary increased
case 180: // heal on kill
case 266: // projectile penetration
case 335: // clip size bonus upgrade
case 397: // projectile penetration heavy
iCost *= 0.5f;
break;
default:
break;
}
}
else if ( iItemSlot == LOADOUT_POSITION_ACTION )
{
if ( pPurchaser )
{
int iCanteenSpec = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pPurchaser, iCanteenSpec, canteen_specialist );
if ( iCanteenSpec )
{
// iCost *= ( 1.f - ( iCanteenSpec * 0.1f ) );
// iCost = Max( 1, ( iCost - ( iCost % 5 ) ) );
iCost -= ( 10 * iCanteenSpec );
iCost = Max( 5, iCost );
}
}
}
}
}
return iCost;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFGameRules::CTFGameRules()
#ifdef GAME_DLL
: m_mapCoachToStudentMap( DefLessFunc(uint32) )
, m_flNextStrangeEventProcessTime( g_flStrangeEventBatchProcessInterval )
, m_mapTeleportLocations( DefLessFunc(string_t) )
, m_bMapCycleNeedsUpdate( false )
, m_flSafeToLeaveTimer( -1.f )
, m_flCompModeRespawnPlayersAtMatchStart( -1.f )
, m_bMapForcedTruceDuringBossFight( false )
, m_flNextHalloweenGiftUpdateTime( -1 )
#else
: m_bRecievedBaseline( false )
#endif
{
#ifdef GAME_DLL
// Create teams.
TFTeamMgr()->Init();
ResetMapTime();
// Create the team managers
// for ( int i = 0; i < ARRAYSIZE( teamnames ); i++ )
// {
// CTeam *pTeam = static_cast<CTeam*>(CreateEntityByName( "tf_team" ));
// pTeam->Init( sTeamNames[i], i );
//
// g_Teams.AddToTail( pTeam );
// }
m_flIntermissionEndTime = 0.0f;
m_flNextPeriodicThink = 0.0f;
ListenForGameEvent( "teamplay_point_captured" );
ListenForGameEvent( "teamplay_capture_blocked" );
ListenForGameEvent( "teamplay_round_win" );
ListenForGameEvent( "teamplay_flag_event" );
ListenForGameEvent( "teamplay_round_start" );
ListenForGameEvent( "player_escort_score" );
ListenForGameEvent( "player_disconnect" );
ListenForGameEvent( "teamplay_setup_finished" );
ListenForGameEvent( "recalculate_truce" );
Q_memset( m_vecPlayerPositions,0, sizeof(m_vecPlayerPositions) );
m_iPrevRoundState = -1;
m_iCurrentRoundState = -1;
m_iCurrentMiniRoundMask = 0;
m_iPreviousTeamSize = 0;
// Lets execute a map specific cfg file
// ** execute this after server.cfg!
char szCommand[MAX_PATH] = { 0 };
// Map names cannot contain quotes or control characters so this is safe but silly that we have to do it.
Q_snprintf( szCommand, sizeof( szCommand ), "exec \"%s.cfg\"\n", STRING( gpGlobals->mapname ) );
engine->ServerCommand( szCommand );
m_flSendNotificationTime = 0.0f;
m_bOvertimeAllowedForCTF = true;
m_redPayloadToPush = NULL;
m_bluePayloadToPush = NULL;
m_redPayloadToBlock = NULL;
m_bluePayloadToBlock = NULL;
SetCTFCaptureBonusTime( -1 );
m_hasSpawnedToy = false;
m_flCapInProgressBuffer = 0.f;
m_bMannVsMachineAlarmStatus = false;
m_flNextFlagAlarm = 0.0f;
m_flNextFlagAlert = 0.0f;
m_doomsdaySetupTimer.Invalidate();
StopDoomsdayTicketsTimer();
m_nPowerupKillsRedTeam = 0;
m_nPowerupKillsBlueTeam = 0;
m_flTimeToRunImbalanceMeasures = 120.f;
m_flTimeToStopImbalanceMeasures = 0.f;
m_bPowerupImbalanceMeasuresRunning = false;
m_hRequiredObserverTarget = NULL;
m_bStopWatchWinner.Set( false );
#else // GAME_DLL
// Vision Filter Translations for swapping out particle effects and models
SetUpVisionFilterKeyValues();
m_bSillyGibs = CommandLine()->FindParm( "-sillygibs" ) ? true : false;
if ( m_bSillyGibs )
{
cl_burninggibs.SetValue( 0 );
}
// @todo Tom Bui: game_newmap doesn't seem to be used...
ListenForGameEvent( "game_newmap" );
ListenForGameEvent( "overtime_nag" );
ListenForGameEvent( "recalculate_holidays" );
#endif
ClearHalloweenEffectStatus();
// Initialize the game type
m_nGameType.Set( TF_GAMETYPE_UNDEFINED );
m_bPlayingMannVsMachine.Set( false );
m_bMannVsMachineAlarmStatus.Set( false );
m_bBountyModeEnabled.Set( false );
m_bPlayingKoth.Set( false );
m_bPlayingMedieval.Set( false );
m_bPlayingHybrid_CTF_CP.Set( false );
m_bPlayingSpecialDeliveryMode.Set( false );
m_bPlayingRobotDestructionMode.Set( false );
m_bPowerupMode.Set( false );
m_bHelltowerPlayersInHell.Set( false );
m_bIsUsingSpells.Set( false );
m_bTruceActive.Set( false );
m_bTeamsSwitched.Set( false );
m_halloweenScenario.Set( HALLOWEEN_SCENARIO_NONE );
m_iGlobalAttributeCacheVersion = 0;
//=============================================================================
// HPE_BEGIN
// [msmith] HUD type
//=============================================================================
m_nHudType.Set( TF_HUDTYPE_UNDEFINED );
m_bIsInTraining.Set( false );
m_bAllowTrainingAchievements.Set( false );
m_bIsWaitingForTrainingContinue.Set( false );
//=============================================================================
// HPE_END
//=============================================================================
m_bIsTrainingHUDVisible.Set( false );
m_bIsInItemTestingMode.Set( false );
// Set turbo physics on. Do it here for now.
sv_turbophysics.SetValue( 1 );
// Initialize the team manager here, etc...
// If you hit these asserts its because you added or removed a weapon type
// and didn't also add or remove the weapon name or damage type from the
// arrays defined in tf_shareddefs.cpp
COMPILE_TIME_ASSERT( TF_WEAPON_COUNT == ARRAYSIZE( g_aWeaponDamageTypes ) );
COMPILE_TIME_ASSERT( TF_WEAPON_COUNT == ARRAYSIZE( g_aWeaponNames ) );
m_iPreviousRoundWinners = TEAM_UNASSIGNED;
m_pszTeamGoalStringRed.GetForModify()[0] = '\0';
m_pszTeamGoalStringBlue.GetForModify()[0] = '\0';
m_nStopWatchState.Set( STOPWATCH_CAPTURE_TIME_NOT_SET );
mp_tournament_redteamname.Revert();
mp_tournament_blueteamname.Revert();
m_flCapturePointEnableTime = 0.0f;
m_itHandle = 0;
m_hBirthdayPlayer = NULL;
m_nBossHealth = 0;
m_nMaxBossHealth = 0;
m_fBossNormalizedTravelDistance = 0.0f;
m_areHealthAndAmmoVectorsReady = false;
m_flGravityMultiplier.Set( 1.0 );
m_pszCustomUpgradesFile.GetForModify()[0] = '\0';
m_bShowMatchSummary.Set( false );
m_bMapHasMatchSummaryStage.Set( false );
m_bPlayersAreOnMatchSummaryStage.Set( false );
m_bUseMatchHUD = false;
m_bUsePreRoundDoors = false;
m_nMatchGroupType.Set( k_nMatchGroup_Invalid );
m_bMatchEnded.Set( true );
for ( int i = 1; i <= MAX_PLAYERS; i++ )
{
m_ePlayerWantsRematch.Set( i, USER_NEXT_MAP_VOTE_UNDECIDED );
}
m_eRematchState = NEXT_MAP_VOTE_STATE_NONE;
#ifdef GAME_DLL
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
if ( pMatch )
{
SyncMatchSettings();
}
for ( int i = 0; i < TF_TEAM_COUNT; i++ )
{
m_bHasSpawnedSoccerBall[i] = false;
}
m_flCheckPlayersConnectingTime = 0;
m_pUpgrades = NULL;
// Determine if a halloween event map is active
// Map active always turns on Halloween
{
char szCurrentMap[MAX_MAP_NAME];
Q_strncpy( szCurrentMap, STRING( gpGlobals->mapname ), sizeof( szCurrentMap ) );
if ( !Q_stricmp( szCurrentMap, "cp_manor_event" ) )
{
m_halloweenScenario.Set( HALLOWEEN_SCENARIO_MANN_MANOR );
}
else if ( !Q_stricmp( szCurrentMap, "koth_viaduct_event" ) )
{
m_halloweenScenario.Set( HALLOWEEN_SCENARIO_VIADUCT );
}
else if ( !Q_stricmp( szCurrentMap, "koth_lakeside_event" ) )
{
m_halloweenScenario.Set( HALLOWEEN_SCENARIO_LAKESIDE );
}
else if( !Q_stricmp( szCurrentMap, "plr_hightower_event" ) )
{
m_halloweenScenario.Set( HALLOWEEN_SCENARIO_HIGHTOWER );
}
else if ( !Q_stricmp( szCurrentMap, "sd_doomsday_event" ) )
{
m_halloweenScenario.Set( HALLOWEEN_SCENARIO_DOOMSDAY );
}
}
// Our hook for LoadMapCycleFile wont run during the base class constructor that does this initially
TrackWorkshopMapsInMapCycle();
#endif
}
#ifdef GAME_DLL
void CTFGameRules::Precache( void )
{
BaseClass::Precache();
// The Halloween bosses get spawned in code, so they don't get a chance to precache
// when the map loads. We'll do the precaching for them here.
if( IsHalloweenScenario( HALLOWEEN_SCENARIO_LAKESIDE ) )
{
CMerasmus::PrecacheMerasmus();
}
else if( IsHalloweenScenario( HALLOWEEN_SCENARIO_VIADUCT ) )
{
CEyeballBoss::PrecacheEyeballBoss();
}
else if( IsHalloweenScenario( HALLOWEEN_SCENARIO_MANN_MANOR ) )
{
CHeadlessHatman::PrecacheHeadlessHatman();
}
else if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
{
CEyeballBoss::PrecacheEyeballBoss();
CGhost::PrecacheGhost();
}
else if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) )
{
CTFPlayer::PrecacheKart();
CGhost::PrecacheGhost();
CHeadlessHatman::PrecacheHeadlessHatman();
CMerasmus::PrecacheMerasmus();
}
if ( StringHasPrefix( STRING( gpGlobals->mapname ), "mvm_" ) )
{
CTFPlayer::PrecacheMvM();
}
CTFPlayer::m_bTFPlayerNeedsPrecache = true;
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
//#ifdef GAME_DLL
//extern void AddHalloweenGiftPositionsForMap( const char *pszMapName, CUtlVector<Vector> &vLocations );
//#endif
void CTFGameRules::LevelInitPostEntity( void )
{
BaseClass::LevelInitPostEntity();
#ifdef GAME_DLL
// Refind our proxy, because we might have had it deleted due to a mapmaker placed one
m_hGamerulesProxy = dynamic_cast<CTFGameRulesProxy*>( gEntList.FindEntityByClassname( NULL, "tf_gamerules" ) );
// Halloween
// Flush Halloween Gift Location and grab locations if applicable. NonHalloween maps will have these as zero
m_halloweenGiftSpawnLocations.Purge();
if ( IsHolidayActive( kHoliday_Halloween ) )
{
for ( int i=0; i<IHalloweenGiftSpawnAutoList::AutoList().Count(); ++i )
{
CHalloweenGiftSpawnLocation* pGift = static_cast< CHalloweenGiftSpawnLocation* >( IHalloweenGiftSpawnAutoList::AutoList()[i] );
m_halloweenGiftSpawnLocations.AddToTail( pGift->GetAbsOrigin() );
UTIL_Remove( pGift );
}
// Ask Halloween System if there are any locations
AddHalloweenGiftPositionsForMap( STRING(gpGlobals->mapname), m_halloweenGiftSpawnLocations );
}
m_flMatchSummaryTeleportTime = -1.f;
//tagES
#ifdef STAGING_ONLY
tf_test_match_summary.SetValue( 0 );
#endif
const IMatchGroupDescription *pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
if ( pMatchDesc )
{
pMatchDesc->InitGameRulesSettingsPostEntity();
}
#endif // GAME_DLL
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CTFGameRules::GetRespawnTimeScalar( int iTeam )
{
// In PvE mode, we don't modify respawn times
if ( IsPVEModeActive() )
return 1.0;
return BaseClass::GetRespawnTimeScalar( iTeam );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CTFGameRules::GetRespawnWaveMaxLength( int iTeam, bool bScaleWithNumPlayers )
{
bool bScale = bScaleWithNumPlayers;
#ifdef TF_RAID_MODE
if ( IsRaidMode() )
{
return tf_raid_respawn_time.GetFloat();
}
#endif // TF_RAID_MODE
#ifdef TF_CREEP_MODE
if ( IsCreepWaveMode() )
{
return tf_creep_wave_player_respawn_time.GetFloat();
}
#endif
if ( IsMannVsMachineMode() )
{
bScale = false;
}
float flTime = BaseClass::GetRespawnWaveMaxLength( iTeam, bScale );
CTFRobotDestructionLogic* pRoboLogic = CTFRobotDestructionLogic::GetRobotDestructionLogic();
if ( pRoboLogic )
{
flTime *= ( 1.f - pRoboLogic->GetRespawnScaleForTeam( iTeam ) );
}
return flTime;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::FlagsMayBeCapped( void )
{
if ( State_Get() != GR_STATE_TEAM_WIN && State_Get() != GR_STATE_PREROUND )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Return which Halloween scenario is currently running
//-----------------------------------------------------------------------------
CTFGameRules::HalloweenScenarioType CTFGameRules::GetHalloweenScenario( void ) const
{
if ( !const_cast< CTFGameRules * >( this )->IsHolidayActive( kHoliday_Halloween ) )
return HALLOWEEN_SCENARIO_NONE;
return m_halloweenScenario;
}
//-----------------------------------------------------------------------------
bool CTFGameRules::IsUsingSpells( void ) const
{
if ( tf_spells_enabled.GetBool() )
return true;
if ( IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_HIGHTOWER ) )
return true;
return m_bIsUsingSpells;
}
//-----------------------------------------------------------------------------
bool CTFGameRules::IsUsingGrapplingHook( void ) const
{
return tf_grapplinghook_enable.GetBool();
}
//-----------------------------------------------------------------------------
bool CTFGameRules::IsTruceActive( void ) const
{
return m_bTruceActive;
}
//-----------------------------------------------------------------------------
bool CTFGameRules::CanInitiateDuels( void )
{
if ( IsInWaitingForPlayers() )
return false;
gamerules_roundstate_t roundState = State_Get();
if ( ( roundState != GR_STATE_RND_RUNNING ) && ( roundState != GR_STATE_PREROUND ) )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFGameRules::GetGameTeamForGCTeam( TF_GC_TEAM nGCTeam )
{
if ( nGCTeam == TF_GC_TEAM_INVADERS )
{
if ( IsCompetitiveMode() )
{
return ( m_bTeamsSwitched ) ? TF_TEAM_RED : TF_TEAM_BLUE;
}
return TF_TEAM_BLUE;
}
else if ( nGCTeam == TF_GC_TEAM_DEFENDERS )
{
if ( IsCompetitiveMode() )
{
return ( m_bTeamsSwitched ) ? TF_TEAM_BLUE : TF_TEAM_RED;
}
return TF_TEAM_RED;
}
return TEAM_UNASSIGNED;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
TF_GC_TEAM CTFGameRules::GetGCTeamForGameTeam( int nGameTeam )
{
if ( nGameTeam == TF_TEAM_BLUE )
{
if ( IsCompetitiveMode() )
{
return ( m_bTeamsSwitched ) ? TF_GC_TEAM_DEFENDERS : TF_GC_TEAM_INVADERS;
}
return TF_GC_TEAM_INVADERS;
}
else if ( nGameTeam == TF_TEAM_RED )
{
if ( IsCompetitiveMode() )
{
return ( m_bTeamsSwitched ) ? TF_GC_TEAM_INVADERS : TF_GC_TEAM_DEFENDERS;
}
return TF_GC_TEAM_DEFENDERS;
}
return TF_GC_TEAM_NOTEAM;
}
CTFGameRules::EUserNextMapVote CTFGameRules::GetWinningVote( int (&nVotes)[ EUserNextMapVote::NUM_VOTE_STATES ] ) const
{
// We assume "undecided" is the index just after the last vote option
COMPILE_TIME_ASSERT( USER_NEXT_MAP_VOTE_UNDECIDED == NEXT_MAP_VOTE_OPTIONS );
memset( nVotes, 0, sizeof( nVotes ) );
int nTotalPlayers = 0;
// Tally up votes.
for( int iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ )
{
#ifdef CLIENT_DLL
if ( !g_PR || !g_PR->IsConnected( iPlayerIndex ) )
continue;
#else // GAME_DLL
// We care about those that are still here. If you leave, you don't count towards the vote total
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
if ( !pTFPlayer || pTFPlayer->IsBot() )
continue;
if ( !pTFPlayer->IsConnected() )
continue;
CSteamID steamID;
pTFPlayer->GetSteamID( &steamID );
// People without parties *should* be getting a new one soon. Count them as undecided
// until their party shows up and they're allowed to make a real vote.
CTFParty* pParty = GTFGCClientSystem()->GetPartyForPlayer( steamID );
if ( !pParty )
{
++nVotes[ EUserNextMapVote::USER_NEXT_MAP_VOTE_UNDECIDED ];
++nTotalPlayers;
continue;
}
const CMatchInfo* pMatch = GTFGCClientSystem()->GetMatch();
Assert( pMatch );
if ( !pMatch )
{
continue;
}
// Need to be a match players
const CMatchInfo::PlayerMatchData_t* pPlayerMatchData = pMatch->GetMatchDataForPlayer( steamID );
Assert( pPlayerMatchData );
if ( !pPlayerMatchData )
{
// How'd you get here?
continue;
}
#endif
nTotalPlayers++;
nVotes[ TFGameRules()->PlayerNextMapVoteState( iPlayerIndex ) ]++;
}
if ( nVotes[ USER_NEXT_MAP_VOTE_UNDECIDED ] == nTotalPlayers )
{
return USER_NEXT_MAP_VOTE_UNDECIDED;
}
else
{
EUserNextMapVote eWinningVote = USER_NEXT_MAP_VOTE_MAP_0;
for( int i = 0; i < NEXT_MAP_VOTE_OPTIONS; ++i )
{
// The current map is in slot 0. >= so we favor change.
eWinningVote = nVotes[ i ] >= nVotes[ eWinningVote ]
? (EUserNextMapVote)i
: eWinningVote;
}
return eWinningVote;
}
}
#ifdef GAME_DLL
void CTFGameRules::UpdateNextMapVoteOptionsFromLobby()
{
for( int i = 0; i < NEXT_MAP_VOTE_OPTIONS; ++i )
{
m_nNextMapVoteOptions.Set( i, GTFGCClientSystem()->GetNextMapVoteByIndex( i )->m_nDefIndex );
}
}
void CTFGameRules::KickPlayersNewMatchIDRequestFailed()
{
Assert( m_eRematchState == NEXT_MAP_VOTE_STATE_MAP_CHOSEN_PAUSE );
// Let everyone know the rematch failed.
if ( m_eRematchState == NEXT_MAP_VOTE_STATE_MAP_CHOSEN_PAUSE )
{
CBroadcastRecipientFilter filter;
UTIL_ClientPrintFilter( filter, HUD_PRINTTALK, "#TF_Matchmaking_RollingQueue_NewRematch_GCFail" );
IGameEvent *pEvent = gameeventmanager->CreateEvent( "rematch_failed_to_create" );
if ( pEvent )
{
gameeventmanager->FireEvent( pEvent );
}
}
// The GC failed to get a new MatchID for us. Let's clear out and reset.
engine->ServerCommand( "kickall #TF_Competitive_Disconnect\n" );
// Tell the GC System to end the managed match mode -- we skipped this in StopCompetitiveMatch so we could roll the
// managed match into a new one.
Assert( !IsManagedMatchEnded() );
if ( !IsManagedMatchEnded() )
{
GTFGCClientSystem()->EndManagedMatch( /* bKickPlayersToParties */ false );
Assert( IsManagedMatchEnded() );
m_bMatchEnded.Set( true );
}
// Prepare for next match
g_fGameOver = false;
m_bAllowBetweenRounds = true;
State_Transition( GR_STATE_RESTART );
SetInWaitingForPlayers( true );
}
//-----------------------------------------------------------------------------
void CTFGameRules::CheckAndSetPartyLeader( CTFPlayer *pTFPlayer, int iTeam )
{
if ( !pTFPlayer )
return;
Assert( iTeam >= FIRST_GAME_TEAM );
if ( iTeam < FIRST_GAME_TEAM )
return;
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
if ( !pMatch )
return;
CSteamID steamID;
if ( !pTFPlayer->GetSteamID( &steamID ) )
return;
// TODO: Whenever a lobby is updated, look at the CTFLobbyMembers and see if
// everyone has the same partyID and then set whoever is the leader to
// have their name be the team name
//CMatchInfo::PlayerMatchData_t *pMatchPlayer = pMatch->GetMatchDataForPlayer( steamID );
//if ( pMatchPlayer && pMatchPlayer->bPremadeLeader )
//{
// CTFPlayerResource *pResource = dynamic_cast< CTFPlayerResource* >( g_pPlayerResource );
// if ( pResource )
// {
// pResource->SetPartyLeaderIndex( iTeam, pTFPlayer->entindex() );
// }
//}
}
//-----------------------------------------------------------------------------
// Purpose: Sets current boss victim
//-----------------------------------------------------------------------------
void CTFGameRules::SetIT( CBaseEntity *who )
{
if ( IsHolidayActive( kHoliday_Halloween ) && !IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) )
{
CTFPlayer* newIT = ToTFPlayer( who );
if ( newIT && newIT != m_itHandle.Get() )
{
// new IT victim - warn them
ClientPrint( newIT, HUD_PRINTTALK, "#TF_HALLOWEEN_BOSS_WARN_VICTIM", newIT->GetPlayerName() );
ClientPrint( newIT, HUD_PRINTCENTER, "#TF_HALLOWEEN_BOSS_WARN_VICTIM", newIT->GetPlayerName() );
CSingleUserReliableRecipientFilter filter( newIT );
newIT->EmitSound( filter, newIT->entindex(), "Player.YouAreIT" );
// force them to scream when they become it
newIT->EmitSound( "Halloween.PlayerScream" );
}
CTFPlayer *oldIT = ToTFPlayer( m_itHandle );
if ( oldIT && oldIT != who && oldIT->IsAlive() )
{
// tell old IT player they are safe
CSingleUserReliableRecipientFilter filter( oldIT );
oldIT->EmitSound( filter, oldIT->entindex(), "Player.TaggedOtherIT" );
ClientPrint( oldIT, HUD_PRINTTALK, "#TF_HALLOWEEN_BOSS_LOST_AGGRO" );
ClientPrint( oldIT, HUD_PRINTCENTER, "#TF_HALLOWEEN_BOSS_LOST_AGGRO" );
}
}
m_itHandle = who;
}
//-----------------------------------------------------------------------------
// Purpose: Sets current birthday player
//-----------------------------------------------------------------------------
void CTFGameRules::SetBirthdayPlayer( CBaseEntity *pEntity )
{
/*
if ( IsBirthday() )
{
if ( pEntity && pEntity->IsPlayer() && pEntity != m_hBirthdayPlayer.Get() )
{
CTFPlayer *pTFPlayer = ToTFPlayer( pEntity );
if ( pTFPlayer )
{
// new IT victim - warn them
// ClientPrint( pTFPlayer, HUD_PRINTTALK, "#TF_HALLOWEEN_BOSS_WARN_VICTIM", player->GetPlayerName() );
// ClientPrint( pTFPlayer, HUD_PRINTCENTER, "#TF_HALLOWEEN_BOSS_WARN_VICTIM", player->GetPlayerName() );
CSingleUserReliableRecipientFilter filter( pTFPlayer );
pTFPlayer->EmitSound( filter, pTFPlayer->entindex(), "Game.HappyBirthday" );
// force them to scream when they become it
// pTFPlayer->EmitSound( "Halloween.PlayerScream" );
}
}
// CTFPlayer *oldIT = ToTFPlayer( m_itHandle );
//
// if ( oldIT && oldIT != who && oldIT->IsAlive() )
// {
// // tell old IT player they are safe
// CSingleUserReliableRecipientFilter filter( oldIT );
// oldIT->EmitSound( filter, oldIT->entindex(), "Player.TaggedOtherIT" );
//
// ClientPrint( oldIT, HUD_PRINTTALK, "#TF_HALLOWEEN_BOSS_LOST_AGGRO" );
// ClientPrint( oldIT, HUD_PRINTCENTER, "#TF_HALLOWEEN_BOSS_LOST_AGGRO" );
// }
m_hBirthdayPlayer = pEntity;
}
else
{
m_hBirthdayPlayer = NULL;
}
*/
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose: remove all projectiles in the world
//-----------------------------------------------------------------------------
void CTFGameRules::RemoveAllProjectiles()
{
for ( int i=0; i<IBaseProjectileAutoList::AutoList().Count(); ++i )
{
UTIL_Remove( static_cast< CBaseProjectile* >( IBaseProjectileAutoList::AutoList()[i] ) );
}
}
//-----------------------------------------------------------------------------
// Purpose: remove all buildings in the world
//-----------------------------------------------------------------------------
void CTFGameRules::RemoveAllBuildings( bool bExplodeBuildings /*= false*/ )
{
for ( int i=0; i<IBaseObjectAutoList::AutoList().Count(); ++i )
{
CBaseObject *pObj = static_cast< CBaseObject* >( IBaseObjectAutoList::AutoList()[i] );
if ( !pObj->IsMapPlaced() )
{
// this is separate from the object_destroyed event, which does
// not get sent when we remove the objects from the world
IGameEvent *event = gameeventmanager->CreateEvent( "object_removed" );
if ( event )
{
CTFPlayer *pOwner = pObj->GetOwner();
event->SetInt( "userid", pOwner ? pOwner->GetUserID() : -1 ); // user ID of the object owner
event->SetInt( "objecttype", pObj->GetType() ); // type of object removed
event->SetInt( "index", pObj->entindex() ); // index of the object removed
gameeventmanager->FireEvent( event );
}
if ( bExplodeBuildings )
{
pObj->DetonateObject();
}
else
{
// This fixes a bug in Raid mode where we could spawn where our sentry was but
// we didn't get the weapons because they couldn't trace to us in FVisible
pObj->SetSolid( SOLID_NONE );
UTIL_Remove( pObj );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: remove all sentries ammo
//-----------------------------------------------------------------------------
void CTFGameRules::RemoveAllSentriesAmmo()
{
for ( int i=0; i<IBaseObjectAutoList::AutoList().Count(); ++i )
{
CBaseObject *pObj = static_cast< CBaseObject* >( IBaseObjectAutoList::AutoList()[i] );
if ( pObj->GetType() == OBJ_SENTRYGUN )
{
CObjectSentrygun *pSentry = assert_cast< CObjectSentrygun* >( pObj );
pSentry->RemoveAllAmmo();
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Removes all projectiles and buildings from world
//-----------------------------------------------------------------------------
void CTFGameRules::RemoveAllProjectilesAndBuildings( bool bExplodeBuildings /*= false*/ )
{
RemoveAllProjectiles();
RemoveAllBuildings( bExplodeBuildings );
}
#endif // GAME_DLL
//-----------------------------------------------------------------------------
// Purpose: Determines whether we should allow mp_timelimit to trigger a map change
//-----------------------------------------------------------------------------
bool CTFGameRules::CanChangelevelBecauseOfTimeLimit( void )
{
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
// we only want to deny a map change triggered by mp_timelimit if we're not forcing a map reset,
// we're playing mini-rounds, and the master says we need to play all of them before changing (for maps like Dustbowl)
if ( !m_bForceMapReset && pMaster && pMaster->PlayingMiniRounds() && pMaster->ShouldPlayAllControlPointRounds() )
{
if ( pMaster->NumPlayableControlPointRounds() > 0 )
{
return false;
}
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::CanGoToStalemate( void )
{
// In CTF, don't go to stalemate if one of the flags isn't at home
if ( m_nGameType == TF_GAMETYPE_CTF )
{
for ( int i=0; i<ICaptureFlagAutoList::AutoList().Count(); ++i )
{
CCaptureFlag *pFlag = static_cast< CCaptureFlag* >( ICaptureFlagAutoList::AutoList()[i] );
if ( pFlag->IsDropped() || pFlag->IsStolen() )
return false;
}
// check that one team hasn't won by capping
if ( CheckCapsPerRound() )
return false;
}
return BaseClass::CanGoToStalemate();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::RestoreActiveTimer( void )
{
BaseClass::RestoreActiveTimer();
if ( IsInKothMode() )
{
CTeamRoundTimer *pTimer = GetBlueKothRoundTimer();
if ( pTimer )
{
pTimer->SetShowInHud( true );
}
pTimer = GetRedKothRoundTimer();
if ( pTimer )
{
pTimer->SetShowInHud( true );
}
}
}
// Classnames of entities that are preserved across round restarts
static const char *s_PreserveEnts[] =
{
"tf_gamerules",
"tf_team_manager",
"tf_player_manager",
"tf_team",
"tf_objective_resource",
"keyframe_rope",
"move_rope",
"tf_viewmodel",
"tf_logic_training",
"tf_logic_training_mode",
#ifdef TF_RAID_MODE
"tf_logic_raid",
#endif // TF_RAID_MODE
"tf_powerup_bottle",
"tf_mann_vs_machine_stats",
"tf_wearable",
"tf_wearable_demoshield",
"tf_wearable_robot_arm",
"tf_wearable_vm",
"tf_logic_bonusround",
"vote_controller",
"monster_resource",
"tf_logic_medieval",
"tf_logic_cp_timer",
"tf_logic_tower_defense", // legacy
"tf_logic_mann_vs_machine",
"func_upgradestation",
"entity_rocket",
"entity_carrier",
"entity_sign",
"entity_saucer",
"tf_halloween_gift_pickup",
"tf_logic_competitive",
"", // END Marker
};
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::Activate()
{
m_nGameType.Set( TF_GAMETYPE_UNDEFINED );
tf_gamemode_arena.SetValue( 0 );
tf_gamemode_cp.SetValue( 0 );
tf_gamemode_ctf.SetValue( 0 );
tf_gamemode_sd.SetValue( 0 );
tf_gamemode_payload.SetValue( 0 );
tf_gamemode_mvm.SetValue( 0 );
tf_gamemode_rd.SetValue( 0 );
tf_gamemode_pd.SetValue( 0 );
tf_gamemode_tc.SetValue( 0 );
tf_beta_content.SetValue( 0 );
tf_gamemode_passtime.SetValue( 0 );
tf_gamemode_misc.SetValue( 0 );
tf_bot_count.SetValue( 0 );
#ifdef TF_RAID_MODE
tf_gamemode_raid.SetValue( 0 );
tf_gamemode_boss_battle.SetValue( 0 );
#endif
m_bPlayingMannVsMachine.Set( false );
m_bBountyModeEnabled.Set( false );
m_nCurrencyAccumulator = 0;
m_iCurrencyPool = 0;
m_bMannVsMachineAlarmStatus.Set( false );
m_bPlayingKoth.Set( false );
m_bPlayingMedieval.Set( false );
m_bPlayingHybrid_CTF_CP.Set( false );
m_bPlayingSpecialDeliveryMode.Set( false );
m_bPlayingRobotDestructionMode.Set( false );
m_bPowerupMode.Set( false );
m_redPayloadToPush = NULL;
m_bluePayloadToPush = NULL;
m_redPayloadToBlock = NULL;
m_bluePayloadToBlock = NULL;
m_zombieMobTimer.Invalidate();
m_zombiesLeftToSpawn = 0;
m_CPTimerEnts.RemoveAll();
m_nMapHolidayType.Set( kHoliday_None );
CArenaLogic *pArenaLogic = dynamic_cast< CArenaLogic * > (gEntList.FindEntityByClassname( NULL, "tf_logic_arena" ) );
if ( pArenaLogic != NULL )
{
m_hArenaEntity = pArenaLogic;
m_nGameType.Set( TF_GAMETYPE_ARENA );
tf_gamemode_arena.SetValue( 1 );
Msg( "Executing server arena config file\n" );
engine->ServerCommand( "exec config_arena.cfg\n" );
}
#ifdef TF_RAID_MODE
CRaidLogic *pRaidLogic = dynamic_cast< CRaidLogic * >( gEntList.FindEntityByClassname( NULL, "tf_logic_raid" ) );
if ( pRaidLogic )
{
m_hRaidLogic = pRaidLogic;
tf_gamemode_raid.SetValue( 1 );
Msg( "Executing server raid game mode config file\n" );
engine->ServerCommand( "exec config_raid.cfg\n" );
}
CBossBattleLogic *pBossBattleLogic = dynamic_cast< CBossBattleLogic * >( gEntList.FindEntityByClassname( NULL, "tf_logic_boss_battle" ) );
if ( pBossBattleLogic )
{
m_hBossBattleLogic = pBossBattleLogic;
tf_gamemode_boss_battle.SetValue( 1 );
}
#endif // TF_RAID_MODE
// This is beta content if this map has "beta" as a tag in the schema
{
const MapDef_t* pMap = GetItemSchema()->GetMasterMapDefByName( STRING( gpGlobals->mapname ) );
if ( pMap && pMap->vecTags.HasElement( GetItemSchema()->GetHandleForTag( "beta" ) ) )
{
tf_beta_content.SetValue( 1 );
}
}
if ( !Q_strncmp( STRING( gpGlobals->mapname ), "tc_", 3 ) )
{
tf_gamemode_tc.SetValue( 1 );
}
CMannVsMachineLogic *pMannVsMachineLogic = dynamic_cast< CMannVsMachineLogic * >( gEntList.FindEntityByClassname( NULL, "tf_logic_mann_vs_machine" ) );
CTeamTrainWatcher *pTrainWatch = dynamic_cast<CTeamTrainWatcher*> ( gEntList.FindEntityByClassname( NULL, "team_train_watcher" ) );
bool bFlag = ICaptureFlagAutoList::AutoList().Count() > 0;
if ( CTFRobotDestructionLogic::GetRobotDestructionLogic() )
{
m_bPlayingRobotDestructionMode.Set( true );
if ( CTFRobotDestructionLogic::GetRobotDestructionLogic()->GetType() == CTFRobotDestructionLogic::TYPE_ROBOT_DESTRUCTION )
{
tf_gamemode_rd.SetValue( 1 );
m_nGameType.Set( TF_GAMETYPE_RD );
tf_beta_content.SetValue( 1 );
}
else
{
tf_gamemode_pd.SetValue( 1 );
m_nGameType.Set( TF_GAMETYPE_PD );
}
}
else if ( pMannVsMachineLogic )
{
m_bPlayingMannVsMachine.Set( true );
tf_gamemode_mvm.SetValue( 1 );
m_nGameType.Set( TF_GAMETYPE_MVM );
}
else if ( StringHasPrefix( STRING( gpGlobals->mapname ), "sd_" ) )
{
m_bPlayingSpecialDeliveryMode.Set( true );
tf_gamemode_sd.SetValue( 1 );
}
else if ( bFlag && !CTFRobotDestructionLogic::GetRobotDestructionLogic() )
{
m_nGameType.Set( TF_GAMETYPE_CTF );
tf_gamemode_ctf.SetValue( 1 );
}
else if ( pTrainWatch )
{
m_nGameType.Set( TF_GAMETYPE_ESCORT );
tf_gamemode_payload.SetValue( 1 );
CMultipleEscort *pMultipleEscort = dynamic_cast<CMultipleEscort*> ( gEntList.FindEntityByClassname( NULL, "tf_logic_multiple_escort" ) );
SetMultipleTrains( pMultipleEscort != NULL );
}
else if ( g_hControlPointMasters.Count() && m_nGameType != TF_GAMETYPE_ARENA ) // We have cap points in arena but we're not CP
{
m_nGameType.Set( TF_GAMETYPE_CP );
tf_gamemode_cp.SetValue( 1 );
}
auto *pPasstime = dynamic_cast<CTFPasstimeLogic*> ( gEntList.FindEntityByClassname( NULL, "passtime_logic" ) );
if ( pPasstime )
{
m_nGameType.Set( TF_GAMETYPE_PASSTIME );
tf_gamemode_passtime.SetValue( 1 );
}
// the game is in training mode if this entity is found
m_hTrainingModeLogic = dynamic_cast< CTrainingModeLogic * > ( gEntList.FindEntityByClassname( NULL, "tf_logic_training_mode" ) );
if ( NULL != m_hTrainingModeLogic )
{
m_bIsInTraining.Set( true );
m_bAllowTrainingAchievements.Set( false );
mp_humans_must_join_team.SetValue( "blue" );
m_bIsTrainingHUDVisible.Set( true );
tf_training_client_message.SetValue( (int)TRAINING_CLIENT_MESSAGE_NONE );
}
m_bIsInItemTestingMode.Set( false );
CKothLogic *pKoth = dynamic_cast<CKothLogic*> ( gEntList.FindEntityByClassname( NULL, "tf_logic_koth" ) );
if ( pKoth )
{
m_bPlayingKoth.Set( true );
}
CMedievalLogic *pMedieval = dynamic_cast<CMedievalLogic*> ( gEntList.FindEntityByClassname( NULL, "tf_logic_medieval" ) );
if ( pMedieval || tf_medieval.GetBool() )
{
m_bPlayingMedieval.Set( true );
}
CCompetitiveLogic *pCompLogic = dynamic_cast< CCompetitiveLogic* > ( gEntList.FindEntityByClassname( NULL, "tf_logic_competitive" ) );
if ( pCompLogic )
{
m_hCompetitiveLogicEntity = pCompLogic;
}
CHybridMap_CTF_CP *pHybridMap_CTF_CP = dynamic_cast<CHybridMap_CTF_CP*> ( gEntList.FindEntityByClassname( NULL, "tf_logic_hybrid_ctf_cp" ) );
if ( pHybridMap_CTF_CP )
{
m_bPlayingHybrid_CTF_CP.Set( true );
}
CTFHolidayEntity *pHolidayEntity = dynamic_cast<CTFHolidayEntity*> ( gEntList.FindEntityByClassname( NULL, "tf_logic_holiday" ) );
if ( pHolidayEntity )
{
m_nMapHolidayType.Set( pHolidayEntity->GetHolidayType() );
}
// bot roster
m_hBlueBotRoster = NULL;
m_hRedBotRoster = NULL;
CHandle<CTFBotRoster> hBotRoster = dynamic_cast< CTFBotRoster* >( gEntList.FindEntityByClassname( NULL, "bot_roster" ) );
while ( hBotRoster != NULL )
{
if ( FStrEq( hBotRoster->m_teamName.ToCStr(), "blue" ) )
{
m_hBlueBotRoster = hBotRoster;
}
else if ( FStrEq( hBotRoster->m_teamName.ToCStr(), "red" ) )
{
m_hRedBotRoster = hBotRoster;
}
else
{
if ( m_hBlueBotRoster == NULL )
{
m_hBlueBotRoster = hBotRoster;
}
if ( m_hRedBotRoster == NULL )
{
m_hRedBotRoster = hBotRoster;
}
}
hBotRoster = dynamic_cast< CTFBotRoster* >( gEntList.FindEntityByClassname( hBotRoster, "bot_roster" ) );
}
CHandle<CCPTimerLogic> hCPTimer = dynamic_cast< CCPTimerLogic* >( gEntList.FindEntityByClassname( NULL, "tf_logic_cp_timer" ) );
while ( hCPTimer != NULL )
{
m_CPTimerEnts.AddToTail( hCPTimer );
hCPTimer = dynamic_cast< CCPTimerLogic* >( gEntList.FindEntityByClassname( hCPTimer, "tf_logic_cp_timer" ) );
}
// hide from the master server if this game is a training game
// or offline practice
if ( IsInTraining() || TheTFBots().IsInOfflinePractice() || IsInItemTestingMode() )
{
hide_server.SetValue( true );
}
m_bVoteCalled = false;
m_bServerVoteOnReset = false;
m_flVoteCheckThrottle = 0;
#ifdef STAGING_ONLY
// Dynamically create an upgrade entity outside MvM
if ( tf_bountymode.GetBool() && !IsBountyMode() )
{
SetBountyMode( true );
}
#endif // STAGING_ONLY
if ( tf_powerup_mode.GetBool() )
{
if ( !IsPowerupMode() )
{
SetPowerupMode( true );
}
}
// if ( !IsInTournamentMode() )
// {
// CExtraMapEntity::SpawnExtraModel();
// }
// If leaving MvM for any other game mode, clean up any sticky UI/state
if ( IsInTournamentMode() && m_nGameType != TF_GAMETYPE_MVM && g_TFGameModeHistory.GetPrevState() == TF_GAMETYPE_MVM )
{
mp_tournament.SetValue( false );
}
if ( GameModeUsesUpgrades() && g_pPopulationManager == NULL )
{
(CPopulationManager *)CreateEntityByName( "info_populator" );
}
if ( tf_gamemode_tc.GetBool() || tf_gamemode_sd.GetBool() || tf_gamemode_pd.GetBool() || m_bPlayingMedieval )
{
tf_gamemode_misc.SetValue( 1 );
}
CBaseEntity *pStageLogic = gEntList.FindEntityByName( NULL, "competitive_stage_logic_case" );
if ( pStageLogic )
{
m_bMapHasMatchSummaryStage.Set( true );
}
m_bCompetitiveMode.Set( false );
const IMatchGroupDescription *pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
if ( pMatchDesc )
{
pMatchDesc->InitGameRulesSettings();
}
CLogicMannPower *pLogicMannPower = dynamic_cast< CLogicMannPower* > ( gEntList.FindEntityByClassname( NULL, "tf_logic_mannpower" ) );
tf_powerup_mode.SetValue( pLogicMannPower ? 1 : 0 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::AllowDamage( CBaseEntity *pVictim, const CTakeDamageInfo &info )
{
bool bRetVal = true;
if ( ( State_Get() == GR_STATE_TEAM_WIN ) && pVictim )
{
if ( pVictim->GetTeamNumber() == GetWinningTeam() )
{
CBaseTrigger *pTrigger = dynamic_cast< CBaseTrigger *>( info.GetInflictor() );
// we don't want players on the winning team to be
// hurt by team-specific trigger_hurt entities during the bonus time
if ( pTrigger && pTrigger->UsesFilter() )
{
bRetVal = false;
}
}
}
return bRetVal;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::SetTeamGoalString( int iTeam, const char *pszGoal )
{
if ( iTeam == TF_TEAM_RED )
{
if ( !pszGoal || !pszGoal[0] )
{
m_pszTeamGoalStringRed.GetForModify()[0] = '\0';
}
else
{
if ( Q_stricmp( m_pszTeamGoalStringRed.Get(), pszGoal ) )
{
Q_strncpy( m_pszTeamGoalStringRed.GetForModify(), pszGoal, MAX_TEAMGOAL_STRING );
}
}
}
else if ( iTeam == TF_TEAM_BLUE )
{
if ( !pszGoal || !pszGoal[0] )
{
m_pszTeamGoalStringBlue.GetForModify()[0] = '\0';
}
else
{
if ( Q_stricmp( m_pszTeamGoalStringBlue.Get(), pszGoal ) )
{
Q_strncpy( m_pszTeamGoalStringBlue.GetForModify(), pszGoal, MAX_TEAMGOAL_STRING );
}
}
}
}
//=============================================================================
// HPE_BEGIN:
// [msmith] Added a HUD type so that we can have the hud independent from the
// game type. This is useful in training where we want a training hud
// Instead of the other types of HUD.
//=============================================================================
//-----------------------------------------------------------------------------
// Purpose: Set a HUD type.
//-----------------------------------------------------------------------------
void CTFGameRules::SetHUDType( int nHudType )
{
if ( nHudType != TF_HUDTYPE_ARENA )
{
if ( nHudType >= TF_HUDTYPE_UNDEFINED && nHudType <= TF_HUDTYPE_TRAINING )
{
m_nHudType.Set( nHudType );
}
}
}
//=============================================================================
// HPE_END
//=============================================================================
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::RoundCleanupShouldIgnore( CBaseEntity *pEnt )
{
if ( FindInList( s_PreserveEnts, pEnt->GetClassname() ) )
return true;
//There has got to be a better way of doing this.
if ( Q_strstr( pEnt->GetClassname(), "tf_weapon_" ) )
return true;
return BaseClass::RoundCleanupShouldIgnore( pEnt );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldCreateEntity( const char *pszClassName )
{
if ( FindInList( s_PreserveEnts, pszClassName ) )
return false;
return BaseClass::ShouldCreateEntity( pszClassName );
}
const char* CTFGameRules::GetStalemateSong( int nTeam )
{
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
{
return (nTeam == TF_TEAM_RED)
? "Announcer.Helltower_Hell_Red_Stalemate"
: "Announcer.Helltower_Hell_Blue_Stalemate";
}
else if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) )
{
return "Announcer.SD_Event_MurderedToStalemate";
}
return "Game.Stalemate";
}
const char* CTFGameRules::WinSongName( int nTeam )
{
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
{
return (nTeam == TF_TEAM_RED)
? "Announcer.Helltower_Hell_Red_Win"
: "Announcer.Helltower_Hell_Blue_Win";
}
return "Game.YourTeamWon";
}
const char* CTFGameRules::LoseSongName( int nTeam )
{
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
{
return (nTeam == TF_TEAM_RED)
? "Announcer.Helltower_Hell_Red_Lose"
: "Announcer.Helltower_Hell_Blue_Lose";
}
else if ( IsMannVsMachineMode() )
{
return "music.mvm_lost_wave";
}
else
{
return BaseClass::LoseSongName( nTeam );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::CleanUpMap( void )
{
#ifdef GAME_DLL
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( !pTFPlayer )
continue;
// Remove all player conditions to prevent some dependency bugs
pTFPlayer->m_Shared.RemoveAllCond();
}
#endif // GAME_DLL
BaseClass::CleanUpMap();
if ( HLTVDirector() )
{
HLTVDirector()->BuildCameraList();
}
#ifdef GAME_DLL
m_hasSpawnedToy = false;
for ( int i = 0; i < TF_TEAM_COUNT; i++ )
{
m_bHasSpawnedSoccerBall[i] = false;
}
// If we're in a mode with upgrades, we force the players to recreate their weapons on next spawn.
// This clears out any weapon upgrades they had in the previous round.
if ( g_hUpgradeEntity )
{
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( !pTFPlayer )
continue;
pTFPlayer->ForceItemRemovalOnRespawn();
// Remove all player upgrades as well
pTFPlayer->RemovePlayerAttributes( false );
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::RecalculateControlPointState( void )
{
Assert( ObjectiveResource() );
if ( !g_hControlPointMasters.Count() )
return;
if ( g_pObjectiveResource && g_pObjectiveResource->PlayingMiniRounds() )
return;
for ( int iTeam = LAST_SHARED_TEAM+1; iTeam < GetNumberOfTeams(); iTeam++ )
{
int iFarthestPoint = GetFarthestOwnedControlPoint( iTeam, true );
if ( iFarthestPoint == -1 )
continue;
// Now enable all spawn points for that spawn point
for ( int i=0; i<ITFTeamSpawnAutoList::AutoList().Count(); ++i )
{
CTFTeamSpawn *pTFSpawn = static_cast< CTFTeamSpawn* >( ITFTeamSpawnAutoList::AutoList()[i] );
if ( pTFSpawn->GetControlPoint() )
{
if ( pTFSpawn->GetTeamNumber() == iTeam )
{
if ( pTFSpawn->GetControlPoint()->GetPointIndex() == iFarthestPoint )
{
pTFSpawn->SetDisabled( false );
}
else
{
pTFSpawn->SetDisabled( true );
}
}
}
}
}
}
DECLARE_AUTO_LIST( ITFTeleportLocationAutoList )
class CTFTeleportLocation : public CPointEntity, public ITFTeleportLocationAutoList
{
public:
DECLARE_CLASS( CTFTeleportLocation, CPointEntity );
};
IMPLEMENT_AUTO_LIST( ITFTeleportLocationAutoList );
LINK_ENTITY_TO_CLASS( tf_teleport_location, CTFTeleportLocation );
void SpawnRunes( void )
{
// Spawn power-up runes when the round starts. Choice of spawn location and Powerup Type is random
CUtlVector< CTFInfoPowerupSpawn* > vecSpawnPoints;
for ( int i = 0; i < IInfoPowerupSpawnAutoList::AutoList().Count(); i++ )
{
CTFInfoPowerupSpawn *pSpawnPoint = static_cast< CTFInfoPowerupSpawn* >( IInfoPowerupSpawnAutoList::AutoList()[i] );
if ( !pSpawnPoint->IsDisabled() && !pSpawnPoint->HasRune() )
{
vecSpawnPoints.AddToTail( pSpawnPoint );
}
}
Assert( vecSpawnPoints.Count() > 0 ); // We need at least one valid info_powerup_spawn
// Warn if there aren't enough valid info_powerup_spawns to spawn all powerups
if ( vecSpawnPoints.Count() < RUNE_TYPES_MAX )
{
Warning( "Warning: Not enough valid info_powerup_spawn locations found. You need a minimum of %i valid locations to spawn all Powerups.\n", RUNE_TYPES_MAX );
}
// try to spawn each rune type
for ( int nRuneTypes = 0; nRuneTypes < RUNE_TYPES_MAX && vecSpawnPoints.Count() > 0; nRuneTypes++ )
{
int index = RandomInt( 0, vecSpawnPoints.Count() - 1 );
CTFInfoPowerupSpawn *pSpawnPoint = vecSpawnPoints[index];
CTFRune *pNewRune = CTFRune::CreateRune( pSpawnPoint->GetAbsOrigin(), (RuneTypes_t) nRuneTypes, TEAM_ANY, false, false );
pSpawnPoint->SetRune( pNewRune );
vecSpawnPoints.Remove( index );
}
}
#ifdef STAGING_ONLY
// Force spawn runes for testing
CON_COMMAND_F( tf_force_spawn_runes, "For testing.", FCVAR_CHEAT )
{
SpawnRunes();
}
#endif
void CTFGameRules::RespawnPlayers( bool bForceRespawn, bool bTeam, int iTeam )
{
// Skip the respawn at the beginning of a round in casual/comp mode since we already
// handled it when the pre-round doors closed over the players' views
if ( IsCompetitiveMode() && ( GetRoundsPlayed() == 0 ) && bForceRespawn && ( State_Get() == GR_STATE_BETWEEN_RNDS || State_Get() == GR_STATE_PREROUND ) )
{
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
if ( !pMaster || !pMaster->PlayingMiniRounds() || ( pMaster->GetCurrentRoundIndex() == 0 ) )
return;
}
BaseClass::RespawnPlayers( bForceRespawn, bTeam, iTeam );
}
//-----------------------------------------------------------------------------
// Purpose: Called when a new round is being initialized
//-----------------------------------------------------------------------------
void CTFGameRules::SetupOnRoundStart( void )
{
for ( int i = 0; i < MAX_TEAMS; i++ )
{
ObjectiveResource()->SetBaseCP( -1, i );
}
for ( int i = 0; i < TF_TEAM_COUNT; i++ )
{
m_iNumCaps[i] = 0;
}
SetOvertime( false );
m_hRedKothTimer.Set( NULL );
m_hBlueKothTimer.Set( NULL );
// Let all entities know that a new round is starting
CBaseEntity *pEnt = gEntList.FirstEnt();
while( pEnt )
{
variant_t emptyVariant;
pEnt->AcceptInput( "RoundSpawn", NULL, NULL, emptyVariant, 0 );
pEnt = gEntList.NextEnt( pEnt );
}
// All entities have been spawned, now activate them
m_areHealthAndAmmoVectorsReady = false;
m_ammoVector.RemoveAll();
m_healthVector.RemoveAll();
pEnt = gEntList.FirstEnt();
while( pEnt )
{
variant_t emptyVariant;
pEnt->AcceptInput( "RoundActivate", NULL, NULL, emptyVariant, 0 );
pEnt = gEntList.NextEnt( pEnt );
}
if ( g_pObjectiveResource && !g_pObjectiveResource->PlayingMiniRounds() )
{
// Find all the control points with associated spawnpoints
memset( m_bControlSpawnsPerTeam, 0, sizeof(bool) * MAX_TEAMS * MAX_CONTROL_POINTS );
for ( int i=0; i<ITFTeamSpawnAutoList::AutoList().Count(); ++i )
{
CTFTeamSpawn *pTFSpawn = static_cast< CTFTeamSpawn* >( ITFTeamSpawnAutoList::AutoList()[i] );
if ( pTFSpawn->GetControlPoint() )
{
m_bControlSpawnsPerTeam[ pTFSpawn->GetTeamNumber() ][ pTFSpawn->GetControlPoint()->GetPointIndex() ] = true;
pTFSpawn->SetDisabled( true );
}
}
RecalculateControlPointState();
SetRoundOverlayDetails();
}
//Do any round specific setup for training logic (resetting the score, messages, etc).
if ( IsInTraining() )
{
if ( m_hTrainingModeLogic )
{
m_hTrainingModeLogic->SetupOnRoundStart();
}
}
m_szMostRecentCappers[0] = 0;
m_halloweenBossTimer.Invalidate();
m_ghostVector.RemoveAll();
m_zombieMobTimer.Invalidate();
m_zombiesLeftToSpawn = 0;
SetIT( NULL );
SetBirthdayPlayer( NULL );
if ( g_pMonsterResource )
{
g_pMonsterResource->HideBossHealthMeter();
}
#ifdef TF_RAID_MODE
if ( IsBossBattleMode() )
{
CTFTeam *enemyTeam = GetGlobalTFTeam( TF_TEAM_RED );
for( int i=0; i<enemyTeam->GetNumPlayers(); ++i )
{
CTFPlayer *who = ToTFPlayer( enemyTeam->GetPlayer( i ) );
who->ChangeTeam( TEAM_SPECTATOR, false, true );
who->RemoveAllObjects();
}
}
#endif // TF_RAID_MODE
if ( IsMannVsMachineMode() )
{
if ( g_hMannVsMachineLogic )
{
g_hMannVsMachineLogic->SetupOnRoundStart();
}
}
m_redPayloadToPush = NULL;
m_bluePayloadToPush = NULL;
m_redPayloadToBlock = NULL;
m_bluePayloadToBlock = NULL;
// Tell the clients to recalculate the holiday
IGameEvent *event = gameeventmanager->CreateEvent( "recalculate_holidays" );
if ( event )
{
gameeventmanager->FireEvent( event );
}
UTIL_CalculateHolidays();
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
{
m_helltowerTimer.Start( HELLTOWER_TIMER_INTERVAL );
}
// reset hell state
SetPlayersInHell( false );
if ( IsPowerupMode() )
{
// Reset imbalance detection scores
m_nPowerupKillsBlueTeam = 0;
m_nPowerupKillsRedTeam = 0;
SpawnRunes();
}
m_hHolidayLogic = dynamic_cast<CTFHolidayEntity*> ( gEntList.FindEntityByClassname( NULL, "tf_logic_holiday" ) );
if ( m_hHolidayLogic.IsValid() )
{
m_hHolidayLogic->ResetWinner();
}
// cache off teleport locations and remove entities to save edicts
m_mapTeleportLocations.PurgeAndDeleteElements();
for ( int i=0; i<ITFTeleportLocationAutoList::AutoList().Count(); ++i )
{
CTFTeleportLocation *pLocation = static_cast< CTFTeleportLocation* >( ITFTeleportLocationAutoList::AutoList()[i] );
int iMap = m_mapTeleportLocations.Find( pLocation->GetEntityName() );
if ( !m_mapTeleportLocations.IsValidIndex( iMap ) )
{
CUtlVector< TeleportLocation_t > *pNew = new CUtlVector< TeleportLocation_t >;
iMap = m_mapTeleportLocations.Insert( pLocation->GetEntityName(), pNew );
}
CUtlVector< TeleportLocation_t > *pLocations = m_mapTeleportLocations[iMap];
int iLocation = pLocations->AddToTail();
pLocations->Element( iLocation ).m_vecPosition = pLocation->GetAbsOrigin();
pLocations->Element( iLocation ).m_qAngles = pLocation->GetAbsAngles();
UTIL_Remove( pLocation );
}
// swap our train model for the EOTL holiday
if ( IsHolidayActive( kHoliday_EOTL ) )
{
for ( int i = 0; i < IPhysicsPropAutoList::AutoList().Count(); i++ )
{
CPhysicsProp *pPhysicsProp = static_cast<CPhysicsProp*>( IPhysicsPropAutoList::AutoList()[i] );
const char *pszTemp = pPhysicsProp->GetModelName().ToCStr();
if ( FStrEq( pszTemp, "models/props_trainyard/bomb_cart.mdl" ) )
{
pPhysicsProp->SetModel( "models/props_trainyard/bomb_eotl_blue.mdl" );
}
else if ( FStrEq( pszTemp, "models/props_trainyard/bomb_cart_red.mdl" ) )
{
pPhysicsProp->SetModel( "models/props_trainyard/bomb_eotl_red.mdl" );
}
}
}
m_flMatchSummaryTeleportTime = -1.f;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::RestartTournament( void )
{
BaseClass::RestartTournament();
if ( GetStopWatchTimer() )
{
UTIL_Remove( GetStopWatchTimer() );
}
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( !pTFPlayer || !pTFPlayer->IsAlive() )
continue;
pTFPlayer->m_Shared.RemoveCond( TF_COND_CRITBOOSTED, true );
pTFPlayer->m_Shared.RemoveCond( TF_COND_CRITBOOSTED_BONUS_TIME, true );
pTFPlayer->m_Shared.RemoveCond( TF_COND_CRITBOOSTED_CTF_CAPTURE, true );
}
ItemSystem()->ReloadWhitelist();
ResetPlayerAndTeamReadyState();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::HandleTeamScoreModify( int iTeam, int iScore )
{
BaseClass::HandleTeamScoreModify( iTeam, iScore );
if ( IsInStopWatch() == true )
{
if ( GetStopWatchTimer() )
{
if ( GetStopWatchTimer()->IsWatchingTimeStamps() == true )
{
GetStopWatchTimer()->SetStopWatchTimeStamp();
}
StopWatchModeThink();
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::StopWatchShouldBeTimedWin_Calculate( void )
{
m_bStopWatchShouldBeTimedWin = false;
if ( IsInTournamentMode() && IsInStopWatch() && ObjectiveResource() )
{
int iStopWatchTimer = ObjectiveResource()->GetStopWatchTimer();
CTeamRoundTimer *pStopWatch = dynamic_cast< CTeamRoundTimer* >( UTIL_EntityByIndex( iStopWatchTimer ) );
if ( pStopWatch && !pStopWatch->IsWatchingTimeStamps() )
{
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
if ( pMaster == NULL )
return;
int iNumPoints = pMaster->GetNumPoints();
CTFTeam *pAttacker = NULL;
CTFTeam *pDefender = NULL;
for ( int i = LAST_SHARED_TEAM+1; i < GetNumberOfTeams(); i++ )
{
CTFTeam *pTeam = GetGlobalTFTeam( i );
if ( pTeam )
{
if ( pTeam->GetRole() == TEAM_ROLE_DEFENDERS )
{
pDefender = pTeam;
}
if ( pTeam->GetRole() == TEAM_ROLE_ATTACKERS )
{
pAttacker = pTeam;
}
}
}
if ( pAttacker == NULL || pDefender == NULL )
return;
m_bStopWatchShouldBeTimedWin = ( pDefender->GetScore() == iNumPoints );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::StopWatchShouldBeTimedWin( void )
{
StopWatchShouldBeTimedWin_Calculate();
return m_bStopWatchShouldBeTimedWin;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::StopWatchModeThink( void )
{
if ( IsInTournamentMode() == false || IsInStopWatch() == false )
return;
if ( GetStopWatchTimer() == NULL )
return;
CTeamRoundTimer *pTimer = GetStopWatchTimer();
bool bWatchingCaps = pTimer->IsWatchingTimeStamps();
CTFTeam *pAttacker = NULL;
CTFTeam *pDefender = NULL;
for ( int i = LAST_SHARED_TEAM+1; i < GetNumberOfTeams(); i++ )
{
CTFTeam *pTeam = GetGlobalTFTeam( i );
if ( pTeam )
{
if ( pTeam->GetRole() == TEAM_ROLE_DEFENDERS )
{
pDefender = pTeam;
}
if ( pTeam->GetRole() == TEAM_ROLE_ATTACKERS )
{
pAttacker = pTeam;
}
}
}
if ( pAttacker == NULL || pDefender == NULL )
return;
m_bStopWatchWinner.Set( false );
if ( bWatchingCaps == false )
{
if ( pTimer->GetTimeRemaining() <= 0.0f )
{
if ( StopWatchShouldBeTimedWin() )
{
if ( pAttacker->GetScore() < pDefender->GetScore() )
{
m_bStopWatchWinner.Set( true );
SetWinningTeam( pDefender->GetTeamNumber(), WINREASON_DEFEND_UNTIL_TIME_LIMIT, true, true );
}
}
else
{
if ( pAttacker->GetScore() > pDefender->GetScore() )
{
m_bStopWatchWinner.Set( true );
SetWinningTeam( pAttacker->GetTeamNumber(), WINREASON_ALL_POINTS_CAPTURED, true, true );
}
}
if ( pTimer->IsTimerPaused() == false )
{
variant_t sVariant;
pTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 );
}
m_nStopWatchState.Set( STOPWATCH_OVERTIME );
}
else
{
if ( pAttacker->GetScore() >= pDefender->GetScore() )
{
m_bStopWatchWinner.Set( true );
SetWinningTeam( pAttacker->GetTeamNumber(), WINREASON_ALL_POINTS_CAPTURED, true, true );
}
}
}
else
{
if ( pTimer->GetTimeRemaining() <= 0.0f )
{
m_nStopWatchState.Set( STOPWATCH_CAPTURE_TIME_NOT_SET );
}
else
{
m_nStopWatchState.Set( STOPWATCH_RUNNING );
}
}
if ( m_bStopWatchWinner == true )
{
UTIL_Remove( pTimer );
m_hStopWatchTimer = NULL;
m_flStopWatchTotalTime = -1.0f;
m_bStopWatch = false;
m_nStopWatchState.Set( STOPWATCH_CAPTURE_TIME_NOT_SET );
ShouldResetRoundsPlayed( false );
ShouldResetScores( true, false );
ResetScores();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::ManageStopwatchTimer( bool bInSetup )
{
if ( IsInTournamentMode() == false )
return;
if ( mp_tournament_stopwatch.GetBool() == false )
return;
bool bAttacking = false;
bool bDefending = false;
for ( int i = LAST_SHARED_TEAM+1; i < GetNumberOfTeams(); i++ )
{
CTFTeam *pTeam = GetGlobalTFTeam( i );
if ( pTeam )
{
if ( pTeam->GetRole() == TEAM_ROLE_DEFENDERS )
{
bDefending = true;
}
if ( pTeam->GetRole() == TEAM_ROLE_ATTACKERS )
{
bAttacking = true;
}
}
}
if ( bDefending == true && bAttacking == true )
{
SetInStopWatch( true );
}
else
{
SetInStopWatch( false );
}
if ( IsInStopWatch() == true )
{
if ( m_hStopWatchTimer == NULL )
{
variant_t sVariant;
CTeamRoundTimer *pStopWatch = (CTeamRoundTimer*)CBaseEntity::CreateNoSpawn( "team_round_timer", vec3_origin, vec3_angle );
m_hStopWatchTimer = pStopWatch;
pStopWatch->SetName( MAKE_STRING("zz_stopwatch_timer") );
pStopWatch->SetShowInHud( false );
pStopWatch->SetStopWatch( true );
if ( m_flStopWatchTotalTime < 0.0f )
{
pStopWatch->SetCaptureWatchState( true );
DispatchSpawn( pStopWatch );
pStopWatch->AcceptInput( "Enable", NULL, NULL, sVariant, 0 );
}
else
{
DispatchSpawn( pStopWatch );
pStopWatch->SetCaptureWatchState( false );
sVariant.SetInt( m_flStopWatchTotalTime );
pStopWatch->AcceptInput( "Enable", NULL, NULL, sVariant, 0 );
pStopWatch->AcceptInput( "SetTime", NULL, NULL, sVariant, 0 );
pStopWatch->SetAutoCountdown( true );
}
if ( bInSetup == true )
{
pStopWatch->AcceptInput( "Pause", NULL, NULL, sVariant, 0 );
}
ObjectiveResource()->SetStopWatchTimer( pStopWatch );
}
else
{
if ( bInSetup == false )
{
variant_t sVariant;
m_hStopWatchTimer->AcceptInput( "Resume", NULL, NULL, sVariant, 0 );
}
else
{
variant_t sVariant;
m_hStopWatchTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::SetSetup( bool bSetup )
{
if ( m_bInSetup == bSetup )
return;
BaseClass::SetSetup( bSetup );
ManageStopwatchTimer( bSetup );
}
//-----------------------------------------------------------------------------
// Purpose: Called when a new round is off and running
//-----------------------------------------------------------------------------
void CTFGameRules::SetupOnRoundRunning( void )
{
// Let out control point masters know that the round has started
for ( int i = 0; i < g_hControlPointMasters.Count(); i++ )
{
variant_t emptyVariant;
if ( g_hControlPointMasters[i] )
{
g_hControlPointMasters[i]->AcceptInput( "RoundStart", NULL, NULL, emptyVariant, 0 );
}
}
// Reset player speeds after preround lock
CTFPlayer *pPlayer;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( !pPlayer )
continue;
pPlayer->TeamFortress_SetSpeed();
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
{
if ( !IsInWaitingForPlayers() )
{
pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_ROUND_START );
}
}
else if ( !IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) )
{
if ( IsCompetitiveMode() )
{
pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_ROUND_START_COMP );
}
else
{
pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_ROUND_START );
}
}
// warp the coach to student
if ( pPlayer->GetStudent() )
{
pPlayer->SetObserverTarget( pPlayer->GetStudent() );
pPlayer->StartObserverMode( OBS_MODE_CHASE );
}
if ( FNullEnt( pPlayer->edict() ) )
continue;
pPlayer->m_Shared.ResetRoundScores();
// Store the class they started the round as (tf_player captures everything after this)
if ( pPlayer->GetTeamNumber() >= FIRST_GAME_TEAM )
{
CSteamID steamID;
pPlayer->GetSteamID( &steamID );
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
if ( pMatch )
{
CMatchInfo::PlayerMatchData_t *pMatchPlayer = pMatch->GetMatchDataForPlayer( steamID );
if ( pMatchPlayer )
{
pMatchPlayer->UpdateClassesPlayed( pPlayer->GetPlayerClass()->GetClassIndex() );
pMatchPlayer->bPlayed = true;
}
}
}
}
if ( IsPlayingSpecialDeliveryMode() && !IsInWaitingForPlayers() )
{
if ( !IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) )
{
BroadcastSound( 255, "Announcer.SD_RoundStart" );
}
}
if ( IsMannVsMachineMode() && g_pPopulationManager )
{
IGameEvent *event = gameeventmanager->CreateEvent( "mvm_begin_wave" );
if ( event )
{
event->SetInt( "wave_index", g_pPopulationManager->GetWaveNumber() );
event->SetInt( "max_waves", g_pPopulationManager->GetTotalWaveCount() );
event->SetInt( "advanced", g_pPopulationManager->IsAdvancedPopFile() ? 1 : 0 );
gameeventmanager->FireEvent( event );
}
}
if ( IsCompetitiveMode() && !( GetActiveRoundTimer() && ( GetActiveRoundTimer()->GetSetupTimeLength() > 0 ) ) )
{
// Announcer VO
if ( ( TFTeamMgr()->GetTeam( TF_TEAM_BLUE )->GetScore() == ( mp_winlimit.GetInt() - 1 ) ) &&
( TFTeamMgr()->GetTeam( TF_TEAM_RED )->GetScore() == ( mp_winlimit.GetInt() - 1 ) ) )
{
BroadcastSound( 255, "Announcer.CompFinalGameBeginsFight" );
}
else
{
BroadcastSound( 255, "Announcer.CompGameBeginsFight" );
}
}
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
if ( pMatch && IsMatchTypeCompetitive() )
{
static ConVarRef tf_bot_quota( "tf_bot_quota" );
tf_bot_quota.SetValue( (int)pMatch->GetCanonicalMatchSize() );
static ConVarRef tf_bot_quota_mode( "tf_bot_quota_mode" );
tf_bot_quota_mode.SetValue( "fill" );
}
if ( m_hGamerulesProxy )
{
m_hGamerulesProxy->StateEnterRoundRunning();
}
}
//-----------------------------------------------------------------------------
// Purpose: Called before a new round is started (so the previous round can end)
//-----------------------------------------------------------------------------
void CTFGameRules::PreviousRoundEnd( void )
{
// before we enter a new round, fire the "end output" for the previous round
if ( g_hControlPointMasters.Count() && g_hControlPointMasters[0] )
{
g_hControlPointMasters[0]->FireRoundEndOutput();
}
m_iPreviousRoundWinners = GetWinningTeam();
}
//-----------------------------------------------------------------------------
// Purpose: Called when a round has entered stalemate mode (timer has run out)
//-----------------------------------------------------------------------------
void CTFGameRules::SetupOnStalemateStart( void )
{
// Remove everyone's objects
RemoveAllProjectilesAndBuildings();
if ( IsInArenaMode() == false )
{
// Respawn all the players
RespawnPlayers( true );
// Disable all the active health packs in the world
m_hDisabledHealthKits.Purge();
CHealthKit *pHealthPack = gEntList.NextEntByClass( (CHealthKit *)NULL );
while ( pHealthPack )
{
if ( !pHealthPack->IsDisabled() )
{
pHealthPack->SetDisabled( true );
m_hDisabledHealthKits.AddToTail( pHealthPack );
}
pHealthPack = gEntList.NextEntByClass( pHealthPack );
}
}
else
{
CArenaLogic *pArenaLogic = dynamic_cast< CArenaLogic * > (gEntList.FindEntityByClassname( NULL, "tf_logic_arena" ) );
if ( pArenaLogic )
{
pArenaLogic->m_OnArenaRoundStart.FireOutput( pArenaLogic, pArenaLogic );
if ( tf_arena_override_cap_enable_time.GetFloat() > 0 )
{
m_flCapturePointEnableTime = gpGlobals->curtime + tf_arena_override_cap_enable_time.GetFloat();
}
else
{
m_flCapturePointEnableTime = gpGlobals->curtime + pArenaLogic->m_flTimeToEnableCapPoint;
}
IGameEvent *event = gameeventmanager->CreateEvent( "arena_round_start" );
if ( event )
{
gameeventmanager->FireEvent( event );
}
BroadcastSound( 255, "Announcer.AM_RoundStartRandom" );
}
}
CTFPlayer *pPlayer;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( !pPlayer )
continue;
if ( IsInArenaMode() == true )
{
pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_ROUND_START );
pPlayer->TeamFortress_SetSpeed();
}
else
{
pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_SUDDENDEATH_START );
}
}
m_flStalemateStartTime = gpGlobals->curtime;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::SetupOnStalemateEnd( void )
{
// Reenable all the health packs we disabled
for ( int i = 0; i < m_hDisabledHealthKits.Count(); i++ )
{
if ( m_hDisabledHealthKits[i] )
{
m_hDisabledHealthKits[i]->SetDisabled( false );
}
}
m_hDisabledHealthKits.Purge();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::InitTeams( void )
{
BaseClass::InitTeams();
// clear the player class data
ResetFilePlayerClassInfoDatabase();
}
class CTraceFilterIgnoreTeammatesWithException : public CTraceFilterSimple
{
DECLARE_CLASS( CTraceFilterIgnoreTeammatesWithException, CTraceFilterSimple );
public:
CTraceFilterIgnoreTeammatesWithException( const IHandleEntity *passentity, int collisionGroup, int iIgnoreTeam, const IHandleEntity *pExceptionEntity )
: CTraceFilterSimple( passentity, collisionGroup ), m_iIgnoreTeam( iIgnoreTeam )
{
m_pExceptionEntity = pExceptionEntity;
}
virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask )
{
CBaseEntity *pEntity = EntityFromEntityHandle( pServerEntity );
if ( pServerEntity == m_pExceptionEntity )
return true;
if ( pEntity->IsPlayer() && pEntity->GetTeamNumber() == m_iIgnoreTeam )
{
return false;
}
return true;
}
int m_iIgnoreTeam;
const IHandleEntity *m_pExceptionEntity;
};
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::RadiusDamage( CTFRadiusDamageInfo &info )
{
float flRadSqr = (info.flRadius * info.flRadius);
int iDamageEnemies = 0;
int nDamageDealt = 0;
// Some weapons pass a radius of 0, since their only goal is to give blast jumping ability
if ( info.flRadius > 0 )
{
// Find all the entities in the radius, and attempt to damage them.
CBaseEntity *pEntity = NULL;
for ( CEntitySphereQuery sphere( info.vecSrc, info.flRadius ); (pEntity = sphere.GetCurrentEntity()) != NULL; sphere.NextEntity() )
{
// Skip the attacker, if we have a RJ radius set. We'll do it post.
if ( info.flRJRadius && pEntity == info.dmgInfo->GetAttacker() )
continue;
// CEntitySphereQuery actually does a box test. So we need to make sure the distance is less than the radius first.
Vector vecPos;
pEntity->CollisionProp()->CalcNearestPoint( info.vecSrc, &vecPos );
if ( (info.vecSrc - vecPos).LengthSqr() > flRadSqr )
continue;
int iDamageToEntity = info.ApplyToEntity( pEntity );
if ( iDamageToEntity )
{
// Keep track of any enemies we damaged
if ( pEntity->IsPlayer() && !pEntity->InSameTeam( info.dmgInfo->GetAttacker() ) )
{
nDamageDealt+= iDamageToEntity;
iDamageEnemies++;
}
}
}
}
// If we have a set RJ radius, use it to affect the inflictor. This way Rocket Launchers
// with modified damage/radius perform like the base rocket launcher when it comes to RJing.
if ( info.flRJRadius && info.dmgInfo->GetAttacker() )
{
// Set our radius & damage to the base RL
info.flRadius = info.flRJRadius;
CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase *>(info.dmgInfo->GetWeapon());
if ( pWeapon )
{
float flBaseDamage = pWeapon->GetTFWpnData().GetWeaponData( TF_WEAPON_PRIMARY_MODE ).m_nDamage;
info.dmgInfo->SetDamage( flBaseDamage );
info.dmgInfo->CopyDamageToBaseDamage();
info.dmgInfo->SetDamagedOtherPlayers( iDamageEnemies );
// If we dealt damage, check radius life leech
if ( nDamageDealt > 0 )
{
// Heal on hits
int iModHealthOnHit = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( info.dmgInfo->GetWeapon(), iModHealthOnHit, add_health_on_radius_damage );
if ( iModHealthOnHit )
{
// Scale Health mod with damage dealt, input being the maximum amount of health possible
float flScale = Clamp( nDamageDealt / flBaseDamage, 0.f, 1.0f );
iModHealthOnHit = (int)( (float)iModHealthOnHit * flScale );
int iHealed = info.dmgInfo->GetAttacker()->TakeHealth( iModHealthOnHit, DMG_GENERIC );
if ( iHealed )
{
IGameEvent *event = gameeventmanager->CreateEvent( "player_healonhit" );
if ( event )
{
event->SetInt( "amount", iHealed );
event->SetInt( "entindex", info.dmgInfo->GetAttacker()->entindex() );
item_definition_index_t healingItemDef = INVALID_ITEM_DEF_INDEX;
if ( pWeapon->GetAttributeContainer() && pWeapon->GetAttributeContainer()->GetItem() )
{
healingItemDef = pWeapon->GetAttributeContainer()->GetItem()->GetItemDefIndex();
}
event->SetInt( "weapon_def_index", healingItemDef );
gameeventmanager->FireEvent( event );
}
}
}
}
}
// Apply ourselves to our attacker, if we're within range
Vector vecPos;
info.dmgInfo->GetAttacker()->CollisionProp()->CalcNearestPoint( info.vecSrc, &vecPos );
if ( (info.vecSrc - vecPos).LengthSqr() <= (info.flRadius * info.flRadius) )
{
info.ApplyToEntity( info.dmgInfo->GetAttacker() );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Calculate the damage falloff over distance
//-----------------------------------------------------------------------------
void CTFRadiusDamageInfo::CalculateFalloff( void )
{
if ( dmgInfo->GetDamageType() & DMG_RADIUS_MAX )
flFalloff = 0.0;
else if ( dmgInfo->GetDamageType() & DMG_HALF_FALLOFF )
flFalloff = 0.5;
else if ( flRadius )
flFalloff = dmgInfo->GetDamage() / flRadius;
else
flFalloff = 1.0;
CBaseEntity *pWeapon = dmgInfo->GetWeapon();
if ( pWeapon != NULL )
{
float flFalloffMod = 1.f;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, flFalloffMod, mult_dmg_falloff );
if ( flFalloffMod != 1.f )
{
flFalloff += flFalloffMod;
}
}
if ( TFGameRules() && TFGameRules()->IsPowerupMode() )
{
CTFPlayer *pOwner = ToTFPlayer( dmgInfo->GetAttacker() );
if ( pOwner && pOwner->m_Shared.GetCarryingRuneType() == RUNE_PRECISION )
{
flFalloff = 1.0;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Attempt to apply the radius damage to the specified entity
//-----------------------------------------------------------------------------
int CTFRadiusDamageInfo::ApplyToEntity( CBaseEntity *pEntity )
{
if ( pEntity == pEntityIgnore || pEntity->m_takedamage == DAMAGE_NO )
return 0;
trace_t tr;
CBaseEntity *pInflictor = dmgInfo->GetInflictor();
// Check that the explosion can 'see' this entity.
Vector vecSpot = pEntity->BodyTarget( vecSrc, false );
CTraceFilterIgnorePlayers filterPlayers( pInflictor, COLLISION_GROUP_PROJECTILE );
CTraceFilterIgnoreFriendlyCombatItems filterCombatItems( pInflictor, COLLISION_GROUP_PROJECTILE, pInflictor->GetTeamNumber() );
CTraceFilterChain filter( &filterPlayers, &filterCombatItems );
UTIL_TraceLine( vecSrc, vecSpot, MASK_RADIUS_DAMAGE, &filter, &tr );
if ( tr.startsolid && tr.m_pEnt )
{
// Return when inside an enemy combat shield and tracing against a player of that team ("absorbed")
if ( tr.m_pEnt->IsCombatItem() && pEntity->InSameTeam( tr.m_pEnt ) && ( pEntity != tr.m_pEnt ) )
return 0;
filterPlayers.SetPassEntity( tr.m_pEnt );
CTraceFilterChain filterSelf( &filterPlayers, &filterCombatItems );
UTIL_TraceLine( vecSrc, vecSpot, MASK_RADIUS_DAMAGE, &filterSelf, &tr );
}
// If we don't trace the whole way to the target, and we didn't hit the target entity, we're blocked
if ( tr.fraction != 1.0 && tr.m_pEnt != pEntity )
return 0;
// Adjust the damage - apply falloff.
float flAdjustedDamage = 0.0f;
float flDistanceToEntity;
// Rockets store the ent they hit as the enemy and have already dealt full damage to them by this time
if ( pInflictor && ( pEntity == pInflictor->GetEnemy() ) )
{
// Full damage, we hit this entity directly
flDistanceToEntity = 0;
}
else if ( pEntity->IsPlayer() )
{
// Use whichever is closer, absorigin or worldspacecenter
float flToWorldSpaceCenter = ( vecSrc - pEntity->WorldSpaceCenter() ).Length();
float flToOrigin = ( vecSrc - pEntity->GetAbsOrigin() ).Length();
flDistanceToEntity = MIN( flToWorldSpaceCenter, flToOrigin );
}
else
{
flDistanceToEntity = ( vecSrc - tr.endpos ).Length();
}
flAdjustedDamage = RemapValClamped( flDistanceToEntity, 0, flRadius, dmgInfo->GetDamage(), dmgInfo->GetDamage() * flFalloff );
CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase *>(dmgInfo->GetWeapon());
// Grenades & Pipebombs do less damage to ourselves.
if ( pEntity == dmgInfo->GetAttacker() && pWeapon )
{
switch( pWeapon->GetWeaponID() )
{
case TF_WEAPON_PIPEBOMBLAUNCHER :
case TF_WEAPON_GRENADELAUNCHER :
case TF_WEAPON_CANNON :
case TF_WEAPON_STICKBOMB :
flAdjustedDamage *= 0.75f;
break;
}
}
// If we end up doing 0 damage, exit now.
if ( flAdjustedDamage <= 0 )
return 0;
// the explosion can 'see' this entity, so hurt them!
if (tr.startsolid)
{
// if we're stuck inside them, fixup the position and distance
tr.endpos = vecSrc;
tr.fraction = 0.0;
}
CTakeDamageInfo adjustedInfo = *dmgInfo;
adjustedInfo.SetDamage( flAdjustedDamage );
Vector dir = vecSpot - vecSrc;
VectorNormalize( dir );
// If we don't have a damage force, manufacture one
if ( adjustedInfo.GetDamagePosition() == vec3_origin || adjustedInfo.GetDamageForce() == vec3_origin )
{
CalculateExplosiveDamageForce( &adjustedInfo, dir, vecSrc );
}
else
{
// Assume the force passed in is the maximum force. Decay it based on falloff.
float flForce = adjustedInfo.GetDamageForce().Length() * flFalloff;
adjustedInfo.SetDamageForce( dir * flForce );
adjustedInfo.SetDamagePosition( vecSrc );
}
adjustedInfo.ScaleDamageForce( m_flForceScale );
int nDamageTaken = 0;
if ( tr.fraction != 1.0 && pEntity == tr.m_pEnt )
{
ClearMultiDamage( );
pEntity->DispatchTraceAttack( adjustedInfo, dir, &tr );
ApplyMultiDamage();
}
else
{
nDamageTaken = pEntity->TakeDamage( adjustedInfo );
}
// Now hit all triggers along the way that respond to damage.
pEntity->TraceAttackToTriggers( adjustedInfo, vecSrc, tr.endpos, dir );
return nDamageTaken;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &info -
// &vecSrcIn -
// flRadius -
// iClassIgnore -
// *pEntityIgnore -
//-----------------------------------------------------------------------------
void CTFGameRules::RadiusDamage( const CTakeDamageInfo &info, const Vector &vecSrcIn, float flRadius, int iClassIgnore, CBaseEntity *pEntityIgnore )
{
// This shouldn't be used. Call the version above that takes a CTFRadiusDamageInfo pointer.
Assert(0);
CTakeDamageInfo dmgInfo = info;
Vector vecSrc = vecSrcIn;
CTFRadiusDamageInfo radiusinfo( &dmgInfo, vecSrc, flRadius, pEntityIgnore );
RadiusDamage(radiusinfo);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::ApplyOnDamageModifyRules( CTakeDamageInfo &info, CBaseEntity *pVictimBaseEntity, bool bAllowDamage )
{
info.SetDamageForForceCalc( info.GetDamage() );
bool bDebug = tf_debug_damage.GetBool();
CTFPlayer *pVictim = ToTFPlayer( pVictimBaseEntity );
CBaseEntity *pAttacker = info.GetAttacker();
CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
// damage may not come from a weapon (ie: Bosses, etc)
// The existing code below already checked for NULL pWeapon, anyways
CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase * >( info.GetWeapon() );
bool bShowDisguisedCrit = false;
bool bAllSeeCrit = false;
EAttackBonusEffects_t eBonusEffect = kBonusEffect_None;
if ( pVictim )
{
pVictim->SetSeeCrit( false, false, false );
pVictim->SetAttackBonusEffect( kBonusEffect_None );
}
int bitsDamage = info.GetDamageType();
// Damage type was already crit (Flares / headshot)
if ( bitsDamage & DMG_CRITICAL )
{
info.SetCritType( CTakeDamageInfo::CRIT_FULL );
}
// First figure out whether this is going to be a full forced crit for some specific reason. It's
// important that we do this before figuring out whether we're going to be a minicrit or not.
// Allow attributes to force critical hits on players with specific conditions
if ( pVictim )
{
// Crit against players that have these conditions
int iCritDamageTypes = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iCritDamageTypes, or_crit_vs_playercond );
if ( iCritDamageTypes )
{
// iCritDamageTypes is an or'd list of types. We need to pull each bit out and
// then test against what that bit in the items_master file maps to.
for ( int i = 0; condition_to_attribute_translation[i] != TF_COND_LAST; i++ )
{
if ( iCritDamageTypes & ( 1 << i ) )
{
if ( pVictim->m_Shared.InCond( condition_to_attribute_translation[ i ] ) )
{
bitsDamage |= DMG_CRITICAL;
info.AddDamageType( DMG_CRITICAL );
info.SetCritType( CTakeDamageInfo::CRIT_FULL );
if ( condition_to_attribute_translation[i] == TF_COND_DISGUISED ||
condition_to_attribute_translation[i] == TF_COND_DISGUISING )
{
// if our attribute specifically crits disguised enemies we need to show it on the client
bShowDisguisedCrit = true;
}
break;
}
}
}
}
int iCritVsWet = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iCritVsWet, crit_vs_wet_players );
if ( iCritVsWet )
{
float flWaterExitTime = pVictim->GetWaterExitTime();
if ( pVictim->m_Shared.InCond( TF_COND_URINE ) ||
pVictim->m_Shared.InCond( TF_COND_MAD_MILK ) ||
( pVictim->GetWaterLevel() > WL_NotInWater ) ||
( ( flWaterExitTime > 0 ) && ( gpGlobals->curtime - flWaterExitTime < 5.0f ) ) ) // or they exited the water in the last few seconds
{
bitsDamage |= DMG_CRITICAL;
info.AddDamageType( DMG_CRITICAL );
info.SetCritType( CTakeDamageInfo::CRIT_FULL );
}
}
// Crit against players that don't have these conditions
int iCritDamageNotTypes = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iCritDamageNotTypes, or_crit_vs_not_playercond );
if ( iCritDamageNotTypes )
{
// iCritDamageTypes is an or'd list of types. We need to pull each bit out and
// then test against what that bit in the items_master file maps to.
for ( int i = 0; condition_to_attribute_translation[i] != TF_COND_LAST; i++ )
{
if ( iCritDamageNotTypes & ( 1 << i ) )
{
if ( !pVictim->m_Shared.InCond( condition_to_attribute_translation[ i ] ) )
{
bitsDamage |= DMG_CRITICAL;
info.AddDamageType( DMG_CRITICAL );
info.SetCritType( CTakeDamageInfo::CRIT_FULL );
if ( condition_to_attribute_translation[ i ] == TF_COND_DISGUISED ||
condition_to_attribute_translation[ i ] == TF_COND_DISGUISING )
{
// if our attribute specifically crits disguised enemies we need to show it on the client
bShowDisguisedCrit = true;
}
break;
}
}
}
}
// Crit burning behind
int iCritBurning = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iCritBurning, axtinguisher_properties );
if ( iCritBurning && pVictim->m_Shared.InCond( TF_COND_BURNING ) )
{
// Full crit in back, mini in front
Vector toEnt = pVictim->GetAbsOrigin() - pTFAttacker->GetAbsOrigin();
{
Vector entForward;
AngleVectors( pVictim->EyeAngles(), &entForward );
toEnt.z = 0;
toEnt.NormalizeInPlace();
if ( DotProduct( toEnt, entForward ) > 0.0f ) // 90 degrees from center (total of 180)
{
bitsDamage |= DMG_CRITICAL;
info.AddDamageType( DMG_CRITICAL );
info.SetCritType( CTakeDamageInfo::CRIT_FULL );
}
else
{
bAllSeeCrit = true;
info.SetCritType( CTakeDamageInfo::CRIT_MINI );
eBonusEffect = kBonusEffect_MiniCrit;
}
}
}
}
int iCritWhileAirborne = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iCritWhileAirborne, crit_while_airborne );
if ( iCritWhileAirborne && pTFAttacker )
{
if ( pTFAttacker->InAirDueToExplosion() )
{
bitsDamage |= DMG_CRITICAL;
info.AddDamageType( DMG_CRITICAL );
info.SetCritType( CTakeDamageInfo::CRIT_FULL );
}
}
// For awarding assist damage stat later
ETFCond eDamageBonusCond = TF_COND_LAST;
// Some forms of damage override long range damage falloff
bool bIgnoreLongRangeDmgEffects = false;
// Figure out if it's a minicrit or not
// But we never minicrit ourselves.
if ( pAttacker != pVictimBaseEntity )
{
if ( info.GetCritType() == CTakeDamageInfo::CRIT_NONE )
{
CBaseEntity *pInflictor = info.GetInflictor();
CTFGrenadePipebombProjectile *pBaseGrenade = dynamic_cast< CTFGrenadePipebombProjectile* >( pInflictor );
CTFBaseRocket *pBaseRocket = dynamic_cast< CTFBaseRocket* >( pInflictor );
if ( pVictim && ( pVictim->m_Shared.InCond( TF_COND_URINE ) ||
pVictim->m_Shared.InCond( TF_COND_MARKEDFORDEATH ) ||
pVictim->m_Shared.InCond( TF_COND_MARKEDFORDEATH_SILENT ) ||
pVictim->m_Shared.InCond( TF_COND_PASSTIME_PENALTY_DEBUFF ) ) )
{
bAllSeeCrit = true;
info.SetCritType( CTakeDamageInfo::CRIT_MINI );
eBonusEffect = kBonusEffect_MiniCrit;
if ( !pVictim->m_Shared.InCond( TF_COND_MARKEDFORDEATH_SILENT ) )
{
eDamageBonusCond = pVictim->m_Shared.InCond( TF_COND_URINE ) ? TF_COND_URINE : TF_COND_MARKEDFORDEATH;
}
}
else if ( pTFAttacker && ( pTFAttacker->m_Shared.InCond( TF_COND_OFFENSEBUFF ) || pTFAttacker->m_Shared.InCond( TF_COND_NOHEALINGDAMAGEBUFF ) ) )
{
// Attackers buffed by the soldier do mini-crits.
bAllSeeCrit = true;
info.SetCritType( CTakeDamageInfo::CRIT_MINI );
eBonusEffect = kBonusEffect_MiniCrit;
if ( pTFAttacker->m_Shared.InCond( TF_COND_OFFENSEBUFF ) )
{
eDamageBonusCond = TF_COND_OFFENSEBUFF;
}
}
else if ( pTFAttacker && (bitsDamage & DMG_RADIUS_MAX) && pWeapon && ( (pWeapon->GetWeaponID() == TF_WEAPON_SWORD) || (pWeapon->GetWeaponID() == TF_WEAPON_BOTTLE)|| (pWeapon->GetWeaponID() == TF_WEAPON_WRENCH) ) )
{
// First sword or bottle attack after a charge is a mini-crit.
bAllSeeCrit = true;
info.SetCritType( CTakeDamageInfo::CRIT_MINI );
eBonusEffect = kBonusEffect_MiniCrit;
}
else if ( ( pInflictor && pInflictor->IsPlayer() == false ) && ( ( pBaseRocket && pBaseRocket->GetDeflected() ) || ( pBaseGrenade && pBaseGrenade->GetDeflected() && ( pBaseGrenade->ShouldMiniCritOnReflect() ) ) ) )
{
// Reflected rockets, grenades (non-remote detonate), arrows always mini-crit
info.SetCritType( CTakeDamageInfo::CRIT_MINI );
eBonusEffect = kBonusEffect_MiniCrit;
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_PLASMA_CHARGED )
{
// Charged plasma shots do minicrits.
info.SetCritType( CTakeDamageInfo::CRIT_MINI );
eBonusEffect = kBonusEffect_MiniCrit;
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_CLEAVER_CRIT )
{
// Long range cleaver hit
info.SetCritType( CTakeDamageInfo::CRIT_MINI );
eBonusEffect = kBonusEffect_MiniCrit;
}
else if ( pTFAttacker && ( pTFAttacker->m_Shared.InCond( TF_COND_ENERGY_BUFF ) ) )
{
// Scouts using crit drink do mini-crits, as well as receive them
info.SetCritType( CTakeDamageInfo::CRIT_MINI );
eBonusEffect = kBonusEffect_MiniCrit;
}
else if ( ( info.GetDamageType() & DMG_IGNITE ) && pVictim && pVictim->m_Shared.InCond( TF_COND_BURNING ) && info.GetDamageCustom() == TF_DMG_CUSTOM_BURNING_FLARE )
{
CTFFlareGun *pFlareGun = dynamic_cast< CTFFlareGun* >( pWeapon );
if ( pFlareGun && pFlareGun->GetFlareGunType() != FLAREGUN_GRORDBORT )
{
info.SetCritType( CTakeDamageInfo::CRIT_MINI );
eBonusEffect = kBonusEffect_MiniCrit;
}
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_FLARE_PELLET )
{
CBaseEntity *pInflictor = info.GetInflictor();
CTFProjectile_Flare *pFlare = dynamic_cast< CTFProjectile_Flare* >( pInflictor );
if ( pFlare && pFlare->IsFromTaunt() && pFlare->GetTimeAlive() < 0.05f )
{
// Taunt crits fired from the scorch shot at short range are super powerful!
info.SetDamage( 400.0f );
}
}
else if( pTFAttacker && pWeapon && pWeapon->GetWeaponID() == TF_WEAPON_CANNON && ( info.GetDamageType() & DMG_BLAST ) )
{
CTFGrenadeLauncher* pGrenadeLauncher = static_cast<CTFGrenadeLauncher*>( pWeapon );
if( pGrenadeLauncher->IsDoubleDonk( pVictim ) )
{
info.SetCritType( CTakeDamageInfo::CRIT_MINI );
eBonusEffect = kBonusEffect_DoubleDonk;
info.SetDamage( info.GetMaxDamage() ); // Double donk victims score max damage
EconEntity_OnOwnerKillEaterEvent( pGrenadeLauncher, pTFAttacker, pVictim, kKillEaterEvent_DoubleDonks );
}
}
else
{
// Allow Attributes to shortcut out if found, no need to check all of them
for ( int i = 0; i < 1; ++i )
{
// Some weapons force minicrits on burning targets.
// Does not work for burn but works for ignite
int iForceMiniCritOnBurning = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iForceMiniCritOnBurning, or_minicrit_vs_playercond_burning );
if ( iForceMiniCritOnBurning == 1 && pVictim && pVictim->m_Shared.InCond( TF_COND_BURNING ) && !( info.GetDamageType() & DMG_BURN ) )
{
bAllSeeCrit = true;
info.SetCritType( CTakeDamageInfo::CRIT_MINI );
eBonusEffect = kBonusEffect_MiniCrit;
break;
}
// Some weapons mini-crit airborne targets. Airborne targets are any target that has been knocked
// into the air by an explosive force from an enemy.
int iMiniCritAirborne = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iMiniCritAirborne, mini_crit_airborne );
if ( iMiniCritAirborne == 1 && pVictim && pVictim->InAirDueToKnockback() )
{
bAllSeeCrit = true;
info.SetCritType( CTakeDamageInfo::CRIT_MINI );
eBonusEffect = kBonusEffect_MiniCrit;
break;
}
//// Some weapons minicrit *any* target in the air, regardless of how they got there.
//int iMiniCritAirborneDeploy = 0;
//CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iMiniCritAirborneDeploy, mini_crit_airborne_deploy );
//if ( iMiniCritAirborneDeploy > 0 &&
// pWeapon &&
// ( gpGlobals->curtime - pWeapon->GetLastDeployTime() ) < iMiniCritAirborneDeploy &&
// //
// pVictim && !( pVictim->GetFlags() & FL_ONGROUND ) &&
// ( pVictim->GetWaterLevel() == WL_NotInWater ) )
//{
// bAllSeeCrit = true;
// info.SetCritType( CTakeDamageInfo::CRIT_MINI );
// eBonusEffect = kBonusEffect_MiniCrit;
// break;
//}
if ( pTFAttacker && pVictim )
{
// MiniCrit a victims back at close range
int iMiniCritBackAttack = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iMiniCritBackAttack, closerange_backattack_minicrits );
Vector toEnt = pVictim->GetAbsOrigin() - pTFAttacker->GetAbsOrigin();
if ( iMiniCritBackAttack == 1 && toEnt.LengthSqr() < Square( 512.0f ) )
{
Vector entForward;
AngleVectors( pVictim->EyeAngles(), &entForward );
toEnt.z = 0;
toEnt.NormalizeInPlace();
if ( DotProduct( toEnt, entForward ) > 0.259f ) // 75 degrees from center (total of 150)
{
bAllSeeCrit = true;
info.SetCritType( CTakeDamageInfo::CRIT_MINI );
eBonusEffect = kBonusEffect_MiniCrit;
break;
}
}
}
}
}
// Don't do long range distance falloff when pAttacker has Rocket Specialist attrib and directly hits an enemy
if ( pBaseRocket && pBaseRocket->GetEnemy() && pBaseRocket->GetEnemy() == pVictimBaseEntity )
{
int iRocketSpecialist = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pAttacker, iRocketSpecialist, rocket_specialist );
if ( iRocketSpecialist )
bIgnoreLongRangeDmgEffects = true;
}
// Some Powerups remove distance damage falloff
if ( pTFAttacker && ( pTFAttacker->m_Shared.GetCarryingRuneType() == RUNE_STRENGTH || pTFAttacker->m_Shared.GetCarryingRuneType() == RUNE_PRECISION ) )
{
bIgnoreLongRangeDmgEffects = true;
}
}
}
if ( info.GetCritType() == CTakeDamageInfo::CRIT_MINI )
{
int iPromoteMiniCritToCrit = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iPromoteMiniCritToCrit, minicrits_become_crits );
if ( iPromoteMiniCritToCrit == 1 )
{
info.SetCritType( CTakeDamageInfo::CRIT_FULL );
eBonusEffect = kBonusEffect_Crit;
bitsDamage |= DMG_CRITICAL;
info.AddDamageType( DMG_CRITICAL );
}
}
if ( pVictim )
{
pVictim->SetSeeCrit( bAllSeeCrit, info.GetCritType() == CTakeDamageInfo::CRIT_MINI, bShowDisguisedCrit );
pVictim->SetAttackBonusEffect( eBonusEffect );
}
// If we're invulnerable, force ourselves to only take damage events only, so we still get pushed
if ( pVictim && pVictim->m_Shared.IsInvulnerable() )
{
if ( !bAllowDamage )
{
int iOldTakeDamage = pVictim->m_takedamage;
pVictim->m_takedamage = DAMAGE_EVENTS_ONLY;
// NOTE: Deliberately skip base player OnTakeDamage, because we don't want all the stuff it does re: suit voice
pVictim->CBaseCombatCharacter::OnTakeDamage( info );
pVictim->m_takedamage = iOldTakeDamage;
// Burn sounds are handled in ConditionThink()
if ( !(bitsDamage & DMG_BURN ) )
{
pVictim->SpeakConceptIfAllowed( MP_CONCEPT_HURT );
}
// If this is critical explosive damage, and the Medic giving us invuln triggered
// it in the last second, he's earned himself an achievement.
if ( (bitsDamage & DMG_CRITICAL) && (bitsDamage & DMG_BLAST) )
{
pVictim->m_Shared.CheckForAchievement( ACHIEVEMENT_TF_MEDIC_SAVE_TEAMMATE );
}
return false;
}
}
if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BACKSTAB )
{
// Jarate backstabber
int iJarateBackstabber = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pVictim, iJarateBackstabber, jarate_backstabber );
if ( iJarateBackstabber > 0 && pTFAttacker )
{
pTFAttacker->m_Shared.AddCond( TF_COND_URINE, 10.0f, pVictim );
pTFAttacker->m_Shared.SetPeeAttacker( pVictim );
pTFAttacker->SpeakConceptIfAllowed( MP_CONCEPT_JARATE_HIT );
}
if ( pVictim && pVictim->CheckBlockBackstab( pTFAttacker ) )
{
// The backstab was absorbed by a shield.
info.SetDamage( 0 );
// Shake nearby players' screens.
UTIL_ScreenShake( pVictim->GetAbsOrigin(), 25.f, 150.0, 1.0, 50.f, SHAKE_START );
// Play the notification sound.
pVictim->EmitSound( "Player.Spy_Shield_Break" );
// Unzoom the sniper.
CTFWeaponBase *pWeapon = pVictim->GetActiveTFWeapon();
if ( pWeapon && WeaponID_IsSniperRifle( pWeapon->GetWeaponID() ) )
{
CTFSniperRifle *pSniperRifle = static_cast< CTFSniperRifle* >( pWeapon );
if ( pSniperRifle->IsZoomed() )
{
pSniperRifle->ZoomOut();
}
}
// Vibrate the spy's knife.
if ( pTFAttacker && pTFAttacker->GetActiveWeapon() )
{
CTFKnife *pKnife = (CTFKnife *) pTFAttacker->GetActiveWeapon();
if ( pKnife )
{
pKnife->BackstabBlocked();
}
}
// Tell the clients involved in the jarate
CRecipientFilter involved_filter;
involved_filter.AddRecipient( pVictim );
involved_filter.AddRecipient( pTFAttacker );
UserMessageBegin( involved_filter, "PlayerShieldBlocked" );
WRITE_BYTE( pTFAttacker->entindex() );
WRITE_BYTE( pVictim->entindex() );
MessageEnd();
}
}
// Apply attributes that increase damage vs players
if ( pWeapon )
{
float flDamage = info.GetDamage();
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, flDamage, mult_dmg_vs_players );
// Check if we're to boost damage against the same class
if( pVictim && pTFAttacker )
{
int nVictimClass = pVictim->GetPlayerClass()->GetClassIndex();
int nAttackerClass = pTFAttacker->GetPlayerClass()->GetClassIndex();
// Same class?
if( nVictimClass == nAttackerClass )
{
// Potentially boost damage
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, flDamage, mult_dmg_vs_same_class );
}
}
info.SetDamage( flDamage );
}
if ( pVictim && !pVictim->m_Shared.InCond( TF_COND_BURNING ) )
{
if ( bitsDamage & DMG_CRITICAL )
{
if ( pTFAttacker && !pTFAttacker->m_Shared.IsCritBoosted() )
{
int iNonBurningCritsDisabled = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iNonBurningCritsDisabled, set_nocrit_vs_nonburning );
if ( iNonBurningCritsDisabled )
{
bitsDamage &= ~DMG_CRITICAL;
info.SetDamageType( info.GetDamageType() & (~DMG_CRITICAL) );
info.SetCritType( CTakeDamageInfo::CRIT_NONE );
}
}
}
float flDamage = info.GetDamage();
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, flDamage, mult_dmg_vs_nonburning );
info.SetDamage( flDamage );
}
// Alien Isolation SetBonus Checking
if ( pVictim && pTFAttacker && pWeapon )
{
// Alien->Merc melee bonus
if ( ( info.GetDamageType() & (DMG_CLUB|DMG_SLASH) ) && info.GetDamageCustom() != TF_DMG_CUSTOM_BASEBALL )
{
CTFWeaponBaseMelee *pMelee = dynamic_cast<CTFWeaponBaseMelee*>( pWeapon );
if ( pMelee )
{
int iAttackerAlien = 0;
int iVictimMerc = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pTFAttacker, iAttackerAlien, alien_isolation_xeno_bonus_pos );
CALL_ATTRIB_HOOK_INT_ON_OTHER( pVictim, iVictimMerc, alien_isolation_merc_bonus_pos );
if ( iAttackerAlien && iVictimMerc )
{
info.SetDamage( info.GetDamage() * 5.0f );
}
}
}
// Merc->Alien MK50 damage, aka flamethrower
if ( ( info.GetDamageType() & DMG_IGNITE ) && pWeapon->GetWeaponID() == TF_WEAPON_FLAMETHROWER )
{
int iAttackerMerc = 0;
int iVictimAlien = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pTFAttacker, iAttackerMerc, alien_isolation_merc_bonus_pos );
CALL_ATTRIB_HOOK_INT_ON_OTHER( pVictim, iVictimAlien, alien_isolation_xeno_bonus_pos );
if ( iAttackerMerc && iVictimAlien )
{
info.SetDamage( info.GetDamage() * 3.0f );
}
}
}
int iPierceResists = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iPierceResists, mod_ignore_resists_absorbs );
// Use defense buffs if it's not a backstab or direct crush damage (telefrage, etc.)
if ( pVictim && info.GetDamageCustom() != TF_DMG_CUSTOM_BACKSTAB && ( info.GetDamageType() & DMG_CRUSH ) == 0 )
{
if ( pVictim->m_Shared.InCond( TF_COND_DEFENSEBUFF ) )
{
// We take no crits of any kind...
if( eBonusEffect == kBonusEffect_MiniCrit || eBonusEffect == kBonusEffect_Crit )
eBonusEffect = kBonusEffect_None;
info.SetCritType( CTakeDamageInfo::CRIT_NONE );
bAllSeeCrit = false;
bShowDisguisedCrit = false;
pVictim->SetSeeCrit( bAllSeeCrit, false, bShowDisguisedCrit );
pVictim->SetAttackBonusEffect( eBonusEffect );
bitsDamage &= ~DMG_CRITICAL;
info.SetDamageType( bitsDamage );
info.SetCritType( CTakeDamageInfo::CRIT_NONE );
}
if ( !iPierceResists )
{
// If we are defense buffed...
if ( pVictim->m_Shared.InCond( TF_COND_DEFENSEBUFF_HIGH ) )
{
// We take 75% less damage... still take crits
info.SetDamage( info.GetDamage() * 0.25f );
}
else if ( pVictim->m_Shared.InCond( TF_COND_DEFENSEBUFF ) || pVictim->m_Shared.InCond( TF_COND_DEFENSEBUFF_NO_CRIT_BLOCK ) )
{
// defense buffs gives 50% to sentry dmg and 35% from all other sources
CObjectSentrygun *pSentry = ( info.GetInflictor() && info.GetInflictor()->IsBaseObject() ) ? dynamic_cast< CObjectSentrygun* >( info.GetInflictor() ) : NULL;
if ( pSentry )
{
info.SetDamage( info.GetDamage() * 0.50f );
}
else
{
// And we take 35% less damage...
info.SetDamage( info.GetDamage() * 0.65f );
}
}
}
}
// A note about why crits now go through the randomness/variance code:
// Normally critical damage is not affected by variance. However, we always want to measure what that variance
// would have been so that we can lump it into the DamageBonus value inside the info. This means crits actually
// boost more than 3X when you factor the reduction we avoided. Example: a rocket that normally would do 50
// damage due to range now does the original 100, which is then multiplied by 3, resulting in a 6x increase.
bool bCrit = ( bitsDamage & DMG_CRITICAL ) ? true : false;
// If we're not damaging ourselves, apply randomness
if ( pAttacker != pVictimBaseEntity && !(bitsDamage & (DMG_DROWN | DMG_FALL)) )
{
float flDamage = info.GetDamage();
float flDmgVariance = 0.f;
// Minicrits still get short range damage bonus
bool bForceCritFalloff = ( bitsDamage & DMG_USEDISTANCEMOD ) &&
( ( bCrit && tf_weapon_criticals_distance_falloff.GetBool() ) ||
( info.GetCritType() == CTakeDamageInfo::CRIT_MINI && tf_weapon_minicrits_distance_falloff.GetBool() ) );
bool bDoShortRangeDistanceIncrease = !bCrit || info.GetCritType() == CTakeDamageInfo::CRIT_MINI ;
bool bDoLongRangeDistanceDecrease = !bIgnoreLongRangeDmgEffects && ( bForceCritFalloff || ( !bCrit && info.GetCritType() != CTakeDamageInfo::CRIT_MINI ) );
// If we're doing any distance modification, we need to do that first
float flRandomDamage = info.GetDamage() * tf_damage_range.GetFloat();
float flRandomDamageSpread = 0.10f;
float flMin = 0.5 - flRandomDamageSpread;
float flMax = 0.5 + flRandomDamageSpread;
if ( bitsDamage & DMG_USEDISTANCEMOD )
{
Vector vAttackerPos = pAttacker->WorldSpaceCenter();
float flOptimalDistance = 512.0;
// Use Sentry position for distance mod
CObjectSentrygun *pSentry = dynamic_cast<CObjectSentrygun*>( info.GetInflictor() );
if ( pSentry )
{
vAttackerPos = pSentry->WorldSpaceCenter();
// Sentries have a much further optimal distance
flOptimalDistance = SENTRY_MAX_RANGE;
}
// The base sniper rifle doesn't have DMG_USEDISTANCEMOD, so this isn't used. Unlockable rifle had it for a bit.
else if ( pWeapon && WeaponID_IsSniperRifle( pWeapon->GetWeaponID() ) )
{
flOptimalDistance *= 2.5f;
}
float flDistance = MAX( 1.0, ( pVictimBaseEntity->WorldSpaceCenter() - vAttackerPos).Length() );
float flCenter = RemapValClamped( flDistance / flOptimalDistance, 0.0, 2.0, 1.0, 0.0 );
if ( ( flCenter > 0.5 && bDoShortRangeDistanceIncrease ) || flCenter <= 0.5 )
{
if ( bitsDamage & DMG_NOCLOSEDISTANCEMOD )
{
if ( flCenter > 0.5 )
{
// Reduce the damage bonus at close range
flCenter = RemapVal( flCenter, 0.5, 1.0, 0.5, 0.65 );
}
}
flMin = MAX( 0.0, flCenter - flRandomDamageSpread );
flMax = MIN( 1.0, flCenter + flRandomDamageSpread );
if ( bDebug )
{
Warning(" RANDOM: Dist %.2f, Ctr: %.2f, Min: %.2f, Max: %.2f\n", flDistance, flCenter, flMin, flMax );
}
}
else
{
if ( bDebug )
{
Warning(" NO DISTANCE MOD: Dist %.2f, Ctr: %.2f, Min: %.2f, Max: %.2f\n", flDistance, flCenter, flMin, flMax );
}
}
}
//Msg("Range: %.2f - %.2f\n", flMin, flMax );
float flRandomRangeVal;
if ( tf_damage_disablespread.GetBool() || ( pTFAttacker && pTFAttacker->m_Shared.GetCarryingRuneType() == RUNE_PRECISION ) )
{
flRandomRangeVal = flMin + flRandomDamageSpread;
}
else
{
flRandomRangeVal = RandomFloat( flMin, flMax );
}
//if ( bDebug )
//{
// Warning( " Val: %.2f\n", flRandomRangeVal );
//}
// Weapon Based Damage Mod
if ( pWeapon && pAttacker && pAttacker->IsPlayer() )
{
switch ( pWeapon->GetWeaponID() )
{
// Rocket launcher only has half the bonus of the other weapons at short range
// Rocket Launchers
case TF_WEAPON_ROCKETLAUNCHER :
case TF_WEAPON_ROCKETLAUNCHER_DIRECTHIT :
case TF_WEAPON_PARTICLE_CANNON :
if ( flRandomRangeVal > 0.5 )
{
flRandomDamage *= 0.5f;
}
break;
case TF_WEAPON_PIPEBOMBLAUNCHER : // Stickies
case TF_WEAPON_GRENADELAUNCHER :
case TF_WEAPON_CANNON :
case TF_WEAPON_STICKBOMB:
if ( !( bitsDamage & DMG_NOCLOSEDISTANCEMOD ) )
{
flRandomDamage *= 0.2f;
}
break;
case TF_WEAPON_SCATTERGUN :
case TF_WEAPON_SODA_POPPER :
case TF_WEAPON_PEP_BRAWLER_BLASTER :
//case TF_WEAPON_HANDGUN_SCOUT_PRIMARY : // Shortstop
// Scattergun gets 50% bonus at short range
if ( flRandomRangeVal > 0.5 )
{
flRandomDamage *= 1.5f;
}
break;
}
}
// Random damage variance.
flDmgVariance = SimpleSplineRemapValClamped( flRandomRangeVal, 0, 1, -flRandomDamage, flRandomDamage );
if ( ( bDoShortRangeDistanceIncrease && flDmgVariance > 0.f ) || bDoLongRangeDistanceDecrease )
{
flDamage = info.GetDamage() + flDmgVariance;
}
if ( bDebug )
{
Warning(" Out: %.2f -> Final %.2f\n", flDmgVariance, flDamage );
}
/*
for ( float flVal = flMin; flVal <= flMax; flVal += 0.05 )
{
float flOut = SimpleSplineRemapValClamped( flVal, 0, 1, -flRandomDamage, flRandomDamage );
Msg("Val: %.2f, Out: %.2f, Dmg: %.2f\n", flVal, flOut, info.GetDamage() + flOut );
}
*/
// Burn sounds are handled in ConditionThink()
if ( !(bitsDamage & DMG_BURN ) && pVictim )
{
pVictim->SpeakConceptIfAllowed( MP_CONCEPT_HURT );
}
// Save any bonus damage as a separate value
float flCritDamage = 0.f;
// Yes, it's weird that we sometimes fabs flDmgVariance. Here's why: In the case of a crit rocket, we
// know that number will generally be negative due to dist or randomness. In this case, we want to track
// that effect - even if we don't apply it. In the case of our crit rocket that normally would lose 50
// damage, we fabs'd so that we can account for it as a bonus - since it's present in a crit.
float flBonusDamage = bForceCritFalloff ? 0.f : fabs( flDmgVariance );
CTFPlayer *pProvider = NULL;
if ( info.GetCritType() == CTakeDamageInfo::CRIT_MINI )
{
// We should never have both of these flags set or Weird Things will happen with the damage numbers
// that aren't clear to the players. Or us, really.
Assert( !(bitsDamage & DMG_CRITICAL) );
if ( bDebug )
{
Warning( " MINICRIT: Dmg %.2f -> ", flDamage );
}
COMPILE_TIME_ASSERT( TF_DAMAGE_MINICRIT_MULTIPLIER > 1.f );
flCritDamage = ( TF_DAMAGE_MINICRIT_MULTIPLIER - 1.f ) * flDamage;
bitsDamage |= DMG_CRITICAL;
info.AddDamageType( DMG_CRITICAL );
// Any condition assist stats to send out?
if ( eDamageBonusCond < TF_COND_LAST )
{
if ( pVictim )
{
pProvider = ToTFPlayer( pVictim->m_Shared.GetConditionProvider( eDamageBonusCond ) );
if ( pProvider )
{
CTF_GameStats.Event_PlayerDamageAssist( pProvider, flCritDamage + flBonusDamage );
}
}
if ( pTFAttacker )
{
pProvider = ToTFPlayer( pTFAttacker->m_Shared.GetConditionProvider( eDamageBonusCond ) );
if ( pProvider && pProvider != pTFAttacker )
{
CTF_GameStats.Event_PlayerDamageAssist( pProvider, flCritDamage + flBonusDamage );
}
}
}
if ( bDebug )
{
Warning( "reduced to %.2f before crit mult\n", flDamage );
}
}
if ( bCrit )
{
if ( info.GetCritType() != CTakeDamageInfo::CRIT_MINI )
{
COMPILE_TIME_ASSERT( TF_DAMAGE_CRIT_MULTIPLIER > 1.f );
flCritDamage = ( TF_DAMAGE_CRIT_MULTIPLIER - 1.f ) * flDamage;
}
if ( bDebug )
{
Warning( " CRITICAL! Damage: %.2f\n", flDamage );
}
// Burn sounds are handled in ConditionThink()
if ( !(bitsDamage & DMG_BURN ) && pVictim )
{
pVictim->SpeakConceptIfAllowed( MP_CONCEPT_HURT, "damagecritical:1" );
}
if ( pTFAttacker && pTFAttacker->m_Shared.IsCritBoosted() )
{
pProvider = ToTFPlayer( pTFAttacker->m_Shared.GetConditionProvider( TF_COND_CRITBOOSTED ) );
if ( pProvider && pTFAttacker && pProvider != pTFAttacker )
{
CTF_GameStats.Event_PlayerDamageAssist( pProvider, flCritDamage + flBonusDamage );
}
}
}
if ( pAttacker && pAttacker->IsPlayer() )
{
// Modify damage based on bonuses
flDamage *= pTFAttacker->m_Shared.GetTmpDamageBonus();
}
// Store the extra damage and update actual damage
if ( bCrit || info.GetCritType() == CTakeDamageInfo::CRIT_MINI )
{
info.SetDamageBonus( flCritDamage + flBonusDamage, pProvider ); // Order-of-operations sensitive, but fine as long as TF_COND_CRITBOOSTED is last
}
// Crit-A-Cola and Steak Sandwich - only increase normal damage
if ( pVictim && pVictim->m_Shared.InCond( TF_COND_ENERGY_BUFF ) && !bCrit && info.GetCritType() != CTakeDamageInfo::CRIT_MINI )
{
float flDmgMult = 1.f;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flDmgMult, energy_buff_dmg_taken_multiplier );
flDamage *= flDmgMult;
}
info.SetDamage( flDamage + flCritDamage );
}
if ( pTFAttacker && pTFAttacker->IsPlayerClass( TF_CLASS_SPY ) )
{
if ( pTFAttacker->GetActiveWeapon() )
{
int iAddCloakOnHit = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pTFAttacker->GetActiveWeapon(), iAddCloakOnHit, add_cloak_on_hit );
if ( iAddCloakOnHit > 0 )
{
pTFAttacker->m_Shared.AddToSpyCloakMeter( iAddCloakOnHit, true );
}
}
}
// Apply on-hit attributes
if ( pVictim && pAttacker && pAttacker->GetTeam() != pVictim->GetTeam() && pAttacker->IsPlayer() && pWeapon )
{
pWeapon->ApplyOnHitAttributes( pVictimBaseEntity, pTFAttacker, info );
}
// Give assist points to the provider of any stun on the victim - up to half the damage, based on the amount of stun
if ( pVictim && pVictim->m_Shared.InCond( TF_COND_STUNNED ) )
{
CTFPlayer *pProvider = ToTFPlayer( pVictim->m_Shared.GetConditionProvider( TF_COND_STUNNED ) );
if ( pProvider && pTFAttacker && pProvider != pTFAttacker )
{
float flStunAmount = pVictim->m_Shared.GetAmountStunned( TF_STUN_MOVEMENT );
if ( flStunAmount < 1.f && pVictim->m_Shared.IsControlStunned() )
flStunAmount = 1.f;
int nAssistPoints = RemapValClamped( flStunAmount, 0.1f, 1.f, 1, ( info.GetDamage() / 2 ) );
if ( nAssistPoints )
{
CTF_GameStats.Event_PlayerDamageAssist( pProvider, nAssistPoints );
}
}
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static bool CheckForDamageTypeImmunity( int nDamageType, CTFPlayer* pVictim, float &flDamageBase, float &flCritBonusDamage )
{
bool bImmune = false;
if( nDamageType & (DMG_BURN|DMG_IGNITE) )
{
bImmune = pVictim->m_Shared.InCond( TF_COND_FIRE_IMMUNE );
}
else if( nDamageType & (DMG_BULLET|DMG_BUCKSHOT) )
{
bImmune = pVictim->m_Shared.InCond( TF_COND_BULLET_IMMUNE );
}
else if( nDamageType & DMG_BLAST )
{
bImmune = pVictim->m_Shared.InCond( TF_COND_BLAST_IMMUNE );
}
if( bImmune )
{
flDamageBase = flCritBonusDamage = 0.f;
IGameEvent* event = gameeventmanager->CreateEvent( "damage_resisted" );
if ( event )
{
event->SetInt( "entindex", pVictim->entindex() );
gameeventmanager->FireEvent( event );
}
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static bool CheckMedicResist( ETFCond ePassiveCond, ETFCond eDeployedCond, CTFPlayer* pVictim, float flRawDamage, float& flDamageBase, bool bCrit, float& flCritBonusDamage )
{
// Might be a tank or some other object that's getting shot
if( !pVictim || !pVictim->IsPlayer() )
return false;
ETFCond eActiveCond;
// Be in the condition!
if( pVictim->m_Shared.InCond( eDeployedCond ) )
{
eActiveCond = eDeployedCond;
}
else if( pVictim->m_Shared.InCond( ePassiveCond ) )
{
eActiveCond = ePassiveCond;
}
else
{
return false;
}
// Get our condition provider
CBaseEntity* pProvider = pVictim->m_Shared.GetConditionProvider( eActiveCond );
CTFPlayer* pTFProvider = ToTFPlayer( pProvider );
Assert( pTFProvider );
float flDamageScale = 0.f;
//float flCritBarDeplete = 0.f;
bool bUberResist = false;
if( pTFProvider )
{
switch( eActiveCond )
{
case TF_COND_MEDIGUN_UBER_BULLET_RESIST:
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flDamageScale, medigun_bullet_resist_deployed );
bUberResist = true;
// if ( bCrit )
// {
// CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flCritBarDeplete, medigun_crit_bullet_percent_bar_deplete );
// }
break;
case TF_COND_MEDIGUN_SMALL_BULLET_RESIST:
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flDamageScale, medigun_bullet_resist_passive );
break;
case TF_COND_MEDIGUN_UBER_BLAST_RESIST:
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flDamageScale, medigun_blast_resist_deployed );
bUberResist = true;
//if( bCrit )
//{
// CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flCritBarDeplete, medigun_crit_blast_percent_bar_deplete );
//}
break;
case TF_COND_MEDIGUN_SMALL_BLAST_RESIST:
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flDamageScale, medigun_blast_resist_passive );
break;
case TF_COND_MEDIGUN_UBER_FIRE_RESIST:
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flDamageScale, medigun_fire_resist_deployed );
bUberResist = true;
// if( bCrit )
// {
// CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flCritBarDeplete, medigun_crit_fire_percent_bar_deplete );
// }
break;
case TF_COND_MEDIGUN_SMALL_FIRE_RESIST:
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flDamageScale, medigun_fire_resist_passive );
break;
}
}
if ( bUberResist && pVictim->m_Shared.InCond( TF_COND_HEALING_DEBUFF ) )
{
flDamageScale *= 0.75f;
}
flDamageScale = 1.f - flDamageScale;
if( flDamageScale < 0.f )
flDamageScale = 0.f;
//// Dont let the medic heal themselves when they take damage
//if( pTFProvider && pTFProvider != pVictim )
//{
// // Heal the medic for 10% of the incoming damage
// int nHeal = flRawDamage * 0.10f;
// // Heal!
// int iHealed = pTFProvider->TakeHealth( nHeal, DMG_GENERIC );
// // Tell them about it!
// if ( iHealed )
// {
// CTF_GameStats.Event_PlayerHealedOther( pTFProvider, iHealed );
// }
// IGameEvent *event = gameeventmanager->CreateEvent( "player_healonhit" );
// if ( event )
// {
// event->SetInt( "amount", nHeal );
// event->SetInt( "entindex", pTFProvider->entindex() );
// gameeventmanager->FireEvent( event );
// }
//}
IGameEvent* event = gameeventmanager->CreateEvent( "damage_resisted" );
if ( event )
{
event->SetInt( "entindex", pVictim->entindex() );
gameeventmanager->FireEvent( event );
}
if ( bCrit && pTFProvider && bUberResist )
{
flCritBonusDamage = ( pVictim->m_Shared.InCond( TF_COND_HEALING_DEBUFF ) ) ? flCritBonusDamage *= 0.25f : 0.f;
//CWeaponMedigun* pMedigun = dynamic_cast<CWeaponMedigun*>( pTFProvider->Weapon_OwnsThisID( TF_WEAPON_MEDIGUN ) );
//if( pMedigun )
//{
// if( pMedigun->GetChargeLevel() > 0.f && pMedigun->IsReleasingCharge() )
// {
// flCritBonusDamage = 0;
// }
// pMedigun->SubtractCharge( flCritBarDeplete );
//}
}
// Scale the damage!
flDamageBase = flDamageBase * flDamageScale;
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static void PotentiallyFireDamageMitigatedEvent( const CTFPlayer* pMitigator, const CTFPlayer* pDamaged, const CEconEntity* pMitigationProvidingEconItem, float flBeforeDamage, float flAfterDamage )
{
int nAmount = flBeforeDamage - flAfterDamage;
// Nothing mitigated!
if ( nAmount == 0 )
return;
IGameEvent *pEvent = gameeventmanager->CreateEvent( "damage_mitigated" );
if ( pEvent )
{
item_definition_index_t nDefIndex = INVALID_ITEM_DEF_INDEX;
if ( pMitigationProvidingEconItem && pMitigationProvidingEconItem->GetAttributeContainer() && pMitigationProvidingEconItem->GetAttributeContainer()->GetItem() )
{
nDefIndex = pMitigationProvidingEconItem->GetAttributeContainer()->GetItem()->GetItemDefinition()->GetDefinitionIndex();
}
pEvent->SetInt( "mitigator", pMitigator ? pMitigator->GetUserID() : -1 );
pEvent->SetInt( "damaged", pDamaged ? pDamaged->GetUserID() : -1 );
pEvent->SetInt( "amount", nAmount );
pEvent->SetInt( "itemdefindex", nDefIndex );
gameeventmanager->FireEvent( pEvent, true );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CTFGameRules::ApplyOnDamageAliveModifyRules( const CTakeDamageInfo &info, CBaseEntity *pVictimBaseEntity, DamageModifyExtras_t& outParams )
{
CTFPlayer *pVictim = ToTFPlayer( pVictimBaseEntity );
CBaseEntity *pAttacker = info.GetAttacker();
CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
float flRealDamage = info.GetDamage();
if ( pVictimBaseEntity && pVictimBaseEntity->m_takedamage != DAMAGE_EVENTS_ONLY && pVictim )
{
int iDamageTypeBits = info.GetDamageType() & DMG_IGNITE;
// Handle attributes that want to change our damage type, but only if we're taking damage from a non-DOT. This
// stops fire DOT damage from constantly reigniting us. This will also prevent ignites from happening on the
// damage *from-a-bleed-DOT*, but not from the bleed application attack.
if ( !IsDOTDmg( info.GetDamageCustom() ) )
{
int iAddBurningDamageType = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iAddBurningDamageType, set_dmgtype_ignite );
if ( iAddBurningDamageType )
{
iDamageTypeBits |= DMG_IGNITE;
}
}
// Start burning if we took ignition damage
outParams.bIgniting = ( ( iDamageTypeBits & DMG_IGNITE ) && ( !pVictim || pVictim->GetWaterLevel() < WL_Waist ) );
if ( outParams.bIgniting && pVictim )
{
if ( pVictim->m_Shared.InCond( TF_COND_DISGUISED ) )
{
int iDisguiseNoBurn = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pVictim, iDisguiseNoBurn, disguise_no_burn );
if ( iDisguiseNoBurn == 1 )
{
// Do a hard out in the caller
return -1;
}
}
if ( pVictim->m_Shared.InCond( TF_COND_FIRE_IMMUNE ) )
{
// Do a hard out in the caller
return -1;
}
}
// When obscured by smoke, attacks have a chance to miss
if ( pVictim && pVictim->m_Shared.InCond( TF_COND_OBSCURED_SMOKE ) )
{
if ( RandomInt( 1, 4 ) >= 2 )
{
flRealDamage = 0.f;
pVictim->SpeakConceptIfAllowed( MP_CONCEPT_DODGE_SHOT );
if ( pTFAttacker )
{
CEffectData data;
data.m_nHitBox = GetParticleSystemIndex( "miss_text" );
data.m_vOrigin = pVictim->WorldSpaceCenter() + Vector( 0.f , 0.f, 32.f );
data.m_vAngles = vec3_angle;
data.m_nEntIndex = 0;
CSingleUserRecipientFilter filter( pTFAttacker );
te->DispatchEffect( filter, 0.f, data.m_vOrigin, "ParticleEffect", data );
}
// No damage
return -1.f;
}
}
// Proc invicibility upon being hit
float flUberChance = 0.f;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flUberChance, uber_on_damage_taken );
if( RandomFloat() < flUberChance )
{
pVictim->m_Shared.AddCond( TF_COND_INVULNERABLE_CARD_EFFECT, 3.f );
// Make sure we don't take any damage
flRealDamage = 0.f;
}
// Resists and Boosts
float flDamageBonus = info.GetDamageBonus();
float flDamageBase = flRealDamage - flDamageBonus;
Assert( flDamageBase >= 0.f );
int iPierceResists = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iPierceResists, mod_pierce_resists_absorbs );
// This raw damage wont get scaled. Used for determining how much health to give resist medics.
float flRawDamage = flDamageBase;
// Check if we're immune
outParams.bPlayDamageReductionSound = CheckForDamageTypeImmunity( info.GetDamageType(), pVictim, flDamageBase, flDamageBonus );
if ( !iPierceResists )
{
// Reduce only the crit portion of the damage with crit resist
bool bCrit = ( info.GetDamageType() & DMG_CRITICAL ) > 0;
if ( bCrit )
{
// Break the damage down and reassemble
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flDamageBonus, mult_dmgtaken_from_crit );
}
// Apply general dmg type reductions. Should we only ever apply one of these? (Flaregun is DMG_BULLET|DMG_IGNITE, for instance)
if ( info.GetDamageType() & (DMG_BURN|DMG_IGNITE) )
{
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flDamageBase, mult_dmgtaken_from_fire );
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim->GetActiveWeapon(), flDamageBase, mult_dmgtaken_from_fire_active );
// Check for medic resist
outParams.bPlayDamageReductionSound = CheckMedicResist( TF_COND_MEDIGUN_SMALL_FIRE_RESIST, TF_COND_MEDIGUN_UBER_FIRE_RESIST, pVictim, flRawDamage, flDamageBase, bCrit, flDamageBonus );
}
if ( pTFAttacker && pVictim && pVictim->m_Shared.InCond( TF_COND_BURNING ) )
{
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFAttacker->GetActiveWeapon(), flDamageBase, mult_dmg_vs_burning );
}
if ( (info.GetDamageType() & (DMG_BLAST) ) )
{
bool bReduceBlast = false;
// If someone else shot us or we're in MvM
if( pAttacker != pVictimBaseEntity || IsMannVsMachineMode() )
{
bReduceBlast = true;
}
if ( bReduceBlast )
{
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flDamageBase, mult_dmgtaken_from_explosions );
// Check for medic resist
outParams.bPlayDamageReductionSound = CheckMedicResist( TF_COND_MEDIGUN_SMALL_BLAST_RESIST, TF_COND_MEDIGUN_UBER_BLAST_RESIST, pVictim, flRawDamage, flDamageBase, bCrit, flDamageBonus );
}
}
if ( info.GetDamageType() & (DMG_BULLET|DMG_BUCKSHOT) )
{
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flDamageBase, mult_dmgtaken_from_bullets );
// Check for medic resist
outParams.bPlayDamageReductionSound = CheckMedicResist( TF_COND_MEDIGUN_SMALL_BULLET_RESIST, TF_COND_MEDIGUN_UBER_BULLET_RESIST, pVictim, flRawDamage, flDamageBase, bCrit, flDamageBonus );
}
if ( info.GetDamageType() & DMG_MELEE )
{
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flDamageBase, mult_dmgtaken_from_melee );
}
if ( pVictim->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && pVictim->m_Shared.InCond( TF_COND_AIMING ) && ( ( pVictim->GetHealth() - flRealDamage ) / pVictim->GetMaxHealth() ) <= 0.5f )
{
float flOriginalDamage = flDamageBase;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flDamageBase, spunup_damage_resistance );
if ( flOriginalDamage != flDamageBase )
{
pVictim->PlayDamageResistSound( flOriginalDamage, flDamageBase );
}
}
}
// If the damage changed at all play the resist sound
if ( flDamageBase != flRawDamage )
{
outParams.bPlayDamageReductionSound = true;
}
// Stomp flRealDamage with resist adjusted values
flRealDamage = flDamageBase + flDamageBonus;
// Some Powerups apply a damage multiplier. Backstabs are immune to resist protection
if ( ( pVictim && info.GetDamageCustom() != TF_DMG_CUSTOM_BACKSTAB ) )
{
// Plague bleed damage is immune from resist calculation
if ( ( !pVictim->m_Shared.InCond( TF_COND_PLAGUE ) && info.GetDamageCustom() != TF_DMG_CUSTOM_BLEEDING ) )
{
if ( pVictim->m_Shared.GetCarryingRuneType() == RUNE_RESIST )
{
flRealDamage *= 0.5f;
outParams.bPlayDamageReductionSound = true;
IGameEvent* event = gameeventmanager->CreateEvent( "damage_resisted" );
if ( event )
{
event->SetInt( "entindex", pVictim->entindex() );
gameeventmanager->FireEvent( event );
}
}
else if ( ( pVictim->m_Shared.GetCarryingRuneType() == RUNE_VAMPIRE ) )
{
flRealDamage *= 0.75f;
outParams.bPlayDamageReductionSound = true;
}
//Plague powerup carrier is resistant to infected enemies
else if ( pTFAttacker && ( pVictim->m_Shared.GetCarryingRuneType() == RUNE_PLAGUE ) && pTFAttacker->m_Shared.InCond( TF_COND_PLAGUE ) )
{
flRealDamage *= 0.5f;
outParams.bPlayDamageReductionSound = true;
}
}
}
// End Resists
// Increased damage taken from all sources
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flRealDamage, mult_dmgtaken );
if ( info.GetInflictor() && info.GetInflictor()->IsBaseObject() )
{
CObjectSentrygun* pSentry = dynamic_cast<CObjectSentrygun*>( info.GetInflictor() );
if ( pSentry )
{
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flRealDamage, dmg_from_sentry_reduced );
}
}
if ( IsMannVsMachineMode() )
{
if ( pTFAttacker && pTFAttacker->IsBot() && pAttacker != pVictimBaseEntity && pVictim && !pVictim->IsBot() )
{
flRealDamage *= g_pPopulationManager ? g_pPopulationManager->GetDamageMultiplier() : tf_populator_damage_multiplier.GetFloat();
}
}
// Heavy rage-based knockback+stun effect that also reduces their damage output
if ( pTFAttacker && pTFAttacker->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
{
int iRage = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pTFAttacker, iRage, generate_rage_on_dmg );
if ( iRage && pTFAttacker->m_Shared.IsRageDraining() )
{
flRealDamage *= 0.5f;
}
}
if ( pVictim && pTFAttacker && info.GetWeapon() )
{
CTFWeaponBase *pWeapon = pTFAttacker->GetActiveTFWeapon();
if ( pWeapon && pWeapon->GetWeaponID() == TF_WEAPON_SNIPERRIFLE && info.GetWeapon() == pWeapon )
{
CTFSniperRifle *pRifle = static_cast< CTFSniperRifle* >( info.GetWeapon() );
float flStun = 1.0f;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pRifle, flStun, applies_snare_effect );
if ( flStun != 1.0f )
{
float flDuration = pRifle->GetJarateTime();
pVictim->m_Shared.StunPlayer( flDuration, flStun, TF_STUN_MOVEMENT, pTFAttacker );
}
}
}
if ( pVictim && pVictim->GetActiveTFWeapon() )
{
if ( info.GetDamageType() & (DMG_CLUB) )
{
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim->GetActiveTFWeapon(), flRealDamage, dmg_from_melee );
}
else if ( info.GetDamageType() & (DMG_BLAST|DMG_BULLET|DMG_BUCKSHOT|DMG_IGNITE|DMG_SONIC) )
{
float flBeforeDamage = flRealDamage;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim->GetActiveTFWeapon(), flRealDamage, dmg_from_ranged );
PotentiallyFireDamageMitigatedEvent( pVictim, pVictim, pVictim->GetActiveTFWeapon(), flBeforeDamage, flRealDamage );
}
}
outParams.bSendPreFeignDamage = false;
if ( pVictim && pVictim->IsPlayerClass( TF_CLASS_SPY ) && ( info.GetDamageCustom() != TF_DMG_CUSTOM_TELEFRAG ) && !pVictim->IsTaunting() )
{
// STAGING_SPY
// Reduce damage taken if we have recently feigned death.
if ( pVictim->m_Shared.InCond( TF_COND_FEIGN_DEATH ) || pVictim->m_Shared.IsFeignDeathReady() )
{
// Damage reduction is proportional to cloak remaining (60%->20%)
float flDamageReduction = RemapValClamped( pVictim->m_Shared.GetSpyCloakMeter(), 50.0f, 0.0f, tf_feign_death_damage_scale.GetFloat(), tf_stealth_damage_reduction.GetFloat() );
// On Activate Reduce Remaining Cloak by 50%
if ( pVictim->m_Shared.IsFeignDeathReady() )
{
flDamageReduction = tf_feign_death_activate_damage_scale.GetFloat();
}
outParams.bSendPreFeignDamage = true;
float flBeforeflRealDamage = flRealDamage;
flRealDamage *= flDamageReduction;
CTFWeaponInvis *pWatch = (CTFWeaponInvis *) pVictim->Weapon_OwnsThisID( TF_WEAPON_INVIS );
PotentiallyFireDamageMitigatedEvent( pVictim, pVictim, pWatch, flBeforeflRealDamage, flRealDamage );
// Original damage would've killed the player, but the reduced damage wont
if ( flBeforeflRealDamage >= pVictim->GetHealth() && flRealDamage < pVictim->GetHealth() )
{
IGameEvent *pEvent = gameeventmanager->CreateEvent( "deadringer_cheat_death" );
if ( pEvent )
{
pEvent->SetInt( "spy", pVictim->GetUserID() );
pEvent->SetInt( "attacker", pTFAttacker ? pTFAttacker->GetUserID() : -1 );
gameeventmanager->FireEvent( pEvent, true );
}
}
}
// Standard Stealth gives small damage reduction
else if ( pVictim->m_Shared.InCond( TF_COND_STEALTHED ) )
{
flRealDamage *= tf_stealth_damage_reduction.GetFloat();
}
}
if ( flRealDamage == 0.0f )
{
// Do a hard out in the caller
return -1;
}
if ( pAttacker == pVictimBaseEntity && (info.GetDamageType() & DMG_BLAST) &&
info.GetDamagedOtherPlayers() == 0 && (info.GetDamageCustom() != TF_DMG_CUSTOM_TAUNTATK_GRENADE) )
{
// If we attacked ourselves, hurt no other players, and it is a blast,
// check the attribute that reduces rocket jump damage.
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( info.GetAttacker(), flRealDamage, rocket_jump_dmg_reduction );
outParams.bSelfBlastDmg = true;
}
if ( pAttacker == pVictimBaseEntity )
{
enum
{
kSelfBlastResponse_IgnoreProjectilesFromThisWeapon = 1, // the sticky jumper doesn't disable damage from other explosive weapons
kSelfBlastResponse_IgnoreProjectilesFromAllWeapons = 2, // the rocket jumper doesn't have a special projectile type and so ignores all self-inflicted damage from explosive sources
};
if ( info.GetWeapon() )
{
int iNoSelfBlastDamage = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iNoSelfBlastDamage, no_self_blast_dmg );
const bool bIgnoreThisSelfDamage = ( iNoSelfBlastDamage == kSelfBlastResponse_IgnoreProjectilesFromAllWeapons )
|| ( (iNoSelfBlastDamage == kSelfBlastResponse_IgnoreProjectilesFromThisWeapon) && (info.GetDamageCustom() == TF_DMG_CUSTOM_PRACTICE_STICKY) );
if ( bIgnoreThisSelfDamage )
{
flRealDamage = 0;
}
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( info.GetWeapon(), flRealDamage, blast_dmg_to_self );
}
}
// Precision Powerup removes self damage
if ( pTFAttacker == pVictim && pTFAttacker->m_Shared.GetCarryingRuneType() == RUNE_PRECISION )
{
flRealDamage = 0.f;
}
if ( pTFAttacker && ( pTFAttacker != pVictim ) )
{
// Vampire Powerup collects health based on damage received on victim. Does not apply to self damage. Do it here to factor in victim resistance calculations
if ( pTFAttacker->m_Shared.GetCarryingRuneType() == RUNE_VAMPIRE )
{
if ( flRealDamage > 0 )
{
if ( pTFAttacker->GetActiveTFWeapon()->GetWeaponID() == TF_WEAPON_MINIGUN || pTFAttacker->GetActiveTFWeapon()->GetWeaponID() == TF_WEAPON_FLAMETHROWER )
{
pTFAttacker->TakeHealth( ( flRealDamage * 0.6f ), DMG_GENERIC );
}
else if ( info.GetDamageType() & DMG_MELEE )
{
pTFAttacker->TakeHealth( ( flRealDamage * 1.25f ), DMG_GENERIC );
}
else
{
pTFAttacker->TakeHealth( flRealDamage, DMG_GENERIC );
}
}
}
int iHypeOnDamage = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pTFAttacker, iHypeOnDamage, hype_on_damage );
if ( iHypeOnDamage )
{
float flHype = RemapValClamped( flRealDamage, 1.f, 200.f, 1.f, 50.f );
pTFAttacker->m_Shared.SetScoutHypeMeter( Min( 100.f, flHype + pTFAttacker->m_Shared.GetScoutHypeMeter() ) );
}
}
}
return flRealDamage;
}
// --------------------------------------------------------------------------------------------------- //
// Voice helper
// --------------------------------------------------------------------------------------------------- //
class CVoiceGameMgrHelper : public IVoiceGameMgrHelper
{
public:
virtual bool CanPlayerHearPlayer( CBasePlayer *pListener, CBasePlayer *pTalker, bool &bProximity )
{
return TFGameRules()->TFVoiceManager( pListener, pTalker );
}
};
CVoiceGameMgrHelper g_VoiceGameMgrHelper;
IVoiceGameMgrHelper *g_pVoiceGameMgrHelper = &g_VoiceGameMgrHelper;
// Load the objects.txt file.
class CObjectsFileLoad : public CAutoGameSystem
{
public:
virtual bool Init()
{
LoadObjectInfos( filesystem );
return true;
}
} g_ObjectsFileLoad;
// --------------------------------------------------------------------------------------------------- //
// Globals.
// --------------------------------------------------------------------------------------------------- //
/*
// NOTE: the indices here must match TEAM_UNASSIGNED, TEAM_SPECTATOR, TF_TEAM_RED, TF_TEAM_BLUE, etc.
char *sTeamNames[] =
{
"Unassigned",
"Spectator",
"Red",
"Blue"
};
*/
// --------------------------------------------------------------------------------------------------- //
// Global helper functions.
// --------------------------------------------------------------------------------------------------- //
// World.cpp calls this but we don't use it in TF.
void InitBodyQue()
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFGameRules::~CTFGameRules()
{
// Note, don't delete each team since they are in the gEntList and will
// automatically be deleted from there, instead.
TFTeamMgr()->Shutdown();
ShutdownCustomResponseRulesDicts();
// clean up cached teleport locations
m_mapTeleportLocations.PurgeAndDeleteElements();
// reset this only if we quit MvM to minimize the risk of breaking pub tournament
if ( IsMannVsMachineMode() )
{
mp_tournament.SetValue( 0 );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::CheckTauntAchievement( CTFPlayer *pAchiever, int nGibs, int *pTauntCamAchievements )
{
if ( !pAchiever || !pAchiever->GetPlayerClass() )
return;
int iClass = pAchiever->GetPlayerClass()->GetClassIndex();
if ( pTauntCamAchievements[ iClass ] )
{
bool bAwardAchievement = true;
// for the Heavy achievement, the player needs to also be invuln
if ( iClass == TF_CLASS_HEAVYWEAPONS && pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_HEAVY_FREEZECAM_TAUNT )
{
if ( !pAchiever->m_Shared.InCond( TF_COND_INVULNERABLE_WEARINGOFF ) && !pAchiever->m_Shared.InCond( TF_COND_INVULNERABLE ) )
{
bAwardAchievement = false;
}
}
// for the Spy achievement, we must be in the cig lighter taunt
if ( iClass == TF_CLASS_SPY && pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_SPY_FREEZECAM_FLICK )
{
if ( pAchiever->GetActiveTFWeapon() && pAchiever->GetActiveTFWeapon()->GetWeaponID() != TF_WEAPON_PDA_SPY )
{
bAwardAchievement = false;
}
}
// for the two Sniper achievements, we need to check for specific taunts
if ( iClass == TF_CLASS_SNIPER )
{
if ( pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_SNIPER_FREEZECAM_HAT )
{
if ( pAchiever->GetActiveTFWeapon() && pAchiever->GetActiveTFWeapon()->GetWeaponID() != TF_WEAPON_CLUB )
{
bAwardAchievement = false;
}
}
else if ( pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_SNIPER_FREEZECAM_WAVE )
{
if ( pAchiever->GetActiveTFWeapon() && WeaponID_IsSniperRifle( pAchiever->GetActiveTFWeapon()->GetWeaponID() ) )
{
bAwardAchievement = false;
}
}
}
// For the Soldier achievements, we need to be doing a specific taunt, or have enough gibs onscreen
if ( iClass == TF_CLASS_SOLDIER )
{
if ( pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_SOLDIER_FREEZECAM_TAUNT )
{
if ( pAchiever->GetActiveTFWeapon() && pAchiever->GetActiveTFWeapon()->GetWeaponID() != TF_WEAPON_SHOTGUN_SOLDIER )
{
bAwardAchievement = false;
}
}
else if ( pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_SOLDIER_FREEZECAM_GIBS )
{
// Need at least 3 gibs on-screen
if ( nGibs < 3 )
{
bAwardAchievement = false;
}
}
}
// for the two Demoman achievements, we need to check for specific taunts
if ( iClass == TF_CLASS_DEMOMAN )
{
if ( pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_DEMOMAN_FREEZECAM_SMILE )
{
if ( pAchiever->GetActiveTFWeapon() && pAchiever->GetActiveTFWeapon()->GetWeaponID() != TF_WEAPON_GRENADELAUNCHER )
{
bAwardAchievement = false;
}
}
else if ( pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_DEMOMAN_FREEZECAM_RUMP )
{
if ( pAchiever->GetActiveTFWeapon() && pAchiever->GetActiveTFWeapon()->GetAttributeContainer() )
{
// Needs to be the Scottish Defender
CEconItemView *pItem = pAchiever->GetActiveTFWeapon()->GetAttributeContainer()->GetItem();
if ( pItem && pItem->IsValid() && pItem->GetItemDefIndex() != 130 ) // Scottish Defender is item index 130
{
bAwardAchievement = false;
}
}
}
}
// for the Engineer achievement, we must be in the guitar taunt
if ( iClass == TF_CLASS_ENGINEER && pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_ENGINEER_FREEZECAM_TAUNT )
{
if ( pAchiever->GetActiveTFWeapon() && pAchiever->GetActiveTFWeapon()->GetWeaponID() != TF_WEAPON_SENTRY_REVENGE )
{
bAwardAchievement = false;
}
}
if ( bAwardAchievement )
{
pAchiever->AwardAchievement( pTauntCamAchievements[ iClass ] );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::TFVoiceManager( CBasePlayer *pListener, CBasePlayer *pTalker )
{
// check coaching--we only want coaches and students to talk and listen to each other!
CTFPlayer* pTFListener = (CTFPlayer*)pListener;
CTFPlayer* pTFTalker = (CTFPlayer*)pTalker;
if ( pTFListener->GetStudent() || pTFListener->GetCoach() ||
pTFTalker->GetStudent() || pTFTalker->GetCoach() )
{
if ( pTFListener->GetStudent() == pTFTalker || pTFTalker->GetStudent() == pTFListener ||
pTFListener->GetCoach() == pTalker || pTFTalker->GetCoach() == pTFListener )
{
return true;
}
return false;
}
// Always allow teams to hear each other in TD mode
if ( IsMannVsMachineMode() )
return true;
if ( !tf_gravetalk.GetBool() )
{
// Dead players can only be heard by other dead team mates but only if a match is in progress
if ( State_Get() != GR_STATE_TEAM_WIN && State_Get() != GR_STATE_GAME_OVER )
{
if ( pTalker->IsAlive() == false )
{
if ( pListener->IsAlive() == false )
return ( pListener->InSameTeam( pTalker ) );
return false;
}
}
}
return ( pListener->InSameTeam( pTalker ) );
}
//-----------------------------------------------------------------------------
// Purpose: TF2 Specific Client Commands
// Input :
// Output :
//-----------------------------------------------------------------------------
bool CTFGameRules::ClientCommand( CBaseEntity *pEdict, const CCommand &args )
{
CTFPlayer *pPlayer = ToTFPlayer( pEdict );
const char *pcmd = args[0];
if ( IsInTournamentMode() == true && IsInPreMatch() == true )
{
if ( FStrEq( pcmd, "tournament_readystate" ) )
{
if ( IsMannVsMachineMode() )
return true;
if ( UsePlayerReadyStatusMode() )
return true;
if ( args.ArgC() < 2 )
return true;
if ( pPlayer->GetTeamNumber() <= LAST_SHARED_TEAM )
return true;
int iReadyState = atoi( args[1] );
//Already this state
if ( iReadyState == (int)IsTeamReady( pPlayer->GetTeamNumber() ) )
return true;
SetTeamReadyState( iReadyState == 1, pPlayer->GetTeamNumber() );
IGameEvent * event = gameeventmanager->CreateEvent( "tournament_stateupdate" );
if ( event )
{
event->SetInt( "userid", pPlayer->entindex() );
event->SetInt( "readystate", iReadyState );
event->SetBool( "namechange", 0 );
event->SetString( "oldname", " " );
event->SetString( "newname", " " );
gameeventmanager->FireEvent( event );
}
if ( iReadyState == 0 )
{
m_flRestartRoundTime.Set( -1.f );
m_bAwaitingReadyRestart = true;
}
return true;
}
if ( FStrEq( pcmd, "tournament_teamname" ) )
{
if ( IsMannVsMachineMode() )
return true;
if ( args.ArgC() < 2 )
return true;
if ( pPlayer->GetTeamNumber() <= LAST_SHARED_TEAM )
return true;
const char *commandline = args.GetCommandString();
// find the rest of the command line past the bot index
commandline = strstr( commandline, args[1] );
Assert( commandline );
char szName[MAX_TEAMNAME_STRING + 1] = { 0 };
Q_strncpy( szName, commandline, sizeof( szName ));
if ( pPlayer->GetTeamNumber() == TF_TEAM_BLUE )
{
if ( FStrEq( szName, mp_tournament_blueteamname.GetString() ) == true )
return true;
mp_tournament_blueteamname.SetValue( szName );
}
else if ( pPlayer->GetTeamNumber() == TF_TEAM_RED )
{
if ( FStrEq( szName, mp_tournament_redteamname.GetString() ) == true )
return true;
mp_tournament_redteamname.SetValue( szName );
}
IGameEvent * event = gameeventmanager->CreateEvent( "tournament_stateupdate" );
if ( event )
{
event->SetInt( "userid", pPlayer->entindex() );
event->SetBool( "readystate", 0 );
event->SetBool( "namechange", 1 );
event->SetString( "newname", szName );
gameeventmanager->FireEvent( event );
}
return true;
}
if ( FStrEq( pcmd, "tournament_player_readystate" ) )
{
if ( State_Get() != GR_STATE_BETWEEN_RNDS )
return true;
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
if ( pMatchDesc && pMatchDesc->m_params.m_bAutoReady )
return true;
// Make sure we have enough to allow ready mode commands
if ( !PlayerReadyStatus_HaveMinPlayersToEnable() )
return true;
if ( args.ArgC() < 2 )
return true;
bool bReady = ( atoi( args[1] ) == 1 );
PlayerReadyStatus_UpdatePlayerState( pPlayer, bReady );
if ( bReady )
{
pPlayer->PlayReadySound();
}
return true;
}
}
if ( FStrEq( pcmd, "objcmd" ) )
{
if ( args.ArgC() < 3 )
return true;
int entindex = atoi( args[1] );
edict_t* pEdict = INDEXENT(entindex);
if ( pEdict )
{
CBaseEntity* pBaseEntity = GetContainingEntity(pEdict);
CBaseObject* pObject = dynamic_cast<CBaseObject*>(pBaseEntity);
if ( pObject )
{
// We have to be relatively close to the object too...
// BUG! Some commands need to get sent without the player being near the object,
// eg delayed dismantle commands. Come up with a better way to ensure players aren't
// entering these commands in the console.
//float flDistSq = pObject->GetAbsOrigin().DistToSqr( pPlayer->GetAbsOrigin() );
//if (flDistSq <= (MAX_OBJECT_SCREEN_INPUT_DISTANCE * MAX_OBJECT_SCREEN_INPUT_DISTANCE))
{
// Strip off the 1st two arguments and make a new argument string
CCommand objectArgs( args.ArgC() - 2, &args.ArgV()[2]);
pObject->ClientCommand( pPlayer, objectArgs );
}
}
}
return true;
}
// Handle some player commands here as they relate more directly to gamerules state
if ( FStrEq( pcmd, "nextmap" ) )
{
if ( pPlayer->m_flNextTimeCheck < gpGlobals->curtime )
{
char szNextMap[MAX_MAP_NAME];
if ( nextlevel.GetString() && *nextlevel.GetString() )
{
Q_strncpy( szNextMap, nextlevel.GetString(), sizeof( szNextMap ) );
}
else
{
GetNextLevelName( szNextMap, sizeof( szNextMap ) );
}
ClientPrint( pPlayer, HUD_PRINTTALK, "#TF_nextmap", szNextMap);
pPlayer->m_flNextTimeCheck = gpGlobals->curtime + 1;
}
return true;
}
else if ( FStrEq( pcmd, "timeleft" ) )
{
if ( pPlayer->m_flNextTimeCheck < gpGlobals->curtime )
{
if ( mp_timelimit.GetInt() > 0 )
{
int iTimeLeft = GetTimeLeft();
char szMinutes[5];
char szSeconds[3];
if ( iTimeLeft <= 0 )
{
Q_snprintf( szMinutes, sizeof(szMinutes), "0" );
Q_snprintf( szSeconds, sizeof(szSeconds), "00" );
}
else
{
Q_snprintf( szMinutes, sizeof(szMinutes), "%d", iTimeLeft / 60 );
Q_snprintf( szSeconds, sizeof(szSeconds), "%02d", iTimeLeft % 60 );
}
ClientPrint( pPlayer, HUD_PRINTTALK, "#TF_timeleft", szMinutes, szSeconds );
}
else
{
ClientPrint( pPlayer, HUD_PRINTTALK, "#TF_timeleft_nolimit" );
}
pPlayer->m_flNextTimeCheck = gpGlobals->curtime + 1;
}
return true;
}
#ifdef STAGING_ONLY
else if ( FStrEq( pcmd, "mvm_allupgrades" ) )
{
if ( GameModeUsesUpgrades() && g_hUpgradeEntity )
{
g_hUpgradeEntity->GrantOrRemoveAllUpgrades( pPlayer );
}
return true;
}
#endif
else if( pPlayer->ClientCommand( args ) )
{
return true;
}
return BaseClass::ClientCommand( pEdict, args );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::LevelShutdown()
{
if ( IsInTraining() )
{
mp_humans_must_join_team.SetValue( "any" );
training_can_build_sentry.Revert();
training_can_build_dispenser.Revert();
training_can_build_tele_entrance.Revert();
training_can_build_tele_exit.Revert();
training_can_destroy_buildings.Revert();
training_can_pickup_sentry.Revert();
training_can_pickup_dispenser.Revert();
training_can_pickup_tele_entrance.Revert();
training_can_pickup_tele_exit.Revert();
training_can_select_weapon_primary.Revert();
training_can_select_weapon_secondary.Revert();
training_can_select_weapon_melee.Revert();
training_can_select_weapon_building.Revert();
training_can_select_weapon_pda.Revert();
training_can_select_weapon_item1.Revert();
training_can_select_weapon_item2.Revert();
tf_training_client_message.Revert();
}
TheTFBots().LevelShutdown();
hide_server.Revert();
DuelMiniGame_LevelShutdown();
GameCoordinator_NotifyLevelShutdown();
g_TFGameModeHistory.SetPrevState( m_nGameType );
if ( m_pUpgrades )
{
UTIL_Remove( m_pUpgrades );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::Think()
{
if ( m_bMapCycleNeedsUpdate )
{
m_bMapCycleNeedsUpdate = false;
LoadMapCycleFile();
}
if ( g_fGameOver )
{
if ( UsePlayerReadyStatusMode() && !IsMannVsMachineMode() )
{
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
static int nLastTimeSent = -1;
int nTimeLeft = ( m_flStateTransitionTime - gpGlobals->curtime );
int nTimePassed = gpGlobals->curtime - m_flLastRoundStateChangeTime;
if ( pMatchDesc && pMatchDesc->m_params.m_pszMatchEndKickWarning && nTimeLeft <= 50 && nTimeLeft % 10 == 0 && nTimeLeft != nLastTimeSent )
{
nLastTimeSent = nTimeLeft;
CBroadcastRecipientFilter filter;
UTIL_ClientPrintFilter( filter, HUD_PRINTTALK, pMatchDesc->m_params.m_pszMatchEndKickWarning, CFmtStr( "%d", nTimeLeft ) );
}
if ( BAttemptMapVoteRollingMatch() )
{
const CMatchInfo* pMatch = GTFGCClientSystem()->GetMatch();
if ( pMatch && pMatch->GetNumActiveMatchPlayers() == 0 )
{
Msg( "All players left during next map voting period. Ending match.\n" );
GTFGCClientSystem()->EndManagedMatch( /* bKickPlayersToParties */ false );
Assert( IsManagedMatchEnded() );
m_bMatchEnded.Set( true );
return;
}
if ( m_eRematchState == NEXT_MAP_VOTE_STATE_WAITING_FOR_USERS_TO_VOTE )
{
bool bVotePeriodExpired = false;
// Judgment time has arrived. Force a result below
if ( nTimePassed == tf_mm_next_map_vote_time.GetInt() )
{
bVotePeriodExpired = true;
}
int nVotes[ EUserNextMapVote::NUM_VOTE_STATES ];
EUserNextMapVote eWinningVote = GetWinningVote( nVotes );
if ( bVotePeriodExpired ||
( nVotes[ USER_NEXT_MAP_VOTE_UNDECIDED ] == 0 && eWinningVote != USER_NEXT_MAP_VOTE_UNDECIDED ) )
{
CBroadcastRecipientFilter filter;
const MapDef_t *pMap = NULL;
if ( eWinningVote == USER_NEXT_MAP_VOTE_UNDECIDED )
{
// Nobody voted! We're playing on the same map again by default
pMap = GetItemSchema()->GetMasterMapDefByName( STRING( gpGlobals->mapname ) );
}
else
{
pMap = GetItemSchema()->GetMasterMapDefByIndex( GetNextMapVoteOption( eWinningVote ) );
}
if ( pMap == NULL )
{
Assert( !"We somehow didn't pick a new map to rotate to! Default to the current one" );
pMap = GetItemSchema()->GetMasterMapDefByName( STRING( gpGlobals->mapname ) );
}
if ( pMap )
{
m_eRematchState = NEXT_MAP_VOTE_STATE_MAP_CHOSEN_PAUSE;
GTFGCClientSystem()->RequestNewMatchForLobby( pMap );
}
}
}
else if ( m_eRematchState == NEXT_MAP_VOTE_STATE_MAP_CHOSEN_PAUSE )
{
// CTFGCServerSystem is in control at this point
}
}
if ( gpGlobals->curtime > m_flStateTransitionTime || !BHavePlayers() )
{
nLastTimeSent = -1;
if ( pMatchDesc )
{
// Matchmaking path
pMatchDesc->PostMatchClearServerSettings();
}
else
{
// Readymode (Tournament) path
g_fGameOver = false;
m_bAllowBetweenRounds = true;
State_Transition( GR_STATE_RESTART );
SetInWaitingForPlayers( true );
}
return;
}
}
if ( ( m_flMatchSummaryTeleportTime > 0 ) && ( gpGlobals->curtime > m_flMatchSummaryTeleportTime ) )
{
m_flMatchSummaryTeleportTime = -1.f;
MatchSummaryTeleport();
}
}
else
{
if ( gpGlobals->curtime > m_flNextPeriodicThink )
{
if ( State_Get() != GR_STATE_BONUS && State_Get() != GR_STATE_TEAM_WIN && State_Get() != GR_STATE_GAME_OVER && IsInWaitingForPlayers() == false )
{
if ( CheckCapsPerRound() )
return;
}
}
// These network variables mirror the MM system's match state for client's sake. Gamerules should still
// be aware of when these change, either because we caused it or via a callback. This warning will
// detect desync. (Ideally we'd have the ability to just share between the client GC system and server
// GC system directly without passing things through gamerules)
if ( m_bMatchEnded != IsManagedMatchEnded() )
{
Assert( false );
Warning( "Mirrored Match parameters on gamerules don't match MatchInfo\n" );
m_bMatchEnded.Set( IsManagedMatchEnded() );
}
if ( GTFGCClientSystem()->GetMatch() && GetCurrentMatchGroup() != (EMatchGroup)m_nMatchGroupType.Get() )
{
Assert( false );
Warning( "Mirrored Match parameters on gamerules don't match MatchInfo\n" );
m_nMatchGroupType.Set( GetCurrentMatchGroup() );
}
// Managed matches (MvM and competitive) abandon thing
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
bool bEveryoneSafeToLeave = true;
if ( pMatch )
{
// Send current safe-to-leave flags down from the GCServerSystem
for ( int i = 1; i <= gpGlobals->maxClients; ++i )
{
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( !pPlayer )
{ continue; }
CSteamID steamID;
bool bSafe = !pMatch || !pPlayer->GetSteamID( &steamID ) || pMatch->BPlayerSafeToLeaveMatch( steamID );
pPlayer->SetMatchSafeToLeave( bSafe );
bEveryoneSafeToLeave = bEveryoneSafeToLeave && bSafe;
}
}
if ( IsCompetitiveMode() )
{
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
Assert( pMatch ); // Should not be in competitive mode without a match
//
// Check if this is mode requires a complete match, but doesn't have one
//
bool bEndMatch = false;
int nActiveMatchPlayers = pMatch->GetNumActiveMatchPlayers();
int nMissingPlayers = pMatch->GetCanonicalMatchSize() - nActiveMatchPlayers;
if ( pMatchDesc->m_params.m_bRequireCompleteMatch &&
!IsManagedMatchEnded() &&
nMissingPlayers )
{
// See if we are requesting late join right now, and give that time to work
if ( pMatchDesc->ShouldRequestLateJoin() )
{
// End match if GC system didn't request late join in response to players leaving
auto *pGCSys = GTFGCClientSystem();
double flRequestedLateJoin = pGCSys->GetTimeRequestedLateJoin();
if ( flRequestedLateJoin == -1.f )
{
bEndMatch = true;
Msg( "Failed to request late join, ending competitive match\n" );
}
else
{
// Otherwise, since we can't proceed without players, apply a timeout after which we'll
// cancel the match and release these players. The time to wait is shorter if the GC
// hasn't confirmed our late join request, so we're not spending the full time waiting
// when the GC is just non-responsive.
double flTimeWaitingForLateJoin = CRTime::RTime32TimeCur() - flRequestedLateJoin;
bool bGotLateJoin = pGCSys->BLateJoinEligible();
double flWaitLimit = bGotLateJoin ? tf_competitive_required_late_join_timeout.GetFloat()
: tf_competitive_required_late_join_confirm_timeout.GetFloat();
if ( flTimeWaitingForLateJoin > flWaitLimit )
{
Msg( "Exceeded wait time limit for late joiners, canceling match\n" );
bEndMatch = true;
}
}
}
else
{
// Can't request late joiners, tank match if number of active players get below some threshold
int iRedActive = 0;
int iBlueActive = 0;
for ( int idxPlayer = 0; idxPlayer < pMatch->GetNumTotalMatchPlayers(); idxPlayer++ )
{
CMatchInfo::PlayerMatchData_t *pMatchPlayer = pMatch->GetMatchDataForPlayer( idxPlayer );
if ( !pMatchPlayer->bDropped )
{
int iTeam = GetGameTeamForGCTeam( pMatchPlayer->eGCTeam );
if ( iTeam == TF_TEAM_RED )
iRedActive++;
else
iBlueActive++;
}
}
int iTeamSize = pMatch->GetCanonicalMatchSize() / 2;
if ( iRedActive == 0 || iBlueActive == 0 || ( iTeamSize - iRedActive ) > tf_mm_abandoned_players_per_team_max.GetInt() || ( iTeamSize - iBlueActive ) > tf_mm_abandoned_players_per_team_max.GetInt() )
{
Msg( "Match type requires a complete match, but there are not enough active players left and we are not requesting late join. Stopping match.\n" );
bEndMatch = true;
}
}
}
else if ( !IsManagedMatchEnded() && nActiveMatchPlayers < 1 )
{
// For non-complete mode, just stop the match if we lose all players
Msg( "Competitive managed match in progress, but no remaining match players. Stopping match.\n" );
bEndMatch = true;
}
if ( bEndMatch )
{
StopCompetitiveMatch( CMsgGC_Match_Result_Status_MATCH_FAILED_ABANDON );
}
else
{
// If the match was ended but we're still playing, kick off a timer to remind people that
// they're in a dead match.
AssertMsg( !IsManagedMatchEnded() || ( pMatch->BMatchTerminated() && bEveryoneSafeToLeave ),
"Expect everyone to be safe to leave and the match info to reflect that after the match is over" );
bool bGameRunning = ( State_Get() == GR_STATE_BETWEEN_RNDS || State_Get() == GR_STATE_RND_RUNNING );
bool bDeadMatch = bGameRunning && IsManagedMatchEnded() && pMatch->BMatchTerminated() && bEveryoneSafeToLeave;
if ( bDeadMatch && ( m_flSafeToLeaveTimer == -.1f ||
m_flSafeToLeaveTimer - gpGlobals->curtime <= 0.f ) )
{
// Periodic nag event
m_flSafeToLeaveTimer = gpGlobals->curtime + 30.f;
IGameEvent *pEvent = gameeventmanager->CreateEvent( "player_abandoned_match" );
if ( pEvent )
{
pEvent->SetBool( "game_over", false );
gameeventmanager->FireEvent( pEvent );
}
}
}
// Handle re-spawning the players after the doors have shut at the beginning of a match
if ( ( m_flCompModeRespawnPlayersAtMatchStart > 0 ) && ( m_flCompModeRespawnPlayersAtMatchStart < gpGlobals->curtime ) )
{
for ( int i = 1; i <= MAX_PLAYERS; i++ )
{
CTFPlayer *pPlayer = static_cast<CTFPlayer*>( UTIL_PlayerByIndex( i ) );
if ( !pPlayer )
continue;
pPlayer->RemoveAllOwnedEntitiesFromWorld();
pPlayer->ForceRespawn();
}
m_flCompModeRespawnPlayersAtMatchStart = -1.f;
}
}
}
if ( g_bRandomMap == true )
{
g_bRandomMap = false;
char szNextMap[MAX_MAP_NAME];
GetNextLevelName( szNextMap, sizeof(szNextMap), true );
IncrementMapCycleIndex();
ChangeLevelToMap( szNextMap );
return;
}
if ( IsInArenaMode() == true )
{
if ( m_flSendNotificationTime > 0.0f && m_flSendNotificationTime <= gpGlobals->curtime )
{
Arena_SendPlayerNotifications();
}
}
// periodically count up the fake clients and set the bot_count cvar to update server tags
if ( m_botCountTimer.IsElapsed() )
{
m_botCountTimer.Start( 5.0f );
int botCount = 0;
for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
{
CTFPlayer *player = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( player && player->IsFakeClient() )
{
++botCount;
}
}
tf_bot_count.SetValue( botCount );
}
#ifdef GAME_DLL
#ifdef _DEBUG
if ( tf_debug_ammo_and_health.GetBool() )
{
CBaseEntity *ent;
for( int i=0; i<m_healthVector.Count(); ++i )
{
ent = m_healthVector[i];
if ( ent )
{
NDebugOverlay::Cross3D( ent->WorldSpaceCenter(), 10.0f, 0, 255, 0, true, 0.1f );
}
}
for( int i=0; i<m_ammoVector.Count(); ++i )
{
ent = m_ammoVector[i];
if ( ent )
{
NDebugOverlay::Cross3D( ent->WorldSpaceCenter(), 10.0f, 0, 0, 255, true, 0.1f );
}
}
}
#endif // _DEBUG
if ( g_voteController )
{
ManageServerSideVoteCreation();
}
// ...
if ( tf_item_based_forced_holiday.GetInt() == kHoliday_Halloween && engine->Time() >= g_fEternaweenAutodisableTime )
{
if ( GCClientSystem() )
{
GCSDK::CProtoBufMsg<CMsgGC_GameServer_ServerModificationItemExpired> msg( k_EMsgGC_GameServer_ServerModificationItemExpired );
msg.Body().set_modification_type( kGameServerModificationItem_Halloween );
GCClientSystem()->BSendMessage( msg );
}
tf_item_based_forced_holiday.SetValue( kHoliday_None );
FlushAllAttributeCaches();
}
// play the bomb alarm if we need to
if ( m_bMannVsMachineAlarmStatus )
{
if ( m_flNextFlagAlert < gpGlobals->curtime )
{
if ( PlayThrottledAlert( 255, "Announcer.MVM_Bomb_Alert_Near_Hatch", 5.0f ) )
{
m_flNextFlagAlarm = gpGlobals->curtime + 3.0;
m_flNextFlagAlert = gpGlobals->curtime + 20.0f;
}
}
if ( m_flNextFlagAlarm < gpGlobals->curtime )
{
m_flNextFlagAlarm = gpGlobals->curtime + 3.0;
BroadcastSound( 255, "MVM.BombWarning" );
}
}
else if ( m_flNextFlagAlarm > 0.0f )
{
m_flNextFlagAlarm = 0.0f;
m_flNextFlagAlert = gpGlobals->curtime + 5.0f;
}
if ( m_bPowerupImbalanceMeasuresRunning )
{
if ( m_flTimeToStopImbalanceMeasures < gpGlobals->curtime )
{
PowerupTeamImbalance( TEAM_UNASSIGNED ); // passing TEAM_UNASSIGNED will fire the ImbalanceMeasuresOver output
m_bPowerupImbalanceMeasuresRunning = false;
}
}
PeriodicHalloweenUpdate();
SpawnHalloweenBoss();
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
{
if ( ( State_Get() == GR_STATE_RND_RUNNING ) && ( !m_bHelltowerPlayersInHell ) && ( m_helltowerTimer.IsElapsed() ) )
{
// Play our Halloween winning/losing lines for the teams
int iWinningTeam = TEAM_UNASSIGNED;
bool bRareLine = ( RandomFloat( 0, 1 ) < HELLTOWER_RARE_LINE_CHANCE );
float flRedProgress = 0.0f, flBlueProgress = 0.0f;
for ( int i = 0 ; i < ITFTeamTrainWatcher::AutoList().Count() ; ++i )
{
CTeamTrainWatcher *pTrainWatcher = static_cast< CTeamTrainWatcher* >( ITFTeamTrainWatcher::AutoList()[i] );
if ( !pTrainWatcher->IsDisabled() )
{
if ( pTrainWatcher->GetTeamNumber() == TF_TEAM_RED )
{
flRedProgress = pTrainWatcher->GetTrainDistanceAlongTrack();
}
else
{
flBlueProgress = pTrainWatcher->GetTrainDistanceAlongTrack();
}
}
}
if ( flRedProgress > flBlueProgress )
{
iWinningTeam = TF_TEAM_RED;
}
else if ( flBlueProgress > flRedProgress )
{
iWinningTeam = TF_TEAM_BLUE;
}
int iRedLine = HELLTOWER_VO_RED_MISC;
int iBlueLine = HELLTOWER_VO_BLUE_MISC;
// should we play the misc lines or the winning/losing lines?
if ( ( iWinningTeam == TEAM_UNASSIGNED ) || ( RandomFloat( 0, 1 ) < HELLTOWER_MISC_CHANCE ) )
{
if ( bRareLine )
{
iRedLine = HELLTOWER_VO_RED_MISC_RARE;
iBlueLine = HELLTOWER_VO_BLUE_MISC_RARE;
}
}
else
{
// play a winning/losing line
iRedLine = ( iWinningTeam == TF_TEAM_RED ) ? HELLTOWER_VO_RED_WINNING : HELLTOWER_VO_RED_LOSING;
iBlueLine = ( iWinningTeam == TF_TEAM_BLUE ) ? HELLTOWER_VO_BLUE_WINNING : HELLTOWER_VO_BLUE_LOSING;
if ( bRareLine )
{
iRedLine = ( iWinningTeam == TF_TEAM_RED ) ? HELLTOWER_VO_RED_WINNING_RARE : HELLTOWER_VO_RED_LOSING_RARE;
iBlueLine = ( iWinningTeam == TF_TEAM_BLUE ) ? HELLTOWER_VO_BLUE_WINNING_RARE : HELLTOWER_VO_BLUE_LOSING_RARE;
}
}
PlayHelltowerAnnouncerVO( iRedLine, iBlueLine );
m_helltowerTimer.Start( HELLTOWER_TIMER_INTERVAL );
}
}
else if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) )
{
if ( ( State_Get() == GR_STATE_RND_RUNNING ) && m_doomsdaySetupTimer.HasStarted() && m_doomsdaySetupTimer.IsElapsed() )
{
m_doomsdaySetupTimer.Invalidate();
const char *pszSound = NULL;
switch( GetRoundsPlayed() )
{
case 0:
pszSound = "sf14.Merasmus.Start.FirstRound";
if ( RandomInt( 1, 10 ) == 1 )
{
pszSound = "sf14.Merasmus.Start.FirstRoundRare";
}
break;
case 1:
pszSound = "sf14.Merasmus.Start.SecondRound";
break;
case 2:
default:
pszSound = "sf14.Merasmus.Start.ThirdRoundAndBeyond";
break;
}
if ( pszSound && pszSound[0] )
{
BroadcastSound( 255, pszSound );
}
}
}
#ifdef TF_RAID_MODE
// This check is here for Boss battles that don't have a tf_raid_logic entity
if ( IsBossBattleMode() && !IsInWaitingForPlayers() && State_Get() == GR_STATE_RND_RUNNING )
{
CUtlVector< CTFPlayer * > alivePlayerVector;
CollectPlayers( &alivePlayerVector, TF_TEAM_BLUE, COLLECT_ONLY_LIVING_PLAYERS );
// if everyone is dead at the same time, they lose
if ( alivePlayerVector.Count() == 0 )
{
SetWinningTeam( TF_TEAM_RED, WINREASON_OPPONENTS_DEAD );
}
}
#endif // TF_RAID_MODE
// Batched strange event message processing?
if ( engine->Time() > m_flNextStrangeEventProcessTime )
{
KillEaterEvents_FlushBatches();
m_flNextStrangeEventProcessTime = engine->Time() + g_flStrangeEventBatchProcessInterval;
}
ManageCompetitiveMode();
#endif // GAME_DLL
//=============================================================================
// HPE_BEGIN:
// [msmith] Do training summary screen logic.
//=============================================================================
if ( IsInTraining() == true )
{
if ( m_flStateTransitionTime > gpGlobals->curtime )
{
int client_message = tf_training_client_message.GetInt();
switch ( client_message )
{
case TRAINING_CLIENT_MESSAGE_IN_SUMMARY_SCREEN:
{
//Keep adding time to the restart while we are in the end screen menu so that we never restart the round until
//the player presses the replay button (or next button to go to the next map).
m_flStateTransitionTime = gpGlobals->curtime + 5.0f;
}
break;
case TRAINING_CLIENT_MESSAGE_NEXT_MAP:
{
LoadNextTrainingMap();
tf_training_client_message.SetValue( (int)TRAINING_CLIENT_MESSAGE_NONE );
}
break;
case TRAINING_CLIENT_MESSAGE_REPLAY:
{
// Reload the map
engine->ChangeLevel( STRING( gpGlobals->mapname ), NULL );
tf_training_client_message.SetValue( (int)TRAINING_CLIENT_MESSAGE_NONE );
}
break;
} // switch
}
}
//=============================================================================
// HPE_END
//=============================================================================
// This is ugly, but, population manager needs to sometimes think when we're not simulating, but it is an entity.
// Really, we need to better split out some kind of "sub-gamerules" class for modes like this.
if ( IsMannVsMachineMode() && g_pPopulationManager )
{
g_pPopulationManager->GameRulesThink();
}
BaseClass::Think();
}
#ifdef GAME_DLL
#ifdef STAGING_ONLY
ConVar tf_spawn_halloween_gift_test_enabled( "tf_spawn_halloween_gift_test_enabled", "0", 0, "enable to spawn a gift at the world origin. You probably want to use ConCommand 'SpawnHalloweenGiftTest'" );
CON_COMMAND_F( tf_spawn_halloween_gift_test, "Test Halloween Gifts", FCVAR_NONE )
{
ConVarRef gift_test( "tf_spawn_halloween_gift_test_enabled" );
gift_test.SetValue( 1 );
}
#endif // STAGING_ONLY
void CTFGameRules::PeriodicHalloweenUpdate()
{
// DEBUG
#ifdef STAGING_ONLY
if ( tf_spawn_halloween_gift_test_enabled.GetBool() )
{
m_flNextHalloweenGiftUpdateTime = gpGlobals->curtime;
tf_spawn_halloween_gift_test_enabled.SetValue( 0 );
return;
}
#endif //staging_only
// Are we on a Halloween Map?
// Do we have Halloween Contracts?
if ( !IsHolidayActive( kHoliday_Halloween ) )
return;
// Loop through each player that has a quest and spawn them a gift
if ( m_halloweenGiftSpawnLocations.Count() == 0 )
return;
// If we've never given out gifts before, set the time
if ( m_flNextHalloweenGiftUpdateTime < 0 )
{
m_flNextHalloweenGiftUpdateTime = gpGlobals->curtime + RandomInt( 7, 12 ) * 60;
return;
}
if ( m_flNextHalloweenGiftUpdateTime > gpGlobals->curtime )
return;
m_flNextHalloweenGiftUpdateTime = gpGlobals->curtime + RandomInt( 7, 12 ) * 60;
CUtlVector< CTFPlayer* > playerVector;
CollectPlayers( &playerVector );
FOR_EACH_VEC( playerVector, i )
{
Vector vLocation = m_halloweenGiftSpawnLocations.Element( RandomInt( 0, m_halloweenGiftSpawnLocations.Count() - 1 ) );
CHalloweenGiftPickup *pGift = assert_cast<CHalloweenGiftPickup*>( CBaseEntity::CreateNoSpawn( "tf_halloween_gift_pickup", vLocation, vec3_angle, NULL ) );
if ( pGift )
{
pGift->SetTargetPlayer( playerVector[i] );
DispatchSpawn( pGift );
}
}
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::SwitchToNextBestWeapon( CBaseCombatCharacter *pPlayer, CBaseCombatWeapon *pCurrentWeapon )
{
if ( pPlayer )
{
CBaseCombatWeapon *lastWeapon = ToTFPlayer( pPlayer )->GetLastWeapon();
if ( lastWeapon != NULL && lastWeapon->HasAnyAmmo() )
{
return pPlayer->Weapon_Switch( lastWeapon );
}
}
return BaseClass::SwitchToNextBestWeapon( pPlayer, pCurrentWeapon );
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::PointsMayBeCaptured( void )
{
if ( IsHolidayActive( kHoliday_Halloween ) && GetActiveBoss() )
{
switch ( GetHalloweenScenario() )
{
case HALLOWEEN_SCENARIO_VIADUCT:
{
// the eyeball prevents point capturing while he's in play
if ( assert_cast< CEyeballBoss * >( GetActiveBoss() ) )
{
return false;
}
}
break;
case HALLOWEEN_SCENARIO_LAKESIDE:
{
// merasmus prevents point capturing while he's in play
if ( assert_cast< CMerasmus * >( GetActiveBoss() ) )
{
return false;
}
}
break;
}
}
if ( IsMannVsMachineMode() )
{
return true;
}
return BaseClass::PointsMayBeCaptured();
}
extern bool IsSpaceToSpawnHere( const Vector &where );
static bool isZombieMobForceSpawning = false;
#ifdef STAGING_ONLY
// force the boss to spawn where our cursor is pointing
CON_COMMAND_F( tf_halloween_force_zombie_mob, "For testing.", FCVAR_CHEAT )
{
isZombieMobForceSpawning = true;
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::SpawnZombieMob( void )
{
if ( !tf_halloween_zombie_mob_enabled.GetBool() )
{
return;
}
// timer was started and has elapsed - time to spawn the boss
if ( InSetup() || IsInWaitingForPlayers() )
{
m_zombieMobTimer.Start( tf_halloween_zombie_mob_spawn_interval.GetFloat() );
return;
}
if ( isZombieMobForceSpawning )
{
isZombieMobForceSpawning = false;
m_zombieMobTimer.Invalidate();
}
// spawn pending mob members
if ( m_zombiesLeftToSpawn > 0 )
{
if ( IsSpaceToSpawnHere( m_zombieSpawnSpot ) )
{
if ( CZombie::SpawnAtPos( m_zombieSpawnSpot ) )
{
--m_zombiesLeftToSpawn;
}
}
}
// require a minimum number of human players in the game before the boss appears
CUtlVector< CTFPlayer * > playerVector;
CollectPlayers( &playerVector, TF_TEAM_RED, COLLECT_ONLY_LIVING_PLAYERS );
CollectPlayers( &playerVector, TF_TEAM_BLUE, COLLECT_ONLY_LIVING_PLAYERS, APPEND_PLAYERS );
// only count humans
int totalPlayers = 0;
for( int i=0; i<playerVector.Count(); ++i )
{
if ( !playerVector[i]->IsBot() )
{
++totalPlayers;
}
}
if ( totalPlayers == 0 )
{
return;
}
// spawn a mob
if ( m_zombieMobTimer.IsElapsed() )
{
m_zombieMobTimer.Start( tf_halloween_zombie_mob_spawn_interval.GetFloat() );
CUtlVector< CTFNavArea * > ambushVector; // vector of hidden but near-to-victim areas
for( int i=0; i<playerVector.Count(); ++i )
{
CTFPlayer *player = playerVector[i];
if ( player->IsBot() )
{
continue;
}
if ( !player->GetLastKnownArea() )
{
continue;
}
const float maxSurroundTravelRange = 2000.0f;
CUtlVector< CNavArea * > areaVector;
// collect walkable areas surrounding this player
CollectSurroundingAreas( &areaVector, player->GetLastKnownArea(), maxSurroundTravelRange, StepHeight, StepHeight );
// keep subset that isn't visible to any player
for( int j=0; j<areaVector.Count(); ++j )
{
CTFNavArea *area = (CTFNavArea *)areaVector[j];
if ( !area->IsValidForWanderingPopulation() )
{
continue;
}
if ( area->IsPotentiallyVisibleToTeam( TF_TEAM_BLUE ) || area->IsPotentiallyVisibleToTeam( TF_TEAM_RED ) )
{
continue;
}
ambushVector.AddToTail( area );
}
}
if ( ambushVector.Count() == 0 )
{
// no place to spawn the mob this time
return;
}
for( int retry=0; retry<10; ++retry )
{
int which = RandomInt( 0, ambushVector.Count()-1 );
m_zombieSpawnSpot = ambushVector[ which ]->GetCenter() + Vector( 0, 0, StepHeight );
if ( !IsSpaceToSpawnHere( m_zombieSpawnSpot ) )
{
continue;
}
// spawn a mob here
m_zombiesLeftToSpawn = tf_halloween_zombie_mob_spawn_count.GetInt();
break;
}
}
}
//---------------------------------------------------------------------------------------------------------
static bool isBossForceSpawning = false;
// force the boss to spawn where our cursor is pointing
CON_COMMAND_F( tf_halloween_force_boss_spawn, "For testing.", FCVAR_CHEAT )
{
isBossForceSpawning = true;
}
CON_COMMAND_F( cc_spawn_merasmus_at_level, "Force Merasmus to spawn at a specific difficulty level", FCVAR_CHEAT )
{
if( args.ArgC() != 2 )
{
DevMsg( "Must specify a level\n" );
return;
}
CMerasmus::DBG_SetLevel( atoi(args[1]) );
tf_halloween_force_boss_spawn( args );
}
extern ConVar tf_halloween_bot_min_player_count;
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::SpawnHalloweenBoss( void )
{
if ( !IsHolidayActive( kHoliday_Halloween ) )
return;
// only spawn the Halloween Boss on our Halloween maps
HalloweenBossType bossType = HALLOWEEN_BOSS_INVALID;
float bossInterval = 0.0f;
float bossIntervalVariation = 0.0f;
HalloweenScenarioType scenario = GetHalloweenScenario();
if ( scenario == HALLOWEEN_SCENARIO_MANN_MANOR )
{
bossType = HALLOWEEN_BOSS_HHH;
bossInterval = tf_halloween_boss_spawn_interval.GetFloat();
bossIntervalVariation = tf_halloween_boss_spawn_interval_variation.GetFloat();
}
else if ( scenario == HALLOWEEN_SCENARIO_VIADUCT )
{
bossType = HALLOWEEN_BOSS_MONOCULUS;
bossInterval = tf_halloween_eyeball_boss_spawn_interval.GetFloat();
bossIntervalVariation = tf_halloween_eyeball_boss_spawn_interval_variation.GetFloat();
}
else if ( scenario == HALLOWEEN_SCENARIO_LAKESIDE )
{
bossType = HALLOWEEN_BOSS_MERASMUS;
if ( CMerasmus::GetMerasmusLevel() <= 3 )
{
bossInterval = tf_merasmus_spawn_interval.GetFloat();
bossIntervalVariation = tf_merasmus_spawn_interval_variation.GetFloat();
}
else
{
// after level 3, spawn Merasmus every 60 secs
bossInterval = 60;
bossIntervalVariation = 0;
}
// check if the wheel is still spinning
CWheelOfDoom* pWheel = assert_cast< CWheelOfDoom* >( gEntList.FindEntityByClassname( NULL, "wheel_of_doom" ) );
if ( pWheel && !pWheel->IsDoneBoardcastingEffectSound() )
{
return;
}
}
//else if ( scenario == HALLOWEEN_SCENARIO_HIGHTOWER )
//{
// bool bWasEnabled = tf_halloween_zombie_mob_enabled.GetBool();
// tf_halloween_zombie_mob_enabled.SetValue( true );
// // not a boss battle map
// SpawnZombieMob();
// tf_halloween_zombie_mob_enabled.SetValue( bWasEnabled );
// bossType = "eyeball_boss";
// bossInterval = tf_halloween_eyeball_boss_spawn_interval.GetFloat();
// bossIntervalVariation = tf_halloween_eyeball_boss_spawn_interval_variation.GetFloat();
//}
else
{
// not a boss battle map
SpawnZombieMob();
return;
}
// only one boss at a time
if ( GetActiveBoss() )
{
// boss is still out there - restart the timer
StartHalloweenBossTimer( bossInterval, bossIntervalVariation );
isBossForceSpawning = false;
return;
}
if ( !m_halloweenBossTimer.IsElapsed() && !isBossForceSpawning )
return;
// boss timer has elapsed
if ( m_halloweenBossTimer.HasStarted() || isBossForceSpawning )
{
if ( !isBossForceSpawning )
{
// timer was started and has elapsed - time to spawn the boss
if ( InSetup() || IsInWaitingForPlayers() )
return;
// require a minimum number of human players in the game before the boss appears
CUtlVector< CTFPlayer * > playerVector;
CollectPlayers( &playerVector, TF_TEAM_RED, COLLECT_ONLY_LIVING_PLAYERS );
CollectPlayers( &playerVector, TF_TEAM_BLUE, COLLECT_ONLY_LIVING_PLAYERS, APPEND_PLAYERS );
// only count humans
int totalPlayers = 0;
for( int i=0; i<playerVector.Count(); ++i )
{
if ( !playerVector[i]->IsBot() )
{
++totalPlayers;
}
}
if ( totalPlayers < tf_halloween_bot_min_player_count.GetInt() )
return;
}
Vector bossSpawnPos = vec3_origin;
// spawn on the currently contested point
CTeamControlPoint *contestedPoint = NULL;
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
if ( pMaster )
{
for( int i=0; i<pMaster->GetNumPoints(); ++i )
{
contestedPoint = pMaster->GetControlPoint( i );
if ( contestedPoint && pMaster->IsInRound( contestedPoint ) )
{
if ( ObjectiveResource()->GetOwningTeam( contestedPoint->GetPointIndex() ) == TF_TEAM_BLUE )
continue;
// blue are the invaders
if ( !TeamplayGameRules()->TeamMayCapturePoint( TF_TEAM_BLUE, contestedPoint->GetPointIndex() ) )
continue;
break;
}
}
}
CBaseEntity *pCustomSpawnBossPos = gEntList.FindEntityByClassname( NULL, "spawn_boss" );
if ( pCustomSpawnBossPos )
{
bossSpawnPos = pCustomSpawnBossPos->GetAbsOrigin();
}
else if ( contestedPoint )
{
bossSpawnPos = contestedPoint->GetAbsOrigin();
if ( scenario == HALLOWEEN_SCENARIO_VIADUCT || scenario == HALLOWEEN_SCENARIO_LAKESIDE )
{
// revert ownership of point to neutral
contestedPoint->ForceOwner( 0 );
// pause the timers
if ( IsInKothMode() )
{
variant_t sVariant;
CTeamRoundTimer *pTimer = GetKothTeamTimer( TF_TEAM_BLUE );
if ( pTimer )
{
pTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 );
}
pTimer = GetKothTeamTimer( TF_TEAM_RED );
if ( pTimer )
{
pTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 );
}
}
}
}
else
{
// pick a random spot
CUtlVector< CTFNavArea * > spawnAreaVector;
for( int i=0; i<TheNavAreas.Count(); ++i )
{
CTFNavArea *area = (CTFNavArea *)TheNavAreas[i];
if ( area->HasAttributeTF( TF_NAV_SPAWN_ROOM_BLUE | TF_NAV_SPAWN_ROOM_RED | TF_NAV_SPAWN_ROOM_EXIT ) )
{
// don't spawn in team spawn rooms
continue;
}
// don't use small nav areas
const float goodSize = 100.0f;
if ( area->GetSizeX() < goodSize || area->GetSizeY() < goodSize )
{
continue;
}
spawnAreaVector.AddToTail( area );
}
if ( spawnAreaVector.Count() == 0 )
{
// no place to spawn (!)
return;
}
int which = RandomInt( 0, spawnAreaVector.Count()-1 );
bossSpawnPos = spawnAreaVector[ which ]->GetCenter();
}
CHalloweenBaseBoss::SpawnBossAtPos( bossType, bossSpawnPos );
// pick next spawn time
StartHalloweenBossTimer( bossInterval, bossIntervalVariation );
isBossForceSpawning = false;
}
else
{
// Merasmus has a more reliable initial spawn time
if( IsHalloweenScenario( HALLOWEEN_SCENARIO_LAKESIDE ) )
{
StartHalloweenBossTimer( bossInterval, bossIntervalVariation );
}
else
{
// initial spawn time
m_halloweenBossTimer.Start( 0.5f * RandomFloat( 0.0f, bossInterval + bossIntervalVariation ) );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::BeginHaunting( int nDesiredCount, float flMinDuration, float flMaxDuration )
{
if ( !IsHolidayActive( kHoliday_Halloween ) )
return;
if ( !IsHalloweenScenario( HALLOWEEN_SCENARIO_VIADUCT ) && !IsHalloweenScenario( HALLOWEEN_SCENARIO_LAKESIDE ) )
{
CTFHolidayEntity *pHolidayEntity = dynamic_cast<CTFHolidayEntity*> ( gEntList.FindEntityByClassname( NULL, "tf_logic_holiday" ) );
if ( !pHolidayEntity || !pHolidayEntity->ShouldAllowHaunting() )
return;
}
const int desiredGhostCount = nDesiredCount;
// if there are existing ghosts, extend their time
CUtlVector< CGhost * > priorGhostVector;
for( int g=0; g<m_ghostVector.Count(); ++g )
{
if ( m_ghostVector[g] != NULL )
{
priorGhostVector.AddToTail( m_ghostVector[g] );
}
}
m_ghostVector.RemoveAll();
for( int g=0; g<priorGhostVector.Count(); ++g )
{
priorGhostVector[g]->SetLifetime( RandomFloat( flMinDuration, flMaxDuration ) );
m_ghostVector.AddToTail( priorGhostVector[g] );
}
if ( m_ghostVector.Count() >= desiredGhostCount )
return;
// spawn ghosts away from players
CUtlVector< CTFPlayer * > playerVector;
CollectPlayers( &playerVector, TF_TEAM_BLUE, COLLECT_ONLY_LIVING_PLAYERS );
CollectPlayers( &playerVector, TF_TEAM_RED, COLLECT_ONLY_LIVING_PLAYERS, APPEND_PLAYERS );
const int ghostCount = desiredGhostCount - m_ghostVector.Count();
CUtlVector< Vector > spawnVector;
for( int i=0; i<TheNavAreas.Count(); ++i )
{
CTFNavArea *area = (CTFNavArea *)TheNavAreas.Element(i);
if ( area->HasAttributeTF( TF_NAV_SPAWN_ROOM_BLUE | TF_NAV_SPAWN_ROOM_RED ) )
{
// keep out of spawn rooms
continue;
}
Vector spot = area->GetCenter();
// don't spawn near players (so they aren't instantly scared)
int p;
for( p=0; p<playerVector.Count(); ++p )
{
if ( ( playerVector[p]->GetAbsOrigin() - spot ).IsLengthLessThan( 1.25f * GHOST_SCARE_RADIUS ) )
{
break;
}
}
if ( p == playerVector.Count() )
{
spawnVector.AddToTail( spot );
}
}
if ( spawnVector.Count() == 0 )
{
return;
}
for( int g=0; g<ghostCount; ++g )
{
int which = RandomInt( 0, spawnVector.Count()-1 );
CGhost *ghost = SpawnGhost( spawnVector[ which ], vec3_angle, RandomFloat( flMinDuration, flMaxDuration ) );
m_ghostVector.AddToTail( ghost );
}
}
static const int k_RecentPlayerInfoMaxTime = 7200; // 2 hours
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::PlayerHistory_AddPlayer( CTFPlayer *pTFPlayer )
{
if ( !pTFPlayer )
return;
CSteamID steamID;
pTFPlayer->GetSteamID( &steamID );
if ( !steamID.IsValid() || !steamID.BIndividualAccount() )
return;
// Exists?
FOR_EACH_VEC_BACK( m_vecPlayerHistory, i )
{
if ( m_vecPlayerHistory[i].steamID == steamID )
{
m_vecPlayerHistory[i].flTime = Plat_FloatTime();
return;
}
// Do maintenance here.
if ( Plat_FloatTime() - m_vecPlayerHistory[i].flTime >= (float)k_RecentPlayerInfoMaxTime )
{
m_vecPlayerHistory.Remove( i );
}
}
PlayerHistoryInfo_t info =
{
steamID,
(float) Plat_FloatTime(),
pTFPlayer->GetTeamNumber()
};
m_vecPlayerHistory.AddToTail( info );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
PlayerHistoryInfo_t *CTFGameRules::PlayerHistory_GetPlayerInfo( CTFPlayer *pTFPlayer )
{
if ( !pTFPlayer )
return NULL;
CSteamID steamID;
pTFPlayer->GetSteamID( &steamID );
if ( !steamID.IsValid() || !steamID.BIndividualAccount() )
return NULL;
FOR_EACH_VEC_BACK( m_vecPlayerHistory, i )
{
if ( m_vecPlayerHistory[i].steamID == steamID )
return &m_vecPlayerHistory[i];
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Returns -1 if we don't have the data
//-----------------------------------------------------------------------------
int CTFGameRules::PlayerHistory_GetTimeSinceLastSeen( CTFPlayer *pTFPlayer )
{
PlayerHistoryInfo_t *pInfo = PlayerHistory_GetPlayerInfo( pTFPlayer );
if ( !pInfo )
return -1;
// We only care about whole seconds
return (int)( Plat_FloatTime() - pInfo->flTime );
}
#endif
//=============================================================================
// HPE_BEGIN:
// [msmith] TEMP CODE: needs to be replaced with the final solution for our training mission navigation.
//=============================================================================
void CTFGameRules::LoadNextTrainingMap()
{
if ( m_hTrainingModeLogic )
{
g_fGameOver = true;
const char* pNextMap = m_hTrainingModeLogic->GetNextMap();
if ( pNextMap && FStrEq( pNextMap, "" ) == false )
{
Msg( "CHANGE LEVEL: %s\n", pNextMap );
engine->ChangeLevel( pNextMap, NULL );
}
else
{
Msg( "CHANGE LEVEL: %s\n", STRING( gpGlobals->mapname ) );
engine->ChangeLevel( STRING( gpGlobals->mapname ), NULL );
}
return;
}
Msg( "CHANGE LEVEL: %s\n", STRING( gpGlobals->mapname ) );
engine->ChangeLevel( STRING( gpGlobals->mapname ), NULL );
}
//=============================================================================
// HPE_END
//=============================================================================
//Runs think for all player's conditions
//Need to do this here instead of the player so players that crash still run their important thinks
void CTFGameRules::RunPlayerConditionThink ( void )
{
for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
{
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( pPlayer )
{
pPlayer->m_Shared.ConditionGameRulesThink();
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::FrameUpdatePostEntityThink()
{
BaseClass::FrameUpdatePostEntityThink();
RunPlayerConditionThink();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::CheckCapsPerRound()
{
return IsPasstimeMode()
? SetPasstimeWinningTeam()
: SetCtfWinningTeam();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::SetPasstimeWinningTeam()
{
Assert( IsPasstimeMode() );
int iScoreLimit = tf_passtime_scores_per_round.GetInt();
if ( iScoreLimit <= 0 )
{
// no score limit set, play forever
return false;
}
// TODO need to generalize the "flag captures" parts of CTFTeam to avoid
// this confusing overload of the flag captures concept, or maybe defer
// this logic to the specific object that manages the mode.
CTFTeamManager *pTeamMgr = TFTeamMgr();
int iBlueScore = pTeamMgr->GetFlagCaptures( TF_TEAM_BLUE );
int iRedScore = pTeamMgr->GetFlagCaptures( TF_TEAM_RED );
if ( ( iBlueScore < iScoreLimit ) && ( iRedScore < iScoreLimit ) )
{
// no team has exceeded the score limit
return false;
}
int iWinnerTeam = ( iBlueScore > iRedScore )
? TF_TEAM_BLUE
: TF_TEAM_RED;
SetWinningTeam( iWinnerTeam, WINREASON_SCORED );
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::SetCtfWinningTeam()
{
Assert( !IsPasstimeMode() );
if ( tf_flag_caps_per_round.GetInt() > 0 )
{
int iMaxCaps = -1;
CTFTeam *pMaxTeam = NULL;
// check to see if any team has won a "round"
int nTeamCount = TFTeamMgr()->GetTeamCount();
for ( int iTeam = FIRST_GAME_TEAM; iTeam < nTeamCount; ++iTeam )
{
CTFTeam *pTeam = GetGlobalTFTeam( iTeam );
if ( !pTeam )
continue;
// we might have more than one team over the caps limit (if the server op lowered the limit)
// so loop through to see who has the most among teams over the limit
if ( pTeam->GetFlagCaptures() >= tf_flag_caps_per_round.GetInt() )
{
if ( pTeam->GetFlagCaptures() > iMaxCaps )
{
iMaxCaps = pTeam->GetFlagCaptures();
pMaxTeam = pTeam;
}
}
}
if ( iMaxCaps != -1 && pMaxTeam != NULL )
{
SetWinningTeam( pMaxTeam->GetTeamNumber(), WINREASON_FLAG_CAPTURE_LIMIT );
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::CheckWinLimit( bool bAllowEnd /*= true*/, int nAddValueWhenChecking /*= 0*/ )
{
if ( IsInPreMatch() )
return false;
bool bWinner = false;
int iTeam = TEAM_UNASSIGNED;
int iReason = WINREASON_NONE;
const char *pszReason = "";
if ( mp_winlimit.GetInt() != 0 )
{
if ( ( TFTeamMgr()->GetTeam( TF_TEAM_BLUE )->GetScore() + nAddValueWhenChecking ) >= mp_winlimit.GetInt() )
{
pszReason = "Team \"BLUE\" triggered \"Intermission_Win_Limit\"\n";
bWinner = true;
iTeam = TF_TEAM_BLUE;
iReason = WINREASON_WINLIMIT;
}
else if ( ( TFTeamMgr()->GetTeam( TF_TEAM_RED )->GetScore() + nAddValueWhenChecking ) >= mp_winlimit.GetInt() )
{
pszReason = "Team \"RED\" triggered \"Intermission_Win_Limit\"\n";
bWinner = true;
iTeam = TF_TEAM_RED;
iReason = WINREASON_WINLIMIT;
}
}
// has one team go far enough ahead of the other team to trigger the win difference?
if ( !bWinner )
{
int iWinLimit = mp_windifference.GetInt();
if ( iWinLimit > 0 )
{
int iBlueScore = TFTeamMgr()->GetTeam( TF_TEAM_BLUE )->GetScore();
int iRedScore = TFTeamMgr()->GetTeam( TF_TEAM_RED )->GetScore();
if ( (iBlueScore - iRedScore) >= iWinLimit )
{
if ( (mp_windifference_min.GetInt() == 0) || (iBlueScore >= mp_windifference_min.GetInt()) )
{
pszReason = "Team \"BLUE\" triggered \"Intermission_Win_Limit\" due to mp_windifference\n";
bWinner = true;
iTeam = TF_TEAM_BLUE;
iReason = WINREASON_WINDIFFLIMIT;
}
}
else if ( (iRedScore - iBlueScore) >= iWinLimit )
{
if ( (mp_windifference_min.GetInt() == 0) || (iRedScore >= mp_windifference_min.GetInt()) )
{
pszReason = "Team \"RED\" triggered \"Intermission_Win_Limit\" due to mp_windifference\n";
bWinner = true;
iTeam = TF_TEAM_RED;
iReason = WINREASON_WINDIFFLIMIT;
}
}
}
}
if ( bWinner )
{
if ( bAllowEnd )
{
IGameEvent *event = gameeventmanager->CreateEvent( "tf_game_over" );
if ( event )
{
if ( iReason == WINREASON_WINDIFFLIMIT )
{
event->SetString( "reason", "Reached Win Difference Limit" );
}
else
{
event->SetString( "reason", "Reached Win Limit" );
}
gameeventmanager->FireEvent( event );
}
if ( IsInTournamentMode() == true )
{
SetWinningTeam( iTeam, iReason, true, false, true );
}
else
{
GoToIntermission();
}
Assert( V_strlen( pszReason ) );
UTIL_LogPrintf( "%s", pszReason );
}
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::CheckRespawnWaves()
{
BaseClass::CheckRespawnWaves();
// Look for overrides
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( !pTFPlayer )
continue;
if ( pTFPlayer->IsAlive() )
continue;
if ( m_iRoundState == GR_STATE_PREROUND )
continue;
// Triggers can force a player to spawn at a specific time
if ( pTFPlayer->GetRespawnTimeOverride() != -1.f &&
gpGlobals->curtime > pTFPlayer->GetDeathTime() + pTFPlayer->GetRespawnTimeOverride() )
{
pTFPlayer->ForceRespawn();
}
else if ( IsPVEModeActive() )
{
// special stuff for PVE mode
if ( !ShouldRespawnQuickly( pTFPlayer ) )
continue;
// If the player hasn't been dead the minimum respawn time, he
// waits until the next wave.
if ( !HasPassedMinRespawnTime( pTFPlayer ) )
continue;
if ( !pTFPlayer->IsReadyToSpawn() )
{
// Let the player spawn immediately when they do pick a class
if ( pTFPlayer->ShouldGainInstantSpawn() )
{
pTFPlayer->AllowInstantSpawn();
}
continue;
}
// Respawn this player
pTFPlayer->ForceRespawn();
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::PlayWinSong( int team )
{
if ( IsPlayingSpecialDeliveryMode() )
return;
bool bGameOver = IsGameOver();
if ( !IsInStopWatch() || bGameOver )
{
// Give the match a chance to play something custom. It returns true if it handled everything
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
if ( pMatchDesc && pMatchDesc->BPlayWinMusic( team, bGameOver ) )
{
return;
}
}
if ( IsInTournamentMode() && IsInStopWatch() && ObjectiveResource() )
{
int iStopWatchTimer = ObjectiveResource()->GetStopWatchTimer();
CTeamRoundTimer *pStopWatch = dynamic_cast< CTeamRoundTimer* >( UTIL_EntityByIndex( iStopWatchTimer ) );
if ( ( pStopWatch && pStopWatch->IsWatchingTimeStamps() ) || ( !m_bForceMapReset ) )
{
BroadcastSound( 255, "MatchMaking.RoundEndStalemateMusic" );
return;
}
}
CTeamplayRoundBasedRules::PlayWinSong( team );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::SetWinningTeam( int team, int iWinReason, bool bForceMapReset /* = true */, bool bSwitchTeams /* = false*/, bool bDontAddScore /* = false*/, bool bFinal /*= false*/ )
{
// matching the value calculated in CTeamplayRoundBasedRules::State_Enter_TEAM_WIN()
// for m_flStateTransitionTime and adding 1 second to make sure we're covered
int nTime = GetBonusRoundTime( bFinal ) + 1;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( !pTFPlayer )
continue;
// store our team for the response rules at the next round start
// (teams might be switched for attack/defend maps)
pTFPlayer->SetPrevRoundTeamNum( pTFPlayer->GetTeamNumber() );
if ( team != TEAM_UNASSIGNED )
{
if ( pTFPlayer->GetTeamNumber() == team )
{
if ( pTFPlayer->IsAlive() )
{
pTFPlayer->m_Shared.AddCond( TF_COND_CRITBOOSTED_BONUS_TIME, nTime );
}
}
else
{
pTFPlayer->ClearExpression();
#ifdef GAME_DLL
// Loser karts get max Damage and stun
if ( pTFPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
{
pTFPlayer->AddKartDamage( 666 );
pTFPlayer->m_Shared.StunPlayer( 1.5f, 1.0f, TF_STUN_BOTH ); // Short full stun then slow
pTFPlayer->m_Shared.StunPlayer( 10.0f, 0.25f, TF_STUN_MOVEMENT );
}
#endif //GAME_DLL
}
}
}
DuelMiniGame_AssignWinners();
#ifdef TF_RAID_MODE
if ( !IsBossBattleMode() )
{
// Don't do a full reset in Raid mode if the defending team didn't win
if ( IsRaidMode() && team != TF_TEAM_PVE_DEFENDERS )
{
bForceMapReset = false;
}
}
#endif // TF_RAID_MODE
SetBirthdayPlayer( NULL );
#ifdef GAME_DLL
if ( m_bPlayingKoth )
{
// Increment BLUE KOTH cap time
CTeamRoundTimer *pKOTHTimer = TFGameRules()->GetBlueKothRoundTimer();
GetGlobalTFTeam( TF_TEAM_BLUE )->AddKOTHTime( pKOTHTimer->GetTimerMaxLength() - pKOTHTimer->GetTimeRemaining() );
// Increment RED KOTH cap time
pKOTHTimer = TFGameRules()->GetRedKothRoundTimer();
GetGlobalTFTeam( TF_TEAM_RED )->AddKOTHTime( pKOTHTimer->GetTimerMaxLength() - pKOTHTimer->GetTimeRemaining() );
}
else if ( HasMultipleTrains() )
{
for ( int i = 0 ; i < ITFTeamTrainWatcher::AutoList().Count() ; ++i )
{
CTeamTrainWatcher *pTrainWatcher = static_cast< CTeamTrainWatcher* >( ITFTeamTrainWatcher::AutoList()[i] );
if ( !pTrainWatcher->IsDisabled() )
{
if ( pTrainWatcher->GetTeamNumber() == TF_TEAM_RED )
{
GetGlobalTFTeam( TF_TEAM_RED )->AddPLRTrack( pTrainWatcher->GetTrainProgress() );
}
else
{
GetGlobalTFTeam( TF_TEAM_BLUE )->AddPLRTrack( pTrainWatcher->GetTrainProgress() );
}
}
}
}
#endif
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) && CTFMinigameLogic::GetMinigameLogic() )
{
CTFMiniGame *pMiniGame = CTFMinigameLogic::GetMinigameLogic()->GetActiveMinigame();
if ( pMiniGame )
{
IGameEvent *event = gameeventmanager->CreateEvent( "minigame_win" );
if ( event )
{
event->SetInt( "team", team );
event->SetInt( "type", (int)( pMiniGame->GetMinigameType() ) );
gameeventmanager->FireEvent( event );
}
}
}
if ( IsPasstimeMode() )
{
CTF_GameStats.m_passtimeStats.summary.nRoundEndReason = iWinReason;
CTF_GameStats.m_passtimeStats.summary.nRoundRemainingSec = (int) GetActiveRoundTimer()->GetTimeRemaining();
CTF_GameStats.m_passtimeStats.summary.nScoreBlue = GetGlobalTFTeam( TF_TEAM_BLUE )->GetFlagCaptures();
CTF_GameStats.m_passtimeStats.summary.nScoreRed = GetGlobalTFTeam( TF_TEAM_RED )->GetFlagCaptures();
// stats reporting happens as a result of BaseClass::SetWinningTeam, but we need to make sure to
// update ball carry data before stats are reported.
// FIXME: refactor this so we're not calling it just for its side effects :/
CPasstimeBall *pBall = g_pPasstimeLogic->GetBall();
if ( pBall )
{
pBall->SetStateOutOfPlay();
}
}
CTeamplayRoundBasedRules::SetWinningTeam( team, iWinReason, bForceMapReset, bSwitchTeams, bDontAddScore, bFinal );
if ( IsCompetitiveMode() )
{
HaveAllPlayersSpeakConceptIfAllowed( IsGameOver() ? MP_CONCEPT_MATCH_OVER_COMP : MP_CONCEPT_GAME_OVER_COMP );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::SetStalemate( int iReason, bool bForceMapReset /* = true */, bool bSwitchTeams /* = false */ )
{
DuelMiniGame_AssignWinners();
if ( IsPasstimeMode() )
{
CTF_GameStats.m_passtimeStats.summary.bStalemate = true;
CTF_GameStats.m_passtimeStats.summary.bSuddenDeath = mp_stalemate_enable.GetBool();
CTF_GameStats.m_passtimeStats.summary.bMeleeOnlySuddenDeath = mp_stalemate_meleeonly.GetBool();
}
BaseClass::SetStalemate( iReason, bForceMapReset, bSwitchTeams );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CTFGameRules::GetPreMatchEndTime() const
{
//TFTODO: implement this.
return gpGlobals->curtime;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::GoToIntermission( void )
{
// Tell the clients to recalculate the holiday
IGameEvent *event = gameeventmanager->CreateEvent( "recalculate_holidays" );
if ( event )
{
gameeventmanager->FireEvent( event );
}
UTIL_CalculateHolidays();
BaseClass::GoToIntermission();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::RecalculateTruce( void )
{
bool bTruceActive = false;
// Call a truce if the teams are fighting a Halloween boss
if ( IsHolidayActive( kHoliday_Halloween ) )
{
if ( ( IMerasmusAutoList::AutoList().Count() > 0 ) || ( IEyeballBossAutoList::AutoList().Count() > 0 ) )
{
bool bHaveActiveBoss = false;
for ( int i = 0; i < IMerasmusAutoList::AutoList().Count(); ++i )
{
CMerasmus *pBoss = static_cast< CMerasmus* >( IMerasmusAutoList::AutoList()[i] );
if ( !pBoss->IsMarkedForDeletion() )
{
bHaveActiveBoss = true;
}
}
for ( int i = 0; i < IEyeballBossAutoList::AutoList().Count(); ++i )
{
CEyeballBoss *pBoss = static_cast< CEyeballBoss* >( IEyeballBossAutoList::AutoList()[i] );
if ( !pBoss->IsMarkedForDeletion() )
{
if ( ( pBoss->GetTeamNumber() != TF_TEAM_RED ) && ( pBoss->GetTeamNumber() != TF_TEAM_BLUE ) )
{
bHaveActiveBoss = true;
}
}
}
if ( bHaveActiveBoss && ( IsValveMap() || tf_halloween_allow_truce_during_boss_event.GetBool() || IsMapForcedTruceDuringBossFight() ) )
{
bTruceActive = true;
}
}
}
#ifdef STAGING_ONLY
if ( tf_truce.GetBool() )
{
bTruceActive = true;
}
#endif
if ( m_bTruceActive != bTruceActive )
{
m_bTruceActive.Set( bTruceActive );
CReliableBroadcastRecipientFilter filter;
if ( m_bTruceActive )
{
SendHudNotification( filter, HUD_NOTIFY_TRUCE_START, true );
if ( m_hGamerulesProxy )
{
m_hGamerulesProxy->TruceStart();
}
}
else
{
SendHudNotification( filter, HUD_NOTIFY_TRUCE_END, true );
if ( m_hGamerulesProxy )
{
m_hGamerulesProxy->TruceEnd();
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::FPlayerCanTakeDamage( CBasePlayer *pPlayer, CBaseEntity *pAttacker, const CTakeDamageInfo &info )
{
// guard against NULL pointers if players disconnect
if ( !pPlayer || !pAttacker )
return false;
if ( IsTruceActive() && ( pPlayer != pAttacker ) && ( pPlayer->GetTeamNumber() != pAttacker->GetTeamNumber() ) )
{
if ( ( ( pAttacker->GetTeamNumber() == TF_TEAM_RED ) && ( pPlayer->GetTeamNumber() == TF_TEAM_BLUE ) ) || ( ( pAttacker->GetTeamNumber() == TF_TEAM_BLUE ) && ( pPlayer->GetTeamNumber() == TF_TEAM_RED ) ) )
{
CBaseEntity *pInflictor = info.GetInflictor();
if ( pInflictor )
{
return !( pInflictor->IsTruceValidForEnt() || pAttacker->IsTruceValidForEnt() );
}
else
{
return !pAttacker->IsTruceValidForEnt();
}
}
}
// if pAttacker is an object, we can only do damage if pPlayer is our builder
if ( pAttacker->IsBaseObject() )
{
CBaseObject *pObj = ( CBaseObject *)pAttacker;
if ( pObj->GetBuilder() == pPlayer || pPlayer->GetTeamNumber() != pObj->GetTeamNumber() )
{
// Builder and enemies
return true;
}
else
{
// Teammates of the builder
return false;
}
}
// prevent eyeball rockets from hurting teammates if it's a spell
if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_MONOCULUS && pAttacker->GetTeamNumber() == pPlayer->GetTeamNumber() )
{
return false;
}
// in PvE modes, if entities are on the same team, they can't hurt each other
// this is needed since not all entities will be players
if ( IsPVEModeActive() &&
pPlayer->GetTeamNumber() == pAttacker->GetTeamNumber() &&
pPlayer != pAttacker &&
!info.IsForceFriendlyFire() )
{
return false;
}
return BaseClass::FPlayerCanTakeDamage( pPlayer, pAttacker, info );
}
Vector DropToGround(
CBaseEntity *pMainEnt,
const Vector &vPos,
const Vector &vMins,
const Vector &vMaxs )
{
trace_t trace;
UTIL_TraceHull( vPos, vPos + Vector( 0, 0, -500 ), vMins, vMaxs, MASK_SOLID, pMainEnt, COLLISION_GROUP_NONE, &trace );
return trace.endpos;
}
void TestSpawnPointType( const char *pEntClassName )
{
// Find the next spawn spot.
CBaseEntity *pSpot = gEntList.FindEntityByClassname( NULL, pEntClassName );
while( pSpot )
{
// trace a box here
Vector vTestMins = pSpot->GetAbsOrigin() + VEC_HULL_MIN;
Vector vTestMaxs = pSpot->GetAbsOrigin() + VEC_HULL_MAX;
if ( UTIL_IsSpaceEmpty( pSpot, vTestMins, vTestMaxs ) )
{
// the successful spawn point's location
NDebugOverlay::Box( pSpot->GetAbsOrigin(), VEC_HULL_MIN, VEC_HULL_MAX, 0, 255, 0, 100, 60 );
// drop down to ground
Vector GroundPos = DropToGround( NULL, pSpot->GetAbsOrigin(), VEC_HULL_MIN, VEC_HULL_MAX );
// the location the player will spawn at
NDebugOverlay::Box( GroundPos, VEC_HULL_MIN, VEC_HULL_MAX, 0, 0, 255, 100, 60 );
// draw the spawn angles
QAngle spotAngles = pSpot->GetLocalAngles();
Vector vecForward;
AngleVectors( spotAngles, &vecForward );
NDebugOverlay::HorzArrow( pSpot->GetAbsOrigin(), pSpot->GetAbsOrigin() + vecForward * 32, 10, 255, 0, 0, 255, true, 60 );
}
else
{
// failed spawn point location
NDebugOverlay::Box( pSpot->GetAbsOrigin(), VEC_HULL_MIN, VEC_HULL_MAX, 255, 0, 0, 100, 60 );
}
// increment pSpot
pSpot = gEntList.FindEntityByClassname( pSpot, pEntClassName );
}
}
// -------------------------------------------------------------------------------- //
void TestSpawns()
{
TestSpawnPointType( "info_player_teamspawn" );
}
ConCommand cc_TestSpawns( "map_showspawnpoints", TestSpawns, "Dev - test the spawn points, draws for 60 seconds", FCVAR_CHEAT );
// -------------------------------------------------------------------------------- //
void cc_ShowRespawnTimes()
{
CTFGameRules *pRules = TFGameRules();
CBasePlayer *pPlayer = ToBasePlayer( UTIL_GetCommandClient() );
if ( pRules && pPlayer )
{
float flRedMin = ( pRules->m_TeamRespawnWaveTimes[TF_TEAM_RED] >= 0 ? pRules->m_TeamRespawnWaveTimes[TF_TEAM_RED] : mp_respawnwavetime.GetFloat() );
float flRedScalar = pRules->GetRespawnTimeScalar( TF_TEAM_RED );
float flNextRedRespawn = pRules->GetNextRespawnWave( TF_TEAM_RED, NULL ) - gpGlobals->curtime;
float flBlueMin = ( pRules->m_TeamRespawnWaveTimes[TF_TEAM_BLUE] >= 0 ? pRules->m_TeamRespawnWaveTimes[TF_TEAM_BLUE] : mp_respawnwavetime.GetFloat() );
float flBlueScalar = pRules->GetRespawnTimeScalar( TF_TEAM_BLUE );
float flNextBlueRespawn = pRules->GetNextRespawnWave( TF_TEAM_BLUE, NULL ) - gpGlobals->curtime;
char tempRed[128];
Q_snprintf( tempRed, sizeof( tempRed ), "Red: Min Spawn %2.2f, Scalar %2.2f, Next Spawn In: %.2f\n", flRedMin, flRedScalar, flNextRedRespawn );
char tempBlue[128];
Q_snprintf( tempBlue, sizeof( tempBlue ), "Blue: Min Spawn %2.2f, Scalar %2.2f, Next Spawn In: %.2f\n", flBlueMin, flBlueScalar, flNextBlueRespawn );
ClientPrint( pPlayer, HUD_PRINTTALK, tempRed );
ClientPrint( pPlayer, HUD_PRINTTALK, tempBlue );
}
}
ConCommand mp_showrespawntimes( "mp_showrespawntimes", cc_ShowRespawnTimes, "Show the min respawn times for the teams", FCVAR_CHEAT );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBaseEntity *CTFGameRules::GetPlayerSpawnSpot( CBasePlayer *pPlayer )
{
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
if ( IsInItemTestingMode() && pTFPlayer->m_bItemTestingRespawn )
{
pTFPlayer->m_bItemTestingRespawn = false;
return NULL;
}
// get valid spawn point
CBaseEntity *pSpawnSpot = pPlayer->EntSelectSpawnPoint();
// drop down to ground
Vector GroundPos = DropToGround( pPlayer, pSpawnSpot->GetAbsOrigin(), VEC_HULL_MIN_SCALED( pTFPlayer ), VEC_HULL_MAX_SCALED( pTFPlayer ) );
// Move the player to the place it said.
pPlayer->SetLocalOrigin( GroundPos + Vector(0,0,1) );
pPlayer->SetAbsVelocity( vec3_origin );
pPlayer->SetLocalAngles( pSpawnSpot->GetLocalAngles() );
pPlayer->m_Local.m_vecPunchAngle = vec3_angle;
pPlayer->m_Local.m_vecPunchAngleVel = vec3_angle;
pPlayer->SnapEyeAngles( pSpawnSpot->GetLocalAngles() );
return pSpawnSpot;
}
//-----------------------------------------------------------------------------
// Purpose: Checks to see if the player is on the correct team and whether or
// not the spawn point is available.
//-----------------------------------------------------------------------------
bool CTFGameRules::IsSpawnPointValid( CBaseEntity *pSpot, CBasePlayer *pPlayer, bool bIgnorePlayers, PlayerTeamSpawnMode_t nSpawnMode /* = 0*/ )
{
bool bMatchSummary = ShowMatchSummary();
// Check the team.
// In Item Testing mode, bots all use the Red team spawns, and the player uses Blue
if ( IsInItemTestingMode() )
{
if ( pSpot->GetTeamNumber() != (pPlayer->IsFakeClient() ? TF_TEAM_RED : TF_TEAM_BLUE) )
return false;
}
else
{
if ( !bMatchSummary )
{
if ( pSpot->GetTeamNumber() != pPlayer->GetTeamNumber() )
return false;
}
}
if ( !pSpot->IsTriggered( pPlayer ) )
return false;
CTFTeamSpawn *pCTFSpawn = dynamic_cast<CTFTeamSpawn*>( pSpot );
if ( pCTFSpawn )
{
if ( pCTFSpawn->IsDisabled() )
return false;
if ( pCTFSpawn->GetTeamSpawnMode() && pCTFSpawn->GetTeamSpawnMode() != nSpawnMode )
return false;
if ( bMatchSummary )
{
if ( pCTFSpawn->AlreadyUsedForMatchSummary() )
return false;
if ( pCTFSpawn->GetMatchSummaryType() == PlayerTeamSpawn_MatchSummary_Winner )
{
if ( pPlayer->GetTeamNumber() != GetWinningTeam() )
return false;
}
else if ( pCTFSpawn->GetMatchSummaryType() == PlayerTeamSpawn_MatchSummary_Loser )
{
if ( pPlayer->GetTeamNumber() == GetWinningTeam() )
return false;
}
else
{
return false;
}
}
else
{
if ( pCTFSpawn->GetMatchSummaryType() != PlayerTeamSpawn_MatchSummary_None )
return false;
}
}
Vector mins = VEC_HULL_MIN_SCALED( pPlayer );
Vector maxs = VEC_HULL_MAX_SCALED( pPlayer );
if ( !bIgnorePlayers && !bMatchSummary )
{
Vector vTestMins = pSpot->GetAbsOrigin() + mins;
Vector vTestMaxs = pSpot->GetAbsOrigin() + maxs;
return UTIL_IsSpaceEmpty( pPlayer, vTestMins, vTestMaxs );
}
trace_t trace;
UTIL_TraceHull( pSpot->GetAbsOrigin(), pSpot->GetAbsOrigin(), mins, maxs, MASK_PLAYERSOLID, pPlayer, COLLISION_GROUP_PLAYER_MOVEMENT, &trace );
if ( trace.fraction == 1 && trace.allsolid != 1 && (trace.startsolid != 1) )
{
if ( bMatchSummary )
{
if ( pCTFSpawn )
{
pCTFSpawn->SetAlreadyUsedForMatchSummary();
}
}
return true;
}
return false;
}
Vector CTFGameRules::VecItemRespawnSpot( CItem *pItem )
{
return pItem->GetOriginalSpawnOrigin();
}
QAngle CTFGameRules::VecItemRespawnAngles( CItem *pItem )
{
return pItem->GetOriginalSpawnAngles();
}
int CTFGameRules::ItemShouldRespawn( CItem *pItem )
{
return BaseClass::ItemShouldRespawn( pItem );
}
float CTFGameRules::FlItemRespawnTime( CItem *pItem )
{
return ITEM_RESPAWN_TIME;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CTFGameRules::GetChatFormat( bool bTeamOnly, CBasePlayer *pPlayer )
{
if ( !pPlayer ) // dedicated server output
{
return NULL;
}
const char *pszFormat = NULL;
// coach?
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
if ( pTFPlayer && pTFPlayer->IsCoaching() )
{
pszFormat = "TF_Chat_Coach";
}
// team only
else if ( bTeamOnly == true )
{
if ( pPlayer->GetTeamNumber() == TEAM_SPECTATOR )
{
pszFormat = "TF_Chat_Spec";
}
else
{
if ( pPlayer->IsAlive() == false && State_Get() != GR_STATE_TEAM_WIN )
{
pszFormat = "TF_Chat_Team_Dead";
}
else
{
const char *chatLocation = GetChatLocation( bTeamOnly, pPlayer );
if ( chatLocation && *chatLocation )
{
pszFormat = "TF_Chat_Team_Loc";
}
else
{
pszFormat = "TF_Chat_Team";
}
}
}
}
// everyone
else
{
if ( pPlayer->GetTeamNumber() == TEAM_SPECTATOR )
{
pszFormat = "TF_Chat_AllSpec";
}
else
{
if ( pPlayer->IsAlive() == false && State_Get() != GR_STATE_TEAM_WIN )
{
pszFormat = "TF_Chat_AllDead";
}
else
{
pszFormat = "TF_Chat_All";
}
}
}
return pszFormat;
}
VoiceCommandMenuItem_t *CTFGameRules::VoiceCommand( CBaseMultiplayerPlayer *pPlayer, int iMenu, int iItem )
{
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
if ( pTFPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
{
engine->ClientCommand( pTFPlayer->edict(), "boo" );
return NULL;
}
VoiceCommandMenuItem_t *pItem = BaseClass::VoiceCommand( pPlayer, iMenu, iItem );
if ( pItem )
{
int iActivity = ActivityList_IndexForName( pItem->m_szGestureActivity );
if ( iActivity != ACT_INVALID )
{
if ( pTFPlayer )
{
pTFPlayer->DoAnimationEvent( PLAYERANIMEVENT_VOICE_COMMAND_GESTURE, iActivity );
// Note when we call for a Medic.
// Hardcoding this for menu 0, item 0 is an ugly hack, but we don't have a good way to
// translate this at this level without plumbing a through bunch of stuff (MSB)
if ( iMenu == 0 && iItem == 0 )
{
pTFPlayer->NoteMedicCall();
}
}
}
}
return pItem;
}
//-----------------------------------------------------------------------------
// Purpose: Actually change a player's name.
//-----------------------------------------------------------------------------
void CTFGameRules::ChangePlayerName( CTFPlayer *pPlayer, const char *pszNewName )
{
const char *pszOldName = pPlayer->GetPlayerName();
// Check if they can change their name
// don't show when bots change their names in PvE mode
if ( State_Get() != GR_STATE_STALEMATE && !( IsPVEModeActive() && pPlayer->IsBot() ) )
{
CReliableBroadcastRecipientFilter filter;
UTIL_SayText2Filter( filter, pPlayer, false, "#TF_Name_Change", pszOldName, pszNewName );
IGameEvent * event = gameeventmanager->CreateEvent( "player_changename" );
if ( event )
{
event->SetInt( "userid", pPlayer->GetUserID() );
event->SetString( "oldname", pszOldName );
event->SetString( "newname", pszNewName );
gameeventmanager->FireEvent( event );
}
}
pPlayer->SetPlayerName( pszNewName );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::ClientSettingsChanged( CBasePlayer *pPlayer )
{
const char *pszName = engine->GetClientConVarValue( pPlayer->entindex(), "name" );
const char *pszOldName = pPlayer->GetPlayerName();
CTFPlayer *pTFPlayer = (CTFPlayer*)pPlayer;
// msg everyone if someone changes their name, and it isn't the first time (changing no name to current name)
// Note, not using FStrEq so that this is case sensitive
if ( pszOldName[0] != 0 && Q_strncmp( pszOldName, pszName, MAX_PLAYER_NAME_LENGTH-1 ) )
{
ChangePlayerName( pTFPlayer, pszName );
}
// keep track of their hud_classautokill value
int nClassAutoKill = Q_atoi( engine->GetClientConVarValue( pPlayer->entindex(), "hud_classautokill" ) );
pTFPlayer->SetHudClassAutoKill( nClassAutoKill > 0 ? true : false );
// keep track of their tf_medigun_autoheal value
pTFPlayer->SetMedigunAutoHeal( Q_atoi( engine->GetClientConVarValue( pPlayer->entindex(), "tf_medigun_autoheal" ) ) > 0 );
// keep track of their cl_autorezoom value
pTFPlayer->SetAutoRezoom( Q_atoi( engine->GetClientConVarValue( pPlayer->entindex(), "cl_autorezoom" ) ) > 0 );
pTFPlayer->SetAutoReload( Q_atoi( engine->GetClientConVarValue( pPlayer->entindex(), "cl_autoreload" ) ) > 0 );
// keep track of their tf_remember_lastswitched value
pTFPlayer->SetRememberActiveWeapon( Q_atoi( engine->GetClientConVarValue( pPlayer->entindex(), "tf_remember_activeweapon" ) ) > 0 );
pTFPlayer->SetRememberLastWeapon( Q_atoi( engine->GetClientConVarValue( pPlayer->entindex(), "tf_remember_lastswitched" ) ) > 0 );
const char *pszFov = engine->GetClientConVarValue( pPlayer->entindex(), "fov_desired" );
int iFov = atoi(pszFov);
iFov = clamp( iFov, 75, MAX_FOV );
pTFPlayer->SetDefaultFOV( iFov );
pTFPlayer->m_bFlipViewModels = Q_strcmp( engine->GetClientConVarValue( pPlayer->entindex(), "cl_flipviewmodels" ), "1" ) == 0;
}
//-----------------------------------------------------------------------------
// Purpose: Return true if the specified player can carry any more of the ammo type
//-----------------------------------------------------------------------------
bool CTFGameRules::CanHaveAmmo( CBaseCombatCharacter *pPlayer, int iAmmoIndex )
{
if ( iAmmoIndex > -1 )
{
CTFPlayer *pTFPlayer = (CTFPlayer*)pPlayer;
if ( pTFPlayer )
{
// Get the max carrying capacity for this ammo
int iMaxCarry = pTFPlayer->GetMaxAmmo(iAmmoIndex);
// Does the player have room for more of this type of ammo?
if ( pTFPlayer->GetAmmoCount( iAmmoIndex ) < iMaxCarry )
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool EconEntity_KillEaterEventPassesRestrictionCheck( const IEconItemInterface *pEconInterface, const CEconItemAttributeDefinition *pRestrictionAttribDef, const CEconItemAttributeDefinition *pRestrictionValueAttribDef, const CSteamID VictimSteamID )
{
uint32 unRestrictionType = kStrangeEventRestriction_None;
attrib_value_t unRestrictionValue;
DbgVerify( pEconInterface->FindAttribute( pRestrictionAttribDef, &unRestrictionType ) ==
pEconInterface->FindAttribute( pRestrictionValueAttribDef, &unRestrictionValue ) );
switch (unRestrictionType)
{
case kStrangeEventRestriction_None:
return true;
case kStrangeEventRestriction_Map:
{
const MapDef_t *pMap = GetItemSchema()->GetMasterMapDefByName(STRING(gpGlobals->mapname));
return pMap && pMap->m_nDefIndex == unRestrictionValue;
}
case kStrangeEventRestriction_VictimSteamAccount:
return VictimSteamID.GetAccountID() == unRestrictionValue;
case kStrangeEventRestriction_Competitive:
{
if ( TFGameRules() && TFGameRules()->IsMatchTypeCompetitive() )
{
// Match Season unRestrictionValue == Season Number
return true;
}
return false;
}
} // end Switch
AssertMsg1( false, "Unhandled strange event restriction %u!", unRestrictionType );
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static CSteamID GetSteamIDForKillEaterScoring( CTFPlayer *pPlayer )
{
if ( pPlayer->IsBot() )
return k_steamIDNil;
CSteamID ret;
if ( !pPlayer->GetSteamID( &ret ) )
return k_steamIDNil;
return ret;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
class CStrangeEventValidator
{
public:
CStrangeEventValidator( IEconItemInterface *pEconEntity, CTFPlayer *pOwner, CTFPlayer *pVictim, kill_eater_event_t eEventType )
: m_unItemID( INVALID_ITEM_ID )
, m_eEventType( eEventType )
{
m_bIsValid = BInitEventParams( pEconEntity, pOwner, pVictim );
}
bool BIsValidEvent() const { return m_bIsValid; }
CSteamID GetKillerSteamID() const { Assert( m_bIsValid ); return m_KillerSteamID; }
CSteamID GetVictimSteamID() const { Assert( m_bIsValid ); return m_VictimSteamID; }
itemid_t GetItemID() const { Assert( m_bIsValid ); return m_unItemID; }
kill_eater_event_t GetEventType() const { Assert( m_bIsValid ); return m_eEventType; }
private:
bool BInitEventParams( IEconItemInterface *pEconEntity, CTFPlayer *pOwner, CTFPlayer *pVictim )
{
static CSchemaAttributeDefHandle pAttrDef_KillEater( "kill eater" );
// Kill-eater weapons.
if ( !pEconEntity )
return false;
if ( !pOwner )
return false;
if ( !pVictim )
return false;
// Ignore events where we're affecting ourself.
if ( pOwner == pVictim )
return false;
// Store off our item ID for reference post-init.
m_unItemID = pEconEntity->GetID();
// Always require that we have at least the base kill eater attribute before sending any messages
// to the GC.
if ( !pEconEntity->FindAttribute( pAttrDef_KillEater ) )
return false;
// Don't bother sending a message to the GC if either party is a bot, unless we're tracking events against
// bots specifically.
if ( !pOwner->GetSteamID( &m_KillerSteamID ) )
return false;
m_VictimSteamID = GetSteamIDForKillEaterScoring( pVictim );
if ( !m_VictimSteamID.IsValid() )
{
if ( !GetItemSchema()->GetKillEaterScoreTypeAllowsBotVictims( m_eEventType ) )
return false;
}
// Also require that we have whatever event type we're looking for, unless we're looking for regular
// player kills in which case we may or may not have a field to describe that.
for ( int i = 0; i < GetKillEaterAttrCount(); i++ )
{
const CEconItemAttributeDefinition *pScoreAttribDef = GetKillEaterAttr_Score(i);
if ( !pScoreAttribDef )
continue;
// If we don't have this attribute, move on. It's possible to be missing this attribute but still
// have the next one in the list if we have user-customized tracking types.
if ( !pEconEntity->FindAttribute( pScoreAttribDef ) )
continue;
const CEconItemAttributeDefinition *pScoreTypeAttribDef = GetKillEaterAttr_Type(i);
if ( !pScoreTypeAttribDef )
continue;
// If we're missing our type attribute, we interpret that as "track kills" -- none of the original
// kill eaters have score type attributes.
float fKillEaterEventType;
kill_eater_event_t eMatchEvent = FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pEconEntity, pScoreTypeAttribDef, &fKillEaterEventType )
? (kill_eater_event_t)(int)fKillEaterEventType
: kKillEaterEvent_PlayerKill;
if ( m_eEventType == eMatchEvent )
{
// Does this attribute also specify a restriction (ie., "has to be on this specific map" or "has to be
// against this specific account"? If so, only count this as a match if the restriction check passes.
if ( EconEntity_KillEaterEventPassesRestrictionCheck( pEconEntity, GetKillEaterAttr_Restriction(i), GetKillEaterAttr_RestrictionValue(i), m_VictimSteamID ) )
return true;
}
}
return false;
}
private:
bool m_bIsValid;
CSteamID m_KillerSteamID;
CSteamID m_VictimSteamID;
itemid_t m_unItemID;
kill_eater_event_t m_eEventType;
};
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
template < typename tMsgType >
static void FillOutBaseKillEaterMessage( tMsgType *out_pMsg, const CStrangeEventValidator& Validator )
{
Assert( out_pMsg );
Assert( Validator.BIsValidEvent() );
out_pMsg->set_killer_steam_id( Validator.GetKillerSteamID().ConvertToUint64() );
out_pMsg->set_victim_steam_id( Validator.GetVictimSteamID().ConvertToUint64() );
out_pMsg->set_item_id( Validator.GetItemID() );
out_pMsg->set_event_type( Validator.GetEventType() );
}
//-----------------------------------------------------------------------------
// Purpose: Get the actual killeater weapon from a CTakeDamageInfo
//-----------------------------------------------------------------------------
CTFWeaponBase *GetKilleaterWeaponFromDamageInfo( const CTakeDamageInfo *pInfo )
{
CTFWeaponBase *pTFWeapon = dynamic_cast<CTFWeaponBase *>( pInfo->GetWeapon() );
CBaseEntity* pInflictor = pInfo->GetInflictor();
// If there's no weapon specified, it might have been from a sentry
if ( !pTFWeapon )
{
// If a sentry did the damage with bullets, it's the inflictor
CObjectSentrygun *pSentrygun = dynamic_cast<CObjectSentrygun *>( pInflictor );
if ( !pSentrygun )
{
// If a sentry's rocket did the damage, then the rocket is the inflictor, and the sentry is the rocket's owner
pSentrygun = pInflictor ? dynamic_cast<CObjectSentrygun *>( pInflictor->GetOwnerEntity() ) : NULL;
}
if ( pSentrygun )
{
// Maybe they were using a Wrangler? The builder is the player who owns the sentry
CTFPlayer *pBuilder = pSentrygun->GetBuilder();
if ( pBuilder )
{
// Check if they have a Wrangler and were aiming with it
CTFLaserPointer* pLaserPointer = dynamic_cast< CTFLaserPointer * >( pBuilder->GetEntityForLoadoutSlot( LOADOUT_POSITION_SECONDARY ) );
if ( pLaserPointer && pLaserPointer->HasLaserDot() )
{
pTFWeapon = pLaserPointer;
}
}
}
}
// need to check for deflected projectiles so the weapon that did the most recent
// deflection will get the killeater credit instead of the original launcher
if ( pInflictor )
{
CTFWeaponBaseGrenadeProj *pBaseGrenade = dynamic_cast< CTFWeaponBaseGrenadeProj* >( pInflictor );
if ( pBaseGrenade )
{
if ( pBaseGrenade->GetDeflected() && pBaseGrenade->GetLauncher() )
{
pTFWeapon = dynamic_cast< CTFWeaponBase* >( pBaseGrenade->GetLauncher() );
}
}
else
{
CTFBaseRocket *pRocket = dynamic_cast< CTFBaseRocket* >( pInflictor );
if ( pRocket )
{
if ( pRocket->GetDeflected() && pRocket->GetLauncher() )
{
pTFWeapon = dynamic_cast< CTFWeaponBase* >( pRocket->GetLauncher() );
}
}
}
}
return pTFWeapon;
}
//-----------------------------------------------------------------------------
void EconEntity_ValidateAndSendStrangeMessageToGC( IEconItemInterface *pEconEntity, CTFPlayer *pOwner, CTFPlayer *pVictim, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ )
{
CStrangeEventValidator Validator( pEconEntity, pOwner, pVictim, eEventType );
if ( !Validator.BIsValidEvent() )
return;
GCSDK::CProtoBufMsg<CMsgIncrementKillCountAttribute> msg( k_EMsgGC_IncrementKillCountAttribute );
FillOutBaseKillEaterMessage( &msg.Body(), Validator );
if ( nIncrementValue != 1 )
{
msg.Body().set_increment_value( nIncrementValue );
}
GCClientSystem()->BSendMessage( msg );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void EconEntity_OnOwnerKillEaterEvent( CEconEntity *pEconEntity, CTFPlayer *pOwner, CTFPlayer *pVictim, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ )
{
if ( !pEconEntity )
return;
EconItemInterface_OnOwnerKillEaterEvent( pEconEntity->GetAttributeContainer()->GetItem(), pOwner, pVictim, eEventType, nIncrementValue );
}
//-----------------------------------------------------------------------------
void EconItemInterface_OnOwnerKillEaterEvent( IEconItemInterface *pEconEntity, CTFPlayer *pOwner, CTFPlayer *pVictim, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ )
{
bool bEconEntityHandled = false;
// Fire the kill eater event on all wearables
// Wearables can have all Strange parts
for ( int i = 0; i < pOwner->GetNumWearables(); ++i )
{
CTFWearable *pWearableItem = dynamic_cast<CTFWearable *>( pOwner->GetWearable( i ) );
if ( !pWearableItem )
continue;
if ( !pWearableItem->GetAttributeContainer() )
continue;
EconEntity_ValidateAndSendStrangeMessageToGC( pWearableItem->GetAttributeContainer()->GetItem(), pOwner, pVictim, eEventType, nIncrementValue );
if ( pWearableItem->GetAttributeContainer()->GetItem() == pEconEntity )
{
bEconEntityHandled = true;
}
}
if ( !bEconEntityHandled )
{
EconEntity_ValidateAndSendStrangeMessageToGC( pEconEntity, pOwner, pVictim, eEventType, nIncrementValue );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void EconEntity_OnOwnerKillEaterEventNoPartner( CEconEntity *pEconEntity, CTFPlayer *pOwner, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ )
{
if ( !pEconEntity )
return;
EconItemInterface_OnOwnerKillEaterEventNoPartner( pEconEntity->GetAttributeContainer()->GetItem(), pOwner, eEventType, nIncrementValue );
}
//-----------------------------------------------------------------------------
void EconItemInterface_OnOwnerKillEaterEventNoPartner( IEconItemInterface *pEconEntity, CTFPlayer *pOwner, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ )
{
// Look for another player to pass in. We do two passes over the list of candidates.
// First we look for anyone that we know is a real player. If we don't find any of
// those then we pass in a known bot. This means that things that allow bots will
// still find one and work, but event types that don't allow bots won't be dependent
// on the order of players in the list.
for( int iPass = 1; iPass <= 2; iPass++ )
{
for( int playerIndex = 1; playerIndex <= MAX_PLAYERS; playerIndex++ )
{
CTFPlayer *pOtherPlayer = ToTFPlayer( UTIL_PlayerByIndex( playerIndex ) );
if ( !pOtherPlayer )
continue;
// Ignore ourself.
if ( pOtherPlayer == pOwner )
continue;
const bool bCandidatePasses = (iPass == 1 && GetSteamIDForKillEaterScoring( pOtherPlayer ).IsValid()) // if we have a real Steam ID we're golden
|| (iPass == 2); // or if we made it to the second pass, any valid player pointer is as good as any other
if ( bCandidatePasses )
{
EconItemInterface_OnOwnerKillEaterEvent( pEconEntity, pOwner, pOtherPlayer, eEventType, nIncrementValue );
return;
}
}
}
// We couldn't find anyone else at all. This is hard. Let's give up.
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static GCSDK::CProtoBufMsg<CMsgIncrementKillCountAttribute_Multiple> *s_pmsgIncrementKillCountMessageBatch = NULL;
//-----------------------------------------------------------------------------
void EconEntity_ValidateAndSendStrangeMessageToGC_Batched( IEconItemInterface *pEconInterface, class CTFPlayer *pOwner, class CTFPlayer *pVictim, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ )
{
CStrangeEventValidator Validator( pEconInterface, pOwner, pVictim, eEventType );
if ( !Validator.BIsValidEvent() )
return;
// This has to be dynamically allocated because we can't static-init a protobuf message at startup type.
if ( !s_pmsgIncrementKillCountMessageBatch )
{
s_pmsgIncrementKillCountMessageBatch = new GCSDK::CProtoBufMsg<CMsgIncrementKillCountAttribute_Multiple>( k_EMsgGC_IncrementKillCountAttribute_Multiple );
}
// Look for an existing message that matches this user and this event.
for ( int i = 0; i < s_pmsgIncrementKillCountMessageBatch->Body().msgs_size(); i++ )
{
CMsgIncrementKillCountAttribute *pMsg = s_pmsgIncrementKillCountMessageBatch->Body().mutable_msgs( i );
Assert( pMsg );
if ( pMsg->killer_steam_id() == Validator.GetKillerSteamID().ConvertToUint64() &&
pMsg->victim_steam_id() == Validator.GetVictimSteamID().ConvertToUint64() &&
pMsg->item_id() == Validator.GetItemID() &&
(kill_eater_event_t)pMsg->event_type() == Validator.GetEventType() )
{
// We found an existing entry for this message. All we want to do is add to the stat we're tracking
// but still send up this single message.
Assert( pMsg->has_increment_value() );
pMsg->set_increment_value( pMsg->increment_value() + nIncrementValue );
return;
}
}
// We don't have an existing entry, so make a new one.
CMsgIncrementKillCountAttribute *pNewMsg = s_pmsgIncrementKillCountMessageBatch->Body().add_msgs();
FillOutBaseKillEaterMessage( pNewMsg, Validator );
pNewMsg->set_increment_value( nIncrementValue );
}
//-----------------------------------------------------------------------------
void EconEntity_OnOwnerKillEaterEvent_Batched( CEconEntity *pEconEntity, class CTFPlayer *pOwner, class CTFPlayer *pVictim, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ )
{
if ( !pEconEntity )
return;
EconItemInterface_OnOwnerKillEaterEvent_Batched( pEconEntity->GetAttributeContainer()->GetItem(), pOwner, pVictim, eEventType, nIncrementValue );
}
//-----------------------------------------------------------------------------
void EconItemInterface_OnOwnerKillEaterEvent_Batched( IEconItemInterface *pEconInterface, class CTFPlayer *pOwner, class CTFPlayer *pVictim, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ )
{
for ( int i = 0; i < pOwner->GetNumWearables(); ++i )
{
CTFWearable *pWearableItem = dynamic_cast<CTFWearable *>( pOwner->GetWearable( i ) );
if ( !pWearableItem )
continue;
if ( !pWearableItem->GetAttributeContainer() )
continue;
CEconItemView *pEconItemView = pWearableItem->GetAttributeContainer()->GetItem();
if ( !pEconItemView )
continue;
EconEntity_ValidateAndSendStrangeMessageToGC_Batched( pWearableItem->GetAttributeContainer()->GetItem(), pOwner, pVictim, eEventType, nIncrementValue );
}
EconEntity_ValidateAndSendStrangeMessageToGC_Batched( pEconInterface, pOwner, pVictim, eEventType, nIncrementValue );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void KillEaterEvents_FlushBatches()
{
if ( s_pmsgIncrementKillCountMessageBatch )
{
Assert( s_pmsgIncrementKillCountMessageBatch->Body().msgs_size() > 0 );
GCClientSystem()->BSendMessage( *s_pmsgIncrementKillCountMessageBatch );
delete s_pmsgIncrementKillCountMessageBatch;
s_pmsgIncrementKillCountMessageBatch = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void HatAndMiscEconEntities_OnOwnerKillEaterEventNoParter( class CTFPlayer *pOwner, kill_eater_event_t eEventType, int nIncrementValue )
{
EconItemInterface_OnOwnerKillEaterEventNoPartner( NULL, pOwner, eEventType, nIncrementValue );
}
//-----------------------------------------------------------------------------
void HatAndMiscEconEntities_OnOwnerKillEaterEvent( class CTFPlayer *pOwner, class CTFPlayer *pVictim, kill_eater_event_t eEventType, int nIncrementValue )
{
EconItemInterface_OnOwnerKillEaterEvent( NULL, pOwner, pVictim, eEventType, nIncrementValue );
}
//-----------------------------------------------------------------------------
void EconEntity_OnOwnerUniqueEconEvent( IEconItemInterface *pEconEntity, CTFPlayer *pOwner, CTFPlayer *pVictim, kill_eater_event_t eEventType )
{
CStrangeEventValidator Validator( pEconEntity, pOwner, pVictim, eEventType );
if ( !Validator.BIsValidEvent() )
return;
GCSDK::CProtoBufMsg<CMsgTrackUniquePlayerPairEvent> msg( k_EMsgGC_TrackUniquePlayerPairEvent );
FillOutBaseKillEaterMessage( &msg.Body(), Validator );
GCClientSystem()->BSendMessage( msg );
}
//-----------------------------------------------------------------------------
void EconEntity_OnOwnerUniqueEconEvent( CEconEntity *pEconEntity, CTFPlayer *pOwner, CTFPlayer *pVictim, kill_eater_event_t eEventType )
{
if ( !pEconEntity )
return;
EconEntity_OnOwnerUniqueEconEvent( pEconEntity->GetAttributeContainer()->GetItem(), pOwner, pVictim, eEventType );
}
//-----------------------------------------------------------------------------
void EconEntity_NonEquippedItemKillTracking( CTFPlayer *pOwner, CTFPlayer *pVictim, item_definition_index_t iDefIndex, kill_eater_event_t eEventType, int nIncrementValue = 1 )
{
// Validate
if ( !pOwner || !pVictim || pOwner == pVictim )
return;
#ifndef STAGING_ONLY
if ( pOwner->IsBot() || pVictim->IsBot() )
return;
#endif
CSteamID pOwnerSteamID;
CSteamID pVictimSteamID;
if ( !pOwner->GetSteamID( &pOwnerSteamID ) || !pVictim->GetSteamID( &pVictimSteamID ) )
return;
// Current date
static CSchemaAttributeDefHandle pAttrDef_DeactiveDate( "deactive date" );
uint32 unCurrentDate = CRTime::RTime32TimeCur();
CEconItemView *pNonEquippedItem = pOwner->Inventory()->GetFirstItemOfItemDef( iDefIndex, pOwner->Inventory() );
if ( pNonEquippedItem )
{
// Check the date
uint32 unDeactiveDate = 0;
if ( !pNonEquippedItem->FindAttribute( pAttrDef_DeactiveDate, &unDeactiveDate ) || unDeactiveDate > unCurrentDate )
{
GCSDK::CProtoBufMsg<CMsgIncrementKillCountAttribute> msg( k_EMsgGC_IncrementKillCountAttribute );
msg.Body().set_killer_steam_id( pOwnerSteamID.ConvertToUint64() );
msg.Body().set_victim_steam_id( pVictimSteamID.ConvertToUint64() );
if ( nIncrementValue > 1 )
{
msg.Body().set_increment_value( nIncrementValue );
}
msg.Body().set_item_id( pNonEquippedItem->GetID() );
msg.Body().set_event_type( eEventType );
GCClientSystem()->BSendMessage( msg );
}
}
}
//-----------------------------------------------------------------------------
void EconEntity_NonEquippedItemKillTracking_NoPartner( CTFPlayer *pOwner, item_definition_index_t iDefIndex, kill_eater_event_t eEventType, int nIncrementValue )
{
// Find a partner or give up
for( int iPass = 1; iPass <= 2; iPass++ )
{
for( int playerIndex = 1; playerIndex <= MAX_PLAYERS; playerIndex++ )
{
CTFPlayer *pOtherPlayer = ToTFPlayer( UTIL_PlayerByIndex( playerIndex ) );
if ( !pOtherPlayer )
continue;
// Ignore ourself.
if ( pOtherPlayer == pOwner )
continue;
const bool bCandidatePasses = (iPass == 1 && GetSteamIDForKillEaterScoring( pOtherPlayer ).IsValid()) // if we have a real Steam ID we're golden
|| (iPass == 2); // or if we made it to the second pass, any valid player pointer is as good as any other
if ( bCandidatePasses )
{
EconEntity_NonEquippedItemKillTracking( pOwner, pOtherPlayer, iDefIndex, eEventType, nIncrementValue );
return;
}
}
}
}
void EconEntity_NonEquippedItemKillTracking_NoPartnerBatched( class CTFPlayer *pOwner, item_definition_index_t iDefIndex, kill_eater_event_t eEventType, int nIncrementValue )
{
// Find a partner or give up
for ( int iPass = 1; iPass <= 2; iPass++ )
{
for ( int playerIndex = 1; playerIndex <= MAX_PLAYERS; playerIndex++ )
{
CTFPlayer *pOtherPlayer = ToTFPlayer( UTIL_PlayerByIndex( playerIndex ) );
if ( !pOtherPlayer )
continue;
// Ignore ourself.
if ( pOtherPlayer == pOwner )
continue;
const bool bCandidatePasses = ( iPass == 1 && GetSteamIDForKillEaterScoring( pOtherPlayer ).IsValid() ) // if we have a real Steam ID we're golden
|| ( iPass == 2 ); // or if we made it to the second pass, any valid player pointer is as good as any other
if ( bCandidatePasses )
{
// find the item
// Current date
static CSchemaAttributeDefHandle pAttrDef_DeactiveDate( "deactive date" );
uint32 unCurrentDate = CRTime::RTime32TimeCur();
CEconItemView *pNonEquippedItem = pOwner->Inventory()->GetFirstItemOfItemDef( iDefIndex, pOwner->Inventory() );
if ( pNonEquippedItem )
{
uint32 unDeactiveDate = 0;
if ( !pNonEquippedItem->FindAttribute( pAttrDef_DeactiveDate, &unDeactiveDate ) || unDeactiveDate > unCurrentDate )
{
EconEntity_ValidateAndSendStrangeMessageToGC_Batched( pNonEquippedItem, pOwner, pOtherPlayer, eEventType, nIncrementValue );
}
}
return;
}
}
}
}
//-----------------------------------------------------------------------------
// TODO: Remove this call and only use the one above
//-----------------------------------------------------------------------------
void EconEntity_NonEquippedItemKillTracking( CTFPlayer *pOwner, CTFPlayer *pVictim, int nIncrementValue )
{
// Validate
if ( !pOwner || !pVictim || pOwner == pVictim )
return;
if ( pOwner->IsBot() || pVictim->IsBot() )
return;
CSteamID pOwnerSteamID;
CSteamID pVictimSteamID;
if ( ! pOwner->GetSteamID( &pOwnerSteamID ) || !pVictim->GetSteamID( &pVictimSteamID ) )
return;
// Find any active operation
const auto& mapOperations = GetItemSchema()->GetOperationDefinitions();
FOR_EACH_MAP_FAST( mapOperations, i )
{
CEconOperationDefinition* pOperation = mapOperations[i];
if ( pOperation->IsActive() && pOperation->IsCampaign() )
{
EconEntity_NonEquippedItemKillTracking( pOwner, pVictim, pOperation->GetRequiredItemDefIndex(), kKillEaterEvent_CosmeticOperationKills, nIncrementValue );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Sends a soul with the specified value to every living member of the
// specified team, originating from vecPosition.
//-----------------------------------------------------------------------------
void CTFGameRules::DropHalloweenSoulPackToTeam( int nAmount, const Vector& vecPosition, int nTeamNumber, int nSourceTeam )
{
for( int iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ )
{
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
if ( !pTFPlayer || !pTFPlayer->IsConnected() )
continue;
if ( pTFPlayer->GetTeamNumber() != nTeamNumber || !pTFPlayer->IsAlive() || pTFPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
continue;
DropHalloweenSoulPack( nAmount, vecPosition, pTFPlayer, nSourceTeam );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::DropHalloweenSoulPack( int nAmount, const Vector& vecSource, CBaseEntity *pTarget, int nSourceTeam )
{
QAngle angles(0,0,0);
CHalloweenSoulPack *pSoulsPack = assert_cast<CHalloweenSoulPack*>( CBaseEntity::CreateNoSpawn( "halloween_souls_pack", vecSource, angles, NULL ) );
if ( pSoulsPack )
{
pSoulsPack->SetTarget( pTarget );
pSoulsPack->SetAmount( nAmount );
pSoulsPack->ChangeTeam( nSourceTeam );
DispatchSpawn( pSoulsPack );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldDropSpellPickup()
{
if ( IsUsingSpells() )
{
return RandomFloat() <= tf_player_spell_drop_on_death_rate.GetFloat();
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::DropSpellPickup( const Vector& vPosition, int nTier /*= 0*/ ) const
{
if ( !IsUsingSpells() )
return;
CSpellPickup *pSpellPickup = assert_cast<CSpellPickup*>( CBaseEntity::CreateNoSpawn( "tf_spell_pickup", vPosition + Vector( 0, 0, 50 ), vec3_angle, NULL ) );
if ( pSpellPickup )
{
pSpellPickup->SetTier( nTier );
DispatchSpawn( pSpellPickup );
Vector vecImpulse = RandomVector( -0.5f, 0.5f );
vecImpulse.z = 1.f;
VectorNormalize( vecImpulse );
Vector vecVelocity = vecImpulse * 500.f;
pSpellPickup->DropSingleInstance( vecVelocity, NULL, 0 );
}
}
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldDropBonusDuck( void )
{
if ( tf_player_drop_bonus_ducks.GetInt() < 0 )
{
return IsHolidayActive( kHoliday_EOTL );
}
else if ( tf_player_drop_bonus_ducks.GetInt() > 0 )
{
return true;
}
return false;
}
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldDropBonusDuckFromPlayer( CTFPlayer *pTFScorer, CTFPlayer *pTFVictim )
{
if ( !pTFScorer || !pTFVictim )
return false;
#ifndef STAGING_ONLY
// Only drop if bot is not involved
if ( pTFScorer->IsBot() || pTFVictim->IsBot() || pTFScorer == pTFVictim )
return false;
#endif
return ShouldDropBonusDuck();
}
//-----------------------------------------------------------------------------
int CTFGameRules::GetDuckSkinForClass( int nTeam, int nClass ) const
{
int nSkin = 0;
if ( nTeam >= FIRST_GAME_TEAM )
{
bool bRed = ( nTeam == TF_TEAM_RED );
switch ( nClass )
{
case TF_CLASS_SCOUT:
nSkin = bRed ? 3 : 12;
break;
case TF_CLASS_SNIPER:
nSkin = bRed ? 4 : 13;
break;
case TF_CLASS_SOLDIER:
nSkin = bRed ? 5 : 14;
break;
case TF_CLASS_DEMOMAN:
nSkin = bRed ? 6 : 15;
break;
case TF_CLASS_MEDIC:
nSkin = bRed ? 7 : 16;
break;
case TF_CLASS_HEAVYWEAPONS:
nSkin = bRed ? 8 : 17;
break;
case TF_CLASS_PYRO:
nSkin = bRed ? 9 : 18;
break;
case TF_CLASS_SPY:
nSkin = bRed ? 10 : 19;
break;
case TF_CLASS_ENGINEER:
nSkin = bRed ? 11 : 20;
break;
default:
nSkin = bRed ? 1 : 2;
break;
}
}
return nSkin;
}
//-----------------------------------------------------------------------------
//
#ifdef STAGING_ONLY
ConVar tf_duck_droprate_min( "tf_duck_droprate_min", "-1", FCVAR_REPLICATED, "Set Minimum Number of Ducks to Spawn. No upgrade" );
ConVar tf_duck_droprate_bias( "tf_duck_droprate_bias", "0.2", FCVAR_REPLICATED, "Set Bias on Duck Spawns. No upgrade" );
ConVar tf_duck_power_override( "tf_duck_power_override", "0", FCVAR_REPLICATED, "Override everyone's duck power and use this value when > 0" );
ConVar tf_duck_random_extra( "tf_duck_random_extra", "3.0f", FCVAR_REPLICATED, "Random Count of Ducks to be added used by bias function" );
#endif
ConVar tf_duck_edict_limit( "tf_duck_edict_limit", "1900", FCVAR_REPLICATED, "Maximum number of edicts allowed before spawning a duck" );
ConVar tf_duck_edict_warning( "tf_duck_edict_warning", "1800", FCVAR_REPLICATED, "Maximum number of edicts allowed before slowing duck spawn rate" );
void CTFGameRules::DropBonusDuck( const Vector& vPosition, CTFPlayer *pTFCreator /*=NULL*/, CTFPlayer *pAssister /*=NULL*/, CTFPlayer *pTFVictim /*=NULL*/, bool bCrit /*=false*/, bool bObjective /*=false*/) const
{
if ( gEntList.NumberOfEdicts() > tf_duck_edict_limit.GetInt() )
{
Warning( "Warning: High level of Edicts, Not spawning Ducks \n" );
return;
}
static CSchemaAttributeDefHandle pAttr_DuckLevelBadge( "duck badge level" );
// Find Badge and increase number of ducks based on badge level (1 duck per 5 levels)
// Look through equipped items, if one is a duck badge use its level
int iDuckFlags = 0;
if ( pTFCreator == NULL || bObjective )
{
iDuckFlags |= EDuckFlags::DUCK_FLAG_OBJECTIVE;
}
uint32 iDuckBadgeLevel = 0;
if ( pTFCreator )
{
for ( int i = 0; i < pTFCreator->GetNumWearables(); ++i )
{
CTFWearable* pWearable = dynamic_cast<CTFWearable*>( pTFCreator->GetWearable( i ) );
if ( !pWearable )
continue;
//if ( pWearable->GetAttributeContainer() && pWearable->GetAttributeContainer()->GetItem() )
{
//CEconItemView *pItem = pWearable->GetAttributeContainer()->GetItem();
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWearable, iDuckBadgeLevel, duck_badge_level );
//if ( pItem && FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pItem, pAttr_DuckLevelBadge, &iDuckBadgeLevel ) )
{
iDuckBadgeLevel++;
}
}
}
}
// Badges only go to max of 5 now instead of 10 so just doubling the output value
int iDuckPower = Min( (int)iDuckBadgeLevel * 2, 11 );
float flBias = RemapValClamped( (float)iDuckPower, 0.0f, 10.0f, 0.2f, 0.5f);
float flBiasScale = 3.0f;
int iMinimum = 0;
bool bSpecial = false;
// Drop a few bonus ducks, extra ducks for Crits!
#ifdef STAGING_ONLY
flBias = RemapValClamped( (float)iDuckPower, 0.0f, 10.0f, tf_duck_droprate_bias.GetFloat(), 0.5f);
iMinimum = tf_duck_droprate_min.GetInt();
if ( tf_duck_power_override.GetInt() > 0 )
{
iDuckPower = tf_duck_power_override.GetInt();
}
flBiasScale = tf_duck_random_extra.GetFloat();
#endif
//tf_duck_droprate_bias
int iDuckCount = (int)( Bias( RandomFloat( 0, 1 ), flBias ) * ( flBiasScale + iDuckPower ) ) + iMinimum;
iDuckCount = Max( iDuckCount, (int)iDuckBadgeLevel ); // min ducks for a badge
if ( bCrit )
{
iDuckCount += RandomInt( 1, 2 );
}
if ( pTFCreator && ( iDuckBadgeLevel > 0 ) )
{
if ( RandomInt( 0, 600 ) <= iDuckPower )
{
// MEGA BONUS DUCKS
iDuckCount += iDuckPower;
bSpecial = true;
}
}
if ( iDuckCount > 0 )
{
// Max of 50 ducks, which is a lot of ducks
iDuckCount = Min( 50, iDuckCount );
// High edict count, slow generation
if ( gEntList.NumberOfEdicts() > tf_duck_edict_warning.GetInt() )
{
Warning( "Warning: High level of Edicts, Not spawning as many ducks\n" );
iDuckCount /= 2;
}
int iCreatorId = pTFCreator ? pTFCreator->entindex() : -1;
int iAssisterId = pAssister ? pAssister->entindex() : -1;
int iVictimId = -1;
int iDuckTeam = TEAM_UNASSIGNED;
if ( pTFVictim )
{
iVictimId = pTFVictim->entindex();
iDuckTeam = pTFVictim->GetTeamNumber();
}
for ( int i = 0; i < iDuckCount; ++i )
{
Vector vecOrigin = vPosition + Vector( 0, 0, 50 );
CBonusDuckPickup *pDuckPickup = assert_cast<CBonusDuckPickup*>( CBaseEntity::CreateNoSpawn( "tf_bonus_duck_pickup", vecOrigin, vec3_angle, NULL ) );
if ( pDuckPickup )
{
DispatchSpawn( pDuckPickup );
Vector vecImpulse = RandomVector( -0.5f, 0.5f );
vecImpulse.z = 1.f;
VectorNormalize( vecImpulse );
Vector vecVelocity = vecImpulse * RandomFloat( 350.0f, 450.0f );
pDuckPickup->DropSingleInstance( vecVelocity, NULL, 1.0f );
pDuckPickup->SetCreatorId( iCreatorId );
pDuckPickup->SetVictimId( iVictimId );
pDuckPickup->SetAssisterId( iAssisterId );
pDuckPickup->ChangeTeam( iDuckTeam );
pDuckPickup->SetDuckFlag( iDuckFlags );
// random chance to have a special duck appear
// Bonus duck implies atleast 1 Saxton
if ( bSpecial || ( RandomInt( 1, 100 ) <= tf_test_special_ducks.GetInt() ) )
{
bSpecial = false;
pDuckPickup->m_nSkin = 21; // Quackston Hale
pDuckPickup->SetSpecial();
CSingleUserRecipientFilter filter( pTFCreator );
UserMessageBegin( filter, "BonusDucks" );
WRITE_BYTE( iCreatorId );
WRITE_BYTE( true );
MessageEnd();
}
else
{
if ( iDuckPower > 0 )
{
pDuckPickup->m_nSkin = GetDuckSkinForClass( iDuckTeam, ( pTFVictim && pTFVictim->GetPlayerClass() ) ? pTFVictim->GetPlayerClass()->GetClassIndex() : -1 );
}
else
{
// Scorer without a badge only make normal ducks
pDuckPickup->m_nSkin = iDuckTeam == TF_TEAM_RED ? 1 : 2;
}
pDuckPickup->SetModelScale( 0.7f );
}
}
}
// Update duckstreak count on player and assister if they have badges
if ( pTFCreator && PlayerHasDuckStreaks( pTFCreator ) )
{
pTFCreator->m_Shared.IncrementStreak( CTFPlayerShared::kTFStreak_Ducks, iDuckCount );
}
if ( pAssister && PlayerHasDuckStreaks( pAssister ) )
{
pAssister->m_Shared.IncrementStreak( CTFPlayerShared::kTFStreak_Ducks, iDuckCount );
}
// Duck UserMessage
if ( pTFCreator && pTFVictim && !TFGameRules()->HaveCheatsBeenEnabledDuringLevel() )
{
if ( IsHolidayActive( kHoliday_EOTL ) )
{
// Send a Message to Creator
{
// IsCreated, ID of Creator, ID of Victim, Count, IsGolden
CSingleUserRecipientFilter userfilter( pTFCreator );
UserMessageBegin( userfilter, "EOTLDuckEvent" );
WRITE_BYTE( true );
WRITE_BYTE( iCreatorId );
WRITE_BYTE( iVictimId );
WRITE_BYTE( 0 );
WRITE_BYTE( iDuckTeam );
WRITE_BYTE( iDuckCount );
WRITE_BYTE( iDuckFlags );
MessageEnd();
}
// To assister
if ( pAssister )
{
// IsCreated, ID of Creator, ID of Victim, Count, IsGolden
CSingleUserRecipientFilter userfilter( pAssister );
UserMessageBegin( userfilter, "EOTLDuckEvent" );
WRITE_BYTE( true );
WRITE_BYTE( pAssister->entindex() );
WRITE_BYTE( iVictimId );
WRITE_BYTE( 0 );
WRITE_BYTE( iDuckTeam );
WRITE_BYTE( iDuckCount );
WRITE_BYTE( iDuckFlags );
MessageEnd();
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static kill_eater_event_t g_eClassKillEvents[] =
{
kKillEaterEvent_ScoutKill, // TF_CLASS_SCOUT
kKillEaterEvent_SniperKill, // TF_CLASS_SNIPER
kKillEaterEvent_SoldierKill, // TF_CLASS_SOLDIER
kKillEaterEvent_DemomanKill, // TF_CLASS_DEMOMAN
kKillEaterEvent_MedicKill, // TF_CLASS_MEDIC
kKillEaterEvent_HeavyKill, // TF_CLASS_HEAVYWEAPONS
kKillEaterEvent_PyroKill, // TF_CLASS_PYRO
kKillEaterEvent_SpyKill, // TF_CLASS_SPY
kKillEaterEvent_EngineerKill, // TF_CLASS_ENGINEER
};
COMPILE_TIME_ASSERT( ARRAYSIZE( g_eClassKillEvents ) == (TF_LAST_NORMAL_CLASS - TF_FIRST_NORMAL_CLASS) );
//-----------------------------------------------------------------------------
static kill_eater_event_t g_eRobotClassKillEvents[] =
{
kKillEaterEvent_RobotScoutKill, // TF_CLASS_SCOUT
kKillEaterEvent_RobotSniperKill, // TF_CLASS_SNIPER
kKillEaterEvent_RobotSoldierKill, // TF_CLASS_SOLDIER
kKillEaterEvent_RobotDemomanKill, // TF_CLASS_DEMOMAN
kKillEaterEvent_RobotMedicKill, // TF_CLASS_MEDIC
kKillEaterEvent_RobotHeavyKill, // TF_CLASS_HEAVYWEAPONS
kKillEaterEvent_RobotPyroKill, // TF_CLASS_PYRO
kKillEaterEvent_RobotSpyKill, // TF_CLASS_SPY
kKillEaterEvent_RobotEngineerKill, // TF_CLASS_ENGINEER
};
COMPILE_TIME_ASSERT( ARRAYSIZE( g_eRobotClassKillEvents ) == (TF_LAST_NORMAL_CLASS - TF_FIRST_NORMAL_CLASS) );
static bool BHasWearableOfSpecificQualityEquipped( /*const*/ CTFPlayer *pTFPlayer, EEconItemQuality eQuality )
{
Assert( pTFPlayer );
// Fire the kill eater event on all wearables
for ( int i = 0; i < pTFPlayer->GetNumWearables(); ++i )
{
CTFWearable *pWearableItem = dynamic_cast<CTFWearable *>( pTFPlayer->GetWearable( i ) );
if ( !pWearableItem )
continue;
if ( !pWearableItem->GetAttributeContainer() )
continue;
CEconItemView *pEconItemView = pWearableItem->GetAttributeContainer()->GetItem();
if ( !pEconItemView )
continue;
if ( pEconItemView->GetQuality() == eQuality )
return true;
}
return false;
}
void CTFGameRules::PlayerKilled( CBasePlayer *pVictim, const CTakeDamageInfo &info )
{
// Find the killer & the scorer
CBaseEntity *pInflictor = info.GetInflictor();
CBaseEntity *pKiller = info.GetAttacker();
CBaseMultiplayerPlayer *pScorer = ToBaseMultiplayerPlayer( GetDeathScorer( pKiller, pInflictor, pVictim ) );
CTFPlayer *pAssister = NULL;
CBaseObject *pObject = NULL;
// if inflictor or killer is a base object, tell them that they got a kill
// ( depends if a sentry rocket got the kill, sentry may be inflictor or killer )
if ( pInflictor )
{
if ( pInflictor->IsBaseObject() )
{
pObject = dynamic_cast<CBaseObject *>( pInflictor );
}
else
{
CBaseEntity *pInflictorOwner = pInflictor->GetOwnerEntity();
if ( pInflictorOwner && pInflictorOwner->IsBaseObject() )
{
pObject = dynamic_cast<CBaseObject *>( pInflictorOwner );
}
}
}
else if( pKiller && pKiller->IsBaseObject() )
{
pObject = dynamic_cast<CBaseObject *>( pKiller );
}
if ( pObject )
{
if ( pObject->GetBuilder() != pVictim )
{
pObject->IncrementKills();
// minibosses count for 5 kills
if ( IsMannVsMachineMode() && pVictim && pVictim->IsPlayer() )
{
CTFPlayer *playerVictim = ToTFPlayer( pVictim );
if ( playerVictim->IsMiniBoss() )
{
pObject->IncrementKills();
pObject->IncrementKills();
pObject->IncrementKills();
pObject->IncrementKills();
}
}
}
pInflictor = pObject;
if ( pObject->ObjectType() == OBJ_SENTRYGUN )
{
// notify the sentry
CObjectSentrygun *pSentrygun = dynamic_cast<CObjectSentrygun *>( pObject );
if ( pSentrygun )
{
pSentrygun->OnKilledEnemy( pVictim );
}
CTFPlayer *pOwner = pObject->GetOwner();
if ( pOwner )
{
int iKills = pObject->GetKills();
// keep track of max kills per a single sentry gun in the player object
if ( pOwner->GetMaxSentryKills() < iKills )
{
pOwner->SetMaxSentryKills( iKills );
}
// if we just got 10 kills with one sentry, tell the owner's client, which will award achievement if it doesn't have it already
if ( iKills == 10 )
{
pOwner->AwardAchievement( ACHIEVEMENT_TF_GET_TURRETKILLS );
}
}
}
}
// if not killed by suicide or killed by world, see if the scorer had an assister, and if so give the assister credit
if ( ( pVictim != pScorer ) && pKiller )
{
pAssister = ToTFPlayer( GetAssister( pVictim, pScorer, pInflictor ) );
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pAssister && pTFVictim )
{
EntityHistory_t* entHist = pTFVictim->m_AchievementData.IsSentryDamagerInHistory( pAssister, 5.0 );
if ( entHist )
{
CBaseObject *pObj = dynamic_cast<CBaseObject*>( entHist->hObject.Get() );
if ( pObj )
{
pObj->IncrementAssists();
}
}
// Rage On Assists
// Sniper Kill Rage
if ( pAssister->IsPlayerClass( TF_CLASS_SNIPER ) )
{
// Item attribute
// Add Sniper Rage On Assists
float flRageGain = 0;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pAssister, flRageGain, rage_on_assists );
if (flRageGain != 0)
{
pAssister->m_Shared.ModifyRage(flRageGain);
}
}
}
}
if ( pVictim )
{
if ( ShouldDropSpellPickup() )
{
DropSpellPickup( pVictim->GetAbsOrigin() );
}
CTFPlayer *pTFScorer = ToTFPlayer( pScorer );
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFScorer && pTFVictim )
{
if ( ShouldDropBonusDuckFromPlayer( pTFScorer, pTFVictim ) )
{
DropBonusDuck( pTFVictim->GetAbsOrigin(), pTFScorer, pAssister, pTFVictim, ( info.GetDamageType() & DMG_CRITICAL ) != 0 );
}
}
// Drop a halloween soul!
if ( IsHolidayActive( kHoliday_Halloween ) )
{
CBaseCombatCharacter* pBaseCombatScorer = dynamic_cast< CBaseCombatCharacter*>( pScorer ? pScorer : pKiller );
// No souls for a pure suicide
if ( pTFVictim != pBaseCombatScorer )
{
// Only spawn a soul if the target is a base combat character.
if ( pTFVictim && pBaseCombatScorer )
{
DropHalloweenSoulPack( 1, pVictim->EyePosition(), pBaseCombatScorer, pTFVictim->GetTeamNumber() );
}
// Also spawn one for the assister
if ( pAssister )
{
DropHalloweenSoulPack( 1, pVictim->EyePosition(), pAssister, pTFVictim->GetTeamNumber() );
}
}
}
}
//find the area the player is in and see if his death causes a block
CBaseMultiplayerPlayer *pMultiplayerPlayer = ToBaseMultiplayerPlayer(pVictim);
for ( int i=0; i<ITriggerAreaCaptureAutoList::AutoList().Count(); ++i )
{
CTriggerAreaCapture *pArea = static_cast< CTriggerAreaCapture * >( ITriggerAreaCaptureAutoList::AutoList()[i] );
if ( pArea->IsTouching( pMultiplayerPlayer ) )
{
// ACHIEVEMENT_TF_MEDIC_ASSIST_CAPTURER
// kill 3 players
if ( pAssister && pAssister->IsPlayerClass( TF_CLASS_MEDIC ) )
{
// the victim is touching a cap point, see if they own it
if ( pMultiplayerPlayer->GetTeamNumber() == pArea->GetOwningTeam() )
{
int iDefenderKills = pAssister->GetPerLifeCounterKV( "medic_defender_kills" );
if ( ++iDefenderKills == 3 )
{
pAssister->AwardAchievement( ACHIEVEMENT_TF_MEDIC_ASSIST_CAPTURER );
}
pAssister->SetPerLifeCounterKV( "medic_defender_kills", iDefenderKills );
}
}
if ( pArea->CheckIfDeathCausesBlock( pMultiplayerPlayer, pScorer ) )
break;
}
}
// determine if this kill affected a nemesis relationship
int iDeathFlags = 0;
CTFPlayer *pTFPlayerVictim = ToTFPlayer( pVictim );
CTFPlayer *pTFPlayerScorer = ToTFPlayer( pScorer );
if ( pScorer )
{
CalcDominationAndRevenge( pTFPlayerScorer, info.GetWeapon(), pTFPlayerVictim, false, &iDeathFlags );
if ( pAssister )
{
CalcDominationAndRevenge( pAssister, info.GetWeapon(), pTFPlayerVictim, true, &iDeathFlags );
}
}
pTFPlayerVictim->SetDeathFlags( iDeathFlags );
CTFPlayer *pTFPlayerAssister = ToTFPlayer( pAssister );
if ( pTFPlayerAssister )
{
CTF_GameStats.Event_AssistKill( pTFPlayerAssister, pVictim );
}
// check for achievements
PlayerKilledCheckAchievements( pTFPlayerScorer, pTFPlayerVictim );
if ( IsInTraining() && GetTrainingModeLogic() )
{
if ( pVictim->IsFakeClient() == false )
{
GetTrainingModeLogic()->OnPlayerDied( ToTFPlayer( pVictim ), pKiller );
}
else
{
GetTrainingModeLogic()->OnBotDied( ToTFPlayer( pVictim ), pKiller );
}
}
// credit for dueling
if ( pTFPlayerScorer != NULL && pTFPlayerScorer != pTFPlayerVictim )
{
DuelMiniGame_NotifyKill( pTFPlayerScorer, pTFPlayerVictim );
}
if ( pTFPlayerAssister && pTFPlayerAssister != pTFPlayerVictim )
{
DuelMiniGame_NotifyAssist( pTFPlayerAssister, pTFPlayerVictim );
}
// Count kills from powerup carriers to detect imbalances
if ( IFuncPowerupVolumeAutoList::AutoList().Count() != 0 ) // If there are no func_powerupvolumes in the map, there's no point in checking for imbalances
{
if ( pTFPlayerScorer && pTFPlayerScorer != pTFPlayerVictim && pTFPlayerScorer->m_Shared.IsCarryingRune() && !pTFPlayerScorer->m_Shared.InCond( TF_COND_RUNE_IMBALANCE ) )
{
if ( !m_bPowerupImbalanceMeasuresRunning && !PowerupModeFlagStandoffActive() ) // Only count if imbalance measures aren't running and there is no flag standoff
{
if ( pTFPlayerScorer->GetTeamNumber() == TF_TEAM_BLUE )
{
m_nPowerupKillsBlueTeam++; // Blue team score increases if a powered up blue player makes a kill
}
else if ( pTFPlayerScorer->GetTeamNumber() == TF_TEAM_RED )
{
m_nPowerupKillsRedTeam++;
}
int nBlueAdvantage = m_nPowerupKillsBlueTeam - m_nPowerupKillsRedTeam; // How far ahead is this team?
// Msg( "\nnBlueAdvantage = %d\n", nBlueAdvantage );
int nRedAdvantage = m_nPowerupKillsRedTeam - m_nPowerupKillsBlueTeam;
// Msg( "nRedAdvantage = %d\n\n", nRedAdvantage );
if ( nRedAdvantage >= tf_powerup_mode_imbalance_delta.GetInt() )
{
PowerupTeamImbalance( TF_TEAM_BLUE ); // Fire the output to map logic
}
else if ( nBlueAdvantage >= tf_powerup_mode_imbalance_delta.GetInt() )
{
PowerupTeamImbalance( TF_TEAM_RED );
}
}
}
}
// credit for kill-eating weapons and anything else that might care
if ( pTFPlayerScorer && pTFPlayerVictim && pTFPlayerScorer != pTFPlayerVictim )
{
// Increment the server-side kill count for this weapon -- this is used for honorbound
// weapons and has nothing to do with strange weapons/stats.
pTFPlayerScorer->IncrementKillCountSinceLastDeploy( info );
CTFWeaponBase *pTFWeapon = GetKilleaterWeaponFromDamageInfo( &info );
kill_eater_event_t eKillEaterEvent = pTFWeapon // if we have a weapon...
? pTFWeapon->GetKillEaterKillEventType() // ...then ask it what type of event to report
: info.GetDamageCustom() == TF_DMG_CUSTOM_BOOTS_STOMP // if we don't have a weapon, and we're hacking for kill types from wearables (!)...
? kKillEaterEvent_PlayerKillByBootStomp // ...then use our hard-coded event
: kKillEaterEvent_PlayerKill; // otherwise default to a normal player kill
CEconEntity *pAttackerEconWeapon = NULL;
// Cosmetic Kill like manntreads or demo shield
if ( !pTFWeapon )
{
pAttackerEconWeapon = dynamic_cast< CEconEntity * >( info.GetWeapon() );
}
else
{
pAttackerEconWeapon = dynamic_cast< CEconEntity * >( pTFWeapon );
}
if ( pAttackerEconWeapon )
{
if ( !( IsPVEModeActive() && pTFPlayerVictim->GetTeamNumber() == TF_TEAM_PVE_INVADERS ) )
{
// Any type of non-robot kill!
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, eKillEaterEvent );
// Cosmetic any kill type tracking
{
HatAndMiscEconEntities_OnOwnerKillEaterEvent( pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_CosmeticKills );
// Halloween silliness: overworld kills for Merasmus carnival.
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) && !pTFPlayerScorer->m_Shared.InCond( TF_COND_HALLOWEEN_IN_HELL ) )
{
HatAndMiscEconEntities_OnOwnerKillEaterEvent( pTFPlayerScorer,
pTFPlayerVictim,
kKillEaterEvent_Halloween_OverworldKills );
}
}
// Operation Kills
EconEntity_NonEquippedItemKillTracking( pTFPlayerScorer, pTFPlayerVictim, 1 );
// Unique kill tracking?
EconEntity_OnOwnerUniqueEconEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_UniqueEvent__KilledAccountWithItem );
// Optional Taunt Kill tracking
if ( IsTauntDmg( info.GetDamageCustom() ) )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_TauntKill );
}
// Scorch Shot Taunt is Different
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_FLARE_PELLET )
{
CBaseEntity *pInflictor = info.GetInflictor();
CTFProjectile_Flare *pFlare = dynamic_cast<CTFProjectile_Flare*>(pInflictor);
if ( pFlare && pFlare->IsFromTaunt() )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_TauntKill );
}
}
// Optional: also track "killed X players of this specific class".
int iVictimClassIndex = pTFPlayerVictim->GetPlayerClass()->GetClassIndex();
if ( iVictimClassIndex >= TF_FIRST_NORMAL_CLASS && iVictimClassIndex <= TF_LAST_NORMAL_CLASS )
{
const kill_eater_event_t eClassKillType = g_eClassKillEvents[ iVictimClassIndex - TF_FIRST_NORMAL_CLASS ];
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, eClassKillType );
}
// Optional : Kills while in Victory / Bonus time
if ( State_Get() == GR_STATE_TEAM_WIN && GetWinningTeam() != pTFPlayerVictim->GetTeamNumber() )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_VictoryTimeKill );
}
// Optional: also track "killed X players while they were in the air".
if ( !(pTFPlayerVictim->GetFlags() & FL_ONGROUND) && (pTFPlayerVictim->GetWaterLevel() == WL_NotInWater) )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_AirborneEnemyKill );
}
// Optional: also track "killed X players with headshots".
if ( IsHeadshot( info.GetDamageCustom() ) )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_HeadshotKill );
}
// Optional: also track "gibbed X players".
if ( pTFPlayerVictim->ShouldGib( info ) )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_GibKill );
}
// Optional: also track "killed X players during full moons". We intentionally don't call into the
// game rules here because we don't want server variables to override this. Setting local time on the
// server will still allow it to happen but it at least takes a little effort.
if ( UTIL_IsHolidayActive( kHoliday_FullMoon ) )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillDuringFullMoon );
}
// Optional: also track kills we make while we're dead (afterburn, pre-death-fired rocket, etc.)
if ( !pTFPlayerScorer->IsAlive() )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillPosthumous );
}
// Optional: also track kills that were specifically criticals.
if ( (info.GetDamageType() & DMG_CRITICAL) != 0 )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillCritical );
}
else
{
// Not special at all kill
if ( pTFPlayerVictim->GetAttackBonusEffect() == kBonusEffect_None )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_NonCritKills );
}
}
// Optional: also track kills that were made while we were launched into the air from an explosion (ie., rocket-jumping).
if ( pTFPlayerScorer->InAirDueToExplosion() )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillWhileExplosiveJumping );
}
// Optional: also track kills where the victim was a spy who was invisible at the time of death.
if ( iVictimClassIndex == TF_CLASS_SPY && pTFPlayerVictim->m_Shared.GetPercentInvisible() > 0 )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_InvisibleSpiesKilled );
}
// Optional: also track kills where the victim was a medic with 100% uber.
if ( pTFPlayerVictim->MedicGetChargeLevel() >= 1.0f )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_MedicsWithFullUberKilled );
}
// Optional: also track kills where the killer was at low health when they dealt the final damage. Don't count
// kills with 0 or fewer health -- those would be post-mortem kills instead.
if ( ((float)pTFPlayerScorer->GetHealth() / (float)pTFPlayerScorer->GetMaxHealth()) <= 0.1f && pTFPlayerScorer->GetHealth() > 0 )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_KillWhileLowHealth );
}
// Optional: also track kills that take place during the Halloween holiday. We intentionally *do* check against
// the game rules logic here -- if folks want to enable Halloween mode on a server and play around, I don't see any
// reason why we benefit from stopping their fun.
if ( TF_IsHolidayActive( kHoliday_Halloween ) )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_HalloweenKill );
}
// Optional: also track kills where the victim was completely underwater.
if ( pTFPlayerVictim->GetWaterLevel() >= WL_Eyes )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_UnderwaterKill );
}
// Optional: also track kills where we're under the effects of a medic's ubercharge.
if ( pTFPlayerScorer->m_Shared.InCond( TF_COND_INVULNERABLE ) || pTFPlayerScorer->m_Shared.InCond( TF_COND_INVULNERABLE_WEARINGOFF ) )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_KillWhileUbercharged );
}
// Optional: also track kills where the victim was in the process of carrying the intel, capturing a point, or pushing
// the cart. The actual logic for "killed a flag carrier" is handled elsewhere because by this point we've forgotten
// if we had a flag before we died.
if ( pTFPlayerVictim->IsCapturingPoint() )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_DefenderKill );
}
// Optional: also track kills where the victim was at least N units from the person dealing the damage, where N is "however far
// you have to be to get the crowd chear noise". This also specifically checks to make sure the damage dealer is alive to avoid
// casing where you spectate far away, etc.
if ( pTFPlayerScorer->IsAlive() && (pTFPlayerScorer->GetAbsOrigin() - pTFPlayerVictim->GetAbsOrigin()).Length() >= 2000.0f )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_LongDistanceKill );
}
// Optional: also track kills where the victim was wearing at least one unusual-quality item.
if ( BHasWearableOfSpecificQualityEquipped( pTFPlayerVictim, AE_UNUSUAL ) )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_PlayersWearingUnusualKill );
}
// Optional: also track kills where the victim was on fire at the time that they died. We can't check the condition flag
// here because that may or may not be active after they die, but instead we test to see whether they still had a burn queued
// up for the future as a proxy for "was on fire at this point".
if ( pTFPlayerVictim->m_Shared.GetFlameBurnTime() >= gpGlobals->curtime )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_BurningEnemyKill );
}
// Optional: also track kills where this kill ended someone else's killstreak, where "killstreak" starts when the first
// announcement happens. If Mike gets to hard-code constants, I do, too.
enum { kFirstKillStreakAnnouncement = 5 };
if ( pTFPlayerVictim->m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Kills ) >= kFirstKillStreakAnnouncement )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_KillstreaksEnded );
}
// Optional: also track kills where the killer and the victim were basically right next to each other. This is hard-coded to
// 1.5x default melee swing range.
if ( pTFPlayerScorer->IsAlive() && (pTFPlayerScorer->GetAbsOrigin() - pTFPlayerVictim->GetAbsOrigin()).Length() <= 72.0f )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_PointBlankKills );
}
// Optional : Fullhealth kills
if ( pTFPlayerScorer->GetHealth() >= pTFPlayerScorer->GetMaxHealth() )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_FullHealthKills );
}
// Optional : Taunting Player kills
if ( pTFPlayerVictim->IsTaunting() )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_TauntingPlayerKills );
}
}
else
{
Assert( pTFPlayerVictim->GetTeamNumber() == TF_TEAM_PVE_INVADERS );
// Optional: also track kills where the victim was a robot in MvM
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_RobotsDestroyed );
// Optional: also track "killed X Robots of this specific class".
int iVictimClassIndex = pTFPlayerVictim->GetPlayerClass()->GetClassIndex();
if ( iVictimClassIndex >= TF_FIRST_NORMAL_CLASS && iVictimClassIndex <= TF_LAST_NORMAL_CLASS )
{
const kill_eater_event_t eClassKillType = g_eRobotClassKillEvents[ iVictimClassIndex - TF_FIRST_NORMAL_CLASS ];
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, eClassKillType );
}
// Optional: specifically track miniboss kills separately from base robot kills.
if ( pTFPlayerVictim->IsMiniBoss() )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_MinibossRobotsDestroyed );
}
// Optional: track whether this shot killed a robot *after* penetrating something else.
if ( info.GetPlayerPenetrationCount() > 0 )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_RobotsDestroyedAfterPenetration );
}
// Optional: also track "killed X players with headshots", but for robots specifically.
if ( IsHeadshot( info.GetDamageCustom() ) )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_RobotHeadshotKills );
}
// Optional: also track kills that take place during the Halloween holiday. See note for kKillEaterEvent_HalloweenKill
// regarding calling into game rules here.
if ( TF_IsHolidayActive( kHoliday_Halloween ) )
{
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_HalloweenKillRobot );
}
}
}
}
BaseClass::PlayerKilled( pVictim, info );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::PlayerKilledCheckAchievements( CTFPlayer *pAttacker, CTFPlayer *pVictim )
{
if ( !pAttacker || !pVictim )
return;
// HEAVY WEAPONS GUY
if ( pAttacker->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
{
if ( GetGameType() == TF_GAMETYPE_CP )
{
// ACHIEVEMENT_TF_HEAVY_DEFEND_CONTROL_POINT
CTriggerAreaCapture *pAreaTrigger = pAttacker->GetControlPointStandingOn();
if ( pAreaTrigger )
{
CTeamControlPoint *pCP = pAreaTrigger->GetControlPoint();
if ( pCP )
{
if ( pCP->GetOwner() == pAttacker->GetTeamNumber() )
{
// no suicides!
if ( pAttacker != pVictim )
{
pAttacker->AwardAchievement( ACHIEVEMENT_TF_HEAVY_DEFEND_CONTROL_POINT );
}
}
}
}
// ACHIEVEMENT_TF_HEAVY_KILL_CAPPING_ENEMIES
pAreaTrigger = pVictim->GetControlPointStandingOn();
if ( pAreaTrigger )
{
CTeamControlPoint *pCP = pAreaTrigger->GetControlPoint();
if ( pCP )
{
if ( pCP->GetOwner() == pAttacker->GetTeamNumber() &&
TeamMayCapturePoint( pVictim->GetTeamNumber(), pCP->GetPointIndex() ) &&
PlayerMayCapturePoint( pVictim, pCP->GetPointIndex() ) )
{
pAttacker->AwardAchievement( ACHIEVEMENT_TF_HEAVY_KILL_CAPPING_ENEMIES );
}
}
}
}
// ACHIEVEMENT_TF_HEAVY_CLEAR_STICKYBOMBS
if ( pVictim->IsPlayerClass( TF_CLASS_DEMOMAN ) )
{
int iPipes = pVictim->GetNumActivePipebombs();
for (int i = 0; i < iPipes; i++)
{
pAttacker->AwardAchievement( ACHIEVEMENT_TF_HEAVY_CLEAR_STICKYBOMBS );
}
}
// ACHIEVEMENT_TF_HEAVY_DEFEND_MEDIC
int i;
int iNumHealers = pAttacker->m_Shared.GetNumHealers();
for ( i = 0 ; i < iNumHealers ; i++ )
{
CTFPlayer *pMedic = ToTFPlayer( pAttacker->m_Shared.GetHealerByIndex( i ) );
if ( pMedic && pMedic->m_AchievementData.IsDamagerInHistory( pVictim, 3.0 ) )
{
pAttacker->AwardAchievement( ACHIEVEMENT_TF_HEAVY_DEFEND_MEDIC );
break; // just award it once for each kill...even if the victim attacked more than one medic attached to the killer
}
}
// ACHIEVEMENT_TF_HEAVY_STAND_NEAR_DISPENSER
for ( i = 0 ; i < iNumHealers ; i++ )
{
if ( pAttacker->m_Shared.HealerIsDispenser( i ) )
{
pAttacker->AwardAchievement( ACHIEVEMENT_TF_HEAVY_STAND_NEAR_DISPENSER );
break; // just award it once for each kill...even if the attacker is being healed by more than one dispenser
}
}
}
int i;
int iNumHealers = pAttacker->m_Shared.GetNumHealers();
for ( i = 0 ; i < iNumHealers ; i++ )
{
CTFPlayer *pMedic = ToTFPlayer( pAttacker->m_Shared.GetHealerByIndex( i ) );
if ( pMedic && pMedic->m_AchievementData.IsDamagerInHistory( pVictim, 10.0 ) )
{
IGameEvent * event = gameeventmanager->CreateEvent( "medic_defended" );
if ( event )
{
event->SetInt( "userid", pAttacker->GetUserID() );
event->SetInt( "medic", pMedic->GetUserID() );
gameeventmanager->FireEvent( event );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Determines if attacker and victim have gotten domination or revenge
//-----------------------------------------------------------------------------
void CTFGameRules::CalcDominationAndRevenge( CTFPlayer *pAttacker, CBaseEntity *pWeapon, CTFPlayer *pVictim, bool bIsAssist, int *piDeathFlags )
{
//=============================================================================
// HPE_BEGIN:
// [msmith] If we're in training, we want to disable this domination stuff.
//=============================================================================
if ( IsInTraining() )
return;
//=============================================================================
// HPE_END
//=============================================================================
// don't do domination stuff in powerup mode
if ( IsPowerupMode() )
return;
// no dominations/revenge in competitive mode
if ( IsMatchTypeCompetitive() )
return;
PlayerStats_t *pStatsVictim = CTF_GameStats.FindPlayerStats( pVictim );
// no dominations/revenge in PvE mode
if ( IsPVEModeActive() )
return;
CEconEntity *pEconWeapon = dynamic_cast<CEconEntity *>( pWeapon );
// calculate # of unanswered kills between killer & victim - add 1 to include current kill
int iKillsUnanswered = pStatsVictim->statsKills.iNumKilledByUnanswered[pAttacker->entindex()] + 1;
if ( TF_KILLS_DOMINATION == iKillsUnanswered )
{
// this is the Nth unanswered kill between killer and victim, killer is now dominating victim
*piDeathFlags |= ( bIsAssist ? TF_DEATH_ASSISTER_DOMINATION : TF_DEATH_DOMINATION );
// set victim to be dominated by killer
pAttacker->m_Shared.SetPlayerDominated( pVictim, true );
int iCurrentlyDominated = pAttacker->GetNumberofDominations() + 1;
pAttacker->SetNumberofDominations( iCurrentlyDominated );
// record stats
CTF_GameStats.Event_PlayerDominatedOther( pAttacker );
// strange weapon stat tracking?
EconEntity_OnOwnerKillEaterEvent( pEconWeapon, pAttacker, pVictim, kKillEaterEvent_PlayerKillStartDomination );
}
else if ( pVictim->m_Shared.IsPlayerDominated( pAttacker->entindex() ) )
{
// the killer killed someone who was dominating him, gains revenge
*piDeathFlags |= ( bIsAssist ? TF_DEATH_ASSISTER_REVENGE : TF_DEATH_REVENGE );
// set victim to no longer be dominating the killer
pVictim->m_Shared.SetPlayerDominated( pAttacker, false );
int iCurrentlyDominated = pVictim->GetNumberofDominations() - 1;
if (iCurrentlyDominated < 0)
{
iCurrentlyDominated = 0;
}
pVictim->SetNumberofDominations( iCurrentlyDominated );
// record stats
CTF_GameStats.Event_PlayerRevenge( pAttacker );
// strange weapon stat tracking?
EconEntity_OnOwnerKillEaterEvent( pEconWeapon, pAttacker, pVictim, kKillEaterEvent_PlayerKillRevenge );
}
else if ( pAttacker->m_Shared.IsPlayerDominated( pVictim->entindex() ) )
{
// the killer killed someone who they were already dominating
// strange weapon stat tracking?
EconEntity_OnOwnerKillEaterEvent( pEconWeapon, pAttacker, pVictim, kKillEaterEvent_PlayerKillAlreadyDominated );
}
}
//-----------------------------------------------------------------------------
// Purpose: create some proxy entities that we use for transmitting data */
//-----------------------------------------------------------------------------
void CTFGameRules::CreateStandardEntities()
{
// Create the player resource
g_pPlayerResource = (CPlayerResource*)CBaseEntity::Create( "tf_player_manager", vec3_origin, vec3_angle );
// Create the objective resource
g_pObjectiveResource = (CTFObjectiveResource *)CBaseEntity::Create( "tf_objective_resource", vec3_origin, vec3_angle );
Assert( g_pObjectiveResource );
// Create the monster resource for PvE battles
g_pMonsterResource = (CMonsterResource *)CBaseEntity::Create( "monster_resource", vec3_origin, vec3_angle );
MannVsMachineStats_Init();
// Create the entity that will send our data to the client.
m_hGamerulesProxy = assert_cast<CTFGameRulesProxy*>(CBaseEntity::Create( "tf_gamerules", vec3_origin, vec3_angle ));
Assert( m_hGamerulesProxy.Get() );
m_hGamerulesProxy->SetName( AllocPooledString("tf_gamerules" ) );
CBaseEntity::Create("vote_controller", vec3_origin, vec3_angle);
// Vote Issue classes are handled/cleaned-up by g_voteController
new CKickIssue;
new CRestartGameIssue;
new CChangeLevelIssue;
new CNextLevelIssue;
new CExtendLevelIssue;
new CScrambleTeams;
new CMannVsMachineChangeChallengeIssue;
new CEnableTemporaryHalloweenIssue;
new CTeamAutoBalanceIssue;
new CClassLimitsIssue;
new CPauseGameIssue;
}
//-----------------------------------------------------------------------------
// Purpose: determine the class name of the weapon that got a kill
//-----------------------------------------------------------------------------
const char *CTFGameRules::GetKillingWeaponName( const CTakeDamageInfo &info, CTFPlayer *pVictim, int *iWeaponID )
{
CBaseEntity *pInflictor = info.GetInflictor();
CBaseEntity *pKiller = info.GetAttacker();
CBasePlayer *pScorer = GetDeathScorer( pKiller, pInflictor, pVictim );
const char *killer_weapon_name = "world";
*iWeaponID = TF_WEAPON_NONE;
if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BURNING )
{
// special-case burning damage, since persistent burning damage may happen after attacker has switched weapons
killer_weapon_name = "tf_weapon_flamethrower";
*iWeaponID = TF_WEAPON_FLAMETHROWER;
CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase * >( info.GetWeapon() );
if ( pWeapon )
{
CEconItemView *pItem = pWeapon->GetAttributeContainer()->GetItem();
if ( pItem && pItem->GetStaticData() && pItem->GetStaticData()->GetIconClassname() )
{
killer_weapon_name = pItem->GetStaticData()->GetIconClassname();
*iWeaponID = TF_WEAPON_NONE;
}
}
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BURNING_FLARE )
{
// special-case burning damage, since persistent burning damage may happen after attacker has switched weapons
killer_weapon_name = "tf_weapon_flaregun";
*iWeaponID = TF_WEAPON_FLAREGUN;
if ( pInflictor && pInflictor->IsPlayer() == false )
{
CTFBaseRocket *pBaseRocket = dynamic_cast<CTFBaseRocket*>( pInflictor );
if ( pBaseRocket )
{
if ( pBaseRocket->GetDeflected() )
{
killer_weapon_name = "deflect_flare";
}
}
}
CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase * >( info.GetWeapon() );
if ( pWeapon && pWeapon->GetWeaponID() == TF_WEAPON_FLAREGUN_REVENGE )
{
CEconItemView *pItem = pWeapon->GetAttributeContainer()->GetItem();
if ( pItem && pItem->GetStaticData() && pItem->GetStaticData()->GetIconClassname() )
{
killer_weapon_name = pItem->GetStaticData()->GetIconClassname();
*iWeaponID = pWeapon->GetWeaponID();
}
}
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_FLARE_EXPLOSION )
{
killer_weapon_name = "tf_weapon_detonator";
*iWeaponID = TF_WEAPON_FLAREGUN;
if ( pInflictor && pInflictor->IsPlayer() == false )
{
CTFBaseRocket *pBaseRocket = dynamic_cast<CTFBaseRocket*>( pInflictor );
if ( pBaseRocket )
{
if ( pBaseRocket->GetDeflected() )
{
killer_weapon_name = "deflect_flare_detonator";
}
}
}
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_CHARGE_IMPACT )
{
CTFWearable *pWearable = dynamic_cast< CTFWearable * >( info.GetWeapon() );
if ( pWearable )
{
CEconItemView *pItem = pWearable->GetAttributeContainer()->GetItem();
if ( pItem && pItem->GetStaticData() && pItem->GetStaticData()->GetIconClassname() )
{
killer_weapon_name = pItem->GetStaticData()->GetIconClassname();
*iWeaponID = TF_WEAPON_NONE;
}
}
}
else if ( info.GetPlayerPenetrationCount() > 0 )
{
// This may be stomped later if the kill was a headshot.
killer_weapon_name = "player_penetration";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_PICKAXE )
{
killer_weapon_name = "pickaxe";
*iWeaponID = TF_WEAPON_SHOVEL;
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_CARRIED_BUILDING )
{
killer_weapon_name = "tf_weapon_building_carried_destroyed";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_HADOUKEN )
{
killer_weapon_name = "tf_weapon_taunt_pyro";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_HIGH_NOON )
{
killer_weapon_name = "tf_weapon_taunt_heavy";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_GRAND_SLAM )
{
killer_weapon_name = "tf_weapon_taunt_scout";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_BARBARIAN_SWING )
{
killer_weapon_name = "tf_weapon_taunt_demoman";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_UBERSLICE )
{
killer_weapon_name = "tf_weapon_taunt_medic";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_FENCING )
{
killer_weapon_name = "tf_weapon_taunt_spy";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_ARROW_STAB )
{
killer_weapon_name = "tf_weapon_taunt_sniper";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_GRENADE )
{
CTFPlayer *pTFKiller = ToTFPlayer( pKiller );
if ( pTFKiller && pTFKiller->IsWormsGearEquipped() )
{
killer_weapon_name = "tf_weapon_taunt_soldier_lumbricus";
}
else
{
killer_weapon_name = "tf_weapon_taunt_soldier";
}
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_ENGINEER_GUITAR_SMASH )
{
killer_weapon_name = "tf_weapon_taunt_guitar_kill";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_ALLCLASS_GUITAR_RIFF )
{
killer_weapon_name = "tf_weapon_taunt_guitar_riff_kill";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_ENGINEER_ARM_KILL )
{
killer_weapon_name = "robot_arm_blender_kill";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TELEFRAG )
{
killer_weapon_name = "telefrag";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BOOTS_STOMP )
{
killer_weapon_name = "mantreads";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BASEBALL )
{
killer_weapon_name = "ball";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_COMBO_PUNCH )
{
killer_weapon_name = "robot_arm_combo_kill";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BLEEDING )
{
killer_weapon_name = "tf_weapon_bleed_kill";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_PLAYER_SENTRY )
{
int nGigerCounter = 0;
if ( pScorer )
{
CALL_ATTRIB_HOOK_INT_ON_OTHER( pScorer, nGigerCounter, is_giger_counter );
}
if ( nGigerCounter > 0 )
{
killer_weapon_name = "giger_counter";
}
else
{
killer_weapon_name = "wrangler_kill";
}
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_DECAPITATION_BOSS )
{
killer_weapon_name = "headtaker";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_EYEBALL_ROCKET )
{
killer_weapon_name = "eyeball_rocket";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_STICKBOMB_EXPLOSION )
{
killer_weapon_name = "ullapool_caber_explosion";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_ARMAGEDDON )
{
killer_weapon_name = "armageddon";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SAPPER_RECORDER_DEATH )
{
killer_weapon_name = "recorder";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_MERASMUS_DECAPITATION )
{
killer_weapon_name = "merasmus_decap";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_MERASMUS_ZAP )
{
killer_weapon_name = "merasmus_zap";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_MERASMUS_GRENADE )
{
killer_weapon_name = "merasmus_grenade";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_MERASMUS_PLAYER_BOMB )
{
killer_weapon_name = "merasmus_player_bomb";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_CANNONBALL_PUSH )
{
killer_weapon_name = "loose_cannon_impact";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_TELEPORT )
{
killer_weapon_name = "spellbook_teleport";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_SKELETON )
{
killer_weapon_name = "spellbook_skeleton";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_MIRV )
{
killer_weapon_name = "spellbook_mirv";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_METEOR )
{
killer_weapon_name = "spellbook_meteor";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_LIGHTNING )
{
killer_weapon_name = "spellbook_lightning";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_FIREBALL )
{
killer_weapon_name = "spellbook_fireball";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_MONOCULUS )
{
killer_weapon_name = "spellbook_boss";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_BLASTJUMP )
{
killer_weapon_name = "spellbook_blastjump";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_BATS )
{
killer_weapon_name = "spellbook_bats";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_TINY )
{
killer_weapon_name = "spellbook_athletic";
}
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_THROWABLE ||
info.GetDamageCustom() == TF_DMG_CUSTOM_THROWABLE_KILL ) // Throwables
{
if ( pVictim && pVictim->GetHealth() <= 0 )
{
killer_weapon_name = "water_balloon_kill";
}
else
{
killer_weapon_name = "water_balloon_hit";
}
*iWeaponID = TF_WEAPON_THROWABLE;
}
else if ( pScorer && pInflictor && ( pInflictor == pScorer ) )
{
// If this is not a suicide
if ( pVictim != pScorer )
{
// If the inflictor is the killer, then it must be their current weapon doing the damage
if ( pScorer->GetActiveWeapon() )
{
killer_weapon_name = pScorer->GetActiveWeapon()->GetClassname();
if ( pScorer->IsPlayer() )
{
*iWeaponID = ToTFPlayer(pScorer)->GetActiveTFWeapon()->GetWeaponID();
}
}
}
}
else if ( pInflictor )
{
killer_weapon_name = STRING( pInflictor->m_iClassname );
CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase * >( pInflictor );
if ( pWeapon )
{
*iWeaponID = pWeapon->GetWeaponID();
}
else
{
CTFBaseRocket *pBaseRocket = dynamic_cast<CTFBaseRocket*>( pInflictor );
if ( pBaseRocket )
{
*iWeaponID = pBaseRocket->GetWeaponID();
if ( pBaseRocket->GetDeflected() )
{
if ( *iWeaponID == TF_WEAPON_ROCKETLAUNCHER || *iWeaponID == TF_WEAPON_ROCKETLAUNCHER_DIRECTHIT )
{
killer_weapon_name = "deflect_rocket";
}
else if ( *iWeaponID == TF_WEAPON_COMPOUND_BOW )
{
CTFProjectile_Arrow* pArrow = dynamic_cast<CTFProjectile_Arrow*>( pBaseRocket );
if ( pArrow && pArrow->IsAlight() )
{
killer_weapon_name = "deflect_huntsman_flyingburn";
}
else
{
killer_weapon_name = "deflect_arrow";
}
}
else if ( *iWeaponID == TF_WEAPON_SHOTGUN_BUILDING_RESCUE )
{
killer_weapon_name = "rescue_ranger_reflect";
}
}
else if ( *iWeaponID == TF_WEAPON_ROCKETLAUNCHER_DIRECTHIT )
{
killer_weapon_name = "rocketlauncher_directhit";
}
}
else
{
CTFWeaponBaseGrenadeProj *pBaseGrenade = dynamic_cast<CTFWeaponBaseGrenadeProj*>( pInflictor );
if ( pBaseGrenade )
{
*iWeaponID = pBaseGrenade->GetWeaponID();
if ( pBaseGrenade->GetDeflected() )
{
if ( *iWeaponID == TF_WEAPON_GRENADE_PIPEBOMB )
{
killer_weapon_name = "deflect_sticky";
}
else if ( *iWeaponID == TF_WEAPON_GRENADE_DEMOMAN )
{
killer_weapon_name = "deflect_promode";
}
else if ( *iWeaponID == TF_WEAPON_BAT_WOOD )
{
killer_weapon_name = "deflect_ball";
}
else if ( *iWeaponID == TF_WEAPON_CANNON )
{
killer_weapon_name = "loose_cannon_reflect";
}
}
}
}
}
}
if ( info.GetDamageCustom() == TF_DMG_CUSTOM_DEFENSIVE_STICKY )
{
killer_weapon_name = "sticky_resistance";
}
// strip certain prefixes from inflictor's classname
const char *prefix[] = { "tf_weapon_grenade_", "tf_weapon_", "NPC_", "func_" };
for ( int i = 0; i< ARRAYSIZE( prefix ); i++ )
{
// if prefix matches, advance the string pointer past the prefix
int len = Q_strlen( prefix[i] );
if ( strncmp( killer_weapon_name, prefix[i], len ) == 0 )
{
killer_weapon_name += len;
break;
}
}
// look out for sentry rocket as weapon and map it to sentry gun, so we get the sentry death icon based off level
if ( 0 == Q_strcmp( killer_weapon_name, "tf_projectile_sentryrocket" ) )
{
killer_weapon_name = "obj_sentrygun3";
}
else if ( 0 == Q_strcmp( killer_weapon_name, "obj_sentrygun" ) )
{
CObjectSentrygun *pSentrygun = assert_cast<CObjectSentrygun*>( pInflictor );
if ( pSentrygun )
{
if ( pSentrygun->IsMiniBuilding() )
{
killer_weapon_name = "obj_minisentry";
}
else
{
int iSentryLevel = pSentrygun->GetUpgradeLevel();
switch( iSentryLevel)
{
case 1:
killer_weapon_name = "obj_sentrygun";
break;
case 2:
killer_weapon_name = "obj_sentrygun2";
break;
case 3:
killer_weapon_name = "obj_sentrygun3";
break;
default:
killer_weapon_name = "obj_sentrygun";
break;
}
}
}
}
else if ( 0 == Q_strcmp( killer_weapon_name, "tf_projectile_healing_bolt" ) )
{
killer_weapon_name = "crusaders_crossbow";
}
else if ( 0 == Q_strcmp( killer_weapon_name, "tf_projectile_pipe" ) )
{
// let's look-up the primary weapon to see what type of grenade launcher it is
if ( pScorer )
{
CTFPlayer *pTFScorer = ToTFPlayer( pScorer );
if ( pTFScorer )
{
CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase * >( pTFScorer->Weapon_GetWeaponByType( TF_WPN_TYPE_PRIMARY ) );
if ( pWeapon && ( pWeapon->GetWeaponID() == TF_WEAPON_GRENADELAUNCHER ) && pWeapon->GetAttributeContainer() )
{
CEconItemView *pItem = pWeapon->GetAttributeContainer()->GetItem();
if ( pItem && pItem->GetStaticData() )
{
if ( pItem->GetStaticData()->GetIconClassname() )
{
killer_weapon_name = pItem->GetStaticData()->GetIconClassname();
*iWeaponID = TF_WEAPON_NONE;
}
}
}
}
}
}
else if ( 0 == Q_strcmp( killer_weapon_name, "tf_projectile_energy_ring" ) )
{
CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase *>( info.GetWeapon() );
if ( pWeapon )
{
CEconItemView *pItem = pWeapon->GetAttributeContainer()->GetItem();
if ( pItem && pItem->GetStaticData() && pItem->GetStaticData()->GetIconClassname() )
{
killer_weapon_name = pItem->GetStaticData()->GetIconClassname();
*iWeaponID = TF_WEAPON_NONE;
}
}
}
else if ( 0 == Q_strcmp( killer_weapon_name, "obj_attachment_sapper" ) )
{
// let's look-up the sapper weapon to see what type it is
if ( pScorer )
{
CTFPlayer *pTFScorer = ToTFPlayer( pScorer );
if ( pTFScorer )
{
CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase *>( pTFScorer->GetEntityForLoadoutSlot( LOADOUT_POSITION_BUILDING ) );
if ( pWeapon && ( pWeapon->GetWeaponID() == TF_WEAPON_BUILDER ) && pWeapon->GetAttributeContainer() )
{
CEconItemView *pItem = pWeapon->GetAttributeContainer()->GetItem();
if ( pItem && pItem->GetStaticData() )
{
if ( pItem->GetStaticData()->GetIconClassname() )
{
killer_weapon_name = pItem->GetStaticData()->GetIconClassname();
*iWeaponID = TF_WEAPON_NONE;
}
}
}
}
}
}
else if ( ( info.GetDamageCustom() == TF_DMG_CUSTOM_STANDARD_STICKY ) || ( info.GetDamageCustom() == TF_DMG_CUSTOM_AIR_STICKY_BURST ) )
{
// let's look-up the secondary weapon to see what type of sticky launcher it is
if ( pScorer )
{
CTFPlayer *pTFScorer = ToTFPlayer( pScorer );
if ( pTFScorer )
{
CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase * >( pTFScorer->Weapon_GetWeaponByType( TF_WPN_TYPE_SECONDARY ) );
if ( pWeapon && ( pWeapon->GetWeaponID() == TF_WEAPON_PIPEBOMBLAUNCHER ) && pWeapon->GetAttributeContainer() )
{
CEconItemView *pItem = pWeapon->GetAttributeContainer()->GetItem();
if ( pItem && pItem->GetStaticData() )
{
if ( pItem->GetStaticData()->GetIconClassname() )
{
killer_weapon_name = pItem->GetStaticData()->GetIconClassname();
*iWeaponID = TF_WEAPON_NONE;
}
}
}
}
}
}
return killer_weapon_name;
}
//-----------------------------------------------------------------------------
// Purpose: returns the player who assisted in the kill, or NULL if no assister
//-----------------------------------------------------------------------------
CBasePlayer *CTFGameRules::GetAssister( CBasePlayer *pVictim, CBasePlayer *pScorer, CBaseEntity *pInflictor )
{
CTFPlayer *pTFScorer = ToTFPlayer( pScorer );
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFScorer && pTFVictim )
{
// if victim killed himself, don't award an assist to anyone else, even if there was a recent damager
if ( pTFScorer == pTFVictim )
return NULL;
// If an assist has been specified already, use it.
if ( pTFVictim->m_Shared.GetAssist() )
{
return pTFVictim->m_Shared.GetAssist();
}
// If a player is healing the scorer, give that player credit for the assist
CTFPlayer *pHealer = ToTFPlayer( pTFScorer->m_Shared.GetFirstHealer() );
// Must be a medic to receive a healing assist, otherwise engineers get credit for assists from dispensers doing healing.
// Also don't give an assist for healing if the inflictor was a sentry gun, otherwise medics healing engineers get assists for the engineer's sentry kills.
if ( pHealer && ( TF_CLASS_MEDIC == pHealer->GetPlayerClass()->GetClassIndex() ) && ( NULL == dynamic_cast<CObjectSentrygun *>( pInflictor ) ) )
{
return pHealer;
}
// If we're under the effect of a condition that grants assists, give one to the player that buffed us
CTFPlayer *pCondAssister = ToTFPlayer( pTFScorer->m_Shared.GetConditionAssistFromAttacker() );
if ( pCondAssister )
return pCondAssister;
// See who has damaged the victim 2nd most recently (most recent is the killer), and if that is within a certain time window.
// If so, give that player an assist. (Only 1 assist granted, to single other most recent damager.)
CTFPlayer *pRecentDamager = GetRecentDamager( pTFVictim, 1, TF_TIME_ASSIST_KILL );
if ( pRecentDamager && ( pRecentDamager != pScorer ) )
return pRecentDamager;
// if a teammate has recently helped this sentry (ie: wrench hit), they assisted in the kill
CObjectSentrygun *sentry = dynamic_cast< CObjectSentrygun * >( pInflictor );
if ( sentry )
{
CTFPlayer *pAssister = sentry->GetAssistingTeammate( TF_TIME_ASSIST_KILL );
if ( pAssister )
return pAssister;
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Returns specified recent damager, if there is one who has done damage
// within the specified time period. iDamager=0 returns the most recent
// damager, iDamager=1 returns the next most recent damager.
//-----------------------------------------------------------------------------
CTFPlayer *CTFGameRules::GetRecentDamager( CTFPlayer *pVictim, int iDamager, float flMaxElapsed )
{
EntityHistory_t *damagerHistory = pVictim->m_AchievementData.GetDamagerHistory( iDamager );
if ( !damagerHistory )
return NULL;
if ( damagerHistory->hEntity && ( gpGlobals->curtime - damagerHistory->flTimeDamage <= flMaxElapsed ) )
{
CTFPlayer *pRecentDamager = ToTFPlayer( damagerHistory->hEntity );
if ( pRecentDamager )
return pRecentDamager;
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Returns who should be awarded the kill
//-----------------------------------------------------------------------------
CBasePlayer *CTFGameRules::GetDeathScorer( CBaseEntity *pKiller, CBaseEntity *pInflictor, CBaseEntity *pVictim )
{
if ( ( pKiller == pVictim ) && ( pKiller == pInflictor ) )
{
// If this was an explicit suicide, see if there was a damager within a certain time window. If so, award this as a kill to the damager.
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim )
{
CTFPlayer *pRecentDamager = GetRecentDamager( pTFVictim, 0, TF_TIME_SUICIDE_KILL_CREDIT );
if ( pRecentDamager )
return pRecentDamager;
}
}
//Handle Pyro's Deflection credit.
CTFWeaponBaseGrenadeProj *pBaseGrenade = dynamic_cast<CTFWeaponBaseGrenadeProj*>( pInflictor );
if ( pBaseGrenade )
{
if ( pBaseGrenade->GetDeflected() )
{
if ( pBaseGrenade->GetWeaponID() == TF_WEAPON_GRENADE_PIPEBOMB )
{
CTFPlayer *pDeflectOwner = ToTFPlayer( pBaseGrenade->GetDeflectOwner() );
if ( pDeflectOwner )
{
if ( pDeflectOwner->InSameTeam( pVictim ) == false )
return pDeflectOwner;
else
{
pBaseGrenade->ResetDeflected();
pBaseGrenade->SetDeflectOwner( NULL );
}
}
}
}
}
return BaseClass::GetDeathScorer( pKiller, pInflictor, pVictim );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pVictim -
// *pKiller -
// *pInflictor -
//-----------------------------------------------------------------------------
void CTFGameRules::DeathNotice( CBasePlayer *pVictim, const CTakeDamageInfo &info )
{
DeathNotice( pVictim, info, "player_death" );
}
void CTFGameRules::DeathNotice( CBasePlayer *pVictim, const CTakeDamageInfo &info, const char* eventName )
{
int killer_ID = 0;
// Find the killer & the scorer
CTFPlayer *pTFPlayerVictim = ToTFPlayer( pVictim );
CBaseEntity *pInflictor = info.GetInflictor();
CBaseEntity *pKiller = info.GetAttacker();
CTFPlayer *pScorer = ToTFPlayer( GetDeathScorer( pKiller, pInflictor, pVictim ) );
CTFPlayer *pAssister = ToTFPlayer( GetAssister( pVictim, pScorer, pInflictor ) );
// You can't assist yourself!
Assert( pScorer != pAssister || !pScorer );
if ( pScorer == pAssister && pScorer )
{
pAssister = NULL;
}
// Silent killers cause no death notices.
bool bSilentKill = false;
CTFPlayer *pAttacker = (CTFPlayer*)ToTFPlayer( info.GetAttacker() );
if ( pAttacker )
{
CTFWeaponBase *pWpn = pAttacker->GetActiveTFWeapon();
if ( pWpn && pWpn->IsSilentKiller() && ( info.GetDamageCustom() == TF_DMG_CUSTOM_BACKSTAB ) )
bSilentKill = true;
}
// Determine whether it's a feign death fake death notice
bool bFeignDeath = pTFPlayerVictim->IsGoingFeignDeath();
if ( bFeignDeath )
{
CTFPlayer *pDisguiseTarget = ToTFPlayer( pTFPlayerVictim->m_Shared.GetDisguiseTarget() );
if ( pDisguiseTarget && (pTFPlayerVictim->GetTeamNumber() == pDisguiseTarget->GetTeamNumber()) )
{
// We're disguised as a team mate. Pretend to die as that player instead of us.
pVictim = pTFPlayerVictim = pDisguiseTarget;
}
}
// Work out what killed the player, and send a message to all clients about it
int iWeaponID;
const char *killer_weapon_name = GetKillingWeaponName( info, pTFPlayerVictim, &iWeaponID );
const char *killer_weapon_log_name = killer_weapon_name;
// Kill eater events.
{
// Was this a sentry kill? If the sentry did the kill itself with bullets then it'll be the inflictor.
// If it got the kill by firing a rocket, the rocket will be the inflictor and the sentry will be the
// owner of the rocket.
//
// Holy crap dynamic_cast quagmire of sadness below.
CObjectSentrygun *pSentrygun = dynamic_cast<CObjectSentrygun *>( pInflictor );
if ( !pSentrygun )
{
pSentrygun = pInflictor ? dynamic_cast<CObjectSentrygun *>( pInflictor->GetOwnerEntity() ) : NULL;
}
if ( pSentrygun )
{
// Try to grab the wrench that the engineer has equipped right now. We destroy sentries when wrenches
// get changed so whatever they have equipped right now counts for the wrench that built this sentry.
CTFPlayer *pBuilder = pSentrygun->GetBuilder();
if ( pBuilder )
{
EconEntity_OnOwnerKillEaterEvent( dynamic_cast<CEconEntity *>( pBuilder->GetEntityForLoadoutSlot( LOADOUT_POSITION_MELEE ) ), pScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillsBySentry );
// PDA's Also count Sentry kills
EconEntity_OnOwnerKillEaterEvent( dynamic_cast<CEconEntity *>( pBuilder->GetEntityForLoadoutSlot( LOADOUT_POSITION_PDA ) ), pScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillsBySentry );
// Check if the engineer is using a Wrangler on this sentry
CTFLaserPointer* pLaserPointer = dynamic_cast< CTFLaserPointer * >( pBuilder->GetEntityForLoadoutSlot( LOADOUT_POSITION_SECONDARY ) );
if ( pLaserPointer && pLaserPointer->HasLaserDot() )
{
EconEntity_OnOwnerKillEaterEvent( dynamic_cast<CEconEntity *>( pLaserPointer ), pScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillsByManualControlOfSentry );
}
}
}
// Should we award an assist kill to someone?
if ( pAssister )
{
EconEntity_OnOwnerKillEaterEvent( dynamic_cast<CEconEntity *>( pAssister->GetActiveWeapon() ), pAssister, pTFPlayerVictim, kKillEaterEvent_PlayerKillAssist );
HatAndMiscEconEntities_OnOwnerKillEaterEvent( pAssister, pTFPlayerVictim, kKillEaterEvent_CosmeticAssists );
}
}
if ( pScorer ) // Is the killer a client?
{
killer_ID = pScorer->GetUserID();
}
CTFWeaponBase *pScorerWeapon = NULL;
if ( pScorer )
{
pScorerWeapon = dynamic_cast< CTFWeaponBase * >( pScorer->Weapon_OwnsThisID( iWeaponID ) );
if ( pScorerWeapon )
{
CEconItemView *pItem = pScorerWeapon->GetAttributeContainer()->GetItem();
if ( pItem )
{
if ( pItem->GetStaticData()->GetIconClassname() )
{
killer_weapon_name = pItem->GetStaticData()->GetIconClassname();
}
if ( pItem->GetStaticData()->GetLogClassname() )
{
killer_weapon_log_name = pItem->GetStaticData()->GetLogClassname();
}
}
}
}
// In Arena mode award first blood to the first player that kills an enemy.
bool bKillWasFirstBlood = false;
if ( IsFirstBloodAllowed() )
{
if ( pScorer && pVictim && pScorer != pVictim )
{
if ( !FStrEq( eventName, "fish_notice" ) && !FStrEq( eventName, "fish_notice__arm" ) && !FStrEq( eventName, "throwable_hit" ) )
{
#ifndef _DEBUG
if ( GetGlobalTeam( pVictim->GetTeamNumber() ) && GetGlobalTeam( pVictim->GetTeamNumber() )->GetNumPlayers() > 1 )
#endif // !DEBUG
{
float flFastTime = IsCompetitiveMode() ? 120.f : TF_ARENA_MODE_FAST_FIRST_BLOOD_TIME;
float flSlowTime = IsCompetitiveMode() ? 300.f : TF_ARENA_MODE_SLOW_FIRST_BLOOD_TIME;
if ( ( gpGlobals->curtime - m_flRoundStartTime ) <= flFastTime )
{
BroadcastSound( 255, "Announcer.AM_FirstBloodFast" );
}
else if ( ( gpGlobals->curtime - m_flRoundStartTime ) >= flSlowTime )
{
BroadcastSound( 255, "Announcer.AM_FirstBloodFinally" );
}
else
{
BroadcastSound( 255, "Announcer.AM_FirstBloodRandom" );
}
m_bArenaFirstBlood = true;
bKillWasFirstBlood = true;
if ( IsCompetitiveMode() )
{
// CTF_GameStats.Event_PlayerAwardBonusPoints( pScorer, pVictim, 10 );
//
// CUtlVector< CTFPlayer* > vecPlayers;
// CollectPlayers( &vecPlayers, pScorer->GetTeamNumber(), false );
// FOR_EACH_VEC( vecPlayers, i )
// {
// if ( !vecPlayers[i] )
// continue;
//
// if ( vecPlayers[i] == pScorer )
// continue;
//
// CTF_GameStats.Event_PlayerAwardBonusPoints( vecPlayers[i], pVictim, 5 );
// }
}
else
{
pScorer->m_Shared.AddCond( TF_COND_CRITBOOSTED_FIRST_BLOOD, TF_ARENA_MODE_FIRST_BLOOD_CRIT_TIME );
}
}
}
}
}
else
{
// so you can't turn on the ConVar in the middle of a round and get the first blood reward
m_bArenaFirstBlood = true;
}
// Awesome hack for pyroland silliness: if there was no other assister, and the person that got
// the kill has some sort of "pet" item (balloonicorn, brainslug, etc.), we send the name of
// that item down as the assister. We'll use a custom name if available and fall back to the
// localization token (localized on the client) if not.
CUtlConstString sAssisterOverrideDesc;
if ( pScorer && !pAssister )
{
// Find out whether the killer has at least one item that will ask for kill assist credit.
int iKillerHasPetItem = 0;
CUtlVector<CBaseEntity *> vecItems;
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER_WITH_ITEMS( pScorer, iKillerHasPetItem, &vecItems, counts_as_assister );
FOR_EACH_VEC( vecItems, i )
{
CEconEntity *pEconEntity = dynamic_cast<CEconEntity *>( vecItems[i] );
if ( !pEconEntity )
continue;
CEconItemView *pEconItemView = pEconEntity->GetAttributeContainer()->GetItem();
if ( !pEconItemView )
continue;
if ( pEconItemView->GetCustomName() )
{
sAssisterOverrideDesc = CFmtStr( "%c%s", iKillerHasPetItem == 2 ? kHorriblePyroVisionHack_KillAssisterType_CustomName_First : kHorriblePyroVisionHack_KillAssisterType_CustomName, pEconItemView->GetCustomName() );
}
else
{
sAssisterOverrideDesc = CFmtStr( "%c%s", iKillerHasPetItem == 2 ? kHorriblePyroVisionHack_KillAssisterType_LocalizationString_First : kHorriblePyroVisionHack_KillAssisterType_LocalizationString, pEconItemView->GetItemDefinition()->GetItemBaseName() ).Get();
}
break;
}
}
IGameEvent * event = gameeventmanager->CreateEvent( eventName /* "player_death" */ );
//if ( event && FStrEq( eventName, "throwable_hit" ) )
//{
// int iHitCount = 1;
// PlayerStats_t *pStats = CTF_GameStats.FindPlayerStats( pScorer );
// if ( pStats )
// {
// iHitCount = pStats->statsAccumulated.Get( TFSTAT_THROWABLEHIT );
// }
// event->SetInt( "totalhits", iHitCount );
//}
if ( event )
{
event->SetInt( "userid", pVictim->GetUserID() );
event->SetInt( "victim_entindex", pVictim->entindex() );
event->SetInt( "attacker", killer_ID );
event->SetInt( "assister", pAssister ? pAssister->GetUserID() : -1 );
event->SetString( "weapon", killer_weapon_name );
event->SetString( "weapon_logclassname", killer_weapon_log_name );
event->SetInt( "weaponid", iWeaponID );
event->SetInt( "damagebits", info.GetDamageType() );
event->SetInt( "customkill", info.GetDamageCustom() );
event->SetInt( "inflictor_entindex", pInflictor ? pInflictor->entindex() : -1 );
event->SetInt( "priority", 7 ); // HLTV event priority, not transmitted
if ( info.GetPlayerPenetrationCount() > 0 )
{
event->SetInt( "playerpenetratecount", info.GetPlayerPenetrationCount() );
}
if ( !sAssisterOverrideDesc.IsEmpty() )
{
event->SetString( "assister_fallback", sAssisterOverrideDesc.Get() );
}
event->SetBool( "silent_kill", bSilentKill );
int iDeathFlags = pTFPlayerVictim->GetDeathFlags();
if ( bKillWasFirstBlood )
{
iDeathFlags |= TF_DEATH_FIRST_BLOOD;
}
if ( bFeignDeath )
{
iDeathFlags |= TF_DEATH_FEIGN_DEATH;
}
if ( pTFPlayerVictim->WasGibbedOnLastDeath() )
{
iDeathFlags |= TF_DEATH_GIBBED;
}
if ( pTFPlayerVictim->IsInPurgatory() )
{
iDeathFlags |= TF_DEATH_PURGATORY;
}
if ( pTFPlayerVictim->IsMiniBoss() )
{
iDeathFlags |= TF_DEATH_MINIBOSS;
}
// Australium Guns get a Gold Background
IHasAttributes *pAttribInterface = GetAttribInterface( info.GetWeapon() );
if ( pAttribInterface )
{
int iIsAustralium = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iIsAustralium, is_australium_item );
if ( iIsAustralium )
{
iDeathFlags |= TF_DEATH_AUSTRALIUM;
}
}
// We call this directly since we need more information than provided in the event alone.
if ( FStrEq( eventName, "player_death" ) )
{
CTF_GameStats.Event_KillDetail( pScorer, pTFPlayerVictim, pAssister, event, info );
event->SetInt( "kill_streak_victim", pTFPlayerVictim->m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Kills ) );
event->SetBool( "rocket_jump", ( pTFPlayerVictim->RocketJumped() == 1 ) );
event->SetInt( "crit_type", info.GetCritType() );
// Kill streak updating
if ( pTFPlayerVictim && pScorer && pTFPlayerVictim != pScorer )
{
// Propagate duckstreaks
event->SetInt( "duck_streak_victim", pTFPlayerVictim->m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Ducks ) );
event->SetInt( "duck_streak_total", pScorer->m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Ducks ) );
event->SetInt( "ducks_streaked", pScorer->m_Shared.GetLastDuckStreakIncrement() );
// Check if they have the appropriate attribute.
int iKillStreak = 0;
int iKills = 0;
CBaseEntity *pKillStreakTarget = NULL;
if ( !pAttribInterface )
{
// Check if you are a sentry and if so, use the wrench
// For Sentries Inflictor can be the sentry (bullets) or the Sentry Rocket
CObjectSentrygun *pSentry = dynamic_cast<CObjectSentrygun*>( pInflictor );
if ( !pSentry && pInflictor )
{
pSentry = dynamic_cast<CObjectSentrygun*>( pInflictor->GetOwnerEntity() );
}
if ( pSentry )
{
pKillStreakTarget = dynamic_cast<CTFWeaponBase*>( pScorer->GetEntityForLoadoutSlot( LOADOUT_POSITION_MELEE ) );
}
}
else
{
pKillStreakTarget = info.GetWeapon();
}
if ( pKillStreakTarget )
{
CALL_ATTRIB_HOOK_INT_ON_OTHER( pKillStreakTarget, iKillStreak, killstreak_tier );
#ifdef STAGING_ONLY
if ( tf_killstreak_alwayson.GetBool() )
{
iKillStreak = 1;
}
#endif
// Always track killstreak regardless of the attribute for data collection purposes
pScorer->m_Shared.IncrementStreak( CTFPlayerShared::kTFStreak_KillsAll, 1 );
if ( iKillStreak )
{
iKills = pScorer->m_Shared.IncrementStreak( CTFPlayerShared::kTFStreak_Kills, 1 );
event->SetInt( "kill_streak_total", iKills );
int iWepKills = 0;
CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase*>( pKillStreakTarget );
if ( pWeapon )
{
iWepKills = pWeapon->GetKillStreak() + 1;
pWeapon->SetKillStreak( iWepKills );
}
else
{
CTFWearable *pWearable = dynamic_cast<CTFWearable*>( pKillStreakTarget );
if ( pWearable )
{
iWepKills = pWearable->GetKillStreak() + 1;
pWearable->SetKillStreak( iWepKills );
}
}
event->SetInt( "kill_streak_wep", iWepKills );
// Track each player's max streak per-round
CTF_GameStats.Event_PlayerEarnedKillStreak( pScorer );
}
}
if ( pAssister )
{
event->SetInt( "duck_streak_assist", pAssister->m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Ducks ) );
// Only allow assists for Mediguns
CTFWeaponBase *pAssisterWpn = pAssister->GetActiveTFWeapon();
if ( pAssisterWpn && pAssister->IsPlayerClass( TF_CLASS_MEDIC ) )
{
CWeaponMedigun *pMedigun = dynamic_cast<CWeaponMedigun*>( pAssisterWpn );
if ( pMedigun )
{
iKillStreak = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pAssisterWpn, iKillStreak, killstreak_tier );
#ifdef STAGING_ONLY
if ( tf_killstreak_alwayson.GetBool() )
{
iKillStreak = 1;
}
#endif
if ( iKillStreak )
{
iKills = pAssister->m_Shared.IncrementStreak( CTFPlayerShared::kTFStreak_Kills, 1 );
event->SetInt( "kill_streak_assist", iKills );
int iWepKills = pAssisterWpn->GetKillStreak() + 1;
pAssisterWpn->SetKillStreak( iWepKills );
// Track each player's max streak per-round
CTF_GameStats.Event_PlayerEarnedKillStreak( pAssister );
}
}
}
}
}
}
event->SetInt( "death_flags", iDeathFlags );
event->SetInt( "stun_flags", pTFPlayerVictim->m_iOldStunFlags );
item_definition_index_t weaponDefIndex = INVALID_ITEM_DEF_INDEX;
if ( pScorerWeapon )
{
CEconItemView *pItem = pScorerWeapon->GetAttributeContainer()->GetItem();
if ( pItem )
{
weaponDefIndex = pItem->GetItemDefIndex();
}
}
else if ( pScorer && pScorer->GetActiveTFWeapon() )
{
// get from active weapon instead
CEconItemView *pItem = pScorer->GetActiveTFWeapon()->GetAttributeContainer()->GetItem();
if ( pItem )
{
weaponDefIndex = pItem->GetItemDefIndex();
}
}
event->SetInt( "weapon_def_index", weaponDefIndex );
pTFPlayerVictim->m_iOldStunFlags = 0;
gameeventmanager->FireEvent( event );
}
}
void CTFGameRules::ClientDisconnected( edict_t *pClient )
{
CTFPlayer *pPlayer = ToTFPlayer( GetContainingEntity( pClient ) );
if ( pPlayer )
{
// ACHIEVEMENT_TF_PYRO_DOMINATE_LEAVESVR - Pyro causes a dominated player to leave the server
for ( int i = 1; i <= gpGlobals->maxClients ; i++ )
{
if ( pPlayer->m_Shared.IsPlayerDominatingMe(i) )
{
CTFPlayer *pDominatingPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( pDominatingPlayer && pDominatingPlayer != pPlayer )
{
if ( pDominatingPlayer->IsPlayerClass(TF_CLASS_PYRO) )
{
pDominatingPlayer->AwardAchievement( ACHIEVEMENT_TF_PYRO_DOMINATE_LEAVESVR );
}
}
}
}
CTFPlayerResource *pTFResource = dynamic_cast< CTFPlayerResource* >( g_pPlayerResource );
if ( pTFResource )
{
if ( pPlayer->entindex() == pTFResource->GetPartyLeaderIndex( pPlayer->GetTeamNumber() ) )
{
// the leader is leaving so reset the player resource index
pTFResource->SetPartyLeaderIndex( pPlayer->GetTeamNumber(), 0 );
}
}
// Notify gamestats that the player left.
CTF_GameStats.Event_PlayerDisconnectedTF( pPlayer );
// Check Ready status for the player
if ( UsePlayerReadyStatusMode() )
{
if ( !pPlayer->IsBot() && State_Get() != GR_STATE_RND_RUNNING )
{
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
if ( !pMatchDesc || !pMatchDesc->m_params.m_bAutoReady )
{
// Always reset when a player leaves this type of match
PlayerReadyStatus_ResetState();
}
else if ( !IsTeamReady( pPlayer->GetTeamNumber() ) )
{
if ( IsPlayerReady( pPlayer->entindex() ) )
{
// Clear the ready status so it doesn't block the rest of the team
PlayerReadyStatus_UpdatePlayerState( pPlayer, false );
}
else
{
// Disconnecting player wasn't ready, but is the rest of the team?
// If so, we want to cancel the ready_state so it doesn't start right away when this player disconnects
bool bEveryoneReady = true;
CUtlVector<CTFPlayer *> playerVector;
CollectPlayers( &playerVector, pPlayer->GetTeamNumber() );
FOR_EACH_VEC( playerVector, i )
{
if ( !playerVector[i] )
continue;
if ( playerVector[i]->IsBot() )
continue;
if ( playerVector[i] == pPlayer )
continue;
if ( !IsPlayerReady( playerVector[i]->entindex() ) )
{
bEveryoneReady = false;
}
}
if ( bEveryoneReady )
{
PlayerReadyStatus_ResetState();
}
}
}
else
{
// If we're currently in a countdown we should cancel it
if ( ( m_flRestartRoundTime > 0 ) || ( mp_restartgame.GetInt() > 0 ) )
{
PlayerReadyStatus_ResetState();
}
}
}
}
// clean up anything they left behind
pPlayer->TeamFortress_ClientDisconnected();
Arena_ClientDisconnect( pPlayer->GetPlayerName() );
}
BaseClass::ClientDisconnected( pClient );
// are any of the spies disguising as this player?
for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
{
CTFPlayer *pTemp = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( pTemp && pTemp != pPlayer )
{
if ( pTemp->m_Shared.GetDisguiseTarget() == pPlayer )
{
// choose someone else...
pTemp->m_Shared.FindDisguiseTarget();
}
}
}
}
// Falling damage stuff.
#define TF_PLAYER_MAX_SAFE_FALL_SPEED 650
float CTFGameRules::FlPlayerFallDamage( CBasePlayer *pPlayer )
{
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
if ( !pTFPlayer )
return 0;
// Karts don't take fall damage
if ( pTFPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
{
return 0;
}
// grappling hook don't take fall damage
if ( pTFPlayer->GetGrapplingHookTarget() )
{
return 0;
}
if ( pTFPlayer->m_Shared.GetCarryingRuneType() == RUNE_AGILITY )
{
return 0;
}
if ( pPlayer->m_Local.m_flFallVelocity > TF_PLAYER_MAX_SAFE_FALL_SPEED )
{
// Old TFC damage formula
float flFallDamage = 5 * (pPlayer->m_Local.m_flFallVelocity / 300);
// Fall damage needs to scale according to the player's max health, or
// it's always going to be much more dangerous to weaker classes than larger.
float flRatio = (float)pPlayer->GetMaxHealth() / 100.0;
flFallDamage *= flRatio;
flFallDamage *= random->RandomFloat( 0.8, 1.2 );
int iCancelFallingDamage = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer, iCancelFallingDamage, cancel_falling_damage );
if ( iCancelFallingDamage > 0 )
flFallDamage = 0;
return flFallDamage;
}
// Fall caused no damage
return 0;
}
void CTFGameRules::SendArenaWinPanelInfo( void )
{
IGameEvent *winEvent = gameeventmanager->CreateEvent( "arena_win_panel" );
if ( winEvent )
{
int iBlueScore = GetGlobalTeam( TF_TEAM_BLUE )->GetScore();
int iRedScore = GetGlobalTeam( TF_TEAM_RED )->GetScore();
int iBlueScorePrev = iBlueScore;
int iRedScorePrev = iRedScore;
// if this is a complete round, calc team scores prior to this win
switch ( m_iWinningTeam )
{
case TF_TEAM_BLUE:
{
iBlueScorePrev = ( iBlueScore - TEAMPLAY_ROUND_WIN_SCORE >= 0 ) ? ( iBlueScore - TEAMPLAY_ROUND_WIN_SCORE ) : 0;
if ( IsInTournamentMode() == false )
{
iRedScore = 0;
}
}
break;
case TF_TEAM_RED:
{
iRedScorePrev = ( iRedScore - TEAMPLAY_ROUND_WIN_SCORE >= 0 ) ? ( iRedScore - TEAMPLAY_ROUND_WIN_SCORE ) : 0;
if ( IsInTournamentMode() == false )
{
iBlueScore = 0;
}
break;
}
case TEAM_UNASSIGNED:
break; // stalemate; nothing to do
}
winEvent->SetInt( "panel_style", WINPANEL_BASIC );
winEvent->SetInt( "winning_team", m_iWinningTeam );
winEvent->SetInt( "winreason", m_iWinReason );
winEvent->SetString( "cappers", ( m_iWinReason == WINREASON_ALL_POINTS_CAPTURED || m_iWinReason == WINREASON_FLAG_CAPTURE_LIMIT ) ? m_szMostRecentCappers : "" );
winEvent->SetInt( "blue_score", iBlueScore );
winEvent->SetInt( "red_score", iRedScore );
winEvent->SetInt( "blue_score_prev", iBlueScorePrev );
winEvent->SetInt( "red_score_prev", iRedScorePrev );
CTFPlayerResource *pResource = dynamic_cast< CTFPlayerResource * >( g_pPlayerResource );
if ( !pResource )
return;
// build a vector of players & round scores
CUtlVector<PlayerArenaRoundScore_t> vecPlayerScore;
int iPlayerIndex;
for( iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ )
{
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
if ( !pTFPlayer || !pTFPlayer->IsConnected() )
continue;
// filter out spectators and, if not stalemate, all players not on winning team
int iPlayerTeam = pTFPlayer->GetTeamNumber();
if ( ( iPlayerTeam < FIRST_GAME_TEAM ) )
continue;
PlayerStats_t *pStats = CTF_GameStats.FindPlayerStats( pTFPlayer );
PlayerArenaRoundScore_t &playerRoundScore = vecPlayerScore[vecPlayerScore.AddToTail()];
playerRoundScore.iPlayerIndex = iPlayerIndex;
if ( pStats )
{
playerRoundScore.iTotalDamage = pStats->statsCurrentRound.m_iStat[TFSTAT_DAMAGE];
playerRoundScore.iTotalHealing = pStats->statsCurrentRound.m_iStat[TFSTAT_HEALING];
if ( pTFPlayer->IsAlive() == true )
{
playerRoundScore.iTimeAlive = (int)gpGlobals->curtime - pTFPlayer->GetSpawnTime();
}
else
{
playerRoundScore.iTimeAlive = (int)pTFPlayer->GetDeathTime() - pTFPlayer->GetSpawnTime();
}
playerRoundScore.iKillingBlows = pStats->statsCurrentRound.m_iStat[TFSTAT_KILLS];
playerRoundScore.iScore = CalcPlayerScore( &pStats->statsCurrentRound, pTFPlayer );
}
}
// sort the players by round score
vecPlayerScore.Sort( PlayerArenaRoundScoreSortFunc );
// set the top (up to) 6 players by round score in the event data
int numPlayers = 6;
int iPlayersAdded = 0;
// Add winners first
for ( int i = 0; i < vecPlayerScore.Count(); i++ )
{
if ( GetWinningTeam() == TEAM_UNASSIGNED )
{
if ( iPlayersAdded >= 6 )
break;
}
else
{
if ( iPlayersAdded >= 3 )
break;
}
int iPlayerIndex = vecPlayerScore[i].iPlayerIndex;
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
if ( pTFPlayer && pTFPlayer->GetTeamNumber() != GetWinningTeam() && GetWinningTeam() != TEAM_UNASSIGNED )
continue;
winEvent->SetInt( UTIL_VarArgs( "player_%d", iPlayersAdded + 1 ), vecPlayerScore[i].iPlayerIndex );
winEvent->SetInt( UTIL_VarArgs( "player_%d_damage", iPlayersAdded + 1 ), vecPlayerScore[i].iTotalDamage );
winEvent->SetInt( UTIL_VarArgs( "player_%d_healing", iPlayersAdded + 1 ), vecPlayerScore[i].iTotalHealing );
winEvent->SetInt( UTIL_VarArgs( "player_%d_lifetime", iPlayersAdded + 1 ), vecPlayerScore[i].iTimeAlive );
winEvent->SetInt( UTIL_VarArgs( "player_%d_kills", iPlayersAdded + 1 ), vecPlayerScore[i].iKillingBlows );
iPlayersAdded++;
}
if ( GetWinningTeam() != TEAM_UNASSIGNED )
{
//Now add the rest
iPlayersAdded = 3;
for ( int i = 0; i < vecPlayerScore.Count(); i++ )
{
if ( iPlayersAdded >= numPlayers )
break;
int iIndex = iPlayersAdded + 1;
int iPlayerIndex = vecPlayerScore[i].iPlayerIndex;
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
if ( pTFPlayer && pTFPlayer->GetTeamNumber() == GetWinningTeam() )
continue;
winEvent->SetInt( UTIL_VarArgs( "player_%d", iIndex ), vecPlayerScore[i].iPlayerIndex );
winEvent->SetInt( UTIL_VarArgs( "player_%d_damage", iIndex ), vecPlayerScore[i].iTotalDamage );
winEvent->SetInt( UTIL_VarArgs( "player_%d_healing", iIndex ), vecPlayerScore[i].iTotalHealing );
winEvent->SetInt( UTIL_VarArgs( "player_%d_lifetime", iIndex ), vecPlayerScore[i].iTimeAlive );
winEvent->SetInt( UTIL_VarArgs( "player_%d_kills", iIndex ), vecPlayerScore[i].iKillingBlows );
iPlayersAdded++;
}
}
// Send the event
gameeventmanager->FireEvent( winEvent );
}
}
void CTFGameRules::SendPVEWinPanelInfo( void )
{
IGameEvent *winEvent = gameeventmanager->CreateEvent( "pve_win_panel" );
if ( winEvent )
{
winEvent->SetInt( "panel_style", WINPANEL_BASIC );
winEvent->SetInt( "winning_team", m_iWinningTeam );
winEvent->SetInt( "winreason", 0 );
// Send the event
gameeventmanager->FireEvent( winEvent );
}
/*CBroadcastRecipientFilter filter;
filter.MakeReliable();
UserMessageBegin( filter, "MVMAnnouncement" );
WRITE_CHAR( TF_MVM_ANNOUNCEMENT_WAVE_FAILED );
WRITE_CHAR( -1 );
MessageEnd();*/
}
void CTFGameRules::SendWinPanelInfo( bool bGameOver )
{
if ( IsInArenaMode() == true )
{
SendArenaWinPanelInfo();
return;
}
if ( IsPVEModeActive() )
{
SendPVEWinPanelInfo();
return;
}
IGameEvent *winEvent = gameeventmanager->CreateEvent( "teamplay_win_panel" );
if ( winEvent )
{
int iBlueScore = GetGlobalTeam( TF_TEAM_BLUE )->GetScore();
int iRedScore = GetGlobalTeam( TF_TEAM_RED )->GetScore();
int iBlueScorePrev = iBlueScore;
int iRedScorePrev = iRedScore;
bool bRoundComplete = m_bForceMapReset || ( IsGameUnderTimeLimit() && ( GetTimeLeft() <= 0 ) );
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
bool bScoringPerCapture = ( pMaster ) ? ( pMaster->ShouldScorePerCapture() ) : false;
if ( m_nGameType == TF_GAMETYPE_CTF )
{
if ( tf_flag_caps_per_round.GetInt() == 0 )
{
bScoringPerCapture = true;
}
}
if ( bRoundComplete && !bScoringPerCapture && m_bUseAddScoreAnim )
{
// if this is a complete round, calc team scores prior to this win
switch ( m_iWinningTeam )
{
case TF_TEAM_BLUE:
iBlueScorePrev = ( iBlueScore - TEAMPLAY_ROUND_WIN_SCORE >= 0 ) ? ( iBlueScore - TEAMPLAY_ROUND_WIN_SCORE ) : 0;
break;
case TF_TEAM_RED:
iRedScorePrev = ( iRedScore - TEAMPLAY_ROUND_WIN_SCORE >= 0 ) ? ( iRedScore - TEAMPLAY_ROUND_WIN_SCORE ) : 0;
break;
case TEAM_UNASSIGNED:
break; // stalemate; nothing to do
}
}
winEvent->SetInt( "panel_style", WINPANEL_BASIC );
winEvent->SetInt( "winning_team", m_iWinningTeam );
winEvent->SetInt( "winreason", m_iWinReason );
winEvent->SetString( "cappers", ( m_iWinReason == WINREASON_ALL_POINTS_CAPTURED || m_iWinReason == WINREASON_FLAG_CAPTURE_LIMIT ) ?
m_szMostRecentCappers : "" );
winEvent->SetInt( "flagcaplimit", IsPasstimeMode() ? tf_passtime_scores_per_round.GetInt() : tf_flag_caps_per_round.GetInt() );
winEvent->SetInt( "blue_score", iBlueScore );
winEvent->SetInt( "red_score", iRedScore );
winEvent->SetInt( "blue_score_prev", iBlueScorePrev );
winEvent->SetInt( "red_score_prev", iRedScorePrev );
winEvent->SetInt( "round_complete", bRoundComplete );
CTFPlayerResource *pResource = dynamic_cast< CTFPlayerResource * >( g_pPlayerResource );
if ( !pResource )
return;
// Highest killstreak
int nMaxStreakPlayerIndex = 0;
int nMaxStreakCount = 0;
// determine the 3 players on winning team who scored the most points this round
// build a vector of players & round scores
CUtlVector<PlayerRoundScore_t> vecPlayerScore;
int iPlayerIndex;
for( iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ )
{
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
if ( !pTFPlayer || !pTFPlayer->IsConnected() )
continue;
// filter out spectators and, if not stalemate, all players not on winning team
int iPlayerTeam = pTFPlayer->GetTeamNumber();
if ( ( iPlayerTeam < FIRST_GAME_TEAM ) || ( m_iWinningTeam != TEAM_UNASSIGNED && ( m_iWinningTeam != iPlayerTeam ) ) )
continue;
int iRoundScore = 0, iTotalScore = 0;
PlayerStats_t *pStats = CTF_GameStats.FindPlayerStats( pTFPlayer );
if ( pStats )
{
iRoundScore = CalcPlayerScore( &pStats->statsCurrentRound, pTFPlayer );
iTotalScore = CalcPlayerScore( &pStats->statsAccumulated, pTFPlayer );
}
PlayerRoundScore_t &playerRoundScore = vecPlayerScore[vecPlayerScore.AddToTail()];
playerRoundScore.iRoundScore = iRoundScore;
playerRoundScore.iPlayerIndex = iPlayerIndex;
playerRoundScore.iTotalScore = iTotalScore;
// Highest killstreak?
PlayerStats_t *pPlayerStats = CTF_GameStats.FindPlayerStats( pTFPlayer );
if ( pPlayerStats )
{
int nMax = pPlayerStats->statsCurrentRound.m_iStat[TFSTAT_KILLSTREAK_MAX];
if ( nMax > nMaxStreakCount )
{
nMaxStreakCount = nMax;
nMaxStreakPlayerIndex = iPlayerIndex;
}
}
}
// sort the players by round score
vecPlayerScore.Sort( PlayerRoundScoreSortFunc );
// set the top (up to) 6 players by round score in the event data
int numPlayers = MIN( 6, vecPlayerScore.Count() );
for ( int i = 0; i < numPlayers; i++ )
{
// only include players who have non-zero points this round; if we get to a player with 0 round points, stop
if ( 0 == vecPlayerScore[i].iRoundScore )
break;
// set the player index and their round score in the event
char szPlayerIndexVal[64]="", szPlayerScoreVal[64]="";
Q_snprintf( szPlayerIndexVal, ARRAYSIZE( szPlayerIndexVal ), "player_%d", i+ 1 );
Q_snprintf( szPlayerScoreVal, ARRAYSIZE( szPlayerScoreVal ), "player_%d_points", i+ 1 );
winEvent->SetInt( szPlayerIndexVal, vecPlayerScore[i].iPlayerIndex );
winEvent->SetInt( szPlayerScoreVal, vecPlayerScore[i].iRoundScore );
}
winEvent->SetInt( "killstreak_player_1", nMaxStreakPlayerIndex );
winEvent->SetInt( "killstreak_player_1_count", nMaxStreakCount );
#ifdef TF_RAID_MODE
if ( !bRoundComplete && ( TEAM_UNASSIGNED != m_iWinningTeam ) && !IsRaidMode() )
#else
if ( !bRoundComplete && ( TEAM_UNASSIGNED != m_iWinningTeam ) )
#endif // TF_RAID_MODE
{
// is this our new payload race game mode?
if ( ( m_nGameType == TF_GAMETYPE_ESCORT ) && ( m_bMultipleTrains == true ) )
{
if ( g_hControlPointMasters.Count() && g_hControlPointMasters[0] && g_hControlPointMasters[0]->PlayingMiniRounds() )
{
int nRoundsRemaining = g_hControlPointMasters[0]->NumPlayableControlPointRounds();
if ( nRoundsRemaining > 0 )
{
winEvent->SetInt( "rounds_remaining", nRoundsRemaining );
}
}
}
else
{
// if this was not a full round ending, include how many mini-rounds remain for winning team to win
if ( g_hControlPointMasters.Count() && g_hControlPointMasters[0] )
{
winEvent->SetInt( "rounds_remaining", g_hControlPointMasters[0]->CalcNumRoundsRemaining( m_iWinningTeam ) );
}
}
}
winEvent->SetBool( "game_over", bGameOver );
// Send the event
gameeventmanager->FireEvent( winEvent );
}
}
//-----------------------------------------------------------------------------
// Purpose: Sorts players by round score
//-----------------------------------------------------------------------------
int CTFGameRules::PlayerRoundScoreSortFunc( const PlayerRoundScore_t *pRoundScore1, const PlayerRoundScore_t *pRoundScore2 )
{
// sort first by round score
if ( pRoundScore1->iRoundScore != pRoundScore2->iRoundScore )
return pRoundScore2->iRoundScore - pRoundScore1->iRoundScore;
// if round scores are the same, sort next by total score
if ( pRoundScore1->iTotalScore != pRoundScore2->iTotalScore )
return pRoundScore2->iTotalScore - pRoundScore1->iTotalScore;
// if scores are the same, sort next by player index so we get deterministic sorting
return ( pRoundScore2->iPlayerIndex - pRoundScore1->iPlayerIndex );
}
//-----------------------------------------------------------------------------
// Purpose: Sorts players by arena stats
//-----------------------------------------------------------------------------
int CTFGameRules::PlayerArenaRoundScoreSortFunc( const PlayerArenaRoundScore_t *pRoundScore1, const PlayerArenaRoundScore_t *pRoundScore2 )
{
//Compare Total points first
//This gives us a rough estimate of performance
if ( pRoundScore1->iScore != pRoundScore2->iScore )
return pRoundScore2->iScore - pRoundScore1->iScore;
//Compare healing
if ( pRoundScore1->iTotalHealing != pRoundScore2->iTotalHealing )
return pRoundScore2->iTotalHealing - pRoundScore1->iTotalHealing;
//Compare damage
if ( pRoundScore1->iTotalDamage != pRoundScore2->iTotalDamage )
return pRoundScore2->iTotalDamage - pRoundScore1->iTotalDamage;
//Compare time alive
if ( pRoundScore1->iTimeAlive != pRoundScore2->iTimeAlive )
return pRoundScore2->iTimeAlive - pRoundScore1->iTimeAlive;
//Compare killing blows
if ( pRoundScore1->iKillingBlows != pRoundScore2->iKillingBlows )
return pRoundScore2->iKillingBlows - pRoundScore1->iKillingBlows;
// if scores are the same, sort next by player index so we get deterministic sorting
return ( pRoundScore2->iPlayerIndex - pRoundScore1->iPlayerIndex );
}
//-----------------------------------------------------------------------------
// Purpose: Called when the teamplay_round_win event is about to be sent, gives
// this method a chance to add more data to it
//-----------------------------------------------------------------------------
void CTFGameRules::FillOutTeamplayRoundWinEvent( IGameEvent *event )
{
event->SetInt( "flagcaplimit", IsPasstimeMode() ? tf_passtime_scores_per_round.GetInt() : tf_flag_caps_per_round.GetInt() );
// determine the losing team
int iLosingTeam;
switch( event->GetInt( "team" ) )
{
case TF_TEAM_RED:
iLosingTeam = TF_TEAM_BLUE;
break;
case TF_TEAM_BLUE:
iLosingTeam = TF_TEAM_RED;
break;
case TEAM_UNASSIGNED:
default:
iLosingTeam = TEAM_UNASSIGNED;
break;
}
// set the number of caps that team got any time during the round
event->SetInt( "losing_team_num_caps", m_iNumCaps[iLosingTeam] );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::SetupSpawnPointsForRound( void )
{
if ( !g_hControlPointMasters.Count() || !g_hControlPointMasters[0] || !g_hControlPointMasters[0]->PlayingMiniRounds() )
return;
CTeamControlPointRound *pCurrentRound = g_hControlPointMasters[0]->GetCurrentRound();
if ( !pCurrentRound )
{
return;
}
// loop through the spawn points in the map and find which ones are associated with this round or the control points in this round
for ( int i=0; i<ITFTeamSpawnAutoList::AutoList().Count(); ++i )
{
CTFTeamSpawn *pTFSpawn = static_cast< CTFTeamSpawn* >( ITFTeamSpawnAutoList::AutoList()[i] );
CHandle<CTeamControlPoint> hControlPoint = pTFSpawn->GetControlPoint();
CHandle<CTeamControlPointRound> hRoundBlue = pTFSpawn->GetRoundBlueSpawn();
CHandle<CTeamControlPointRound> hRoundRed = pTFSpawn->GetRoundRedSpawn();
if ( hControlPoint && pCurrentRound->IsControlPointInRound( hControlPoint ) )
{
// this spawn is associated with one of our control points
pTFSpawn->SetDisabled( false );
pTFSpawn->ChangeTeam( hControlPoint->GetOwner() );
}
else if ( hRoundBlue && ( hRoundBlue == pCurrentRound ) )
{
pTFSpawn->SetDisabled( false );
pTFSpawn->ChangeTeam( TF_TEAM_BLUE );
}
else if ( hRoundRed && ( hRoundRed == pCurrentRound ) )
{
pTFSpawn->SetDisabled( false );
pTFSpawn->ChangeTeam( TF_TEAM_RED );
}
else
{
// this spawn isn't associated with this round or the control points in this round
pTFSpawn->SetDisabled( true );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFGameRules::SetCurrentRoundStateBitString( void )
{
m_iPrevRoundState = m_iCurrentRoundState;
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
if ( !pMaster )
{
return 0;
}
int iState = 0;
for ( int i=0; i<pMaster->GetNumPoints(); i++ )
{
CTeamControlPoint *pPoint = pMaster->GetControlPoint( i );
if ( pPoint->GetOwner() == TF_TEAM_BLUE )
{
// Set index to 1 for the point being owned by blue
iState |= ( 1<<i );
}
}
m_iCurrentRoundState = iState;
return iState;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::SetMiniRoundBitMask( int iMask )
{
m_iCurrentMiniRoundMask = iMask;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::IsFirstBloodAllowed( void )
{
// Already granted
if ( m_bArenaFirstBlood )
return false;
if ( IsInArenaMode() && tf_arena_first_blood.GetBool() )
return true;
if ( IsCompetitiveMode() && ( State_Get() == GR_STATE_RND_RUNNING ) )
{
if ( IsMatchTypeCompetitive() )
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: NULL pPlayer means show the panel to everyone
//-----------------------------------------------------------------------------
void CTFGameRules::ShowRoundInfoPanel( CTFPlayer *pPlayer /* = NULL */ )
{
KeyValues *data = new KeyValues( "data" );
if ( m_iCurrentRoundState < 0 )
{
// Haven't set up the round state yet
return;
}
// if prev and cur are equal, we are starting from a fresh round
if ( m_iPrevRoundState >= 0 && pPlayer == NULL ) // we have data about a previous state
{
data->SetInt( "prev", m_iPrevRoundState );
}
else
{
// don't send a delta if this is just to one player, they are joining mid-round
data->SetInt( "prev", m_iCurrentRoundState );
}
data->SetInt( "cur", m_iCurrentRoundState );
// get bitmask representing the current miniround
data->SetInt( "round", m_iCurrentMiniRoundMask );
if ( pPlayer )
{
pPlayer->ShowViewPortPanel( PANEL_ROUNDINFO, true, data );
}
else
{
for ( int i = 1; i <= MAX_PLAYERS; i++ )
{
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( pTFPlayer && pTFPlayer->IsReadyToPlay() )
{
pTFPlayer->ShowViewPortPanel( PANEL_ROUNDINFO, true, data );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::TimerMayExpire( void )
{
// Prevent timers expiring while control points are contested
int iNumControlPoints = ObjectiveResource()->GetNumControlPoints();
for ( int iPoint = 0; iPoint < iNumControlPoints; iPoint ++ )
{
if ( ObjectiveResource()->GetCappingTeam(iPoint) )
{
m_flCapInProgressBuffer = gpGlobals->curtime + 0.1f;
return false;
}
}
// This delay prevents an order-of-operations issue with caps that
// fire an AddTime output, and round timers' OnFinished output
if ( m_flCapInProgressBuffer >= gpGlobals->curtime )
return false;
if ( GetOvertimeAllowedForCTF() )
{
// Prevent timers expiring while flags are stolen/dropped
for ( int i=0; i<ICaptureFlagAutoList::AutoList().Count(); ++i )
{
CCaptureFlag *pFlag = static_cast< CCaptureFlag* >( ICaptureFlagAutoList::AutoList()[i] );
if ( !pFlag->IsDisabled() && !pFlag->IsHome() )
return false;
}
}
for ( int i = 0 ; i < m_CPTimerEnts.Count() ; i++ )
{
CCPTimerLogic *pTimer = m_CPTimerEnts[i];
if ( pTimer )
{
if ( pTimer->TimerMayExpire() == false )
return false;
}
}
#ifdef TF_RAID_MODE
if ( IsRaidMode() && IsBossBattleMode() && tf_raid_allow_overtime.GetBool() )
{
CUtlVector< CTFPlayer * > alivePlayerVector;
CollectPlayers( &alivePlayerVector, TF_TEAM_BLUE, COLLECT_ONLY_LIVING_PLAYERS );
// if anyone is alive, go into overtime
if ( alivePlayerVector.Count() > 0 )
{
return false;
}
}
#endif
return BaseClass::TimerMayExpire();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::BHavePlayers( void )
{
CMatchInfo *pInfo = GTFGCClientSystem()->GetMatch();
if ( pInfo )
{
// When we have a match, we start reporting we're active as soon as the first person loads, and never stop.
return pInfo->m_bFirstPersonActive;
}
if ( IsInArenaMode() )
{
// At least two in queue, we're always able to play
if ( m_hArenaPlayerQueue.Count() >= 2 )
return true;
// Otherwise, return false if nobody is actually on a team, regardless of players ready-to-play state.
if ( GetGlobalTFTeam( TF_TEAM_BLUE )->GetNumPlayers() == 0 || GetGlobalTFTeam( TF_TEAM_RED )->GetNumPlayers() == 0 )
return false;
// Otherwise, fall through to base logic (e.g. 1v0 but already running)
}
return BaseClass::BHavePlayers();
}
int SortPlayerSpectatorQueue( CTFPlayer* const *p1, CTFPlayer* const *p2 )
{
float flTime1 = (*p1)->GetTeamJoinTime();
float flTime2 = (*p2)->GetTeamJoinTime();
if ( flTime1 == flTime2 )
{
flTime1 = (*p1)->GetConnectionTime();
flTime2 = (*p2)->GetConnectionTime();
if ( flTime1 < flTime2 )
return -1;
}
else
{
if ( flTime1 > flTime2 )
return -1;
}
if ( flTime1 == flTime2 )
return 0;
return 1;
}
int SortPlayersScoreBased( CTFPlayer* const *p1, CTFPlayer* const *p2 )
{
CTFPlayerResource *pResource = dynamic_cast<CTFPlayerResource *>( g_pPlayerResource );
if ( pResource )
{
int nScore2 = pResource->GetTotalScore( ( *p2 )->entindex() );
int nScore1 = pResource->GetTotalScore( ( *p1 )->entindex() );
// check the priority
if ( nScore2 > nScore1 )
{
return 1;
}
}
return -1;
}
// sort function for the list of players that we're going to use to scramble the teams
int ScramblePlayersSort( CTFPlayer* const *p1, CTFPlayer* const *p2 )
{
CTFPlayerResource *pResource = dynamic_cast< CTFPlayerResource * >( g_pPlayerResource );
if ( pResource )
{
int nScore2 = pResource->GetTotalScore( (*p2)->entindex() );
int nScore1 = pResource->GetTotalScore( (*p1)->entindex() );
// check the priority
if ( nScore2 > nScore1 )
{
return 1;
}
}
return -1;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::Arena_ClientDisconnect( const char *playername )
{
if ( IsInArenaMode() == false )
return;
if ( IsInWaitingForPlayers() == true )
return;
if ( m_iRoundState != GR_STATE_PREROUND )
return;
if ( IsInTournamentMode() == true )
return;
int iLight, iHeavy;
if ( AreTeamsUnbalanced( iHeavy, iLight ) == true )
{
CTeam *pTeamHeavy = GetGlobalTeam( iHeavy );
CTeam *pTeamLight = GetGlobalTeam( iLight );
if ( pTeamHeavy == NULL || pTeamLight == NULL )
return;
int iPlayersNeeded = pTeamHeavy->GetNumPlayers() - pTeamLight->GetNumPlayers();
if ( m_hArenaPlayerQueue.Count() == 0 )
return;
for ( int iPlayers = 0; iPlayers < iPlayersNeeded; iPlayers++ )
{
CTFPlayer *pPlayer = m_hArenaPlayerQueue[iPlayers];
if ( pPlayer && pPlayer->IsHLTV() == false && pPlayer->IsReplay() == false )
{
pPlayer->ForceChangeTeam( TF_TEAM_AUTOASSIGN );
UTIL_ClientPrintAll( HUD_PRINTTALK, "#TF_Arena_ClientDisconnect", pPlayer->GetPlayerName(), GetGlobalTeam( pPlayer->GetTeamNumber() )->GetName(), playername );
if ( pPlayer->DidPlayerJustPlay() == false )
{
pPlayer->MarkTeamJoinTime();
}
m_hArenaPlayerQueue.FindAndRemove( pPlayer );
pPlayer->PlayerJustPlayed( false );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::Arena_ResetLosersScore( bool bResetAll )
{
//Winner gets to keep their score
for ( int i = 0; i < GetNumberOfTeams(); i++ )
{
if ( ( i != GetWinningTeam() && GetWinningTeam() > LAST_SHARED_TEAM ) || bResetAll == true )
{
GetGlobalTeam( i )->ResetScores();
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::Arena_PrepareNewPlayerQueue( bool bResetAll )
{
CUtlVector<CTFPlayer*> pTempPlayerQueue;
for ( int i = 1; i <= MAX_PLAYERS; i++ )
{
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( pPlayer && pPlayer->IsHLTV() == false && pPlayer->IsReplay() == false )
{
if ( ( GetWinningTeam() > LAST_SHARED_TEAM && pPlayer->GetTeamNumber() != GetWinningTeam() && pPlayer->IsReadyToPlay() ) || bResetAll == true )
{
pTempPlayerQueue.AddToTail( pPlayer );
}
}
}
//Sort the players going into spectator
//Players that have been longer on the server should go in front of newer players
//We have to do this since player slots are reused for new clients, so looping through players
//using their entindex doesn't work.
if ( bResetAll == true )
{
pTempPlayerQueue.Sort( ScramblePlayersSort );
}
else
{
pTempPlayerQueue.Sort( SortPlayerSpectatorQueue );
}
for ( int i = 0; i < pTempPlayerQueue.Count(); i++ )
{
CTFPlayer *pPlayer = pTempPlayerQueue[i];
if ( pPlayer && pPlayer->IsReadyToPlay() )
{
//Changing into Spectator Team puts the player at the end of the queue
//Use ForceChangeTeam if you want to move them to the FRONT of the queue
pPlayer->ChangeTeam( TEAM_SPECTATOR );
pPlayer->PlayerJustPlayed( true );
}
}
}
#define TF_ARENA_TEAM_COUNT 3
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFGameRules::Arena_PlayersNeededForMatch( void )
{
int iMaxPlayers = gpGlobals->maxClients;
if ( HLTVDirector()->IsActive() )
{
iMaxPlayers -= 1;
}
int iTeamSize;
if ( tf_arena_override_team_size.GetInt() > 0 )
iTeamSize = tf_arena_override_team_size.GetInt();
else
iTeamSize = floor( ( (float)iMaxPlayers / TF_ARENA_TEAM_COUNT ) + 0.5f );
int iPlayersNeeded = iTeamSize * 2;
int iDesiredTeamSize = iTeamSize;
int iPlayersInWinningTeam = 0;
bool bRebalanceWinners = false;
int iPlayerNumber = 0;
for ( int i = 1; i <= MAX_PLAYERS; i++ )
{
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( pPlayer && pPlayer->IsReadyToPlay() )
{
iPlayerNumber++;
}
}
int iBalancedTeamSize = floor( ((m_hArenaPlayerQueue.Count() + iPlayerNumber ) * 0.5f ) );
iPlayersNeeded = (iBalancedTeamSize - iPlayerNumber) + iBalancedTeamSize;
if ( (iPlayersNeeded + iPlayerNumber) > iDesiredTeamSize*2 )
{
iPlayersNeeded = (iDesiredTeamSize*2) - iPlayerNumber;
if ( iPlayersNeeded < 0 )
{
iPlayersNeeded = 0;
}
}
// If the last round was won by a team, then let's figure out how many players we need.
// Also, if the winning team has more players than are available, then let's have one of them switch teams.
if ( GetWinningTeam() > LAST_SHARED_TEAM )
{
iPlayersInWinningTeam = GetGlobalTFTeam( GetWinningTeam() )->GetNumPlayers();
if ( iPlayersInWinningTeam > iTeamSize )
{
bRebalanceWinners = true;
iDesiredTeamSize = iTeamSize;
}
else if ( iPlayersInWinningTeam > iBalancedTeamSize )
{
bRebalanceWinners = true;
iDesiredTeamSize = iBalancedTeamSize;
}
}
// Msg( "iPlayerNumber: %d - InQueue: %d - iPlayersInWinningTeam: %d - iDesiredTeamSize: %d - iBalancedTeamSize: %d - iPlayersNeeded: %d - bRebalanceWinners %d\n", iPlayerNumber, m_hArenaPlayerQueue.Count(), iPlayersInWinningTeam, iDesiredTeamSize, iBalancedTeamSize, iPlayersNeeded, bRebalanceWinners );
if ( bRebalanceWinners == true )
{
while ( iPlayersInWinningTeam > iDesiredTeamSize )
{
CTFPlayer *pBalancedWinner = NULL;
float flShortestTeamJoinTime = 9999.9f;
for ( int i = 1; i <= MAX_PLAYERS; i++ )
{
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( pPlayer && pPlayer->GetTeamNumber() == GetWinningTeam() && pPlayer->IsHLTV() == false && pPlayer->IsReplay() == false )
{
if ( bRebalanceWinners == true )
{
//Find the newest guy that joined this team and flag him.
if ( (gpGlobals->curtime - pPlayer->GetTeamJoinTime()) < flShortestTeamJoinTime )
{
flShortestTeamJoinTime = (gpGlobals->curtime - pPlayer->GetTeamJoinTime());
pBalancedWinner = pPlayer;
}
}
}
}
if ( pBalancedWinner )
{
pBalancedWinner->ForceChangeTeam( TEAM_SPECTATOR );
pBalancedWinner->MarkTeamJoinTime();
if ( iPlayersNeeded < iDesiredTeamSize )
{
iPlayersNeeded++;
}
IGameEvent *event = gameeventmanager->CreateEvent( "teamplay_teambalanced_player" );
if ( event )
{
event->SetInt( "player", pBalancedWinner->entindex() );
event->SetInt( "team", GetWinningTeam() == TF_TEAM_BLUE ? TF_TEAM_RED : TF_TEAM_BLUE );
gameeventmanager->FireEvent( event );
}
// tell people that we've switched this player
UTIL_ClientPrintAll( HUD_PRINTTALK, "#game_player_was_team_balanced", pBalancedWinner->GetPlayerName() );
}
iPlayersInWinningTeam = GetGlobalTFTeam( GetWinningTeam() )->GetNumPlayers();
}
}
return iPlayersNeeded;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::Arena_CleanupPlayerQueue( void )
{
//One more loop to remove players that are currently playing from the queue
//And to mark everyone as not having just played.
for ( int i = 1; i <= MAX_PLAYERS; i++ )
{
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( pPlayer && pPlayer->IsHLTV() == false && pPlayer->IsReplay() == false )
{
if ( pPlayer->GetTeamNumber() != TEAM_SPECTATOR )
{
m_hArenaPlayerQueue.FindAndRemove( pPlayer );
}
pPlayer->PlayerJustPlayed( false );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::Arena_RunTeamLogic( void )
{
if ( IsInArenaMode() == false )
return;
if ( IsInWaitingForPlayers() == true )
return;
bool bGameNotReady = !BHavePlayers();
bool bStreaksReached = false;
if ( tf_arena_use_queue.GetBool() == false )
{
if ( bGameNotReady == true || GetGlobalTFTeam( TF_TEAM_BLUE )->GetNumPlayers() == 0 || GetGlobalTFTeam( TF_TEAM_RED )->GetNumPlayers() == 0 )
{
State_Transition( GR_STATE_PREGAME );
}
return;
}
if ( tf_arena_max_streak.GetInt() > 0 )
{
if ( GetWinningTeam() != TEAM_UNASSIGNED )
{
if ( GetGlobalTFTeam( GetWinningTeam() )->GetScore() >= tf_arena_max_streak.GetInt() )
{
bStreaksReached = true;
IGameEvent *event = gameeventmanager->CreateEvent( "arena_match_maxstreak" );
if ( event )
{
event->SetInt( "team", GetWinningTeam() );
event->SetInt( "streak", tf_arena_max_streak.GetInt() );
gameeventmanager->FireEvent( event );
}
BroadcastSound( 255, "Announcer.AM_TeamScrambleRandom" );
m_iWinningTeam = TEAM_UNASSIGNED;
}
}
}
if ( IsInTournamentMode() == false )
{
Arena_ResetLosersScore( bGameNotReady || bStreaksReached );
}
Arena_PrepareNewPlayerQueue( bGameNotReady || bStreaksReached );
if ( bGameNotReady == true )
{
State_Transition( GR_STATE_PREGAME );
return;
}
int iPlayersNeeded = Arena_PlayersNeededForMatch();
//Let's add people to teams
//But only do this if there's people in the actual game and teams are unbalanced
//(which they should be since winners are in and everyone else is spectating)
int iLight, iHeavy;
if ( AreTeamsUnbalanced( iHeavy, iLight ) == true && iPlayersNeeded > 0 )
{
if ( iPlayersNeeded > m_hArenaPlayerQueue.Count() )
{
iPlayersNeeded = m_hArenaPlayerQueue.Count();
}
// Msg( "iTeamSize: %d\n", iTeamSize );
int iTeam = GetWinningTeam();
int iSwitch = floor( ((GetGlobalTFTeam( GetWinningTeam() )->GetNumPlayers() + iPlayersNeeded) * 0.5f ) - GetGlobalTFTeam( GetWinningTeam() )->GetNumPlayers() );
if ( GetWinningTeam() == TEAM_UNASSIGNED )
{
iTeam = TF_TEAM_AUTOASSIGN;
}
//Move people in the queue into a team.
for ( int iPlayers = 0; iPlayers < iPlayersNeeded; iPlayers++ )
{
CTFPlayer *pPlayer = m_hArenaPlayerQueue[iPlayers];
if ( iPlayers >= iSwitch )
{
iTeam = TF_TEAM_AUTOASSIGN;
}
if ( pPlayer )
{
pPlayer->ForceChangeTeam( iTeam );
// Msg( "Moving Player to game: %s - team: %d\n", pPlayer->GetPlayerName(), pPlayer->GetTeamNumber() );
if ( pPlayer->DidPlayerJustPlay() == false )
{
pPlayer->MarkTeamJoinTime();
}
}
}
}
// show the class composition panel
m_flSendNotificationTime = gpGlobals->curtime + 1.0f;
Arena_CleanupPlayerQueue();
Arena_NotifyTeamSizeChange();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::Arena_NotifyTeamSizeChange( void )
{
int iTeamSize = GetGlobalTFTeam( TF_TEAM_BLUE )->GetNumPlayers();
if ( iTeamSize == m_iPreviousTeamSize )
return;
if ( m_iPreviousTeamSize == 0 )
{
m_iPreviousTeamSize = iTeamSize;
return;
}
if ( m_iPreviousTeamSize > iTeamSize )
{
UTIL_ClientPrintAll( HUD_PRINTTALK, "#TF_Arena_TeamSizeDecreased", UTIL_VarArgs( "%d", iTeamSize ) );
}
else
{
UTIL_ClientPrintAll( HUD_PRINTTALK, "#TF_Arena_TeamSizeIncreased", UTIL_VarArgs( "%d", iTeamSize ) );
}
m_iPreviousTeamSize = iTeamSize;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::Arena_SendPlayerNotifications( void )
{
int iTeamPlayers = GetGlobalTFTeam( TF_TEAM_RED )->GetNumPlayers() + GetGlobalTFTeam( TF_TEAM_BLUE )->GetNumPlayers();
int iNumPlayers = 0;
m_flSendNotificationTime = 0.0f;
for ( int i = 1; i <= MAX_PLAYERS; i++ )
{
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( pPlayer && pPlayer->IsHLTV() == false && pPlayer->IsReplay() == false && pPlayer->GetDesiredPlayerClassIndex() > TF_CLASS_UNDEFINED )
{
iNumPlayers++;
if ( pPlayer->GetTeamNumber() == TEAM_SPECTATOR && pPlayer->GetPreviousTeam() != TEAM_UNASSIGNED )
{
CSingleUserRecipientFilter filter( pPlayer );
UserMessageBegin( filter, "HudArenaNotify" );
WRITE_BYTE( pPlayer->entindex() );
WRITE_BYTE( TF_ARENA_NOTIFICATION_SITOUT );
MessageEnd();
}
}
}
if ( iTeamPlayers == iNumPlayers )
return;
int iExtras = iNumPlayers - iTeamPlayers;
for ( int iTeam = TF_TEAM_RED; iTeam < TF_TEAM_COUNT; iTeam++ )
{
CUtlVector<CTFPlayer*> pTempPlayerQueue;
CTFTeam *pTeam = GetGlobalTFTeam( iTeam );
if ( pTeam )
{
for ( int iPlayer = 0; iPlayer < pTeam->GetNumPlayers(); iPlayer++ )
{
CTFPlayer *pPlayer = ToTFPlayer( pTeam->GetPlayer( iPlayer ) );
if ( pPlayer && pPlayer->IsHLTV() == false && pPlayer->IsReplay() == false )
{
pTempPlayerQueue.AddToTail( pPlayer );
}
}
}
pTempPlayerQueue.Sort( SortPlayerSpectatorQueue );
for ( int i = pTempPlayerQueue.Count(); --i >= 0; )
{
if ( pTempPlayerQueue.Count() - i > iExtras )
continue;
CTFPlayer *pPlayer = pTempPlayerQueue[i];
CSingleUserRecipientFilter filter( pPlayer );
UserMessageBegin( filter, "HudArenaNotify" );
WRITE_BYTE( pPlayer->entindex() );
WRITE_BYTE( TF_ARENA_NOTIFICATION_CAREFUL );
MessageEnd();
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Handle maps that may be in our map cycle/etc changing name or availability
//-----------------------------------------------------------------------------
#ifdef GAME_DLL
void CTFGameRules::OnWorkshopMapUpdated( PublishedFileId_t nUpdatedWorkshopID )
{
// Check if this map is in the mapcycle under a different name, reload mapcycle if so. We want the up-to-date names
// in the map cycle as it is used for user-facing things such as votes.
CTFMapsWorkshop *pWorkshop = TFMapsWorkshop();
if ( pWorkshop )
{
FOR_EACH_VEC( m_MapList, i )
{
// Check if this represents a workshop map
PublishedFileId_t nWorkshopID = pWorkshop->MapIDFromName( m_MapList[ i ] );
if ( nWorkshopID == nUpdatedWorkshopID )
{
CUtlString newName;
if ( pWorkshop->GetMapName( nWorkshopID, newName ) == CTFMapsWorkshop::eName_Canon &&
newName != m_MapList[ i ] )
{
// We can't just fixup the name here, as the primary mapcycle is also mirrored to a string
// table. This queues a reload, which will check for workshop names at that point.
m_bMapCycleNeedsUpdate = true;
break;
}
}
}
}
}
#endif
//-----------------------------------------------------------------------------
// Purpose: Hook new map cycle file loads
//-----------------------------------------------------------------------------
void CTFGameRules::LoadMapCycleFile( void )
{
BaseClass::LoadMapCycleFile();
#ifdef GAME_DLL
// The underlying LoadMapCycleFileIntoVector fixes up workshop names, but for loading the primary map cycle file, we
// also want to tell the workshop to track them. See also: TFGameRules::OnWorkshopMapChanged
TrackWorkshopMapsInMapCycle();
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Hook new map cycle file loads
//-----------------------------------------------------------------------------
void CTFGameRules::TrackWorkshopMapsInMapCycle( void )
{
CTFMapsWorkshop *pWorkshop = TFMapsWorkshop();
if ( pWorkshop )
{
unsigned int nAddedMaps = 0;
unsigned int nWorkshopMaps = 0;
FOR_EACH_VEC( m_MapList, i )
{
// Check if this represents a workshop map
PublishedFileId_t nWorkshopID = pWorkshop->MapIDFromName( m_MapList[ i ] );
if ( nWorkshopID != k_PublishedFileIdInvalid )
{
nWorkshopMaps++;
// Track it if we're not
if ( pWorkshop->AddMap( nWorkshopID ) )
{
nAddedMaps++;
}
}
}
if ( nAddedMaps )
{
Msg( "Tracking %u new workshop maps from map cycle (%u already tracked)\n", nAddedMaps, nWorkshopMaps - nAddedMaps );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Hook new map cycle file loads
//-----------------------------------------------------------------------------
void CTFGameRules::LoadMapCycleFileIntoVector( const char *pszMapCycleFile, CUtlVector<char *> &mapList )
{
BaseClass::LoadMapCycleFileIntoVector( pszMapCycleFile, mapList );
#ifdef GAME_DLL
// Fixup workshop map names if known. E.g. workshop/12345 -> workshop/cp_foo.ugc12345
CTFMapsWorkshop *pWorkshop = TFMapsWorkshop();
if ( pWorkshop )
{
FOR_EACH_VEC( mapList, i )
{
// Check if this represents a workshop map
PublishedFileId_t nWorkshopID = pWorkshop->MapIDFromName( mapList[ i ] );
if ( nWorkshopID != k_PublishedFileIdInvalid )
{
// Workshop map, update name
CUtlString newName;
pWorkshop->GetMapName( nWorkshopID, newName );
if ( newName.Length() )
{
// Alloc replacement
size_t nNewSize = newName.Length() + 1;
char *pNew = new char[ nNewSize ];
V_strncpy( pNew, newName.Get(), nNewSize );
// Replace
delete [] mapList[ i ];
mapList[ i ] = pNew;
}
}
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Server-side vote creation
//-----------------------------------------------------------------------------
void CTFGameRules::ManageServerSideVoteCreation( void )
{
if ( gpGlobals->curtime < m_flVoteCheckThrottle )
return;
if ( IsInTournamentMode() )
return;
if ( IsInArenaMode() )
return;
if ( IsInWaitingForPlayers() )
return;
if ( m_bInSetup )
return;
if ( IsInTraining() )
return;
if ( IsInItemTestingMode() )
return;
if ( m_MapList.Count() < 2 )
return;
// Ask players which map they would prefer to play next, based
// on "n" lowest playtime from server stats
ConVarRef sv_vote_issue_nextlevel_allowed( "sv_vote_issue_nextlevel_allowed" );
ConVarRef sv_vote_issue_nextlevel_choicesmode( "sv_vote_issue_nextlevel_choicesmode" );
if ( sv_vote_issue_nextlevel_allowed.GetBool() && sv_vote_issue_nextlevel_choicesmode.GetBool() )
{
// Don't do this if we already have a nextlevel set
if ( nextlevel.GetString() && *nextlevel.GetString() )
return;
if ( !m_bServerVoteOnReset && !m_bVoteCalled )
{
// If we have any round or win limit, ignore time
if ( mp_winlimit.GetInt() || mp_maxrounds.GetInt() )
{
int nBlueScore = TFTeamMgr()->GetTeam( TF_TEAM_BLUE )->GetScore();
int nRedScore = TFTeamMgr()->GetTeam( TF_TEAM_RED)->GetScore();
int nWinLimit = mp_winlimit.GetInt();
if ( ( nWinLimit - nBlueScore ) == 1 || ( nWinLimit - nRedScore ) == 1 )
{
m_bServerVoteOnReset = true;
}
int nRoundsPlayed = GetRoundsPlayed();
if ( ( mp_maxrounds.GetInt() - nRoundsPlayed ) == 1 )
{
m_bServerVoteOnReset = true;
}
}
else if ( mp_timelimit.GetInt() > 0 )
{
int nTimeLeft = GetTimeLeft();
if ( nTimeLeft <= 120 && !m_bServerVoteOnReset )
{
if ( g_voteController )
{
g_voteController->CreateVote( DEDICATED_SERVER, "nextlevel", "" );
}
m_bVoteCalled = true;
}
}
}
}
m_flVoteCheckThrottle = gpGlobals->curtime + 0.5f;
}
//-----------------------------------------------------------------------------
// Purpose: Figures out how much money to put in a custom currency pack drop
//-----------------------------------------------------------------------------
int CTFGameRules::CalculateCurrencyAmount_CustomPack( int nAmount )
{
// Entities and events that specify a custom currency value should pass in the amount
// they're worth, and we figure out if there's enough currency to generate a pack.
// If the amount passed in isn't enough to generate a pack, we store it in an accumulator.
int nMinDrop = kMVM_CurrencyPackMinSize;
if ( nMinDrop > 1 )
{
// If we're on the last spawn, drop everything
if ( TFObjectiveResource()->GetMannVsMachineWaveEnemyCount() == 1 )
{
nMinDrop = m_nCurrencyAccumulator + nAmount;
m_nCurrencyAccumulator = 0;
return nMinDrop;
}
// If we're passing in a value above mindrop, just drop it
if ( nAmount >= nMinDrop )
return nAmount;
// Accumulate currency if we're getting values below nMinDrop
m_nCurrencyAccumulator += nAmount;
if ( m_nCurrencyAccumulator >= nMinDrop )
{
m_nCurrencyAccumulator -= nMinDrop;
//DevMsg( "*MIN REACHED* -- %d left\n", m_nCurrencyAccumulator );
return nMinDrop;
}
else
{
// We don't have enough yet, drop nothing
//DevMsg( "*STORE* -- %d stored\n", m_nCurrencyAccumulator );
return 0;
}
}
else
{
// We don't have a PopManager - return the amount passed in
return nAmount;
}
}
//-----------------------------------------------------------------------------
// Purpose: Figures out how much to give for pre-definied events or types
//-----------------------------------------------------------------------------
int CTFGameRules::CalculateCurrencyAmount_ByType( CurrencyRewards_t nType )
{
// CUSTOM values are usually determined by CalculateCurrencyAmount_CustomPack() and set via CCurrencyPack::SetValue()
Assert ( nType != TF_CURRENCY_PACK_CUSTOM );
int nAmount = 0;
switch ( nType )
{
case TF_CURRENCY_KILLED_PLAYER:
nAmount = 40;
break;
case TF_CURRENCY_KILLED_OBJECT:
nAmount = 40;
break;
case TF_CURRENCY_ASSISTED_PLAYER:
nAmount = 20;
break;
case TF_CURRENCY_BONUS_POINTS:
nAmount = 1;
break;
case TF_CURRENCY_CAPTURED_OBJECTIVE:
nAmount = 100;
break;
case TF_CURRENCY_ESCORT_REWARD:
nAmount = 10;
break;
case TF_CURRENCY_PACK_SMALL:
nAmount = 5;
break;
case TF_CURRENCY_PACK_MEDIUM:
nAmount = 10;
break;
case TF_CURRENCY_PACK_LARGE:
nAmount = 25;
break;
case TF_CURRENCY_TIME_REWARD:
nAmount = 5;
break;
case TF_CURRENCY_WAVE_COLLECTION_BONUS:
nAmount = 100;
break;
default:
Assert( 0 ); // Unknown type
};
return nAmount;
}
//-----------------------------------------------------------------------------
// Purpose: Gives money directly to a team or specific player
//-----------------------------------------------------------------------------
int CTFGameRules::DistributeCurrencyAmount( int nAmount, CTFPlayer *pTFPlayer /* = NULL */, bool bShared /* = true */, bool bCountAsDropped /*= false */, bool bIsBonus /*= false */ )
{
// Group distribution (default)
if ( bShared )
{
CUtlVector<CTFPlayer *> playerVector;
if ( IsMannVsMachineMode() )
{
CollectPlayers( &playerVector, TF_TEAM_PVE_DEFENDERS );
}
#ifdef STAGING_ONLY
else if ( IsBountyMode() )
{
// We require a player in order to award the proper team
if ( pTFPlayer )
{
CollectPlayers( &playerVector, pTFPlayer->GetTeamNumber() );
}
}
#endif // STAGING_ONLY
// Money
FOR_EACH_VEC( playerVector, i )
{
if ( playerVector[i] )
{
#ifdef STAGING_ONLY
if ( IsBountyMode() )
{
// Check for a cap
int nLimit = tf_bountymode_currency_limit.GetInt();
if ( nLimit > 0 )
{
int nNewCurrency = nAmount + pTFPlayer->GetCurrency();
if ( nNewCurrency > nLimit )
{
int nDelta = nNewCurrency - nLimit;
if ( nDelta )
{
nAmount -= nDelta;
}
}
}
}
#endif // STAGING_ONLY
playerVector[i]->AddCurrency( nAmount );
}
}
}
// Individual distribution
else if ( pTFPlayer )
{
#ifdef STAGING_ONLY
if ( IsBountyMode() )
{
// Check for a cap
int nLimit = tf_bountymode_currency_limit.GetInt();
if ( nLimit > 0 )
{
int nNewCurrency = nAmount + pTFPlayer->GetCurrency();
if ( nNewCurrency > nLimit )
{
int nDelta = nNewCurrency - nLimit;
if ( nDelta )
{
nAmount -= nDelta;
}
}
}
}
#endif // STAGING_ONLY
pTFPlayer->AddCurrency( nAmount );
}
// Accounting
if ( IsMannVsMachineMode() && g_pPopulationManager )
{
g_pPopulationManager->OnCurrencyCollected( nAmount, bCountAsDropped, bIsBonus );
}
return nAmount;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::RoundRespawn( void )
{
#ifdef GAME_DLL
m_hasSpawnedToy = false;
for ( int i = 0; i < TF_TEAM_COUNT; i++ )
{
m_bHasSpawnedSoccerBall[i] = false;
}
#endif // GAME_DLL
// remove any buildings, grenades, rockets, etc. the player put into the world
RemoveAllProjectilesAndBuildings();
// re-enable any sentry guns the losing team has built (and not hidden!)
for ( int i=0; i<IBaseObjectAutoList::AutoList().Count(); ++i )
{
CBaseObject *pObj = static_cast< CBaseObject* >( IBaseObjectAutoList::AutoList()[i] );
if ( pObj->ObjectType() == OBJ_SENTRYGUN && pObj->IsEffectActive( EF_NODRAW ) == false && pObj->GetTeamNumber() != m_iWinningTeam )
{
pObj->SetDisabled( false );
}
}
#ifdef TF_RAID_MODE
// Raid mode: clean up any Red buildings that might be left behind from the previous round
if ( IsRaidMode() )
{
CTFTeam *pTeam = TFTeamMgr()->GetTeam( TF_TEAM_RED );
if ( pTeam )
{
int nTeamObjectCount = pTeam->GetNumObjects();
for ( int iObject = 0; iObject < nTeamObjectCount; ++iObject )
{
CBaseObject *pObj = pTeam->GetObject( iObject );
if ( pObj )
{
pObj->SetThink( &CBaseEntity::SUB_Remove );
pObj->SetNextThink( gpGlobals->curtime );
pObj->SetTouch( NULL );
pObj->AddEffects( EF_NODRAW );
}
}
}
}
else if ( IsBossBattleMode() )
{
// unspawn entire red team
CTeam *defendingTeam = GetGlobalTeam( TF_TEAM_RED );
int i;
for( i=0; i<defendingTeam->GetNumPlayers(); ++i )
{
engine->ServerCommand( UTIL_VarArgs( "kickid %d\n", defendingTeam->GetPlayer(i)->GetUserID() ) );
}
}
#endif // TF_RAID_MODE
if ( IsInTournamentMode() == false )
{
Arena_RunTeamLogic();
}
m_bArenaFirstBlood = false;
// reset the flag captures
int nTeamCount = TFTeamMgr()->GetTeamCount();
for ( int iTeam = FIRST_GAME_TEAM; iTeam < nTeamCount; ++iTeam )
{
CTFTeam *pTeam = GetGlobalTFTeam( iTeam );
if ( !pTeam )
continue;
pTeam->SetFlagCaptures( 0 );
}
if ( !IsMannVsMachineMode() )
{
IGameEvent *event = gameeventmanager->CreateEvent( "scorestats_accumulated_update" );
if ( event )
{
gameeventmanager->FireEvent( event );
}
}
// reset player per-round stats
CTF_GameStats.ResetRoundStats();
BaseClass::RoundRespawn();
// ** AFTER WE'VE BEEN THROUGH THE ROUND RESPAWN, SHOW THE ROUNDINFO PANEL
if ( !IsInWaitingForPlayers() )
{
ShowRoundInfoPanel();
}
// We've hit some condition where a server-side vote should be called on respawn
if ( m_bServerVoteOnReset )
{
if ( g_voteController )
{
g_voteController->CreateVote( DEDICATED_SERVER, "nextlevel", "" );
}
m_bVoteCalled = true;
m_bServerVoteOnReset = false;
}
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldSwitchTeams( void )
{
if ( IsPVEModeActive() )
return false;
return BaseClass::ShouldSwitchTeams();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldScrambleTeams( void )
{
if ( IsPVEModeActive() )
return false;
if ( IsCompetitiveMode() )
return false;
return BaseClass::ShouldScrambleTeams();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::ClientCommandKeyValues( edict_t *pEntity, KeyValues *pKeyValues )
{
CTFPlayer *pTFPlayer = ToTFPlayer( CBaseEntity::Instance( pEntity ) );
if ( !pTFPlayer )
return;
char const *pszCommand = pKeyValues->GetName();
if ( pszCommand && pszCommand[0] )
{
if ( FStrEq( pszCommand, "FreezeCamTaunt" ) )
{
CTFPlayer *pAchiever = ToTFPlayer( UTIL_PlayerByUserId( pKeyValues->GetInt( "achiever" ) ) );
if ( pAchiever )
{
const char *pszCommand = pKeyValues->GetString( "command" );
if ( pszCommand && pszCommand[0] )
{
int nGibs = pKeyValues->GetInt( "gibs" );
if ( FStrEq( pszCommand, "freezecam_taunt" ) )
{
CheckTauntAchievement( pAchiever, nGibs, g_TauntCamAchievements );
CheckTauntAchievement( pAchiever, nGibs, g_TauntCamAchievements2 );
HatAndMiscEconEntities_OnOwnerKillEaterEventNoParter( pAchiever, kKillEaterEvent_KillcamTaunts );
}
else if ( FStrEq( pszCommand, "freezecam_tauntrag" ) )
{
CheckTauntAchievement( pAchiever, nGibs, g_TauntCamRagdollAchievements );
}
else if ( FStrEq( pszCommand, "freezecam_tauntgibs" ) )
{
CheckTauntAchievement( pAchiever, nGibs, g_TauntCamAchievements );
}
else if ( FStrEq( pszCommand, "freezecam_tauntsentry" ) )
{
// Maybe should also require a taunt? Currently too easy to get?
pAchiever->AwardAchievement( ACHIEVEMENT_TF_ENGINEER_FREEZECAM_SENTRY );
}
}
}
}
else if ( FStrEq( pszCommand, "UsingVRHeadset" ) )
{
pTFPlayer->SetUsingVRHeadset( true );
}
else if ( FStrEq( pszCommand, "TestItems" ) )
{
pTFPlayer->ItemTesting_Start( pKeyValues );
}
else if ( FStrEq( pszCommand, "TestItemsBotUpdate" ) )
{
ItemTesting_SetupFromKV( pKeyValues );
}
else if ( FStrEq( pszCommand, "MVM_Upgrade" ) )
{
if ( GameModeUsesUpgrades() )
{
#ifndef STAGING_ONLY
if ( IsMannVsMachineMode() )
{
if ( sv_cheats && !sv_cheats->GetBool() && !pTFPlayer->m_Shared.IsInUpgradeZone() )
return;
}
#endif //!STAGING_ONLY
if ( g_hUpgradeEntity )
{
// First sell everything we want to sell
KeyValues *pSubKey = pKeyValues->GetFirstTrueSubKey();
while ( pSubKey )
{
int iCount = pSubKey->GetInt("count");
if ( iCount < 0 )
{
int iItemSlot = pSubKey->GetInt("itemslot");
int iUpgrade = pSubKey->GetInt("upgrade");
bool bFree = pSubKey->GetBool( "free", false );
while ( iCount < 0 )
{
g_hUpgradeEntity->PlayerPurchasingUpgrade( pTFPlayer, iItemSlot, iUpgrade, true, bFree );
++iCount;
}
}
pSubKey = pSubKey->GetNextTrueSubKey();
}
// Now buy everything we want to buy
pSubKey = pKeyValues->GetFirstTrueSubKey();
while ( pSubKey )
{
int iCount = pSubKey->GetInt("count");
if ( iCount > 0 )
{
int iItemSlot = pSubKey->GetInt("itemslot");
int iUpgrade = pSubKey->GetInt("upgrade");
bool bFree = ( sv_cheats && sv_cheats->GetBool() ) ? pSubKey->GetBool( "free", false ) : false; // Never let a client set "free" without sv_cheats 1
while ( iCount > 0 )
{
g_hUpgradeEntity->PlayerPurchasingUpgrade( pTFPlayer, iItemSlot, iUpgrade, false, bFree );
--iCount;
}
}
pSubKey = pSubKey->GetNextTrueSubKey();
}
}
}
}
else if ( FStrEq( pszCommand, "MvM_UpgradesBegin" ) )
{
pTFPlayer->BeginPurchasableUpgrades();
}
else if ( FStrEq( pszCommand, "MvM_UpgradesDone" ) )
{
pTFPlayer->EndPurchasableUpgrades();
if ( IsMannVsMachineMode() && pKeyValues->GetInt( "num_upgrades", 0 ) > 0 )
{
pTFPlayer->SpeakConceptIfAllowed( MP_CONCEPT_MVM_UPGRADE_COMPLETE );
}
}
else if ( FStrEq( pszCommand, "MVM_Revive_Response" ) )
{
CTFReviveMarker *pReviveMarker = pTFPlayer->GetReviveMarker();
if ( pReviveMarker )
{
if ( pKeyValues->GetBool( "accepted", 0 ) )
{
pReviveMarker->ReviveOwner();
}
else
{
// They hit cancel after their spawn timer was up
if ( HasPassedMinRespawnTime( pTFPlayer ) )
{
pTFPlayer->ForceRespawn();
}
UTIL_Remove( pReviveMarker );
}
}
}
else if ( FStrEq( pszCommand, "MVM_Respec" ) )
{
if ( GameModeUsesUpgrades() && IsMannVsMachineRespecEnabled() && CanPlayerUseRespec( pTFPlayer ) )
{
#ifndef STAGING_ONLY
if ( IsMannVsMachineMode() )
{
if ( sv_cheats && !sv_cheats->GetBool() && !pTFPlayer->m_Shared.IsInUpgradeZone() )
return;
}
#endif //!STAGING_ONLY
if ( g_hUpgradeEntity && g_pPopulationManager )
{
// Consume a respec credit
g_pPopulationManager->RemoveRespecFromPlayer( pTFPlayer );
// Remove the appropriate upgrade info from upgrade histories
g_pPopulationManager->RemovePlayerAndItemUpgradesFromHistory( pTFPlayer );
// Remove upgrade attributes from the player and their items
g_hUpgradeEntity->GrantOrRemoveAllUpgrades( pTFPlayer, true );
pTFPlayer->ForceRespawn();
}
}
}
else if ( FStrEq( pszCommand, "use_action_slot_item_server" ) )
{
if ( pTFPlayer->ShouldRunRateLimitedCommand( "use_action_slot_item_server" ) )
{
pTFPlayer->UseActionSlotItemPressed();
pTFPlayer->UseActionSlotItemReleased();
}
}
else if ( FStrEq( pszCommand, "+use_action_slot_item_server" ) )
{
if ( !pTFPlayer->IsUsingActionSlot() )
{
pTFPlayer->UseActionSlotItemPressed();
}
}
else if ( FStrEq( pszCommand, "-use_action_slot_item_server" ) )
{
if ( pTFPlayer->IsUsingActionSlot() )
{
pTFPlayer->UseActionSlotItemReleased();
}
}
else if ( FStrEq( pszCommand, "+inspect_server" ) )
{
pTFPlayer->InspectButtonPressed();
}
else if ( FStrEq( pszCommand, "-inspect_server" ) )
{
pTFPlayer->InspectButtonReleased();
}
else if ( FStrEq( pszCommand, "cl_drawline" ) )
{
BroadcastDrawLine( pTFPlayer, pKeyValues );
}
else if ( FStrEq( pszCommand, "AutoBalanceVolunteerReply" ) )
{
if ( TFAutoBalance() )
{
TFAutoBalance()->ReplyReceived( pTFPlayer, pKeyValues->GetBool( "response", false ) );
}
}
else
{
BaseClass::ClientCommandKeyValues( pEntity, pKeyValues );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::BroadcastDrawLine( CTFPlayer *pTFPlayer, KeyValues *pKeyValues )
{
int paneltype = clamp( pKeyValues->GetInt( "panel", DRAWING_PANEL_TYPE_NONE ), DRAWING_PANEL_TYPE_NONE, DRAWING_PANEL_TYPE_MAX - 1 );
if ( paneltype >= DRAWING_PANEL_TYPE_MATCH_SUMMARY )
{
int linetype = clamp( pKeyValues->GetInt( "line", 0 ), 0, 1 );
float x = pKeyValues->GetFloat( "x", 0.f );
float y = pKeyValues->GetFloat( "y", 0.f );
IGameEvent *event = gameeventmanager->CreateEvent( "cl_drawline" );
if ( event )
{
event->SetInt( "player", pTFPlayer->entindex() );
event->SetInt( "panel",paneltype );
event->SetInt( "line", linetype );
event->SetFloat( "x", x );
event->SetFloat( "y", y );
gameeventmanager->FireEvent( event );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::RespawnTeam( int iTeam )
{
BaseClass::RespawnTeam( iTeam );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::SpawnPlayerInHell( CTFPlayer *pPlayer, const char *pszSpawnPointName )
{
Vector vTeleportPosition;
QAngle qTeleportAngles;
int iCachedLocations = m_mapTeleportLocations.Find( MAKE_STRING( pszSpawnPointName ) );
if ( m_mapTeleportLocations.IsValidIndex( iCachedLocations ) )
{
CUtlVector< TeleportLocation_t > *pLocations = m_mapTeleportLocations[iCachedLocations];
Assert( pLocations );
if ( !pLocations )
return;
const TeleportLocation_t& location = pLocations->Element( RandomInt( 0, pLocations->Count() - 1 ) );
vTeleportPosition = location.m_vecPosition;
qTeleportAngles = location.m_qAngles;
}
else
{
CUtlVector< CBaseEntity* > m_vecPossibleSpawns;
CBaseEntity* pSpawn = NULL;
while( (pSpawn = gEntList.FindEntityByName( pSpawn, pszSpawnPointName ) ) != NULL )
{
m_vecPossibleSpawns.AddToTail( pSpawn );
}
// There had better be a spawnpoint in this map!
Assert( m_vecPossibleSpawns.Count() );
if ( m_vecPossibleSpawns.Count() == 0 )
return;
// Randomly choose one
pSpawn = m_vecPossibleSpawns[ RandomInt( 0, m_vecPossibleSpawns.Count() - 1 ) ];
vTeleportPosition = pSpawn->GetAbsOrigin();
qTeleportAngles = pSpawn->GetAbsAngles();
}
// Teleport them to hell
pPlayer->Teleport( &vTeleportPosition, &qTeleportAngles, &vec3_origin );
pPlayer->pl.v_angle = qTeleportAngles;
// Send us to hell as a ghost!
pPlayer->m_Shared.AddCond( TF_COND_HALLOWEEN_GHOST_MODE );
pPlayer->m_Shared.AddCond( TF_COND_HALLOWEEN_IN_HELL );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
extern ISoundEmitterSystemBase *soundemitterbase;
void CTFGameRules::PlayHelltowerAnnouncerVO( int iRedLine, int iBlueLine )
{
static float flRedAnnouncerTalkingUntil = 0.00f, flBlueAnnouncerTalkingUntil = 0.00f;
// 01 is the first line for the VO
int iRandomVORed = RandomInt( 1, g_pszHelltowerAnnouncerLines[iRedLine].m_nCount );
int iRandomVOBlue = RandomInt( 1, g_pszHelltowerAnnouncerLines[iBlueLine].m_nCount );
// the misc lines should match up so we'll play the same lines to both teams
if ( ( iRedLine <= HELLTOWER_VO_BLUE_MISC_RARE ) && ( iBlueLine <= HELLTOWER_VO_BLUE_MISC_RARE ) )
{
// can we safely set blue to the same value?
if ( iRandomVORed <= g_pszHelltowerAnnouncerLines[iBlueLine].m_nCount )
{
iRandomVOBlue = iRandomVORed;
}
}
char szRedAudio[128];
char szBlueAudio[128];
V_sprintf_safe( szRedAudio, g_pszHelltowerAnnouncerLines[iRedLine].m_pszFormatString, iRandomVORed );
V_sprintf_safe( szBlueAudio, g_pszHelltowerAnnouncerLines[iBlueLine].m_pszFormatString, iRandomVOBlue );
bool bForceVO = false;
switch (iRedLine)
{
case HELLTOWER_VO_RED_WIN:
case HELLTOWER_VO_RED_WIN_RARE:
case HELLTOWER_VO_RED_LOSE:
case HELLTOWER_VO_RED_LOSE_RARE:
bForceVO = true;
}
switch (iBlueLine)
{
case HELLTOWER_VO_BLUE_WIN:
case HELLTOWER_VO_BLUE_WIN_RARE:
case HELLTOWER_VO_BLUE_LOSE:
case HELLTOWER_VO_BLUE_LOSE_RARE:
bForceVO = true;
}
CSoundParameters params;
float flSoundDuration = 0;
if ( gpGlobals->curtime > flRedAnnouncerTalkingUntil || bForceVO )
{
BroadcastSound( TF_TEAM_RED, szRedAudio );
if ( soundemitterbase->GetParametersForSound( szRedAudio, params, GENDER_NONE ) )
{
//flSoundDuration = enginesound->GetSoundDuration( params.soundname );
flRedAnnouncerTalkingUntil = gpGlobals->curtime + flSoundDuration;
}
else
{
flRedAnnouncerTalkingUntil = 0.00;
}
}
if ( gpGlobals->curtime > flBlueAnnouncerTalkingUntil || bForceVO )
{
BroadcastSound( TF_TEAM_BLUE, szBlueAudio );
if ( soundemitterbase->GetParametersForSound( szBlueAudio, params, GENDER_NONE ) )
{
//flSoundDuration = enginesound->GetSoundDuration( params.soundname );
flBlueAnnouncerTalkingUntil = gpGlobals->curtime + flSoundDuration;
}
else
{
flBlueAnnouncerTalkingUntil = 0.00;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Based on connected match players, chooses the 3 maps players can
// vote on as their next map
//-----------------------------------------------------------------------------
void CTFGameRules::ChooseNextMapVoteOptions()
{
// Copy chosen maps into the actual fields we're networking to clients
for( int i=0; i < NEXT_MAP_VOTE_OPTIONS; ++i )
{
m_nNextMapVoteOptions.Set( i, GTFGCClientSystem()->GetNextMapVoteByIndex( i )->m_nDefIndex );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::CheckHelltowerCartAchievement( int iTeam )
{
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
{
CUtlVector< CTFPlayer * > playerVector;
CollectPlayers( &playerVector, iTeam );
FOR_EACH_VEC( playerVector, i )
{
CTFPlayer *pPlayer = playerVector[i];
if ( pPlayer && ( pPlayer->GetObserverMode() <= OBS_MODE_DEATHCAM ) ) // they might be killed by the explosion, so check if they are OBS_MODE_NONE OR OBS_MODE_DEATHCAM
{
CTriggerAreaCapture *pAreaTrigger = pPlayer->GetControlPointStandingOn();
if ( pAreaTrigger && pAreaTrigger->TeamCanCap( iTeam ) )
{
pPlayer->AwardAchievement( ACHIEVEMENT_TF_HALLOWEEN_HELLTOWER_KILL_BROTHERS );
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::HandleMapEvent( inputdata_t &inputdata )
{
if ( FStrEq( "sd_doomsday", STRING( gpGlobals->mapname ) ) )
{
// find the flag in the map
CCaptureFlag *pFlag = NULL;
for ( int i=0; i<ICaptureFlagAutoList::AutoList().Count(); ++i )
{
pFlag = static_cast< CCaptureFlag* >( ICaptureFlagAutoList::AutoList()[i] );
if ( !pFlag->IsDisabled() )
{
break;
}
}
// make sure it's being carried by one of the teams
if ( pFlag && pFlag->IsStolen() )
{
CTFPlayer *pFlagCarrier = ToTFPlayer( pFlag->GetOwnerEntity() );
if ( pFlagCarrier )
{
// let everyone know which team has opened the rocket
IGameEvent *event = gameeventmanager->CreateEvent( "doomsday_rocket_open" );
if ( event )
{
event->SetInt( "team", pFlagCarrier->GetTeamNumber() );
gameeventmanager->FireEvent( event );
}
}
}
}
else if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
{
const char *pszEvent = inputdata.value.String();
if ( FStrEq( pszEvent, "midnight" ) )
{
HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_PLAYER_HELLTOWER_MIDNIGHT );
}
else if ( FStrEq( pszEvent, "horde" ) )
{
HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_PLAYER_SKELETON_KING_APPEAR );
PlayHelltowerAnnouncerVO( HELLTOWER_VO_RED_SKELETON_KING, HELLTOWER_VO_BLUE_SKELETON_KING );
}
else if ( FStrEq( pszEvent, "red_capture" ) )
{
CheckHelltowerCartAchievement( TF_TEAM_RED );
if ( RandomFloat( 0, 1 ) < HELLTOWER_RARE_LINE_CHANCE )
{
PlayHelltowerAnnouncerVO( HELLTOWER_VO_RED_WIN_RARE, HELLTOWER_VO_BLUE_LOSE_RARE );
}
else
{
PlayHelltowerAnnouncerVO( HELLTOWER_VO_RED_WIN, HELLTOWER_VO_BLUE_LOSE );
}
}
else if ( FStrEq( pszEvent, "blue_capture" ) )
{
CheckHelltowerCartAchievement( TF_TEAM_BLUE );
if ( RandomFloat( 0, 1 ) < HELLTOWER_RARE_LINE_CHANCE )
{
PlayHelltowerAnnouncerVO( HELLTOWER_VO_RED_LOSE_RARE, HELLTOWER_VO_BLUE_WIN_RARE );
}
else
{
PlayHelltowerAnnouncerVO( HELLTOWER_VO_RED_LOSE, HELLTOWER_VO_BLUE_WIN );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::SetCustomUpgradesFile( inputdata_t &inputdata )
{
const char *pszPath = inputdata.value.String();
// Reload
g_MannVsMachineUpgrades.LoadUpgradesFileFromPath( pszPath );
// Tell future clients to load from this path
V_strncpy( m_pszCustomUpgradesFile.GetForModify(), pszPath, MAX_PATH );
// Tell connected clients to reload
IGameEvent *pEvent = gameeventmanager->CreateEvent( "upgrades_file_changed" );
if ( pEvent )
{
pEvent->SetString( "path", pszPath );
gameeventmanager->FireEvent( pEvent );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldWaitToStartRecording( void )
{
if ( IsMannVsMachineMode() )
{
// Don't wait for the WaitingForPlayers period to end if we're MvM
return false;
}
return BaseClass::ShouldWaitToStartRecording();
}
//-----------------------------------------------------------------------------
// Purpose: return true if this flag is currently allowed to be captured
//-----------------------------------------------------------------------------
bool CTFGameRules::CanFlagBeCaptured( CBaseEntity *pOther )
{
if ( pOther && ( tf_flag_return_on_touch.GetBool() || IsPowerupMode() ) )
{
for ( int i = 0; i < ICaptureFlagAutoList::AutoList().Count(); ++i )
{
CCaptureFlag *pListFlag = static_cast<CCaptureFlag*>( ICaptureFlagAutoList::AutoList()[i] );
if ( ( pListFlag->GetType() == TF_FLAGTYPE_CTF ) && !pListFlag->IsDisabled() && ( pOther->GetTeamNumber() == pListFlag->GetTeamNumber() ) && !pListFlag->IsHome() )
return false;
}
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: return true if the game is in a state where both flags are stolen and poisonous
//-----------------------------------------------------------------------------
bool CTFGameRules::PowerupModeFlagStandoffActive( void )
{
if ( IsPowerupMode() )
{
int nQualifyingFlags = 0; // All flags need to be stolen and poisonous (poisonous time delay gives the flag carriers a chance to get out of the enemy base)
int nEnabledFlags = 0; // Some flags might be in the autolist but be out of play. We don't want them included in the count
for ( int i = 0; i < ICaptureFlagAutoList::AutoList().Count(); ++i )
{
CCaptureFlag *pFlag = static_cast<CCaptureFlag*>( ICaptureFlagAutoList::AutoList()[i] );
if ( !pFlag->IsDisabled() )
nEnabledFlags++;
if ( pFlag->IsPoisonous() && pFlag->IsStolen() )
nQualifyingFlags++;
}
if ( nQualifyingFlags == nEnabledFlags )
{
return true;
}
}
return false;
}
void CTFGameRules::TeleportPlayersToTargetEntities( int iTeam, const char *pszEntTargetName, CUtlVector< CTFPlayer * > *pTeleportedPlayers )
{
CUtlVector< CTFPlayer * > vecPlayers;
CUtlVector< CTFPlayer * > vecRandomOrderPlayers;
CollectPlayers( &vecPlayers, iTeam );
FOR_EACH_VEC( vecPlayers, i )
{
CTFPlayer *pPlayer = vecPlayers[i];
// Skip players not on a team or who have not chosen a class
if ( ( pPlayer->GetTeamNumber() != TF_TEAM_RED && pPlayer->GetTeamNumber() != TF_TEAM_BLUE )
|| pPlayer->IsPlayerClass( TF_CLASS_UNDEFINED ) )
continue;
vecRandomOrderPlayers.AddToTail( pPlayer );
}
// Randomize the order so players dont go to the same spot every time
vecRandomOrderPlayers.Shuffle();
string_t sName = MAKE_STRING( pszEntTargetName );
int iCachedLocationIndex = m_mapTeleportLocations.Find( sName );
CUtlVector< TeleportLocation_t > *pCachedLocations = NULL;
// is there any cached entities to teleport to
if ( m_mapTeleportLocations.IsValidIndex( iCachedLocationIndex ) )
{
pCachedLocations = m_mapTeleportLocations[iCachedLocationIndex];
}
int iCurrentTeleportLocation = 0;
CBaseEntity *pSpawnPoint = NULL;
FOR_EACH_VEC_BACK( vecRandomOrderPlayers, i )
{
// don't do anything if we run out of spawn point
Vector vTeleportPosition;
QAngle qTeleportAngles;
// if we have cached locations, use them
if ( pCachedLocations )
{
Assert( iCurrentTeleportLocation < pCachedLocations->Count() );
if ( iCurrentTeleportLocation < pCachedLocations->Count() )
{
const TeleportLocation_t& location = pCachedLocations->Element( iCurrentTeleportLocation );
vTeleportPosition = location.m_vecPosition;
qTeleportAngles = location.m_qAngles;
iCurrentTeleportLocation++;
}
else
{
// we need to add more teleport location in the map for players to teleport to
continue;
}
}
else // use old search for entities by name
{
pSpawnPoint = gEntList.FindEntityByName( pSpawnPoint, pszEntTargetName );
Assert( pSpawnPoint );
if ( pSpawnPoint )
{
vTeleportPosition = pSpawnPoint->GetAbsOrigin();
qTeleportAngles = pSpawnPoint->GetAbsAngles();
}
else
{
// we need to add more teleport location in the map for players to teleport to
continue;
}
}
CTFPlayer *pPlayer = vecRandomOrderPlayers[ i ];
pPlayer->m_Shared.RemoveAllCond();
// Respawn dead players
if ( !pPlayer->IsAlive() )
{
pPlayer->ForceRespawn();
}
// Unzoom if we are a sniper zoomed!
pPlayer->m_Shared.InstantlySniperUnzoom();
// Teleport
pPlayer->Teleport( &vTeleportPosition, &qTeleportAngles, &vec3_origin );
pPlayer->SnapEyeAngles( qTeleportAngles );
// Force client to update all view angles (including kart and taunt yaw)
pPlayer->ForcePlayerViewAngles( qTeleportAngles );
// fill in the teleported player vector
if ( pTeleportedPlayers )
{
pTeleportedPlayers->AddToTail( pPlayer );
}
}
}
#endif // GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::InternalHandleTeamWin( int iWinningTeam )
{
// remove any spies' disguises and make them visible (for the losing team only)
// and set the speed for both teams (winners get a boost and losers have reduced speed)
for ( int i = 1; i <= MAX_PLAYERS; i++ )
{
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( pPlayer )
{
if ( pPlayer->GetTeamNumber() > LAST_SHARED_TEAM )
{
if ( pPlayer->GetTeamNumber() != iWinningTeam )
{
pPlayer->RemoveInvisibility();
// pPlayer->RemoveDisguise();
if ( pPlayer->HasTheFlag() )
{
pPlayer->DropFlag();
}
}
pPlayer->TeamFortress_SetSpeed();
}
}
}
for ( int i=0; i<IBaseObjectAutoList::AutoList().Count(); ++i )
{
CBaseObject *pObj = static_cast< CBaseObject* >( IBaseObjectAutoList::AutoList()[i] );
if ( pObj->GetTeamNumber() != iWinningTeam )
{
// Stop placing any carried objects or else they will float around
// at our feet at the end of the round
if( pObj->IsPlacing() )
{
pObj->StopPlacement();
}
// Disable sentry guns that the losing team has built
if( pObj->GetType() == OBJ_SENTRYGUN )
{
pObj->SetDisabled( true );
}
}
}
if ( m_bForceMapReset )
{
m_iPrevRoundState = -1;
m_iCurrentRoundState = -1;
m_iCurrentMiniRoundMask = 0;
}
if ( IsInStopWatch() == true && GetStopWatchTimer() )
{
variant_t sVariant;
GetStopWatchTimer()->AcceptInput( "Pause", NULL, NULL, sVariant, 0 );
if ( m_bForceMapReset )
{
if ( GetStopWatchTimer()->IsWatchingTimeStamps() == true )
{
m_flStopWatchTotalTime = GetStopWatchTimer()->GetStopWatchTotalTime();
}
else
{
ShouldResetScores( true, false );
UTIL_Remove( m_hStopWatchTimer );
m_hStopWatchTimer = NULL;
m_flStopWatchTotalTime = -1.0f;
m_bStopWatch = false;
m_nStopWatchState.Set( STOPWATCH_CAPTURE_TIME_NOT_SET );
}
}
}
#ifdef GAME_DLL
if ( GetHalloweenScenario() == HALLOWEEN_SCENARIO_VIADUCT )
{
// send everyone to the underworld!
BroadcastSound( 255, "Halloween.PlayerEscapedUnderworld" );
CUtlVector< CTFPlayer * > playerVector;
CollectPlayers( &playerVector, TF_TEAM_RED, COLLECT_ONLY_LIVING_PLAYERS );
CollectPlayers( &playerVector, TF_TEAM_BLUE, COLLECT_ONLY_LIVING_PLAYERS, APPEND_PLAYERS );
CUtlVector< CBaseEntity * > spawnVector;
CBaseEntity *spawnPoint = NULL;
while( ( spawnPoint = gEntList.FindEntityByClassname( spawnPoint, "info_target" ) ) != NULL )
{
if ( FStrEq( STRING( spawnPoint->GetEntityName() ), "spawn_warcrimes" ) )
{
spawnVector.AddToTail( spawnPoint );
}
}
if ( spawnVector.Count() > 0 )
{
// shuffle the order of the spawns
int n = spawnVector.Count();
while( n > 1 )
{
int k = RandomInt( 0, n-1 );
n--;
CBaseEntity *tmp = spawnVector[n];
spawnVector[n] = spawnVector[k];
spawnVector[k] = tmp;
}
color32 fadeColor = { 255, 255, 255, 100 };
// send players to the underworld
for( int i=0; i<playerVector.Count(); ++i )
{
CTFPlayer *player = playerVector[i];
player->SetLocalOrigin( spawnVector[n]->GetAbsOrigin() + Vector( 0, 0, 20.0f ) );
player->SetAbsVelocity( vec3_origin );
player->SetLocalAngles( spawnVector[n]->GetAbsAngles() );
player->m_Local.m_vecPunchAngle = vec3_angle;
player->m_Local.m_vecPunchAngleVel = vec3_angle;
player->SnapEyeAngles( spawnVector[n]->GetAbsAngles() );
// give them full health since purgatory damages them over time
player->SetHealth( player->GetMaxHealth() );
UTIL_ScreenFade( player, fadeColor, 0.25, 0.4, FFADE_IN );
n = ( n + 1 ) % spawnVector.Count();
}
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Helper function for scramble teams
//-----------------------------------------------------------------------------
int FindScoreDifferenceBetweenTeams( CUtlVector< CTFPlayer* > &vecSource, CTFPlayerResource *pPR, int &nRedScore, int &nBlueScore )
{
if ( !pPR )
return false;
nRedScore = 0;
nBlueScore = 0;
FOR_EACH_VEC( vecSource, i )
{
if ( !vecSource[i] )
continue;
if ( vecSource[i]->GetTeamNumber() == TF_TEAM_RED )
{
nRedScore += pPR->GetTotalScore( vecSource[i]->entindex() );
}
else
{
nBlueScore += pPR->GetTotalScore( vecSource[i]->entindex() );
}
}
return abs( nRedScore - nBlueScore );
}
//-----------------------------------------------------------------------------
// Purpose: Helper function for scramble teams
//-----------------------------------------------------------------------------
bool FindAndSwapPlayersToBalanceTeams( CUtlVector< CTFPlayer* > &vecSource, int &nDelta, CTFPlayerResource *pPR )
{
if ( !pPR )
return false;
int nTeamScoreRed = 0;
int nTeamScoreBlue = 0;
FindScoreDifferenceBetweenTeams( vecSource, pPR, nTeamScoreRed, nTeamScoreBlue );
FOR_EACH_VEC( vecSource, i )
{
if ( !vecSource[i] )
continue;
if ( vecSource[i]->GetTeamNumber() != TF_TEAM_RED )
continue;
// Check against players on the other team
FOR_EACH_VEC( vecSource, j )
{
if ( !vecSource[j] )
continue;
if ( vecSource[j]->GetTeamNumber() != TF_TEAM_BLUE )
continue;
if ( vecSource[i] == vecSource[j] )
continue;
int nRedPlayerScore = pPR->GetTotalScore( vecSource[i]->entindex() );
int nBluePlayerScore = pPR->GetTotalScore( vecSource[j]->entindex() );
int nPlayerDiff = abs( nRedPlayerScore - nBluePlayerScore );
if ( nPlayerDiff )
{
int nNewRedScore = nTeamScoreRed;
int nNewBlueScore = nTeamScoreBlue;
if ( nRedPlayerScore > nBluePlayerScore )
{
nNewRedScore -= nPlayerDiff;
nNewBlueScore += nPlayerDiff;
}
else
{
nNewRedScore += nPlayerDiff;
nNewBlueScore -= nPlayerDiff;
}
int nNewDelta = abs( nNewRedScore - nNewBlueScore );
if ( nNewDelta < nDelta )
{
// Swap and recheck
vecSource[i]->ForceChangeTeam( TF_TEAM_BLUE );
vecSource[j]->ForceChangeTeam( TF_TEAM_RED );
nDelta = FindScoreDifferenceBetweenTeams( vecSource, pPR, nTeamScoreRed, nTeamScoreBlue );
return true;
}
}
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::HandleScrambleTeams( void )
{
static CUtlVector< CTFPlayer* > playerVector;
playerVector.RemoveAll();
CollectPlayers( &playerVector, TF_TEAM_RED );
CollectPlayers( &playerVector, TF_TEAM_BLUE, false, APPEND_PLAYERS );
// Sort by player score.
playerVector.Sort( ScramblePlayersSort );
// Put everyone on Spectator to clear the teams (or the autoteam step won't work correctly)
FOR_EACH_VEC_BACK( playerVector, i )
{
if ( !playerVector[i] )
{
playerVector.Remove( i );
continue;
}
else if ( DuelMiniGame_IsInDuel( playerVector[i] ) ) // don't include them if they're in a duel
{
playerVector.Remove( i );
continue;
}
playerVector[i]->ForceChangeTeam( TEAM_SPECTATOR );
}
// Assign players using the original, quick method.
FOR_EACH_VEC( playerVector, i )
{
if ( !playerVector[i] )
continue;
if ( playerVector[i]->GetTeamNumber() >= FIRST_GAME_TEAM ) // are they already on a game team?
continue;
playerVector[i]->ForceChangeTeam( TF_TEAM_AUTOASSIGN );
}
// New method
if ( playerVector.Count() > 2 )
{
CTFPlayerResource *pPR = dynamic_cast< CTFPlayerResource* >( g_pPlayerResource );
if ( pPR )
{
int nTeamScoreRed = 0;
int nTeamScoreBlue = 0;
int nDelta = FindScoreDifferenceBetweenTeams( playerVector, pPR, nTeamScoreRed, nTeamScoreBlue );
#ifdef _DEBUG
if ( mp_scrambleteams_debug.GetBool() )
{
DevMsg( "FIRST PASS -- Team1: %i || Team2: %i || Diff: %i\n",
nTeamScoreRed,
nTeamScoreBlue,
nDelta );
}
#endif // _DEBUG
// Try swapping players to bring scores closer
if ( nDelta > 1 )
{
int nOrigValue = mp_teams_unbalance_limit.GetInt();
mp_teams_unbalance_limit.SetValue( 0 );
static const int nPassLimit = 8;
for ( int i = 0; i < nPassLimit && FindAndSwapPlayersToBalanceTeams( playerVector, nDelta, pPR ); ++i )
{
#ifdef _DEBUG
if ( mp_scrambleteams_debug.GetBool() )
{
nTeamScoreRed = 0;
nTeamScoreBlue = 0;
DevMsg( "EXTRA PASS -- Team1: %i || Team2: %i || Diff: %i\n",
nTeamScoreRed,
nTeamScoreBlue,
FindScoreDifferenceBetweenTeams( playerVector, pPR, nTeamScoreRed, nTeamScoreBlue ) );
}
#endif // _DEBUG
}
mp_teams_unbalance_limit.SetValue( nOrigValue );
}
}
}
// scrambleteams_auto tracking
ResetTeamsRoundWinTracking();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::TeamPlayerCountChanged( CTFTeam *pTeam )
{
if ( m_hGamerulesProxy )
{
m_hGamerulesProxy->TeamPlayerCountChanged( pTeam );
}
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose: Should we attempt to roll into a new match for the current match
//-----------------------------------------------------------------------------
bool CTFGameRules::BAttemptMapVoteRollingMatch()
{
if ( IsManagedMatchEnded() )
{ return false; }
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
return pMatchDesc && GTFGCClientSystem()->CanRequestNewMatchForLobby() && pMatchDesc->BUsesMapVoteAfterMatchEnds();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::BIsManagedMatchEndImminent( void )
{
/*
if ( IsCompetitiveMode() )
{
if ( State_Get() == GR_STATE_RND_RUNNING )
{
bool bPotentiallyTheFinalRound = ( CheckWinLimit( false, 1 ) || CheckMaxRounds( false, 1 ) );
if ( bPotentiallyTheFinalRound )
{
bool bPlayingMiniRounds = ( g_hControlPointMasters.Count() && g_hControlPointMasters[0] && g_hControlPointMasters[0]->PlayingMiniRounds() );
switch( m_nGameType )
{
case TF_GAMETYPE_ESCORT:
{
if ( HasMultipleTrains() )
{
}
else
{
}
}
break;
case TF_GAMETYPE_CP:
break;
case TF_GAMETYPE_CTF:
if ( tf_flag_caps_per_round.GetInt() > 0 )
{
for ( int iTeam = TF_TEAM_RED; iTeam < TF_TEAM_COUNT; iTeam++ )
{
C_TFTeam *pTeam = GetGlobalTFTeam( iTeam );
if ( pTeam )
{
if ( ( tf_flag_caps_per_round.GetInt() - pTeam->GetFlagCaptures() ) <= 1 )
{
CCaptureFlag *pFlag = NULL;
for ( int iFlag = 0; iFlag < ICaptureFlagAutoList::AutoList().Count(); ++iFlag )
{
pFlag = static_cast< CCaptureFlag* >( ICaptureFlagAutoList::AutoList()[iFlag] );
if ( !pFlag->IsDisabled() && ( pFlag->GetTeamNumber() == iTeam ) && !pFlag->IsHome() )
return true;
}
}
}
}
}
break;
default:
break;
}
}
}
}*/
return false;
}
#endif // GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::PowerupTeamImbalance( int nTeam )
{
if ( m_hGamerulesProxy )
{
m_hGamerulesProxy->PowerupTeamImbalance( nTeam );
if ( nTeam == TEAM_UNASSIGNED )
{
m_bPowerupImbalanceMeasuresRunning = false;
}
else
{
m_bPowerupImbalanceMeasuresRunning = true;
m_flTimeToStopImbalanceMeasures = gpGlobals->curtime + m_flTimeToRunImbalanceMeasures;
BroadcastSound( nTeam, "Announcer.Powerup.Volume.Starting" );
CTeamRecipientFilter filter( nTeam, true );
UTIL_ClientPrintFilter( filter, HUD_PRINTCENTER, "#TF_Powerupvolume_Available" );
}
m_nPowerupKillsBlueTeam = 0; // Reset both scores
m_nPowerupKillsRedTeam = 0;
}
}
//-----------------------------------------------------------------------------
// Purpose: Restrict team human players can join
//-----------------------------------------------------------------------------
int CTFGameRules::GetAssignedHumanTeam( void )
{
if ( FStrEq( "blue", mp_humans_must_join_team.GetString() ) )
{
return TF_TEAM_BLUE;
}
else if ( FStrEq( "red", mp_humans_must_join_team.GetString() ) )
{
return TF_TEAM_RED;
}
else if ( FStrEq( "spectator", mp_humans_must_join_team.GetString() ) )
{
return TEAM_SPECTATOR;
}
else
{
return TEAM_ANY;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::HandleSwitchTeams( void )
{
if ( IsPVEModeActive() )
return;
m_bTeamsSwitched.Set( !m_bTeamsSwitched );
// switch this as well
if ( FStrEq( mp_humans_must_join_team.GetString(), "blue" ) )
{
mp_humans_must_join_team.SetValue( "red" );
}
else if ( FStrEq( mp_humans_must_join_team.GetString(), "red" ) )
{
mp_humans_must_join_team.SetValue( "blue" );
}
int i = 0;
// remove everyone's projectiles and objects
RemoveAllProjectilesAndBuildings();
// respawn the players
for ( i = 1 ; i <= gpGlobals->maxClients ; i++ )
{
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( pPlayer )
{
if ( pPlayer->GetTeamNumber() == TF_TEAM_RED )
{
pPlayer->ForceChangeTeam( TF_TEAM_BLUE, true );
}
else if ( pPlayer->GetTeamNumber() == TF_TEAM_BLUE )
{
pPlayer->ForceChangeTeam( TF_TEAM_RED, true );
}
}
}
// switch the team scores
CTFTeam *pRedTeam = GetGlobalTFTeam( TF_TEAM_RED );
CTFTeam *pBlueTeam = GetGlobalTFTeam( TF_TEAM_BLUE );
if ( pRedTeam && pBlueTeam )
{
int nRed = pRedTeam->GetScore();
int nBlue = pBlueTeam->GetScore();
pRedTeam->SetScore( nBlue );
pBlueTeam->SetScore( nRed );
if ( IsInTournamentMode() == true )
{
char szBlueName[16];
char szRedName[16];
Q_strncpy( szBlueName, mp_tournament_blueteamname.GetString(), sizeof ( szBlueName ) );
Q_strncpy( szRedName, mp_tournament_redteamname.GetString(), sizeof ( szRedName ) );
mp_tournament_redteamname.SetValue( szBlueName );
mp_tournament_blueteamname.SetValue( szRedName );
}
}
UTIL_ClientPrintAll( HUD_PRINTTALK, "#TF_TeamsSwitched" );
CMatchInfo *pMatchInfo = GTFGCClientSystem()->GetMatch();
if ( pMatchInfo )
{
CTFPlayerResource *pTFResource = dynamic_cast< CTFPlayerResource* >( g_pPlayerResource );
if ( pTFResource )
{
uint32 unEventTeamStatus = pTFResource->GetEventTeamStatus();
if ( unEventTeamStatus && m_bTeamsSwitched )
{
const uint32 unInvadersArePyro = 1u;
const uint32 unInvadersAreHeavy = 2u;
unEventTeamStatus = ( unEventTeamStatus == unInvadersArePyro ) ? unInvadersAreHeavy : unInvadersArePyro;
}
pMatchInfo->m_unEventTeamStatus = unEventTeamStatus;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::CanChangeClassInStalemate( void )
{
return (gpGlobals->curtime < (m_flStalemateStartTime + tf_stalematechangeclasstime.GetFloat()));
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::CanChangeTeam( int iCurrentTeam ) const
{
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
{
if ( ( iCurrentTeam == TF_TEAM_RED ) || ( iCurrentTeam == TF_TEAM_BLUE ) )
{
return !ArePlayersInHell();
}
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::SetRoundOverlayDetails( void )
{
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
if ( pMaster && pMaster->PlayingMiniRounds() )
{
CTeamControlPointRound *pRound = pMaster->GetCurrentRound();
if ( pRound )
{
CHandle<CTeamControlPoint> pRedPoint = pRound->GetPointOwnedBy( TF_TEAM_RED );
CHandle<CTeamControlPoint> pBluePoint = pRound->GetPointOwnedBy( TF_TEAM_BLUE );
// do we have opposing points in this round?
if ( pRedPoint && pBluePoint )
{
int iMiniRoundMask = ( 1<<pBluePoint->GetPointIndex() ) | ( 1<<pRedPoint->GetPointIndex() );
SetMiniRoundBitMask( iMiniRoundMask );
}
else
{
SetMiniRoundBitMask( 0 );
}
SetCurrentRoundStateBitString();
}
}
BaseClass::SetRoundOverlayDetails();
}
//-----------------------------------------------------------------------------
// Purpose: Returns whether a team should score for each captured point
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldScorePerRound( void )
{
bool bRetVal = true;
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
if ( pMaster && pMaster->ShouldScorePerCapture() )
{
bRetVal = false;
}
return bRetVal;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::IsValveMap( void )
{
char szCurrentMap[MAX_MAP_NAME];
Q_strncpy( szCurrentMap, STRING( gpGlobals->mapname ), sizeof( szCurrentMap ) );
if ( ::IsValveMap( szCurrentMap ) )
{
return true;
}
return BaseClass::IsValveMap();
}
void CTFGameRules::PlayTrainCaptureAlert( CTeamControlPoint *pPoint, bool bFinalPointInMap )
{
if ( !pPoint )
return;
if ( State_Get() != GR_STATE_RND_RUNNING )
return;
const char *pszAlert = TEAM_TRAIN_ALERT;
// is this the final control point in the map?
if ( bFinalPointInMap )
{
pszAlert = TEAM_TRAIN_FINAL_ALERT;
}
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
{
if ( bFinalPointInMap )
{
int iWinningTeam = TEAM_UNASSIGNED;
float flRedProgress = 0.0f, flBlueProgress = 0.0f;
for ( int i = 0 ; i < ITFTeamTrainWatcher::AutoList().Count() ; ++i )
{
CTeamTrainWatcher *pTrainWatcher = static_cast< CTeamTrainWatcher* >( ITFTeamTrainWatcher::AutoList()[i] );
if ( !pTrainWatcher->IsDisabled() )
{
if ( pTrainWatcher->GetTeamNumber() == TF_TEAM_RED )
{
flRedProgress = pTrainWatcher->GetTrainDistanceAlongTrack();
}
else
{
flBlueProgress = pTrainWatcher->GetTrainDistanceAlongTrack();
}
}
}
if ( flRedProgress > flBlueProgress )
{
iWinningTeam = TF_TEAM_RED;
}
else if ( flBlueProgress > flRedProgress )
{
iWinningTeam = TF_TEAM_BLUE;
}
if ( iWinningTeam != TEAM_UNASSIGNED )
{
int iRedLine, iBlueLine;
iRedLine = ( iWinningTeam == TF_TEAM_RED ) ? HELLTOWER_VO_RED_NEAR_WIN : HELLTOWER_VO_RED_NEAR_LOSE;
iBlueLine = ( iWinningTeam == TF_TEAM_BLUE ) ? HELLTOWER_VO_BLUE_NEAR_WIN : HELLTOWER_VO_BLUE_NEAR_LOSE;
PlayHelltowerAnnouncerVO( iRedLine, iBlueLine );
}
}
return;
}
CBroadcastRecipientFilter filter;
pPoint->EmitSound( filter, pPoint->entindex(), pszAlert );
}
#endif // GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFGameRules::GetFarthestOwnedControlPoint( int iTeam, bool bWithSpawnpoints )
{
int iOwnedEnd = ObjectiveResource()->GetBaseControlPointForTeam( iTeam );
if ( iOwnedEnd == -1 )
return -1;
int iNumControlPoints = ObjectiveResource()->GetNumControlPoints();
int iWalk = 1;
int iEnemyEnd = iNumControlPoints-1;
if ( iOwnedEnd != 0 )
{
iWalk = -1;
iEnemyEnd = 0;
}
// Walk towards the other side, and find the farthest owned point that has spawn points
int iFarthestPoint = iOwnedEnd;
for ( int iPoint = iOwnedEnd; iPoint != iEnemyEnd; iPoint += iWalk )
{
// If we've hit a point we don't own, we're done
if ( ObjectiveResource()->GetOwningTeam( iPoint ) != iTeam )
break;
if ( bWithSpawnpoints && !m_bControlSpawnsPerTeam[iTeam][iPoint] )
continue;
iFarthestPoint = iPoint;
}
return iFarthestPoint;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::TeamMayCapturePoint( int iTeam, int iPointIndex )
{
if ( !tf_caplinear.GetBool() )
return true;
// Any previous points necessary?
int iPointNeeded = ObjectiveResource()->GetPreviousPointForPoint( iPointIndex, iTeam, 0 );
// Points set to require themselves are always cappable
if ( iPointNeeded == iPointIndex )
return true;
if ( IsInKothMode() && IsInWaitingForPlayers() )
return false;
// Is the point locked?
if ( ObjectiveResource()->GetCPLocked( iPointIndex ) )
return false;
// No required points specified? Require all previous points.
if ( iPointNeeded == -1 )
{
if ( IsInArenaMode() == true )
{
#ifdef CLIENT_DLL
if ( m_flCapturePointEnableTime - 5.0f <= gpGlobals->curtime && State_Get() == GR_STATE_STALEMATE )
return true;
#endif
if ( m_flCapturePointEnableTime <= gpGlobals->curtime && State_Get() == GR_STATE_STALEMATE )
return true;
return false;
}
if ( !ObjectiveResource()->PlayingMiniRounds() )
{
// No custom previous point, team must own all previous points
int iFarthestPoint = GetFarthestOwnedControlPoint( iTeam, false );
return (abs(iFarthestPoint - iPointIndex) <= 1);
}
else
{
// No custom previous point, team must own all previous points in the current mini-round
//tagES TFTODO: need to figure out a good algorithm for this
return true;
}
}
// Loop through each previous point and see if the team owns it
for ( int iPrevPoint = 0; iPrevPoint < MAX_PREVIOUS_POINTS; iPrevPoint++ )
{
iPointNeeded = ObjectiveResource()->GetPreviousPointForPoint( iPointIndex, iTeam, iPrevPoint );
if ( iPointNeeded != -1 )
{
if ( ObjectiveResource()->GetOwningTeam( iPointNeeded ) != iTeam )
return false;
}
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::PlayerMayCapturePoint( CBasePlayer *pPlayer, int iPointIndex, char *pszReason /* = NULL */, int iMaxReasonLength /* = 0 */ )
{
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
if ( !pTFPlayer )
{
return false;
}
// Disguised and invisible spies cannot capture points
if ( pTFPlayer->m_Shared.IsStealthed() )
{
if ( pszReason )
{
Q_snprintf( pszReason, iMaxReasonLength, "#Cant_cap_stealthed" );
}
return false;
}
if ( ( pTFPlayer->m_Shared.IsInvulnerable() || pTFPlayer->m_Shared.InCond( TF_COND_MEGAHEAL ) ) && !pTFPlayer->m_bInPowerPlay && !IsMannVsMachineMode() )
{
if ( pszReason )
{
Q_snprintf( pszReason, iMaxReasonLength, "#Cant_cap_invuln" );
}
return false;
}
if ( pTFPlayer->m_Shared.InCond( TF_COND_PHASE ) )
{
if ( pszReason )
{
Q_snprintf( pszReason, iMaxReasonLength, "#Cant_cap_invuln" );
}
return false;
}
if ( pTFPlayer->m_Shared.IsControlStunned() )
{
if ( pszReason )
{
Q_snprintf( pszReason, iMaxReasonLength, "#Cant_cap_stunned" );
}
return false;
}
// spies disguised as the enemy team cannot capture points
if ( pTFPlayer->m_Shared.InCond( TF_COND_DISGUISED ) && pTFPlayer->m_Shared.GetDisguiseTeam() != pTFPlayer->GetTeamNumber() )
{
if ( pszReason )
{
Q_snprintf( pszReason, iMaxReasonLength, "#Cant_cap_disguised" );
}
return false;
}
#ifdef GAME_DLL
if ( IsInTraining() && pTFPlayer->IsBotOfType( TF_BOT_TYPE ) )
{
switch( GetGameType() )
{
case TF_GAMETYPE_CP:
{
// in training mode, bots cannot initiate a capture
float flCapPerc = ObjectiveResource()->GetCPCapPercentage( iPointIndex );
if ( flCapPerc <= 0.0f )
{
return false;
}
break;
}
case TF_GAMETYPE_ESCORT:
{
// in training mode, the player must push the cart for the first time
// after that, bots can start it moving again
// assume only one cart in the map
CTeamTrainWatcher *watcher = NULL;
while( ( watcher = dynamic_cast< CTeamTrainWatcher * >( gEntList.FindEntityByClassname( watcher, "team_train_watcher" ) ) ) != NULL )
{
if ( !watcher->IsDisabled() )
{
break;
}
}
if ( watcher && !watcher->IsDisabled() )
{
return !watcher->IsTrainAtStart();
}
break;
}
}
}
#ifdef TF_CREEP_MODE
if ( IsCreepWaveMode() )
{
CTFBot *bot = ToTFBot( pTFPlayer );
if ( !bot || !bot->HasAttribute( CTFBot::IS_NPC ) )
{
// only creeps can capture points
return false;
}
}
#endif
#endif
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::PlayerMayBlockPoint( CBasePlayer *pPlayer, int iPointIndex, char *pszReason, int iMaxReasonLength )
{
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
if ( !pTFPlayer )
return false;
#ifdef GAME_DLL
#ifdef TF_CREEP_MODE
if ( IsCreepWaveMode() )
{
CTFBot *bot = ToTFBot( pTFPlayer );
if ( !bot || !bot->HasAttribute( CTFBot::IS_NPC ) )
{
// only creeps can block points
return false;
}
}
#endif
#endif
// Invuln players can block points
if ( pTFPlayer->m_Shared.IsInvulnerable() )
{
if ( pszReason )
{
Q_snprintf( pszReason, iMaxReasonLength, "#Cant_cap_invuln" );
}
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Calculates score for player
//-----------------------------------------------------------------------------
int CTFGameRules::CalcPlayerScore( RoundStats_t *pRoundStats, CTFPlayer *pPlayer )
{
Assert( pRoundStats );
if ( !pRoundStats )
return 0;
// defensive fix for the moment for bug where healing value becomes bogus sometimes: if bogus, slam it to 0
int iHealing = pRoundStats->m_iStat[TFSTAT_HEALING];
Assert( iHealing >= 0 );
Assert( iHealing <= 10000000 );
if ( iHealing < 0 || iHealing > 10000000 )
{
iHealing = 0;
}
bool bMvM = TFGameRules() && TFGameRules()->IsMannVsMachineMode();
bool bPowerupMode = TFGameRules() && TFGameRules()->IsPowerupMode();
int iScore = ( pRoundStats->m_iStat[TFSTAT_KILLS] * TF_SCORE_KILL ) +
( pRoundStats->m_iStat[TFSTAT_KILLS_RUNECARRIER] * TF_SCORE_KILL_RUNECARRIER ) + // Kill someone who is carrying a rune
( pRoundStats->m_iStat[TFSTAT_CAPTURES] * ( ( bPowerupMode ) ? TF_SCORE_CAPTURE_POWERUPMODE : TF_SCORE_CAPTURE ) ) +
( pRoundStats->m_iStat[TFSTAT_FLAGRETURNS] * TF_SCORE_FLAG_RETURN ) +
( pRoundStats->m_iStat[TFSTAT_DEFENSES] * TF_SCORE_DEFEND ) +
( pRoundStats->m_iStat[TFSTAT_BUILDINGSDESTROYED] * TF_SCORE_DESTROY_BUILDING ) +
( pRoundStats->m_iStat[TFSTAT_HEADSHOTS] / TF_SCORE_HEADSHOT_DIVISOR ) +
( pRoundStats->m_iStat[TFSTAT_BACKSTABS] * TF_SCORE_BACKSTAB ) +
( iHealing / ( ( bMvM ) ? TF_SCORE_DAMAGE : TF_SCORE_HEAL_HEALTHUNITS_PER_POINT ) ) + // MvM values healing more than PvP
( pRoundStats->m_iStat[TFSTAT_KILLASSISTS] / TF_SCORE_KILL_ASSISTS_PER_POINT ) +
( pRoundStats->m_iStat[TFSTAT_TELEPORTS] / TF_SCORE_TELEPORTS_PER_POINT ) +
( pRoundStats->m_iStat[TFSTAT_INVULNS] / TF_SCORE_INVULN ) +
( pRoundStats->m_iStat[TFSTAT_REVENGE] / TF_SCORE_REVENGE ) +
( pRoundStats->m_iStat[TFSTAT_BONUS_POINTS] / TF_SCORE_BONUS_POINT_DIVISOR );
( pRoundStats->m_iStat[TFSTAT_CURRENCY_COLLECTED] / TF_SCORE_CURRENCY_COLLECTED );
if ( pPlayer )
{
int nScoreboardMinigame = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer, nScoreboardMinigame, scoreboard_minigame );
if ( nScoreboardMinigame > 0 )
{
// Increment Score
iScore +=
( pRoundStats->m_iStat[TFSTAT_KILLS] ) +
( pRoundStats->m_iStat[TFSTAT_CAPTURES] ) +
( pRoundStats->m_iStat[TFSTAT_DEFENSES] ) +
( pRoundStats->m_iStat[TFSTAT_BUILDINGSDESTROYED] );
// Subtract Deaths
iScore -= pRoundStats->m_iStat[TFSTAT_DEATHS] * 3;
}
}
// Previously MvM-only
const int nDivisor = ( bMvM ) ? TF_SCORE_DAMAGE : TF_SCORE_HEAL_HEALTHUNITS_PER_POINT;
iScore += ( pRoundStats->m_iStat[TFSTAT_DAMAGE] / nDivisor );
iScore += ( pRoundStats->m_iStat[TFSTAT_DAMAGE_ASSIST] / nDivisor );
iScore += ( pRoundStats->m_iStat[TFSTAT_DAMAGE_BOSS] / nDivisor );
iScore += ( pRoundStats->m_iStat[TFSTAT_HEALING_ASSIST] / nDivisor );
iScore += ( pRoundStats->m_iStat[TFSTAT_DAMAGE_BLOCKED] / nDivisor );
return Max( iScore, 0 );
}
//-----------------------------------------------------------------------------
// Purpose: Calculates score for player
//-----------------------------------------------------------------------------
int CTFGameRules::CalcPlayerSupportScore( RoundStats_t *pRoundStats, int iPlayerIdx )
{
#ifdef GAME_DLL
Assert( pRoundStats );
if ( !pRoundStats )
return 0;
return ( pRoundStats->m_iStat[TFSTAT_DAMAGE_ASSIST] +
pRoundStats->m_iStat[TFSTAT_HEALING_ASSIST] +
pRoundStats->m_iStat[TFSTAT_DAMAGE_BLOCKED] +
( pRoundStats->m_iStat[TFSTAT_BONUS_POINTS] * 25 ) );
#else
Assert( g_TF_PR );
if ( !g_TF_PR )
return 0;
return g_TF_PR->GetDamageAssist( iPlayerIdx ) +
g_TF_PR->GetHealingAssist( iPlayerIdx ) +
g_TF_PR->GetDamageBlocked( iPlayerIdx ) +
( g_TF_PR->GetBonusPoints( iPlayerIdx ) * 25 );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::IsBirthday( void ) const
{
if ( IsX360() )
return false;
return tf_birthday.GetBool() || IsHolidayActive( kHoliday_TFBirthday );
}
bool CTFGameRules::IsBirthdayOrPyroVision( void ) const
{
if ( IsBirthday() )
return true;
#ifdef CLIENT_DLL
// Use birthday fun if the local player has an item that allows them to see it (Pyro Goggles)
if ( IsLocalPlayerUsingVisionFilterFlags( TF_VISION_FILTER_PYRO ) )
{
return true;
}
#endif
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::IsHolidayActive( /*EHoliday*/ int eHoliday ) const
{
//if ( IsPVEModeActive() )
// return false;
return TF_IsHolidayActive( eHoliday );
}
#ifndef GAME_DLL
void CTFGameRules::SetUpVisionFilterKeyValues( void )
{
m_pkvVisionFilterShadersMapWhitelist = new KeyValues( "VisionFilterShadersMapWhitelist" );
m_pkvVisionFilterShadersMapWhitelist->LoadFromFile( g_pFullFileSystem, "cfg/mtp.cfg", "MOD" );
m_pkvVisionFilterTranslations = new KeyValues( "VisionFilterTranslations" );
// **************************************************************************************************
// PARTICLES
KeyValues *pKVBlock = new KeyValues( "particles" );
m_pkvVisionFilterTranslations->AddSubKey( pKVBlock );
// No special vision
KeyValues *pKVFlag = new KeyValues( "0" );
pKVFlag->SetString( "flamethrower_rainbow", "flamethrower" );
pKVFlag->SetString( "flamethrower_rainbow_FP", "flamethrower" );
pKVBlock->AddSubKey( pKVFlag );
// Pyrovision
pKVFlag = new KeyValues( "1" ); //TF_VISION_FILTER_PYRO
pKVFlag->SetString( "flamethrower_rainbow", "flamethrower_rainbow" ); // Rainblower defaults to rainbows and we want to ensure that we use it
pKVFlag->SetString( "flamethrower_rainbow_FP", "flamethrower_rainbow_FP" );
pKVFlag->SetString( "burningplayer_blue", "burningplayer_rainbow_blue" );
pKVFlag->SetString( "burningplayer_red", "burningplayer_rainbow_red" );
pKVFlag->SetString( "burningplayer_corpse", "burningplayer_corpse_rainbow" );
pKVFlag->SetString( "water_blood_impact_red_01", "pyrovision_blood" );
pKVFlag->SetString( "blood_impact_red_01", "pyrovision_blood" );
pKVFlag->SetString( "blood_spray_red_01", "pyrovision_blood" );
pKVFlag->SetString( "blood_spray_red_01_far", "pyrovision_blood" );
pKVFlag->SetString( "ExplosionCore_wall", "pyrovision_explosion" );
pKVFlag->SetString( "ExplosionCore_buildings", "pyrovision_explosion" );
pKVFlag->SetString( "ExplosionCore_MidAir", "pyrovision_explosion" );
pKVFlag->SetString( "rockettrail", "pyrovision_rockettrail" );
pKVFlag->SetString( "rockettrail_!", "pyrovision_rockettrail" );
pKVFlag->SetString( "sentry_rocket", "pyrovision_rockettrail" );
pKVFlag->SetString( "flaregun_trail_blue", "pyrovision_flaregun_trail_blue" );
pKVFlag->SetString( "flaregun_trail_red", "pyrovision_flaregun_trail_red" );
pKVFlag->SetString( "flaregun_trail_crit_blue", "pyrovision_flaregun_trail_crit_blue" );
pKVFlag->SetString( "flaregun_trail_crit_red", "pyrovision_flaregun_trail_crit_red" );
pKVFlag->SetString( "flaregun_destroyed", "pyrovision_flaregun_destroyed" );
pKVFlag->SetString( "scorchshot_trail_blue", "pyrovision_scorchshot_trail_blue" );
pKVFlag->SetString( "scorchshot_trail_red", "pyrovision_scorchshot_trail_red" );
pKVFlag->SetString( "scorchshot_trail_crit_blue", "pyrovision_scorchshot_trail_crit_blue" );
pKVFlag->SetString( "scorchshot_trail_crit_red", "pyrovision_scorchshot_trail_crit_red" );
pKVFlag->SetString( "ExplosionCore_MidAir_Flare", "pyrovision_flaregun_destroyed" );
pKVFlag->SetString( "pyrotaunt_rainbow_norainbow", "pyrotaunt_rainbow" );
pKVFlag->SetString( "pyrotaunt_rainbow_bubbles_flame", "pyrotaunt_rainbow_bubbles" );
pKVFlag->SetString( "v_flaming_arrow", "pyrovision_v_flaming_arrow" );
pKVFlag->SetString( "flaming_arrow", "pyrovision_flaming_arrow" );
pKVFlag->SetString( "flying_flaming_arrow", "pyrovision_flying_flaming_arrow" );
pKVFlag->SetString( "taunt_pyro_balloon", "taunt_pyro_balloon_vision" );
pKVFlag->SetString( "taunt_pyro_balloon_explosion", "taunt_pyro_balloon_explosion_vision" );
pKVBlock->AddSubKey( pKVFlag );
//// Spooky Vision
//pKVFlag = new KeyValues( "2" ); //TF_VISION_FILTER_HALLOWEEN
//pKVBlock->AddSubKey( pKVFlag );
// **************************************************************************************************
// SOUNDS
pKVBlock = new KeyValues( "sounds" );
m_pkvVisionFilterTranslations->AddSubKey( pKVBlock );
// No special vision
pKVFlag = new KeyValues( "0" );
pKVFlag->SetString( "weapons/rainblower/rainblower_start.wav", "weapons/flame_thrower_start.wav" );
pKVFlag->SetString( "weapons/rainblower/rainblower_loop.wav", "weapons/flame_thrower_loop.wav" );
pKVFlag->SetString( "weapons/rainblower/rainblower_end.wav", "weapons/flame_thrower_end.wav" );
pKVFlag->SetString( "weapons/rainblower/rainblower_hit.wav", "weapons/flame_thrower_fire_hit.wav" );
pKVFlag->SetString( "weapons/rainblower/rainblower_pilot.wav", "weapons/flame_thrower_pilot.wav" );
pKVFlag->SetString( ")weapons/rainblower/rainblower_start.wav", ")weapons/flame_thrower_start.wav" );
pKVFlag->SetString( ")weapons/rainblower/rainblower_loop.wav", ")weapons/flame_thrower_loop.wav" );
pKVFlag->SetString( ")weapons/rainblower/rainblower_end.wav", ")weapons/flame_thrower_end.wav" );
pKVFlag->SetString( ")weapons/rainblower/rainblower_hit.wav", ")weapons/flame_thrower_fire_hit.wav" );
pKVFlag->SetString( ")weapons/rainblower/rainblower_pilot.wav", "weapons/flame_thrower_pilot.wav" );
pKVFlag->SetString( "Weapon_Rainblower.Fire", "Weapon_FlameThrower.Fire" );
pKVFlag->SetString( "Weapon_Rainblower.FireLoop", "Weapon_FlameThrower.FireLoop" );
pKVFlag->SetString( "Weapon_Rainblower.WindDown", "Weapon_FlameThrower.WindDown" );
pKVFlag->SetString( "Weapon_Rainblower.FireHit", "Weapon_FlameThrower.FireHit" );
pKVFlag->SetString( "Weapon_Rainblower.PilotLoop", "Weapon_FlameThrower.PilotLoop" );
pKVFlag->SetString( "Taunt.PyroBalloonicorn", "Taunt.PyroHellicorn" );
pKVFlag->SetString( ")items/pyro_music_tube.wav", "common/null.wav" );
pKVBlock->AddSubKey( pKVFlag );
// Pyrovision
pKVFlag = new KeyValues( "1" ); //TF_VISION_FILTER_PYRO
pKVFlag->SetString( "weapons/rainblower/rainblower_start.wav", "weapons/rainblower/rainblower_start.wav" ); // If we're in PyroVision, explicitly set to ensure this is saved
pKVFlag->SetString( "weapons/rainblower/rainblower_loop.wav", "weapons/rainblower/rainblower_loop.wav" );
pKVFlag->SetString( "weapons/rainblower/rainblower_end.wav", "weapons/rainblower/rainblower_end.wav" );
pKVFlag->SetString( "weapons/rainblower/rainblower_hit.wav", "weapons/rainblower/rainblower_hit.wav" );
pKVFlag->SetString( "weapons/rainblower/rainblower_pilot.wav", "weapons/rainblower/rainblower_pilot.wav" );
pKVFlag->SetString( ")weapons/rainblower/rainblower_start.wav", ")weapons/rainblower/rainblower_start.wav" );
pKVFlag->SetString( ")weapons/rainblower/rainblower_loop.wav", ")weapons/rainblower/rainblower_loop.wav" );
pKVFlag->SetString( ")weapons/rainblower/rainblower_end.wav", ")weapons/rainblower/rainblower_end.wav" );
pKVFlag->SetString( ")weapons/rainblower/rainblower_hit.wav", ")weapons/rainblower/rainblower_hit.wav" );
pKVFlag->SetString( ")weapons/rainblower/rainblower_pilot.wav", ")weapons/rainblower/rainblower_pilot.wav" );
pKVFlag->SetString( "Weapon_Rainblower.Fire", "Weapon_Rainblower.Fire" );
pKVFlag->SetString( "Weapon_Rainblower.FireLoop", "Weapon_Rainblower.FireLoop" );
pKVFlag->SetString( "Weapon_Rainblower.WindDown", "Weapon_Rainblower.WindDown" );
pKVFlag->SetString( "Weapon_Rainblower.FireHit", "Weapon_Rainblower.FireHit" );
pKVFlag->SetString( "Weapon_Rainblower.PilotLoop", "Weapon_Rainblower.PilotLoop" );
pKVFlag->SetString( "Taunt.PyroBalloonicorn", "Taunt.PyroBalloonicorn" );
pKVFlag->SetString( ")items/pyro_music_tube.wav", ")items/pyro_music_tube.wav" );
pKVFlag->SetString( "vo/demoman_PainCrticialDeath01.mp3", "vo/demoman_LaughLong01.mp3" );
pKVFlag->SetString( "vo/demoman_PainCrticialDeath02.mp3", "vo/demoman_LaughLong02.mp3" );
pKVFlag->SetString( "vo/demoman_PainCrticialDeath03.mp3", "vo/demoman_LaughLong01.mp3" );
pKVFlag->SetString( "vo/demoman_PainCrticialDeath04.mp3", "vo/demoman_LaughLong02.mp3" );
pKVFlag->SetString( "vo/demoman_PainCrticialDeath05.mp3", "vo/demoman_LaughLong01.mp3" );
pKVFlag->SetString( "vo/demoman_PainSevere01.mp3", "vo/demoman_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/demoman_PainSevere02.mp3", "vo/demoman_LaughHappy02.mp3" );
pKVFlag->SetString( "vo/demoman_PainSevere03.mp3", "vo/demoman_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/demoman_PainSevere04.mp3", "vo/demoman_LaughHappy02.mp3" );
pKVFlag->SetString( "vo/demoman_PainSharp01.mp3", "vo/demoman_LaughShort01.mp3" );
pKVFlag->SetString( "vo/demoman_PainSharp02.mp3", "vo/demoman_LaughShort02.mp3" );
pKVFlag->SetString( "vo/demoman_PainSharp03.mp3", "vo/demoman_LaughShort03.mp3" );
pKVFlag->SetString( "vo/demoman_PainSharp04.mp3", "vo/demoman_LaughShort04.mp3" );
pKVFlag->SetString( "vo/demoman_PainSharp05.mp3", "vo/demoman_LaughShort05.mp3" );
pKVFlag->SetString( "vo/demoman_PainSharp06.mp3", "vo/demoman_LaughShort06.mp3" );
pKVFlag->SetString( "vo/demoman_PainSharp07.mp3", "vo/demoman_LaughShort01.mp3" );
pKVFlag->SetString( "vo/demoman_AutoOnFire01.mp3", "vo/demoman_PositiveVocalization02.mp3" );
pKVFlag->SetString( "vo/demoman_AutoOnFire02.mp3", "vo/demoman_PositiveVocalization03.mp3" );
pKVFlag->SetString( "vo/demoman_AutoOnFire03.mp3", "vo/demoman_PositiveVocalization04.mp3" );
pKVFlag->SetString( "vo/engineer_PainCrticialDeath01.mp3", "vo/engineer_LaughLong01.mp3" );
pKVFlag->SetString( "vo/engineer_PainCrticialDeath02.mp3", "vo/engineer_LaughLong02.mp3" );
pKVFlag->SetString( "vo/engineer_PainCrticialDeath03.mp3", "vo/engineer_LaughLong01.mp3" );
pKVFlag->SetString( "vo/engineer_PainCrticialDeath04.mp3", "vo/engineer_LaughLong02.mp3" );
pKVFlag->SetString( "vo/engineer_PainCrticialDeath05.mp3", "vo/engineer_LaughLong01.mp3" );
pKVFlag->SetString( "vo/engineer_PainCrticialDeath06.mp3", "vo/engineer_LaughLong02.mp3" );
pKVFlag->SetString( "vo/engineer_PainSevere01.mp3", "vo/engineer_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/engineer_PainSevere02.mp3", "vo/engineer_LaughHappy02.mp3" );
pKVFlag->SetString( "vo/engineer_PainSevere03.mp3", "vo/engineer_LaughHappy03.mp3" );
pKVFlag->SetString( "vo/engineer_PainSevere04.mp3", "vo/engineer_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/engineer_PainSevere05.mp3", "vo/engineer_LaughHappy02.mp3" );
pKVFlag->SetString( "vo/engineer_PainSevere06.mp3", "vo/engineer_LaughHappy03.mp3" );
pKVFlag->SetString( "vo/engineer_PainSevere07.mp3", "vo/engineer_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/engineer_PainSharp01.mp3", "vo/engineer_LaughShort01.mp3" );
pKVFlag->SetString( "vo/engineer_PainSharp02.mp3", "vo/engineer_LaughShort02.mp3" );
pKVFlag->SetString( "vo/engineer_PainSharp03.mp3", "vo/engineer_LaughShort03.mp3" );
pKVFlag->SetString( "vo/engineer_PainSharp04.mp3", "vo/engineer_LaughShort04.mp3" );
pKVFlag->SetString( "vo/engineer_PainSharp05.mp3", "vo/engineer_LaughShort01.mp3" );
pKVFlag->SetString( "vo/engineer_PainSharp06.mp3", "vo/engineer_LaughShort02.mp3" );
pKVFlag->SetString( "vo/engineer_PainSharp07.mp3", "vo/engineer_LaughShort03.mp3" );
pKVFlag->SetString( "vo/engineer_PainSharp08.mp3", "vo/engineer_LaughShort04.mp3" );
pKVFlag->SetString( "vo/engineer_AutoOnFire01.mp3", "vo/engineer_PositiveVocalization01.mp3" );
pKVFlag->SetString( "vo/engineer_AutoOnFire02.mp3", "vo/engineer_Cheers01.mp3" );
pKVFlag->SetString( "vo/engineer_AutoOnFire03.mp3", "vo/engineer_Cheers02.mp3" );
pKVFlag->SetString( "vo/heavy_PainCrticialDeath01.mp3", "vo/heavy_LaughLong01.mp3" );
pKVFlag->SetString( "vo/heavy_PainCrticialDeath02.mp3", "vo/heavy_LaughLong02.mp3" );
pKVFlag->SetString( "vo/heavy_PainCrticialDeath03.mp3", "vo/heavy_LaughLong02.mp3" );
pKVFlag->SetString( "vo/heavy_PainSevere01.mp3", "vo/heavy_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/heavy_PainSevere02.mp3", "vo/heavy_LaughHappy02.mp3" );
pKVFlag->SetString( "vo/heavy_PainSevere03.mp3", "vo/heavy_LaughHappy03.mp3" );
pKVFlag->SetString( "vo/heavy_PainSharp01.mp3", "vo/heavy_LaughShort01.mp3" );
pKVFlag->SetString( "vo/heavy_PainSharp02.mp3", "vo/heavy_LaughShort02.mp3" );
pKVFlag->SetString( "vo/heavy_PainSharp03.mp3", "vo/heavy_LaughShort03.mp3" );
pKVFlag->SetString( "vo/heavy_PainSharp04.mp3", "vo/heavy_LaughShort01.mp3" );
pKVFlag->SetString( "vo/heavy_PainSharp05.mp3", "vo/heavy_LaughShort02.mp3" );
pKVFlag->SetString( "vo/heavy_AutoOnFire01.mp3", "vo/heavy_PositiveVocalization01.mp3" );
pKVFlag->SetString( "vo/heavy_AutoOnFire02.mp3", "vo/heavy_PositiveVocalization02.mp3" );
pKVFlag->SetString( "vo/heavy_AutoOnFire03.mp3", "vo/heavy_PositiveVocalization03.mp3" );
pKVFlag->SetString( "vo/heavy_AutoOnFire04.mp3", "vo/heavy_PositiveVocalization04.mp3" );
pKVFlag->SetString( "vo/heavy_AutoOnFire05.mp3", "vo/heavy_PositiveVocalization05.mp3" );
pKVFlag->SetString( "vo/medic_PainCrticialDeath01.mp3", "vo/medic_LaughLong01.mp3" );
pKVFlag->SetString( "vo/medic_PainCrticialDeath02.mp3", "vo/medic_LaughLong02.mp3" );
pKVFlag->SetString( "vo/medic_PainCrticialDeath03.mp3", "vo/medic_LaughLong01.mp3" );
pKVFlag->SetString( "vo/medic_PainCrticialDeath04.mp3", "vo/medic_LaughLong02.mp3" );
pKVFlag->SetString( "vo/medic_PainSevere01.mp3", "vo/medic_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/medic_PainSevere02.mp3", "vo/medic_LaughHappy02.mp3" );
pKVFlag->SetString( "vo/medic_PainSevere03.mp3", "vo/medic_LaughHappy03.mp3" );
pKVFlag->SetString( "vo/medic_PainSevere04.mp3", "vo/medic_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/medic_PainSharp01.mp3", "vo/medic_LaughShort01.mp3" );
pKVFlag->SetString( "vo/medic_PainSharp02.mp3", "vo/medic_LaughShort02.mp3" );
pKVFlag->SetString( "vo/medic_PainSharp03.mp3", "vo/medic_LaughShort03.mp3" );
pKVFlag->SetString( "vo/medic_PainSharp04.mp3", "vo/medic_LaughShort01.mp3" );
pKVFlag->SetString( "vo/medic_PainSharp05.mp3", "vo/medic_LaughShort02.mp3" );
pKVFlag->SetString( "vo/medic_PainSharp06.mp3", "vo/medic_LaughShort03.mp3" );
pKVFlag->SetString( "vo/medic_PainSharp07.mp3", "vo/medic_LaughShort01.mp3" );
pKVFlag->SetString( "vo/medic_PainSharp08.mp3", "vo/medic_LaughShort02.mp3" );
pKVFlag->SetString( "vo/medic_AutoOnFire01.mp3", "vo/medic_PositiveVocalization01.mp3" );
pKVFlag->SetString( "vo/medic_AutoOnFire02.mp3", "vo/medic_PositiveVocalization02.mp3" );
pKVFlag->SetString( "vo/medic_AutoOnFire03.mp3", "vo/medic_PositiveVocalization03.mp3" );
pKVFlag->SetString( "vo/medic_AutoOnFire04.mp3", "vo/medic_PositiveVocalization04.mp3" );
pKVFlag->SetString( "vo/medic_AutoOnFire05.mp3", "vo/medic_PositiveVocalization05.mp3" );
pKVFlag->SetString( "vo/pyro_PainCrticialDeath01.mp3", "vo/pyro_LaughLong01.mp3" );
pKVFlag->SetString( "vo/pyro_PainCrticialDeath02.mp3", "vo/pyro_LaughLong01.mp3" );
pKVFlag->SetString( "vo/pyro_PainCrticialDeath03.mp3", "vo/pyro_LaughLong01.mp3" );
pKVFlag->SetString( "vo/pyro_PainSevere01.mp3", "vo/pyro_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/pyro_PainSevere02.mp3", "vo/pyro_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/pyro_PainSevere03.mp3", "vo/pyro_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/pyro_PainSevere04.mp3", "vo/pyro_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/pyro_PainSevere05.mp3", "vo/pyro_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/pyro_PainSevere06.mp3", "vo/pyro_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/pyro_AutoOnFire01.mp3", "vo/pyro_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/pyro_AutoOnFire02.mp3", "vo/pyro_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/scout_PainCrticialDeath01.mp3", "vo/scout_LaughLong01.mp3" );
pKVFlag->SetString( "vo/scout_PainCrticialDeath02.mp3", "vo/scout_LaughLong02.mp3" );
pKVFlag->SetString( "vo/scout_PainCrticialDeath03.mp3", "vo/scout_LaughLong01.mp3" );
pKVFlag->SetString( "vo/scout_PainSevere01.mp3", "vo/scout_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/scout_PainSevere02.mp3", "vo/scout_LaughHappy02.mp3" );
pKVFlag->SetString( "vo/scout_PainSevere03.mp3", "vo/scout_LaughHappy03.mp3" );
pKVFlag->SetString( "vo/scout_PainSevere04.mp3", "vo/scout_LaughHappy04.mp3" );
pKVFlag->SetString( "vo/scout_PainSevere05.mp3", "vo/scout_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/scout_PainSevere06.mp3", "vo/scout_LaughHappy02.mp3" );
pKVFlag->SetString( "vo/scout_PainSharp01.mp3", "vo/scout_LaughShort01.mp3" );
pKVFlag->SetString( "vo/scout_PainSharp02.mp3", "vo/scout_LaughShort02.mp3" );
pKVFlag->SetString( "vo/scout_PainSharp03.mp3", "vo/scout_LaughShort03.mp3" );
pKVFlag->SetString( "vo/scout_PainSharp04.mp3", "vo/scout_LaughShort04.mp3" );
pKVFlag->SetString( "vo/scout_PainSharp05.mp3", "vo/scout_LaughShort05.mp3" );
pKVFlag->SetString( "vo/scout_PainSharp06.mp3", "vo/scout_LaughShort01.mp3" );
pKVFlag->SetString( "vo/scout_PainSharp07.mp3", "vo/scout_LaughShort02.mp3" );
pKVFlag->SetString( "vo/scout_PainSharp08.mp3", "vo/scout_LaughShort03.mp3" );
pKVFlag->SetString( "vo/scout_AutoOnFire01.mp3", "vo/scout_PositiveVocalization02.mp3" );
pKVFlag->SetString( "vo/scout_AutoOnFire02.mp3", "vo/scout_PositiveVocalization03.mp3" );
pKVFlag->SetString( "vo/sniper_PainCrticialDeath01.mp3", "vo/sniper_LaughLong01.mp3" );
pKVFlag->SetString( "vo/sniper_PainCrticialDeath02.mp3", "vo/sniper_LaughLong02.mp3" );
pKVFlag->SetString( "vo/sniper_PainCrticialDeath03.mp3", "vo/sniper_LaughLong01.mp3" );
pKVFlag->SetString( "vo/sniper_PainCrticialDeath04.mp3", "vo/sniper_LaughLong02.mp3" );
pKVFlag->SetString( "vo/sniper_PainSevere01.mp3", "vo/sniper_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/sniper_PainSevere02.mp3", "vo/sniper_LaughHappy02.mp3" );
pKVFlag->SetString( "vo/sniper_PainSevere03.mp3", "vo/sniper_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/sniper_PainSevere04.mp3", "vo/sniper_LaughHappy02.mp3" );
pKVFlag->SetString( "vo/sniper_PainSharp01.mp3", "vo/sniper_LaughShort01.mp3" );
pKVFlag->SetString( "vo/sniper_PainSharp02.mp3", "vo/sniper_LaughShort02.mp3" );
pKVFlag->SetString( "vo/sniper_PainSharp03.mp3", "vo/sniper_LaughShort03.mp3" );
pKVFlag->SetString( "vo/sniper_PainSharp04.mp3", "vo/sniper_LaughShort04.mp3" );
pKVFlag->SetString( "vo/sniper_AutoOnFire01.mp3", "vo/sniper_PositiveVocalization02.mp3" );
pKVFlag->SetString( "vo/sniper_AutoOnFire02.mp3", "vo/sniper_PositiveVocalization03.mp3" );
pKVFlag->SetString( "vo/sniper_AutoOnFire03.mp3", "vo/sniper_PositiveVocalization05.mp3" );
pKVFlag->SetString( "vo/soldier_PainCrticialDeath01.mp3", "vo/soldier_LaughLong01.mp3" );
pKVFlag->SetString( "vo/soldier_PainCrticialDeath02.mp3", "vo/soldier_LaughLong02.mp3" );
pKVFlag->SetString( "vo/soldier_PainCrticialDeath03.mp3", "vo/soldier_LaughLong03.mp3" );
pKVFlag->SetString( "vo/soldier_PainCrticialDeath04.mp3", "vo/soldier_LaughLong01.mp3" );
pKVFlag->SetString( "vo/soldier_PainSevere01.mp3", "vo/soldier_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/soldier_PainSevere02.mp3", "vo/soldier_LaughHappy02.mp3" );
pKVFlag->SetString( "vo/soldier_PainSevere03.mp3", "vo/soldier_LaughHappy03.mp3" );
pKVFlag->SetString( "vo/soldier_PainSevere04.mp3", "vo/soldier_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/soldier_PainSevere05.mp3", "vo/soldier_LaughHappy02.mp3" );
pKVFlag->SetString( "vo/soldier_PainSevere06.mp3", "vo/soldier_LaughHappy03.mp3" );
pKVFlag->SetString( "vo/soldier_PainSharp01.mp3", "vo/soldier_LaughShort01.mp3" );
pKVFlag->SetString( "vo/soldier_PainSharp02.mp3", "vo/soldier_LaughShort02.mp3" );
pKVFlag->SetString( "vo/soldier_PainSharp03.mp3", "vo/soldier_LaughShort03.mp3" );
pKVFlag->SetString( "vo/soldier_PainSharp04.mp3", "vo/soldier_LaughShort04.mp3" );
pKVFlag->SetString( "vo/soldier_PainSharp05.mp3", "vo/soldier_LaughShort01.mp3" );
pKVFlag->SetString( "vo/soldier_PainSharp06.mp3", "vo/soldier_LaughShort02.mp3" );
pKVFlag->SetString( "vo/soldier_PainSharp07.mp3", "vo/soldier_LaughShort03.mp3" );
pKVFlag->SetString( "vo/soldier_PainSharp08.mp3", "vo/soldier_LaughShort04.mp3" );
pKVFlag->SetString( "vo/soldier_AutoOnFire01.mp3", "vo/soldier_PositiveVocalization01.mp3" );
pKVFlag->SetString( "vo/soldier_AutoOnFire02.mp3", "vo/soldier_PositiveVocalization02.mp3" );
pKVFlag->SetString( "vo/soldier_AutoOnFire03.mp3", "vo/soldier_PositiveVocalization03.mp3" );
pKVFlag->SetString( "vo/spy_PainCrticialDeath01.mp3", "vo/spy_LaughLong01.mp3" );
pKVFlag->SetString( "vo/spy_PainCrticialDeath02.mp3", "vo/spy_LaughLong01.mp3" );
pKVFlag->SetString( "vo/spy_PainCrticialDeath03.mp3", "vo/spy_LaughLong01.mp3" );
pKVFlag->SetString( "vo/spy_PainSevere01.mp3", "vo/spy_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/spy_PainSevere02.mp3", "vo/spy_LaughHappy02.mp3" );
pKVFlag->SetString( "vo/spy_PainSevere03.mp3", "vo/spy_LaughHappy03.mp3" );
pKVFlag->SetString( "vo/spy_PainSevere04.mp3", "vo/spy_LaughHappy01.mp3" );
pKVFlag->SetString( "vo/spy_PainSevere05.mp3", "vo/spy_LaughHappy02.mp3" );
pKVFlag->SetString( "vo/spy_PainSharp01.mp3", "vo/spy_LaughShort01.mp3" );
pKVFlag->SetString( "vo/spy_PainSharp02.mp3", "vo/spy_LaughShort02.mp3" );
pKVFlag->SetString( "vo/spy_PainSharp03.mp3", "vo/spy_LaughShort03.mp3" );
pKVFlag->SetString( "vo/spy_PainSharp04.mp3", "vo/spy_LaughShort04.mp3" );
pKVFlag->SetString( "vo/spy_AutoOnFire01.mp3", "vo/spy_PositiveVocalization02.mp3" );
pKVFlag->SetString( "vo/spy_AutoOnFire02.mp3", "vo/spy_PositiveVocalization04.mp3" );
pKVFlag->SetString( "vo/spy_AutoOnFire03.mp3", "vo/spy_PositiveVocalization05.mp3" );
pKVBlock->AddSubKey( pKVFlag );
// Spooky Vision
//pKVFlag = new KeyValues( "2" ); // TF_VISION_FILTER_HALLOWEEN
//pKVBlock->AddSubKey( pKVFlag );
// **************************************************************************************************
// WEAPONS
pKVBlock = new KeyValues( "weapons" );
m_pkvVisionFilterTranslations->AddSubKey( pKVBlock );
// No special vision
pKVFlag = new KeyValues( "0" );
pKVFlag->SetString( "models/weapons/c_models/c_rainblower/c_rainblower.mdl", "models/weapons/c_models/c_flamethrower/c_flamethrower.mdl" );
pKVFlag->SetString( "models/weapons/c_models/c_lollichop/c_lollichop.mdl", "models/weapons/w_models/w_fireaxe.mdl" );
pKVBlock->AddSubKey( pKVFlag );
// Pyrovision
pKVFlag = new KeyValues( "1" );
pKVFlag->SetString( "models/weapons/c_models/c_rainblower/c_rainblower.mdl", "models/weapons/c_models/c_rainblower/c_rainblower.mdl" ); //explicit set for pyrovision
pKVFlag->SetString( "models/weapons/c_models/c_lollichop/c_lollichop.mdl", "models/weapons/c_models/c_lollichop/c_lollichop.mdl" );
pKVFlag->SetString( "models/player/items/demo/demo_bombs.mdl", "models/player/items/all_class/mtp_bottle_demo.mdl" );
pKVFlag->SetString( "models/player/items/pyro/xms_pyro_bells.mdl", "models/player/items/all_class/mtp_bottle_pyro.mdl" );
pKVFlag->SetString( "models/player/items/soldier/ds_can_grenades.mdl", "models/player/items/all_class/mtp_bottle_soldier.mdl" );
pKVBlock->AddSubKey( pKVFlag );
// Spooky Vision
//pKVFlag = new KeyValues( "2" );
//pKVBlock->AddSubKey( pKVFlag );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::UseSillyGibs( void )
{
// Use silly gibs if the local player has an item that allows them to see it (Pyro Goggles)
if ( IsLocalPlayerUsingVisionFilterFlags( TF_VISION_FILTER_PYRO ) )
return true;
if ( UTIL_IsLowViolence() )
return true;
return m_bSillyGibs;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::AllowWeatherParticles( void )
{
return ( tf_particles_disable_weather.GetBool() == false );
}
bool CTFGameRules::AllowMapVisionFilterShaders( void )
{
if ( !m_pkvVisionFilterShadersMapWhitelist )
return false;
const char *pMapName = engine->GetLevelName();
while ( pMapName && pMapName[ 0 ] != '\\' && pMapName[ 0 ] != '/' )
{
pMapName++;
}
if ( !pMapName )
return false;
pMapName++;
return m_pkvVisionFilterShadersMapWhitelist->GetInt( pMapName, 0 ) != 0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char* CTFGameRules::TranslateEffectForVisionFilter( const char *pchEffectType, const char *pchEffectName )
{
if ( !pchEffectType || !pchEffectName )
{
return pchEffectName;
}
CUtlVector<const char *> vecNames;
vecNames.AddToTail( pchEffectName );
// Swap the effect if the local player has an item that allows them to see it (Pyro Goggles)
bool bWeaponsOnly = FStrEq( pchEffectType, "weapons" );
int nVisionOptInFlags = GetLocalPlayerVisionFilterFlags( bWeaponsOnly );
KeyValues *pkvParticles = m_pkvVisionFilterTranslations->FindKey( pchEffectType );
if ( pkvParticles )
{
for ( KeyValues *pkvFlag = pkvParticles->GetFirstTrueSubKey(); pkvFlag != NULL; pkvFlag = pkvFlag->GetNextTrueSubKey() )
{
int nFlag = atoi( pkvFlag->GetName() );
// Grab any potential translations for this item
// Always grab default (No vision) names if they exist
if ( ( nVisionOptInFlags & nFlag ) != 0 || nFlag == 0 )
{
// We either have this vision flag or we have no flags and this is the no flag block
const char *pchTranslatedString = pkvFlag->GetString( pchEffectName, NULL );
if ( pchTranslatedString )
{
vecNames.AddToHead( pchTranslatedString );
}
}
}
}
// Return the top item in the list. Currently Halloween replacements would out prioritize Pyrovision if there is any overlap
return vecNames.Head();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::ModifySentChat( char *pBuf, int iBufSize )
{
if ( IsInMedievalMode() && tf_medieval_autorp.GetBool() && english.GetBool() )
{
AutoRP()->ApplyRPTo( pBuf, iBufSize );
}
// replace all " with ' to prevent exploits related to chat text
// example: ";exit
for ( char *ch = pBuf; *ch != 0; ch++ )
{
if ( *ch == '"' )
{
*ch = '\'';
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::AllowMapParticleEffect( const char *pszParticleEffect )
{
static const char *s_WeatherEffects[] =
{
"tf_gamerules",
"env_rain_001",
"env_rain_002_256",
"env_rain_ripples",
"env_snow_light_001",
"env_rain_gutterdrip",
"env_rain_guttersplash",
"", // END Marker
};
if ( !AllowWeatherParticles() )
{
if ( FindInList( s_WeatherEffects, pszParticleEffect ) )
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::GetTeamGlowColor( int nTeam, float &r, float &g, float &b )
{
if ( nTeam == TF_TEAM_RED )
{
r = 0.74f;
g = 0.23f;
b = 0.23f;
}
else if ( nTeam == TF_TEAM_BLUE )
{
r = 0.49f;
g = 0.66f;
b = 0.77f;
}
else
{
r = 0.76f;
g = 0.76f;
b = 0.76f;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldConfirmOnDisconnect()
{
// Add any game mode which uses matchmaking here. Note that the disconnect dialog checks if it should be showing abandons and such.
return ( IsMannVsMachineMode() && GTFGCClientSystem()->GetSearchPlayForBraggingRights() ) ||
( IsCompetitiveMode() && GTFGCClientSystem()->GetLobby() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldShowPreRoundDoors() const
{
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
if ( pMatchDesc )
{
return pMatchDesc->m_params.m_bShowPreRoundDoors;
}
return false;
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFGameRules::GetClassLimit( int iClass )
{
if ( IsInTournamentMode() || IsPasstimeMode() )
{
switch ( iClass )
{
case TF_CLASS_SCOUT: return tf_tournament_classlimit_scout.GetInt(); break;
case TF_CLASS_SNIPER: return tf_tournament_classlimit_sniper.GetInt(); break;
case TF_CLASS_SOLDIER: return tf_tournament_classlimit_soldier.GetInt(); break;
case TF_CLASS_DEMOMAN: return tf_tournament_classlimit_demoman.GetInt(); break;
case TF_CLASS_MEDIC: return tf_tournament_classlimit_medic.GetInt(); break;
case TF_CLASS_HEAVYWEAPONS: return tf_tournament_classlimit_heavy.GetInt(); break;
case TF_CLASS_PYRO: return tf_tournament_classlimit_pyro.GetInt(); break;
case TF_CLASS_SPY: return tf_tournament_classlimit_spy.GetInt(); break;
case TF_CLASS_ENGINEER: return tf_tournament_classlimit_engineer.GetInt(); break;
default:
break;
}
}
else if ( IsInHighlanderMode() )
{
return 1;
}
else if ( tf_classlimit.GetInt() )
{
return tf_classlimit.GetInt();
}
return NO_CLASS_LIMIT;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::CanPlayerChooseClass( CBasePlayer *pPlayer, int iClass )
{
int iClassLimit = GetClassLimit( iClass );
#ifdef TF_RAID_MODE
if ( IsRaidMode() && !pPlayer->IsBot() )
{
// bots are exempt from class limits, to allow for additional support bot "friends"
if ( pPlayer->GetTeamNumber() == TF_TEAM_BLUE )
{
if ( tf_raid_allow_all_classes.GetBool() == false )
{
if ( iClass == TF_CLASS_SCOUT )
return false;
if ( iClass == TF_CLASS_SPY )
return false;
}
if ( tf_raid_enforce_unique_classes.GetBool() )
{
// only one of each class on the raiding team
iClassLimit = 1;
}
}
}
else if ( IsBossBattleMode() )
{
return true;
}
else
#endif // TF_RAID_MODE
if ( iClassLimit == NO_CLASS_LIMIT )
return true;
if ( pPlayer->GetTeamNumber() != TF_TEAM_BLUE && pPlayer->GetTeamNumber() != TF_TEAM_RED )
return true;
#ifdef GAME_DLL
CTFTeam *pTeam = assert_cast<CTFTeam*>(pPlayer->GetTeam());
#else
C_TFTeam *pTeam = assert_cast<C_TFTeam*>(pPlayer->GetTeam());
#endif
if ( !pTeam )
return true;
int iTeamClassCount = 0;
for ( int iPlayer = 0; iPlayer < pTeam->GetNumPlayers(); iPlayer++ )
{
CTFPlayer *pTFPlayer = ToTFPlayer( pTeam->GetPlayer( iPlayer ) );
if ( pTFPlayer && pTFPlayer != pPlayer && pTFPlayer->GetPlayerClass()->GetClassIndex() == iClass )
{
iTeamClassCount++;
}
}
return ( iTeamClassCount < iClassLimit );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldBalanceTeams( void )
{
// never autobalance the teams for managed matches using the old system
if ( GetMatchGroupDescription( GetCurrentMatchGroup() ) )
return false;
bool bDisableBalancing = false;
#ifdef STAGING_ONLY
bDisableBalancing = IsBountyMode();
#endif // STAGING_ONLY
if ( IsPVEModeActive() || bDisableBalancing )
return false;
// don't balance the teams while players are in hell
if ( ArePlayersInHell() )
return false;
return BaseClass::ShouldBalanceTeams();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFGameRules::GetBonusRoundTime( bool bGameOver /* = false*/ )
{
if ( IsMannVsMachineMode() )
{
return 5;
}
else if ( IsCompetitiveMode() && bGameOver )
{
if ( IsMatchTypeCompetitive() )
{
return 5;
}
}
return BaseClass::GetBonusRoundTime( bGameOver );
}
#ifdef GAME_DLL
bool CTFGameRules::CanBotChangeClass( CBasePlayer* pPlayer )
{
// if there's a roster for this bot's team, check to see if the level designer has allowed the bot to change class
// used when the bot dies and wants to see if it can change class
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
if ( pTFPlayer && pTFPlayer->GetPlayerClass() && pTFPlayer->GetPlayerClass()->GetClassIndex() != TF_CLASS_UNDEFINED )
{
switch ( pPlayer->GetTeamNumber() )
{
case TF_TEAM_RED: return m_hRedBotRoster ? m_hRedBotRoster->IsClassChangeAllowed() : true; break;
case TF_TEAM_BLUE: return m_hBlueBotRoster ? m_hBlueBotRoster->IsClassChangeAllowed() : true; break;
}
}
return true;
}
bool CTFGameRules::CanBotChooseClass( CBasePlayer *pPlayer, int iClass )
{
// if there's a roster for this bot's team, then check to see if the class the bot has requested is allowed by the roster
bool bCanChooseClass = CanPlayerChooseClass( pPlayer, iClass );
if ( bCanChooseClass )
{
// now check rosters...
switch ( pPlayer->GetTeamNumber() )
{
case TF_TEAM_RED:
bCanChooseClass = m_hRedBotRoster ? m_hRedBotRoster->IsClassAllowed( iClass ) : true;
break;
case TF_TEAM_BLUE:
bCanChooseClass = m_hBlueBotRoster ? m_hBlueBotRoster->IsClassAllowed( iClass ) : true;
break;
default:
// no roster - spectator team
bCanChooseClass = true;
break;
}
}
return bCanChooseClass;
}
//-----------------------------------------------------------------------------
// Populate vector with set of control points the player needs to capture
void CTFGameRules::CollectCapturePoints( CBasePlayer *player, CUtlVector< CTeamControlPoint * > *captureVector ) const
{
if ( !captureVector )
return;
captureVector->RemoveAll();
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
if ( pMaster )
{
// special case hack for KotH mode to use control points that are locked at the start of the round
if ( IsInKothMode() && pMaster->GetNumPoints() == 1 )
{
captureVector->AddToTail( pMaster->GetControlPoint( 0 ) );
return;
}
for( int i=0; i<pMaster->GetNumPoints(); ++i )
{
CTeamControlPoint *point = pMaster->GetControlPoint( i );
if ( point && pMaster->IsInRound( point ) )
{
if ( ObjectiveResource()->GetOwningTeam( point->GetPointIndex() ) == player->GetTeamNumber() )
continue;
if ( player && player->IsBot() && point->ShouldBotsIgnore() )
continue;
if ( ObjectiveResource()->TeamCanCapPoint( point->GetPointIndex(), player->GetTeamNumber() ) )
{
if ( TeamplayGameRules()->TeamMayCapturePoint( player->GetTeamNumber(), point->GetPointIndex() ) )
{
// unlocked point not on our team available to capture
captureVector->AddToTail( point );
}
}
}
}
}
}
//-----------------------------------------------------------------------------
// Populate vector with set of control points the player needs to defend from capture
void CTFGameRules::CollectDefendPoints( CBasePlayer *player, CUtlVector< CTeamControlPoint * > *defendVector ) const
{
if ( !defendVector )
return;
defendVector->RemoveAll();
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
if ( pMaster )
{
for( int i=0; i<pMaster->GetNumPoints(); ++i )
{
CTeamControlPoint *point = pMaster->GetControlPoint( i );
if ( point && pMaster->IsInRound( point ) )
{
if ( ObjectiveResource()->GetOwningTeam( point->GetPointIndex() ) != player->GetTeamNumber() )
continue;
if ( player && player->IsBot() && point->ShouldBotsIgnore() )
continue;
if ( ObjectiveResource()->TeamCanCapPoint( point->GetPointIndex(), GetEnemyTeam( player->GetTeamNumber() ) ) )
{
if ( TeamplayGameRules()->TeamMayCapturePoint( GetEnemyTeam( player->GetTeamNumber() ), point->GetPointIndex() ) )
{
// unlocked point on our team vulnerable to capture
defendVector->AddToTail( point );
}
}
}
}
}
}
//-----------------------------------------------------------------------------
CObjectSentrygun *CTFGameRules::FindSentryGunWithMostKills( int team ) const
{
CObjectSentrygun *dangerousSentry = NULL;
int dangerousSentryKills = -1;
for ( int i=0; i<IBaseObjectAutoList::AutoList().Count(); ++i )
{
CBaseObject *pObj = static_cast< CBaseObject* >( IBaseObjectAutoList::AutoList()[i] );
if ( pObj->ObjectType() == OBJ_SENTRYGUN && pObj->GetTeamNumber() == team && pObj->GetKills() >= dangerousSentryKills )
{
dangerousSentryKills = pObj->GetKills();
dangerousSentry = static_cast<CObjectSentrygun *>( pObj );
}
}
return dangerousSentry;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::ClientConnected( edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen )
{
if ( IsMannVsMachineMode() )
{
int nCount = 0;
CTFPlayer *pPlayer;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( !pPlayer || pPlayer->IsFakeClient() )
continue;
nCount++;
}
if ( nCount >= kMVM_MaxConnectedPlayers )
return false;
}
bool bRet = BaseClass::ClientConnected( pEntity, pszName, pszAddress, reject, maxrejectlen );
if ( bRet )
{
const CSteamID *steamID = engine->GetClientSteamID( pEntity );
if ( steamID && steamID->IsValid() )
{
// Invalid steamIDs wont be known to the GC system, but it has a SteamIDAllowedToConnect() hook that would
// allow it to reject the connect in the first place in a matchmaking scenario where cares.
GTFGCClientSystem()->ClientConnected( *steamID, pEntity );
}
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldMakeChristmasAmmoPack( void )
{
if ( IsInTournamentMode() && !IsMatchTypeCasual() )
return false;
if ( IsMannVsMachineMode() )
return false;
if ( mp_holiday_nogifts.GetBool() == true )
return false;
if ( IsHolidayActive( kHoliday_Christmas ) == false )
return false;
return ( RandomInt( 0, 100 ) < 10 );
}
//-----------------------------------------------------------------------------
// Purpose: **** DO NOT SHIP THIS IN REL/HL2 ****
//-----------------------------------------------------------------------------
void CTFGameRules::UpdatePeriodicEvent( CTFPlayer *pPlayer, eEconPeriodicScoreEvents eEvent, uint32 nCount )
{
CSteamID steamID;
if ( !pPlayer || !pPlayer->GetSteamID( &steamID ) || !steamID.IsValid() )
return;
GCSDK::CProtoBufMsg<CMsgUpdatePeriodicEvent> msg( k_EMsgGC_UpdatePeriodicEvent );
msg.Body().set_account_id( steamID.GetAccountID() );
msg.Body().set_event_type( eEvent );
msg.Body().set_amount( nCount );
GCClientSystem()->BSendMessage( msg );
}
#endif // GAME_DLL
#ifndef CLIENT_DLL
void CTFGameRules::Status( void (*print) (const char *fmt, ...) )
{
// print( "Total Time: %d seconds\n", CTF_GameStats.m_currentMap.m_Header.m_iTotalTime );
// priprint( "Blue Team Wins: %d\n", CTF_GameStats.m_currentMap.m_Header.m_iBlueWins );
// priprint( "Red Team Wins: %d\n", CTF_GameStats.m_currentMap.m_Header.m_iRedWins );
// priprint( "Stalemates: %d\n", CTF_GameStats.m_currentMap.m_Header.m_iStalemates );
print( " Spawns Points Kills Deaths Assists\n" );
for ( int iClass = TF_FIRST_NORMAL_CLASS; iClass < TF_LAST_NORMAL_CLASS; iClass++ )
{
TF_Gamestats_ClassStats_t &Stats = CTF_GameStats.m_currentMap.m_aClassStats[ iClass ];
print( "%-8s %6d %6d %5d %6d %7d\n",
g_aPlayerClassNames_NonLocalized[ iClass ],
Stats.iSpawns, Stats.iScore, Stats.iKills, Stats.iDeaths, Stats.iAssists );
}
print( "\n" );
}
#endif // !CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldCollide( int collisionGroup0, int collisionGroup1 )
{
if ( collisionGroup0 > collisionGroup1 )
{
// swap so that lowest is always first
::V_swap( collisionGroup0, collisionGroup1 );
}
//Don't stand on COLLISION_GROUP_WEAPONs
if( collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT &&
collisionGroup1 == COLLISION_GROUP_WEAPON )
{
return false;
}
// Don't stand on projectiles
if( collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT &&
collisionGroup1 == COLLISION_GROUP_PROJECTILE )
{
return false;
}
// Rockets need to collide with players when they hit, but
// be ignored by player movement checks
if ( ( collisionGroup0 == COLLISION_GROUP_PLAYER ) &&
( collisionGroup1 == TFCOLLISION_GROUP_ROCKETS || collisionGroup1 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) )
return true;
if ( ( collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT ) &&
( collisionGroup1 == TFCOLLISION_GROUP_ROCKETS || collisionGroup1 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) )
return false;
if ( ( collisionGroup0 == COLLISION_GROUP_WEAPON ) &&
( collisionGroup1 == TFCOLLISION_GROUP_ROCKETS || collisionGroup1 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) )
return false;
if ( ( collisionGroup0 == TF_COLLISIONGROUP_GRENADES ) &&
( collisionGroup1 == TFCOLLISION_GROUP_ROCKETS || collisionGroup1 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) )
return false;
if ( ( collisionGroup0 == COLLISION_GROUP_PROJECTILE ) &&
( collisionGroup1 == TFCOLLISION_GROUP_ROCKETS || collisionGroup1 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) )
return false;
if ( ( collisionGroup0 == TFCOLLISION_GROUP_ROCKETS ) &&
( collisionGroup1 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) )
return false;
if ( ( collisionGroup0 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) &&
( collisionGroup1 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) )
return false;
// Grenades don't collide with players. They handle collision while flying around manually.
if ( ( collisionGroup0 == COLLISION_GROUP_PLAYER ) &&
( collisionGroup1 == TF_COLLISIONGROUP_GRENADES ) )
return false;
if ( ( collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT ) &&
( collisionGroup1 == TF_COLLISIONGROUP_GRENADES ) )
return false;
// Respawn rooms only collide with players
if ( collisionGroup1 == TFCOLLISION_GROUP_RESPAWNROOMS )
return ( collisionGroup0 == COLLISION_GROUP_PLAYER ) || ( collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT );
/* if ( collisionGroup0 == COLLISION_GROUP_PLAYER )
{
// Players don't collide with objects or other players
if ( collisionGroup1 == COLLISION_GROUP_PLAYER )
return false;
}
if ( collisionGroup1 == COLLISION_GROUP_PLAYER_MOVEMENT )
{
// This is only for probing, so it better not be on both sides!!!
Assert( collisionGroup0 != COLLISION_GROUP_PLAYER_MOVEMENT );
// No collide with players any more
// Nor with objects or grenades
switch ( collisionGroup0 )
{
default:
break;
case COLLISION_GROUP_PLAYER:
return false;
}
}
*/
// don't want caltrops and other grenades colliding with each other
// caltops getting stuck on other caltrops, etc.)
if ( ( collisionGroup0 == TF_COLLISIONGROUP_GRENADES ) &&
( collisionGroup1 == TF_COLLISIONGROUP_GRENADES ) )
{
return false;
}
if ( collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT &&
collisionGroup1 == TFCOLLISION_GROUP_COMBATOBJECT )
{
return false;
}
if ( collisionGroup0 == COLLISION_GROUP_PLAYER &&
collisionGroup1 == TFCOLLISION_GROUP_COMBATOBJECT )
{
return false;
}
if ( ( collisionGroup0 == COLLISION_GROUP_PLAYER || collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT ) &&
collisionGroup1 == TFCOLLISION_GROUP_TANK )
{
return false;
}
return BaseClass::ShouldCollide( collisionGroup0, collisionGroup1 );
}
//-----------------------------------------------------------------------------
// Purpose: Return the value of this player towards capturing a point
//-----------------------------------------------------------------------------
int CTFGameRules::GetCaptureValueForPlayer( CBasePlayer *pPlayer )
{
#ifdef GAME_DLL
#ifdef TF_CREEP_MODE
if ( IsCreepWaveMode() )
{
CTFBot *bot = ToTFBot( pPlayer );
if ( !bot || !bot->HasAttribute( CTFBot::IS_NPC ) )
{
// only creeps can influence points
return 0;
}
}
#endif
#endif
int nValue = BaseClass::GetCaptureValueForPlayer( pPlayer );
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
if ( pTFPlayer->IsPlayerClass( TF_CLASS_SCOUT ) )
{
if ( mp_capstyle.GetInt() == 1 )
{
// Scouts count for 2 people in timebased capping.
nValue = 2;
}
else
{
// Scouts can cap all points on their own.
nValue = 10;
}
}
CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer, nValue, add_player_capturevalue );
return nValue;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFGameRules::GetTimeLeft( void )
{
float flTimeLimit = mp_timelimit.GetInt() * 60;
Assert( flTimeLimit > 0 && "Should not call this function when !IsGameUnderTimeLimit" );
float flMapChangeTime = m_flMapResetTime + flTimeLimit;
int iTime = (int)(flMapChangeTime - gpGlobals->curtime);
if ( iTime < 0 )
{
iTime = 0;
}
return ( iTime );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::FireGameEvent( IGameEvent *event )
{
const char *eventName = event->GetName();
#ifdef GAME_DLL
if ( !Q_strcmp( eventName, "teamplay_point_captured" ) )
{
if ( IsMannVsMachineMode() )
return;
// keep track of how many times each team caps
int iTeam = event->GetInt( "team" );
Assert( iTeam >= FIRST_GAME_TEAM && iTeam < TF_TEAM_COUNT );
m_iNumCaps[iTeam]++;
// award a capture to all capping players
const char *cappers = event->GetString( "cappers" );
Q_strncpy( m_szMostRecentCappers, cappers, ARRAYSIZE( m_szMostRecentCappers ) );
for ( int i =0; i < Q_strlen( cappers ); i++ )
{
int iPlayerIndex = (int) cappers[i];
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
if ( pPlayer )
{
CTF_GameStats.Event_PlayerCapturedPoint( pPlayer );
if ( pPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && GetGameType() == TF_GAMETYPE_ESCORT )
{
pPlayer->AwardAchievement( ACHIEVEMENT_TF_HEAVY_PAYLOAD_CAP_GRIND );
}
// Give money and experience
int nAmount = CalculateCurrencyAmount_ByType( TF_CURRENCY_CAPTURED_OBJECTIVE );
#ifdef STAGING_ONLY
if ( GameModeUsesExperience() )
{
pPlayer->AddExperiencePoints( nAmount );
}
#endif // STAGING_ONLY
DistributeCurrencyAmount( nAmount, pPlayer, false );
}
}
// Halloween 2012 doesn't want ghosts to spawn when the point is captured
if( !IsHalloweenScenario( HALLOWEEN_SCENARIO_LAKESIDE ) )
{
// for 2011 Halloween map
BeginHaunting( 4, 25.f, 35.f );
}
}
else if ( !Q_strcmp( eventName, "teamplay_capture_blocked" ) )
{
int iPlayerIndex = event->GetInt( "blocker" );
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
CTF_GameStats.Event_PlayerDefendedPoint( pPlayer );
pPlayer->m_Shared.CheckForAchievement( ACHIEVEMENT_TF_MEDIC_CHARGE_BLOCKER );
}
else if ( !Q_strcmp( eventName, "teamplay_round_win" ) )
{
int iWinningTeam = event->GetInt( "team" );
bool bFullRound = event->GetBool( "full_round" );
float flRoundTime = event->GetFloat( "round_time" );
bool bWasSuddenDeath = event->GetBool( "was_sudden_death" );
CTF_GameStats.Event_RoundEnd( iWinningTeam, bFullRound, flRoundTime, bWasSuddenDeath );
}
else if ( !Q_strcmp( eventName, "teamplay_setup_finished" ) )
{
if ( IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_DOOMSDAY ) )
{
m_doomsdaySetupTimer.Start( 1 );
}
}
else if ( !Q_strcmp( eventName, "teamplay_flag_event" ) )
{
// if this is a capture event, remember the player who made the capture
int iEventType = event->GetInt( "eventtype" );
if ( TF_FLAGEVENT_CAPTURE == iEventType )
{
int iPlayerIndex = event->GetInt( "player" );
m_szMostRecentCappers[0] = iPlayerIndex;
m_szMostRecentCappers[1] = 0;
}
}
else if ( !Q_strcmp( eventName, "player_escort_score" ) )
{
int iPlayer = event->GetInt( "player", 0 );
int iPoints = event->GetInt( "points", 0 );
if ( iPlayer > 0 && iPlayer <= MAX_PLAYERS )
{
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex(iPlayer) );
if ( pPlayer )
{
CTF_GameStats.Event_PlayerScoresEscortPoints( pPlayer, iPoints );
int nAmount = CalculateCurrencyAmount_ByType( TF_CURRENCY_ESCORT_REWARD );
#ifdef STAGING_ONLY
if ( GameModeUsesExperience() )
{
pPlayer->AddExperiencePoints( nAmount * iPoints );
}
#endif // STAGING_ONLY
DistributeCurrencyAmount( ( nAmount * iPoints ), pPlayer, false );
if ( pPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && GetGameType() == TF_GAMETYPE_ESCORT )
{
for ( int i = 0 ; i < iPoints ; i++ )
{
pPlayer->AwardAchievement( ACHIEVEMENT_TF_HEAVY_PAYLOAD_CAP_GRIND );
}
}
}
}
}
else if ( !Q_strcmp( eventName, "player_disconnect" ) )
{
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByUserId( event->GetInt("userid") ) );
// @note Tom Bui: this really sucks, but we don't know the reason other than the string...
const char *pReason = event->GetString( "reason" );
if ( !Q_strncmp( pReason, "Kicked", ARRAYSIZE( "Kicked" ) - 1 ) )
{
if ( pPlayer )
{
DuelMiniGame_NotifyPlayerDisconnect( pPlayer, true );
}
}
}
else if ( !Q_strcmp( eventName, "teamplay_round_start" ) )
{
if ( IsMannVsMachineMode() )
{
if ( g_pPopulationManager )
{
g_pPopulationManager->RestorePlayerCurrency();
// make sure all invaders are removed
CUtlVector< CTFPlayer * > playerVector;
CollectPlayers( &playerVector, TF_TEAM_PVE_INVADERS );
for( int i=0; i<playerVector.Count(); ++i )
{
playerVector[i]->ChangeTeam( TEAM_SPECTATOR, false, true );
}
}
}
}
else if ( !Q_strcmp( eventName, "recalculate_truce" ) )
{
RecalculateTruce();
}
#else // CLIENT_DLL
if ( !Q_strcmp( eventName, "overtime_nag" ) )
{
HandleOvertimeBegin();
}
else if ( !Q_strcmp( eventName, "recalculate_holidays" ) )
{
UTIL_CalculateHolidays();
}
#endif
BaseClass::FireGameEvent( event );
}
const char *CTFGameRules::GetGameTypeName( void )
{
return ::GetGameTypeName( m_nGameType.Get() );
}
void CTFGameRules::ClientSpawned( edict_t * pPlayer )
{
}
void CTFGameRules::OnFileReceived( const char * fileName, unsigned int transferID )
{
}
//-----------------------------------------------------------------------------
// Purpose: Init ammo definitions
//-----------------------------------------------------------------------------
// shared ammo definition
// JAY: Trying to make a more physical bullet response
#define BULLET_MASS_GRAINS_TO_LB(grains) (0.002285*(grains)/16.0f)
#define BULLET_MASS_GRAINS_TO_KG(grains) lbs2kg(BULLET_MASS_GRAINS_TO_LB(grains))
// exaggerate all of the forces, but use real numbers to keep them consistent
#define BULLET_IMPULSE_EXAGGERATION 1
// convert a velocity in ft/sec and a mass in grains to an impulse in kg in/s
#define BULLET_IMPULSE(grains, ftpersec) ((ftpersec)*12*BULLET_MASS_GRAINS_TO_KG(grains)*BULLET_IMPULSE_EXAGGERATION)
CAmmoDef* GetAmmoDef()
{
static CAmmoDef def;
static bool bInitted = false;
if ( !bInitted )
{
bInitted = true;
// Start at 1 here and skip the dummy ammo type to make CAmmoDef use the same indices
// as our #defines.
for ( int i=1; i < TF_AMMO_COUNT; i++ )
{
const char *pszAmmoName = GetAmmoName( i );
def.AddAmmoType( pszAmmoName, DMG_BULLET | DMG_USEDISTANCEMOD | DMG_NOCLOSEDISTANCEMOD, TRACER_LINE, 0, 0, "ammo_max", 2400, 10, 14 );
Assert( def.Index( pszAmmoName ) == i );
}
}
return &def;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CTFGameRules::GetTeamGoalString( int iTeam )
{
if ( iTeam == TF_TEAM_RED )
return m_pszTeamGoalStringRed.Get();
if ( iTeam == TF_TEAM_BLUE )
return m_pszTeamGoalStringBlue.Get();
return NULL;
}
#ifdef GAME_DLL
Vector MaybeDropToGround(
CBaseEntity *pMainEnt,
bool bDropToGround,
const Vector &vPos,
const Vector &vMins,
const Vector &vMaxs )
{
if ( bDropToGround )
{
trace_t trace;
UTIL_TraceHull( vPos, vPos + Vector( 0, 0, -500 ), vMins, vMaxs, MASK_SOLID, pMainEnt, COLLISION_GROUP_NONE, &trace );
return trace.endpos;
}
else
{
return vPos;
}
}
//-----------------------------------------------------------------------------
// Purpose: This function can be used to find a valid placement location for an entity.
// Given an origin to start looking from and a minimum radius to place the entity at,
// it will sweep out a circle around vOrigin and try to find a valid spot (on the ground)
// where mins and maxs will fit.
// Input : *pMainEnt - Entity to place
// &vOrigin - Point to search around
// fRadius - Radius to search within
// nTries - Number of tries to attempt
// &mins - mins of the Entity
// &maxs - maxs of the Entity
// &outPos - Return point
// Output : Returns true and fills in outPos if it found a spot.
//-----------------------------------------------------------------------------
bool EntityPlacementTest( CBaseEntity *pMainEnt, const Vector &vOrigin, Vector &outPos, bool bDropToGround )
{
// This function moves the box out in each dimension in each step trying to find empty space like this:
//
// X
// X X
// Step 1: X Step 2: XXX Step 3: XXXXX
// X X
// X
//
Vector mins, maxs;
pMainEnt->CollisionProp()->WorldSpaceAABB( &mins, &maxs );
mins -= pMainEnt->GetAbsOrigin();
maxs -= pMainEnt->GetAbsOrigin();
// Put some padding on their bbox.
float flPadSize = 5;
Vector vTestMins = mins - Vector( flPadSize, flPadSize, flPadSize );
Vector vTestMaxs = maxs + Vector( flPadSize, flPadSize, flPadSize );
// First test the starting origin.
if ( UTIL_IsSpaceEmpty( pMainEnt, vOrigin + vTestMins, vOrigin + vTestMaxs ) )
{
outPos = MaybeDropToGround( pMainEnt, bDropToGround, vOrigin, vTestMins, vTestMaxs );
return true;
}
Vector vDims = vTestMaxs - vTestMins;
// Keep branching out until we get too far.
int iCurIteration = 0;
int nMaxIterations = 15;
int offset = 0;
do
{
for ( int iDim=0; iDim < 3; iDim++ )
{
float flCurOffset = offset * vDims[iDim];
for ( int iSign=0; iSign < 2; iSign++ )
{
Vector vBase = vOrigin;
vBase[iDim] += (iSign*2-1) * flCurOffset;
if ( UTIL_IsSpaceEmpty( pMainEnt, vBase + vTestMins, vBase + vTestMaxs ) )
{
// Ensure that there is a clear line of sight from the spawnpoint entity to the actual spawn point.
// (Useful for keeping things from spawning behind walls near a spawn point)
trace_t tr;
UTIL_TraceLine( vOrigin, vBase, MASK_SOLID, pMainEnt, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction != 1.0 )
{
continue;
}
outPos = MaybeDropToGround( pMainEnt, bDropToGround, vBase, vTestMins, vTestMaxs );
return true;
}
}
}
++offset;
} while ( iCurIteration++ < nMaxIterations );
// Warning( "EntityPlacementTest for ent %d:%s failed!\n", pMainEnt->entindex(), pMainEnt->GetClassname() );
return false;
}
#else // GAME_DLL
CTFGameRules::~CTFGameRules()
{
if ( m_pkvVisionFilterTranslations )
{
m_pkvVisionFilterTranslations->deleteThis();
m_pkvVisionFilterTranslations = NULL;
}
if ( m_pkvVisionFilterShadersMapWhitelist )
{
m_pkvVisionFilterShadersMapWhitelist->deleteThis();
m_pkvVisionFilterShadersMapWhitelist = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::OnDataChanged( DataUpdateType_t updateType )
{
BaseClass::OnDataChanged( updateType );
m_bRecievedBaseline |= updateType == DATA_UPDATE_CREATED;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::HandleOvertimeBegin()
{
C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pTFPlayer )
{
pTFPlayer->EmitSound( "Game.Overtime" );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldShowTeamGoal( void )
{
//=============================================================================
// HPE_BEGIN
// [msmith] We always show the team goal when in training.
//=============================================================================
bool showDuringSetup = InSetup();
if ( IsInTraining() || IsInItemTestingMode() )
{
showDuringSetup = false;
}
if ( State_Get() == GR_STATE_PREROUND || State_Get() == GR_STATE_RND_RUNNING || showDuringSetup )
return true;
//=============================================================================
// HPE_END
//=============================================================================
return false;
}
#endif
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::ShutdownCustomResponseRulesDicts()
{
DestroyCustomResponseSystems();
if ( m_ResponseRules.Count() != 0 )
{
int nRuleCount = m_ResponseRules.Count();
for ( int iRule = 0; iRule < nRuleCount; ++iRule )
{
m_ResponseRules[iRule].m_ResponseSystems.Purge();
}
m_ResponseRules.Purge();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::InitCustomResponseRulesDicts()
{
MEM_ALLOC_CREDIT();
// Clear if necessary.
ShutdownCustomResponseRulesDicts();
// Initialize the response rules for TF.
m_ResponseRules.AddMultipleToTail( TF_CLASS_COUNT_ALL );
char szName[512];
for ( int iClass = TF_FIRST_NORMAL_CLASS; iClass < TF_CLASS_COUNT_ALL; ++iClass )
{
m_ResponseRules[iClass].m_ResponseSystems.AddMultipleToTail( MP_TF_CONCEPT_COUNT );
for ( int iConcept = 0; iConcept < MP_TF_CONCEPT_COUNT; ++iConcept )
{
AI_CriteriaSet criteriaSet;
criteriaSet.AppendCriteria( "playerclass", g_aPlayerClassNames_NonLocalized[iClass] );
criteriaSet.AppendCriteria( "Concept", g_pszMPConcepts[iConcept] );
// 1 point for player class and 1 point for concept.
float flCriteriaScore = 2.0f;
// Name.
V_sprintf_safe( szName, "%s_%s\n", g_aPlayerClassNames_NonLocalized[iClass], g_pszMPConcepts[iConcept] );
m_ResponseRules[iClass].m_ResponseSystems[iConcept] = BuildCustomResponseSystemGivenCriteria( "scripts/talker/response_rules.txt", szName, criteriaSet, flCriteriaScore );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
#ifdef _DEBUG
CON_COMMAND( hud_notify, "Show a hud notification." )
{
if ( args.ArgC() < 2 )
{
Warning( "Requires one argument, HudNotification_t, between 0 and %i\n", NUM_STOCK_NOTIFICATIONS );
return;
}
if ( !TFGameRules() )
{
Warning( "Can't do that right now\n" );
return;
}
CRecipientFilter filter;
filter.AddAllPlayers();
TFGameRules()->SendHudNotification( filter, (HudNotification_t) V_atoi(args.Arg(1)) );
}
#endif
void CTFGameRules::SendHudNotification( IRecipientFilter &filter, HudNotification_t iType, bool bForceShow /*= false*/ )
{
if ( !bForceShow && IsInWaitingForPlayers() )
return;
UserMessageBegin( filter, "HudNotify" );
WRITE_BYTE( iType );
WRITE_BOOL( bForceShow ); // Display in cl_hud_minmode
MessageEnd();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::SendHudNotification( IRecipientFilter &filter, const char *pszText, const char *pszIcon, int iTeam /*= TEAM_UNASSIGNED*/ )
{
if ( IsInWaitingForPlayers() )
return;
UserMessageBegin( filter, "HudNotifyCustom" );
WRITE_STRING( pszText );
WRITE_STRING( pszIcon );
WRITE_BYTE( iTeam );
MessageEnd();
}
//-----------------------------------------------------------------------------
// Purpose: Is the player past the required delays for spawning
//-----------------------------------------------------------------------------
bool CTFGameRules::HasPassedMinRespawnTime( CBasePlayer *pPlayer )
{
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
if ( pTFPlayer && pTFPlayer->GetPlayerClass()->GetClassIndex() == TF_CLASS_UNDEFINED )
return true;
float flMinSpawnTime = GetMinTimeWhenPlayerMaySpawn( pPlayer );
return ( gpGlobals->curtime > flMinSpawnTime );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldRespawnQuickly( CBasePlayer *pPlayer )
{
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
if ( IsPVEModeActive() && pTFPlayer && pTFPlayer->GetTeamNumber() == TF_TEAM_PVE_DEFENDERS && pTFPlayer->GetPlayerClass()->GetClassIndex() == TF_CLASS_SCOUT )
{
return true;
}
#if defined( _DEBUG ) || defined( STAGING_ONLY )
if ( mp_developer.GetBool() )
return true;
#endif // _DEBUG || STAGING_ONLY
if ( IsCompetitiveMode() && State_Get() == GR_STATE_BETWEEN_RNDS )
return true;
return BaseClass::ShouldRespawnQuickly( pPlayer );
}
typedef bool (*BIgnoreConvarChangeFunc)(void);
struct convar_tags_t
{
const char *pszConVar;
const char *pszTag;
BIgnoreConvarChangeFunc ignoreConvarFunc;
};
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static bool BIgnoreConvarChangeInPVEMode(void)
{
return TFGameRules() && TFGameRules()->IsPVEModeActive();
}
// The list of convars that automatically turn on tags when they're changed.
// Convars in this list need to have the FCVAR_NOTIFY flag set on them, so the
// tags are recalculated and uploaded to the master server when the convar is changed.
convar_tags_t convars_to_check_for_tags[] =
{
{ "mp_friendlyfire", "friendlyfire", NULL },
{ "tf_birthday", "birthday", NULL },
{ "mp_respawnwavetime", "respawntimes", NULL },
{ "mp_fadetoblack", "fadetoblack", NULL },
{ "tf_weapon_criticals", "nocrits", NULL },
{ "mp_disable_respawn_times", "norespawntime", NULL },
{ "tf_gamemode_arena", "arena", NULL },
{ "tf_gamemode_cp", "cp", NULL },
{ "tf_gamemode_ctf", "ctf", NULL },
{ "tf_gamemode_sd", "sd", NULL },
{ "tf_gamemode_mvm", "mvm", NULL },
{ "tf_gamemode_payload", "payload", NULL },
{ "tf_gamemode_rd", "rd", NULL },
{ "tf_gamemode_pd", "pd", NULL },
{ "tf_gamemode_tc", "tc", NULL },
{ "tf_beta_content", "beta", NULL },
{ "tf_damage_disablespread", "dmgspread", NULL },
{ "mp_highlander", "highlander", NULL },
{ "tf_bot_count", "bots", &BIgnoreConvarChangeInPVEMode },
{ "tf_pve_mode", "pve" },
{ "sv_registration_successful", "_registered", NULL },
{ "tf_server_identity_disable_quickplay", "noquickplay", NULL },
{ "tf_mm_strict", "hidden", NULL },
{ "tf_medieval", "medieval", NULL },
{ "mp_holiday_nogifts", "nogifts" },
{ "tf_powerup_mode", "powerup", NULL },
{ "tf_gamemode_passtime", "passtime", NULL },
{ "tf_gamemode_misc", "misc", NULL }, // catch-all for matchmaking to identify sd, tc, and pd servers via sv_tags
};
//-----------------------------------------------------------------------------
// Purpose: Engine asks for the list of convars that should tag the server
//-----------------------------------------------------------------------------
void CTFGameRules::GetTaggedConVarList( KeyValues *pCvarTagList )
{
BaseClass::GetTaggedConVarList( pCvarTagList );
for ( int i = 0; i < ARRAYSIZE(convars_to_check_for_tags); i++ )
{
if ( convars_to_check_for_tags[i].ignoreConvarFunc && convars_to_check_for_tags[i].ignoreConvarFunc() )
continue;
KeyValues *pKV = new KeyValues( "tag" );
pKV->SetString( "convar", convars_to_check_for_tags[i].pszConVar );
pKV->SetString( "tag", convars_to_check_for_tags[i].pszTag );
pCvarTagList->AddSubKey( pKV );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::PlaySpecialCapSounds( int iCappingTeam, CTeamControlPoint *pPoint )
{
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_LAKESIDE ) )
{
return;
}
if ( GetGameType() == TF_GAMETYPE_CP )
{
bool bPlayControlPointCappedSound = IsInKothMode();
if ( !bPlayControlPointCappedSound )
{
if ( pPoint && ShouldScorePerRound() )
{
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
if ( pMaster && !pMaster->WouldNewCPOwnerWinGame( pPoint, iCappingTeam ) )
{
bPlayControlPointCappedSound = true;
}
}
}
if ( bPlayControlPointCappedSound )
{
for ( int i = FIRST_GAME_TEAM; i < GetNumberOfTeams(); i++ )
{
if ( IsInKothMode() )
{
BroadcastSound( i, "Hud.PointCaptured" );
}
if ( i == iCappingTeam )
{
BroadcastSound( i, "Announcer.Success" );
}
else
{
BroadcastSound( i, "Announcer.Failure" );
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Factory to create TF-specific mission manager singleton
//-----------------------------------------------------------------------------
CTacticalMissionManager *CTFGameRules::TacticalMissionManagerFactory( void )
{
return new CTFTacticalMissionManager;
}
#endif
//-----------------------------------------------------------------------------
// Purpose: Get the video file name for the current map.
//-----------------------------------------------------------------------------
#ifdef CLIENT_DLL
const char *CTFGameRules::GetVideoFileForMap( bool bWithExtension /*= true*/ )
{
char mapname[MAX_MAP_NAME];
mapname[0] = 0;
Q_FileBase( engine->GetLevelName(), mapname, sizeof( mapname ) );
if ( mapname[0] == 0 )
{
return NULL;
}
Q_strlower( mapname );
return FormatVideoName( (const char *)mapname, bWithExtension );
}
//=============================================================================
// HPE_BEGIN
// [msmith] Used for the client to tell the server that we're watching a movie or not.
// Also contains the name of a movie if it's an in game video.
//=============================================================================
//-----------------------------------------------------------------------------
// Purpose: Format a video file name from the name passed in.
//-----------------------------------------------------------------------------
const char *CTFGameRules::FormatVideoName( const char *videoName, bool bWithExtension /*= true*/ )
{
static char strFullpath[MAX_PATH]; // this buffer is returned to the caller
#ifdef _X360
// Should we be modifying a const buffer?
// need to remove the .360 extension on the end of the map name
char *pExt = Q_stristr( videoName, ".360" );
if ( pExt )
{
*pExt = '\0';
}
#endif
Q_strncpy( strFullpath, "media/", MAX_PATH ); // Assume we must play out of the media directory
if ( Q_strstr( videoName, "arena_" ) )
{
char strTempPath[MAX_PATH];
Q_strncpy( strTempPath, "media/", MAX_PATH );
Q_strncat( strTempPath, videoName, MAX_PATH );
Q_strncat( strTempPath, FILE_EXTENSION_ANY_MATCHING_VIDEO, MAX_PATH );
VideoSystem_t vSystem = VideoSystem::NONE;
// default to arena_intro video if we can't find the specified video
if ( !g_pVideo || g_pVideo->LocatePlayableVideoFile( strTempPath, "GAME", &vSystem, strFullpath, sizeof(strFullpath), VideoSystemFeature::PLAY_VIDEO_FILE_IN_MATERIAL ) != VideoResult::SUCCESS )
{
V_strncpy( strFullpath, "media/" "arena_intro", MAX_PATH );
}
}
else if ( Q_strstr( videoName, "mvm_" ) )
{
char strTempPath[MAX_PATH];
Q_strncpy( strTempPath, "media/", MAX_PATH );
Q_strncat( strTempPath, videoName, MAX_PATH );
Q_strncat( strTempPath, FILE_EXTENSION_ANY_MATCHING_VIDEO, MAX_PATH );
VideoSystem_t vSystem = VideoSystem::NONE;
// default to mvm_intro video if we can't find the specified video
if ( !g_pVideo || g_pVideo->LocatePlayableVideoFile( strTempPath, "GAME", &vSystem, strFullpath, sizeof(strFullpath), VideoSystemFeature::PLAY_VIDEO_FILE_IN_MATERIAL ) != VideoResult::SUCCESS )
{
V_strncpy( strFullpath, "media/" "mvm_intro", MAX_PATH );
}
}
else
{
Q_strncat( strFullpath, videoName, MAX_PATH );
}
if ( bWithExtension )
{
Q_strncat( strFullpath, FILE_EXTENSION_ANY_MATCHING_VIDEO, MAX_PATH ); // Don't assume any specific video type, let the video services find it
}
return strFullpath;
}
#endif
//=============================================================================
// HPE_END
//=============================================================================
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *GetMapDisplayName( const char *mapName )
{
static char szDisplayName[256];
char szTempName[256];
const char *pszSrc = NULL;
szDisplayName[0] = '\0';
if ( !mapName )
return szDisplayName;
// check our lookup table
Q_strncpy( szTempName, mapName, sizeof( szTempName ) );
Q_strlower( szTempName );
pszSrc = szTempName;
for ( int i = 0; i < ARRAYSIZE( s_ValveMaps ); ++i )
{
if ( !Q_stricmp( s_ValveMaps[i].pDiskName, pszSrc ) )
{
return s_ValveMaps[i].pDisplayName;
}
}
// check the community maps that we've featured
for ( int i = 0; i < ARRAYSIZE( s_CommunityMaps ); ++i )
{
if ( !Q_stricmp( s_CommunityMaps[i].pDiskName, pszSrc ) )
{
return s_CommunityMaps[i].pDisplayName;
}
}
char *pszFinal = Q_strstr( pszSrc, "_final" );
if ( pszFinal )
{
// truncate the _final (or _final1) part of the filename if it's at the end of the name
char *pszNextChar = pszFinal + Q_strlen( "_final" );
if ( pszNextChar )
{
if ( ( *pszNextChar == '\0' ) ||
( ( *pszNextChar == '1' ) && ( *(pszNextChar+1) == '\0' ) ) )
{
*pszFinal = '\0';
}
}
}
// Our workshop maps will be of the format workshop/cp_somemap.ugc12345
const char szWorkshop[] = "workshop/";
if ( V_strncmp( pszSrc, szWorkshop, sizeof( szWorkshop ) - 1 ) == 0 )
{
pszSrc += sizeof( szWorkshop ) - 1;
char *pszUGC = V_strstr( pszSrc, ".ugc" );
int nUGCLen = pszUGC ? strlen( pszUGC ) : 0;
if ( pszUGC && nUGCLen > 4 )
{
int i;
for ( i = 4; i < nUGCLen; i ++ )
{
if ( pszUGC[i] < '0' || pszUGC[i] > '9' )
{
break;
}
}
if ( i == nUGCLen )
{
*pszUGC = '\0';
}
}
}
// we haven't found a "friendly" map name, so let's just clean up what we have
if ( !Q_strncmp( pszSrc, "cp_", 3 ) ||
!Q_strncmp( pszSrc, "tc_", 3 ) ||
!Q_strncmp( pszSrc, "pl_", 3 ) ||
!Q_strncmp( pszSrc, "ad_", 3 ) ||
!Q_strncmp( pszSrc, "sd_", 3 ) ||
!Q_strncmp( pszSrc, "rd_", 3 ) ||
!Q_strncmp( pszSrc, "pd_", 3 ) )
{
pszSrc += 3;
}
else if ( !Q_strncmp( pszSrc, "ctf_", 4 ) ||
!Q_strncmp( pszSrc, "plr_", 4 ) )
{
pszSrc += 4;
}
else if ( !Q_strncmp( szTempName, "koth_", 5 ) ||
!Q_strncmp( szTempName, "pass_", 5 ) )
{
pszSrc += 5;
}
#ifdef TF_RAID_MODE
else if ( !Q_strncmp( pszSrc, "raid_", 5 ) )
{
pszSrc += 5;
}
#endif // TF_RAID_MODE
else if ( !Q_strncmp( pszSrc, "mvm_", 4 ) )
{
pszSrc += 4;
}
else if ( !Q_strncmp( pszSrc, "arena_", 6 ) )
{
pszSrc += 6;
}
Q_strncpy( szDisplayName, pszSrc, sizeof( szDisplayName ) );
Q_strupr( szDisplayName );
// replace underscores with spaces
for ( char *pszUnderscore = szDisplayName ; pszUnderscore != NULL && *pszUnderscore != 0 ; pszUnderscore++ )
{
// Replace it with a space
if ( *pszUnderscore == '_' )
{
*pszUnderscore = ' ';
}
}
return szDisplayName;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *GetMapType( const char *mapName )
{
int i;
if ( mapName )
{
for ( i = 0; i < ARRAYSIZE( s_ValveMaps ); ++i )
{
if ( !Q_stricmp( s_ValveMaps[i].pDiskName, mapName ) )
{
return s_ValveMaps[i].pGameType;
}
}
// check the community maps that we've featured
for ( i = 0; i < ARRAYSIZE( s_CommunityMaps ); ++i )
{
if ( !Q_stricmp( s_CommunityMaps[i].pDiskName, mapName ) )
{
return s_CommunityMaps[i].pGameType;
}
}
}
if ( !IsX360() )
{
// we haven't found a "friendly" map name, so let's just clean up what we have
if ( !Q_strnicmp( mapName, "cp_", 3 ) )
{
return "#Gametype_CP";
}
else if ( !Q_strnicmp( mapName, "tc_", 3 ) )
{
return "#TF_TerritoryControl";
}
else if ( !Q_strnicmp( mapName, "pl_", 3 ) )
{
return "#Gametype_Escort";
}
else if ( !Q_strnicmp( mapName, "plr_", 4 ) )
{
return "#Gametype_EscortRace";
}
else if ( !Q_strnicmp( mapName, "ad_", 3 ) )
{
return "#TF_AttackDefend";
}
else if ( !Q_strnicmp( mapName, "ctf_", 4 ) )
{
return "#Gametype_CTF";
}
else if ( !Q_strnicmp( mapName, "koth_", 5 ) )
{
return "#Gametype_Koth";
}
else if ( !Q_strnicmp( mapName, "arena_", 6 ) )
{
return "#Gametype_Arena";
}
else if ( !Q_strnicmp( mapName, "sd_", 3 ) )
{
return "#Gametype_SD";
}
#ifdef TF_RAID_MODE
else if ( !Q_strnicmp( mapName, "raid_", 5 ) )
{
return "#Gametype_Raid";
}
#endif // TF_RAID_MODE
else if ( !Q_strnicmp( mapName, "mvm_", 4 ) )
{
return "#Gametype_MVM";
}
else if ( !Q_strnicmp( mapName, "pass_", 5 ) )
{
return "#GameType_Passtime";
}
else if ( !Q_strnicmp( mapName, "rd_", 3 ) )
{
return "#Gametype_RobotDestruction";
}
else if ( !Q_strnicmp( mapName, "pd_", 3 ) )
{
return "#Gametype_PlayerDestruction";
}
else
{
if ( TFGameRules() )
{
return TFGameRules()->GetGameTypeName();
}
}
}
return "";
}
#endif
//Arena Mode
bool CTFGameRules::IsInArenaMode( void ) const
{
return m_nGameType == TF_GAMETYPE_ARENA;
}
#ifdef GAME_DLL
//==================================================================================================================
// ARENA LOGIC
BEGIN_DATADESC( CArenaLogic )
DEFINE_OUTPUT( m_OnArenaRoundStart, "OnArenaRoundStart" ),
DEFINE_OUTPUT( m_OnCapEnabled, "OnCapEnabled" ),
DEFINE_KEYFIELD( m_flTimeToEnableCapPoint, FIELD_FLOAT, "CapEnableDelay" ),
DEFINE_FUNCTION( ArenaLogicThink ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( tf_logic_arena, CArenaLogic );
void CArenaLogic::Spawn( void )
{
BaseClass::Spawn();
SetThink( &CArenaLogic::ArenaLogicThink );
SetNextThink( gpGlobals->curtime );
}
void CArenaLogic::ArenaLogicThink( void )
{
SetNextThink( gpGlobals->curtime + 0.1f );
if ( TFGameRules()->State_Get() != GR_STATE_STALEMATE )
return;
if ( TFGameRules() && TFGameRules()->GetCapturePointTime() <= gpGlobals->curtime )
{
if ( m_bFiredOutput == false )
{
m_bFiredOutput = true;
m_OnCapEnabled.FireOutput( this, this );
}
}
else if ( TFGameRules() && TFGameRules()->GetCapturePointTime() > gpGlobals->curtime )
{
m_bFiredOutput = false;
}
}
//-----------------------------------------------------------------------------
// Purpose: COMPETITIVE LOGIC (why are we shouting?)
//-----------------------------------------------------------------------------
BEGIN_DATADESC( CCompetitiveLogic )
DEFINE_OUTPUT( m_OnSpawnRoomDoorsShouldLock, "OnSpawnRoomDoorsShouldLock" ),
DEFINE_OUTPUT( m_OnSpawnRoomDoorsShouldUnlock, "OnSpawnRoomDoorsShouldUnlock" ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( tf_logic_competitive, CCompetitiveLogic );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CCompetitiveLogic::OnSpawnRoomDoorsShouldLock( void )
{
if ( !TFGameRules() || !TFGameRules()->IsCompetitiveMode() )
return;
m_OnSpawnRoomDoorsShouldLock.FireOutput( this, this );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CCompetitiveLogic::OnSpawnRoomDoorsShouldUnlock( void )
{
if ( !TFGameRules() || !TFGameRules()->IsCompetitiveMode() )
return;
m_OnSpawnRoomDoorsShouldUnlock.FireOutput( this, this );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
BEGIN_DATADESC( CLogicMannPower )
END_DATADESC()
LINK_ENTITY_TO_CLASS( tf_logic_mannpower, CLogicMannPower );
//=============================================================================
// Training Mode
CON_COMMAND( training_continue, "Tells training that it should continue." )
{
if ( TFGameRules() == NULL || TFGameRules()->IsInTraining() == false || TFGameRules()->GetTrainingModeLogic() == NULL )
{
return;
}
TFGameRules()->GetTrainingModeLogic()->OnPlayerWantsToContinue();
}
#define SF_TF_DYNAMICPROP_GRENADE_COLLISION 512
class CTFTrainingDynamicProp : public CDynamicProp
{
DECLARE_CLASS( CTFTrainingDynamicProp, CDynamicProp );
public:
};
LINK_ENTITY_TO_CLASS( training_prop_dynamic, CTFTrainingDynamicProp );
bool PropDynamic_CollidesWithGrenades( CBaseEntity *pBaseEntity )
{
CTFTrainingDynamicProp *pTrainingDynamicProp = dynamic_cast< CTFTrainingDynamicProp* >( pBaseEntity );
return ( pTrainingDynamicProp && pTrainingDynamicProp->HasSpawnFlags( SF_TF_DYNAMICPROP_GRENADE_COLLISION) );
}
BEGIN_DATADESC( CTrainingModeLogic )
DEFINE_KEYFIELD( m_nextMapName, FIELD_STRING, "nextMap" ),
DEFINE_INPUTFUNC( FIELD_STRING, "ShowTrainingMsg", InputShowTrainingMsg ),
DEFINE_INPUTFUNC( FIELD_STRING, "ShowTrainingObjective", InputShowTrainingObjective ),
DEFINE_INPUTFUNC( FIELD_VOID, "ForcePlayerSpawnAsClassOutput", InputForcePlayerSpawnAsClassOutput ),
DEFINE_INPUTFUNC( FIELD_VOID, "KickBots", InputKickAllBots ),
DEFINE_INPUTFUNC( FIELD_VOID, "ShowTrainingHUD", InputShowTrainingHUD ),
DEFINE_INPUTFUNC( FIELD_VOID, "HideTrainingHUD", InputHideTrainingHUD ),
DEFINE_INPUTFUNC( FIELD_STRING, "EndTraining", InputEndTraining ),
DEFINE_INPUTFUNC( FIELD_STRING, "PlaySoundOnPlayer", InputPlaySoundOnPlayer ),
DEFINE_INPUTFUNC( FIELD_STRING, "WaitForTimerOrKeypress", InputWaitForTimerOrKeypress ),
DEFINE_INPUTFUNC( FIELD_STRING, "SetNextMap", InputSetNextMap ),
DEFINE_INPUTFUNC( FIELD_STRING, "ForcePlayerSwapToWeapon", InputForcePlayerSwapToWeapon ),
DEFINE_OUTPUT( m_outputOnPlayerSpawnAsScout, "OnPlayerSpawnAsScout" ),
DEFINE_OUTPUT( m_outputOnPlayerSpawnAsSniper, "OnPlayerSpawnAsSniper" ),
DEFINE_OUTPUT( m_outputOnPlayerSpawnAsSoldier, "OnPlayerSpawnAsSoldier" ),
DEFINE_OUTPUT( m_outputOnPlayerSpawnAsDemoman, "OnPlayerSpawnAsDemoman" ),
DEFINE_OUTPUT( m_outputOnPlayerSpawnAsMedic, "OnPlayerSpawnAsMedic" ),
DEFINE_OUTPUT( m_outputOnPlayerSpawnAsHeavy, "OnPlayerSpawnAsHeavy" ),
DEFINE_OUTPUT( m_outputOnPlayerSpawnAsPyro, "OnPlayerSpawnAsPyro" ),
DEFINE_OUTPUT( m_outputOnPlayerSpawnAsSpy, "OnPlayerSpawnAsSpy" ),
DEFINE_OUTPUT( m_outputOnPlayerSpawnAsEngineer, "OnPlayerSpawnAsEngineer" ),
DEFINE_OUTPUT( m_outputOnPlayerDied, "OnPlayerDied" ),
DEFINE_OUTPUT( m_outputOnBotDied, "OnBotDied" ),
DEFINE_OUTPUT( m_outputOnPlayerSwappedToWeaponSlotPrimary, "OnPlayerSwappedToPrimary" ),
DEFINE_OUTPUT( m_outputOnPlayerSwappedToWeaponSlotSecondary, "OnPlayerSwappedToSecondary" ),
DEFINE_OUTPUT( m_outputOnPlayerSwappedToWeaponSlotMelee, "OnPlayerSwappedToMelee" ),
DEFINE_OUTPUT( m_outputOnPlayerSwappedToWeaponSlotBuilding, "OnPlayerSwappedToBuilding" ),
DEFINE_OUTPUT( m_outputOnPlayerSwappedToWeaponSlotPDA, "OnPlayerSwappedToPDA" ),
DEFINE_OUTPUT( m_outputOnPlayerBuiltOutsideSuggestedArea, "OnBuildOutsideArea" ),
DEFINE_OUTPUT( m_outputOnPlayerDetonateBuilding, "OnPlayerDetonateBuilding" ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( tf_logic_training_mode, CTrainingModeLogic );
void CTrainingModeLogic::SetupOnRoundStart()
{
m_objText[0] = 0;
SetTrainingMsg( "" );
}
void CTrainingModeLogic::SetTrainingMsg(const char *msg)
{
CBroadcastRecipientFilter allusers;
allusers.MakeReliable();
UserMessageBegin( allusers, "TrainingMsg" );
WRITE_STRING( msg );
MessageEnd();
}
void CTrainingModeLogic::SetTrainingObjective(const char *text)
{
CBroadcastRecipientFilter allusers;
allusers.MakeReliable();
UserMessageBegin( allusers, "TrainingObjective" );
WRITE_STRING( text );
MessageEnd();
}
void CTrainingModeLogic::OnPlayerSpawned( CTFPlayer* pPlayer )
{
if ( pPlayer->GetDesiredPlayerClassIndex() == TF_CLASS_UNDEFINED )
{
return;
}
if ( pPlayer->IsFakeClient() )
{
return;
}
int iClass = pPlayer->GetPlayerClass()->GetClassIndex();
switch ( iClass )
{
case TF_CLASS_SCOUT: m_outputOnPlayerSpawnAsScout.FireOutput( this, this ); break;
case TF_CLASS_SNIPER: m_outputOnPlayerSpawnAsSniper.FireOutput( this, this ); break;
case TF_CLASS_SOLDIER: m_outputOnPlayerSpawnAsSoldier.FireOutput( this, this ); break;
case TF_CLASS_DEMOMAN: m_outputOnPlayerSpawnAsDemoman.FireOutput( this, this ); break;
case TF_CLASS_MEDIC: m_outputOnPlayerSpawnAsMedic.FireOutput( this, this ); break;
case TF_CLASS_HEAVYWEAPONS: m_outputOnPlayerSpawnAsHeavy.FireOutput( this, this ); break;
case TF_CLASS_PYRO: m_outputOnPlayerSpawnAsPyro.FireOutput( this, this ); break;
case TF_CLASS_SPY: m_outputOnPlayerSpawnAsSpy.FireOutput( this, this ); break;
case TF_CLASS_ENGINEER: m_outputOnPlayerSpawnAsEngineer.FireOutput( this, this ); break;
}
}
void CTrainingModeLogic::OnPlayerDied( CTFPlayer *pPlayer, CBaseEntity *pKiller )
{
m_outputOnPlayerDied.FireOutput( pKiller, this );
}
void CTrainingModeLogic::OnBotDied( CTFPlayer *pPlayer, CBaseEntity *pKiller )
{
m_outputOnBotDied.FireOutput( pKiller, this );
}
void CTrainingModeLogic::OnPlayerSwitchedWeapons( CTFPlayer *pPlayer )
{
CTFWeaponBase *pWeapon = (CTFWeaponBase*)pPlayer->GetActiveWeapon();
if ( pWeapon == NULL )
{
return;
}
switch ( pWeapon->GetTFWpnData().m_iWeaponType )
{
case TF_WPN_TYPE_PRIMARY: m_outputOnPlayerSwappedToWeaponSlotPrimary.FireOutput( this, this ); break;
case TF_WPN_TYPE_SECONDARY: m_outputOnPlayerSwappedToWeaponSlotSecondary.FireOutput( this, this ); break;
case TF_WPN_TYPE_MELEE: m_outputOnPlayerSwappedToWeaponSlotMelee.FireOutput( this, this ); break;
case TF_WPN_TYPE_BUILDING: m_outputOnPlayerSwappedToWeaponSlotBuilding.FireOutput( this, this ); break;
case TF_WPN_TYPE_PDA: m_outputOnPlayerSwappedToWeaponSlotPDA.FireOutput( this, this ); break;
}
}
void CTrainingModeLogic::OnPlayerWantsToContinue()
{
if ( m_waitingForKeypressTimer.Get() != NULL )
{
m_waitingForKeypressTimer->FireNamedOutput( "OnTimer", variant_t(), this, this );
m_waitingForKeypressTimer = NULL;
TFGameRules()->SetIsWaitingForTrainingContinue( false );
}
}
void CTrainingModeLogic::OnPlayerBuiltBuilding( CTFPlayer *pPlayer, CBaseObject *pBaseObject )
{
if ( pBaseObject && NotifyObjectBuiltInSuggestedArea( *pBaseObject ) == false )
{
m_outputOnPlayerBuiltOutsideSuggestedArea.FireOutput( pBaseObject, this );
}
}
void CTrainingModeLogic::OnPlayerUpgradedBuilding( CTFPlayer *pPlayer, CBaseObject *pBaseObject )
{
if ( pBaseObject )
{
NotifyObjectUpgradedInSuggestedArea( *pBaseObject );
}
}
void CTrainingModeLogic::OnPlayerDetonateBuilding( CTFPlayer *pPlayer, CBaseObject *pBaseObject )
{
m_outputOnPlayerDetonateBuilding.FireOutput( pPlayer, pBaseObject );
}
void CTrainingModeLogic::UpdateHUDObjective()
{
if ( m_objText[0] != 0 )
{
SetTrainingObjective( m_objText );
}
else
{
SetTrainingObjective("");
}
}
const char* CTrainingModeLogic::GetNextMap()
{
return m_nextMapName.ToCStr();
}
const char* CTrainingModeLogic::GetTrainingEndText()
{
return m_endTrainingText.ToCStr();
}
int CTrainingModeLogic::GetDesiredClass() const
{
return training_class.GetInt();
}
void CTrainingModeLogic::InputForcePlayerSpawnAsClassOutput( inputdata_t &inputdata )
{
// This is a bit weird, but we will call this for every player--bots should be ignored
CTFPlayer *pPlayer;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( !pPlayer )
continue;
OnPlayerSpawned( pPlayer );
}
}
void CTrainingModeLogic::InputKickAllBots( inputdata_t &inputdata )
{
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( pPlayer && pPlayer->IsFakeClient() )
{
engine->ServerCommand( UTIL_VarArgs( "kickid %d\n", pPlayer->GetUserID() ) );
}
}
}
void CTrainingModeLogic::InputShowTrainingMsg( inputdata_t &inputdata )
{
if ( TFGameRules()->IsInTraining() )
{
SetTrainingMsg( inputdata.value.String() );
}
}
void CTrainingModeLogic::InputShowTrainingObjective( inputdata_t &inputdata )
{
if ( !TFGameRules()->IsInTraining() )
return;
//First try to find the unicode string to send over.
wchar_t *strPtr = NULL;
strPtr = g_pVGuiLocalize->Find( inputdata.value.String() );
if (NULL == strPtr)
{
V_strcpy_safe(m_objText, inputdata.value.String());
}
else
{
g_pVGuiLocalize->ConvertUnicodeToANSI(strPtr, m_objText, kMaxLengthObjectiveText);
}
UpdateHUDObjective();
}
void CTrainingModeLogic::InputShowTrainingHUD( inputdata_t &inputdata )
{
if ( !TFGameRules()->IsInTraining() )
return;
TFGameRules()->SetTrainingHUDVisible( true );
}
void CTrainingModeLogic::InputHideTrainingHUD( inputdata_t &inputdata )
{
if ( !TFGameRules()->IsInTraining() )
return;
TFGameRules()->SetTrainingHUDVisible( false );
}
void CTrainingModeLogic::InputEndTraining( inputdata_t &inputdata )
{
if ( !TFGameRules()->IsInTraining() )
return;
TFGameRules()->SetAllowTrainingAchievements( true );
m_endTrainingText = inputdata.value.StringID();
CTFPlayer* pHumanPlayer = ToTFPlayer( UTIL_GetListenServerHost() );
if (NULL == pHumanPlayer) return;
int iTeam = pHumanPlayer->GetTeamNumber();
bool force_map_reset = true;
CTeamplayRoundBasedRules *pGameRules = dynamic_cast<CTeamplayRoundBasedRules *>( GameRules() );
pGameRules->SetWinningTeam( iTeam, pGameRules->GetWinReason(), force_map_reset );
// Show a training win screen so send that event instead.
IGameEvent *winEvent = gameeventmanager->CreateEvent( "training_complete" );
if ( winEvent )
{
winEvent->SetString( "map", STRING( gpGlobals->mapname ) );
winEvent->SetString( "next_map", GetNextMap() );
winEvent->SetString( "text", GetTrainingEndText() );
gameeventmanager->FireEvent( winEvent );
}
}
void CTrainingModeLogic::InputPlaySoundOnPlayer( inputdata_t &inputdata )
{
if ( !TFGameRules()->IsInTraining() )
return;
CTFPlayer* pHumanPlayer = ToTFPlayer( UTIL_GetListenServerHost() );
if (NULL == pHumanPlayer)
return;
pHumanPlayer->EmitSound( inputdata.value.String() );
}
void CTrainingModeLogic::InputWaitForTimerOrKeypress( inputdata_t &inputdata )
{
if ( !TFGameRules()->IsInTraining() )
return;
m_waitingForKeypressTimer = gEntList.FindEntityByName( NULL, inputdata.value.String() );
TFGameRules()->SetIsWaitingForTrainingContinue( m_waitingForKeypressTimer.Get() != NULL );
}
void CTrainingModeLogic::InputSetNextMap( inputdata_t &inputdata )
{
m_nextMapName = AllocPooledString( inputdata.value.String() );
}
void CTrainingModeLogic::InputForcePlayerSwapToWeapon( inputdata_t &inputdata )
{
CTFPlayer* pHumanPlayer = ToTFPlayer( UTIL_GetListenServerHost() );
if (NULL == pHumanPlayer)
return;
CBaseCombatWeapon *pWeapon = NULL;
if ( FStrEq( inputdata.value.String(), "primary" ) )
{
pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_PRIMARY );
}
else if ( FStrEq( inputdata.value.String(), "secondary" ) )
{
pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_SECONDARY );
}
else if ( FStrEq( inputdata.value.String(), "melee" ) )
{
pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_MELEE );
}
else if ( FStrEq( inputdata.value.String(), "grenade" ) )
{
pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_GRENADE );
}
else if ( FStrEq( inputdata.value.String(), "building" ) )
{
pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_BUILDING );
}
else if ( FStrEq( inputdata.value.String(), "pda" ) )
{
pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_PDA );
}
else if ( FStrEq( inputdata.value.String(), "item1" ) )
{
pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_ITEM1 );
}
else if ( FStrEq( inputdata.value.String(), "item2" ) )
{
pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_ITEM2 );
}
if ( pWeapon )
{
pHumanPlayer->Weapon_Switch( pWeapon );
}
}
LINK_ENTITY_TO_CLASS( tf_logic_multiple_escort, CMultipleEscort );
LINK_ENTITY_TO_CLASS( tf_logic_hybrid_ctf_cp, CHybridMap_CTF_CP );
LINK_ENTITY_TO_CLASS( tf_logic_medieval, CMedievalLogic );
BEGIN_DATADESC(CTFHolidayEntity)
DEFINE_KEYFIELD( m_nHolidayType, FIELD_INTEGER, "holiday_type" ),
DEFINE_KEYFIELD( m_nTauntInHell, FIELD_INTEGER, "tauntInHell" ),
DEFINE_KEYFIELD( m_nAllowHaunting, FIELD_INTEGER, "allowHaunting" ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "HalloweenSetUsingSpells", InputHalloweenSetUsingSpells ),
DEFINE_INPUTFUNC( FIELD_STRING, "Halloween2013TeleportToHell", InputHalloweenTeleportToHell ),
END_DATADESC();
LINK_ENTITY_TO_CLASS( tf_logic_holiday, CTFHolidayEntity );
void CTFHolidayEntity::InputHalloweenSetUsingSpells( inputdata_t &inputdata )
{
if ( !TFGameRules() )
return;
TFGameRules()->SetUsingSpells( ( inputdata.value.Int() == 0 ) ? false : true );
}
void CTFHolidayEntity::InputHalloweenTeleportToHell( inputdata_t &inputdata )
{
m_nWinningTeam = FStrEq( "red", inputdata.value.String() ) ? TF_TEAM_RED : TF_TEAM_BLUE;
CUtlVector< CTFPlayer * > vecPlayers;
CollectPlayers( &vecPlayers, TEAM_ANY, false );
FOR_EACH_VEC( vecPlayers, i )
{
CTFPlayer *pPlayer = vecPlayers[i];
// Only do these effects if the player is alive
if ( !pPlayer->IsAlive() )
continue;
// Fade to white
color32 fadeColor = {255,255,255,255};
UTIL_ScreenFade( pPlayer, fadeColor, 2.f, 0.5, FFADE_OUT | FFADE_PURGE );
// Do a zoom in effect
pPlayer->SetFOV( pPlayer, 10.f, 2.5f, 0.f );
// Rumble like something important happened
UTIL_ScreenShake(pPlayer->GetAbsOrigin(), 100.f, 150, 4.f, 0.f, SHAKE_START, true );
}
// Play a sound for all players
TFGameRules()->BroadcastSound( 255, "Halloween.hellride" );
SetContextThink( &CTFHolidayEntity::Teleport, gpGlobals->curtime + 2.5f, "TeleportToHell" );
}
void CTFHolidayEntity::Teleport()
{
RemoveAll2013HalloweenTeleportSpellsInMidFlight();
const char *pszRedString = ( m_nWinningTeam == TF_TEAM_RED ) ? "winner" : "loser";
const char *pszBlueString = ( m_nWinningTeam == TF_TEAM_BLUE ) ? "winner" : "loser";
CUtlVector< CTFPlayer* > vecTeleportedPlayers;
TFGameRules()->TeleportPlayersToTargetEntities( TF_TEAM_RED, CFmtStr( "spawn_loot_%s" , pszRedString ), &vecTeleportedPlayers );
TFGameRules()->TeleportPlayersToTargetEntities( TF_TEAM_BLUE, CFmtStr( "spawn_loot_%s" , pszBlueString ), &vecTeleportedPlayers );
// clear dancer
m_vecDancers.RemoveAll();
// remove players' projectiles and buildings from world
TFGameRules()->RemoveAllProjectilesAndBuildings();
FOR_EACH_VEC( vecTeleportedPlayers, i )
{
CTFPlayer *pPlayer = vecTeleportedPlayers[i];
// Roll a new, low-tier spell
CTFSpellBook *pSpellBook = dynamic_cast< CTFSpellBook* >( pPlayer->GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ) );
if ( pSpellBook )
{
pSpellBook->ClearSpell();
if ( TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_HIGHTOWER ) )
{
pSpellBook->RollNewSpell( 0, true );
}
}
// Do a zoom effect
pPlayer->SetFOV( pPlayer, tf_teleporter_fov_start.GetInt() );
pPlayer->SetFOV( pPlayer, 0, 1.f, tf_teleporter_fov_start.GetInt() );
// Screen flash
color32 fadeColor = {255,255,255,100};
UTIL_ScreenFade( pPlayer, fadeColor, 0.25, 0.4, FFADE_IN );
const float flDanceTime = 6.f;
if ( ShouldTauntInHell() || ( TFGameRules()->GetHalloweenScenario() == CTFGameRules::HALLOWEEN_SCENARIO_HIGHTOWER ) )
{
pPlayer->m_Shared.AddCond( TF_COND_HALLOWEEN_THRILLER, flDanceTime );
}
pPlayer->m_Shared.AddCond( TF_COND_HALLOWEEN_IN_HELL );
// Losers get their health set to max. Winners get overhealed
bool bIsWinner = ( pPlayer->GetTeamNumber() == m_nWinningTeam );
float flMax = bIsWinner ? ( pPlayer->GetMaxHealth() * 1.6f ) : ( pPlayer->GetMaxHealth() * 1.1 );
float flToHeal = flMax - pPlayer->GetHealth();
// Overheal the winning team, and just restore the losing team to full health
pPlayer->m_Shared.Heal( pPlayer, flToHeal / flDanceTime, bIsWinner ? 1.5f : 1.f, 1.0f );
// Give them full ammo
pPlayer->GiveAmmo( 1000, TF_AMMO_PRIMARY );
pPlayer->GiveAmmo( 1000, TF_AMMO_SECONDARY );
pPlayer->GiveAmmo( 1000, TF_AMMO_METAL );
pPlayer->GiveAmmo( 1000, TF_AMMO_GRENADES1 );
pPlayer->GiveAmmo( 1000, TF_AMMO_GRENADES2 );
pPlayer->GiveAmmo( 1000, TF_AMMO_GRENADES3 );
// Refills weapon clips, too
for ( int i = 0; i < MAX_WEAPONS; i++ )
{
CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase* >( pPlayer->GetWeapon( i ) );
if ( !pWeapon )
continue;
pWeapon->GiveDefaultAmmo();
if ( pWeapon->IsEnergyWeapon() )
{
pWeapon->WeaponRegenerate();
}
}
m_vecDancers.AddToTail( pPlayer );
}
// Set this flag. Lets us check elsewhere if it's hell time
if ( TFGameRules() )
{
TFGameRules()->SetPlayersInHell( true );
}
if ( ShouldTauntInHell() || ( TFGameRules()->GetHalloweenScenario() == CTFGameRules::HALLOWEEN_SCENARIO_HIGHTOWER ) )
{
const float flDanceTime = 0.5f;
const float flDanceDuration = 2.75f;
SetContextThink( &CTFHolidayEntity::HalloweenTeleportToHellDanceThink, gpGlobals->curtime + flDanceTime, "DanceThink1" );
SetContextThink( &CTFHolidayEntity::HalloweenTeleportToHellDanceThink, gpGlobals->curtime + flDanceTime + flDanceDuration, "DanceThink2" );
}
}
void CTFHolidayEntity::HalloweenTeleportToHellDanceThink( void )
{
FOR_EACH_VEC( m_vecDancers, i )
{
CTFPlayer* pPlayer = m_vecDancers[i];
if ( !pPlayer )
continue;
// Dance
pPlayer->Taunt();
}
}
void CTFHolidayEntity::FireGameEvent( IGameEvent *event )
{
const char *eventName = event->GetName();
#ifdef GAME_DLL
if ( !Q_strcmp( eventName, "player_turned_to_ghost" )
|| !Q_strcmp( eventName, "player_disconnect" )
|| !Q_strcmp( eventName, "player_team" ))
{
if ( TFGameRules()->ArePlayersInHell() )
{
CUtlVector< CTFPlayer * > vecPlayers;
CollectPlayers( &vecPlayers, TF_TEAM_RED, true );
CollectPlayers( &vecPlayers, TF_TEAM_BLUE, true, true );
FOR_EACH_VEC( vecPlayers, i )
{
// If everyone is a ghost
if ( !vecPlayers[i]->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
return;
}
// Everyone is a ghost. Stalemate!
TFGameRules()->SetWinningTeam( TEAM_UNASSIGNED, WINREASON_STALEMATE, true, false );
}
}
#endif
}
BEGIN_DATADESC(CKothLogic)
DEFINE_KEYFIELD( m_nTimerInitialLength, FIELD_INTEGER, "timer_length" ),
DEFINE_KEYFIELD( m_nTimeToUnlockPoint, FIELD_INTEGER, "unlock_point" ),
DEFINE_INPUTFUNC( FIELD_VOID, "RoundSpawn", InputRoundSpawn ),
DEFINE_INPUTFUNC( FIELD_VOID, "RoundActivate", InputRoundActivate ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetRedTimer", InputSetRedTimer ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetBlueTimer", InputSetBlueTimer ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "AddRedTimer", InputAddRedTimer ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "AddBlueTimer", InputAddBlueTimer ),
END_DATADESC();
LINK_ENTITY_TO_CLASS( tf_logic_koth, CKothLogic );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CKothLogic::InputRoundSpawn( inputdata_t &input )
{
if ( TFGameRules() && TFGameRules()->IsInKothMode() )
{
// create the koth team_round_timer entities
variant_t sVariant;
sVariant.SetInt( m_nTimerInitialLength );
CTeamRoundTimer *pTimer = NULL;
pTimer = (CTeamRoundTimer*)CBaseEntity::Create( "team_round_timer", vec3_origin, vec3_angle );
if ( pTimer )
{
TFGameRules()->SetKothTeamTimer( TF_TEAM_BLUE, pTimer );
pTimer->SetName( MAKE_STRING( "zz_blue_koth_timer" ) );
pTimer->SetShowInHud( true );
pTimer->AcceptInput( "SetTime", NULL, NULL, sVariant, 0 );
pTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 );
m_hBlueTimer = pTimer;
}
pTimer = (CTeamRoundTimer*)CBaseEntity::Create( "team_round_timer", vec3_origin, vec3_angle );
if ( pTimer )
{
TFGameRules()->SetKothTeamTimer( TF_TEAM_RED, pTimer );
pTimer->SetName( MAKE_STRING( "zz_red_koth_timer" ) );
pTimer->SetShowInHud( true );
pTimer->AcceptInput( "SetTime", NULL, NULL, sVariant, 0 );
pTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 );
m_hRedTimer = pTimer;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CKothLogic::InputRoundActivate( inputdata_t &inputdata )
{
if ( TFGameRules() && TFGameRules()->IsInKothMode() )
{
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
if ( pMaster )
{
variant_t sVariant;
sVariant.SetInt( m_nTimeToUnlockPoint );
for ( int i = 0 ; i < pMaster->GetNumPoints() ; i++ )
{
CTeamControlPoint *pPoint = pMaster->GetControlPoint( i );
if ( pPoint )
{
pPoint->AcceptInput( "SetLocked", NULL, NULL, sVariant, 0 );
if ( m_nTimeToUnlockPoint > 0 )
{
pPoint->AcceptInput( "SetUnlockTime", NULL, NULL, sVariant, 0 );
}
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CKothLogic::InputSetRedTimer( inputdata_t &inputdata )
{
if ( TFGameRules() && TFGameRules()->IsInKothMode() )
{
if ( m_hRedTimer )
{
m_hRedTimer->SetTimeRemaining( inputdata.value.Int() );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CKothLogic::InputSetBlueTimer( inputdata_t &inputdata )
{
if ( TFGameRules() && TFGameRules()->IsInKothMode() )
{
if ( m_hBlueTimer )
{
m_hBlueTimer->SetTimeRemaining( inputdata.value.Int() );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CKothLogic::InputAddRedTimer( inputdata_t &inputdata )
{
if ( TFGameRules() && TFGameRules()->IsInKothMode() )
{
if ( m_hRedTimer )
{
m_hRedTimer->AddTimerSeconds( inputdata.value.Int() );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CKothLogic::InputAddBlueTimer( inputdata_t &inputdata )
{
if ( TFGameRules() && TFGameRules()->IsInKothMode() )
{
if ( m_hBlueTimer )
{
m_hBlueTimer->AddTimerSeconds( inputdata.value.Int() );
}
}
}
BEGIN_DATADESC(CCPTimerLogic)
DEFINE_KEYFIELD( m_iszControlPointName, FIELD_STRING, "controlpoint" ),
DEFINE_KEYFIELD( m_nTimerLength, FIELD_INTEGER, "timer_length" ),
DEFINE_INPUTFUNC( FIELD_VOID, "RoundSpawn", InputRoundSpawn ),
DEFINE_OUTPUT( m_onCountdownStart, "OnCountdownStart" ),
DEFINE_OUTPUT( m_onCountdown15SecRemain, "OnCountdown15SecRemain" ),
DEFINE_OUTPUT( m_onCountdown10SecRemain, "OnCountdown10SecRemain" ),
DEFINE_OUTPUT( m_onCountdown5SecRemain, "OnCountdown5SecRemain" ),
DEFINE_OUTPUT( m_onCountdownEnd, "OnCountdownEnd" ),
END_DATADESC();
LINK_ENTITY_TO_CLASS( tf_logic_cp_timer, CCPTimerLogic );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CCPTimerLogic::InputRoundSpawn( inputdata_t &input )
{
if ( m_iszControlPointName != NULL_STRING )
{
// We need to re-find our control point, because they're recreated over round restarts
m_hControlPoint = dynamic_cast<CTeamControlPoint*>( gEntList.FindEntityByName( NULL, m_iszControlPointName ) );
if ( !m_hControlPoint )
{
Warning( "%s failed to find control point named '%s'\n", GetClassname(), STRING(m_iszControlPointName) );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CCPTimerLogic::TimerMayExpire( void )
{
if ( m_hControlPoint )
{
if ( TeamplayGameRules()->TeamMayCapturePoint( TF_TEAM_BLUE, m_hControlPoint->GetPointIndex() ) )
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CCPTimerLogic::Think( void )
{
if ( !TFGameRules() || !ObjectiveResource() )
return;
if ( TFGameRules()->State_Get() == GR_STATE_TEAM_WIN )
{
// game has already been won, our job is done
m_pointTimer.Invalidate();
SetContextThink( &CCPTimerLogic::Think, gpGlobals->curtime + 0.15, CP_TIMER_THINK );
}
if ( m_hControlPoint )
{
if ( TeamplayGameRules()->TeamMayCapturePoint( TF_TEAM_BLUE, m_hControlPoint->GetPointIndex() ) )
{
if ( !m_pointTimer.HasStarted() )
{
m_pointTimer.Start( m_nTimerLength );
m_onCountdownStart.FireOutput( this, this );
ObjectiveResource()->SetCPTimerTime( m_hControlPoint->GetPointIndex(), gpGlobals->curtime + m_nTimerLength );
}
else
{
if ( m_pointTimer.IsElapsed() )
{
// the point must be fully owned by the owner before we reset
if ( ObjectiveResource()->GetCappingTeam( m_hControlPoint->GetPointIndex() ) == TEAM_UNASSIGNED )
{
m_pointTimer.Invalidate();
m_onCountdownEnd.FireOutput( this, this );
m_bFire15SecRemain = m_bFire10SecRemain = m_bFire5SecRemain = true;
ObjectiveResource()->SetCPTimerTime( m_hControlPoint->GetPointIndex(), -1.0f );
}
}
else
{
float flRemainingTime = m_pointTimer.GetRemainingTime();
if ( flRemainingTime <= 15.0f && m_bFire15SecRemain )
{
m_bFire15SecRemain = false;
}
else if ( flRemainingTime <= 10.0f && m_bFire10SecRemain )
{
m_bFire10SecRemain = false;
}
else if ( flRemainingTime <= 5.0f && m_bFire5SecRemain )
{
m_bFire5SecRemain = false;
}
}
}
}
else
{
m_pointTimer.Invalidate();
}
}
SetContextThink( &CCPTimerLogic::Think, gpGlobals->curtime + 0.15, CP_TIMER_THINK );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::AddPlayerToQueue( CTFPlayer *pPlayer )
{
//Already in Queue
if ( m_hArenaPlayerQueue.Find( pPlayer ) != m_hArenaPlayerQueue.InvalidIndex() )
return;
if ( pPlayer->IsArenaSpectator() == true )
return;
// Msg( "AddPlayerToQueue:: Adding to queue: %s\n", pPlayer->GetPlayerName() );
m_hArenaPlayerQueue.AddToTail( pPlayer );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::AddPlayerToQueueHead( CTFPlayer *pPlayer )
{
//Already in Queue
if ( m_hArenaPlayerQueue.Find( pPlayer ) != m_hArenaPlayerQueue.InvalidIndex() )
return;
m_hArenaPlayerQueue.AddToHead( pPlayer );
// Msg( "AddPlayerToQueueHead:: Adding to queue: %s\n", pPlayer->GetPlayerName() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::RemovePlayerFromQueue( CTFPlayer *pPlayer )
{
//Not in list?
if ( m_hArenaPlayerQueue.Find( pPlayer ) == m_hArenaPlayerQueue.InvalidIndex() )
return;
m_hArenaPlayerQueue.FindAndRemove( pPlayer );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::OnNavMeshLoad( void )
{
TheNavMesh->SetPlayerSpawnName( "info_player_teamspawn" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::OnDispenserBuilt( CBaseEntity *dispenser )
{
if ( !m_healthVector.HasElement( dispenser ) )
{
m_healthVector.AddToTail( dispenser );
}
if ( !m_ammoVector.HasElement( dispenser ) )
{
m_ammoVector.AddToTail( dispenser );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::OnDispenserDestroyed( CBaseEntity *dispenser )
{
m_healthVector.FindAndFastRemove( dispenser );
m_ammoVector.FindAndFastRemove( dispenser );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CPhysicsProp *CreateBeachBall( const Vector &vSpawnPos, const QAngle &qSpawnAngles );
CPhysicsProp *CreateSoccerBall( const Vector &vSpawnPos, const QAngle &qSpawnAngles );
#ifdef STAGING_ONLY
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
void CC_Spawn_SoccerBall( const CCommand& args )
{
CBasePlayer *pPlayer = UTIL_GetCommandClient();
if ( pPlayer )
{
trace_t tr;
Vector forward;
pPlayer->EyeVectors( &forward );
UTIL_TraceLine( pPlayer->EyePosition(),
pPlayer->EyePosition() + forward * MAX_TRACE_LENGTH,MASK_NPCSOLID,
pPlayer, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction != 1.0 )
{
CreateSoccerBall( tr.endpos, vec3_angle );
}
}
}
ConCommand tf_spawn_soccerball( "tf_spawn_soccerball", CC_Spawn_SoccerBall, "", FCVAR_CHEAT );
#endif // STAGING_ONLY
static bool CanFindBallSpawnLocation( const Vector& vSearchOrigin, Vector *out_pvDropSpot )
{
// find clear space to drop the ball
for( float angle = 0.0f; angle < 2.0f * M_PI; angle += 0.2f )
{
Vector forward;
FastSinCos( angle, &forward.y, &forward.x );
forward.z = 0.0f;
const float ballRadius = 16.0f;
const float playerRadius = 20.0f;
Vector hullMins( -ballRadius, -ballRadius, -ballRadius );
Vector hullMaxs( ballRadius, ballRadius, ballRadius );
Vector dropSpot = vSearchOrigin + 1.2f * ( playerRadius + ballRadius ) * forward;
trace_t result;
UTIL_TraceHull( dropSpot, dropSpot, hullMins, hullMaxs, MASK_PLAYERSOLID, NULL, &result );
if ( !result.DidHit() )
{
*out_pvDropSpot = dropSpot;
return true;
}
}
return false;
}
void CTFGameRules::OnPlayerSpawned( CTFPlayer *pPlayer )
{
// coach?
CSteamID steamIDForPlayer;
if ( pPlayer->GetSteamID( &steamIDForPlayer ) )
{
// find out if we are supposed to coach
int idx = m_mapCoachToStudentMap.Find( steamIDForPlayer.GetAccountID() );
if ( m_mapCoachToStudentMap.IsValidIndex( idx ) )
{
// find student
uint32 studentAccountID = m_mapCoachToStudentMap[idx];
CSteamID steamIDForStudent;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CTFPlayer *pPotentialStudent = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( NULL == pPotentialStudent )
{
continue;
}
// is this the student?
if ( pPotentialStudent->GetSteamID( &steamIDForStudent ) && steamIDForStudent.GetAccountID() == studentAccountID )
{
Coaching_Start( pPlayer, pPotentialStudent );
// @todo (Tom Bui): Not sure this is required--nothing seems to use it
// engine->ClientCommand( pPlayer->edict(), "cl_spec_mode %d", OBS_MODE_IN_EYE );
// finally, notify the GC
GCSDK::CProtoBufMsg< CMsgTFCoaching_CoachJoined > msg( k_EMsgGCCoaching_CoachJoined );
msg.Body().set_account_id_coach( steamIDForPlayer.GetAccountID() );
GCClientSystem()->BSendMessage( msg );
break;
}
}
// remove from the map now so the coach can join later as a normal player if they DC
m_mapCoachToStudentMap.RemoveAt( idx );
}
}
// warp coach to student?
if ( pPlayer->GetCoach() )
{
// warp the coach to student
pPlayer->GetCoach()->SetObserverTarget( pPlayer );
pPlayer->GetCoach()->StartObserverMode( OBS_MODE_CHASE );
}
// notify training
if ( m_hTrainingModeLogic )
{
m_hTrainingModeLogic->OnPlayerSpawned( pPlayer );
}
#ifdef GAME_DLL
if ( !IsInTraining() )
{
// Birthday beachball ball spawning.
if ( IsBirthday() &&
!m_hasSpawnedToy &&
pPlayer->GetTeamNumber() == TF_TEAM_BLUE && // always give ball to first blue player, since they are often trapped during setup
RandomInt( 0, 100 ) < tf_birthday_ball_chance.GetInt() )
{
Vector vDropSpot;
if ( CanFindBallSpawnLocation( pPlayer->WorldSpaceCenter(), &vDropSpot ) )
{
CPhysicsProp *ball = CreateBeachBall( vDropSpot, pPlayer->GetAbsAngles() );
if ( ball )
{
m_hasSpawnedToy = true;
// turn on the birthday skin
ball->m_nSkin = 1;
}
}
}
// Soccer ball spawning if wearing soccer cleats.
if ( !m_bHasSpawnedSoccerBall[ pPlayer->GetTeamNumber() ] )
{
enum
{
kSpawnWith_Nothing = 0,
kSpawnWith_SoccerBall = 1,
};
int iSpawnWithPhysicsToy = kSpawnWith_Nothing;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer, iSpawnWithPhysicsToy, spawn_with_physics_toy );
if ( iSpawnWithPhysicsToy == kSpawnWith_SoccerBall )
{
Vector vDropSpot;
if ( CanFindBallSpawnLocation( pPlayer->WorldSpaceCenter(), &vDropSpot ) )
{
CPhysicsProp *ball = CreateSoccerBall( vDropSpot, pPlayer->GetAbsAngles() );
if ( ball )
{
m_bHasSpawnedSoccerBall[ pPlayer->GetTeamNumber() ] = true;
// turn on the birthday skin
ball->m_nSkin = pPlayer->GetTeamNumber() == TF_TEAM_BLUE ? 1 : 0;
}
}
}
}
}
#endif
}
class CGCCoaching_CoachJoining : public GCSDK::CGCClientJob
{
public:
CGCCoaching_CoachJoining( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {}
virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
{
GCSDK::CProtoBufMsg< CMsgTFCoaching_CoachJoining > msg( pNetPacket );
if ( TFGameRules() )
{
TFGameRules()->OnCoachJoining( msg.Body().account_id_coach(), msg.Body().account_id_student() );
}
return true;
}
};
GC_REG_JOB( GCSDK::CGCClient, CGCCoaching_CoachJoining, "CGCCoaching_CoachJoining", k_EMsgGCCoaching_CoachJoining, GCSDK::k_EServerTypeGCClient );
class CGCCoaching_RemoveCurrentCoach : public GCSDK::CGCClientJob
{
public:
CGCCoaching_RemoveCurrentCoach( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {}
virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
{
GCSDK::CProtoBufMsg< CMsgTFCoaching_RemoveCurrentCoach > msg( pNetPacket );
if ( TFGameRules() )
{
TFGameRules()->OnRemoveCoach( msg.Body().account_id_coach() );
}
return true;
}
};
GC_REG_JOB( GCSDK::CGCClient, CGCCoaching_RemoveCurrentCoach, "CGCCoaching_RemoveCurrentCoach", k_EMsgGCCoaching_RemoveCurrentCoach, GCSDK::k_EServerTypeGCClient );
class CGCUseServerModificationItemJob : public GCSDK::CGCClientJob
{
public:
CGCUseServerModificationItemJob( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {}
virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
{
GCSDK::CProtoBufMsg<CMsgGC_GameServer_UseServerModificationItem> msg( pNetPacket );
// If this server doesn't have the capability to call a vote right now for whatever reason, we
// give up and return immediate failure to the GC. If the vote gets called, we'll send up pass/fail
// when it finishes.
if ( !g_voteController || !g_voteController->CreateVote( DEDICATED_SERVER, "eternaween", "" ) )
{
GCSDK::CProtoBufMsg<CMsgGC_GameServer_UseServerModificationItem_Response> msgResponse( k_EMsgGC_GameServer_UseServerModificationItem_Response );
msgResponse.Body().set_server_response_code( CMsgGC_GameServer_UseServerModificationItem_Response::kServerModificationItemServerResponse_NoVoteCalled );
m_pGCClient->BSendMessage( msgResponse );
}
return true;
}
};
GC_REG_JOB( GCSDK::CGCClient, CGCUseServerModificationItemJob, "CGCUseServerModificationItemJob", k_EMsgGC_GameServer_UseServerModificationItem, GCSDK::k_EServerTypeGCClient );
class CGCUpdateServerModificationItemStateJob : public GCSDK::CGCClientJob
{
public:
CGCUpdateServerModificationItemStateJob( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {}
virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
{
GCSDK::CProtoBufMsg<CMsgGC_GameServer_ServerModificationItem> msg( pNetPacket );
switch ( msg.Body().modification_type() )
{
case kGameServerModificationItem_Halloween:
tf_item_based_forced_holiday.SetValue( msg.Body().active() ? kHoliday_Halloween : kHoliday_None );
g_fEternaweenAutodisableTime = engine->Time() + (SERVER_MODIFICATION_ITEM_DURATION_IN_MINUTES * 60.0f);
if ( TFGameRules() )
{
TFGameRules()->FlushAllAttributeCaches();
}
break;
default:
Warning( "%s: unknown modification type %u for server item.\n", __FUNCTION__, msg.Body().modification_type() );
break;
}
return true;
}
};
GC_REG_JOB( GCSDK::CGCClient, CGCUpdateServerModificationItemStateJob, "CGCUpdateServerModificationItemStateJob", k_EMsgGC_GameServer_ModificationItemState, GCSDK::k_EServerTypeGCClient );
#ifdef _DEBUG
CON_COMMAND( coaching_stop, "Stop coaching" )
{
CTFPlayer* pCoach = ToTFPlayer( UTIL_GetListenServerHost() );
Coaching_Stop( pCoach );
}
CON_COMMAND( coaching_remove_coach, "Remove current coach" )
{
CTFPlayer* pStudent = ToTFPlayer( UTIL_GetListenServerHost() );
CTFPlayer *pCoach = pStudent->GetCoach();
if ( pCoach )
{
Coaching_Stop( pCoach );
}
}
CON_COMMAND( coaching_force_coach, "Force self as coach" )
{
CTFPlayer* pCoachPlayer = ToTFPlayer( UTIL_GetListenServerHost() );
if ( pCoachPlayer && TFGameRules() )
{
for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
{
CTFPlayer *pStudentPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( pStudentPlayer != pCoachPlayer )
{
Coaching_Start( pCoachPlayer, pStudentPlayer );
break;
}
}
}
}
CON_COMMAND( coaching_force_student, "Force self as student" )
{
CTFPlayer* pStudentPlayer = ToTFPlayer( UTIL_GetListenServerHost() );
if ( pStudentPlayer && TFGameRules() )
{
for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
{
CTFPlayer *pCoachPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( pCoachPlayer != pStudentPlayer )
{
Coaching_Start( pCoachPlayer, pStudentPlayer );
break;
}
}
}
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::OnCoachJoining( uint32 unCoachAccountID, uint32 unStudentAccountID )
{
m_mapCoachToStudentMap.Insert( unCoachAccountID, unStudentAccountID );
// see if the coach is on the server already
CSteamID steamIDForCoach;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CTFPlayer *pPotentialCoach = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( NULL == pPotentialCoach )
{
continue;
}
// coach is here, force them to respawn, which will set them up as a coach
if ( pPotentialCoach->GetSteamID( &steamIDForCoach ) && steamIDForCoach.GetAccountID() == unCoachAccountID )
{
pPotentialCoach->ForceRespawn();
return;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::OnRemoveCoach( uint32 unCoachAccountID )
{
m_mapCoachToStudentMap.Remove( unCoachAccountID );
for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
{
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
CSteamID steamID;
if ( pPlayer && pPlayer->GetSteamID( &steamID ) && steamID.GetAccountID() == unCoachAccountID )
{
Coaching_Stop( pPlayer );
return;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Activates 100% crits for an entire team for a short period of time
//-----------------------------------------------------------------------------
void CTFGameRules::HandleCTFCaptureBonus( int nTeam )
{
float flBonusTime = GetCTFCaptureBonusTime();
if ( flBonusTime <= 0 )
return;
for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
{
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( pPlayer && pPlayer->IsAlive() && pPlayer->GetTeamNumber() == nTeam )
{
pPlayer->m_Shared.AddCond( TF_COND_CRITBOOSTED_CTF_CAPTURE, flBonusTime );
}
}
}
#endif
int CTFGameRules::GetStatsMinimumPlayers( void )
{
if ( IsInArenaMode() == true )
{
return 1;
}
return 3;
}
int CTFGameRules::GetStatsMinimumPlayedTime( void )
{
if ( IsInArenaMode() == true )
{
return tf_arena_preround_time.GetFloat();
}
return 4 * 60; //Default of 4 minutes
}
bool CTFGameRules::IsConnectedUserInfoChangeAllowed( CBasePlayer *pPlayer )
{
CTFPlayer* pTFPlayer = NULL;
#ifdef GAME_DLL
pTFPlayer = ToTFPlayer( pPlayer );
#else
pTFPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
#endif
if( pTFPlayer )
{
// We can change if we're not alive
if( pTFPlayer->m_lifeState != LIFE_ALIVE )
return true;
// We can change if we're not on team red or blue
int iPlayerTeam = pTFPlayer->GetTeamNumber();
if( ( iPlayerTeam != TF_TEAM_RED ) && ( iPlayerTeam != TF_TEAM_BLUE ) )
return true;
// We can change if we've respawned/changed classes within the last 2 seconds.
// This allows for <classname>.cfg files to change these types of convars
float flRespawnTime = 0.f;
#ifdef GAME_DLL
flRespawnTime = pTFPlayer->GetSpawnTime(); // Called everytime the player respawns
#else
flRespawnTime = pTFPlayer->GetClassChangeTime(); // Called when the player changes class and respawns
#endif
if( ( gpGlobals->curtime - flRespawnTime ) < 2.f )
return true;
}
return false;
}
//========================================================================================================================
// BONUS ROUND HANDLING
//========================================================================================================================
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldGoToBonusRound( void )
{
// Only do this on a Valve official server. Use the presence of our DLL as a key.
return false;
if ( IsInTournamentMode() )
return false;
// Don't do this on empty servers
if ( !BHavePlayers() )
return false;
if ( TFTeamMgr()->GetTeam( TF_TEAM_RED )->GetNumPlayers() <= 0 )
return false;
if ( TFTeamMgr()->GetTeam( TF_TEAM_BLUE )->GetNumPlayers() <= 0 )
return false;
// Random chance per round, based on time.
float flRoundTime = gpGlobals->curtime - m_flRoundStartTime;
float flChance = RemapValClamped( flRoundTime, (3 * 60), (30 * 60), 0.0, 0.75 ); // 75% chance for > 30 min rounds, down to 0% at 3 min rounds
float flRoll = RandomFloat( 0, 1 );
return ( flRoll < flChance );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::SetupOnBonusStart( void )
{
m_hBonusLogic.Set( dynamic_cast<CBonusRoundLogic*>(CreateEntityByName( "tf_logic_bonusround" )) );
if ( !m_hBonusLogic.Get()->InitBonusRound() )
{
State_Transition( GR_STATE_PREROUND );
return;
}
// Bring up the giveaway panel on all the players
for ( int i = 1; i <= MAX_PLAYERS; i++ )
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
if ( !pPlayer )
continue;
pPlayer->ShowViewPortPanel( PANEL_GIVEAWAY_ITEM );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::SetupOnBonusEnd( void )
{
if ( m_hBonusLogic.Get() )
{
UTIL_Remove( m_hBonusLogic.Get() );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::BonusStateThink( void )
{
}
//-----------------------------------------------------------------------------
// Purpose: We need to abort the bonus state because our item generation failed.
// Steam is probably down.
//-----------------------------------------------------------------------------
void CTFGameRules::BonusStateAbort( void )
{
if ( m_hBonusLogic.Get() )
{
m_hBonusLogic.Get()->SetBonusStateAborted( true );
}
State_Transition( GR_STATE_PREROUND );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::BetweenRounds_Start( void )
{
SetSetup( true );
if ( IsMannVsMachineMode() )
{
mp_tournament.SetValue( true );
RestartTournament();
SetInStopWatch( false );
char szName[16];
Q_strncpy( szName, "ROBOTS", MAX_TEAMNAME_STRING + 1 );
mp_tournament_blueteamname.SetValue( szName );
Q_strncpy( szName, "MANNCO", MAX_TEAMNAME_STRING + 1 );
mp_tournament_redteamname.SetValue( szName );
SetTeamReadyState( true, TF_TEAM_PVE_INVADERS );
}
for ( int i = 0; i < IBaseObjectAutoList::AutoList().Count(); ++i )
{
CBaseObject *pObj = static_cast<CBaseObject*>( IBaseObjectAutoList::AutoList()[i] );
if ( pObj->IsDisposableBuilding() || pObj->GetTeamNumber() == TF_TEAM_PVE_INVADERS )
{
pObj->DetonateObject();
}
}
if ( m_hGamerulesProxy )
{
m_hGamerulesProxy->StateEnterBetweenRounds();
}
if ( m_hCompetitiveLogicEntity )
{
m_hCompetitiveLogicEntity->OnSpawnRoomDoorsShouldUnlock();
}
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
if ( pMatchDesc && pMatchDesc->m_params.m_bAutoReady )
{
for ( int i = 1; i <= MAX_PLAYERS; i++ )
{
CTFPlayer *pPlayer = static_cast<CTFPlayer*>( UTIL_PlayerByIndex( i ) );
if ( !pPlayer )
continue;
if ( IsValidTFTeam( pPlayer->GetTeamNumber() ) && pPlayer->GetPlayerClass() && IsValidTFPlayerClass( pPlayer->GetPlayerClass()->GetClassIndex() ) )
{
PlayerReadyStatus_UpdatePlayerState( pPlayer, true );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::BetweenRounds_End( void )
{
SetInWaitingForPlayers( false );
SetSetup( false );
if ( IsMannVsMachineMode() )
{
SetInStopWatch( false );
mp_tournament_stopwatch.SetValue( false );
}
for ( int i = 1; i <= MAX_PLAYERS; i++ )
{
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( !pPlayer )
continue;
// We don't consider inactivity during BetweenRounds as idle
pPlayer->ResetIdleCheck();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::BetweenRounds_Think( void )
{
if ( UsePlayerReadyStatusMode() )
{
// Everyone is ready, or the drop-dead timer naturally ticked down to mp_tournament_readymode_countdown
bool bStartFinalCountdown = ( PlayerReadyStatus_ShouldStartCountdown() || ( m_flRestartRoundTime > 0 && (int)( m_flRestartRoundTime - gpGlobals->curtime ) == mp_tournament_readymode_countdown.GetInt() ) );
// It's the FINAL COUNTDOOOWWWNNnnnnnnnnn
float flDropDeadTime = gpGlobals->curtime + mp_tournament_readymode_countdown.GetFloat() + 0.1f;
if ( bStartFinalCountdown && ( m_flRestartRoundTime < 0 || m_flRestartRoundTime >= flDropDeadTime ) )
{
float flDelay = IsMannVsMachineMode() ? 10.f : mp_tournament_readymode_countdown.GetFloat();
m_flRestartRoundTime.Set( gpGlobals->curtime + flDelay );
ShouldResetScores( true, true );
ShouldResetRoundsPlayed( true );
if ( IsCompetitiveMode() )
{
m_flCompModeRespawnPlayersAtMatchStart = gpGlobals->curtime + 2.0;
}
}
// Required for UI state
if ( PlayerReadyStatus_HaveMinPlayersToEnable() )
{
CheckReadyRestart();
}
}
CheckRespawnWaves();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::PreRound_Start( void )
{
if ( m_hGamerulesProxy )
{
m_hGamerulesProxy->StateEnterPreRound();
}
if ( m_hCompetitiveLogicEntity )
{
m_hCompetitiveLogicEntity->OnSpawnRoomDoorsShouldLock();
}
BaseClass::PreRound_Start();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::PreRound_End( void )
{
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) && !IsInWaitingForPlayers() )
{
if ( RandomFloat( 0, 1 ) < HELLTOWER_RARE_LINE_CHANCE )
{
PlayHelltowerAnnouncerVO( HELLTOWER_VO_RED_ROUNDSTART_RARE, HELLTOWER_VO_BLUE_ROUNDSTART_RARE );
}
else
{
PlayHelltowerAnnouncerVO( HELLTOWER_VO_RED_ROUNDSTART, HELLTOWER_VO_BLUE_ROUNDSTART );
}
}
if ( m_hGamerulesProxy )
{
m_hGamerulesProxy->StateExitPreRound();
}
if ( m_hCompetitiveLogicEntity )
{
m_hCompetitiveLogicEntity->OnSpawnRoomDoorsShouldUnlock();
}
BaseClass::PreRound_End();
}
//-----------------------------------------------------------------------------
// Purpose: Compute internal vectors of health and ammo locations
//-----------------------------------------------------------------------------
void CTFGameRules::ComputeHealthAndAmmoVectors( void )
{
m_ammoVector.RemoveAll();
m_healthVector.RemoveAll();
CBaseEntity *pEnt = gEntList.FirstEnt();
while( pEnt )
{
if ( pEnt->ClassMatches( "func_regenerate" ) || pEnt->ClassMatches( "item_healthkit*" ) )
{
m_healthVector.AddToTail( pEnt );
}
if ( pEnt->ClassMatches( "func_regenerate" ) || pEnt->ClassMatches( "item_ammopack*" ) )
{
m_ammoVector.AddToTail( pEnt );
}
pEnt = gEntList.NextEnt( pEnt );
}
m_areHealthAndAmmoVectorsReady = true;
}
//-----------------------------------------------------------------------------
// Purpose: Return vector of health entities
//-----------------------------------------------------------------------------
const CUtlVector< CHandle< CBaseEntity > > &CTFGameRules::GetHealthEntityVector( void )
{
// lazy-populate health and ammo vector since some maps (Dario!) move these entities around between stages
if ( !m_areHealthAndAmmoVectorsReady )
{
ComputeHealthAndAmmoVectors();
}
return m_healthVector;
}
//-----------------------------------------------------------------------------
// Purpose: Return vector of ammo entities
//-----------------------------------------------------------------------------
const CUtlVector< CHandle< CBaseEntity > > &CTFGameRules::GetAmmoEntityVector( void )
{
// lazy-populate health and ammo vector since some maps (Dario!) move these entities around between stages
if ( !m_areHealthAndAmmoVectorsReady )
{
ComputeHealthAndAmmoVectors();
}
return m_ammoVector;
}
//-----------------------------------------------------------------------------
// Purpose: Return the Payload cart the given team needs to push to win, or NULL if none currently exists
//-----------------------------------------------------------------------------
CHandle< CTeamTrainWatcher > CTFGameRules::GetPayloadToPush( int pushingTeam ) const
{
if ( TFGameRules()->GetGameType() != TF_GAMETYPE_ESCORT )
return NULL;
if ( pushingTeam == TF_TEAM_RED )
{
if ( m_redPayloadToPush == NULL )
{
// find our cart!
if ( TFGameRules()->HasMultipleTrains() )
{
// find the red cart
}
else
{
// normal Escort scenario, red always blocks
return NULL;
}
}
return m_redPayloadToPush;
}
if ( pushingTeam == TF_TEAM_BLUE )
{
if ( m_bluePayloadToPush == NULL )
{
if ( TFGameRules()->HasMultipleTrains() )
{
// find the blue cart
}
else
{
// only one cart in the map, and we need to push it
CTeamTrainWatcher *watcher = NULL;
while( ( watcher = dynamic_cast< CTeamTrainWatcher * >( gEntList.FindEntityByClassname( watcher, "team_train_watcher" ) ) ) != NULL )
{
if ( !watcher->IsDisabled() )
{
m_bluePayloadToPush = watcher;
break;
}
}
}
}
return m_bluePayloadToPush;
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Return the Payload cart the given player needs to block from advancing, or NULL if none currently exists
//-----------------------------------------------------------------------------
CHandle< CTeamTrainWatcher > CTFGameRules::GetPayloadToBlock( int blockingTeam ) const
{
if ( TFGameRules()->GetGameType() != TF_GAMETYPE_ESCORT )
return NULL;
if ( blockingTeam == TF_TEAM_RED )
{
if ( m_redPayloadToBlock == NULL )
{
// find our cart!
if ( TFGameRules()->HasMultipleTrains() )
{
// find the red cart
}
else
{
// normal Escort scenario, red always blocks
CTeamTrainWatcher *watcher = NULL;
while( ( watcher = dynamic_cast< CTeamTrainWatcher * >( gEntList.FindEntityByClassname( watcher, "team_train_watcher" ) ) ) != NULL )
{
if ( !watcher->IsDisabled() )
{
m_redPayloadToBlock = watcher;
break;
}
}
}
}
return m_redPayloadToBlock;
}
if ( blockingTeam == TF_TEAM_BLUE )
{
if ( m_bluePayloadToBlock == NULL )
{
if ( TFGameRules()->HasMultipleTrains() )
{
// find the blue cart
}
else
{
// normal Payload, blue never blocks
return NULL;
}
}
return m_bluePayloadToBlock;
}
return NULL;
}
#endif // GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::BuildBonusPlayerList( void )
{
if ( m_hBonusLogic.Get() )
{
m_hBonusLogic.Get()->BuildBonusPlayerList();
}
}
//-----------------------------------------------------------------------------
// Purpose: Item testing bot controls
//-----------------------------------------------------------------------------
void CTFGameRules::ItemTesting_SetupFromKV( KeyValues *pKV )
{
m_iItemTesting_BotAnim = pKV->GetInt( "bot_anim", TI_BOTANIM_IDLE );
int iAnimSpeed = pKV->GetInt( "bot_animspeed", 100 );
m_flItemTesting_BotAnimSpeed = ( (float)iAnimSpeed / 100.0f );
m_bItemTesting_BotForceFire = pKV->GetBool( "bot_force_fire" );
m_bItemTesting_BotTurntable = pKV->GetBool( "bot_turntable" );
m_bItemTesting_BotViewScan = pKV->GetBool( "bot_view_scan" );
}
//==================================================================================================================
// BONUS ROUND LOGIC
#ifndef CLIENT_DLL
EXTERN_SEND_TABLE( DT_ScriptCreatedItem );
#else
EXTERN_RECV_TABLE( DT_ScriptCreatedItem );
#endif
BEGIN_NETWORK_TABLE_NOBASE( CBonusRoundLogic, DT_BonusRoundLogic )
#ifdef CLIENT_DLL
RecvPropUtlVector( RECVINFO_UTLVECTOR( m_aBonusPlayerRoll ), MAX_PLAYERS, RecvPropInt( NULL, 0, 4 ) ),
RecvPropEHandle( RECVINFO( m_hBonusWinner ) ),
RecvPropDataTable(RECVINFO_DT(m_Item), 0, &REFERENCE_RECV_TABLE(DT_ScriptCreatedItem)),
#else
SendPropUtlVector( SENDINFO_UTLVECTOR( m_aBonusPlayerRoll ), MAX_PLAYERS, SendPropInt( NULL, 0, 4, 12, SPROP_UNSIGNED ) ),
SendPropEHandle( SENDINFO( m_hBonusWinner ) ),
SendPropDataTable(SENDINFO_DT(m_Item), &REFERENCE_SEND_TABLE(DT_ScriptCreatedItem)),
#endif
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( tf_logic_bonusround, CBonusRoundLogic );
IMPLEMENT_NETWORKCLASS_ALIASED( BonusRoundLogic, DT_BonusRoundLogic )
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBonusRoundLogic::BuildBonusPlayerList( void )
{
m_aBonusPlayerList.Purge();
for( int iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ )
{
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
if ( !pPlayer )
continue;
m_aBonusPlayerList.InsertNoSort( pPlayer );
}
m_aBonusPlayerList.RedoSort( true );
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBonusRoundLogic::InitBonusRound( void )
{
m_bAbortedBonusRound = false;
SetBonusItem( 0 );
m_hBonusWinner = NULL;
BuildBonusPlayerList();
// We actually precalculate the whole shebang.
m_aBonusPlayerRoll.SetSize( m_aBonusPlayerList.Count() );
for ( int i = 0; i < m_aBonusPlayerRoll.Count(); i++ )
{
m_aBonusPlayerRoll[i] = RandomInt( PLAYER_ROLL_MIN, PLAYER_ROLL_MAX );
}
// Sum up the bonus chances
int iTotal = 0;
CUtlVector<int> aBonusPlayerTotals;
aBonusPlayerTotals.SetSize( m_aBonusPlayerList.Count() );
for ( int i = 0; i < aBonusPlayerTotals.Count(); i++ )
{
aBonusPlayerTotals[i] = iTotal + m_aBonusPlayerRoll[i] + m_aBonusPlayerList[i]->m_Shared.GetItemFindBonus();
iTotal = aBonusPlayerTotals[i];
}
// Roll for who gets the item.
int iRoll = RandomInt( 0, iTotal );
for ( int i = 0; i < aBonusPlayerTotals.Count(); i++ )
{
if ( iRoll < aBonusPlayerTotals[i] )
{
m_hBonusWinner = m_aBonusPlayerList[i];
break;
}
}
if ( !m_hBonusWinner.Get() )
return false;
// Generate the item on the server for now
//CSteamID steamID;
//if ( !m_hBonusWinner.Get()->GetSteamID( &steamID ) )
const CSteamID *steamID = engine->GetGameServerSteamID();
if ( !steamID || !steamID->IsValid() )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBonusRoundLogic::SetBonusItem( itemid_t iItemID )
{
m_iBonusItemID = iItemID;
if ( !m_iBonusItemID )
{
m_Item.Invalidate();
return;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::SetBonusItem( itemid_t iItemID )
{
if ( m_hBonusLogic.Get() )
{
m_hBonusLogic.Get()->SetBonusItem( iItemID );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::ProcessVerboseLogOutput( void )
{
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
if ( pPlayer && ( pPlayer->GetTeamNumber() > TEAM_UNASSIGNED ) )
{
UTIL_LogPrintf( "\"%s<%i><%s><%s>\" position_report (position \"%d %d %d\")\n",
pPlayer->GetPlayerName(),
pPlayer->GetUserID(),
pPlayer->GetNetworkIDString(),
pPlayer->GetTeam()->GetName(),
(int)pPlayer->GetAbsOrigin().x,
(int)pPlayer->GetAbsOrigin().y,
(int)pPlayer->GetAbsOrigin().z );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::MatchSummaryTeleport()
{
bool bUseMatchSummaryStage = false;
#ifdef STAGING_ONLY
bUseMatchSummaryStage = tf_test_match_summary.GetBool();
#endif
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
if ( pMatchDesc && pMatchDesc->m_params.m_bUseMatchSummaryStage )
{
bUseMatchSummaryStage = true;
}
if ( bUseMatchSummaryStage && m_bMapHasMatchSummaryStage )
{
RespawnPlayers( true );
// find the observer target for the stage
CObserverPoint *pObserverPoint = dynamic_cast<CObserverPoint*>( gEntList.FindEntityByClassname( NULL, "info_observer_point" ) );
while( pObserverPoint )
{
if ( pObserverPoint->IsMatchSummary() )
{
pObserverPoint->SetDisabled( false );
SetRequiredObserverTarget( pObserverPoint );
break;
}
pObserverPoint = dynamic_cast<CObserverPoint*>( gEntList.FindEntityByClassname( pObserverPoint, "info_observer_point" ) );
}
// need to do this AFTER we respawn the players above or the conditions will be cleared
for ( int i = 1; i <= MAX_PLAYERS; i++ )
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
if ( !pPlayer )
continue;
pPlayer->AddFlag( FL_FROZEN );
if ( pPlayer->GetTeamNumber() >= FIRST_GAME_TEAM ) // spectators automatically get the RequiredObserverTarget that was set above
{
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
if ( pTFPlayer )
{
pTFPlayer->m_Shared.AddCond( ( pTFPlayer->GetTeamNumber() == GetWinningTeam() ) ? TF_COND_COMPETITIVE_WINNER : TF_COND_COMPETITIVE_LOSER );
if ( pObserverPoint )
{
pTFPlayer->SetViewEntity( pObserverPoint );
pTFPlayer->SetViewOffset( vec3_origin );
pTFPlayer->SetFOV( pObserverPoint, pObserverPoint->m_flFOV );
}
// use this to force the client player anim to face the right direction
pTFPlayer->SetTauntYaw( pTFPlayer->GetAbsAngles()[YAW] );
}
}
}
m_bPlayersAreOnMatchSummaryStage.Set( true );
}
}
#ifdef STAGING_ONLY
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::MatchSummaryTest( void )
{
mp_waitingforplayers_cancel.SetValue( 1 );
tf_test_match_summary.SetValue( 1 );
g_fGameOver = true;
TFGameRules()->State_Transition( GR_STATE_GAME_OVER );
m_flStateTransitionTime = gpGlobals->curtime + 99999.f;
TFGameRules()->MatchSummaryStart();
}
CON_COMMAND ( show_match_summary, "Show the match summary" )
{
if ( !UTIL_IsCommandIssuedByServerAdmin() )
return;
if ( args.ArgC() < 2 )
return;
if ( FStrEq( args[1], "start" ) )
{
TFGameRules()->MatchSummaryTest();
}
else if ( FStrEq( args[1], "end" ) )
{
TFGameRules()->MatchSummaryEnd();
}
}
#endif // STAGING_ONLY
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::MatchSummaryStart( void )
{
if ( BAttemptMapVoteRollingMatch() )
{
// Grab the final list of maps for users to vote on
UpdateNextMapVoteOptionsFromLobby();
m_eRematchState = NEXT_MAP_VOTE_STATE_WAITING_FOR_USERS_TO_VOTE;
}
for ( int i = 1; i <= MAX_PLAYERS; i++ )
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
if ( pPlayer )
{
pPlayer->AddFlag( FL_FROZEN );
}
}
m_bShowMatchSummary.Set( true );
m_flMatchSummaryTeleportTime = gpGlobals->curtime + 2.f;
if ( m_hGamerulesProxy )
{
m_hGamerulesProxy->MatchSummaryStart();
}
CBaseEntity *pLogicCase = NULL;
while ( ( pLogicCase = gEntList.FindEntityByName( pLogicCase, "competitive_stage_logic_case" ) ) != NULL )
{
if ( pLogicCase )
{
variant_t sVariant;
sVariant.SetInt( GetWinningTeam() );
pLogicCase->AcceptInput( "InValue", NULL, NULL, sVariant, 0 );
break;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::MatchSummaryEnd( void )
{
m_bShowMatchSummary.Set( false );
m_bPlayersAreOnMatchSummaryStage.Set( false );
SetRequiredObserverTarget( NULL );
for ( int i = 1; i <= MAX_PLAYERS; i++ )
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
if ( !pPlayer )
continue;
pPlayer->RemoveFlag( FL_FROZEN );
pPlayer->SetViewEntity( NULL );
pPlayer->SetFOV( pPlayer, 0 );
}
// reset bot convars here
static ConVarRef tf_bot_quota( "tf_bot_quota" );
tf_bot_quota.SetValue( tf_bot_quota.GetDefault() );
static ConVarRef tf_bot_quota_mode( "tf_bot_quota_mode" );
tf_bot_quota_mode.SetValue( tf_bot_quota_mode.GetDefault() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFGameRules::GetTeamAssignmentOverride( CTFPlayer *pTFPlayer, int iDesiredTeam, bool bAutoBalance /*= false*/ )
{
int iTeam = iDesiredTeam;
// Look up GC managed match info
CSteamID steamID;
pTFPlayer->GetSteamID( &steamID );
CMatchInfo *pMatch = GTFGCClientSystem()->GetLiveMatch();
int nMatchPlayers = pMatch ? pMatch->GetNumActiveMatchPlayers() : 0;
CMatchInfo::PlayerMatchData_t *pMatchPlayer = ( pMatch && steamID.IsValid() ) ? pMatch->GetMatchDataForPlayer( steamID ) : NULL;
if ( IsMannVsMachineMode() )
{
if ( !pTFPlayer->IsBot() && iTeam != TEAM_SPECTATOR )
{
if ( pMatchPlayer && !pMatchPlayer->bDropped )
{
// Part of the lobby match
Log( "MVM assigned %s to defending team (player is in lobby)\n", pTFPlayer->GetPlayerName() );
return TF_TEAM_PVE_DEFENDERS;
}
// Count ad-hoc players on defenders team
int nAdHocDefenders = 0;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
if ( !pPlayer || ( pPlayer->GetTeamNumber() != TF_TEAM_PVE_DEFENDERS ) )
{ continue; }
CSteamID steamID;
if ( pPlayer->GetSteamID( &steamID ) && GTFGCClientSystem()->GetLiveMatchPlayer( steamID ) )
{ continue; }
// Player on defenders that doesn't have a live match entry
nAdHocDefenders++;
}
// Bootcamp mode can mix a lobby with ad-hoc joins
int nSlotsLeft = kMVM_DefendersTeamSize - nMatchPlayers - nAdHocDefenders;
if ( nSlotsLeft >= 1 )
{
Log( "MVM assigned %s to defending team (%d more slots remaining after us)\n", pTFPlayer->GetPlayerName(), nSlotsLeft-1 );
// Set Their Currency
int nRoundCurrency = MannVsMachineStats_GetAcquiredCredits();
nRoundCurrency += g_pPopulationManager->GetStartingCurrency();
// deduct any cash that has already been spent
int spentCurrency = g_pPopulationManager->GetPlayerCurrencySpent( pTFPlayer );
pTFPlayer->SetCurrency( nRoundCurrency - spentCurrency );
iTeam = TF_TEAM_PVE_DEFENDERS;
}
else
{
// no room
Log( "MVM assigned %s to spectator, all slots for defending team are in use, or reserved for lobby members\n",
pTFPlayer->GetPlayerName() );
iTeam = TEAM_SPECTATOR;
}
}
}
else if ( pMatch )
{
if ( !bAutoBalance )
{
CSteamID steamID;
if ( pMatchPlayer )
{
iTeam = GetGameTeamForGCTeam( pMatchPlayer->eGCTeam );
if ( iTeam < FIRST_GAME_TEAM )
{
// We should always have a team assigned by the GC
Warning( "Competitive mode: Lobby player with invalid GC team %i in MatchGroup %i\n", iTeam, (int)pMatch->m_eMatchGroup );
}
CheckAndSetPartyLeader( pTFPlayer, iTeam );
}
}
}
return iTeam;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static CPhysicsProp *CreatePhysicsToy( const char* pszModelName, const Vector &vSpawnPos, const QAngle &qSpawnAngles )
{
if ( pszModelName == NULL )
return NULL;
CPhysicsProp *pProp = NULL;
MDLCACHE_CRITICAL_SECTION();
MDLHandle_t h = mdlcache->FindMDL( pszModelName );
if ( h != MDLHANDLE_INVALID )
{
// Must have vphysics to place as a physics prop
studiohdr_t *pStudioHdr = mdlcache->GetStudioHdr( h );
if ( pStudioHdr && mdlcache->GetVCollide( h ) )
{
bool bAllowPrecache = CBaseEntity::IsPrecacheAllowed();
CBaseEntity::SetAllowPrecache( true );
// Try to create entity
pProp = dynamic_cast< CPhysicsProp * >( CreateEntityByName( "prop_physics_override" ) );
if ( pProp )
{
pProp->SetCollisionGroup( COLLISION_GROUP_PUSHAWAY );
// so it can be pushed by airblast
pProp->AddFlag( FL_GRENADE );
// so that it will always be interactable with the player
//pProp->SetPhysicsMode( PHYSICS_MULTIPLAYER_SOLID );//PHYSICS_MULTIPLAYER_NON_SOLID );
char buf[512];
// Pass in standard key values
Q_snprintf( buf, sizeof(buf), "%.10f %.10f %.10f", vSpawnPos.x, vSpawnPos.y, vSpawnPos.z );
pProp->KeyValue( "origin", buf );
Q_snprintf( buf, sizeof(buf), "%.10f %.10f %.10f", qSpawnAngles.x, qSpawnAngles.y, qSpawnAngles.z );
pProp->KeyValue( "angles", buf );
pProp->KeyValue( "model", pszModelName );
pProp->KeyValue( "fademindist", "-1" );
pProp->KeyValue( "fademaxdist", "0" );
pProp->KeyValue( "fadescale", "1" );
pProp->KeyValue( "inertiaScale", "1.0" );
pProp->KeyValue( "physdamagescale", "0.1" );
pProp->Precache();
DispatchSpawn( pProp );
pProp->m_takedamage = DAMAGE_YES; // Take damage, otherwise this can block trains
pProp->SetHealth( 5000 );
pProp->Activate();
}
CBaseEntity::SetAllowPrecache( bAllowPrecache );
}
mdlcache->Release( h ); // counterbalance addref from within FindMDL
}
return pProp;
}
CPhysicsProp *CreateBeachBall( const Vector &vSpawnPos, const QAngle &qSpawnAngles )
{
return CreatePhysicsToy( "models/props_gameplay/ball001.mdl", vSpawnPos, qSpawnAngles );
}
CPhysicsProp *CreateSoccerBall( const Vector &vSpawnPos, const QAngle &qSpawnAngles )
{
return CreatePhysicsToy( "models/player/items/scout/soccer_ball.mdl", vSpawnPos, qSpawnAngles );
}
void CTFGameRules::PushAllPlayersAway( const Vector& vFromThisPoint, float flRange, float flForce, int nTeam, CUtlVector< CTFPlayer* > *pPushedPlayers /*= NULL*/ )
{
CUtlVector< CTFPlayer * > playerVector;
CollectPlayers( &playerVector, nTeam, COLLECT_ONLY_LIVING_PLAYERS );
for( int i=0; i<playerVector.Count(); ++i )
{
CTFPlayer *pPlayer = playerVector[i];
Vector toPlayer = pPlayer->EyePosition() - vFromThisPoint;
if ( toPlayer.LengthSqr() < flRange * flRange )
{
// send the player flying
// make sure we push players up and away
toPlayer.z = 0.0f;
toPlayer.NormalizeInPlace();
toPlayer.z = 1.0f;
Vector vPush = flForce * toPlayer;
pPlayer->ApplyAbsVelocityImpulse( vPush );
if ( pPushedPlayers )
{
pPushedPlayers->AddToTail( pPlayer );
}
}
}
}
#endif // GAME_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::CanUpgradeWithAttrib( CTFPlayer *pPlayer, int iWeaponSlot, attrib_definition_index_t iAttribIndex, CMannVsMachineUpgrades *pUpgrade )
{
if ( !pPlayer )
return false;
Assert ( pUpgrade );
// Upgrades on players are considered active at all times
if ( pUpgrade->nUIGroup == UIGROUP_UPGRADE_ATTACHED_TO_PLAYER )
{
switch ( iAttribIndex )
{
case 113: // "metal regen"
{
return ( pPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) );
}
break;
}
return true;
}
// Get the item entity. We use the entity, not the item in the loadout, because we want
// the dynamic attributes that have already been purchases and attached.
CEconEntity *pEntity;
CEconItemView *pCurItemData = CTFPlayerSharedUtils::GetEconItemViewByLoadoutSlot( pPlayer, iWeaponSlot, &pEntity );
if ( !pCurItemData || !pEntity )
return false;
// bottles can only hold things in the appropriate ui group
if ( dynamic_cast< CTFPowerupBottle *>( pEntity ) )
{
if ( pUpgrade->nUIGroup == UIGROUP_POWERUPBOTTLE )
{
switch ( iAttribIndex )
{
case 327: // "building instant upgrade"
{
return ( pPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) );
}
#ifndef _DEBUG
case 480: // "radius stealth"
{
return ( pPlayer->IsPlayerClass( TF_CLASS_SPY ) );
}
#endif // !_DEBUG
}
return true;
}
return false;
}
else if ( pUpgrade->nUIGroup == UIGROUP_POWERUPBOTTLE )
{
return false;
}
CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase* > ( pEntity );
CTFWeaponBaseGun *pWeaponGun = dynamic_cast< CTFWeaponBaseGun* > ( pEntity );
int iWeaponID = ( pWeapon ) ? pWeapon->GetWeaponID() : TF_WEAPON_NONE;
CTFWearableDemoShield *pShield = dynamic_cast< CTFWearableDemoShield* >( pEntity );
bool bShield = ( pShield ) ? true : false;
if ( iWeaponID == TF_WEAPON_PARACHUTE )
return false;
// Hack to simplify excluding non-weapons from damage upgrades
bool bHideDmgUpgrades = iWeaponID == TF_WEAPON_NONE ||
iWeaponID == TF_WEAPON_LASER_POINTER ||
iWeaponID == TF_WEAPON_MEDIGUN ||
iWeaponID == TF_WEAPON_BUFF_ITEM ||
iWeaponID == TF_WEAPON_BUILDER ||
iWeaponID == TF_WEAPON_PDA_ENGINEER_BUILD ||
iWeaponID == TF_WEAPON_INVIS ||
iWeaponID == TF_WEAPON_SPELLBOOK;
// What tier upgrade is it?
int nQuality = pUpgrade->nQuality;
// This is crappy, but it's hopefully more maintainable than the allowed attributes block for all current & future items
switch ( iAttribIndex )
{
case 2: // "damage bonus"
{
if ( bHideDmgUpgrades )
return false;
// Some classes get a weaker dmg upgrade
if ( nQuality == MVM_UPGRADE_QUALITY_LOW )
{
if ( pPlayer->IsPlayerClass( TF_CLASS_DEMOMAN ) && !bShield )
{
return ( iWeaponSlot == TF_WPN_TYPE_PRIMARY || iWeaponSlot == TF_WPN_TYPE_SECONDARY );
}
else
{
return false;
}
}
bool bShieldEquipped = false;
if ( pPlayer->IsPlayerClass( TF_CLASS_DEMOMAN ) )
{
for ( int i = 0; i < pPlayer->GetNumWearables(); ++i )
{
CTFWearableDemoShield *pWearableShield = dynamic_cast< CTFWearableDemoShield* >( pPlayer->GetWearable( i ) );
if ( pWearableShield )
{
bShieldEquipped = true;
}
}
}
return ( ( iWeaponSlot == TF_WPN_TYPE_PRIMARY &&
( pPlayer->IsPlayerClass( TF_CLASS_SCOUT ) ||
pPlayer->IsPlayerClass( TF_CLASS_SNIPER ) ||
pPlayer->IsPlayerClass( TF_CLASS_SOLDIER ) ||
pPlayer->IsPlayerClass( TF_CLASS_PYRO ) ) ) ||
( iWeaponID == TF_WEAPON_SWORD && bShieldEquipped ) );
}
break;
case 6: // "fire rate bonus"
{
// Heavy's version of firing speed costs more
bool bMinigun = iWeaponID == TF_WEAPON_MINIGUN;
if ( nQuality == MVM_UPGRADE_QUALITY_LOW )
{
return bMinigun;
}
else if ( iWeaponID == TF_WEAPON_GRENADELAUNCHER && pWeapon && pWeapon->AutoFiresFullClipAllAtOnce() )
{
return false;
}
// Non-melee version
return ( dynamic_cast< CTFWeaponBaseMelee* >( pEntity ) == NULL &&
iWeaponID != TF_WEAPON_NONE && !bHideDmgUpgrades &&
iWeaponID != TF_WEAPON_FLAMETHROWER &&
!WeaponID_IsSniperRifleOrBow( iWeaponID ) &&
!( pWeapon && pWeapon->HasEffectBarRegeneration() ) &&
!bMinigun );
}
break;
// case 8: // "heal rate bonus"
case 10: // "ubercharge rate bonus"
case 314: // "uber duration bonus"
case 481: // "canteen specialist"
case 482: // "overheal expert"
case 483: // "medic machinery beam"
case 493: // "healing mastery"
{
return ( iWeaponID == TF_WEAPON_MEDIGUN );
}
break;
case 31: // "critboost on kill"
{
CTFWeaponBaseMelee *pMelee = dynamic_cast<CTFWeaponBaseMelee *> ( pEntity );
return ( pMelee && (
pPlayer->IsPlayerClass( TF_CLASS_DEMOMAN ) ||
pPlayer->IsPlayerClass( TF_CLASS_SPY ) ) );
}
case 71: // weapon burn dmg increased
case 73: // weapon burn time increased
{
return ( iWeaponID == TF_WEAPON_FLAMETHROWER || iWeaponID == TF_WEAPON_FLAREGUN );
}
break;
case 76: // "maxammo primary increased"
{
return ( pWeapon && pWeapon->GetPrimaryAmmoType() == TF_AMMO_PRIMARY && !pWeapon->IsEnergyWeapon() );
}
break;
case 78: // "maxammo secondary increased"
{
return ( pWeapon && pWeapon->GetPrimaryAmmoType() == TF_AMMO_SECONDARY && !pWeapon->IsEnergyWeapon() );
}
break;
case 90: // "SRifle Charge rate increased"
{
return WeaponID_IsSniperRifle( iWeaponID );
}
break;
case 103: // "Projectile speed increased"
{
if ( pWeaponGun )
{
return ( pWeaponGun->GetWeaponProjectileType() == TF_PROJECTILE_PIPEBOMB );
}
return false;
}
break;
case 149: // "bleed duration"
case 523: // "arrow mastery"
{
return ( iWeaponID == TF_WEAPON_COMPOUND_BOW );
}
break;
case 218: // "mark for death"
{
return ( iWeaponID == TF_WEAPON_BAT_WOOD );
}
break;
case 249: // "charge recharge rate increased"
case 252: // "damage force reduction"
{
return bShield;
}
break;
case 255: // "airblast pushback scale"
{
return ( iWeaponID == TF_WEAPON_FLAMETHROWER &&
pWeaponGun && assert_cast< CTFFlameThrower* >( pWeaponGun )->SupportsAirBlastFunction( TF_FUNCTION_AIRBLAST_PUSHBACK) );
}
break;
case 266: // "projectile penetration"
{
if ( pWeaponGun && !bHideDmgUpgrades )
{
if ( !( pPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY ) )
{
int iProjectile = pWeaponGun->GetWeaponProjectileType();
return ( iProjectile == TF_PROJECTILE_ARROW || iProjectile == TF_PROJECTILE_BULLET || iProjectile == TF_PROJECTILE_HEALING_BOLT || iProjectile == TF_PROJECTILE_FESTIVE_ARROW || iProjectile == TF_PROJECTILE_FESTIVE_HEALING_BOLT );
}
}
return false;
}
break;
case 80: // "maxammo metal increased"
case 276: // "bidirectional teleport"
case 286: // "engy building health bonus"
case 343: // "engy sentry fire rate increased"
case 345: // "engy dispenser radius increased"
case 351: // "engy disposable sentries"
{
return ( pPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) && iWeaponID == TF_WEAPON_PDA_ENGINEER_BUILD );
}
break;
case 278: // "effect bar recharge rate increased"
{
return ( pWeapon && pWeapon->HasEffectBarRegeneration() && iWeaponID != TF_WEAPON_BUILDER && iWeaponID != TF_WEAPON_SPELLBOOK );
}
break;
case 279: // "maxammo grenades1 increased"
{
return ( iWeaponID == TF_WEAPON_BAT_WOOD || iWeaponID == TF_WEAPON_BAT_GIFTWRAP );
}
break;
case 313: // "applies snare effect"
{
return ( iWeaponID == TF_WEAPON_JAR || iWeaponID == TF_WEAPON_JAR_MILK );
}
break;
case 318: // "faster reload rate"
{
return ( ( pWeapon && pWeapon->ReloadsSingly() ) ||
WeaponID_IsSniperRifleOrBow( iWeaponID ) ||
iWeaponID == TF_WEAPON_FLAREGUN );
}
break;
case 319: // "increase buff duration"
{
return ( iWeaponID == TF_WEAPON_BUFF_ITEM );
}
break;
case 320: // "robo sapper"
#ifdef STAGING_ONLY
case 601: // "ability spy traps"
case 603: // "phase cloak"
#endif // STAGING_ONLY
{
return ( pPlayer->IsPlayerClass( TF_CLASS_SPY ) && iWeaponID == TF_WEAPON_BUILDER );
}
break;
case 323: // "attack projectiles"
{
return ( pPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY );
}
break;
case 335: // "clip size bonus upgrade"
{
return ( pWeapon && !pWeapon->IsBlastImpactWeapon() && pWeapon->UsesClipsForAmmo1() && pWeapon->GetMaxClip1() > 1
&& iWeaponID != TF_WEAPON_FLAREGUN_REVENGE && iWeaponID != TF_WEAPON_SPELLBOOK );
}
break;
case 375: // "generate rage on damage"
{
return ( pPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY );
}
break;
case 395: // "explosive sniper shot"
{
return ( pPlayer->IsPlayerClass( TF_CLASS_SNIPER ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY &&
pWeaponGun && pWeaponGun->GetWeaponProjectileType() == TF_PROJECTILE_BULLET );
}
break;
case 396: // "melee attack rate bonus"
{
// Melee version
return ( dynamic_cast< CTFWeaponBaseMelee* >( pEntity ) != NULL && iWeaponID != TF_WEAPON_BUFF_ITEM &&
!( pWeapon && pWeapon->HasEffectBarRegeneration() && iWeaponID != TF_WEAPON_BAT_WOOD ) );
}
break;
case 397: // "projectile penetration heavy"
{
if ( !bHideDmgUpgrades )
{
return ( pPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY );
}
}
break;
case 399: // "armor piercing"
{
return ( pPlayer->IsPlayerClass( TF_CLASS_SPY ) && iWeaponID == TF_WEAPON_KNIFE );
}
break;
case 440: // "clip size upgrade atomic"
{
return pWeapon && pWeapon->IsBlastImpactWeapon();
}
break;
case 484: // "mad milk syringes"
{
return ( iWeaponID == TF_WEAPON_SYRINGEGUN_MEDIC );
}
case 488: // "rocket specialist"
if ( pWeaponGun )
{
return ( pWeaponGun->GetWeaponProjectileType() == TF_PROJECTILE_ROCKET || pWeaponGun->GetWeaponProjectileType() == TF_PROJECTILE_ENERGY_BALL );
}
case 499: // generate rage on heal (shield)
case 554: // revive
case 555: // medigun specialist
{
return ( iWeaponID == TF_WEAPON_MEDIGUN );
}
#ifdef STAGING_ONLY
case 553: // rocket pack
case 558: // mod flamethrower napalm
{
return ( iWeaponID == TF_WEAPON_FLAMETHROWER );
}
case 604: // sniper cloak
case 605: // master sniper
{
return ( pPlayer->IsPlayerClass( TF_CLASS_SNIPER ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY );
}
case 611: // airborne infantry
{
return ( pPlayer->IsPlayerClass( TF_CLASS_SOLDIER ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY );
}
case 624: // construction expert
case 626: // support engineer
{
return ( pPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) && iWeaponSlot == TF_WPN_TYPE_MELEE );
}
case 631: // ability doubletap teleport
{
return ( pPlayer->IsPlayerClass( TF_CLASS_SCOUT ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY );
}
#endif // STAGING_ONLY
}
// All weapon related attributes require an item that does damage
if ( pUpgrade->nUIGroup == UIGROUP_UPGRADE_ATTACHED_TO_ITEM )
{
// All guns
if ( pWeaponGun )
return ( iWeaponID != TF_WEAPON_NONE && !bHideDmgUpgrades &&
!( pWeapon && pWeapon->HasEffectBarRegeneration() ) );
CTFWeaponBaseMelee *pMelee = dynamic_cast< CTFWeaponBaseMelee* >( pEntity );
if ( pMelee )
{
// All melee weapons except buff banners
return ( iWeaponID != TF_WEAPON_BUFF_ITEM && !bHideDmgUpgrades );
}
return false;
}
return false;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int CTFGameRules::GetUpgradeTier( int iUpgrade )
{
if ( !GameModeUsesUpgrades() || iUpgrade < 0 || iUpgrade >= g_MannVsMachineUpgrades.m_Upgrades.Count() )
return 0;
return g_MannVsMachineUpgrades.m_Upgrades[iUpgrade].nTier;
}
//-----------------------------------------------------------------------------
// Given an upgrade and slot, see if its' tier is enabled/available
//-----------------------------------------------------------------------------
bool CTFGameRules::IsUpgradeTierEnabled( CTFPlayer *pTFPlayer, int iItemSlot, int iUpgrade )
{
if ( !pTFPlayer )
return false;
// If the upgrade has a tier, it's mutually exclusive with upgrades of the same tier for the same slot
int nTier = GetUpgradeTier( iUpgrade );
if ( !nTier )
return false;
bool bIsAvailable = true;
CEconItemView *pItem = NULL;
float flValue = 0.f;
// Go through the upgrades and see if it could apply, and if we already have it
for ( int i = 0; i < g_MannVsMachineUpgrades.m_Upgrades.Count(); i++ )
{
CMannVsMachineUpgrades upgrade = g_MannVsMachineUpgrades.m_Upgrades[i];
// Same upgrade
// if ( !V_strcmp( upgrade.szAttrib, g_MannVsMachineUpgrades.m_Upgrades[iUpgrade].szAttrib ) )
// continue;
// Different tier
if ( upgrade.nTier != nTier )
continue;
// Wrong type
if ( upgrade.nUIGroup != g_MannVsMachineUpgrades.m_Upgrades[iUpgrade].nUIGroup )
continue;
CEconItemAttributeDefinition *pAttribDef = ItemSystem()->GetStaticDataForAttributeByName( upgrade.szAttrib );
if ( !pAttribDef )
continue;
// Can't use
if ( !CanUpgradeWithAttrib( pTFPlayer, iItemSlot, pAttribDef->GetDefinitionIndex(), &upgrade ) )
continue;
if ( upgrade.nUIGroup == UIGROUP_UPGRADE_ATTACHED_TO_ITEM )
{
pItem = CTFPlayerSharedUtils::GetEconItemViewByLoadoutSlot( pTFPlayer, iItemSlot );
if ( pItem )
{
::FindAttribute_UnsafeBitwiseCast< attrib_value_t >( pItem->GetAttributeList(), pAttribDef, &flValue );
}
}
else if ( upgrade.nUIGroup == UIGROUP_UPGRADE_ATTACHED_TO_PLAYER )
{
::FindAttribute_UnsafeBitwiseCast< attrib_value_t >( pTFPlayer->GetAttributeList(), pAttribDef, &flValue );
}
if ( flValue > 0.f )
{
bIsAvailable = false;
break;
}
}
return bIsAvailable;
}
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Helper Functions
//-----------------------------------------------------------------------------
void CTFGameRules::SetNextMvMPopfile ( const char * next )
{
s_strNextMvMPopFile = next;
}
//-----------------------------------------------------------------------------
const char * CTFGameRules::GetNextMvMPopfile ( )
{
return s_strNextMvMPopFile.Get();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::BalanceTeams( bool bRequireSwitcheesToBeDead )
{
// are we playing a managed match via matchmaking?
if ( GetMatchGroupDescription( GetCurrentMatchGroup() ) )
return;
if ( mp_autoteambalance.GetInt() == 2 )
return;
BaseClass::BalanceTeams( bRequireSwitcheesToBeDead );
}
#endif
Reference in New Issue View Git Blame Copy Permalink