//========= 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 #include "c_tf_player.h" #include "c_tf_objective_resource.h" #include #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/.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 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( 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(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 &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( 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()[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()[i] ) ); } } //----------------------------------------------------------------------------- // Purpose: remove all buildings in the world //----------------------------------------------------------------------------- void CTFGameRules::RemoveAllBuildings( bool bExplodeBuildings /*= false*/ ) { for ( int i=0; i( 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()[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()[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 ( 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 ( 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 ( 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 ( gEntList.FindEntityByClassname( NULL, "tf_logic_koth" ) ); if ( pKoth ) { m_bPlayingKoth.Set( true ); } CMedievalLogic *pMedieval = dynamic_cast ( 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 ( gEntList.FindEntityByClassname( NULL, "tf_logic_hybrid_ctf_cp" ) ); if ( pHybridMap_CTF_CP ) { m_bPlayingHybrid_CTF_CP.Set( true ); } CTFHolidayEntity *pHolidayEntity = dynamic_cast ( gEntList.FindEntityByClassname( NULL, "tf_logic_holiday" ) ); if ( pHolidayEntity ) { m_nMapHolidayType.Set( pHolidayEntity->GetHolidayType() ); } // bot roster m_hBlueBotRoster = NULL; m_hRedBotRoster = NULL; CHandle 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 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()[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()[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; iGetNumPlayers(); ++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 ( 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()[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( 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(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(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( 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( 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( 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( 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( 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(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( 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; iWorldSpaceCenter(), 10.0f, 0, 255, 0, true, 0.1f ); } } for( int i=0; iWorldSpaceCenter(), 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 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( 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; iIsBot() ) { ++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; iIsBot() ) { 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; jIsValidForWanderingPopulation() ) { 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; iIsBot() ) { ++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; iGetNumPoints(); ++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; iHasAttributeTF( 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 ( 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; gSetLifetime( 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; iHasAttributeTF( 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; pGetAbsOrigin() - spot ).IsLengthLessThan( 1.25f * GHOST_SCARE_RADIUS ) ) { break; } } if ( p == playerVector.Count() ) { spawnVector.AddToTail( spot ); } } if ( spawnVector.Count() == 0 ) { return; } for( int g=0; gGetSteamID( &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( 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( 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( 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( 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( 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 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( 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 *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( 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( 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 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 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( 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( 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( 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( 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( 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( 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( pInflictor ); } else { CBaseEntity *pInflictorOwner = pInflictor->GetOwnerEntity(); if ( pInflictorOwner && pInflictorOwner->IsBaseObject() ) { pObject = dynamic_cast( pInflictorOwner ); } } } else if( pKiller && pKiller->IsBaseObject() ) { pObject = dynamic_cast( 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( 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( 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()[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(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( 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(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( 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( 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( 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( 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( 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( 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( 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( 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( 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( 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( pInflictor ); if ( !pSentrygun ) { pSentrygun = pInflictor ? dynamic_cast( 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( pBuilder->GetEntityForLoadoutSlot( LOADOUT_POSITION_MELEE ) ), pScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillsBySentry ); // PDA's Also count Sentry kills EconEntity_OnOwnerKillEaterEvent( dynamic_cast( 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( pLaserPointer ), pScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillsByManualControlOfSentry ); } } } // Should we award an assist kill to someone? if ( pAssister ) { EconEntity_OnOwnerKillEaterEvent( dynamic_cast( 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 vecItems; CALL_ATTRIB_HOOK_FLOAT_ON_OTHER_WITH_ITEMS( pScorer, iKillerHasPetItem, &vecItems, counts_as_assister ); FOR_EACH_VEC( vecItems, i ) { CEconEntity *pEconEntity = dynamic_cast( 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( pInflictor ); if ( !pSentry && pInflictor ) { pSentry = dynamic_cast( pInflictor->GetOwnerEntity() ); } if ( pSentry ) { pKillStreakTarget = dynamic_cast( 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( pKillStreakTarget ); if ( pWeapon ) { iWepKills = pWeapon->GetKillStreak() + 1; pWeapon->SetKillStreak( iWepKills ); } else { CTFWearable *pWearable = dynamic_cast( 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( 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 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 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 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()[i] ); CHandle hControlPoint = pTFSpawn->GetControlPoint(); CHandle hRoundBlue = pTFSpawn->GetRoundBlueSpawn(); CHandle 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; iGetNumPoints(); 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<= 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()[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( 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 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 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 &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 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()[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; iGetNumPlayers(); ++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()[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( 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( 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()[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; iSetLocalOrigin( 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 pRedPoint = pRound->GetPointOwnedBy( TF_TEAM_RED ); CHandle pBluePoint = pRound->GetPointOwnedBy( TF_TEAM_BLUE ); // do we have opposing points in this round? if ( pRedPoint && pBluePoint ) { int iMiniRoundMask = ( 1<GetPointIndex() ) | ( 1<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 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(pPlayer->GetTeam()); #else C_TFTeam *pTeam = assert_cast(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; iGetNumPoints(); ++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; iGetNumPoints(); ++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()[i] ); if ( pObj->ObjectType() == OBJ_SENTRYGUN && pObj->GetTeamNumber() == team && pObj->GetKills() >= dangerousSentryKills ) { dangerousSentryKills = pObj->GetKills(); dangerousSentry = static_cast( 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 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; iChangeTeam( 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( 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( 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 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 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 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 .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(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( 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( 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 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( gEntList.FindEntityByClassname( NULL, "info_observer_point" ) ); while( pObserverPoint ) { if ( pObserverPoint->IsMatchSummary() ) { pObserverPoint->SetDisabled( false ); SetRequiredObserverTarget( pObserverPoint ); break; } pObserverPoint = dynamic_cast( 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; iEyePosition() - 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 ( 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