You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
21410 lines
680 KiB
21410 lines
680 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: The TF Game rules |
|
// |
|
// $NoKeywords: $ |
|
//============================================================================= |
|
#include "cbase.h" |
|
#include "tf_gamerules.h" |
|
#include "tf_classdata.h" |
|
#include "ammodef.h" |
|
#include "KeyValues.h" |
|
#include "tf_weaponbase.h" |
|
#include "tf_weaponbase_gun.h" |
|
#include "tier0/icommandline.h" |
|
#include "convar_serverbounded.h" |
|
#include "econ_item_system.h" |
|
#include "tf_weapon_grenadelauncher.h" |
|
#include "tf_logic_robot_destruction.h" |
|
#include "tf_logic_player_destruction.h" |
|
#include "tf_matchmaking_shared.h" |
|
|
|
#ifdef CLIENT_DLL |
|
#include <game/client/iviewport.h> |
|
#include "c_tf_player.h" |
|
#include "c_tf_objective_resource.h" |
|
#include <filesystem.h> |
|
#include "c_tf_team.h" |
|
#include "dt_utlvector_recv.h" |
|
#include "tf_autorp.h" |
|
#include "player_vs_environment/c_tf_upgrades.h" |
|
#include "video/ivideoservices.h" |
|
#include "tf_gc_client.h" |
|
#include "c_tf_playerresource.h" |
|
#else |
|
#include "basemultiplayerplayer.h" |
|
#include "voice_gamemgr.h" |
|
#include "items.h" |
|
#include "team.h" |
|
#include "game.h" |
|
#include "tf_bot_temp.h" |
|
#include "tf_player.h" |
|
#include "tf_team.h" |
|
#include "player_resource.h" |
|
#include "entity_tfstart.h" |
|
#include "filesystem.h" |
|
#include "minigames/tf_duel.h" |
|
#include "tf_obj.h" |
|
#include "tf_objective_resource.h" |
|
#include "tf_player_resource.h" |
|
#include "team_control_point_master.h" |
|
#include "team_train_watcher.h" |
|
#include "playerclass_info_parse.h" |
|
#include "team_control_point_master.h" |
|
#include "coordsize.h" |
|
#include "entity_healthkit.h" |
|
#include "tf_gamestats.h" |
|
#include "entity_capture_flag.h" |
|
#include "tf_player_resource.h" |
|
#include "tf_obj_sentrygun.h" |
|
#include "activitylist.h" |
|
#include "AI_ResponseSystem.h" |
|
#include "hl2orange.spa.h" |
|
#include "hltvdirector.h" |
|
#include "tf_projectile_arrow.h" |
|
#include "func_suggested_build.h" |
|
#include "tf_gc_api.h" |
|
#include "tf_weaponbase_grenadeproj.h" |
|
#include "engine/IEngineSound.h" |
|
#include "soundenvelope.h" |
|
#include "dt_utlvector_send.h" |
|
#include "tf_tactical_mission.h" |
|
#include "nav_mesh/tf_nav_area.h" |
|
#include "bot/tf_bot.h" |
|
#include "bot/tf_bot_manager.h" |
|
#include "bot/map_entities/tf_bot_roster.h" |
|
#include "econ_gcmessages.h" |
|
#include "vgui/ILocalize.h" |
|
#include "tier3/tier3.h" |
|
#include "tf_ammo_pack.h" |
|
#include "tf_gcmessages.h" |
|
#include "vote_controller.h" |
|
#include "tf_voteissues.h" |
|
#include "halloween/headless_hatman.h" |
|
#include "halloween/ghost/ghost.h" |
|
#include "halloween/eyeball_boss/eyeball_boss.h" |
|
#include "halloween/merasmus/merasmus.h" |
|
#include "halloween/merasmus/merasmus_dancer.h" |
|
#include "tf_extra_map_entity.h" |
|
#include "tf_weapon_grenade_pipebomb.h" |
|
#include "tf_weapon_flaregun.h" |
|
#include "tf_weapon_sniperrifle.h" |
|
#include "tf_weapon_knife.h" |
|
#include "tf_weapon_jar.h" |
|
#include "halloween/tf_weapon_spellbook.h" |
|
|
|
#include "player_vs_environment/tf_population_manager.h" |
|
#include "player_vs_environment/monster_resource.h" |
|
#include "util_shared.h" |
|
#include "gc_clientsystem.h" |
|
|
|
#include "raid/tf_raid_logic.h" |
|
#include "player_vs_environment/tf_boss_battle_logic.h" |
|
#include "player_vs_environment/tf_mann_vs_machine_logic.h" |
|
#include "player_vs_environment/tf_upgrades.h" |
|
|
|
#include "tf_wheel_of_doom.h" |
|
#include "tf_halloween_souls_pickup.h" |
|
#include "halloween/zombie/zombie.h" |
|
#include "teamplay_round_timer.h" |
|
#include "halloween/spell/tf_spell_pickup.h" |
|
#include "tf_weapon_laser_pointer.h" |
|
#include "effect_dispatch_data.h" |
|
#include "tf_fx.h" |
|
#include "econ_game_account_server.h" |
|
#include "tf_gc_server.h" |
|
#include "tf_logic_halloween_2014.h" |
|
#include "tf_obj_sentrygun.h" |
|
#include "entity_halloween_pickup.h" |
|
#include "entity_rune.h" |
|
#include "func_powerupvolume.h" |
|
#include "workshop/maps_workshop.h" |
|
#include "tf_passtime_logic.h" |
|
#include "cdll_int.h" |
|
#include "halloween/halloween_gift_spawn_locations.h" |
|
#include "tf_weapon_invis.h" |
|
#include "tf_gc_server.h" |
|
#include "gcsdk/msgprotobuf.h" |
|
#include "tf_party.h" |
|
#include "tf_autobalance.h" |
|
#endif |
|
|
|
#include "tf_mann_vs_machine_stats.h" |
|
#include "tf_upgrades_shared.h" |
|
|
|
#include "tf_item_powerup_bottle.h" |
|
#include "tf_weaponbase_gun.h" |
|
#include "tf_weaponbase_melee.h" |
|
#include "tf_wearable_item_demoshield.h" |
|
#include "tf_weapon_buff_item.h" |
|
#include "tf_weapon_flamethrower.h" |
|
#include "tf_weapon_medigun.h" |
|
|
|
#include "econ_holidays.h" |
|
#include "rtime.h" |
|
#include "tf_revive.h" |
|
#include "tf_duckleaderboard.h" |
|
|
|
#include "passtime_convars.h" |
|
|
|
#include "tier3/tier3.h" |
|
// memdbgon must be the last include file in a .cpp file!!! |
|
#include "tier0/memdbgon.h" |
|
|
|
|
|
#define ITEM_RESPAWN_TIME 10.0f |
|
#define MASK_RADIUS_DAMAGE ( MASK_SHOT & ~( CONTENTS_HITBOX ) ) |
|
|
|
// Halloween 2013 VO defines for plr_hightower_event |
|
#define HELLTOWER_TIMER_INTERVAL ( 60 + RandomInt( -30, 30 ) ) |
|
#define HELLTOWER_RARE_LINE_CHANCE 0.15 // 15% |
|
#define HELLTOWER_MISC_CHANCE 0.50 // 50% |
|
|
|
static int g_TauntCamRagdollAchievements[] = |
|
{ |
|
0, // TF_CLASS_UNDEFINED |
|
|
|
0, // TF_CLASS_SCOUT, |
|
0, // TF_CLASS_SNIPER, |
|
0, // TF_CLASS_SOLDIER, |
|
0, // TF_CLASS_DEMOMAN, |
|
ACHIEVEMENT_TF_MEDIC_FREEZECAM_RAGDOLL, // TF_CLASS_MEDIC, |
|
0, // TF_CLASS_HEAVYWEAPONS, |
|
0, // TF_CLASS_PYRO, |
|
ACHIEVEMENT_TF_SPY_FREEZECAM_FLICK, // TF_CLASS_SPY, |
|
0, // TF_CLASS_ENGINEER, |
|
|
|
0, // TF_CLASS_CIVILIAN, |
|
0, // TF_CLASS_COUNT_ALL, |
|
}; |
|
|
|
static int g_TauntCamAchievements[] = |
|
{ |
|
0, // TF_CLASS_UNDEFINED |
|
|
|
0, // TF_CLASS_SCOUT, |
|
ACHIEVEMENT_TF_SNIPER_FREEZECAM_HAT, // TF_CLASS_SNIPER, |
|
ACHIEVEMENT_TF_SOLDIER_FREEZECAM_GIBS, // TF_CLASS_SOLDIER, (extra check to count the number of gibs onscreen) |
|
ACHIEVEMENT_TF_DEMOMAN_FREEZECAM_SMILE, // TF_CLASS_DEMOMAN, |
|
0, // TF_CLASS_MEDIC, |
|
ACHIEVEMENT_TF_HEAVY_FREEZECAM_TAUNT, // TF_CLASS_HEAVYWEAPONS, (there's an extra check on this one to see if we're also invuln) |
|
ACHIEVEMENT_TF_PYRO_FREEZECAM_TAUNTS, // TF_CLASS_PYRO, |
|
0, // TF_CLASS_SPY, |
|
ACHIEVEMENT_TF_ENGINEER_FREEZECAM_TAUNT, // TF_CLASS_ENGINEER, |
|
0, // TF_CLASS_CIVILIAN, |
|
0, // TF_CLASS_COUNT_ALL, |
|
}; |
|
|
|
// used for classes that have more than one freeze cam achievement (example: Sniper) |
|
static int g_TauntCamAchievements2[] = |
|
{ |
|
0, // TF_CLASS_UNDEFINED |
|
|
|
0, // TF_CLASS_SCOUT, |
|
ACHIEVEMENT_TF_SNIPER_FREEZECAM_WAVE, // TF_CLASS_SNIPER, |
|
ACHIEVEMENT_TF_SOLDIER_FREEZECAM_TAUNT, // TF_CLASS_SOLDIER, |
|
ACHIEVEMENT_TF_DEMOMAN_FREEZECAM_RUMP, // TF_CLASS_DEMOMAN, |
|
0, // TF_CLASS_MEDIC, |
|
0, // TF_CLASS_HEAVYWEAPONS, |
|
0, // TF_CLASS_PYRO, |
|
0, // TF_CLASS_SPY, |
|
0, // TF_CLASS_ENGINEER, |
|
|
|
0, // TF_CLASS_CIVILIAN, |
|
0, // TF_CLASS_COUNT_ALL, |
|
}; |
|
|
|
struct MapInfo_t |
|
{ |
|
const char *pDiskName; |
|
const char *pDisplayName; |
|
const char *pGameType; |
|
}; |
|
|
|
static MapInfo_t s_ValveMaps[] = { |
|
{ "ctf_2fort", "2Fort", "#Gametype_CTF" }, |
|
{ "cp_dustbowl", "Dustbowl", "#TF_AttackDefend" }, |
|
{ "cp_granary", "Granary", "#Gametype_CP" }, |
|
{ "cp_well", "Well", "#Gametype_CP" }, |
|
{ "cp_foundry", "Foundry", "#Gametype_CP" }, |
|
{ "cp_gravelpit", "Gravel Pit", "#TF_AttackDefend" }, |
|
{ "tc_hydro", "Hydro", "#TF_TerritoryControl" }, |
|
{ "ctf_well", "Well", "#Gametype_CTF" }, |
|
{ "cp_badlands", "Badlands", "#Gametype_CP" }, |
|
{ "pl_goldrush", "Gold Rush", "#Gametype_Escort" }, |
|
{ "pl_badwater", "Badwater Basin", "#Gametype_Escort" }, |
|
{ "plr_pipeline", "Pipeline", "#Gametype_EscortRace" }, |
|
{ "cp_gorge", "Gorge", "#TF_AttackDefend" }, |
|
{ "ctf_doublecross", "Double Cross", "#Gametype_CTF" }, |
|
{ "pl_thundermountain", "Thunder Mountain", "#Gametype_Escort" }, |
|
{ "tr_target", "Target", "#GameType_Training" }, |
|
{ "tr_dustbowl", "Dustbowl", "#GameType_Training" }, |
|
{ "cp_manor_event", "Mann Manor", "#TF_AttackDefend" }, |
|
{ "cp_mountainlab", "Mountain Lab", "#TF_AttackDefend" }, |
|
{ "cp_degrootkeep", "DeGroot Keep", "#TF_MedievalAttackDefend" }, |
|
{ "pl_barnblitz", "Barnblitz", "#Gametype_Escort" }, |
|
{ "pl_upward", "Upward", "#Gametype_Escort" }, |
|
{ "plr_hightower", "Hightower", "#Gametype_EscortRace" }, |
|
{ "koth_viaduct", "Viaduct", "#Gametype_Koth" }, |
|
{ "koth_viaduct_event", "Eyeaduct", "#Gametype_Koth" }, |
|
{ "koth_king", "Kong King", "#Gametype_Koth" }, |
|
{ "koth_lakeside_event", "Ghost Fort", "#Gametype_Koth" }, |
|
{ "plr_hightower_event", "Helltower", "#Gametype_EscortRace" }, |
|
{ "rd_asteroid", "Asteroid", "#Gametype_RobotDestruction" }, |
|
{ "pl_cactuscanyon", "Cactus Canyon", "#Gametype_Escort" }, |
|
{ "sd_doomsday", "Doomsday", "#Gametype_SD" }, |
|
{ "sd_doomsday_event", "Carnival of Carnage", "#Gametype_SD" }, |
|
}; |
|
|
|
static MapInfo_t s_CommunityMaps[] = { |
|
{ "pl_borneo", "Borneo", "#Gametype_Escort" }, |
|
{ "koth_suijin", "Suijin", "#Gametype_Koth" }, |
|
{ "cp_snowplow", "Snowplow", "#TF_AttackDefend" }, |
|
{ "koth_probed", "Probed", "#Gametype_Koth" }, |
|
{ "pd_watergate", "Watergate", "#Gametype_PlayerDestruction" }, |
|
{ "arena_byre", "Byre", "#Gametype_Arena" }, |
|
{ "ctf_2fort_invasion", "2Fort Invasion", "#Gametype_CTF" }, |
|
{ "cp_sunshine_event", "Sinshine", "#Gametype_CP" }, |
|
{ "pl_millstone_event", "Hellstone", "#Gametype_Escort" }, |
|
{ "cp_gorge_event", "Gorge Event", "#TF_AttackDefend" }, |
|
{ "koth_moonshine_event", "Moonshine Event", "#Gametype_Koth" }, |
|
{ "pl_snowycoast", "Snowycoast", "#Gametype_Escort" }, |
|
{ "cp_vanguard", "Vanguard", "#Gametype_CP" }, |
|
{ "ctf_landfall", "Landfall", "#Gametype_CTF" }, |
|
{ "koth_highpass", "Highpass", "#Gametype_Koth" }, |
|
{ "koth_maple_ridge_event", "Maple Ridge Event", "#Gametype_Koth" }, |
|
{ "pl_fifthcurve_event", "Brimstone", "#Gametype_Escort" }, |
|
{ "pd_pit_of_death_event", "Pit of Death", "#Gametype_PlayerDestruction" }, |
|
}; |
|
|
|
/* |
|
|
|
!! Commented out until we use this data, but we should keep updating it so its current when we need it |
|
|
|
struct FeaturedWorkshopMap_t |
|
{ |
|
// The name the map was shipped as in our files (e.g. it was available as maps/<this>.bsp) |
|
// NOTE After maps are un-shipped we leave them here and don't change this value, this allows mapcycles that have |
|
// this map to proper redirect to the workshop in the future |
|
const char *pShippedName; |
|
// The workshop ID of the map (The public one, not the the private upload they use to send us the sources) |
|
PublishedFileId_t nWorkshopID; |
|
}; |
|
|
|
static FeaturedWorkshopMap_t s_FeaturedWorkshopMaps[] = { |
|
// !! DO NOT remove these after we stop shipping the file -- they exist to ensure users can refer to |
|
// !! e.g. "koth_suijin" and get redirected to the workshop map once the file is no longer in our depots. |
|
|
|
// Summer 2015 Operation |
|
{ "pl_borneo", 454139147 }, |
|
{ "koth_suijin", 454188876 }, |
|
{ "cp_snowplow", 454116615 }, |
|
|
|
// September 2015 Invasion Community Update |
|
{ "koth_probed", 454139808 }, |
|
{ "pd_watergate", 456016898 }, |
|
{ "arena_byre", 454142123 }, |
|
{ "ctf_2fort_invasion", FIXME }, // No public workshop entry yet |
|
|
|
// Halloween 2015 |
|
{ "cp_sunshine_event", 532473747 }, |
|
{ "pl_millstone_event", 531384846 }, |
|
{ "cp_gorge_event", 527145539 }, |
|
{ "koth_moonshine_event", 534874830 }, |
|
|
|
// December 2015 Campaign |
|
{ "pl_snowycoast", 469072819 }, |
|
{ "cp_vanguard", 462908782 }, |
|
{ "ctf_landfall", 459651881 }, |
|
{ "koth_highpass", 463803443 }, |
|
|
|
// Halloween 2016 |
|
{ "koth_maple_ridge_event", 537540619 }, |
|
{ "pl_fifthcurve_event", 764966851 }, |
|
{ "pd_pit_of_death_event", 537319626 }, |
|
}; |
|
|
|
*/ |
|
|
|
bool IsValveMap( const char *pMapName ) |
|
{ |
|
for ( int i = 0; i < ARRAYSIZE( s_ValveMaps ); ++i ) |
|
{ |
|
if ( !Q_stricmp( s_ValveMaps[i].pDiskName, pMapName ) ) |
|
{ |
|
return true; |
|
} |
|
} |
|
return false; |
|
} |
|
|
|
extern ConVar mp_capstyle; |
|
extern ConVar sv_turbophysics; |
|
|
|
extern ConVar tf_vaccinator_small_resist; |
|
extern ConVar tf_vaccinator_uber_resist; |
|
|
|
extern ConVar tf_teleporter_fov_time; |
|
extern ConVar tf_teleporter_fov_start; |
|
|
|
#ifdef GAME_DLL |
|
extern ConVar mp_holiday_nogifts; |
|
extern ConVar tf_debug_damage; |
|
extern ConVar tf_damage_range; |
|
extern ConVar tf_damage_disablespread; |
|
extern ConVar tf_populator_damage_multiplier; |
|
extern ConVar tf_mm_trusted; |
|
extern ConVar tf_weapon_criticals; |
|
extern ConVar tf_weapon_criticals_melee; |
|
extern ConVar mp_idledealmethod; |
|
extern ConVar mp_idlemaxtime; |
|
|
|
extern ConVar tf_mm_strict; |
|
extern ConVar mp_autoteambalance; |
|
|
|
// STAGING_SPY |
|
ConVar tf_feign_death_activate_damage_scale( "tf_feign_death_activate_damage_scale", "0.25", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY ); |
|
ConVar tf_feign_death_damage_scale( "tf_feign_death_damage_scale", "0.35", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY ); |
|
ConVar tf_stealth_damage_reduction( "tf_stealth_damage_reduction", "0.8", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY ); |
|
|
|
// training |
|
ConVar training_class( "training_class", "3", FCVAR_REPLICATED, "Class to use in training." ); |
|
ConVar training_can_build_sentry( "training_can_build_sentry", "1", FCVAR_REPLICATED, "Player can build sentry as engineer." ); |
|
ConVar training_can_build_dispenser( "training_can_build_dispenser", "1", FCVAR_REPLICATED, "Player can build dispenser as engineer." ); |
|
ConVar training_can_build_tele_entrance( "training_can_build_tele_entrance", "1", FCVAR_REPLICATED, "Player can build teleporter entrance as engineer." ); |
|
ConVar training_can_build_tele_exit( "training_can_build_tele_exit", "1", FCVAR_REPLICATED, "Player can build teleporter exit as engineer." ); |
|
ConVar training_can_destroy_buildings( "training_can_destroy_buildings", "1", FCVAR_REPLICATED, "Player can destroy buildings as engineer." ); |
|
ConVar training_can_pickup_sentry( "training_can_pickup_sentry", "1", FCVAR_REPLICATED, "Player can pickup sentry gun as engineer." ); |
|
ConVar training_can_pickup_dispenser( "training_can_pickup_dispenser", "1", FCVAR_REPLICATED, "Player can pickup dispenser as engineer." ); |
|
ConVar training_can_pickup_tele_entrance( "training_can_pickup_tele_entrance", "1", FCVAR_REPLICATED, "Player can pickup teleporter entrance as engineer." ); |
|
ConVar training_can_pickup_tele_exit( "training_can_pickup_tele_exit", "1", FCVAR_REPLICATED, "Player can pickup teleporter entrance as engineer." ); |
|
ConVar training_can_select_weapon_primary ( "training_can_select_weapon_primary", "1", FCVAR_REPLICATED, "In training player select primary weapon." ); |
|
ConVar training_can_select_weapon_secondary ( "training_can_select_weapon_secondary", "1", FCVAR_REPLICATED, "In training player select secondary weapon." ); |
|
ConVar training_can_select_weapon_melee ( "training_can_select_weapon_melee", "1", FCVAR_REPLICATED, "In training player select melee weapon." ); |
|
ConVar training_can_select_weapon_building ( "training_can_select_weapon_building", "1", FCVAR_REPLICATED, "In training player select building tool." ); |
|
ConVar training_can_select_weapon_pda ( "training_can_select_weapon_pda", "1", FCVAR_REPLICATED, "In training player select pda." ); |
|
ConVar training_can_select_weapon_item1 ( "training_can_select_weapon_item1", "1", FCVAR_REPLICATED, "In training player select item 1." ); |
|
ConVar training_can_select_weapon_item2 ( "training_can_select_weapon_item2", "1", FCVAR_REPLICATED, "In training player select item 2." ); |
|
|
|
ConVar tf_birthday_ball_chance( "tf_birthday_ball_chance", "100", FCVAR_REPLICATED, "Percent chance of a birthday beach ball spawning at each round start" ); |
|
|
|
ConVar tf_halloween_boss_spawn_interval( "tf_halloween_boss_spawn_interval", "480", FCVAR_CHEAT, "Average interval between boss spawns, in seconds" ); |
|
ConVar tf_halloween_boss_spawn_interval_variation( "tf_halloween_boss_spawn_interval_variation", "60", FCVAR_CHEAT, "Variation of spawn interval +/-" ); |
|
|
|
ConVar tf_halloween_eyeball_boss_spawn_interval( "tf_halloween_eyeball_boss_spawn_interval", "180", FCVAR_CHEAT, "Average interval between boss spawns, in seconds" ); |
|
ConVar tf_halloween_eyeball_boss_spawn_interval_variation( "tf_halloween_eyeball_boss_spawn_interval_variation", "30", FCVAR_CHEAT, "Variation of spawn interval +/-" ); |
|
|
|
ConVar tf_merasmus_spawn_interval( "tf_merasmus_spawn_interval", "180", FCVAR_CHEAT, "Average interval between boss spawns, in seconds" ); |
|
ConVar tf_merasmus_spawn_interval_variation( "tf_merasmus_spawn_interval_variation", "30", FCVAR_CHEAT, "Variation of spawn interval +/-" ); |
|
|
|
ConVar tf_halloween_zombie_mob_enabled( "tf_halloween_zombie_mob_enabled", "0", FCVAR_CHEAT, "If set to 1, spawn zombie mobs on non-Halloween Valve maps" ); |
|
ConVar tf_halloween_zombie_mob_spawn_interval( "tf_halloween_zombie_mob_spawn_interval", "180", FCVAR_CHEAT, "Average interval between zombie mob spawns, in seconds" ); |
|
ConVar tf_halloween_zombie_mob_spawn_count( "tf_halloween_zombie_mob_spawn_count", "20", FCVAR_CHEAT, "How many zombies to spawn" ); |
|
|
|
ConVar tf_halloween_allow_truce_during_boss_event( "tf_halloween_allow_truce_during_boss_event", "0", FCVAR_NOTIFY, "Determines if RED and BLU can damage each other while fighting Monoculus or Merasmus on non-Valve maps." ); |
|
|
|
ConVar tf_player_spell_drop_on_death_rate( "tf_player_spell_drop_on_death_rate", "0", FCVAR_REPLICATED ); |
|
ConVar tf_player_drop_bonus_ducks( "tf_player_drop_bonus_ducks", "-1", FCVAR_REPLICATED, "-1 Default (Holiday-based)\n0 - Force off\n1 - Force on" ); |
|
|
|
ConVar tf_player_name_change_time( "tf_player_name_change_time", "60", FCVAR_NOTIFY, "Seconds between name changes." ); |
|
|
|
ConVar tf_weapon_criticals_distance_falloff( "tf_weapon_criticals_distance_falloff", "0", FCVAR_CHEAT, "Critical weapon damage will take distance into account." ); |
|
ConVar tf_weapon_minicrits_distance_falloff( "tf_weapon_minicrits_distance_falloff", "0", FCVAR_CHEAT, "Mini-crit weapon damage will take distance into account." ); |
|
|
|
ConVar mp_spectators_restricted( "mp_spectators_restricted", "0", FCVAR_NONE, "Prevent players on game teams from joining team spectator if it would unbalance the teams." ); |
|
|
|
ConVar tf_test_special_ducks( "tf_test_special_ducks", "1", FCVAR_DEVELOPMENTONLY ); |
|
|
|
ConVar tf_mm_abandoned_players_per_team_max( "tf_mm_abandoned_players_per_team_max", "1", FCVAR_DEVELOPMENTONLY ); |
|
|
|
#endif // GAME_DLL |
|
ConVar tf_mm_next_map_vote_time( "tf_mm_next_map_vote_time", "30", FCVAR_REPLICATED ); |
|
|
|
#ifdef STAGING_ONLY |
|
#ifdef GAME_DLL |
|
void cc_tf_truce_changed( IConVar *pConVar, const char *pOldString, float flOldValue ) |
|
{ |
|
|
|
if ( TFGameRules() ) |
|
{ |
|
TFGameRules()->RecalculateTruce(); |
|
} |
|
} |
|
#endif // GAME_DLL |
|
ConVar tf_truce( "tf_truce", "0", FCVAR_REPLICATED, "Force a team truce on or off.", true, 0, true, 1 |
|
#ifdef GAME_DLL |
|
, cc_tf_truce_changed |
|
#endif // GAME_DLL |
|
); |
|
#endif // STAGING_ONLY |
|
|
|
static float g_fEternaweenAutodisableTime = 0.0f; |
|
|
|
ConVar tf_spec_xray( "tf_spec_xray", "1", FCVAR_NOTIFY | FCVAR_REPLICATED, "Allows spectators to see player glows. 1 = same team, 2 = both teams" ); |
|
ConVar tf_spawn_glows_duration( "tf_spawn_glows_duration", "10", FCVAR_NOTIFY | FCVAR_REPLICATED, "How long should teammates glow after respawning\n" ); |
|
|
|
#ifdef GAME_DLL |
|
void cc_tf_forced_holiday_changed( IConVar *pConVar, const char *pOldString, float flOldValue ) |
|
{ |
|
// Tell the listeners to recalculate the holiday |
|
IGameEvent *event = gameeventmanager->CreateEvent( "recalculate_holidays" ); |
|
if ( event ) |
|
{ |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
} |
|
#endif // GAME_DLL |
|
|
|
ConVar tf_forced_holiday( "tf_forced_holiday", "0", FCVAR_REPLICATED, "Forced holiday, \n Birthday = 1\n Halloween = 2\n" // Christmas = 3\n Valentines = 4\n MeetThePyro = 5\n FullMoon=6 |
|
#ifdef GAME_DLL |
|
, cc_tf_forced_holiday_changed |
|
#endif // GAME_DLL |
|
); |
|
ConVar tf_item_based_forced_holiday( "tf_item_based_forced_holiday", "0", FCVAR_REPLICATED, "" // like a clone of tf_forced_holiday, but controlled by client consumable item use |
|
#ifdef GAME_DLL |
|
, cc_tf_forced_holiday_changed |
|
#endif // GAME_DLL |
|
); |
|
ConVar tf_force_holidays_off( "tf_force_holidays_off", "0", FCVAR_NOTIFY | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "" |
|
#ifdef GAME_DLL |
|
, cc_tf_forced_holiday_changed |
|
#endif // GAME_DLL |
|
); |
|
ConVar tf_birthday( "tf_birthday", "0", FCVAR_NOTIFY | FCVAR_REPLICATED ); |
|
ConVar tf_spells_enabled( "tf_spells_enabled", "0", FCVAR_NOTIFY | FCVAR_REPLICATED, "Enable to Allow Halloween Spells to be dropped and used by players" ); |
|
|
|
ConVar tf_caplinear( "tf_caplinear", "1", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "If set to 1, teams must capture control points linearly." ); |
|
ConVar tf_stalematechangeclasstime( "tf_stalematechangeclasstime", "20", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "Amount of time that players are allowed to change class in stalemates." ); |
|
ConVar mp_tournament_redteamname( "mp_tournament_redteamname", "RED", FCVAR_REPLICATED | FCVAR_HIDDEN ); |
|
ConVar mp_tournament_blueteamname( "mp_tournament_blueteamname", "BLU", FCVAR_REPLICATED | FCVAR_HIDDEN ); |
|
|
|
//tagES revisit this later |
|
ConVar tf_attack_defend_map( "tf_attack_defend_map", "0", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY ); |
|
|
|
#ifdef GAME_DLL |
|
void cc_tf_stopwatch_changed( IConVar *pConVar, const char *pOldString, float flOldValue ) |
|
{ |
|
IGameEvent *event = gameeventmanager->CreateEvent( "stop_watch_changed" ); |
|
if ( event ) |
|
{ |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
} |
|
#endif // GAME_DLL |
|
ConVar mp_tournament_stopwatch( "mp_tournament_stopwatch", "1", FCVAR_REPLICATED | FCVAR_NOTIFY, "Use Stopwatch mode while using Tournament mode (mp_tournament)" |
|
#ifdef GAME_DLL |
|
, cc_tf_stopwatch_changed |
|
#endif |
|
); |
|
ConVar mp_tournament_readymode( "mp_tournament_readymode", "0", FCVAR_REPLICATED | FCVAR_NOTIFY, "Enable per-player ready status for tournament mode." ); |
|
ConVar mp_tournament_readymode_min( "mp_tournament_readymode_min", "2", FCVAR_REPLICATED | FCVAR_NOTIFY, "Minimum number of players required on the server before players can toggle ready status." ); |
|
ConVar mp_tournament_readymode_team_size( "mp_tournament_readymode_team_size", "0", FCVAR_REPLICATED | FCVAR_NOTIFY, "Minimum number of players required to be ready per-team before the game can begin." ); |
|
ConVar mp_tournament_readymode_countdown( "mp_tournament_readymode_countdown", "10", FCVAR_REPLICATED | FCVAR_NOTIFY, "The number of seconds before a match begins when both teams are ready." ); |
|
ConVar mp_windifference( "mp_windifference", "0", FCVAR_REPLICATED | FCVAR_NOTIFY, "Score difference between teams before server changes maps", true, 0, false, 0 ); |
|
ConVar mp_windifference_min( "mp_windifference_min", "0", FCVAR_REPLICATED | FCVAR_NOTIFY, "Minimum score needed for mp_windifference to be applied", true, 0, false, 0 ); |
|
|
|
ConVar tf_tournament_classlimit_scout( "tf_tournament_classlimit_scout", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Scouts.\n" ); |
|
ConVar tf_tournament_classlimit_sniper( "tf_tournament_classlimit_sniper", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Snipers.\n" ); |
|
ConVar tf_tournament_classlimit_soldier( "tf_tournament_classlimit_soldier", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Soldiers.\n" ); |
|
ConVar tf_tournament_classlimit_demoman( "tf_tournament_classlimit_demoman", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Demomenz.\n" ); |
|
ConVar tf_tournament_classlimit_medic( "tf_tournament_classlimit_medic", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Medics.\n" ); |
|
ConVar tf_tournament_classlimit_heavy( "tf_tournament_classlimit_heavy", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Heavies.\n" ); |
|
ConVar tf_tournament_classlimit_pyro( "tf_tournament_classlimit_pyro", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Pyros.\n" ); |
|
ConVar tf_tournament_classlimit_spy( "tf_tournament_classlimit_spy", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Spies.\n" ); |
|
ConVar tf_tournament_classlimit_engineer( "tf_tournament_classlimit_engineer", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Engineers.\n" ); |
|
ConVar tf_tournament_classchange_allowed( "tf_tournament_classchange_allowed", "1", FCVAR_REPLICATED, "Allow players to change class while the game is active?.\n" ); |
|
ConVar tf_tournament_classchange_ready_allowed( "tf_tournament_classchange_ready_allowed", "1", FCVAR_REPLICATED, "Allow players to change class after they are READY?.\n" ); |
|
|
|
ConVar tf_classlimit( "tf_classlimit", "0", FCVAR_REPLICATED | FCVAR_NOTIFY, "Limit on how many players can be any class (i.e. tf_class_limit 2 would limit 2 players per class).\n", true, 0.f, false, 0.f ); |
|
ConVar tf_player_movement_restart_freeze( "tf_player_movement_restart_freeze", "1", FCVAR_REPLICATED, "When set, prevent player movement during round restart" ); |
|
|
|
ConVar tf_autobalance_query_lifetime( "tf_autobalance_query_lifetime", "30", FCVAR_REPLICATED ); |
|
ConVar tf_autobalance_xp_bonus( "tf_autobalance_xp_bonus", "150", FCVAR_REPLICATED ); |
|
|
|
//tagES |
|
#ifdef STAGING_ONLY |
|
ConVar tf_test_match_summary( "tf_test_match_summary", "0", FCVAR_REPLICATED ); |
|
|
|
#ifdef GAME_DLL |
|
void cc_tf_fake_mm_changed( IConVar *pConVar, const char *pOldString, float flOldValue ) |
|
{ |
|
ConVarRef var( pConVar ); |
|
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( (EMatchGroup)var.GetInt() ); |
|
if ( pMatchDesc ) |
|
{ |
|
pMatchDesc->InitServerSettingsForMatch( NULL ); |
|
} |
|
} |
|
#endif // GAME_DLL |
|
ConVar tf_fake_mm_group( "tf_fake_mm_group", "-1", FCVAR_REPLICATED, "Fake what kind of MM group is being played" |
|
#ifdef GAME_DLL |
|
, cc_tf_fake_mm_changed |
|
#endif // GAME_DLL |
|
); |
|
#endif // STAGING_ONLY |
|
|
|
#ifdef GAME_DLL |
|
|
|
static const float g_flStrangeEventBatchProcessInterval = 30.0f; |
|
|
|
ConVar mp_humans_must_join_team("mp_humans_must_join_team", "any", FCVAR_REPLICATED, "Restricts human players to a single team {any, blue, red, spectator}" ); |
|
|
|
void cc_tf_medieval_changed( IConVar *pConVar, const char *pOldString, float flOldValue ) |
|
{ |
|
ConVarRef var( pConVar ); |
|
bool bOldValue = flOldValue > 0; |
|
if ( var.IsValid() && ( bOldValue != var.GetBool() ) ) |
|
{ |
|
Msg( "Medieval mode changes take effect after the next map change.\n" ); |
|
} |
|
} |
|
|
|
#endif |
|
ConVar tf_medieval( "tf_medieval", "0", FCVAR_REPLICATED | FCVAR_NOTIFY, "Enable Medieval Mode.\n", true, 0, true, 1 |
|
#ifdef GAME_DLL |
|
, cc_tf_medieval_changed |
|
#endif |
|
); |
|
|
|
ConVar tf_medieval_autorp( "tf_medieval_autorp", "1", FCVAR_REPLICATED | FCVAR_NOTIFY, "Enable Medieval Mode auto-roleplaying.\n", true, 0, true, 1 ); |
|
|
|
ConVar tf_sticky_radius_ramp_time( "tf_sticky_radius_ramp_time", "2.0", FCVAR_DEVELOPMENTONLY | FCVAR_CHEAT | FCVAR_REPLICATED, "Amount of time to get full radius after arming" ); |
|
ConVar tf_sticky_airdet_radius( "tf_sticky_airdet_radius", "0.85", FCVAR_DEVELOPMENTONLY | FCVAR_CHEAT | FCVAR_REPLICATED, "Radius Scale if detonated in the air" ); |
|
|
|
#ifdef STAGING_ONLY |
|
ConVar tf_killstreak_alwayson( "tf_killstreak_alwayson", "0", FCVAR_REPLICATED, "enable to have killstreak effects for all players, bots included"); |
|
|
|
#ifdef GAME_DLL |
|
// Bounty Mode |
|
ConVar tf_bountymode_currency_starting( "tf_bountymode_currency_starting", "1000", FCVAR_ARCHIVE, "How much new players start with when playing Bounty Mode.\n" ); |
|
ConVar tf_bountymode_currency_limit( "tf_bountymode_currency_limit", "0", FCVAR_ARCHIVE, "The maximum amount a player can hold in Bounty Mode.\n" ); |
|
ConVar tf_bountymode_currency_penalty_ondeath( "tf_bountymode_currency_penalty_ondeath", "0", FCVAR_ARCHIVE, "The percentage of unspent money players lose when they die in Bounty Mode.\n" ); |
|
ConVar tf_bountymode_upgrades_wipeondeath( "tf_bountymode_upgrades_wipeondeath", "0", FCVAR_ARCHIVE, "If set to true, wipe player/item upgrades on death.\n" ); |
|
|
|
void cc_bountymode_changed( IConVar *pConVar, const char *pOldString, float flOldValue ) |
|
{ |
|
ConVarRef var( pConVar ); |
|
if ( var.IsValid() && TFGameRules() ) |
|
{ |
|
TFGameRules()->SetBountyMode( var.GetBool() ); |
|
|
|
if ( TFGameRules()->IsMannVsMachineMode() ) |
|
return; |
|
|
|
mp_restartgame_immediate.SetValue( 1 ); |
|
|
|
if ( !g_pPopulationManager ) |
|
{ |
|
CreateEntityByName( "info_populator" ); |
|
} |
|
|
|
int nCurrency = tf_bountymode_currency_starting.GetInt(); |
|
if ( nCurrency > 0 ) |
|
{ |
|
// Give everyone starting money |
|
for ( int i = 0; i <= MAX_PLAYERS; ++i ) |
|
{ |
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
if ( !pPlayer ) |
|
continue; |
|
|
|
pPlayer->SetCurrency( nCurrency ); |
|
} |
|
} |
|
|
|
g_MannVsMachineUpgrades.LoadUpgradesFile(); |
|
|
|
IGameEvent *pEvent = gameeventmanager->CreateEvent( "upgrades_file_changed" ); |
|
if ( pEvent ) |
|
{ |
|
pEvent->SetString( "path", "" ); // Have the client load the default |
|
gameeventmanager->FireEvent( pEvent ); |
|
} |
|
} |
|
} |
|
#endif // GAME_DLL |
|
|
|
ConVar tf_bountymode( "tf_bountymode", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_ARCHIVE, "Allow upgrades and award currency for mission objectives and killing enemy players.\n", true, 0, true, 1 |
|
#ifdef GAME_DLL |
|
, cc_bountymode_changed |
|
#endif // GAME_DLL |
|
); |
|
#endif // STAGING_ONLY |
|
|
|
#ifndef GAME_DLL |
|
extern ConVar cl_burninggibs; |
|
extern ConVar english; |
|
ConVar tf_particles_disable_weather( "tf_particles_disable_weather", "0", FCVAR_ARCHIVE, "Disable particles related to weather effects." ); |
|
#endif |
|
|
|
// arena mode cvars |
|
ConVar tf_arena_force_class( "tf_arena_force_class", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY | FCVAR_CHEAT, "Forces players to play a random class each time they spawn." ); |
|
ConVar tf_arena_change_limit( "tf_arena_change_limit", "1", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY | FCVAR_CHEAT, "Number of times players can change their class when mp_force_random_class is being used." ); |
|
ConVar tf_arena_override_cap_enable_time( "tf_arena_override_cap_enable_time", "-1", FCVAR_REPLICATED | FCVAR_NOTIFY, "Overrides the time (in seconds) it takes for the capture point to become enable, -1 uses the level designer specified time." ); |
|
ConVar tf_arena_override_team_size( "tf_arena_override_team_size", "0", FCVAR_REPLICATED, "Overrides the maximum team size in arena mode. Set to zero to keep the default behavior of 1/3 maxplayers."); |
|
ConVar tf_arena_first_blood( "tf_arena_first_blood", "1", FCVAR_REPLICATED | FCVAR_NOTIFY, "Rewards the first player to get a kill each round." ); |
|
extern ConVar tf_arena_preround_time; |
|
extern ConVar tf_arena_max_streak; |
|
#if defined( _DEBUG ) || defined( STAGING_ONLY ) |
|
extern ConVar mp_developer; |
|
#endif // _DEBUG || STAGING_ONLY |
|
|
|
//============================================================================= |
|
// HPE_BEGIN |
|
// [msmith] Used for the client to tell the server that we're watching a movie or not. |
|
// Also contains the name of a movie if it's an in game video. |
|
//============================================================================= |
|
// Training mode cvars |
|
ConVar tf_training_client_message( "tf_training_client_message", "0", FCVAR_REPLICATED | FCVAR_CHEAT, "A simple way for the training client to communicate with the server." ); |
|
//============================================================================= |
|
// HPE_END |
|
//============================================================================= |
|
|
|
#define TF_ARENA_MODE_FIRST_BLOOD_CRIT_TIME 5.0f |
|
#define TF_ARENA_MODE_FAST_FIRST_BLOOD_TIME 20.0f |
|
#define TF_ARENA_MODE_SLOW_FIRST_BLOOD_TIME 50.0f |
|
|
|
#ifdef TF_RAID_MODE |
|
// Raid mode |
|
ConVar tf_gamemode_raid( "tf_gamemode_raid", "0", FCVAR_REPLICATED | FCVAR_NOTIFY ); // client needs access to this for IsRaidMode() |
|
ConVar tf_raid_enforce_unique_classes( "tf_raid_enforce_unique_classes", "0", FCVAR_REPLICATED | FCVAR_NOTIFY ); |
|
ConVar tf_raid_respawn_time( "tf_raid_respawn_time", "5", FCVAR_REPLICATED | FCVAR_NOTIFY /*| FCVAR_CHEAT*/, "How long it takes for a Raider to respawn with his team after death." ); |
|
ConVar tf_raid_allow_all_classes( "tf_raid_allow_all_classes", "1", FCVAR_REPLICATED | FCVAR_NOTIFY ); |
|
|
|
ConVar tf_gamemode_boss_battle( "tf_gamemode_boss_battle", "0", FCVAR_REPLICATED | FCVAR_NOTIFY ); |
|
|
|
#ifdef GAME_DLL |
|
ConVar tf_raid_allow_overtime( "tf_raid_allow_overtime", "0"/*, FCVAR_CHEAT*/ ); |
|
#endif // GAME_DLL |
|
#endif // TF_RAID_MODE |
|
|
|
enum { kMVM_MaxConnectedPlayers = 10, }; |
|
|
|
ConVar tf_mvm_min_players_to_start( "tf_mvm_min_players_to_start", "3", FCVAR_REPLICATED | FCVAR_NOTIFY, "Minimum number of players connected to start a countdown timer" ); |
|
ConVar tf_mvm_respec_enabled( "tf_mvm_respec_enabled", "1", FCVAR_CHEAT | FCVAR_REPLICATED, "Allow players to refund credits spent on player and item upgrades." ); |
|
ConVar tf_mvm_respec_limit( "tf_mvm_respec_limit", "0", FCVAR_CHEAT | FCVAR_REPLICATED, "The total number of respecs a player can earn. Default: 0 (no limit).", true, 0.f, true, 100.f ); |
|
ConVar tf_mvm_respec_credit_goal( "tf_mvm_respec_credit_goal", "2000", FCVAR_CHEAT | FCVAR_REPLICATED, "When tf_mvm_respec_limit is non-zero, the total amount of money the team must collect to earn a respec credit." ); |
|
#ifdef STAGING_ONLY |
|
ConVar tf_mvm_buybacks_method( "tf_mvm_buybacks_method", "1", FCVAR_REPLICATED | FCVAR_HIDDEN, "When set to 0, use the traditional, currency-based system. When set to 1, use finite, charge-based system.", true, 0.0, true, 1.0 ); |
|
#else |
|
ConVar tf_mvm_buybacks_method( "tf_mvm_buybacks_method", "0", FCVAR_REPLICATED | FCVAR_HIDDEN, "When set to 0, use the traditional, currency-based system. When set to 1, use finite, charge-based system.", true, 0.0, true, 1.0 ); |
|
#endif |
|
ConVar tf_mvm_buybacks_per_wave( "tf_mvm_buybacks_per_wave", "3", FCVAR_REPLICATED | FCVAR_HIDDEN, "The fixed number of buybacks players can use per-wave." ); |
|
|
|
|
|
#ifdef GAME_DLL |
|
enum { kMVM_CurrencyPackMinSize = 1, }; |
|
#endif // GAME_DLL |
|
|
|
extern ConVar mp_tournament; |
|
extern ConVar mp_tournament_post_match_period; |
|
|
|
extern ConVar tf_flag_return_on_touch; |
|
extern ConVar tf_flag_return_time_credit_factor; |
|
ConVar tf_grapplinghook_enable( "tf_grapplinghook_enable", "0", FCVAR_REPLICATED ); |
|
|
|
#ifdef GAME_DLL |
|
CUtlString s_strNextMvMPopFile; |
|
CON_COMMAND_F( tf_mvm_popfile, "Change to a target popfile for MvM", FCVAR_GAMEDLL ) |
|
{ |
|
// Listenserver host or rcon access only! |
|
if ( !UTIL_IsCommandIssuedByServerAdmin() ) |
|
return; |
|
|
|
if ( args.ArgC() <= 1 ) |
|
{ |
|
if ( TFGameRules() && g_pPopulationManager ) |
|
{ |
|
const char *pszFile = g_pPopulationManager->GetPopulationFilename(); |
|
if ( pszFile && pszFile[0] ) |
|
{ |
|
Msg( "Current popfile is: %s\n", pszFile ); |
|
return; |
|
} |
|
} |
|
|
|
Msg( "Missing Popfile name\n" ); |
|
return; |
|
} |
|
|
|
const char *pszShortName = args.Arg(1); |
|
|
|
if ( !TFGameRules() || !g_pPopulationManager ) |
|
{ |
|
Warning( "Cannot set population file before map load.\n" ); |
|
return; |
|
} |
|
|
|
// Make sure we have a file system |
|
if ( !g_pFullFileSystem ) |
|
{ |
|
Msg( "No File System to find Popfile to load\n" ); |
|
return; |
|
} |
|
|
|
// Form full path |
|
CUtlString fullPath; |
|
|
|
if ( g_pPopulationManager->FindPopulationFileByShortName( pszShortName, fullPath ) ) |
|
{ |
|
g_pPopulationManager->SetPopulationFilename( fullPath ); |
|
g_pPopulationManager->ResetMap(); |
|
return; |
|
} |
|
|
|
// Give them a message to make it clear what file we were looking for |
|
Warning( "Could not find a population file matching: %s.\n", pszShortName ); |
|
} |
|
|
|
#ifdef STAGING_ONLY |
|
// Never ship this |
|
CON_COMMAND_F( tf_competitive_mode_force_victory, "For testing.", FCVAR_GAMEDLL ) |
|
{ |
|
// Listenserver host or rcon access only! |
|
if ( !UTIL_IsCommandIssuedByServerAdmin() ) |
|
return; |
|
|
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_GetCommandClient() ); |
|
if ( !pPlayer ) |
|
return; |
|
|
|
CSteamID steamIDForPlayer; |
|
if ( !pPlayer->GetSteamID( &steamIDForPlayer ) ) |
|
return; |
|
|
|
// TODO: Rewrite this based on the shipping version of comp/casual |
|
} |
|
#endif // STAGING_ONLY |
|
#endif |
|
|
|
static bool BIsCvarIndicatingHolidayIsActive( int iCvarValue, /*EHoliday*/ int eHoliday ) |
|
{ |
|
if ( iCvarValue == 0 ) |
|
return false; |
|
|
|
// Unfortunately Holidays are not a proper bitfield |
|
switch ( eHoliday ) |
|
{ |
|
case kHoliday_TFBirthday: return iCvarValue == kHoliday_TFBirthday; |
|
case kHoliday_Halloween: return iCvarValue == kHoliday_Halloween || iCvarValue == kHoliday_HalloweenOrFullMoon || iCvarValue == kHoliday_HalloweenOrFullMoonOrValentines; |
|
case kHoliday_Christmas: return iCvarValue == kHoliday_Christmas; |
|
case kHoliday_Valentines: return iCvarValue == kHoliday_Valentines || iCvarValue == kHoliday_HalloweenOrFullMoonOrValentines; |
|
case kHoliday_MeetThePyro: return iCvarValue == kHoliday_MeetThePyro; |
|
case kHoliday_FullMoon: return iCvarValue == kHoliday_FullMoon || iCvarValue == kHoliday_HalloweenOrFullMoon || iCvarValue == kHoliday_HalloweenOrFullMoonOrValentines; |
|
case kHoliday_HalloweenOrFullMoon: return iCvarValue == kHoliday_Halloween || iCvarValue == kHoliday_FullMoon || iCvarValue == kHoliday_HalloweenOrFullMoon || iCvarValue == kHoliday_HalloweenOrFullMoonOrValentines; |
|
case kHoliday_HalloweenOrFullMoonOrValentines: return iCvarValue == kHoliday_Halloween || iCvarValue == kHoliday_FullMoon || iCvarValue == kHoliday_Valentines || iCvarValue == kHoliday_HalloweenOrFullMoon || iCvarValue == kHoliday_HalloweenOrFullMoonOrValentines; |
|
case kHoliday_AprilFools: return iCvarValue == kHoliday_AprilFools; |
|
case kHoliday_EOTL: return iCvarValue == kHoliday_EOTL; |
|
case kHoliday_CommunityUpdate: return iCvarValue == kHoliday_CommunityUpdate; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
// Fetch holiday setting taking into account convars, etc, but NOT |
|
// taking into consideration the current game rules, map, etc. |
|
// |
|
// This version can be used outside of gameplay, ie., for matchmaking |
|
bool TF_IsHolidayActive( /*EHoliday*/ int eHoliday ) |
|
{ |
|
if ( IsX360() || tf_force_holidays_off.GetBool() ) |
|
return false; |
|
|
|
if ( BIsCvarIndicatingHolidayIsActive( tf_forced_holiday.GetInt(), eHoliday ) ) |
|
return true; |
|
|
|
if ( BIsCvarIndicatingHolidayIsActive( tf_item_based_forced_holiday.GetInt(), eHoliday ) ) |
|
return true; |
|
|
|
if ( ( eHoliday == kHoliday_TFBirthday ) && tf_birthday.GetBool() ) |
|
return true; |
|
|
|
if ( TFGameRules() ) |
|
{ |
|
if ( eHoliday == kHoliday_HalloweenOrFullMoon ) |
|
{ |
|
if ( TFGameRules()->IsHolidayMap( kHoliday_Halloween ) ) |
|
return true; |
|
if ( TFGameRules()->IsHolidayMap( kHoliday_FullMoon ) ) |
|
return true; |
|
} |
|
if ( TFGameRules()->IsHolidayMap( eHoliday ) ) |
|
{ |
|
return true; |
|
} |
|
} |
|
|
|
return UTIL_IsHolidayActive( eHoliday ); |
|
} |
|
|
|
#ifdef TF_CREEP_MODE |
|
ConVar tf_gamemode_creep_wave( "tf_gamemode_creep_wave", "0", FCVAR_REPLICATED | FCVAR_NOTIFY ); |
|
ConVar tf_creep_wave_player_respawn_time( "tf_creep_wave_player_respawn_time", "10", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_CHEAT, "How long it takes for a player to respawn with his team after death." ); |
|
#endif |
|
|
|
#ifdef GAME_DLL |
|
// TF overrides the default value of this convar |
|
|
|
#ifdef _DEBUG |
|
#define WAITING_FOR_PLAYERS_FLAGS 0 |
|
#else |
|
#define WAITING_FOR_PLAYERS_FLAGS FCVAR_DEVELOPMENTONLY |
|
#endif |
|
|
|
ConVar hide_server( "hide_server", "0", FCVAR_GAMEDLL, "Whether the server should be hidden from the master server" ); |
|
|
|
ConVar mp_waitingforplayers_time( "mp_waitingforplayers_time", (IsX360()?"15":"30"), FCVAR_GAMEDLL | WAITING_FOR_PLAYERS_FLAGS, "WaitingForPlayers time length in seconds" ); |
|
|
|
ConVar tf_gamemode_arena ( "tf_gamemode_arena", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY ); |
|
ConVar tf_gamemode_cp ( "tf_gamemode_cp", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY ); |
|
ConVar tf_gamemode_ctf ( "tf_gamemode_ctf", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY ); |
|
ConVar tf_gamemode_sd ( "tf_gamemode_sd", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY ); |
|
ConVar tf_gamemode_rd ( "tf_gamemode_rd", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY ); |
|
ConVar tf_gamemode_pd ( "tf_gamemode_pd", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY ); |
|
ConVar tf_gamemode_tc ( "tf_gamemode_tc", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY ); |
|
ConVar tf_beta_content ( "tf_beta_content", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY ); |
|
ConVar tf_gamemode_payload ( "tf_gamemode_payload", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY ); |
|
ConVar tf_gamemode_mvm ( "tf_gamemode_mvm", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY ); |
|
ConVar tf_gamemode_passtime ( "tf_gamemode_passtime", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY ); |
|
ConVar tf_gamemode_misc ( "tf_gamemode_misc", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY ); |
|
|
|
ConVar tf_bot_count( "tf_bot_count", "0", FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY ); |
|
|
|
#ifdef _DEBUG |
|
ConVar tf_debug_ammo_and_health( "tf_debug_ammo_and_health", "0", FCVAR_CHEAT ); |
|
#endif // _DEBUG |
|
|
|
static Vector s_BotSpawnPosition; |
|
|
|
ConVar tf_gravetalk( "tf_gravetalk", "1", FCVAR_NOTIFY, "Allows living players to hear dead players using text/voice chat.", true, 0, true, 1 ); |
|
|
|
ConVar tf_ctf_bonus_time ( "tf_ctf_bonus_time", "10", FCVAR_NOTIFY, "Length of team crit time for CTF capture." ); |
|
|
|
#ifdef _DEBUG |
|
ConVar mp_scrambleteams_debug( "mp_scrambleteams_debug", "0", FCVAR_NONE, "Debug spew." ); |
|
#endif // _DEBUG |
|
|
|
#ifdef STAGING_ONLY |
|
ConVar mp_tournament_readymode_bots_allowed( "mp_tournament_readymode_bots_allowed", "0", FCVAR_ARCHIVE, "Allow bot data to go through the system for debugging." ); |
|
#endif // STAGING_ONLY |
|
|
|
extern ConVar tf_mm_servermode; |
|
extern ConVar tf_flag_caps_per_round; |
|
|
|
void cc_competitive_mode( IConVar *pConVar, const char *pOldString, float flOldValue ) |
|
{ |
|
IGameEvent *event = gameeventmanager->CreateEvent( "competitive_state_changed" ); |
|
if ( event ) |
|
{ |
|
// Server-side here. Client-side down below in the RecvProxy |
|
gameeventmanager->FireEvent( event, true ); |
|
} |
|
} |
|
ConVar tf_competitive_preround_duration( "tf_competitive_preround_duration", "3", FCVAR_REPLICATED, "How long we stay in pre-round when in competitive games." ); |
|
ConVar tf_competitive_preround_countdown_duration( "tf_competitive_preround_countdown_duration", "10.5", FCVAR_HIDDEN, "How long we stay in countdown when in competitive games." ); |
|
ConVar tf_competitive_abandon_method( "tf_competitive_abandon_method", "0", FCVAR_HIDDEN ); |
|
ConVar tf_competitive_required_late_join_timeout( "tf_competitive_required_late_join_timeout", "120", FCVAR_DEVELOPMENTONLY, |
|
"How long to wait for late joiners in matches requiring full player counts before canceling the match" ); |
|
ConVar tf_competitive_required_late_join_confirm_timeout( "tf_competitive_required_late_join_confirm_timeout", "30", FCVAR_DEVELOPMENTONLY, |
|
"How long to wait for the GC to confirm we're in the late join pool before canceling the match" ); |
|
#endif // GAME_DLL |
|
|
|
#ifdef GAME_DLL |
|
void cc_powerup_mode( IConVar *pConVar, const char *pOldString, float flOldValue ) |
|
{ |
|
ConVarRef var( pConVar ); |
|
if ( var.IsValid() ) |
|
{ |
|
if ( !TFGameRules() ) |
|
return; |
|
|
|
if ( var.GetBool() ) |
|
{ |
|
if ( TFGameRules()->IsMannVsMachineMode() ) |
|
return; |
|
} |
|
|
|
TFGameRules()->SetPowerupMode( var.GetBool() ); |
|
TFGameRules()->State_Transition( GR_STATE_PREROUND ); |
|
tf_flag_caps_per_round.SetValue( var.GetBool() ? 7 : 3 ); // Hack |
|
} |
|
} |
|
|
|
ConVar tf_powerup_mode( "tf_powerup_mode", "0", FCVAR_NOTIFY, "Enable/disable powerup mode. Not compatible with Mann Vs Machine mode", cc_powerup_mode ); |
|
ConVar tf_powerup_mode_imbalance_delta( "tf_powerup_mode_imbalance_delta", "24", FCVAR_CHEAT, "Powerup kill score lead one team must have before imbalance measures are initiated" ); |
|
|
|
ConVar tf_skillrating_update_interval( "tf_skillrating_update_interval", "180", FCVAR_ARCHIVE, "How often to update the GC and OGS." ); |
|
|
|
extern ConVar mp_teams_unbalance_limit; |
|
|
|
static bool g_bRandomMap = false; |
|
|
|
void cc_RandomMap( const CCommand& args ) |
|
{ |
|
CTFGameRules *pRules = TFGameRules(); |
|
if ( pRules ) |
|
{ |
|
if ( !UTIL_IsCommandIssuedByServerAdmin() ) |
|
return; |
|
|
|
g_bRandomMap = true; |
|
} |
|
else |
|
{ |
|
// There's no game rules object yet, so let's load the map cycle and pick a map. |
|
char mapcfile[MAX_PATH]; |
|
CMultiplayRules::DetermineMapCycleFilename( mapcfile, sizeof(mapcfile), true ); |
|
if ( !mapcfile[0] ) |
|
{ |
|
Msg( "No mapcyclefile specified. Cannot pick a random map.\n" ); |
|
return; |
|
} |
|
|
|
CUtlVector<char*> mapList; |
|
// No gamerules entity yet, since we don't need the fixups to find a map just use the base version |
|
CMultiplayRules::RawLoadMapCycleFileIntoVector ( mapcfile, mapList ); |
|
if ( !mapList.Count() ) |
|
{ |
|
Msg( "Map cycle file \"%s\" contains no valid maps or cannot be read. Cannot pick a random map.\n", mapcfile ); |
|
return; |
|
} |
|
|
|
int iMapIndex = RandomInt( 0, mapList.Count() - 1 ); |
|
Msg ( "randommap: selecting map %i out of %i\n", iMapIndex + 1, mapList.Count() ); |
|
engine->ServerCommand( UTIL_VarArgs( "map %s\n", mapList[iMapIndex] ) ); |
|
|
|
CMultiplayRules::FreeMapCycleFileVector( mapList ); |
|
} |
|
} |
|
|
|
// Simple class for tracking previous gamemode across level transitions |
|
// Allows clean-up of UI/state when going between things like MvM and PvP |
|
class CTFGameModeHistory : public CAutoGameSystem |
|
{ |
|
public: |
|
virtual bool Init() |
|
{ |
|
m_nPrevState = 0; |
|
return true; |
|
} |
|
void SetPrevState( int nState ) { m_nPrevState = nState; } |
|
int GetPrevState( void ) { return m_nPrevState; } |
|
private: |
|
int m_nPrevState; |
|
} g_TFGameModeHistory; |
|
|
|
static ConCommand randommap( "randommap", cc_RandomMap, "Changelevel to a random map in the mapcycle file" ); |
|
#endif // GAME_DLL |
|
|
|
#ifdef GAME_DLL |
|
static bool PlayerHasDuckStreaks( CTFPlayer *pPlayer ) |
|
{ |
|
CEconItemView *pActionItem = pPlayer->GetEquippedItemForLoadoutSlot( LOADOUT_POSITION_ACTION ); |
|
if ( !pActionItem ) |
|
return false; |
|
|
|
// Duck Badge Cooldown is based on badge level. Noisemaker is more like an easter egg |
|
static CSchemaAttributeDefHandle pAttr_DuckStreaks( "duckstreaks active" ); |
|
uint32 iDuckStreaksActive = 0; |
|
|
|
// Don't care about the level, just if the attribute is found |
|
return FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pActionItem, pAttr_DuckStreaks, &iDuckStreaksActive ) && iDuckStreaksActive > 0; |
|
} |
|
|
|
void ValidateCapturesPerRound( IConVar *pConVar, const char *oldValue, float flOldValue ) |
|
{ |
|
ConVarRef var( pConVar ); |
|
|
|
if ( var.GetInt() <= 0 ) |
|
{ |
|
// reset the flag captures being played in the current round |
|
int nTeamCount = TFTeamMgr()->GetTeamCount(); |
|
for ( int iTeam = FIRST_GAME_TEAM; iTeam < nTeamCount; ++iTeam ) |
|
{ |
|
CTFTeam *pTeam = GetGlobalTFTeam( iTeam ); |
|
if ( !pTeam ) |
|
continue; |
|
|
|
pTeam->SetFlagCaptures( 0 ); |
|
} |
|
} |
|
} |
|
|
|
static void Coaching_Start( CTFPlayer *pCoach, CTFPlayer *pStudent ) |
|
{ |
|
pCoach->SetIsCoaching( true ); |
|
pCoach->ForceChangeTeam( TEAM_SPECTATOR ); |
|
pCoach->SetObserverTarget( pStudent ); |
|
pCoach->StartObserverMode( OBS_MODE_CHASE ); |
|
pCoach->SetStudent( pStudent ); |
|
pStudent->SetCoach( pCoach ); |
|
} |
|
|
|
static void Coaching_Stop( CTFPlayer *pCoach ) |
|
{ |
|
CTFPlayer *pStudent = pCoach->GetStudent(); |
|
if ( pStudent ) |
|
{ |
|
pStudent->SetCoach( NULL ); |
|
} |
|
pCoach->SetIsCoaching( false ); |
|
pCoach->SetStudent( NULL ); |
|
pCoach->ForceChangeTeam( TEAM_SPECTATOR ); |
|
} |
|
|
|
#endif |
|
|
|
ConVar tf_flag_caps_per_round( "tf_flag_caps_per_round", "3", FCVAR_REPLICATED, "Number of captures per round on CTF and PASS Time maps. Set to 0 to disable.", true, 0, false, 0 |
|
#ifdef GAME_DLL |
|
, ValidateCapturesPerRound |
|
#endif |
|
); |
|
|
|
|
|
/** |
|
* Player hull & eye position for standing, ducking, etc. This version has a taller |
|
* player height, but goldsrc-compatible collision bounds. |
|
*/ |
|
static CViewVectors g_TFViewVectors( |
|
Vector( 0, 0, 72 ), //VEC_VIEW (m_vView) eye position |
|
|
|
Vector(-24, -24, 0 ), //VEC_HULL_MIN (m_vHullMin) hull min |
|
Vector( 24, 24, 82 ), //VEC_HULL_MAX (m_vHullMax) hull max |
|
|
|
Vector(-24, -24, 0 ), //VEC_DUCK_HULL_MIN (m_vDuckHullMin) duck hull min |
|
Vector( 24, 24, 62 ), //VEC_DUCK_HULL_MAX (m_vDuckHullMax) duck hull max |
|
Vector( 0, 0, 45 ), //VEC_DUCK_VIEW (m_vDuckView) duck view |
|
|
|
Vector( -10, -10, -10 ), //VEC_OBS_HULL_MIN (m_vObsHullMin) observer hull min |
|
Vector( 10, 10, 10 ), //VEC_OBS_HULL_MAX (m_vObsHullMax) observer hull max |
|
|
|
Vector( 0, 0, 14 ) //VEC_DEAD_VIEWHEIGHT (m_vDeadViewHeight) dead view height |
|
); |
|
|
|
Vector g_TFClassViewVectors[11] = |
|
{ |
|
Vector( 0, 0, 72 ), // TF_CLASS_UNDEFINED |
|
|
|
Vector( 0, 0, 65 ), // TF_CLASS_SCOUT, // TF_FIRST_NORMAL_CLASS |
|
Vector( 0, 0, 75 ), // TF_CLASS_SNIPER, |
|
Vector( 0, 0, 68 ), // TF_CLASS_SOLDIER, |
|
Vector( 0, 0, 68 ), // TF_CLASS_DEMOMAN, |
|
Vector( 0, 0, 75 ), // TF_CLASS_MEDIC, |
|
Vector( 0, 0, 75 ), // TF_CLASS_HEAVYWEAPONS, |
|
Vector( 0, 0, 68 ), // TF_CLASS_PYRO, |
|
Vector( 0, 0, 75 ), // TF_CLASS_SPY, |
|
Vector( 0, 0, 68 ), // TF_CLASS_ENGINEER, |
|
|
|
Vector( 0, 0, 65 ), // TF_CLASS_CIVILIAN, // TF_LAST_NORMAL_CLASS |
|
}; |
|
|
|
const CViewVectors *CTFGameRules::GetViewVectors() const |
|
{ |
|
return &g_TFViewVectors; |
|
} |
|
|
|
REGISTER_GAMERULES_CLASS( CTFGameRules ); |
|
|
|
#ifdef CLIENT_DLL |
|
void RecvProxy_MatchSummary( const CRecvProxyData *pData, void *pStruct, void *pOut ) |
|
{ |
|
bool bMatchSummary = ( pData->m_Value.m_Int > 0 ); |
|
if ( bMatchSummary && !(*(bool*)(pOut))) |
|
{ |
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer(); |
|
if ( pLocalPlayer ) |
|
{ |
|
pLocalPlayer->TurnOffTauntCam(); |
|
pLocalPlayer->TurnOffTauntCam_Finish();; |
|
} |
|
|
|
IGameEvent *event = gameeventmanager->CreateEvent( "show_match_summary" ); |
|
if ( event ) |
|
{ |
|
gameeventmanager->FireEventClientSide( event ); |
|
} |
|
} |
|
|
|
*(bool*)(pOut) = bMatchSummary; |
|
} |
|
|
|
void RecvProxy_CompetitiveMode( const CRecvProxyData *pData, void *pStruct, void *pOut ) |
|
{ |
|
*(bool*)(pOut) = ( pData->m_Value.m_Int > 0 ); |
|
|
|
IGameEvent *event = gameeventmanager->CreateEvent( "competitive_state_changed" ); |
|
if ( event ) |
|
{ |
|
// Client-side once it's actually happened |
|
gameeventmanager->FireEventClientSide( event ); |
|
} |
|
} |
|
|
|
void RecvProxy_PlayerVotedForMap( const CRecvProxyData *pData, void *pStruct, void *pOut ) |
|
{ |
|
if ( *(int*)(pOut) != pData->m_Value.m_Int ) |
|
{ |
|
*(int*)(pOut) = pData->m_Value.m_Int; |
|
|
|
IGameEvent *event = gameeventmanager->CreateEvent( "player_next_map_vote_change" ); |
|
if ( event ) |
|
{ |
|
event->SetInt( "map_index", pData->m_Value.m_Int ); |
|
event->SetInt( "vote", pData->m_Value.m_Int ); |
|
// Client-side once it's actually happened |
|
gameeventmanager->FireEventClientSide( event ); |
|
} |
|
} |
|
} |
|
|
|
void RecvProxy_NewMapVoteStateChanged( const CRecvProxyData *pData, void *pStruct, void *pOut ) |
|
{ |
|
bool bChange = *(int*)(pOut) != pData->m_Value.m_Int; |
|
*(int*)(pOut) = pData->m_Value.m_Int; |
|
|
|
if ( bChange ) |
|
{ |
|
IGameEvent *event = gameeventmanager->CreateEvent( "vote_maps_changed" ); |
|
if ( event ) |
|
{ |
|
// Client-side once it's actually happened |
|
gameeventmanager->FireEventClientSide( event ); |
|
} |
|
} |
|
} |
|
#endif |
|
|
|
BEGIN_NETWORK_TABLE_NOBASE( CTFGameRules, DT_TFGameRules ) |
|
#ifdef CLIENT_DLL |
|
|
|
RecvPropInt( RECVINFO( m_nGameType ) ), |
|
RecvPropInt( RECVINFO( m_nStopWatchState ) ), |
|
RecvPropString( RECVINFO( m_pszTeamGoalStringRed ) ), |
|
RecvPropString( RECVINFO( m_pszTeamGoalStringBlue ) ), |
|
RecvPropTime( RECVINFO( m_flCapturePointEnableTime ) ), |
|
|
|
//============================================================================= |
|
// HPE_BEGIN: |
|
// [msmith] Training status and HUD Type. |
|
//============================================================================= |
|
RecvPropInt( RECVINFO( m_nHudType ) ), |
|
RecvPropBool( RECVINFO( m_bIsInTraining ) ), |
|
RecvPropBool( RECVINFO( m_bAllowTrainingAchievements ) ), |
|
RecvPropBool( RECVINFO( m_bIsWaitingForTrainingContinue ) ), |
|
//============================================================================= |
|
// HPE_END |
|
//============================================================================= |
|
RecvPropBool( RECVINFO( m_bIsTrainingHUDVisible ) ), |
|
RecvPropBool( RECVINFO( m_bIsInItemTestingMode ) ), |
|
|
|
RecvPropEHandle( RECVINFO( m_hBonusLogic ) ), |
|
RecvPropBool( RECVINFO( m_bPlayingKoth ) ), |
|
RecvPropBool( RECVINFO( m_bPlayingMedieval ) ), |
|
RecvPropBool( RECVINFO( m_bPlayingHybrid_CTF_CP ) ), |
|
RecvPropBool( RECVINFO( m_bPlayingSpecialDeliveryMode ) ), |
|
RecvPropBool( RECVINFO( m_bPlayingRobotDestructionMode ) ), |
|
RecvPropEHandle( RECVINFO( m_hRedKothTimer ) ), |
|
RecvPropEHandle( RECVINFO( m_hBlueKothTimer ) ), |
|
RecvPropInt( RECVINFO( m_nMapHolidayType ) ), |
|
|
|
RecvPropEHandle( RECVINFO( m_itHandle ) ), |
|
RecvPropBool( RECVINFO( m_bPlayingMannVsMachine ) ), |
|
RecvPropEHandle( RECVINFO( m_hBirthdayPlayer ) ), |
|
|
|
RecvPropInt( RECVINFO( m_nBossHealth ) ), |
|
RecvPropInt( RECVINFO( m_nMaxBossHealth ) ), |
|
RecvPropInt( RECVINFO( m_fBossNormalizedTravelDistance ) ), |
|
RecvPropBool( RECVINFO( m_bMannVsMachineAlarmStatus ) ), |
|
RecvPropBool( RECVINFO( m_bHaveMinPlayersToEnableReady ) ), |
|
|
|
RecvPropBool( RECVINFO( m_bBountyModeEnabled ) ), |
|
|
|
RecvPropInt( RECVINFO( m_nHalloweenEffect ) ), |
|
RecvPropFloat( RECVINFO( m_fHalloweenEffectStartTime ) ), |
|
RecvPropFloat( RECVINFO( m_fHalloweenEffectDuration ) ), |
|
RecvPropInt( RECVINFO( m_halloweenScenario ) ), |
|
RecvPropBool( RECVINFO( m_bHelltowerPlayersInHell ) ), |
|
RecvPropBool( RECVINFO( m_bIsUsingSpells ) ), |
|
RecvPropBool( RECVINFO( m_bCompetitiveMode ), 0, RecvProxy_CompetitiveMode ), |
|
RecvPropInt( RECVINFO( m_nMatchGroupType ) ), |
|
RecvPropBool( RECVINFO( m_bMatchEnded ) ), |
|
RecvPropBool( RECVINFO( m_bPowerupMode ) ), |
|
RecvPropString( RECVINFO( m_pszCustomUpgradesFile ) ), |
|
RecvPropBool( RECVINFO( m_bTruceActive ) ), |
|
RecvPropBool( RECVINFO( m_bShowMatchSummary ), 0, RecvProxy_MatchSummary ), |
|
RecvPropBool( RECVINFO_NAME( m_bShowMatchSummary, "m_bShowCompetitiveMatchSummary" ), 0, RecvProxy_MatchSummary ), // Renamed |
|
RecvPropBool( RECVINFO( m_bTeamsSwitched ) ), |
|
RecvPropBool( RECVINFO( m_bMapHasMatchSummaryStage ) ), |
|
RecvPropBool( RECVINFO( m_bPlayersAreOnMatchSummaryStage ) ), |
|
RecvPropBool( RECVINFO( m_bStopWatchWinner ) ), |
|
RecvPropArray3( RECVINFO_ARRAY(m_ePlayerWantsRematch), RecvPropInt( RECVINFO(m_ePlayerWantsRematch[0]), 0, RecvProxy_PlayerVotedForMap ) ), |
|
RecvPropInt( RECVINFO( m_eRematchState ) ), |
|
RecvPropArray3( RECVINFO_ARRAY(m_nNextMapVoteOptions), RecvPropInt( RECVINFO(m_nNextMapVoteOptions[0]), 0, RecvProxy_NewMapVoteStateChanged ) ), |
|
#else |
|
|
|
SendPropInt( SENDINFO( m_nGameType ), 4, SPROP_UNSIGNED ), |
|
SendPropInt( SENDINFO( m_nStopWatchState ), 3, SPROP_UNSIGNED ), |
|
SendPropString( SENDINFO( m_pszTeamGoalStringRed ) ), |
|
SendPropString( SENDINFO( m_pszTeamGoalStringBlue ) ), |
|
SendPropTime( SENDINFO( m_flCapturePointEnableTime ) ), |
|
|
|
//============================================================================= |
|
// HPE_BEGIN: |
|
// [msmith] Training status and hud type. |
|
//============================================================================= |
|
SendPropInt( SENDINFO( m_nHudType ), 3, SPROP_UNSIGNED ), |
|
SendPropBool( SENDINFO( m_bIsInTraining ) ), |
|
SendPropBool( SENDINFO( m_bAllowTrainingAchievements ) ), |
|
SendPropBool( SENDINFO( m_bIsWaitingForTrainingContinue ) ), |
|
//============================================================================= |
|
// HPE_END |
|
//============================================================================= |
|
SendPropBool( SENDINFO( m_bIsTrainingHUDVisible ) ), |
|
SendPropBool( SENDINFO( m_bIsInItemTestingMode ) ), |
|
|
|
SendPropEHandle( SENDINFO( m_hBonusLogic ) ), |
|
SendPropBool( SENDINFO( m_bPlayingKoth ) ), |
|
SendPropBool( SENDINFO( m_bPlayingMedieval ) ), |
|
SendPropBool( SENDINFO( m_bPlayingHybrid_CTF_CP ) ), |
|
SendPropBool( SENDINFO( m_bPlayingSpecialDeliveryMode ) ), |
|
SendPropBool( SENDINFO( m_bPlayingRobotDestructionMode ) ), |
|
SendPropEHandle( SENDINFO( m_hRedKothTimer ) ), |
|
SendPropEHandle( SENDINFO( m_hBlueKothTimer ) ), |
|
SendPropInt( SENDINFO( m_nMapHolidayType ), 3, SPROP_UNSIGNED ), |
|
|
|
SendPropEHandle( SENDINFO( m_itHandle ) ), |
|
SendPropBool( SENDINFO( m_bPlayingMannVsMachine ) ), |
|
SendPropEHandle( SENDINFO( m_hBirthdayPlayer ) ), |
|
|
|
SendPropInt( SENDINFO( m_nBossHealth ) ), |
|
SendPropInt( SENDINFO( m_nMaxBossHealth ) ), |
|
SendPropInt( SENDINFO( m_fBossNormalizedTravelDistance ) ), |
|
SendPropBool( SENDINFO( m_bMannVsMachineAlarmStatus ) ), |
|
SendPropBool( SENDINFO( m_bHaveMinPlayersToEnableReady ) ), |
|
|
|
SendPropBool( SENDINFO( m_bBountyModeEnabled ) ), |
|
|
|
SendPropInt( SENDINFO( m_nHalloweenEffect ) ), |
|
SendPropFloat( SENDINFO( m_fHalloweenEffectStartTime ) ), |
|
SendPropFloat( SENDINFO( m_fHalloweenEffectDuration ) ), |
|
SendPropInt( SENDINFO( m_halloweenScenario ) ), |
|
SendPropBool( SENDINFO( m_bHelltowerPlayersInHell ) ), |
|
SendPropBool( SENDINFO( m_bIsUsingSpells ) ), |
|
SendPropBool( SENDINFO( m_bCompetitiveMode ) ), |
|
SendPropBool( SENDINFO( m_bPowerupMode ) ), |
|
SendPropInt( SENDINFO( m_nMatchGroupType ) ), |
|
SendPropBool( SENDINFO( m_bMatchEnded ) ), |
|
SendPropString( SENDINFO( m_pszCustomUpgradesFile ) ), |
|
SendPropBool( SENDINFO( m_bTruceActive ) ), |
|
SendPropBool( SENDINFO( m_bShowMatchSummary ) ), |
|
SendPropBool( SENDINFO( m_bTeamsSwitched ) ), |
|
SendPropBool( SENDINFO( m_bMapHasMatchSummaryStage ) ), |
|
SendPropBool( SENDINFO( m_bPlayersAreOnMatchSummaryStage ) ), |
|
SendPropBool( SENDINFO( m_bStopWatchWinner ) ), |
|
SendPropArray3( SENDINFO_ARRAY3(m_ePlayerWantsRematch), SendPropInt( SENDINFO_ARRAY(m_ePlayerWantsRematch), -1, SPROP_UNSIGNED | SPROP_VARINT ) ), |
|
SendPropInt( SENDINFO( m_eRematchState ) ), |
|
SendPropArray3( SENDINFO_ARRAY3(m_nNextMapVoteOptions), SendPropInt( SENDINFO_ARRAY(m_nNextMapVoteOptions), -1, SPROP_UNSIGNED | SPROP_VARINT ) ), |
|
#endif |
|
END_NETWORK_TABLE() |
|
|
|
LINK_ENTITY_TO_CLASS( tf_gamerules, CTFGameRulesProxy ); |
|
IMPLEMENT_NETWORKCLASS_ALIASED( TFGameRulesProxy, DT_TFGameRulesProxy ) |
|
|
|
#ifdef CLIENT_DLL |
|
void RecvProxy_TFGameRules( const RecvProp *pProp, void **pOut, void *pData, int objectID ) |
|
{ |
|
CTFGameRules *pRules = TFGameRules(); |
|
Assert( pRules ); |
|
*pOut = pRules; |
|
} |
|
|
|
BEGIN_RECV_TABLE( CTFGameRulesProxy, DT_TFGameRulesProxy ) |
|
RecvPropDataTable( "tf_gamerules_data", 0, 0, &REFERENCE_RECV_TABLE( DT_TFGameRules ), RecvProxy_TFGameRules ) |
|
END_RECV_TABLE() |
|
#else |
|
void *SendProxy_TFGameRules( const SendProp *pProp, const void *pStructBase, const void *pData, CSendProxyRecipients *pRecipients, int objectID ) |
|
{ |
|
CTFGameRules *pRules = TFGameRules(); |
|
Assert( pRules ); |
|
pRecipients->SetAllRecipients(); |
|
return pRules; |
|
} |
|
|
|
BEGIN_SEND_TABLE( CTFGameRulesProxy, DT_TFGameRulesProxy ) |
|
SendPropDataTable( "tf_gamerules_data", 0, &REFERENCE_SEND_TABLE( DT_TFGameRules ), SendProxy_TFGameRules ) |
|
END_SEND_TABLE() |
|
#endif |
|
|
|
#ifdef GAME_DLL |
|
BEGIN_DATADESC( CTFGameRulesProxy ) |
|
//============================================================================= |
|
// HPE_BEGIN: |
|
// [msmith] Training HUD type |
|
//============================================================================= |
|
DEFINE_KEYFIELD( m_nHudType, FIELD_INTEGER, "hud_type" ), |
|
//============================================================================= |
|
// HPE_END |
|
//============================================================================= |
|
|
|
DEFINE_KEYFIELD( m_bOvertimeAllowedForCTF, FIELD_BOOLEAN, "ctf_overtime" ), |
|
|
|
// Inputs. |
|
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetRedTeamRespawnWaveTime", InputSetRedTeamRespawnWaveTime ), |
|
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetBlueTeamRespawnWaveTime", InputSetBlueTeamRespawnWaveTime ), |
|
DEFINE_INPUTFUNC( FIELD_FLOAT, "AddRedTeamRespawnWaveTime", InputAddRedTeamRespawnWaveTime ), |
|
DEFINE_INPUTFUNC( FIELD_FLOAT, "AddBlueTeamRespawnWaveTime", InputAddBlueTeamRespawnWaveTime ), |
|
DEFINE_INPUTFUNC( FIELD_STRING, "SetRedTeamGoalString", InputSetRedTeamGoalString ), |
|
DEFINE_INPUTFUNC( FIELD_STRING, "SetBlueTeamGoalString", InputSetBlueTeamGoalString ), |
|
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetRedTeamRole", InputSetRedTeamRole ), |
|
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetBlueTeamRole", InputSetBlueTeamRole ), |
|
DEFINE_INPUTFUNC( FIELD_STRING, "SetRequiredObserverTarget", InputSetRequiredObserverTarget ), |
|
DEFINE_INPUTFUNC( FIELD_INTEGER, "AddRedTeamScore", InputAddRedTeamScore ), |
|
DEFINE_INPUTFUNC( FIELD_INTEGER, "AddBlueTeamScore", InputAddBlueTeamScore ), |
|
DEFINE_INPUTFUNC( FIELD_VOID, "SetRedKothClockActive", InputSetRedKothClockActive ), |
|
DEFINE_INPUTFUNC( FIELD_VOID, "SetBlueKothClockActive", InputSetBlueKothClockActive ), |
|
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetCTFCaptureBonusTime", InputSetCTFCaptureBonusTime ), |
|
DEFINE_INPUTFUNC( FIELD_STRING, "PlayVORed", InputPlayVORed ), |
|
DEFINE_INPUTFUNC( FIELD_STRING, "PlayVOBlue", InputPlayVOBlue ), |
|
DEFINE_INPUTFUNC( FIELD_STRING, "PlayVO", InputPlayVO ), |
|
DEFINE_INPUTFUNC( FIELD_STRING, "HandleMapEvent", InputHandleMapEvent ), |
|
DEFINE_INPUTFUNC( FIELD_STRING, "SetCustomUpgradesFile", InputSetCustomUpgradesFile ), |
|
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetRoundRespawnFreezeEnabled", InputSetRoundRespawnFreezeEnabled ), |
|
DEFINE_INPUTFUNC( FIELD_BOOLEAN, "SetMapForcedTruceDuringBossFight", InputSetMapForcedTruceDuringBossFight ), |
|
|
|
DEFINE_OUTPUT( m_OnWonByTeam1, "OnWonByTeam1" ), |
|
DEFINE_OUTPUT( m_OnWonByTeam2, "OnWonByTeam2" ), |
|
DEFINE_OUTPUT( m_Team1PlayersChanged, "Team1PlayersChanged" ), |
|
DEFINE_OUTPUT( m_Team2PlayersChanged, "Team2PlayersChanged" ), |
|
DEFINE_OUTPUT( m_OnPowerupImbalanceTeam1, "OnPowerupImbalanceTeam1" ), |
|
DEFINE_OUTPUT( m_OnPowerupImbalanceTeam2, "OnPowerupImbalanceTeam2" ), |
|
DEFINE_OUTPUT( m_OnPowerupImbalanceMeasuresOver, "OnPowerupImbalanceMeasuresOver" ), |
|
DEFINE_OUTPUT( m_OnStateEnterRoundRunning, "OnStateEnterRoundRunning" ), |
|
DEFINE_OUTPUT( m_OnStateEnterBetweenRounds, "OnStateEnterBetweenRounds" ), |
|
DEFINE_OUTPUT( m_OnStateEnterPreRound, "OnStateEnterPreRound" ), |
|
DEFINE_OUTPUT( m_OnStateExitPreRound, "OnStateExitPreRound" ), |
|
DEFINE_OUTPUT( m_OnMatchSummaryStart, "OnMatchSummaryStart" ), |
|
DEFINE_OUTPUT( m_OnTruceStart, "OnTruceStart" ), |
|
DEFINE_OUTPUT( m_OnTruceEnd, "OnTruceEnd" ), |
|
END_DATADESC() |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
CTFGameRulesProxy::CTFGameRulesProxy() |
|
{ |
|
m_nHudType = TF_HUDTYPE_UNDEFINED; |
|
m_bOvertimeAllowedForCTF = true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::InputAddRedTeamScore( inputdata_t &inputdata ) |
|
{ |
|
TFTeamMgr()->AddTeamScore( TF_TEAM_RED, inputdata.value.Int() ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::InputAddBlueTeamScore( inputdata_t &inputdata ) |
|
{ |
|
TFTeamMgr()->AddTeamScore( TF_TEAM_BLUE, inputdata.value.Int() ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::InputSetRedKothClockActive( inputdata_t &inputdata ) |
|
{ |
|
if ( TFGameRules() ) |
|
{ |
|
variant_t sVariant; |
|
CTeamRoundTimer *pTimer = TFGameRules()->GetKothTeamTimer( TF_TEAM_BLUE ); |
|
if ( pTimer ) |
|
{ |
|
pTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 ); |
|
} |
|
|
|
pTimer = TFGameRules()->GetKothTeamTimer( TF_TEAM_RED ); |
|
if ( pTimer ) |
|
{ |
|
pTimer->AcceptInput( "Resume", NULL, NULL, sVariant, 0 ); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::InputSetCTFCaptureBonusTime( inputdata_t &inputdata ) |
|
{ |
|
if ( TFGameRules() ) |
|
{ |
|
TFGameRules()->SetCTFCaptureBonusTime( inputdata.value.Float() ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::InputSetBlueKothClockActive( inputdata_t &inputdata ) |
|
{ |
|
if ( TFGameRules() ) |
|
{ |
|
variant_t sVariant; |
|
CTeamRoundTimer *pTimer = TFGameRules()->GetKothTeamTimer( TF_TEAM_BLUE ); |
|
if ( pTimer ) |
|
{ |
|
pTimer->AcceptInput( "Resume", NULL, NULL, sVariant, 0 ); |
|
} |
|
|
|
pTimer = TFGameRules()->GetKothTeamTimer( TF_TEAM_RED ); |
|
if ( pTimer ) |
|
{ |
|
pTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 ); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::InputSetRequiredObserverTarget( inputdata_t &inputdata ) |
|
{ |
|
const char *pszEntName = inputdata.value.String(); |
|
CBaseEntity *pEnt = NULL; |
|
|
|
if ( pszEntName && pszEntName[0] ) |
|
{ |
|
pEnt = gEntList.FindEntityByName( NULL, pszEntName ); |
|
} |
|
|
|
TFGameRules()->SetRequiredObserverTarget( pEnt ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::InputSetRedTeamRespawnWaveTime( inputdata_t &inputdata ) |
|
{ |
|
TFGameRules()->SetTeamRespawnWaveTime( TF_TEAM_RED, inputdata.value.Float() ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::InputSetBlueTeamRespawnWaveTime( inputdata_t &inputdata ) |
|
{ |
|
TFGameRules()->SetTeamRespawnWaveTime( TF_TEAM_BLUE, inputdata.value.Float() ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::InputAddRedTeamRespawnWaveTime( inputdata_t &inputdata ) |
|
{ |
|
TFGameRules()->AddTeamRespawnWaveTime( TF_TEAM_RED, inputdata.value.Float() ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::InputAddBlueTeamRespawnWaveTime( inputdata_t &inputdata ) |
|
{ |
|
TFGameRules()->AddTeamRespawnWaveTime( TF_TEAM_BLUE, inputdata.value.Float() ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::InputSetRedTeamGoalString( inputdata_t &inputdata ) |
|
{ |
|
TFGameRules()->SetTeamGoalString( TF_TEAM_RED, inputdata.value.String() ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::InputSetBlueTeamGoalString( inputdata_t &inputdata ) |
|
{ |
|
TFGameRules()->SetTeamGoalString( TF_TEAM_BLUE, inputdata.value.String() ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::InputSetRedTeamRole( inputdata_t &inputdata ) |
|
{ |
|
CTFTeam *pTeam = TFTeamMgr()->GetTeam( TF_TEAM_RED ); |
|
if ( pTeam ) |
|
{ |
|
pTeam->SetRole( inputdata.value.Int() ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::InputSetBlueTeamRole( inputdata_t &inputdata ) |
|
{ |
|
CTFTeam *pTeam = TFTeamMgr()->GetTeam( TF_TEAM_BLUE ); |
|
if ( pTeam ) |
|
{ |
|
pTeam->SetRole( inputdata.value.Int() ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Pass in a VO sound entry to play for RED |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::InputPlayVORed( inputdata_t &inputdata ) |
|
{ |
|
const char *szSoundName = inputdata.value.String(); |
|
if ( szSoundName ) |
|
{ |
|
TFGameRules()->BroadcastSound( TF_TEAM_RED, szSoundName ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Pass in a VO sound entry to play for BLUE |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::InputPlayVOBlue( inputdata_t &inputdata ) |
|
{ |
|
const char *szSoundName = inputdata.value.String(); |
|
if ( szSoundName ) |
|
{ |
|
TFGameRules()->BroadcastSound( TF_TEAM_BLUE, szSoundName ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Pass in a VO sound entry to play |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::InputPlayVO( inputdata_t &inputdata ) |
|
{ |
|
const char *szSoundName = inputdata.value.String(); |
|
if ( szSoundName ) |
|
{ |
|
TFGameRules()->BroadcastSound( 255, szSoundName ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::InputHandleMapEvent( inputdata_t &inputdata ) |
|
{ |
|
if ( TFGameRules() ) |
|
{ |
|
TFGameRules()->HandleMapEvent( inputdata ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::InputSetCustomUpgradesFile( inputdata_t &inputdata ) |
|
{ |
|
if ( TFGameRules() ) |
|
{ |
|
TFGameRules()->SetCustomUpgradesFile( inputdata ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::InputSetRoundRespawnFreezeEnabled( inputdata_t &inputdata ) |
|
{ |
|
tf_player_movement_restart_freeze.SetValue( inputdata.value.Bool() ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::InputSetMapForcedTruceDuringBossFight( inputdata_t &inputdata ) |
|
{ |
|
if ( TFGameRules() ) |
|
{ |
|
TFGameRules()->SetMapForcedTruceDuringBossFight( inputdata.value.Bool() ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::Activate() |
|
{ |
|
TFGameRules()->Activate(); |
|
|
|
//============================================================================= |
|
// HPE_BEGIN: |
|
// [msmith] We added a HUDTYPE so that the objective and the HUD are independent. |
|
// This lets us have a non training HUD on a training map. And a training |
|
// HUD on another type of map. |
|
//============================================================================= |
|
if ( m_nHudType != TF_HUDTYPE_UNDEFINED ) |
|
{ |
|
TFGameRules()->SetHUDType( m_nHudType ); |
|
} |
|
//============================================================================= |
|
// HPE_END |
|
//============================================================================= |
|
|
|
TFGameRules()->SetOvertimeAllowedForCTF( m_bOvertimeAllowedForCTF ); |
|
|
|
ListenForGameEvent( "teamplay_round_win" ); |
|
|
|
BaseClass::Activate(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::TeamPlayerCountChanged( CTFTeam *pTeam ) |
|
{ |
|
if ( pTeam == TFTeamMgr()->GetTeam( TF_TEAM_RED ) ) |
|
{ |
|
m_Team1PlayersChanged.Set( pTeam->GetNumPlayers(), this, this ); |
|
} |
|
else if ( pTeam == TFTeamMgr()->GetTeam( TF_TEAM_BLUE ) ) |
|
{ |
|
m_Team2PlayersChanged.Set( pTeam->GetNumPlayers(), this, this ); |
|
} |
|
|
|
// Tell the clients |
|
IGameEvent *event = gameeventmanager->CreateEvent( "teams_changed" ); |
|
if ( event ) |
|
{ |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::PowerupTeamImbalance( int nTeam ) |
|
{ |
|
switch ( nTeam ) |
|
{ |
|
case TF_TEAM_RED: |
|
m_OnPowerupImbalanceTeam1.FireOutput( this, this ); |
|
break; |
|
case TF_TEAM_BLUE: |
|
m_OnPowerupImbalanceTeam2.FireOutput( this, this ); |
|
break; |
|
default: |
|
m_OnPowerupImbalanceMeasuresOver.FireOutput( this, this ); |
|
break; |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::StateEnterRoundRunning( void ) |
|
{ |
|
m_OnStateEnterRoundRunning.FireOutput( this, this ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::StateEnterBetweenRounds( void ) |
|
{ |
|
m_OnStateEnterBetweenRounds.FireOutput( this, this ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::StateEnterPreRound( void ) |
|
{ |
|
m_OnStateEnterPreRound.FireOutput( this, this ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::StateExitPreRound( void ) |
|
{ |
|
m_OnStateExitPreRound.FireOutput( this, this ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::MatchSummaryStart( void ) |
|
{ |
|
m_OnMatchSummaryStart.FireOutput( this, this ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::TruceStart( void ) |
|
{ |
|
m_OnTruceStart.FireOutput( this, this ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::TruceEnd( void ) |
|
{ |
|
m_OnTruceEnd.FireOutput( this, this ); |
|
} |
|
#endif |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRulesProxy::FireGameEvent( IGameEvent *event ) |
|
{ |
|
#ifdef GAME_DLL |
|
const char *pszEventName = event->GetName(); |
|
|
|
if ( FStrEq( pszEventName, "teamplay_round_win" ) ) |
|
{ |
|
int iWinningTeam = event->GetInt( "team" ); |
|
|
|
switch( iWinningTeam ) |
|
{ |
|
case TF_TEAM_RED: |
|
m_OnWonByTeam1.FireOutput( this, this ); |
|
break; |
|
case TF_TEAM_BLUE: |
|
m_OnWonByTeam2.FireOutput( this, this ); |
|
break; |
|
default: |
|
break; |
|
} |
|
} |
|
#endif |
|
} |
|
|
|
// (We clamp ammo ourselves elsewhere). |
|
ConVar ammo_max( "ammo_max", "5000", FCVAR_REPLICATED ); |
|
|
|
#ifndef CLIENT_DLL |
|
ConVar sk_plr_dmg_grenade( "sk_plr_dmg_grenade","0"); // Very lame that the base code needs this defined |
|
#endif |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : iDmgType - |
|
// Output : Returns true on success, false on failure. |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::Damage_IsTimeBased( int iDmgType ) |
|
{ |
|
// Damage types that are time-based. |
|
return ( ( iDmgType & ( DMG_PARALYZE | DMG_NERVEGAS | DMG_DROWNRECOVER ) ) != 0 ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : iDmgType - |
|
// Output : Returns true on success, false on failure. |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::Damage_ShowOnHUD( int iDmgType ) |
|
{ |
|
// Damage types that have client HUD art. |
|
return ( ( iDmgType & ( DMG_DROWN | DMG_BURN | DMG_NERVEGAS | DMG_SHOCK ) ) != 0 ); |
|
} |
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : iDmgType - |
|
// Output : Returns true on success, false on failure. |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::Damage_ShouldNotBleed( int iDmgType ) |
|
{ |
|
// Should always bleed currently. |
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::Damage_GetTimeBased( void ) |
|
{ |
|
int iDamage = ( DMG_PARALYZE | DMG_NERVEGAS | DMG_DROWNRECOVER ); |
|
return iDamage; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::Damage_GetShowOnHud( void ) |
|
{ |
|
int iDamage = ( DMG_DROWN | DMG_BURN | DMG_NERVEGAS | DMG_SHOCK ); |
|
return iDamage; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::Damage_GetShouldNotBleed( void ) |
|
{ |
|
return 0; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Return true if we are playing a PvE mode |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::IsPVEModeActive( void ) const |
|
{ |
|
#ifdef TF_RAID_MODE |
|
if ( IsRaidMode() || IsBossBattleMode() ) |
|
return true; |
|
#endif |
|
|
|
if ( IsMannVsMachineMode() ) |
|
return true; |
|
|
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Return true for PvE opponents (ie: enemy bot team) |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::IsPVEModeControlled( CBaseEntity *who ) const |
|
{ |
|
if ( !who ) |
|
{ |
|
return false; |
|
} |
|
|
|
#ifdef GAME_DLL |
|
if ( IsMannVsMachineMode() ) |
|
{ |
|
return who->GetTeamNumber() == TF_TEAM_PVE_INVADERS ? true : false; |
|
} |
|
|
|
if ( IsPVEModeActive() ) |
|
{ |
|
return who->GetTeamNumber() == TF_TEAM_RED ? true : false; |
|
} |
|
#endif |
|
|
|
return false; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Return true if engineers can build quickly now |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::IsQuickBuildTime( void ) |
|
{ |
|
return IsMannVsMachineMode() && ( InSetup() || TFObjectiveResource()->GetMannVsMachineIsBetweenWaves() ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::GameModeUsesUpgrades( void ) |
|
{ |
|
if ( IsMannVsMachineMode() || IsBountyMode() ) |
|
return true; |
|
|
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::CanPlayerUseRespec( CTFPlayer *pTFPlayer ) |
|
{ |
|
if ( !pTFPlayer ) |
|
return false; |
|
|
|
bool bAllowed = IsMannVsMachineRespecEnabled() && State_Get() == GR_STATE_BETWEEN_RNDS; |
|
|
|
#ifdef GAME_DLL |
|
if ( !g_pPopulationManager ) |
|
return false; |
|
|
|
bAllowed &= ( g_pPopulationManager->GetNumRespecsAvailableForPlayer( pTFPlayer ) ) ? true : false; |
|
#else |
|
if ( !g_TF_PR ) |
|
return false; |
|
|
|
bAllowed &= ( g_TF_PR->GetNumRespecCredits( pTFPlayer->entindex() ) ) ? true : false; |
|
#endif |
|
|
|
return bAllowed; |
|
} |
|
|
|
bool CTFGameRules::IsCompetitiveMode( void ) const |
|
{ |
|
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() ); |
|
if ( pMatchDesc ) |
|
{ |
|
return pMatchDesc->m_params.m_eMatchType == MATCH_TYPE_COMPETITIVE |
|
|| pMatchDesc->m_params.m_eMatchType == MATCH_TYPE_CASUAL; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
bool CTFGameRules::IsMatchTypeCasual( void ) const |
|
{ |
|
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() ); |
|
if ( pMatchDesc ) |
|
{ |
|
return ( pMatchDesc->m_params.m_eMatchType == MATCH_TYPE_CASUAL ); |
|
} |
|
|
|
return false; |
|
} |
|
|
|
bool CTFGameRules::IsMatchTypeCompetitive( void ) const |
|
{ |
|
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() ); |
|
if ( pMatchDesc ) |
|
{ |
|
return ( pMatchDesc->m_params.m_eMatchType == MATCH_TYPE_COMPETITIVE ); |
|
} |
|
|
|
return false; |
|
} |
|
|
|
bool CTFGameRules::BInMatchStartCountdown() const |
|
{ |
|
if ( IsCompetitiveMode() ) |
|
{ |
|
float flTime = GetRoundRestartTime(); |
|
if ( ( flTime > 0.f ) && ( (int)( flTime - gpGlobals->curtime ) <= mp_tournament_readymode_countdown.GetInt() ) ) |
|
{ |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
EMatchGroup CTFGameRules::GetCurrentMatchGroup() const |
|
{ |
|
#if defined STAGING_ONLY && defined CLIENT_DLL |
|
if ( tf_fake_mm_group.GetInt() != -1 ) |
|
{ |
|
return (EMatchGroup)tf_fake_mm_group.GetInt(); |
|
} |
|
#endif |
|
|
|
#ifdef GAME_DLL |
|
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch(); |
|
return pMatch ? pMatch->m_eMatchGroup : k_nMatchGroup_Invalid; |
|
#else |
|
// Client |
|
// We only care about what the server says if we are in an MM match. We pass false |
|
// into BConnectedToMatch because we want the match group of the server EVEN IF |
|
// the match is over, but we're still connected. |
|
return GTFGCClientSystem()->BConnectedToMatchServer( false ) ? (EMatchGroup)m_nMatchGroupType.Get() : k_nMatchGroup_Invalid; |
|
#endif |
|
} |
|
|
|
bool CTFGameRules::IsManagedMatchEnded() const |
|
{ |
|
#ifdef GAME_DLL |
|
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch(); |
|
return !pMatch || pMatch->BMatchTerminated(); |
|
#else |
|
// Client |
|
// We only care about what the server says if we are in an MM match. (Note that the GC client system calls this to |
|
// determine if an MM server considers the match over, so beware circular logic) |
|
return !GTFGCClientSystem()->BConnectedToMatchServer( true ) || m_bMatchEnded; |
|
#endif |
|
} |
|
|
|
#ifdef GAME_DLL |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SyncMatchSettings() |
|
{ |
|
// These mirror the MatchInfo for the client's sake. |
|
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch(); |
|
|
|
m_nMatchGroupType.Set( pMatch ? pMatch->m_eMatchGroup : k_nMatchGroup_Invalid ); |
|
m_bMatchEnded.Set( IsManagedMatchEnded() ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::StartManagedMatch() |
|
{ |
|
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch(); |
|
if ( !pMatch ) |
|
{ |
|
Warning( "Starting a managed match with no match info\n" ); |
|
return false; |
|
} |
|
|
|
// Cleanup |
|
m_eRematchState = NEXT_MAP_VOTE_STATE_NONE; |
|
|
|
/// Sync these before level change, so there's no race condition where clients may connect during/before the |
|
/// changelevel and see that the match is ended or wrong. |
|
SyncMatchSettings(); |
|
|
|
// Change the the correct map from the match. If no match specified, perform a fresh load of the current map |
|
const char *pszMap = pMatch->GetMatchMap(); |
|
if ( !pszMap ) |
|
{ |
|
pszMap = STRING( gpGlobals->mapname ); |
|
Warning( "Managed match did not specify map, using current map (%s)\n", pszMap ); |
|
} |
|
|
|
engine->ServerCommand( CFmtStr( "changelevel %s\n", pszMap ) ); |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetCompetitiveMode( bool bValue ) |
|
{ |
|
m_bCompetitiveMode.Set( bValue ); |
|
//// Competitive mode is only supported on official servers. |
|
//// It requires matchmaking, and doesn't allow ad-hoc connections. |
|
//// If cheats are ever enabled, we force this mode off. |
|
|
|
//tf_mm_trusted.SetValue( bValue ); |
|
//mp_tournament.SetValue( bValue ); |
|
//mp_tournament_readymode.SetValue( bValue ); |
|
|
|
//// No ad-hoc connections |
|
//tf_mm_strict.SetValue( bValue ); |
|
|
|
//if ( bValue ) |
|
//{ |
|
// engine->ServerCommand( "exec server_ladder.cfg\n" ); |
|
|
|
// Assert( tf_mm_servermode.GetInt() == 1 ); |
|
//} |
|
|
|
//// Any state toggle is a reset (so don't spam this call) |
|
//State_Transition( GR_STATE_PREROUND ); |
|
//SetInWaitingForPlayers( bValue ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::StartCompetitiveMatch( void ) |
|
{ |
|
m_flSafeToLeaveTimer = -1.f; |
|
|
|
SetInWaitingForPlayers( false ); |
|
RoundRespawn(); |
|
State_Transition( GR_STATE_RESTART ); |
|
ResetPlayerAndTeamReadyState(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Stops a match for some specified reason |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::StopCompetitiveMatch( CMsgGC_Match_Result_Status nCode ) |
|
{ |
|
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch(); |
|
int nActiveMatchPlayers = pMatch->GetNumActiveMatchPlayers(); |
|
if ( BAttemptMapVoteRollingMatch() && |
|
nCode == CMsgGC_Match_Result_Status_MATCH_SUCCEEDED && |
|
nActiveMatchPlayers > 0 ) |
|
{ |
|
ChooseNextMapVoteOptions(); |
|
} |
|
else |
|
{ |
|
// If we're not attempting a rolling match, end it |
|
// TODO ROLLING MATCHES: If we bail between now and RequestNewMatchForLobby, we need to call this or we'll get stuck. |
|
if ( !IsManagedMatchEnded() ) |
|
{ |
|
GTFGCClientSystem()->EndManagedMatch( /* bKickPlayersToParties */ false ); |
|
Assert( IsManagedMatchEnded() ); |
|
m_bMatchEnded.Set( true ); |
|
} |
|
} |
|
|
|
if ( nCode == CMsgGC_Match_Result_Status_MATCH_SUCCEEDED ) |
|
{ |
|
IGameEvent *winEvent = gameeventmanager->CreateEvent( "competitive_victory" ); |
|
if ( winEvent ) |
|
{ |
|
gameeventmanager->FireEvent( winEvent ); |
|
} |
|
|
|
// |
|
// This determines new ratings and creates the GC messages |
|
// |
|
|
|
CMatchInfo *pInfo = GTFGCClientSystem()->GetMatch(); |
|
if ( pInfo ) |
|
{ |
|
pInfo->CalculateMatchSkillRatingAdjustments( m_iWinningTeam ); |
|
|
|
// Performance ranking with medals is currently server-side |
|
if ( pInfo->CalculatePlayerMatchRankData() ) |
|
{ |
|
// Send scoreboard event with final data |
|
int nPlayers = pInfo->GetNumTotalMatchPlayers(); |
|
for ( int idx = 0; idx < nPlayers; idx++ ) |
|
{ |
|
IGameEvent *pEvent = gameeventmanager->CreateEvent( "competitive_stats_update" ); |
|
if ( pEvent ) |
|
{ |
|
CMatchInfo::PlayerMatchData_t *pMatchRankData = pInfo->GetMatchDataForPlayer( idx ); |
|
|
|
CBasePlayer *pPlayer = UTIL_PlayerBySteamID( pMatchRankData->steamID ); |
|
if ( !pPlayer ) |
|
continue; |
|
|
|
pEvent->SetInt( "index", pPlayer->entindex() ); |
|
pEvent->SetInt( "score_rank", pMatchRankData ? pMatchRankData->nScoreMedal : 0 ); // medal won (if any) |
|
pEvent->SetInt( "kills_rank", pMatchRankData ? pMatchRankData->nKillsMedal : 0 ); // |
|
pEvent->SetInt( "damage_rank", pMatchRankData ? pMatchRankData->nDamageMedal : 0 ); // |
|
pEvent->SetInt( "healing_rank", pMatchRankData ? pMatchRankData->nHealingMedal : 0 ); // |
|
pEvent->SetInt( "support_rank", pMatchRankData ? pMatchRankData->nSupportMedal : 0 ); // |
|
gameeventmanager->FireEvent( pEvent ); |
|
} |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
Warning( "CalculatePlayerMatchRankData(): General failure (investigate).\n" ); |
|
} |
|
|
|
ReportMatchResultsToGC( nCode ); |
|
} |
|
else if ( nCode == CMsgGC_Match_Result_Status_MATCH_FAILED_ABANDON ) |
|
{ |
|
// This generates a "safe to leave" notification on clients |
|
IGameEvent *pEvent = gameeventmanager->CreateEvent( "player_abandoned_match" ); |
|
if ( pEvent ) |
|
{ |
|
pEvent->SetBool( "game_over", ( tf_competitive_abandon_method.GetBool() || State_Get() == GR_STATE_BETWEEN_RNDS ) ); |
|
gameeventmanager->FireEvent( pEvent ); |
|
} |
|
|
|
ReportMatchResultsToGC( nCode ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Fully completes the match |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::EndCompetitiveMatch( void ) |
|
{ |
|
MatchSummaryEnd(); |
|
|
|
Log( "Competitive match ended. Kicking all players.\n" ); |
|
engine->ServerCommand( "kickall #TF_Competitive_Disconnect\n" ); |
|
|
|
// Prepare for next match |
|
g_fGameOver = false; |
|
m_bAllowBetweenRounds = true; |
|
State_Transition( GR_STATE_RESTART ); |
|
SetInWaitingForPlayers( true ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Called during CTFGameRules::Think() |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::ManageCompetitiveMode( void ) |
|
{ |
|
if ( !IsCompetitiveMode() ) |
|
return; |
|
|
|
// Bring this back when we ship? |
|
// // Security check |
|
// if ( !tf_skillrating_debug.GetBool() ) |
|
// { |
|
// m_bCompetitiveMode &= tf_mm_trusted.GetBool() && |
|
// IsInTournamentMode() && |
|
// !HaveCheatsBeenEnabledDuringLevel(); |
|
// } |
|
|
|
// We lost trusted status |
|
if ( !tf_mm_trusted.GetBool() ) |
|
{ |
|
m_nMatchGroupType.Set( k_nMatchGroup_Invalid ); |
|
StopCompetitiveMatch( CMsgGC_Match_Result_Status_MATCH_FAILED_TRUSTED ); |
|
UTIL_ClientPrintAll( HUD_PRINTCENTER, "Exiting Competitive Mode!" ); |
|
Log( "Server lost trusted status. Exiting Competitive Mode!" ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::ReportMatchResultsToGC( CMsgGC_Match_Result_Status nCode ) |
|
{ |
|
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch(); |
|
if ( !pMatch ) |
|
return false; |
|
|
|
GCSDK::CProtoBufMsg< CMsgGC_Match_Result > *pMsg = new GCSDK::CProtoBufMsg< CMsgGC_Match_Result >( k_EMsgGC_Match_Result ); |
|
|
|
pMsg->Body().set_match_id( pMatch->m_nMatchID ); |
|
pMsg->Body().set_match_group( pMatch->m_eMatchGroup ); |
|
pMsg->Body().set_status( nCode ); |
|
pMsg->Body().set_duration( CTF_GameStats.m_currentMap.m_Header.m_iTotalTime + ( gpGlobals->curtime - m_flRoundStartTime ) ); |
|
|
|
CTeam *pTeam = GetGlobalTeam( TF_TEAM_RED ); |
|
pMsg->Body().set_red_score( pTeam ? pTeam->GetScore() : (uint32)-1 ); |
|
pTeam = GetGlobalTeam( TF_TEAM_BLUE ); |
|
pMsg->Body().set_blue_score( pTeam ? pTeam->GetScore() : (uint32)-1 ); |
|
Assert( m_iWinningTeam >= 0 ); |
|
pMsg->Body().set_winning_team( Max( 0, (int)m_iWinningTeam ) ); |
|
const MapDef_t *pMap = GetItemSchema()->GetMasterMapDefByName( STRING( gpGlobals->mapname ) ); |
|
pMsg->Body().set_map_index( ( pMap ) ? pMap->m_nDefIndex : 0 ); |
|
pMsg->Body().set_game_type( 1 ); // TODO: eMapGameType |
|
|
|
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( pMatch->m_eMatchGroup ); |
|
if( !pMatchDesc || !pMatchDesc->m_pProgressionDesc ) |
|
return false; |
|
|
|
int nTotalScore = 0; |
|
|
|
CTFPlayerResource *pTFResource = dynamic_cast< CTFPlayerResource* >( g_pPlayerResource ); |
|
if ( pTFResource ) |
|
{ |
|
pTFResource->UpdatePlayerData(); |
|
|
|
for ( int i=0; i < MAX_PLAYERS; ++i ) |
|
{ |
|
nTotalScore += pTFResource->GetTotalScore( i ); |
|
} |
|
} |
|
|
|
float flBlueScoreRatio = 0.5f; |
|
|
|
const CTFTeam* pTFTeamRed = GetGlobalTFTeam( TF_TEAM_RED ); |
|
const CTFTeam* pTFTeamBlue = GetGlobalTFTeam( TF_TEAM_BLUE ); |
|
|
|
// Figure out how much XP to give each team based on the game mode played |
|
if ( HasMultipleTrains() ) |
|
{ |
|
// In PLR we want to use the distance along the tracks each of the |
|
// trains were at the end of each round |
|
flBlueScoreRatio = RemapValClamped( pTFTeamBlue->GetTotalPLRTrackPercentTraveled(), 0.f, pTFTeamBlue->GetTotalPLRTrackPercentTraveled() + pTFTeamRed->GetTotalPLRTrackPercentTraveled(), 0.f, 1.f ); |
|
} |
|
else if ( !m_bPlayingKoth && !m_bPowerupMode && ( tf_gamemode_cp.GetInt() || tf_gamemode_sd.GetInt() || tf_gamemode_payload.GetInt() ) ) |
|
{ |
|
// Rounds Won |
|
// CP - Points can flow back and forever, so we can't count total caps. And the |
|
// state of the game is always the same at match end, so rounds won is our |
|
// only real metric. |
|
// SD - A flag cap is a round, so we could count caps or rounds here. Again, the |
|
// flag can go back and forth forever, but the match end state is always the same. |
|
// PL - Count the points captured by each team. We do this A/D style where each team has |
|
// a chance to score points. |
|
flBlueScoreRatio = RemapValClamped( pTFTeamBlue->GetScore(), 0.f, pTFTeamBlue->GetScore() + pTFTeamRed->GetScore() , 0.f, 1.f ); |
|
} |
|
else if ( tf_gamemode_ctf.GetInt() || m_bPowerupMode || tf_gamemode_passtime.GetInt() ) |
|
{ |
|
// Flag captures |
|
// Mannpower is a variant of CTF and Passtime effectively is CTF. In all of these modes |
|
// we don't use rounds so our best metric is individual flag captures. |
|
flBlueScoreRatio = RemapValClamped( pTFTeamBlue->GetTotalFlagCaptures(), 0.f, pTFTeamBlue->GetTotalFlagCaptures() + pTFTeamRed->GetTotalFlagCaptures(), 0.f, 1.f ); |
|
} |
|
else if ( m_bPlayingKoth ) |
|
{ |
|
// Time capped |
|
// Looking at the capped time for each team will let us give xp in a fair way. We can |
|
// actually get as close as 50/50 |
|
float flBlueTimeCapped = pTFTeamBlue->GetKOTHTime(); |
|
float flRedTiemCapped = pTFTeamRed->GetKOTHTime(); |
|
|
|
flBlueScoreRatio = RemapValClamped( flBlueTimeCapped, 0.f, flBlueTimeCapped + flRedTiemCapped, 0.f, 1.f ); |
|
} |
|
else if ( tf_gamemode_rd.GetInt() || tf_gamemode_pd.GetInt() ) |
|
{ |
|
CTFRobotDestructionLogic* pRDLogic = CTFRobotDestructionLogic::GetRobotDestructionLogic(); |
|
|
|
// Count bottles/cores scored by each team |
|
flBlueScoreRatio = RemapValClamped( pRDLogic->GetScore( TF_TEAM_BLUE ), 0.f, pRDLogic->GetScore( TF_TEAM_BLUE ) + pRDLogic->GetScore( TF_TEAM_RED ), 0.f, 1.f ); |
|
} |
|
else if ( tf_gamemode_tc.GetInt() ) |
|
{ |
|
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL; |
|
|
|
int nBlueMiniRounds = 0; |
|
int nRedMiniRounds = 0; |
|
|
|
// Use the number of mini-rounds won by each team |
|
for( int i=0; i < pMaster->GetNumRounds(); ++ i ) |
|
{ |
|
const CTeamControlPointRound* pRound = pMaster->GetRoundByIndex( i ); |
|
if ( pRound->RoundOwnedByTeam( TF_TEAM_RED ) ) |
|
{ |
|
++nRedMiniRounds; |
|
} |
|
else if ( pRound->RoundOwnedByTeam( TF_TEAM_BLUE ) ) |
|
{ |
|
++nBlueMiniRounds; |
|
} |
|
else |
|
{ |
|
Assert( false ); |
|
} |
|
} |
|
|
|
|
|
flBlueScoreRatio = RemapValClamped( nBlueMiniRounds, 0.f, nBlueMiniRounds + nRedMiniRounds, 0.f, 1.f ); |
|
} |
|
else |
|
{ |
|
Assert( !"Game mode not handled for team XP bonus!" ); |
|
} |
|
|
|
const float flRedScoreRatio = 1.f - flBlueScoreRatio; |
|
const int nBlueTeamObjectiveBonus = flBlueScoreRatio * nTotalScore; |
|
const int nRedTeamObjectiveBonus = flRedScoreRatio * nTotalScore; |
|
|
|
// Player info |
|
for ( int idxPlayer = 0; idxPlayer < pMatch->GetNumTotalMatchPlayers(); idxPlayer++ ) |
|
{ |
|
CMatchInfo::PlayerMatchData_t *pMatchPlayer = pMatch->GetMatchDataForPlayer( idxPlayer ); |
|
if ( !pMatchPlayer->steamID.BIndividualAccount() ) |
|
{ |
|
Assert( false ); |
|
continue; |
|
} |
|
|
|
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerBySteamID( pMatchPlayer->steamID ) ); |
|
PlayerStats_t *pStats = CTF_GameStats.FindPlayerStats( pTFPlayer ); |
|
|
|
CMsgGC_Match_Result_Player *pMsgPlayer = pMsg->Body().add_players(); |
|
int nTeam = GetGameTeamForGCTeam( pMatchPlayer->eGCTeam ); |
|
pMsgPlayer->set_steam_id( pMatchPlayer->steamID.ConvertToUint64() ); |
|
pMsgPlayer->set_team( nTeam ); |
|
if ( pTFResource && pTFPlayer ) |
|
{ |
|
pMsgPlayer->set_score( pTFResource->GetTotalScore( pTFPlayer->entindex() ) ); |
|
} |
|
else |
|
{ |
|
// They left |
|
} |
|
|
|
int nPing = 0; |
|
int nPacketLoss = 0; |
|
if ( pTFPlayer ) |
|
{ |
|
UTIL_GetPlayerConnectionInfo( pTFPlayer->entindex(), nPing, nPacketLoss ); |
|
} |
|
pMsgPlayer->set_ping( nPing ); |
|
uint32 unPlayerFlags = 0U; |
|
if ( pMatchPlayer->bDropped ) |
|
{ |
|
unPlayerFlags |= MATCH_FLAG_PLAYER_LEAVER; |
|
} |
|
if ( pMatchPlayer->bLateJoin ) |
|
{ |
|
unPlayerFlags |= MATCH_FLAG_PLAYER_LATEJOIN; |
|
} |
|
if ( pMatchPlayer->BDropWasAbandon() ) |
|
{ |
|
unPlayerFlags |= MATCH_FLAG_PLAYER_ABANDONER; |
|
} |
|
if ( pMatchPlayer->bPlayed ) |
|
{ |
|
unPlayerFlags |= MATCH_FLAG_PLAYER_PLAYED; |
|
} |
|
|
|
pMsgPlayer->set_flags( unPlayerFlags ); |
|
// server-side skill system |
|
FixmeMMRatingBackendSwapping(); // Assuming skill rating is drillo |
|
pMsgPlayer->set_classes_played( pMatchPlayer->unClassesPlayed ); |
|
pMsgPlayer->set_kills( pStats ? pStats->statsAccumulated.m_iStat[TFSTAT_KILLS] : 0 ); |
|
pMsgPlayer->set_damage( pStats ? pStats->statsAccumulated.m_iStat[TFSTAT_DAMAGE] : 0 ); |
|
pMsgPlayer->set_healing( pStats ? pStats->statsAccumulated.m_iStat[TFSTAT_HEALING] : 0 ); |
|
pMsgPlayer->set_support( pStats ? CalcPlayerSupportScore( &pStats->statsAccumulated, pTFPlayer->entindex() ) : 0 ); |
|
pMsgPlayer->set_score_medal( pMatchPlayer->nScoreMedal ); |
|
pMsgPlayer->set_kills_medal( pMatchPlayer->nKillsMedal ); |
|
pMsgPlayer->set_damage_medal( pMatchPlayer->nDamageMedal ); |
|
pMsgPlayer->set_healing_medal( pMatchPlayer->nHealingMedal ); |
|
pMsgPlayer->set_support_medal( pMatchPlayer->nSupportMedal ); |
|
FixmeMMRatingBackendSwapping(); // Assuming we're using skill rating for rank? Why even include this? |
|
pMsgPlayer->set_rank( pMatchDesc->m_pProgressionDesc->GetLevelForExperience( pMatchPlayer->unMMSkillRating ).m_nLevelNum ); |
|
pMsgPlayer->set_deaths( pStats ? pStats->statsAccumulated.m_iStat[TFSTAT_DEATHS] : 0 ); |
|
pMsgPlayer->set_party_id( pMatchPlayer->uPartyID ); |
|
uint32 unLeaveTime = ( pMatchPlayer && ( pMatchPlayer->bDropped || pMatchPlayer->BDropWasAbandon() ) ) ? |
|
pMatchPlayer->GetLastActiveEventTime() : 0u; |
|
pMsgPlayer->set_leave_time( unLeaveTime ); |
|
pMsgPlayer->set_leave_reason( pMatchPlayer->GetDropReason() ); |
|
pMsgPlayer->set_connect_time( pMatchPlayer->rtJoinedMatch ); |
|
|
|
// Somebody won! Match finish bonus |
|
if ( nCode == CMsgGC_Match_Result_Status_MATCH_SUCCEEDED ) |
|
{ |
|
// Give points based on team performance |
|
int nPerformanceScore = RemapValClamped( pMsgPlayer->score(), 0, nTotalScore / 24, 0, nTeam == TF_TEAM_RED ? nRedTeamObjectiveBonus : nBlueTeamObjectiveBonus ); |
|
pMatch->GiveXPRewardToPlayerForAction( pMatchPlayer->steamID, CMsgTFXPSource::SOURCE_OBJECTIVE_BONUS, nPerformanceScore ); |
|
|
|
// Everyone gets base completion points |
|
int nCompletionScore = RemapValClamped( pMsgPlayer->score(), 0, nTotalScore / 24, 0, nTotalScore ); |
|
pMatch->GiveXPRewardToPlayerForAction( pMatchPlayer->steamID, CMsgTFXPSource::SOURCE_COMPLETED_MATCH, nCompletionScore ); |
|
} |
|
|
|
// Copy any pending XP sources they had ready to send up |
|
for( int i=0; i < pMatchPlayer->GetXPSources().sources_size(); ++i ) |
|
{ |
|
CMsgTFXPSource* pXPSource = pMsgPlayer->add_xp_breakdown(); |
|
pXPSource->CopyFrom( pMatchPlayer->GetXPSources().sources( i ) ); |
|
} |
|
} |
|
|
|
pMsg->Body().set_win_reason( GetWinReason() ); |
|
uint32 unMatchFlags = 0u; |
|
|
|
if ( pMatch->m_uLobbyFlags & LOBBY_FLAG_LOWPRIORITY ) |
|
{ |
|
unMatchFlags |= MATCH_FLAG_LOWPRIORITY; |
|
} |
|
|
|
if ( pMatch->m_uLobbyFlags & LOBBY_FLAG_REMATCH ) |
|
{ |
|
unMatchFlags |= MATCH_FLAG_REMATCH; |
|
} |
|
|
|
pMsg->Body().set_flags( unMatchFlags ); |
|
pMsg->Body().set_bots( pMatch->m_nBotsAdded ); |
|
|
|
GTFGCClientSystem()->SendCompetitiveMatchResult( pMsg ); |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::MatchmakingShouldUseStopwatchMode() |
|
{ |
|
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL; |
|
bool bRetVal = !HasMultipleTrains() && ( tf_gamemode_payload.GetBool() || ( pMaster && ( pMaster->PlayingMiniRounds() || pMaster->ShouldSwitchTeamsOnRoundWin() ) ) ); |
|
|
|
tf_attack_defend_map.SetValue( bRetVal ); |
|
return bRetVal; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetPowerupMode( bool bValue ) |
|
{ |
|
// Powerup mode uses grapple and changes some gamerule variables. |
|
|
|
if ( bValue ) |
|
{ |
|
tf_grapplinghook_enable.SetValue( 1 ); |
|
tf_flag_return_time_credit_factor.SetValue( 0 ); |
|
} |
|
else |
|
{ |
|
tf_grapplinghook_enable.SetValue( 0 ); |
|
tf_flag_return_time_credit_factor.SetValue( 1 ); |
|
} |
|
|
|
m_bPowerupMode = bValue; |
|
} |
|
|
|
#ifdef GAME_DLL |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::EndManagedMvMMatch( bool bKickPlayersToParties ) |
|
{ |
|
// Primarily a pass through so we can ensure our match end state is sync'd -- CPopulationManager manages most of the |
|
// MvM meta round state |
|
if ( !IsManagedMatchEnded() ) |
|
{ |
|
GTFGCClientSystem()->EndManagedMatch( bKickPlayersToParties ); |
|
Assert( IsManagedMatchEnded() ); |
|
m_bMatchEnded.Set( true ); |
|
} |
|
} |
|
#endif // GAME_DLL |
|
|
|
|
|
#ifdef STAGING_ONLY |
|
//----------------------------------------------------------------------------- |
|
// Purpose: Enable/Disable Bounty Mode |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetBountyMode( bool bValue ) |
|
{ |
|
if ( m_bBountyModeEnabled.Get() != bValue ) |
|
{ |
|
m_bBountyModeEnabled.Set( bValue ); |
|
} |
|
|
|
// If enabling, dynamically create an upgrade entity |
|
if ( bValue ) |
|
{ |
|
if ( !g_hUpgradeEntity && !m_pUpgrades ) |
|
{ |
|
m_pUpgrades = CBaseEntity::Create( "func_upgradestation", vec3_origin, vec3_angle ); |
|
} |
|
} |
|
|
|
// If disabling, remove upgrade entity |
|
if ( !bValue && m_pUpgrades ) |
|
{ |
|
UTIL_Remove( m_pUpgrades ); |
|
m_pUpgrades = NULL; |
|
} |
|
|
|
IGameEvent *event = gameeventmanager->CreateEvent( "bountymode_toggled" ); |
|
if ( event ) |
|
{ |
|
event->SetBool( "active", bValue ); |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
} |
|
|
|
#endif // GAME_DLL |
|
#endif // STAGING_ONLY |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::UsePlayerReadyStatusMode( void ) |
|
{ |
|
if ( IsMannVsMachineMode() ) |
|
return true; |
|
|
|
if ( IsCompetitiveMode() ) |
|
return true; |
|
|
|
if ( mp_tournament.GetBool() && mp_tournament_readymode.GetBool() ) |
|
return true; |
|
|
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::PlayerReadyStatus_HaveMinPlayersToEnable( void ) |
|
{ |
|
// we always have enough players if the match wants players to autoready |
|
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() ); |
|
if ( pMatchDesc && pMatchDesc->m_params.m_bAutoReady ) |
|
return true; |
|
|
|
#ifdef GAME_DLL |
|
// Count connected players |
|
int nNumPlayers = 0; |
|
CUtlVector< CTFPlayer* > playerVector; |
|
CollectPlayers( &playerVector ); |
|
FOR_EACH_VEC( playerVector, i ) |
|
{ |
|
if ( !playerVector[i] ) |
|
continue; |
|
|
|
if ( playerVector[i]->IsFakeClient() ) |
|
continue; |
|
|
|
#ifdef STAGING_ONLY |
|
if ( !mp_tournament_readymode_bots_allowed.GetBool() && playerVector[i]->IsBot() ) |
|
continue; |
|
#else |
|
if ( playerVector[i]->IsBot() ) |
|
continue; |
|
#endif |
|
|
|
if ( playerVector[i]->IsHLTV() ) |
|
continue; |
|
|
|
if ( playerVector[i]->IsReplay() ) |
|
continue; |
|
|
|
nNumPlayers++; |
|
} |
|
|
|
// Default |
|
int nMinPlayers = 1; |
|
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch(); |
|
|
|
if ( pMatch && !pMatch->BMatchTerminated() && pMatchDesc->m_params.m_bRequireCompleteMatch ) |
|
{ |
|
nMinPlayers = pMatch->GetCanonicalMatchSize(); |
|
} |
|
else if ( IsMannVsMachineMode() && |
|
( engine->IsDedicatedServer() || ( !engine->IsDedicatedServer() && nNumPlayers > 1 ) ) ) |
|
{ |
|
nMinPlayers = tf_mvm_min_players_to_start.GetInt(); |
|
} |
|
else if ( UsePlayerReadyStatusMode() && engine->IsDedicatedServer() ) |
|
{ |
|
nMinPlayers = mp_tournament_readymode_min.GetInt(); |
|
} |
|
|
|
// Should be renamed to m_bEnableReady, not sure why we encoded our criteria in the names of all associated functions and variables... |
|
m_bHaveMinPlayersToEnableReady.Set( nNumPlayers >= nMinPlayers ); |
|
|
|
#endif |
|
|
|
return m_bHaveMinPlayersToEnableReady; |
|
} |
|
|
|
#ifdef GAME_DLL |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::PlayerReadyStatus_ArePlayersOnTeamReady( int iTeam ) |
|
{ |
|
if ( IsMannVsMachineMode() && iTeam == TF_TEAM_PVE_INVADERS ) |
|
return true; |
|
|
|
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch(); |
|
if ( pMatch ) |
|
{ |
|
int nMatchPlayers = pMatch->GetNumTotalMatchPlayers(); |
|
if ( nMatchPlayers <= 0 ) |
|
return false; |
|
|
|
int iPlayerReadyCount = 0; |
|
for ( int i = 0; i < nMatchPlayers; i++ ) |
|
{ |
|
CMatchInfo::PlayerMatchData_t *pPlayerData = pMatch->GetMatchDataForPlayer( i ); |
|
if ( !pPlayerData->bDropped && GetGameTeamForGCTeam( pPlayerData->eGCTeam ) == iTeam ) |
|
{ |
|
CBasePlayer *pPlayer = UTIL_PlayerBySteamID( pPlayerData->steamID ); |
|
// XXX(JohnS): Not quite valid yet, We let them join first onto spectate, which is probably a bit |
|
// confusing |
|
// |
|
// AssertMsg( !pPlayer || ToTFPlayer( pPlayer )->GetTeamNumber() == GetGameTeamForGCTeam( pPlayerData->eGCTeam ), |
|
// "Player's GC assigned team does not match their current team" ); |
|
if ( !pPlayer || !m_bPlayerReady[ pPlayer->entindex() ] ) |
|
return false; |
|
|
|
iPlayerReadyCount++; |
|
} |
|
} |
|
|
|
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() ); |
|
if ( pMatchDesc && pMatchDesc->m_params.m_bAutoReady ) |
|
{ |
|
return iPlayerReadyCount > 0 || pMatch->GetNumTotalMatchPlayers() == 1 ; |
|
} |
|
else |
|
{ |
|
int iTeamSize = IsMannVsMachineMode() ? pMatch->GetCanonicalMatchSize() : pMatch->GetCanonicalMatchSize() / 2; |
|
return iPlayerReadyCount >= iTeamSize; |
|
} |
|
} |
|
|
|
// Non-match |
|
bool bAtLeastOneReady = false; |
|
for ( int i = 1; i <= MAX_PLAYERS; ++i ) |
|
{ |
|
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i ); |
|
if ( !pPlayer || ToTFPlayer( pPlayer )->GetTeamNumber() != iTeam ) |
|
continue; |
|
|
|
if ( !m_bPlayerReady[i] ) |
|
{ |
|
return false; |
|
} |
|
else |
|
{ |
|
bAtLeastOneReady = true; |
|
} |
|
} |
|
|
|
// Team isn't ready if there was nobody on it. |
|
return bAtLeastOneReady; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::PlayerReadyStatus_ShouldStartCountdown( void ) |
|
{ |
|
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch(); |
|
|
|
#if defined( STAGING_ONLY ) |
|
// Local testing hack - allow match size of one where just that player is ready |
|
if ( !IsMannVsMachineMode() && !pMatch && BHavePlayers() && ( IsTeamReady( TF_TEAM_RED ) || IsTeamReady( TF_TEAM_BLUE ) ) ) |
|
return true; |
|
#endif // STAGING_ONLY |
|
|
|
if ( IsMannVsMachineMode() ) |
|
{ |
|
if ( !IsTeamReady( TF_TEAM_PVE_DEFENDERS ) && m_flRestartRoundTime >= gpGlobals->curtime + mp_tournament_readymode_countdown.GetInt() ) |
|
{ |
|
bool bIsTeamReady = PlayerReadyStatus_ArePlayersOnTeamReady( TF_TEAM_PVE_DEFENDERS ); |
|
if ( bIsTeamReady ) |
|
{ |
|
SetTeamReadyState( true, TF_TEAM_PVE_DEFENDERS ); |
|
return true; |
|
} |
|
} |
|
} |
|
else if ( pMatch && |
|
PlayerReadyStatus_ArePlayersOnTeamReady( TF_TEAM_RED ) && |
|
PlayerReadyStatus_ArePlayersOnTeamReady( TF_TEAM_BLUE ) ) |
|
{ |
|
return true; |
|
} |
|
else if ( IsTeamReady( TF_TEAM_RED ) && IsTeamReady( TF_TEAM_BLUE ) ) |
|
{ |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::PlayerReadyStatus_ResetState( void ) |
|
{ |
|
// Reset the players |
|
ResetPlayerAndTeamReadyState(); |
|
|
|
// Reset the team |
|
SetTeamReadyState( false, TF_TEAM_RED ); |
|
SetTeamReadyState( false, TF_TEAM_BLUE ); |
|
|
|
m_flRestartRoundTime.Set( -1.f ); |
|
mp_restartgame.SetValue( 0 ); |
|
m_bAwaitingReadyRestart = true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::PlayerReadyStatus_UpdatePlayerState( CTFPlayer *pTFPlayer, bool bState ) |
|
{ |
|
if ( !UsePlayerReadyStatusMode() ) |
|
return; |
|
|
|
if ( !pTFPlayer ) |
|
return; |
|
|
|
if ( pTFPlayer->GetTeamNumber() < FIRST_GAME_TEAM ) |
|
return; |
|
|
|
if ( State_Get() != GR_STATE_BETWEEN_RNDS ) |
|
return; |
|
|
|
// Don't allow toggling state in the final countdown |
|
if ( GetRoundRestartTime() > 0.f && GetRoundRestartTime() <= gpGlobals->curtime + TOURNAMENT_NOCANCEL_TIME ) |
|
return; |
|
|
|
// Make sure we have enough to allow ready mode commands |
|
if ( !PlayerReadyStatus_HaveMinPlayersToEnable() ) |
|
return; |
|
|
|
int nEntIndex = pTFPlayer->entindex(); |
|
|
|
// Already this state |
|
if ( bState == IsPlayerReady( nEntIndex ) ) |
|
return; |
|
|
|
SetPlayerReadyState( nEntIndex, bState ); |
|
|
|
if ( !bState ) |
|
{ |
|
// Slam team status to Not Ready for any player that sets Not Ready |
|
m_bTeamReady.Set( pTFPlayer->GetTeamNumber(), false ); |
|
|
|
// If everyone cancels ready state, stop the clock |
|
bool bAnyoneReady = false; |
|
for ( int i = 1; i <= MAX_PLAYERS; ++i ) |
|
{ |
|
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i ); |
|
if ( !pPlayer ) |
|
continue; |
|
|
|
if ( m_bPlayerReady[i] ) |
|
{ |
|
bAnyoneReady = true; |
|
break; |
|
} |
|
} |
|
|
|
if ( !bAnyoneReady ) |
|
{ |
|
m_flRestartRoundTime.Set( -1.f ); |
|
mp_restartgame.SetValue( 0 ); |
|
ResetPlayerAndTeamReadyState(); |
|
} |
|
} |
|
else |
|
{ |
|
if ( IsMannVsMachineMode() || IsCompetitiveMode() ) |
|
{ |
|
// Reduce timer as each player hits Ready, but only once per-player |
|
if ( !m_bPlayerReadyBefore[nEntIndex] && m_flRestartRoundTime > gpGlobals->curtime + 60.f ) |
|
{ |
|
float flReduceBy = 30.f; |
|
if ( m_flRestartRoundTime < gpGlobals->curtime + 90.f ) |
|
{ |
|
// Never reduce below 60 seconds remaining |
|
flReduceBy = m_flRestartRoundTime - gpGlobals->curtime - 60.f; |
|
} |
|
|
|
m_flRestartRoundTime -= flReduceBy; |
|
} |
|
else if ( m_flRestartRoundTime < 0 && !PlayerReadyStatus_ShouldStartCountdown() ) |
|
{ |
|
m_flRestartRoundTime.Set( gpGlobals->curtime + 150.f ); |
|
m_bAwaitingReadyRestart = false; |
|
|
|
IGameEvent* pEvent = gameeventmanager->CreateEvent( "teamplay_round_restart_seconds" ); |
|
if ( pEvent ) |
|
{ |
|
pEvent->SetInt( "seconds", 150 ); |
|
gameeventmanager->FireEvent( pEvent ); |
|
} |
|
} |
|
} |
|
|
|
// Unofficial modes set team ready state here |
|
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch(); |
|
if ( !pMatch && !IsMannVsMachineMode() ) |
|
{ |
|
int nRed = 0; |
|
int nRedCount = 0; |
|
int nBlue = 0; |
|
int nBlueCount = 0; |
|
|
|
for ( int iTeam = FIRST_GAME_TEAM; iTeam < TFTeamMgr()->GetTeamCount(); iTeam++ ) |
|
{ |
|
CTFTeam *pTeam = GetGlobalTFTeam( iTeam ); |
|
if ( pTeam ) |
|
{ |
|
Assert( pTeam->GetTeamNumber() == TF_TEAM_RED || pTeam->GetTeamNumber() == TF_TEAM_BLUE ); |
|
|
|
for ( int i = 0; i < pTeam->GetNumPlayers(); ++i ) |
|
{ |
|
if ( !pTeam->GetPlayer(i) ) |
|
continue; |
|
|
|
if ( pTeam->GetTeamNumber() == TF_TEAM_RED && IsPlayerReady( pTeam->GetPlayer(i)->entindex() ) ) |
|
{ |
|
if ( !nRedCount ) |
|
{ |
|
nRedCount = pTeam->GetNumPlayers(); |
|
} |
|
|
|
nRed++; |
|
} |
|
else if ( pTeam->GetTeamNumber() == TF_TEAM_BLUE && IsPlayerReady( pTeam->GetPlayer(i)->entindex() ) ) |
|
{ |
|
if ( !nBlueCount ) |
|
{ |
|
nBlueCount = pTeam->GetNumPlayers(); |
|
} |
|
|
|
nBlue++; |
|
} |
|
} |
|
} |
|
} |
|
|
|
// Check for the convar that requires min team size, or just go with whatever each team has |
|
int nRedMin = ( mp_tournament_readymode_team_size.GetInt() > 0 ) ? mp_tournament_readymode_team_size.GetInt() : Max( nRedCount, 1 ); |
|
int nBlueMin = ( mp_tournament_readymode_team_size.GetInt() > 0 ) ? mp_tournament_readymode_team_size.GetInt() : Max( nBlueCount, 1 ); |
|
|
|
SetTeamReadyState( ( nRed == nRedMin ), TF_TEAM_RED ); |
|
SetTeamReadyState( ( nBlue == nBlueMin ), TF_TEAM_BLUE ); |
|
} |
|
|
|
m_bPlayerReadyBefore[nEntIndex] = true; |
|
} |
|
} |
|
#endif // GAME_DLL |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::IsDefaultGameMode( void ) |
|
{ |
|
if ( IsMannVsMachineMode() ) |
|
return false; |
|
|
|
if ( IsInArenaMode() ) |
|
return false; |
|
|
|
if ( IsInMedievalMode() ) |
|
return false; |
|
|
|
if ( IsCompetitiveMode() ) |
|
return false; |
|
|
|
if ( IsInTournamentMode() ) |
|
return false; |
|
|
|
if ( IsInTraining() ) |
|
return false; |
|
|
|
if ( IsInItemTestingMode() ) |
|
return false; |
|
|
|
#ifdef STAGING_ONLY |
|
if ( IsPVEModeActive() ) |
|
return false; |
|
#endif // STAGING_ONLY |
|
|
|
#ifdef TF_RAID_MODE |
|
if ( IsRaidMode() ) |
|
return false; |
|
|
|
if ( IsBossBattleMode() ) |
|
return false; |
|
#endif // TF_RAID_MODE |
|
|
|
#ifdef TF_CREEP_MODE |
|
if ( IsCreepWaveMode() ) |
|
return false; |
|
#endif // TF_CREEP_MODE |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Allows us to give situational discounts, such as secondary weapons |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::GetCostForUpgrade( CMannVsMachineUpgrades *pUpgrade, int iItemSlot, int nClass, CTFPlayer *pPurchaser /*= NULL*/ ) |
|
{ |
|
Assert( pUpgrade ); |
|
|
|
if ( !pUpgrade ) |
|
return 0; |
|
|
|
int iCost = pUpgrade->nCost; |
|
|
|
CEconItemSchema *pSchema = ItemSystem()->GetItemSchema(); |
|
if ( pSchema ) |
|
{ |
|
const CEconItemAttributeDefinition *pAttr = pSchema->GetAttributeDefinitionByName( pUpgrade->szAttrib ); |
|
if ( pAttr ) |
|
{ |
|
if ( ( iItemSlot == LOADOUT_POSITION_PRIMARY && nClass == TF_CLASS_ENGINEER ) || |
|
( iItemSlot == LOADOUT_POSITION_SECONDARY && nClass != TF_CLASS_DEMOMAN ) || |
|
( iItemSlot == LOADOUT_POSITION_MELEE && nClass != TF_CLASS_SPY && nClass != TF_CLASS_ENGINEER ) ) |
|
{ |
|
switch ( pAttr->GetDefinitionIndex() ) |
|
{ |
|
case 4: // clip size bonus |
|
case 6: // fire rate bonus |
|
case 78: // maxammo secondary increased |
|
case 180: // heal on kill |
|
case 266: // projectile penetration |
|
case 335: // clip size bonus upgrade |
|
case 397: // projectile penetration heavy |
|
iCost *= 0.5f; |
|
break; |
|
default: |
|
break; |
|
} |
|
} |
|
else if ( iItemSlot == LOADOUT_POSITION_ACTION ) |
|
{ |
|
if ( pPurchaser ) |
|
{ |
|
int iCanteenSpec = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pPurchaser, iCanteenSpec, canteen_specialist ); |
|
if ( iCanteenSpec ) |
|
{ |
|
|
|
// iCost *= ( 1.f - ( iCanteenSpec * 0.1f ) ); |
|
// iCost = Max( 1, ( iCost - ( iCost % 5 ) ) ); |
|
|
|
iCost -= ( 10 * iCanteenSpec ); |
|
iCost = Max( 5, iCost ); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
return iCost; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
CTFGameRules::CTFGameRules() |
|
#ifdef GAME_DLL |
|
: m_mapCoachToStudentMap( DefLessFunc(uint32) ) |
|
, m_flNextStrangeEventProcessTime( g_flStrangeEventBatchProcessInterval ) |
|
, m_mapTeleportLocations( DefLessFunc(string_t) ) |
|
, m_bMapCycleNeedsUpdate( false ) |
|
, m_flSafeToLeaveTimer( -1.f ) |
|
, m_flCompModeRespawnPlayersAtMatchStart( -1.f ) |
|
, m_bMapForcedTruceDuringBossFight( false ) |
|
, m_flNextHalloweenGiftUpdateTime( -1 ) |
|
#else |
|
: m_bRecievedBaseline( false ) |
|
#endif |
|
{ |
|
#ifdef GAME_DLL |
|
// Create teams. |
|
TFTeamMgr()->Init(); |
|
|
|
ResetMapTime(); |
|
|
|
// Create the team managers |
|
// for ( int i = 0; i < ARRAYSIZE( teamnames ); i++ ) |
|
// { |
|
// CTeam *pTeam = static_cast<CTeam*>(CreateEntityByName( "tf_team" )); |
|
// pTeam->Init( sTeamNames[i], i ); |
|
// |
|
// g_Teams.AddToTail( pTeam ); |
|
// } |
|
|
|
m_flIntermissionEndTime = 0.0f; |
|
m_flNextPeriodicThink = 0.0f; |
|
|
|
ListenForGameEvent( "teamplay_point_captured" ); |
|
ListenForGameEvent( "teamplay_capture_blocked" ); |
|
ListenForGameEvent( "teamplay_round_win" ); |
|
ListenForGameEvent( "teamplay_flag_event" ); |
|
ListenForGameEvent( "teamplay_round_start" ); |
|
ListenForGameEvent( "player_escort_score" ); |
|
ListenForGameEvent( "player_disconnect" ); |
|
ListenForGameEvent( "teamplay_setup_finished" ); |
|
ListenForGameEvent( "recalculate_truce" ); |
|
|
|
Q_memset( m_vecPlayerPositions,0, sizeof(m_vecPlayerPositions) ); |
|
|
|
m_iPrevRoundState = -1; |
|
m_iCurrentRoundState = -1; |
|
m_iCurrentMiniRoundMask = 0; |
|
|
|
m_iPreviousTeamSize = 0; |
|
|
|
// Lets execute a map specific cfg file |
|
// ** execute this after server.cfg! |
|
char szCommand[MAX_PATH] = { 0 }; |
|
// Map names cannot contain quotes or control characters so this is safe but silly that we have to do it. |
|
Q_snprintf( szCommand, sizeof( szCommand ), "exec \"%s.cfg\"\n", STRING( gpGlobals->mapname ) ); |
|
engine->ServerCommand( szCommand ); |
|
|
|
m_flSendNotificationTime = 0.0f; |
|
|
|
m_bOvertimeAllowedForCTF = true; |
|
|
|
m_redPayloadToPush = NULL; |
|
m_bluePayloadToPush = NULL; |
|
m_redPayloadToBlock = NULL; |
|
m_bluePayloadToBlock = NULL; |
|
|
|
SetCTFCaptureBonusTime( -1 ); |
|
|
|
m_hasSpawnedToy = false; |
|
|
|
m_flCapInProgressBuffer = 0.f; |
|
|
|
m_bMannVsMachineAlarmStatus = false; |
|
m_flNextFlagAlarm = 0.0f; |
|
m_flNextFlagAlert = 0.0f; |
|
|
|
m_doomsdaySetupTimer.Invalidate(); |
|
StopDoomsdayTicketsTimer(); |
|
|
|
m_nPowerupKillsRedTeam = 0; |
|
m_nPowerupKillsBlueTeam = 0; |
|
m_flTimeToRunImbalanceMeasures = 120.f; |
|
m_flTimeToStopImbalanceMeasures = 0.f; |
|
m_bPowerupImbalanceMeasuresRunning = false; |
|
|
|
m_hRequiredObserverTarget = NULL; |
|
m_bStopWatchWinner.Set( false ); |
|
|
|
#else // GAME_DLL |
|
|
|
// Vision Filter Translations for swapping out particle effects and models |
|
SetUpVisionFilterKeyValues(); |
|
|
|
m_bSillyGibs = CommandLine()->FindParm( "-sillygibs" ) ? true : false; |
|
if ( m_bSillyGibs ) |
|
{ |
|
cl_burninggibs.SetValue( 0 ); |
|
} |
|
// @todo Tom Bui: game_newmap doesn't seem to be used... |
|
ListenForGameEvent( "game_newmap" ); |
|
ListenForGameEvent( "overtime_nag" ); |
|
ListenForGameEvent( "recalculate_holidays" ); |
|
|
|
#endif |
|
|
|
ClearHalloweenEffectStatus(); |
|
|
|
// Initialize the game type |
|
m_nGameType.Set( TF_GAMETYPE_UNDEFINED ); |
|
|
|
m_bPlayingMannVsMachine.Set( false ); |
|
m_bMannVsMachineAlarmStatus.Set( false ); |
|
m_bBountyModeEnabled.Set( false ); |
|
|
|
m_bPlayingKoth.Set( false ); |
|
m_bPlayingMedieval.Set( false ); |
|
m_bPlayingHybrid_CTF_CP.Set( false ); |
|
m_bPlayingSpecialDeliveryMode.Set( false ); |
|
m_bPlayingRobotDestructionMode.Set( false ); |
|
m_bPowerupMode.Set( false ); |
|
|
|
m_bHelltowerPlayersInHell.Set( false ); |
|
m_bIsUsingSpells.Set( false ); |
|
m_bTruceActive.Set( false ); |
|
m_bTeamsSwitched.Set( false ); |
|
|
|
m_halloweenScenario.Set( HALLOWEEN_SCENARIO_NONE ); |
|
m_iGlobalAttributeCacheVersion = 0; |
|
|
|
//============================================================================= |
|
// HPE_BEGIN |
|
// [msmith] HUD type |
|
//============================================================================= |
|
m_nHudType.Set( TF_HUDTYPE_UNDEFINED ); |
|
m_bIsInTraining.Set( false ); |
|
m_bAllowTrainingAchievements.Set( false ); |
|
m_bIsWaitingForTrainingContinue.Set( false ); |
|
//============================================================================= |
|
// HPE_END |
|
//============================================================================= |
|
m_bIsTrainingHUDVisible.Set( false ); |
|
|
|
m_bIsInItemTestingMode.Set( false ); |
|
|
|
// Set turbo physics on. Do it here for now. |
|
sv_turbophysics.SetValue( 1 ); |
|
|
|
// Initialize the team manager here, etc... |
|
|
|
// If you hit these asserts its because you added or removed a weapon type |
|
// and didn't also add or remove the weapon name or damage type from the |
|
// arrays defined in tf_shareddefs.cpp |
|
COMPILE_TIME_ASSERT( TF_WEAPON_COUNT == ARRAYSIZE( g_aWeaponDamageTypes ) ); |
|
COMPILE_TIME_ASSERT( TF_WEAPON_COUNT == ARRAYSIZE( g_aWeaponNames ) ); |
|
|
|
m_iPreviousRoundWinners = TEAM_UNASSIGNED; |
|
|
|
m_pszTeamGoalStringRed.GetForModify()[0] = '\0'; |
|
m_pszTeamGoalStringBlue.GetForModify()[0] = '\0'; |
|
|
|
m_nStopWatchState.Set( STOPWATCH_CAPTURE_TIME_NOT_SET ); |
|
|
|
mp_tournament_redteamname.Revert(); |
|
mp_tournament_blueteamname.Revert(); |
|
|
|
m_flCapturePointEnableTime = 0.0f; |
|
|
|
m_itHandle = 0; |
|
|
|
m_hBirthdayPlayer = NULL; |
|
|
|
m_nBossHealth = 0; |
|
m_nMaxBossHealth = 0; |
|
m_fBossNormalizedTravelDistance = 0.0f; |
|
|
|
m_areHealthAndAmmoVectorsReady = false; |
|
|
|
m_flGravityMultiplier.Set( 1.0 ); |
|
|
|
m_pszCustomUpgradesFile.GetForModify()[0] = '\0'; |
|
|
|
m_bShowMatchSummary.Set( false ); |
|
m_bMapHasMatchSummaryStage.Set( false ); |
|
m_bPlayersAreOnMatchSummaryStage.Set( false ); |
|
|
|
m_bUseMatchHUD = false; |
|
m_bUsePreRoundDoors = false; |
|
|
|
m_nMatchGroupType.Set( k_nMatchGroup_Invalid ); |
|
m_bMatchEnded.Set( true ); |
|
|
|
for ( int i = 1; i <= MAX_PLAYERS; i++ ) |
|
{ |
|
m_ePlayerWantsRematch.Set( i, USER_NEXT_MAP_VOTE_UNDECIDED ); |
|
} |
|
|
|
m_eRematchState = NEXT_MAP_VOTE_STATE_NONE; |
|
|
|
#ifdef GAME_DLL |
|
|
|
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch(); |
|
if ( pMatch ) |
|
{ |
|
SyncMatchSettings(); |
|
} |
|
|
|
for ( int i = 0; i < TF_TEAM_COUNT; i++ ) |
|
{ |
|
m_bHasSpawnedSoccerBall[i] = false; |
|
} |
|
|
|
m_flCheckPlayersConnectingTime = 0; |
|
|
|
m_pUpgrades = NULL; |
|
|
|
// Determine if a halloween event map is active |
|
// Map active always turns on Halloween |
|
{ |
|
char szCurrentMap[MAX_MAP_NAME]; |
|
Q_strncpy( szCurrentMap, STRING( gpGlobals->mapname ), sizeof( szCurrentMap ) ); |
|
|
|
if ( !Q_stricmp( szCurrentMap, "cp_manor_event" ) ) |
|
{ |
|
m_halloweenScenario.Set( HALLOWEEN_SCENARIO_MANN_MANOR ); |
|
} |
|
else if ( !Q_stricmp( szCurrentMap, "koth_viaduct_event" ) ) |
|
{ |
|
m_halloweenScenario.Set( HALLOWEEN_SCENARIO_VIADUCT ); |
|
} |
|
else if ( !Q_stricmp( szCurrentMap, "koth_lakeside_event" ) ) |
|
{ |
|
m_halloweenScenario.Set( HALLOWEEN_SCENARIO_LAKESIDE ); |
|
} |
|
else if( !Q_stricmp( szCurrentMap, "plr_hightower_event" ) ) |
|
{ |
|
m_halloweenScenario.Set( HALLOWEEN_SCENARIO_HIGHTOWER ); |
|
} |
|
else if ( !Q_stricmp( szCurrentMap, "sd_doomsday_event" ) ) |
|
{ |
|
m_halloweenScenario.Set( HALLOWEEN_SCENARIO_DOOMSDAY ); |
|
} |
|
} |
|
|
|
// Our hook for LoadMapCycleFile wont run during the base class constructor that does this initially |
|
TrackWorkshopMapsInMapCycle(); |
|
#endif |
|
} |
|
|
|
#ifdef GAME_DLL |
|
void CTFGameRules::Precache( void ) |
|
{ |
|
BaseClass::Precache(); |
|
|
|
// The Halloween bosses get spawned in code, so they don't get a chance to precache |
|
// when the map loads. We'll do the precaching for them here. |
|
if( IsHalloweenScenario( HALLOWEEN_SCENARIO_LAKESIDE ) ) |
|
{ |
|
CMerasmus::PrecacheMerasmus(); |
|
} |
|
else if( IsHalloweenScenario( HALLOWEEN_SCENARIO_VIADUCT ) ) |
|
{ |
|
CEyeballBoss::PrecacheEyeballBoss(); |
|
} |
|
else if( IsHalloweenScenario( HALLOWEEN_SCENARIO_MANN_MANOR ) ) |
|
{ |
|
CHeadlessHatman::PrecacheHeadlessHatman(); |
|
} |
|
else if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) ) |
|
{ |
|
CEyeballBoss::PrecacheEyeballBoss(); |
|
CGhost::PrecacheGhost(); |
|
} |
|
else if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) ) |
|
{ |
|
CTFPlayer::PrecacheKart(); |
|
CGhost::PrecacheGhost(); |
|
CHeadlessHatman::PrecacheHeadlessHatman(); |
|
CMerasmus::PrecacheMerasmus(); |
|
} |
|
|
|
if ( StringHasPrefix( STRING( gpGlobals->mapname ), "mvm_" ) ) |
|
{ |
|
CTFPlayer::PrecacheMvM(); |
|
} |
|
|
|
CTFPlayer::m_bTFPlayerNeedsPrecache = true; |
|
} |
|
#endif |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
//#ifdef GAME_DLL |
|
//extern void AddHalloweenGiftPositionsForMap( const char *pszMapName, CUtlVector<Vector> &vLocations ); |
|
//#endif |
|
|
|
void CTFGameRules::LevelInitPostEntity( void ) |
|
{ |
|
BaseClass::LevelInitPostEntity(); |
|
|
|
#ifdef GAME_DLL |
|
// Refind our proxy, because we might have had it deleted due to a mapmaker placed one |
|
m_hGamerulesProxy = dynamic_cast<CTFGameRulesProxy*>( gEntList.FindEntityByClassname( NULL, "tf_gamerules" ) ); |
|
|
|
// Halloween |
|
// Flush Halloween Gift Location and grab locations if applicable. NonHalloween maps will have these as zero |
|
m_halloweenGiftSpawnLocations.Purge(); |
|
|
|
if ( IsHolidayActive( kHoliday_Halloween ) ) |
|
{ |
|
for ( int i=0; i<IHalloweenGiftSpawnAutoList::AutoList().Count(); ++i ) |
|
{ |
|
CHalloweenGiftSpawnLocation* pGift = static_cast< CHalloweenGiftSpawnLocation* >( IHalloweenGiftSpawnAutoList::AutoList()[i] ); |
|
m_halloweenGiftSpawnLocations.AddToTail( pGift->GetAbsOrigin() ); |
|
UTIL_Remove( pGift ); |
|
} |
|
|
|
// Ask Halloween System if there are any locations |
|
AddHalloweenGiftPositionsForMap( STRING(gpGlobals->mapname), m_halloweenGiftSpawnLocations ); |
|
} |
|
|
|
m_flMatchSummaryTeleportTime = -1.f; |
|
|
|
//tagES |
|
#ifdef STAGING_ONLY |
|
tf_test_match_summary.SetValue( 0 ); |
|
#endif |
|
|
|
const IMatchGroupDescription *pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() ); |
|
if ( pMatchDesc ) |
|
{ |
|
pMatchDesc->InitGameRulesSettingsPostEntity(); |
|
} |
|
|
|
#endif // GAME_DLL |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
float CTFGameRules::GetRespawnTimeScalar( int iTeam ) |
|
{ |
|
// In PvE mode, we don't modify respawn times |
|
if ( IsPVEModeActive() ) |
|
return 1.0; |
|
|
|
return BaseClass::GetRespawnTimeScalar( iTeam ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
float CTFGameRules::GetRespawnWaveMaxLength( int iTeam, bool bScaleWithNumPlayers ) |
|
{ |
|
bool bScale = bScaleWithNumPlayers; |
|
|
|
#ifdef TF_RAID_MODE |
|
if ( IsRaidMode() ) |
|
{ |
|
return tf_raid_respawn_time.GetFloat(); |
|
} |
|
#endif // TF_RAID_MODE |
|
|
|
#ifdef TF_CREEP_MODE |
|
if ( IsCreepWaveMode() ) |
|
{ |
|
return tf_creep_wave_player_respawn_time.GetFloat(); |
|
} |
|
#endif |
|
|
|
if ( IsMannVsMachineMode() ) |
|
{ |
|
bScale = false; |
|
} |
|
|
|
float flTime = BaseClass::GetRespawnWaveMaxLength( iTeam, bScale ); |
|
|
|
CTFRobotDestructionLogic* pRoboLogic = CTFRobotDestructionLogic::GetRobotDestructionLogic(); |
|
if ( pRoboLogic ) |
|
{ |
|
flTime *= ( 1.f - pRoboLogic->GetRespawnScaleForTeam( iTeam ) ); |
|
} |
|
|
|
return flTime; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::FlagsMayBeCapped( void ) |
|
{ |
|
if ( State_Get() != GR_STATE_TEAM_WIN && State_Get() != GR_STATE_PREROUND ) |
|
return true; |
|
|
|
return false; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Return which Halloween scenario is currently running |
|
//----------------------------------------------------------------------------- |
|
CTFGameRules::HalloweenScenarioType CTFGameRules::GetHalloweenScenario( void ) const |
|
{ |
|
if ( !const_cast< CTFGameRules * >( this )->IsHolidayActive( kHoliday_Halloween ) ) |
|
return HALLOWEEN_SCENARIO_NONE; |
|
|
|
return m_halloweenScenario; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::IsUsingSpells( void ) const |
|
{ |
|
if ( tf_spells_enabled.GetBool() ) |
|
return true; |
|
|
|
if ( IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_HIGHTOWER ) ) |
|
return true; |
|
|
|
return m_bIsUsingSpells; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::IsUsingGrapplingHook( void ) const |
|
{ |
|
return tf_grapplinghook_enable.GetBool(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::IsTruceActive( void ) const |
|
{ |
|
return m_bTruceActive; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::CanInitiateDuels( void ) |
|
{ |
|
if ( IsInWaitingForPlayers() ) |
|
return false; |
|
|
|
gamerules_roundstate_t roundState = State_Get(); |
|
if ( ( roundState != GR_STATE_RND_RUNNING ) && ( roundState != GR_STATE_PREROUND ) ) |
|
return false; |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::GetGameTeamForGCTeam( TF_GC_TEAM nGCTeam ) |
|
{ |
|
if ( nGCTeam == TF_GC_TEAM_INVADERS ) |
|
{ |
|
if ( IsCompetitiveMode() ) |
|
{ |
|
return ( m_bTeamsSwitched ) ? TF_TEAM_RED : TF_TEAM_BLUE; |
|
} |
|
|
|
return TF_TEAM_BLUE; |
|
} |
|
else if ( nGCTeam == TF_GC_TEAM_DEFENDERS ) |
|
{ |
|
if ( IsCompetitiveMode() ) |
|
{ |
|
return ( m_bTeamsSwitched ) ? TF_TEAM_BLUE : TF_TEAM_RED; |
|
} |
|
|
|
return TF_TEAM_RED; |
|
} |
|
|
|
return TEAM_UNASSIGNED; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
TF_GC_TEAM CTFGameRules::GetGCTeamForGameTeam( int nGameTeam ) |
|
{ |
|
if ( nGameTeam == TF_TEAM_BLUE ) |
|
{ |
|
if ( IsCompetitiveMode() ) |
|
{ |
|
return ( m_bTeamsSwitched ) ? TF_GC_TEAM_DEFENDERS : TF_GC_TEAM_INVADERS; |
|
} |
|
|
|
return TF_GC_TEAM_INVADERS; |
|
} |
|
else if ( nGameTeam == TF_TEAM_RED ) |
|
{ |
|
if ( IsCompetitiveMode() ) |
|
{ |
|
return ( m_bTeamsSwitched ) ? TF_GC_TEAM_INVADERS : TF_GC_TEAM_DEFENDERS; |
|
} |
|
|
|
return TF_GC_TEAM_DEFENDERS; |
|
} |
|
|
|
return TF_GC_TEAM_NOTEAM; |
|
} |
|
|
|
CTFGameRules::EUserNextMapVote CTFGameRules::GetWinningVote( int (&nVotes)[ EUserNextMapVote::NUM_VOTE_STATES ] ) const |
|
{ |
|
// We assume "undecided" is the index just after the last vote option |
|
COMPILE_TIME_ASSERT( USER_NEXT_MAP_VOTE_UNDECIDED == NEXT_MAP_VOTE_OPTIONS ); |
|
memset( nVotes, 0, sizeof( nVotes ) ); |
|
int nTotalPlayers = 0; |
|
|
|
// Tally up votes. |
|
for( int iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ ) |
|
{ |
|
#ifdef CLIENT_DLL |
|
|
|
if ( !g_PR || !g_PR->IsConnected( iPlayerIndex ) ) |
|
continue; |
|
|
|
#else // GAME_DLL |
|
// We care about those that are still here. If you leave, you don't count towards the vote total |
|
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) ); |
|
if ( !pTFPlayer || pTFPlayer->IsBot() ) |
|
continue; |
|
|
|
|
|
if ( !pTFPlayer->IsConnected() ) |
|
continue; |
|
|
|
CSteamID steamID; |
|
pTFPlayer->GetSteamID( &steamID ); |
|
|
|
// People without parties *should* be getting a new one soon. Count them as undecided |
|
// until their party shows up and they're allowed to make a real vote. |
|
CTFParty* pParty = GTFGCClientSystem()->GetPartyForPlayer( steamID ); |
|
if ( !pParty ) |
|
{ |
|
++nVotes[ EUserNextMapVote::USER_NEXT_MAP_VOTE_UNDECIDED ]; |
|
++nTotalPlayers; |
|
continue; |
|
} |
|
|
|
const CMatchInfo* pMatch = GTFGCClientSystem()->GetMatch(); |
|
Assert( pMatch ); |
|
if ( !pMatch ) |
|
{ |
|
continue; |
|
} |
|
|
|
// Need to be a match players |
|
const CMatchInfo::PlayerMatchData_t* pPlayerMatchData = pMatch->GetMatchDataForPlayer( steamID ); |
|
Assert( pPlayerMatchData ); |
|
if ( !pPlayerMatchData ) |
|
{ |
|
// How'd you get here? |
|
continue; |
|
} |
|
#endif |
|
|
|
nTotalPlayers++; |
|
nVotes[ TFGameRules()->PlayerNextMapVoteState( iPlayerIndex ) ]++; |
|
} |
|
|
|
if ( nVotes[ USER_NEXT_MAP_VOTE_UNDECIDED ] == nTotalPlayers ) |
|
{ |
|
return USER_NEXT_MAP_VOTE_UNDECIDED; |
|
} |
|
else |
|
{ |
|
EUserNextMapVote eWinningVote = USER_NEXT_MAP_VOTE_MAP_0; |
|
|
|
for( int i = 0; i < NEXT_MAP_VOTE_OPTIONS; ++i ) |
|
{ |
|
// The current map is in slot 0. >= so we favor change. |
|
eWinningVote = nVotes[ i ] >= nVotes[ eWinningVote ] |
|
? (EUserNextMapVote)i |
|
: eWinningVote; |
|
} |
|
|
|
return eWinningVote; |
|
} |
|
} |
|
|
|
#ifdef GAME_DLL |
|
void CTFGameRules::UpdateNextMapVoteOptionsFromLobby() |
|
{ |
|
for( int i = 0; i < NEXT_MAP_VOTE_OPTIONS; ++i ) |
|
{ |
|
m_nNextMapVoteOptions.Set( i, GTFGCClientSystem()->GetNextMapVoteByIndex( i )->m_nDefIndex ); |
|
} |
|
} |
|
|
|
void CTFGameRules::KickPlayersNewMatchIDRequestFailed() |
|
{ |
|
Assert( m_eRematchState == NEXT_MAP_VOTE_STATE_MAP_CHOSEN_PAUSE ); |
|
|
|
// Let everyone know the rematch failed. |
|
if ( m_eRematchState == NEXT_MAP_VOTE_STATE_MAP_CHOSEN_PAUSE ) |
|
{ |
|
CBroadcastRecipientFilter filter; |
|
UTIL_ClientPrintFilter( filter, HUD_PRINTTALK, "#TF_Matchmaking_RollingQueue_NewRematch_GCFail" ); |
|
|
|
IGameEvent *pEvent = gameeventmanager->CreateEvent( "rematch_failed_to_create" ); |
|
if ( pEvent ) |
|
{ |
|
gameeventmanager->FireEvent( pEvent ); |
|
} |
|
} |
|
|
|
// The GC failed to get a new MatchID for us. Let's clear out and reset. |
|
engine->ServerCommand( "kickall #TF_Competitive_Disconnect\n" ); |
|
|
|
// Tell the GC System to end the managed match mode -- we skipped this in StopCompetitiveMatch so we could roll the |
|
// managed match into a new one. |
|
Assert( !IsManagedMatchEnded() ); |
|
if ( !IsManagedMatchEnded() ) |
|
{ |
|
GTFGCClientSystem()->EndManagedMatch( /* bKickPlayersToParties */ false ); |
|
Assert( IsManagedMatchEnded() ); |
|
m_bMatchEnded.Set( true ); |
|
} |
|
|
|
// Prepare for next match |
|
g_fGameOver = false; |
|
m_bAllowBetweenRounds = true; |
|
State_Transition( GR_STATE_RESTART ); |
|
SetInWaitingForPlayers( true ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::CheckAndSetPartyLeader( CTFPlayer *pTFPlayer, int iTeam ) |
|
{ |
|
if ( !pTFPlayer ) |
|
return; |
|
|
|
Assert( iTeam >= FIRST_GAME_TEAM ); |
|
if ( iTeam < FIRST_GAME_TEAM ) |
|
return; |
|
|
|
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch(); |
|
if ( !pMatch ) |
|
return; |
|
|
|
CSteamID steamID; |
|
if ( !pTFPlayer->GetSteamID( &steamID ) ) |
|
return; |
|
|
|
// TODO: Whenever a lobby is updated, look at the CTFLobbyMembers and see if |
|
// everyone has the same partyID and then set whoever is the leader to |
|
// have their name be the team name |
|
|
|
//CMatchInfo::PlayerMatchData_t *pMatchPlayer = pMatch->GetMatchDataForPlayer( steamID ); |
|
//if ( pMatchPlayer && pMatchPlayer->bPremadeLeader ) |
|
//{ |
|
// CTFPlayerResource *pResource = dynamic_cast< CTFPlayerResource* >( g_pPlayerResource ); |
|
// if ( pResource ) |
|
// { |
|
// pResource->SetPartyLeaderIndex( iTeam, pTFPlayer->entindex() ); |
|
// } |
|
//} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Sets current boss victim |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetIT( CBaseEntity *who ) |
|
{ |
|
if ( IsHolidayActive( kHoliday_Halloween ) && !IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) ) |
|
{ |
|
CTFPlayer* newIT = ToTFPlayer( who ); |
|
|
|
if ( newIT && newIT != m_itHandle.Get() ) |
|
{ |
|
// new IT victim - warn them |
|
ClientPrint( newIT, HUD_PRINTTALK, "#TF_HALLOWEEN_BOSS_WARN_VICTIM", newIT->GetPlayerName() ); |
|
ClientPrint( newIT, HUD_PRINTCENTER, "#TF_HALLOWEEN_BOSS_WARN_VICTIM", newIT->GetPlayerName() ); |
|
|
|
CSingleUserReliableRecipientFilter filter( newIT ); |
|
newIT->EmitSound( filter, newIT->entindex(), "Player.YouAreIT" ); |
|
|
|
// force them to scream when they become it |
|
newIT->EmitSound( "Halloween.PlayerScream" ); |
|
} |
|
|
|
CTFPlayer *oldIT = ToTFPlayer( m_itHandle ); |
|
|
|
if ( oldIT && oldIT != who && oldIT->IsAlive() ) |
|
{ |
|
// tell old IT player they are safe |
|
CSingleUserReliableRecipientFilter filter( oldIT ); |
|
oldIT->EmitSound( filter, oldIT->entindex(), "Player.TaggedOtherIT" ); |
|
|
|
ClientPrint( oldIT, HUD_PRINTTALK, "#TF_HALLOWEEN_BOSS_LOST_AGGRO" ); |
|
ClientPrint( oldIT, HUD_PRINTCENTER, "#TF_HALLOWEEN_BOSS_LOST_AGGRO" ); |
|
} |
|
} |
|
|
|
m_itHandle = who; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Sets current birthday player |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetBirthdayPlayer( CBaseEntity *pEntity ) |
|
{ |
|
/* |
|
if ( IsBirthday() ) |
|
{ |
|
if ( pEntity && pEntity->IsPlayer() && pEntity != m_hBirthdayPlayer.Get() ) |
|
{ |
|
CTFPlayer *pTFPlayer = ToTFPlayer( pEntity ); |
|
if ( pTFPlayer ) |
|
{ |
|
// new IT victim - warn them |
|
// ClientPrint( pTFPlayer, HUD_PRINTTALK, "#TF_HALLOWEEN_BOSS_WARN_VICTIM", player->GetPlayerName() ); |
|
// ClientPrint( pTFPlayer, HUD_PRINTCENTER, "#TF_HALLOWEEN_BOSS_WARN_VICTIM", player->GetPlayerName() ); |
|
|
|
CSingleUserReliableRecipientFilter filter( pTFPlayer ); |
|
pTFPlayer->EmitSound( filter, pTFPlayer->entindex(), "Game.HappyBirthday" ); |
|
|
|
// force them to scream when they become it |
|
// pTFPlayer->EmitSound( "Halloween.PlayerScream" ); |
|
} |
|
} |
|
|
|
// CTFPlayer *oldIT = ToTFPlayer( m_itHandle ); |
|
// |
|
// if ( oldIT && oldIT != who && oldIT->IsAlive() ) |
|
// { |
|
// // tell old IT player they are safe |
|
// CSingleUserReliableRecipientFilter filter( oldIT ); |
|
// oldIT->EmitSound( filter, oldIT->entindex(), "Player.TaggedOtherIT" ); |
|
// |
|
// ClientPrint( oldIT, HUD_PRINTTALK, "#TF_HALLOWEEN_BOSS_LOST_AGGRO" ); |
|
// ClientPrint( oldIT, HUD_PRINTCENTER, "#TF_HALLOWEEN_BOSS_LOST_AGGRO" ); |
|
// } |
|
|
|
m_hBirthdayPlayer = pEntity; |
|
} |
|
else |
|
{ |
|
m_hBirthdayPlayer = NULL; |
|
} |
|
*/ |
|
} |
|
|
|
|
|
#ifdef GAME_DLL |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: remove all projectiles in the world |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::RemoveAllProjectiles() |
|
{ |
|
for ( int i=0; i<IBaseProjectileAutoList::AutoList().Count(); ++i ) |
|
{ |
|
UTIL_Remove( static_cast< CBaseProjectile* >( IBaseProjectileAutoList::AutoList()[i] ) ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: remove all buildings in the world |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::RemoveAllBuildings( bool bExplodeBuildings /*= false*/ ) |
|
{ |
|
for ( int i=0; i<IBaseObjectAutoList::AutoList().Count(); ++i ) |
|
{ |
|
CBaseObject *pObj = static_cast< CBaseObject* >( IBaseObjectAutoList::AutoList()[i] ); |
|
if ( !pObj->IsMapPlaced() ) |
|
{ |
|
// this is separate from the object_destroyed event, which does |
|
// not get sent when we remove the objects from the world |
|
IGameEvent *event = gameeventmanager->CreateEvent( "object_removed" ); |
|
if ( event ) |
|
{ |
|
CTFPlayer *pOwner = pObj->GetOwner(); |
|
event->SetInt( "userid", pOwner ? pOwner->GetUserID() : -1 ); // user ID of the object owner |
|
event->SetInt( "objecttype", pObj->GetType() ); // type of object removed |
|
event->SetInt( "index", pObj->entindex() ); // index of the object removed |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
|
|
if ( bExplodeBuildings ) |
|
{ |
|
pObj->DetonateObject(); |
|
} |
|
else |
|
{ |
|
// This fixes a bug in Raid mode where we could spawn where our sentry was but |
|
// we didn't get the weapons because they couldn't trace to us in FVisible |
|
pObj->SetSolid( SOLID_NONE ); |
|
UTIL_Remove( pObj ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: remove all sentries ammo |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::RemoveAllSentriesAmmo() |
|
{ |
|
for ( int i=0; i<IBaseObjectAutoList::AutoList().Count(); ++i ) |
|
{ |
|
CBaseObject *pObj = static_cast< CBaseObject* >( IBaseObjectAutoList::AutoList()[i] ); |
|
if ( pObj->GetType() == OBJ_SENTRYGUN ) |
|
{ |
|
CObjectSentrygun *pSentry = assert_cast< CObjectSentrygun* >( pObj ); |
|
pSentry->RemoveAllAmmo(); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Removes all projectiles and buildings from world |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::RemoveAllProjectilesAndBuildings( bool bExplodeBuildings /*= false*/ ) |
|
{ |
|
RemoveAllProjectiles(); |
|
RemoveAllBuildings( bExplodeBuildings ); |
|
} |
|
#endif // GAME_DLL |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Determines whether we should allow mp_timelimit to trigger a map change |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::CanChangelevelBecauseOfTimeLimit( void ) |
|
{ |
|
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL; |
|
|
|
// we only want to deny a map change triggered by mp_timelimit if we're not forcing a map reset, |
|
// we're playing mini-rounds, and the master says we need to play all of them before changing (for maps like Dustbowl) |
|
if ( !m_bForceMapReset && pMaster && pMaster->PlayingMiniRounds() && pMaster->ShouldPlayAllControlPointRounds() ) |
|
{ |
|
if ( pMaster->NumPlayableControlPointRounds() > 0 ) |
|
{ |
|
return false; |
|
} |
|
} |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::CanGoToStalemate( void ) |
|
{ |
|
// In CTF, don't go to stalemate if one of the flags isn't at home |
|
if ( m_nGameType == TF_GAMETYPE_CTF ) |
|
{ |
|
for ( int i=0; i<ICaptureFlagAutoList::AutoList().Count(); ++i ) |
|
{ |
|
CCaptureFlag *pFlag = static_cast< CCaptureFlag* >( ICaptureFlagAutoList::AutoList()[i] ); |
|
if ( pFlag->IsDropped() || pFlag->IsStolen() ) |
|
return false; |
|
} |
|
|
|
// check that one team hasn't won by capping |
|
if ( CheckCapsPerRound() ) |
|
return false; |
|
} |
|
|
|
return BaseClass::CanGoToStalemate(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::RestoreActiveTimer( void ) |
|
{ |
|
BaseClass::RestoreActiveTimer(); |
|
|
|
if ( IsInKothMode() ) |
|
{ |
|
CTeamRoundTimer *pTimer = GetBlueKothRoundTimer(); |
|
if ( pTimer ) |
|
{ |
|
pTimer->SetShowInHud( true ); |
|
} |
|
|
|
pTimer = GetRedKothRoundTimer(); |
|
if ( pTimer ) |
|
{ |
|
pTimer->SetShowInHud( true ); |
|
} |
|
} |
|
} |
|
|
|
// Classnames of entities that are preserved across round restarts |
|
static const char *s_PreserveEnts[] = |
|
{ |
|
"tf_gamerules", |
|
"tf_team_manager", |
|
"tf_player_manager", |
|
"tf_team", |
|
"tf_objective_resource", |
|
"keyframe_rope", |
|
"move_rope", |
|
"tf_viewmodel", |
|
"tf_logic_training", |
|
"tf_logic_training_mode", |
|
#ifdef TF_RAID_MODE |
|
"tf_logic_raid", |
|
#endif // TF_RAID_MODE |
|
"tf_powerup_bottle", |
|
"tf_mann_vs_machine_stats", |
|
"tf_wearable", |
|
"tf_wearable_demoshield", |
|
"tf_wearable_robot_arm", |
|
"tf_wearable_vm", |
|
"tf_logic_bonusround", |
|
"vote_controller", |
|
"monster_resource", |
|
"tf_logic_medieval", |
|
"tf_logic_cp_timer", |
|
"tf_logic_tower_defense", // legacy |
|
"tf_logic_mann_vs_machine", |
|
"func_upgradestation", |
|
"entity_rocket", |
|
"entity_carrier", |
|
"entity_sign", |
|
"entity_saucer", |
|
"tf_halloween_gift_pickup", |
|
"tf_logic_competitive", |
|
"", // END Marker |
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::Activate() |
|
{ |
|
m_nGameType.Set( TF_GAMETYPE_UNDEFINED ); |
|
|
|
tf_gamemode_arena.SetValue( 0 ); |
|
tf_gamemode_cp.SetValue( 0 ); |
|
tf_gamemode_ctf.SetValue( 0 ); |
|
tf_gamemode_sd.SetValue( 0 ); |
|
tf_gamemode_payload.SetValue( 0 ); |
|
tf_gamemode_mvm.SetValue( 0 ); |
|
tf_gamemode_rd.SetValue( 0 ); |
|
tf_gamemode_pd.SetValue( 0 ); |
|
tf_gamemode_tc.SetValue( 0 ); |
|
tf_beta_content.SetValue( 0 ); |
|
tf_gamemode_passtime.SetValue( 0 ); |
|
tf_gamemode_misc.SetValue( 0 ); |
|
|
|
tf_bot_count.SetValue( 0 ); |
|
|
|
#ifdef TF_RAID_MODE |
|
tf_gamemode_raid.SetValue( 0 ); |
|
tf_gamemode_boss_battle.SetValue( 0 ); |
|
#endif |
|
m_bPlayingMannVsMachine.Set( false ); |
|
m_bBountyModeEnabled.Set( false ); |
|
m_nCurrencyAccumulator = 0; |
|
m_iCurrencyPool = 0; |
|
m_bMannVsMachineAlarmStatus.Set( false ); |
|
m_bPlayingKoth.Set( false ); |
|
m_bPlayingMedieval.Set( false ); |
|
m_bPlayingHybrid_CTF_CP.Set( false ); |
|
m_bPlayingSpecialDeliveryMode.Set( false ); |
|
m_bPlayingRobotDestructionMode.Set( false ); |
|
m_bPowerupMode.Set( false ); |
|
|
|
m_redPayloadToPush = NULL; |
|
m_bluePayloadToPush = NULL; |
|
m_redPayloadToBlock = NULL; |
|
m_bluePayloadToBlock = NULL; |
|
|
|
m_zombieMobTimer.Invalidate(); |
|
m_zombiesLeftToSpawn = 0; |
|
|
|
m_CPTimerEnts.RemoveAll(); |
|
|
|
m_nMapHolidayType.Set( kHoliday_None ); |
|
|
|
CArenaLogic *pArenaLogic = dynamic_cast< CArenaLogic * > (gEntList.FindEntityByClassname( NULL, "tf_logic_arena" ) ); |
|
|
|
if ( pArenaLogic != NULL ) |
|
{ |
|
m_hArenaEntity = pArenaLogic; |
|
|
|
m_nGameType.Set( TF_GAMETYPE_ARENA ); |
|
|
|
tf_gamemode_arena.SetValue( 1 ); |
|
|
|
Msg( "Executing server arena config file\n" ); |
|
engine->ServerCommand( "exec config_arena.cfg\n" ); |
|
} |
|
|
|
#ifdef TF_RAID_MODE |
|
CRaidLogic *pRaidLogic = dynamic_cast< CRaidLogic * >( gEntList.FindEntityByClassname( NULL, "tf_logic_raid" ) ); |
|
if ( pRaidLogic ) |
|
{ |
|
m_hRaidLogic = pRaidLogic; |
|
|
|
tf_gamemode_raid.SetValue( 1 ); |
|
|
|
Msg( "Executing server raid game mode config file\n" ); |
|
engine->ServerCommand( "exec config_raid.cfg\n" ); |
|
} |
|
|
|
CBossBattleLogic *pBossBattleLogic = dynamic_cast< CBossBattleLogic * >( gEntList.FindEntityByClassname( NULL, "tf_logic_boss_battle" ) ); |
|
if ( pBossBattleLogic ) |
|
{ |
|
m_hBossBattleLogic = pBossBattleLogic; |
|
|
|
tf_gamemode_boss_battle.SetValue( 1 ); |
|
} |
|
#endif // TF_RAID_MODE |
|
|
|
// This is beta content if this map has "beta" as a tag in the schema |
|
{ |
|
const MapDef_t* pMap = GetItemSchema()->GetMasterMapDefByName( STRING( gpGlobals->mapname ) ); |
|
if ( pMap && pMap->vecTags.HasElement( GetItemSchema()->GetHandleForTag( "beta" ) ) ) |
|
{ |
|
tf_beta_content.SetValue( 1 ); |
|
} |
|
} |
|
|
|
if ( !Q_strncmp( STRING( gpGlobals->mapname ), "tc_", 3 ) ) |
|
{ |
|
tf_gamemode_tc.SetValue( 1 ); |
|
} |
|
|
|
CMannVsMachineLogic *pMannVsMachineLogic = dynamic_cast< CMannVsMachineLogic * >( gEntList.FindEntityByClassname( NULL, "tf_logic_mann_vs_machine" ) ); |
|
CTeamTrainWatcher *pTrainWatch = dynamic_cast<CTeamTrainWatcher*> ( gEntList.FindEntityByClassname( NULL, "team_train_watcher" ) ); |
|
bool bFlag = ICaptureFlagAutoList::AutoList().Count() > 0; |
|
if ( CTFRobotDestructionLogic::GetRobotDestructionLogic() ) |
|
{ |
|
m_bPlayingRobotDestructionMode.Set( true ); |
|
if ( CTFRobotDestructionLogic::GetRobotDestructionLogic()->GetType() == CTFRobotDestructionLogic::TYPE_ROBOT_DESTRUCTION ) |
|
{ |
|
tf_gamemode_rd.SetValue( 1 ); |
|
m_nGameType.Set( TF_GAMETYPE_RD ); |
|
tf_beta_content.SetValue( 1 ); |
|
} |
|
else |
|
{ |
|
tf_gamemode_pd.SetValue( 1 ); |
|
m_nGameType.Set( TF_GAMETYPE_PD ); |
|
} |
|
} |
|
else if ( pMannVsMachineLogic ) |
|
{ |
|
m_bPlayingMannVsMachine.Set( true ); |
|
tf_gamemode_mvm.SetValue( 1 ); |
|
m_nGameType.Set( TF_GAMETYPE_MVM ); |
|
} |
|
else if ( StringHasPrefix( STRING( gpGlobals->mapname ), "sd_" ) ) |
|
{ |
|
m_bPlayingSpecialDeliveryMode.Set( true ); |
|
tf_gamemode_sd.SetValue( 1 ); |
|
} |
|
else if ( bFlag && !CTFRobotDestructionLogic::GetRobotDestructionLogic() ) |
|
{ |
|
m_nGameType.Set( TF_GAMETYPE_CTF ); |
|
tf_gamemode_ctf.SetValue( 1 ); |
|
} |
|
|
|
else if ( pTrainWatch ) |
|
{ |
|
m_nGameType.Set( TF_GAMETYPE_ESCORT ); |
|
tf_gamemode_payload.SetValue( 1 ); |
|
|
|
CMultipleEscort *pMultipleEscort = dynamic_cast<CMultipleEscort*> ( gEntList.FindEntityByClassname( NULL, "tf_logic_multiple_escort" ) ); |
|
SetMultipleTrains( pMultipleEscort != NULL ); |
|
} |
|
else if ( g_hControlPointMasters.Count() && m_nGameType != TF_GAMETYPE_ARENA ) // We have cap points in arena but we're not CP |
|
{ |
|
m_nGameType.Set( TF_GAMETYPE_CP ); |
|
tf_gamemode_cp.SetValue( 1 ); |
|
} |
|
|
|
auto *pPasstime = dynamic_cast<CTFPasstimeLogic*> ( gEntList.FindEntityByClassname( NULL, "passtime_logic" ) ); |
|
if ( pPasstime ) |
|
{ |
|
m_nGameType.Set( TF_GAMETYPE_PASSTIME ); |
|
tf_gamemode_passtime.SetValue( 1 ); |
|
} |
|
|
|
// the game is in training mode if this entity is found |
|
m_hTrainingModeLogic = dynamic_cast< CTrainingModeLogic * > ( gEntList.FindEntityByClassname( NULL, "tf_logic_training_mode" ) ); |
|
if ( NULL != m_hTrainingModeLogic ) |
|
{ |
|
m_bIsInTraining.Set( true ); |
|
m_bAllowTrainingAchievements.Set( false ); |
|
mp_humans_must_join_team.SetValue( "blue" ); |
|
m_bIsTrainingHUDVisible.Set( true ); |
|
tf_training_client_message.SetValue( (int)TRAINING_CLIENT_MESSAGE_NONE ); |
|
} |
|
|
|
m_bIsInItemTestingMode.Set( false ); |
|
|
|
CKothLogic *pKoth = dynamic_cast<CKothLogic*> ( gEntList.FindEntityByClassname( NULL, "tf_logic_koth" ) ); |
|
if ( pKoth ) |
|
{ |
|
m_bPlayingKoth.Set( true ); |
|
} |
|
|
|
CMedievalLogic *pMedieval = dynamic_cast<CMedievalLogic*> ( gEntList.FindEntityByClassname( NULL, "tf_logic_medieval" ) ); |
|
if ( pMedieval || tf_medieval.GetBool() ) |
|
{ |
|
m_bPlayingMedieval.Set( true ); |
|
} |
|
|
|
CCompetitiveLogic *pCompLogic = dynamic_cast< CCompetitiveLogic* > ( gEntList.FindEntityByClassname( NULL, "tf_logic_competitive" ) ); |
|
if ( pCompLogic ) |
|
{ |
|
m_hCompetitiveLogicEntity = pCompLogic; |
|
} |
|
|
|
CHybridMap_CTF_CP *pHybridMap_CTF_CP = dynamic_cast<CHybridMap_CTF_CP*> ( gEntList.FindEntityByClassname( NULL, "tf_logic_hybrid_ctf_cp" ) ); |
|
if ( pHybridMap_CTF_CP ) |
|
{ |
|
m_bPlayingHybrid_CTF_CP.Set( true ); |
|
} |
|
|
|
CTFHolidayEntity *pHolidayEntity = dynamic_cast<CTFHolidayEntity*> ( gEntList.FindEntityByClassname( NULL, "tf_logic_holiday" ) ); |
|
if ( pHolidayEntity ) |
|
{ |
|
m_nMapHolidayType.Set( pHolidayEntity->GetHolidayType() ); |
|
} |
|
|
|
// bot roster |
|
m_hBlueBotRoster = NULL; |
|
m_hRedBotRoster = NULL; |
|
CHandle<CTFBotRoster> hBotRoster = dynamic_cast< CTFBotRoster* >( gEntList.FindEntityByClassname( NULL, "bot_roster" ) ); |
|
while ( hBotRoster != NULL ) |
|
{ |
|
if ( FStrEq( hBotRoster->m_teamName.ToCStr(), "blue" ) ) |
|
{ |
|
m_hBlueBotRoster = hBotRoster; |
|
} |
|
else if ( FStrEq( hBotRoster->m_teamName.ToCStr(), "red" ) ) |
|
{ |
|
m_hRedBotRoster = hBotRoster; |
|
} |
|
else |
|
{ |
|
if ( m_hBlueBotRoster == NULL ) |
|
{ |
|
m_hBlueBotRoster = hBotRoster; |
|
} |
|
if ( m_hRedBotRoster == NULL ) |
|
{ |
|
m_hRedBotRoster = hBotRoster; |
|
} |
|
} |
|
hBotRoster = dynamic_cast< CTFBotRoster* >( gEntList.FindEntityByClassname( hBotRoster, "bot_roster" ) ); |
|
} |
|
|
|
CHandle<CCPTimerLogic> hCPTimer = dynamic_cast< CCPTimerLogic* >( gEntList.FindEntityByClassname( NULL, "tf_logic_cp_timer" ) ); |
|
while ( hCPTimer != NULL ) |
|
{ |
|
m_CPTimerEnts.AddToTail( hCPTimer ); |
|
hCPTimer = dynamic_cast< CCPTimerLogic* >( gEntList.FindEntityByClassname( hCPTimer, "tf_logic_cp_timer" ) ); |
|
} |
|
|
|
// hide from the master server if this game is a training game |
|
// or offline practice |
|
if ( IsInTraining() || TheTFBots().IsInOfflinePractice() || IsInItemTestingMode() ) |
|
{ |
|
hide_server.SetValue( true ); |
|
} |
|
|
|
m_bVoteCalled = false; |
|
m_bServerVoteOnReset = false; |
|
m_flVoteCheckThrottle = 0; |
|
|
|
#ifdef STAGING_ONLY |
|
// Dynamically create an upgrade entity outside MvM |
|
if ( tf_bountymode.GetBool() && !IsBountyMode() ) |
|
{ |
|
SetBountyMode( true ); |
|
} |
|
#endif // STAGING_ONLY |
|
|
|
if ( tf_powerup_mode.GetBool() ) |
|
{ |
|
if ( !IsPowerupMode() ) |
|
{ |
|
SetPowerupMode( true ); |
|
} |
|
} |
|
|
|
// if ( !IsInTournamentMode() ) |
|
// { |
|
// CExtraMapEntity::SpawnExtraModel(); |
|
// } |
|
|
|
// If leaving MvM for any other game mode, clean up any sticky UI/state |
|
if ( IsInTournamentMode() && m_nGameType != TF_GAMETYPE_MVM && g_TFGameModeHistory.GetPrevState() == TF_GAMETYPE_MVM ) |
|
{ |
|
mp_tournament.SetValue( false ); |
|
} |
|
|
|
if ( GameModeUsesUpgrades() && g_pPopulationManager == NULL ) |
|
{ |
|
(CPopulationManager *)CreateEntityByName( "info_populator" ); |
|
} |
|
|
|
if ( tf_gamemode_tc.GetBool() || tf_gamemode_sd.GetBool() || tf_gamemode_pd.GetBool() || m_bPlayingMedieval ) |
|
{ |
|
tf_gamemode_misc.SetValue( 1 ); |
|
} |
|
|
|
CBaseEntity *pStageLogic = gEntList.FindEntityByName( NULL, "competitive_stage_logic_case" ); |
|
if ( pStageLogic ) |
|
{ |
|
m_bMapHasMatchSummaryStage.Set( true ); |
|
} |
|
|
|
m_bCompetitiveMode.Set( false ); |
|
|
|
const IMatchGroupDescription *pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() ); |
|
if ( pMatchDesc ) |
|
{ |
|
pMatchDesc->InitGameRulesSettings(); |
|
} |
|
|
|
CLogicMannPower *pLogicMannPower = dynamic_cast< CLogicMannPower* > ( gEntList.FindEntityByClassname( NULL, "tf_logic_mannpower" ) ); |
|
tf_powerup_mode.SetValue( pLogicMannPower ? 1 : 0 ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::AllowDamage( CBaseEntity *pVictim, const CTakeDamageInfo &info ) |
|
{ |
|
bool bRetVal = true; |
|
|
|
if ( ( State_Get() == GR_STATE_TEAM_WIN ) && pVictim ) |
|
{ |
|
if ( pVictim->GetTeamNumber() == GetWinningTeam() ) |
|
{ |
|
CBaseTrigger *pTrigger = dynamic_cast< CBaseTrigger *>( info.GetInflictor() ); |
|
|
|
// we don't want players on the winning team to be |
|
// hurt by team-specific trigger_hurt entities during the bonus time |
|
if ( pTrigger && pTrigger->UsesFilter() ) |
|
{ |
|
bRetVal = false; |
|
} |
|
} |
|
} |
|
|
|
return bRetVal; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetTeamGoalString( int iTeam, const char *pszGoal ) |
|
{ |
|
if ( iTeam == TF_TEAM_RED ) |
|
{ |
|
if ( !pszGoal || !pszGoal[0] ) |
|
{ |
|
m_pszTeamGoalStringRed.GetForModify()[0] = '\0'; |
|
} |
|
else |
|
{ |
|
if ( Q_stricmp( m_pszTeamGoalStringRed.Get(), pszGoal ) ) |
|
{ |
|
Q_strncpy( m_pszTeamGoalStringRed.GetForModify(), pszGoal, MAX_TEAMGOAL_STRING ); |
|
} |
|
} |
|
} |
|
else if ( iTeam == TF_TEAM_BLUE ) |
|
{ |
|
if ( !pszGoal || !pszGoal[0] ) |
|
{ |
|
m_pszTeamGoalStringBlue.GetForModify()[0] = '\0'; |
|
} |
|
else |
|
{ |
|
if ( Q_stricmp( m_pszTeamGoalStringBlue.Get(), pszGoal ) ) |
|
{ |
|
Q_strncpy( m_pszTeamGoalStringBlue.GetForModify(), pszGoal, MAX_TEAMGOAL_STRING ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
//============================================================================= |
|
// HPE_BEGIN: |
|
// [msmith] Added a HUD type so that we can have the hud independent from the |
|
// game type. This is useful in training where we want a training hud |
|
// Instead of the other types of HUD. |
|
//============================================================================= |
|
//----------------------------------------------------------------------------- |
|
// Purpose: Set a HUD type. |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetHUDType( int nHudType ) |
|
{ |
|
if ( nHudType != TF_HUDTYPE_ARENA ) |
|
{ |
|
if ( nHudType >= TF_HUDTYPE_UNDEFINED && nHudType <= TF_HUDTYPE_TRAINING ) |
|
{ |
|
m_nHudType.Set( nHudType ); |
|
} |
|
} |
|
} |
|
//============================================================================= |
|
// HPE_END |
|
//============================================================================= |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::RoundCleanupShouldIgnore( CBaseEntity *pEnt ) |
|
{ |
|
if ( FindInList( s_PreserveEnts, pEnt->GetClassname() ) ) |
|
return true; |
|
|
|
//There has got to be a better way of doing this. |
|
if ( Q_strstr( pEnt->GetClassname(), "tf_weapon_" ) ) |
|
return true; |
|
|
|
return BaseClass::RoundCleanupShouldIgnore( pEnt ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::ShouldCreateEntity( const char *pszClassName ) |
|
{ |
|
if ( FindInList( s_PreserveEnts, pszClassName ) ) |
|
return false; |
|
|
|
return BaseClass::ShouldCreateEntity( pszClassName ); |
|
} |
|
|
|
const char* CTFGameRules::GetStalemateSong( int nTeam ) |
|
{ |
|
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) ) |
|
{ |
|
return (nTeam == TF_TEAM_RED) |
|
? "Announcer.Helltower_Hell_Red_Stalemate" |
|
: "Announcer.Helltower_Hell_Blue_Stalemate"; |
|
} |
|
else if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) ) |
|
{ |
|
return "Announcer.SD_Event_MurderedToStalemate"; |
|
} |
|
|
|
return "Game.Stalemate"; |
|
} |
|
|
|
const char* CTFGameRules::WinSongName( int nTeam ) |
|
{ |
|
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) ) |
|
{ |
|
return (nTeam == TF_TEAM_RED) |
|
? "Announcer.Helltower_Hell_Red_Win" |
|
: "Announcer.Helltower_Hell_Blue_Win"; |
|
} |
|
|
|
return "Game.YourTeamWon"; |
|
} |
|
|
|
|
|
const char* CTFGameRules::LoseSongName( int nTeam ) |
|
{ |
|
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) ) |
|
{ |
|
return (nTeam == TF_TEAM_RED) |
|
? "Announcer.Helltower_Hell_Red_Lose" |
|
: "Announcer.Helltower_Hell_Blue_Lose"; |
|
} |
|
else if ( IsMannVsMachineMode() ) |
|
{ |
|
return "music.mvm_lost_wave"; |
|
} |
|
else |
|
{ |
|
return BaseClass::LoseSongName( nTeam ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::CleanUpMap( void ) |
|
{ |
|
#ifdef GAME_DLL |
|
for ( int i = 1; i <= gpGlobals->maxClients; i++ ) |
|
{ |
|
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
if ( !pTFPlayer ) |
|
continue; |
|
|
|
// Remove all player conditions to prevent some dependency bugs |
|
pTFPlayer->m_Shared.RemoveAllCond(); |
|
} |
|
#endif // GAME_DLL |
|
|
|
BaseClass::CleanUpMap(); |
|
|
|
if ( HLTVDirector() ) |
|
{ |
|
HLTVDirector()->BuildCameraList(); |
|
} |
|
|
|
#ifdef GAME_DLL |
|
m_hasSpawnedToy = false; |
|
for ( int i = 0; i < TF_TEAM_COUNT; i++ ) |
|
{ |
|
m_bHasSpawnedSoccerBall[i] = false; |
|
} |
|
|
|
// If we're in a mode with upgrades, we force the players to recreate their weapons on next spawn. |
|
// This clears out any weapon upgrades they had in the previous round. |
|
if ( g_hUpgradeEntity ) |
|
{ |
|
for ( int i = 1; i <= gpGlobals->maxClients; i++ ) |
|
{ |
|
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
if ( !pTFPlayer ) |
|
continue; |
|
|
|
pTFPlayer->ForceItemRemovalOnRespawn(); |
|
|
|
// Remove all player upgrades as well |
|
pTFPlayer->RemovePlayerAttributes( false ); |
|
} |
|
} |
|
#endif |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::RecalculateControlPointState( void ) |
|
{ |
|
Assert( ObjectiveResource() ); |
|
|
|
if ( !g_hControlPointMasters.Count() ) |
|
return; |
|
|
|
if ( g_pObjectiveResource && g_pObjectiveResource->PlayingMiniRounds() ) |
|
return; |
|
|
|
for ( int iTeam = LAST_SHARED_TEAM+1; iTeam < GetNumberOfTeams(); iTeam++ ) |
|
{ |
|
int iFarthestPoint = GetFarthestOwnedControlPoint( iTeam, true ); |
|
if ( iFarthestPoint == -1 ) |
|
continue; |
|
|
|
// Now enable all spawn points for that spawn point |
|
for ( int i=0; i<ITFTeamSpawnAutoList::AutoList().Count(); ++i ) |
|
{ |
|
CTFTeamSpawn *pTFSpawn = static_cast< CTFTeamSpawn* >( ITFTeamSpawnAutoList::AutoList()[i] ); |
|
if ( pTFSpawn->GetControlPoint() ) |
|
{ |
|
if ( pTFSpawn->GetTeamNumber() == iTeam ) |
|
{ |
|
if ( pTFSpawn->GetControlPoint()->GetPointIndex() == iFarthestPoint ) |
|
{ |
|
pTFSpawn->SetDisabled( false ); |
|
} |
|
else |
|
{ |
|
pTFSpawn->SetDisabled( true ); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
DECLARE_AUTO_LIST( ITFTeleportLocationAutoList ) |
|
class CTFTeleportLocation : public CPointEntity, public ITFTeleportLocationAutoList |
|
{ |
|
public: |
|
DECLARE_CLASS( CTFTeleportLocation, CPointEntity ); |
|
}; |
|
|
|
IMPLEMENT_AUTO_LIST( ITFTeleportLocationAutoList ); |
|
|
|
LINK_ENTITY_TO_CLASS( tf_teleport_location, CTFTeleportLocation ); |
|
|
|
void SpawnRunes( void ) |
|
{ |
|
// Spawn power-up runes when the round starts. Choice of spawn location and Powerup Type is random |
|
CUtlVector< CTFInfoPowerupSpawn* > vecSpawnPoints; |
|
for ( int i = 0; i < IInfoPowerupSpawnAutoList::AutoList().Count(); i++ ) |
|
{ |
|
CTFInfoPowerupSpawn *pSpawnPoint = static_cast< CTFInfoPowerupSpawn* >( IInfoPowerupSpawnAutoList::AutoList()[i] ); |
|
if ( !pSpawnPoint->IsDisabled() && !pSpawnPoint->HasRune() ) |
|
{ |
|
vecSpawnPoints.AddToTail( pSpawnPoint ); |
|
} |
|
} |
|
|
|
Assert( vecSpawnPoints.Count() > 0 ); // We need at least one valid info_powerup_spawn |
|
|
|
// Warn if there aren't enough valid info_powerup_spawns to spawn all powerups |
|
if ( vecSpawnPoints.Count() < RUNE_TYPES_MAX ) |
|
{ |
|
Warning( "Warning: Not enough valid info_powerup_spawn locations found. You need a minimum of %i valid locations to spawn all Powerups.\n", RUNE_TYPES_MAX ); |
|
} |
|
|
|
// try to spawn each rune type |
|
for ( int nRuneTypes = 0; nRuneTypes < RUNE_TYPES_MAX && vecSpawnPoints.Count() > 0; nRuneTypes++ ) |
|
{ |
|
int index = RandomInt( 0, vecSpawnPoints.Count() - 1 ); |
|
CTFInfoPowerupSpawn *pSpawnPoint = vecSpawnPoints[index]; |
|
CTFRune *pNewRune = CTFRune::CreateRune( pSpawnPoint->GetAbsOrigin(), (RuneTypes_t) nRuneTypes, TEAM_ANY, false, false ); |
|
pSpawnPoint->SetRune( pNewRune ); |
|
vecSpawnPoints.Remove( index ); |
|
} |
|
} |
|
|
|
#ifdef STAGING_ONLY |
|
// Force spawn runes for testing |
|
CON_COMMAND_F( tf_force_spawn_runes, "For testing.", FCVAR_CHEAT ) |
|
{ |
|
SpawnRunes(); |
|
} |
|
#endif |
|
|
|
void CTFGameRules::RespawnPlayers( bool bForceRespawn, bool bTeam, int iTeam ) |
|
{ |
|
// Skip the respawn at the beginning of a round in casual/comp mode since we already |
|
// handled it when the pre-round doors closed over the players' views |
|
if ( IsCompetitiveMode() && ( GetRoundsPlayed() == 0 ) && bForceRespawn && ( State_Get() == GR_STATE_BETWEEN_RNDS || State_Get() == GR_STATE_PREROUND ) ) |
|
{ |
|
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL; |
|
if ( !pMaster || !pMaster->PlayingMiniRounds() || ( pMaster->GetCurrentRoundIndex() == 0 ) ) |
|
return; |
|
} |
|
|
|
BaseClass::RespawnPlayers( bForceRespawn, bTeam, iTeam ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Called when a new round is being initialized |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetupOnRoundStart( void ) |
|
{ |
|
for ( int i = 0; i < MAX_TEAMS; i++ ) |
|
{ |
|
ObjectiveResource()->SetBaseCP( -1, i ); |
|
} |
|
|
|
for ( int i = 0; i < TF_TEAM_COUNT; i++ ) |
|
{ |
|
m_iNumCaps[i] = 0; |
|
} |
|
|
|
SetOvertime( false ); |
|
|
|
m_hRedKothTimer.Set( NULL ); |
|
m_hBlueKothTimer.Set( NULL ); |
|
|
|
// Let all entities know that a new round is starting |
|
CBaseEntity *pEnt = gEntList.FirstEnt(); |
|
while( pEnt ) |
|
{ |
|
variant_t emptyVariant; |
|
pEnt->AcceptInput( "RoundSpawn", NULL, NULL, emptyVariant, 0 ); |
|
|
|
pEnt = gEntList.NextEnt( pEnt ); |
|
} |
|
|
|
// All entities have been spawned, now activate them |
|
m_areHealthAndAmmoVectorsReady = false; |
|
m_ammoVector.RemoveAll(); |
|
m_healthVector.RemoveAll(); |
|
|
|
pEnt = gEntList.FirstEnt(); |
|
while( pEnt ) |
|
{ |
|
variant_t emptyVariant; |
|
pEnt->AcceptInput( "RoundActivate", NULL, NULL, emptyVariant, 0 ); |
|
|
|
pEnt = gEntList.NextEnt( pEnt ); |
|
} |
|
|
|
if ( g_pObjectiveResource && !g_pObjectiveResource->PlayingMiniRounds() ) |
|
{ |
|
// Find all the control points with associated spawnpoints |
|
memset( m_bControlSpawnsPerTeam, 0, sizeof(bool) * MAX_TEAMS * MAX_CONTROL_POINTS ); |
|
for ( int i=0; i<ITFTeamSpawnAutoList::AutoList().Count(); ++i ) |
|
{ |
|
CTFTeamSpawn *pTFSpawn = static_cast< CTFTeamSpawn* >( ITFTeamSpawnAutoList::AutoList()[i] ); |
|
if ( pTFSpawn->GetControlPoint() ) |
|
{ |
|
m_bControlSpawnsPerTeam[ pTFSpawn->GetTeamNumber() ][ pTFSpawn->GetControlPoint()->GetPointIndex() ] = true; |
|
pTFSpawn->SetDisabled( true ); |
|
} |
|
} |
|
|
|
RecalculateControlPointState(); |
|
|
|
SetRoundOverlayDetails(); |
|
} |
|
|
|
//Do any round specific setup for training logic (resetting the score, messages, etc). |
|
if ( IsInTraining() ) |
|
{ |
|
if ( m_hTrainingModeLogic ) |
|
{ |
|
m_hTrainingModeLogic->SetupOnRoundStart(); |
|
} |
|
} |
|
|
|
m_szMostRecentCappers[0] = 0; |
|
m_halloweenBossTimer.Invalidate(); |
|
m_ghostVector.RemoveAll(); |
|
|
|
m_zombieMobTimer.Invalidate(); |
|
m_zombiesLeftToSpawn = 0; |
|
|
|
SetIT( NULL ); |
|
SetBirthdayPlayer( NULL ); |
|
|
|
if ( g_pMonsterResource ) |
|
{ |
|
g_pMonsterResource->HideBossHealthMeter(); |
|
} |
|
|
|
#ifdef TF_RAID_MODE |
|
if ( IsBossBattleMode() ) |
|
{ |
|
CTFTeam *enemyTeam = GetGlobalTFTeam( TF_TEAM_RED ); |
|
for( int i=0; i<enemyTeam->GetNumPlayers(); ++i ) |
|
{ |
|
CTFPlayer *who = ToTFPlayer( enemyTeam->GetPlayer( i ) ); |
|
|
|
who->ChangeTeam( TEAM_SPECTATOR, false, true ); |
|
who->RemoveAllObjects(); |
|
} |
|
} |
|
#endif // TF_RAID_MODE |
|
|
|
if ( IsMannVsMachineMode() ) |
|
{ |
|
if ( g_hMannVsMachineLogic ) |
|
{ |
|
g_hMannVsMachineLogic->SetupOnRoundStart(); |
|
} |
|
} |
|
|
|
m_redPayloadToPush = NULL; |
|
m_bluePayloadToPush = NULL; |
|
m_redPayloadToBlock = NULL; |
|
m_bluePayloadToBlock = NULL; |
|
|
|
// Tell the clients to recalculate the holiday |
|
IGameEvent *event = gameeventmanager->CreateEvent( "recalculate_holidays" ); |
|
if ( event ) |
|
{ |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
|
|
UTIL_CalculateHolidays(); |
|
|
|
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) ) |
|
{ |
|
m_helltowerTimer.Start( HELLTOWER_TIMER_INTERVAL ); |
|
} |
|
|
|
// reset hell state |
|
SetPlayersInHell( false ); |
|
|
|
if ( IsPowerupMode() ) |
|
{ |
|
// Reset imbalance detection scores |
|
m_nPowerupKillsBlueTeam = 0; |
|
m_nPowerupKillsRedTeam = 0; |
|
SpawnRunes(); |
|
} |
|
|
|
m_hHolidayLogic = dynamic_cast<CTFHolidayEntity*> ( gEntList.FindEntityByClassname( NULL, "tf_logic_holiday" ) ); |
|
if ( m_hHolidayLogic.IsValid() ) |
|
{ |
|
m_hHolidayLogic->ResetWinner(); |
|
} |
|
|
|
// cache off teleport locations and remove entities to save edicts |
|
m_mapTeleportLocations.PurgeAndDeleteElements(); |
|
for ( int i=0; i<ITFTeleportLocationAutoList::AutoList().Count(); ++i ) |
|
{ |
|
CTFTeleportLocation *pLocation = static_cast< CTFTeleportLocation* >( ITFTeleportLocationAutoList::AutoList()[i] ); |
|
|
|
int iMap = m_mapTeleportLocations.Find( pLocation->GetEntityName() ); |
|
if ( !m_mapTeleportLocations.IsValidIndex( iMap ) ) |
|
{ |
|
CUtlVector< TeleportLocation_t > *pNew = new CUtlVector< TeleportLocation_t >; |
|
iMap = m_mapTeleportLocations.Insert( pLocation->GetEntityName(), pNew ); |
|
} |
|
|
|
CUtlVector< TeleportLocation_t > *pLocations = m_mapTeleportLocations[iMap]; |
|
int iLocation = pLocations->AddToTail(); |
|
pLocations->Element( iLocation ).m_vecPosition = pLocation->GetAbsOrigin(); |
|
pLocations->Element( iLocation ).m_qAngles = pLocation->GetAbsAngles(); |
|
|
|
UTIL_Remove( pLocation ); |
|
} |
|
|
|
// swap our train model for the EOTL holiday |
|
if ( IsHolidayActive( kHoliday_EOTL ) ) |
|
{ |
|
for ( int i = 0; i < IPhysicsPropAutoList::AutoList().Count(); i++ ) |
|
{ |
|
CPhysicsProp *pPhysicsProp = static_cast<CPhysicsProp*>( IPhysicsPropAutoList::AutoList()[i] ); |
|
const char *pszTemp = pPhysicsProp->GetModelName().ToCStr(); |
|
|
|
if ( FStrEq( pszTemp, "models/props_trainyard/bomb_cart.mdl" ) ) |
|
{ |
|
pPhysicsProp->SetModel( "models/props_trainyard/bomb_eotl_blue.mdl" ); |
|
} |
|
else if ( FStrEq( pszTemp, "models/props_trainyard/bomb_cart_red.mdl" ) ) |
|
{ |
|
pPhysicsProp->SetModel( "models/props_trainyard/bomb_eotl_red.mdl" ); |
|
} |
|
} |
|
} |
|
|
|
m_flMatchSummaryTeleportTime = -1.f; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::RestartTournament( void ) |
|
{ |
|
BaseClass::RestartTournament(); |
|
|
|
if ( GetStopWatchTimer() ) |
|
{ |
|
UTIL_Remove( GetStopWatchTimer() ); |
|
} |
|
|
|
for ( int i = 1; i <= gpGlobals->maxClients; i++ ) |
|
{ |
|
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
if ( !pTFPlayer || !pTFPlayer->IsAlive() ) |
|
continue; |
|
|
|
pTFPlayer->m_Shared.RemoveCond( TF_COND_CRITBOOSTED, true ); |
|
pTFPlayer->m_Shared.RemoveCond( TF_COND_CRITBOOSTED_BONUS_TIME, true ); |
|
pTFPlayer->m_Shared.RemoveCond( TF_COND_CRITBOOSTED_CTF_CAPTURE, true ); |
|
} |
|
|
|
ItemSystem()->ReloadWhitelist(); |
|
|
|
ResetPlayerAndTeamReadyState(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::HandleTeamScoreModify( int iTeam, int iScore ) |
|
{ |
|
BaseClass::HandleTeamScoreModify( iTeam, iScore ); |
|
|
|
if ( IsInStopWatch() == true ) |
|
{ |
|
if ( GetStopWatchTimer() ) |
|
{ |
|
if ( GetStopWatchTimer()->IsWatchingTimeStamps() == true ) |
|
{ |
|
GetStopWatchTimer()->SetStopWatchTimeStamp(); |
|
} |
|
|
|
StopWatchModeThink(); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::StopWatchShouldBeTimedWin_Calculate( void ) |
|
{ |
|
m_bStopWatchShouldBeTimedWin = false; |
|
|
|
if ( IsInTournamentMode() && IsInStopWatch() && ObjectiveResource() ) |
|
{ |
|
int iStopWatchTimer = ObjectiveResource()->GetStopWatchTimer(); |
|
CTeamRoundTimer *pStopWatch = dynamic_cast< CTeamRoundTimer* >( UTIL_EntityByIndex( iStopWatchTimer ) ); |
|
if ( pStopWatch && !pStopWatch->IsWatchingTimeStamps() ) |
|
{ |
|
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL; |
|
|
|
if ( pMaster == NULL ) |
|
return; |
|
|
|
int iNumPoints = pMaster->GetNumPoints(); |
|
|
|
CTFTeam *pAttacker = NULL; |
|
CTFTeam *pDefender = NULL; |
|
|
|
for ( int i = LAST_SHARED_TEAM+1; i < GetNumberOfTeams(); i++ ) |
|
{ |
|
CTFTeam *pTeam = GetGlobalTFTeam( i ); |
|
|
|
if ( pTeam ) |
|
{ |
|
if ( pTeam->GetRole() == TEAM_ROLE_DEFENDERS ) |
|
{ |
|
pDefender = pTeam; |
|
} |
|
|
|
if ( pTeam->GetRole() == TEAM_ROLE_ATTACKERS ) |
|
{ |
|
pAttacker = pTeam; |
|
} |
|
} |
|
} |
|
|
|
if ( pAttacker == NULL || pDefender == NULL ) |
|
return; |
|
|
|
m_bStopWatchShouldBeTimedWin = ( pDefender->GetScore() == iNumPoints ); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::StopWatchShouldBeTimedWin( void ) |
|
{ |
|
StopWatchShouldBeTimedWin_Calculate(); |
|
return m_bStopWatchShouldBeTimedWin; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::StopWatchModeThink( void ) |
|
{ |
|
if ( IsInTournamentMode() == false || IsInStopWatch() == false ) |
|
return; |
|
|
|
if ( GetStopWatchTimer() == NULL ) |
|
return; |
|
|
|
CTeamRoundTimer *pTimer = GetStopWatchTimer(); |
|
|
|
bool bWatchingCaps = pTimer->IsWatchingTimeStamps(); |
|
|
|
CTFTeam *pAttacker = NULL; |
|
CTFTeam *pDefender = NULL; |
|
|
|
for ( int i = LAST_SHARED_TEAM+1; i < GetNumberOfTeams(); i++ ) |
|
{ |
|
CTFTeam *pTeam = GetGlobalTFTeam( i ); |
|
|
|
if ( pTeam ) |
|
{ |
|
if ( pTeam->GetRole() == TEAM_ROLE_DEFENDERS ) |
|
{ |
|
pDefender = pTeam; |
|
} |
|
|
|
if ( pTeam->GetRole() == TEAM_ROLE_ATTACKERS ) |
|
{ |
|
pAttacker = pTeam; |
|
} |
|
} |
|
} |
|
|
|
if ( pAttacker == NULL || pDefender == NULL ) |
|
return; |
|
|
|
m_bStopWatchWinner.Set( false ); |
|
|
|
if ( bWatchingCaps == false ) |
|
{ |
|
if ( pTimer->GetTimeRemaining() <= 0.0f ) |
|
{ |
|
if ( StopWatchShouldBeTimedWin() ) |
|
{ |
|
if ( pAttacker->GetScore() < pDefender->GetScore() ) |
|
{ |
|
m_bStopWatchWinner.Set( true ); |
|
SetWinningTeam( pDefender->GetTeamNumber(), WINREASON_DEFEND_UNTIL_TIME_LIMIT, true, true ); |
|
} |
|
} |
|
else |
|
{ |
|
if ( pAttacker->GetScore() > pDefender->GetScore() ) |
|
{ |
|
m_bStopWatchWinner.Set( true ); |
|
SetWinningTeam( pAttacker->GetTeamNumber(), WINREASON_ALL_POINTS_CAPTURED, true, true ); |
|
} |
|
} |
|
|
|
if ( pTimer->IsTimerPaused() == false ) |
|
{ |
|
variant_t sVariant; |
|
pTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 ); |
|
} |
|
|
|
m_nStopWatchState.Set( STOPWATCH_OVERTIME ); |
|
} |
|
else |
|
{ |
|
if ( pAttacker->GetScore() >= pDefender->GetScore() ) |
|
{ |
|
m_bStopWatchWinner.Set( true ); |
|
SetWinningTeam( pAttacker->GetTeamNumber(), WINREASON_ALL_POINTS_CAPTURED, true, true ); |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
if ( pTimer->GetTimeRemaining() <= 0.0f ) |
|
{ |
|
m_nStopWatchState.Set( STOPWATCH_CAPTURE_TIME_NOT_SET ); |
|
} |
|
else |
|
{ |
|
m_nStopWatchState.Set( STOPWATCH_RUNNING ); |
|
} |
|
} |
|
|
|
if ( m_bStopWatchWinner == true ) |
|
{ |
|
UTIL_Remove( pTimer ); |
|
m_hStopWatchTimer = NULL; |
|
m_flStopWatchTotalTime = -1.0f; |
|
m_bStopWatch = false; |
|
m_nStopWatchState.Set( STOPWATCH_CAPTURE_TIME_NOT_SET ); |
|
|
|
ShouldResetRoundsPlayed( false ); |
|
ShouldResetScores( true, false ); |
|
ResetScores(); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::ManageStopwatchTimer( bool bInSetup ) |
|
{ |
|
if ( IsInTournamentMode() == false ) |
|
return; |
|
|
|
if ( mp_tournament_stopwatch.GetBool() == false ) |
|
return; |
|
|
|
bool bAttacking = false; |
|
bool bDefending = false; |
|
|
|
for ( int i = LAST_SHARED_TEAM+1; i < GetNumberOfTeams(); i++ ) |
|
{ |
|
CTFTeam *pTeam = GetGlobalTFTeam( i ); |
|
|
|
if ( pTeam ) |
|
{ |
|
if ( pTeam->GetRole() == TEAM_ROLE_DEFENDERS ) |
|
{ |
|
bDefending = true; |
|
} |
|
|
|
if ( pTeam->GetRole() == TEAM_ROLE_ATTACKERS ) |
|
{ |
|
bAttacking = true; |
|
} |
|
} |
|
} |
|
|
|
if ( bDefending == true && bAttacking == true ) |
|
{ |
|
SetInStopWatch( true ); |
|
} |
|
else |
|
{ |
|
SetInStopWatch( false ); |
|
} |
|
|
|
if ( IsInStopWatch() == true ) |
|
{ |
|
if ( m_hStopWatchTimer == NULL ) |
|
{ |
|
variant_t sVariant; |
|
CTeamRoundTimer *pStopWatch = (CTeamRoundTimer*)CBaseEntity::CreateNoSpawn( "team_round_timer", vec3_origin, vec3_angle ); |
|
m_hStopWatchTimer = pStopWatch; |
|
|
|
pStopWatch->SetName( MAKE_STRING("zz_stopwatch_timer") ); |
|
pStopWatch->SetShowInHud( false ); |
|
pStopWatch->SetStopWatch( true ); |
|
|
|
if ( m_flStopWatchTotalTime < 0.0f ) |
|
{ |
|
pStopWatch->SetCaptureWatchState( true ); |
|
DispatchSpawn( pStopWatch ); |
|
|
|
pStopWatch->AcceptInput( "Enable", NULL, NULL, sVariant, 0 ); |
|
} |
|
else |
|
{ |
|
DispatchSpawn( pStopWatch ); |
|
pStopWatch->SetCaptureWatchState( false ); |
|
|
|
|
|
sVariant.SetInt( m_flStopWatchTotalTime ); |
|
pStopWatch->AcceptInput( "Enable", NULL, NULL, sVariant, 0 ); |
|
pStopWatch->AcceptInput( "SetTime", NULL, NULL, sVariant, 0 ); |
|
pStopWatch->SetAutoCountdown( true ); |
|
} |
|
|
|
if ( bInSetup == true ) |
|
{ |
|
pStopWatch->AcceptInput( "Pause", NULL, NULL, sVariant, 0 ); |
|
} |
|
|
|
ObjectiveResource()->SetStopWatchTimer( pStopWatch ); |
|
} |
|
else |
|
{ |
|
if ( bInSetup == false ) |
|
{ |
|
variant_t sVariant; |
|
m_hStopWatchTimer->AcceptInput( "Resume", NULL, NULL, sVariant, 0 ); |
|
} |
|
else |
|
{ |
|
variant_t sVariant; |
|
m_hStopWatchTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetSetup( bool bSetup ) |
|
{ |
|
if ( m_bInSetup == bSetup ) |
|
return; |
|
|
|
BaseClass::SetSetup( bSetup ); |
|
|
|
ManageStopwatchTimer( bSetup ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Called when a new round is off and running |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetupOnRoundRunning( void ) |
|
{ |
|
// Let out control point masters know that the round has started |
|
for ( int i = 0; i < g_hControlPointMasters.Count(); i++ ) |
|
{ |
|
variant_t emptyVariant; |
|
if ( g_hControlPointMasters[i] ) |
|
{ |
|
g_hControlPointMasters[i]->AcceptInput( "RoundStart", NULL, NULL, emptyVariant, 0 ); |
|
} |
|
} |
|
|
|
// Reset player speeds after preround lock |
|
CTFPlayer *pPlayer; |
|
for ( int i = 1; i <= gpGlobals->maxClients; i++ ) |
|
{ |
|
pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
|
|
if ( !pPlayer ) |
|
continue; |
|
|
|
pPlayer->TeamFortress_SetSpeed(); |
|
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) ) |
|
{ |
|
if ( !IsInWaitingForPlayers() ) |
|
{ |
|
pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_ROUND_START ); |
|
} |
|
|
|
} |
|
else if ( !IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) ) |
|
{ |
|
if ( IsCompetitiveMode() ) |
|
{ |
|
pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_ROUND_START_COMP ); |
|
} |
|
else |
|
{ |
|
pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_ROUND_START ); |
|
} |
|
} |
|
|
|
// warp the coach to student |
|
if ( pPlayer->GetStudent() ) |
|
{ |
|
pPlayer->SetObserverTarget( pPlayer->GetStudent() ); |
|
pPlayer->StartObserverMode( OBS_MODE_CHASE ); |
|
} |
|
|
|
if ( FNullEnt( pPlayer->edict() ) ) |
|
continue; |
|
|
|
pPlayer->m_Shared.ResetRoundScores(); |
|
|
|
// Store the class they started the round as (tf_player captures everything after this) |
|
if ( pPlayer->GetTeamNumber() >= FIRST_GAME_TEAM ) |
|
{ |
|
CSteamID steamID; |
|
pPlayer->GetSteamID( &steamID ); |
|
|
|
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch(); |
|
if ( pMatch ) |
|
{ |
|
CMatchInfo::PlayerMatchData_t *pMatchPlayer = pMatch->GetMatchDataForPlayer( steamID ); |
|
if ( pMatchPlayer ) |
|
{ |
|
pMatchPlayer->UpdateClassesPlayed( pPlayer->GetPlayerClass()->GetClassIndex() ); |
|
pMatchPlayer->bPlayed = true; |
|
} |
|
} |
|
} |
|
} |
|
|
|
if ( IsPlayingSpecialDeliveryMode() && !IsInWaitingForPlayers() ) |
|
{ |
|
if ( !IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) ) |
|
{ |
|
BroadcastSound( 255, "Announcer.SD_RoundStart" ); |
|
} |
|
} |
|
|
|
if ( IsMannVsMachineMode() && g_pPopulationManager ) |
|
{ |
|
IGameEvent *event = gameeventmanager->CreateEvent( "mvm_begin_wave" ); |
|
if ( event ) |
|
{ |
|
event->SetInt( "wave_index", g_pPopulationManager->GetWaveNumber() ); |
|
event->SetInt( "max_waves", g_pPopulationManager->GetTotalWaveCount() ); |
|
event->SetInt( "advanced", g_pPopulationManager->IsAdvancedPopFile() ? 1 : 0 ); |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
} |
|
|
|
if ( IsCompetitiveMode() && !( GetActiveRoundTimer() && ( GetActiveRoundTimer()->GetSetupTimeLength() > 0 ) ) ) |
|
{ |
|
// Announcer VO |
|
if ( ( TFTeamMgr()->GetTeam( TF_TEAM_BLUE )->GetScore() == ( mp_winlimit.GetInt() - 1 ) ) && |
|
( TFTeamMgr()->GetTeam( TF_TEAM_RED )->GetScore() == ( mp_winlimit.GetInt() - 1 ) ) ) |
|
{ |
|
BroadcastSound( 255, "Announcer.CompFinalGameBeginsFight" ); |
|
} |
|
else |
|
{ |
|
BroadcastSound( 255, "Announcer.CompGameBeginsFight" ); |
|
} |
|
} |
|
|
|
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch(); |
|
if ( pMatch && IsMatchTypeCompetitive() ) |
|
{ |
|
static ConVarRef tf_bot_quota( "tf_bot_quota" ); |
|
tf_bot_quota.SetValue( (int)pMatch->GetCanonicalMatchSize() ); |
|
static ConVarRef tf_bot_quota_mode( "tf_bot_quota_mode" ); |
|
tf_bot_quota_mode.SetValue( "fill" ); |
|
} |
|
|
|
if ( m_hGamerulesProxy ) |
|
{ |
|
m_hGamerulesProxy->StateEnterRoundRunning(); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Called before a new round is started (so the previous round can end) |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::PreviousRoundEnd( void ) |
|
{ |
|
// before we enter a new round, fire the "end output" for the previous round |
|
if ( g_hControlPointMasters.Count() && g_hControlPointMasters[0] ) |
|
{ |
|
g_hControlPointMasters[0]->FireRoundEndOutput(); |
|
} |
|
|
|
m_iPreviousRoundWinners = GetWinningTeam(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Called when a round has entered stalemate mode (timer has run out) |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetupOnStalemateStart( void ) |
|
{ |
|
// Remove everyone's objects |
|
RemoveAllProjectilesAndBuildings(); |
|
|
|
if ( IsInArenaMode() == false ) |
|
{ |
|
// Respawn all the players |
|
RespawnPlayers( true ); |
|
|
|
// Disable all the active health packs in the world |
|
m_hDisabledHealthKits.Purge(); |
|
CHealthKit *pHealthPack = gEntList.NextEntByClass( (CHealthKit *)NULL ); |
|
while ( pHealthPack ) |
|
{ |
|
if ( !pHealthPack->IsDisabled() ) |
|
{ |
|
pHealthPack->SetDisabled( true ); |
|
m_hDisabledHealthKits.AddToTail( pHealthPack ); |
|
} |
|
pHealthPack = gEntList.NextEntByClass( pHealthPack ); |
|
} |
|
} |
|
else |
|
{ |
|
CArenaLogic *pArenaLogic = dynamic_cast< CArenaLogic * > (gEntList.FindEntityByClassname( NULL, "tf_logic_arena" ) ); |
|
|
|
if ( pArenaLogic ) |
|
{ |
|
pArenaLogic->m_OnArenaRoundStart.FireOutput( pArenaLogic, pArenaLogic ); |
|
|
|
if ( tf_arena_override_cap_enable_time.GetFloat() > 0 ) |
|
{ |
|
m_flCapturePointEnableTime = gpGlobals->curtime + tf_arena_override_cap_enable_time.GetFloat(); |
|
} |
|
else |
|
{ |
|
m_flCapturePointEnableTime = gpGlobals->curtime + pArenaLogic->m_flTimeToEnableCapPoint; |
|
} |
|
|
|
IGameEvent *event = gameeventmanager->CreateEvent( "arena_round_start" ); |
|
if ( event ) |
|
{ |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
|
|
BroadcastSound( 255, "Announcer.AM_RoundStartRandom" ); |
|
} |
|
} |
|
|
|
CTFPlayer *pPlayer; |
|
for ( int i = 1; i <= gpGlobals->maxClients; i++ ) |
|
{ |
|
pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
|
|
if ( !pPlayer ) |
|
continue; |
|
|
|
if ( IsInArenaMode() == true ) |
|
{ |
|
pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_ROUND_START ); |
|
pPlayer->TeamFortress_SetSpeed(); |
|
} |
|
else |
|
{ |
|
pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_SUDDENDEATH_START ); |
|
} |
|
} |
|
|
|
m_flStalemateStartTime = gpGlobals->curtime; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetupOnStalemateEnd( void ) |
|
{ |
|
// Reenable all the health packs we disabled |
|
for ( int i = 0; i < m_hDisabledHealthKits.Count(); i++ ) |
|
{ |
|
if ( m_hDisabledHealthKits[i] ) |
|
{ |
|
m_hDisabledHealthKits[i]->SetDisabled( false ); |
|
} |
|
} |
|
|
|
m_hDisabledHealthKits.Purge(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::InitTeams( void ) |
|
{ |
|
BaseClass::InitTeams(); |
|
|
|
// clear the player class data |
|
ResetFilePlayerClassInfoDatabase(); |
|
} |
|
|
|
|
|
class CTraceFilterIgnoreTeammatesWithException : public CTraceFilterSimple |
|
{ |
|
DECLARE_CLASS( CTraceFilterIgnoreTeammatesWithException, CTraceFilterSimple ); |
|
public: |
|
CTraceFilterIgnoreTeammatesWithException( const IHandleEntity *passentity, int collisionGroup, int iIgnoreTeam, const IHandleEntity *pExceptionEntity ) |
|
: CTraceFilterSimple( passentity, collisionGroup ), m_iIgnoreTeam( iIgnoreTeam ) |
|
{ |
|
m_pExceptionEntity = pExceptionEntity; |
|
} |
|
|
|
virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask ) |
|
{ |
|
CBaseEntity *pEntity = EntityFromEntityHandle( pServerEntity ); |
|
|
|
if ( pServerEntity == m_pExceptionEntity ) |
|
return true; |
|
|
|
if ( pEntity->IsPlayer() && pEntity->GetTeamNumber() == m_iIgnoreTeam ) |
|
{ |
|
return false; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
int m_iIgnoreTeam; |
|
const IHandleEntity *m_pExceptionEntity; |
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::RadiusDamage( CTFRadiusDamageInfo &info ) |
|
{ |
|
float flRadSqr = (info.flRadius * info.flRadius); |
|
|
|
int iDamageEnemies = 0; |
|
int nDamageDealt = 0; |
|
// Some weapons pass a radius of 0, since their only goal is to give blast jumping ability |
|
if ( info.flRadius > 0 ) |
|
{ |
|
// Find all the entities in the radius, and attempt to damage them. |
|
CBaseEntity *pEntity = NULL; |
|
for ( CEntitySphereQuery sphere( info.vecSrc, info.flRadius ); (pEntity = sphere.GetCurrentEntity()) != NULL; sphere.NextEntity() ) |
|
{ |
|
// Skip the attacker, if we have a RJ radius set. We'll do it post. |
|
if ( info.flRJRadius && pEntity == info.dmgInfo->GetAttacker() ) |
|
continue; |
|
|
|
// CEntitySphereQuery actually does a box test. So we need to make sure the distance is less than the radius first. |
|
Vector vecPos; |
|
pEntity->CollisionProp()->CalcNearestPoint( info.vecSrc, &vecPos ); |
|
if ( (info.vecSrc - vecPos).LengthSqr() > flRadSqr ) |
|
continue; |
|
|
|
int iDamageToEntity = info.ApplyToEntity( pEntity ); |
|
if ( iDamageToEntity ) |
|
{ |
|
// Keep track of any enemies we damaged |
|
if ( pEntity->IsPlayer() && !pEntity->InSameTeam( info.dmgInfo->GetAttacker() ) ) |
|
{ |
|
nDamageDealt+= iDamageToEntity; |
|
iDamageEnemies++; |
|
} |
|
} |
|
} |
|
} |
|
|
|
// If we have a set RJ radius, use it to affect the inflictor. This way Rocket Launchers |
|
// with modified damage/radius perform like the base rocket launcher when it comes to RJing. |
|
if ( info.flRJRadius && info.dmgInfo->GetAttacker() ) |
|
{ |
|
// Set our radius & damage to the base RL |
|
info.flRadius = info.flRJRadius; |
|
CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase *>(info.dmgInfo->GetWeapon()); |
|
if ( pWeapon ) |
|
{ |
|
float flBaseDamage = pWeapon->GetTFWpnData().GetWeaponData( TF_WEAPON_PRIMARY_MODE ).m_nDamage; |
|
info.dmgInfo->SetDamage( flBaseDamage ); |
|
info.dmgInfo->CopyDamageToBaseDamage(); |
|
info.dmgInfo->SetDamagedOtherPlayers( iDamageEnemies ); |
|
|
|
// If we dealt damage, check radius life leech |
|
if ( nDamageDealt > 0 ) |
|
{ |
|
// Heal on hits |
|
int iModHealthOnHit = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( info.dmgInfo->GetWeapon(), iModHealthOnHit, add_health_on_radius_damage ); |
|
if ( iModHealthOnHit ) |
|
{ |
|
// Scale Health mod with damage dealt, input being the maximum amount of health possible |
|
float flScale = Clamp( nDamageDealt / flBaseDamage, 0.f, 1.0f ); |
|
iModHealthOnHit = (int)( (float)iModHealthOnHit * flScale ); |
|
int iHealed = info.dmgInfo->GetAttacker()->TakeHealth( iModHealthOnHit, DMG_GENERIC ); |
|
if ( iHealed ) |
|
{ |
|
IGameEvent *event = gameeventmanager->CreateEvent( "player_healonhit" ); |
|
if ( event ) |
|
{ |
|
event->SetInt( "amount", iHealed ); |
|
event->SetInt( "entindex", info.dmgInfo->GetAttacker()->entindex() ); |
|
item_definition_index_t healingItemDef = INVALID_ITEM_DEF_INDEX; |
|
if ( pWeapon->GetAttributeContainer() && pWeapon->GetAttributeContainer()->GetItem() ) |
|
{ |
|
healingItemDef = pWeapon->GetAttributeContainer()->GetItem()->GetItemDefIndex(); |
|
} |
|
event->SetInt( "weapon_def_index", healingItemDef ); |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
// Apply ourselves to our attacker, if we're within range |
|
Vector vecPos; |
|
info.dmgInfo->GetAttacker()->CollisionProp()->CalcNearestPoint( info.vecSrc, &vecPos ); |
|
if ( (info.vecSrc - vecPos).LengthSqr() <= (info.flRadius * info.flRadius) ) |
|
{ |
|
info.ApplyToEntity( info.dmgInfo->GetAttacker() ); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Calculate the damage falloff over distance |
|
//----------------------------------------------------------------------------- |
|
void CTFRadiusDamageInfo::CalculateFalloff( void ) |
|
{ |
|
if ( dmgInfo->GetDamageType() & DMG_RADIUS_MAX ) |
|
flFalloff = 0.0; |
|
else if ( dmgInfo->GetDamageType() & DMG_HALF_FALLOFF ) |
|
flFalloff = 0.5; |
|
else if ( flRadius ) |
|
flFalloff = dmgInfo->GetDamage() / flRadius; |
|
else |
|
flFalloff = 1.0; |
|
|
|
CBaseEntity *pWeapon = dmgInfo->GetWeapon(); |
|
if ( pWeapon != NULL ) |
|
{ |
|
float flFalloffMod = 1.f; |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, flFalloffMod, mult_dmg_falloff ); |
|
if ( flFalloffMod != 1.f ) |
|
{ |
|
flFalloff += flFalloffMod; |
|
} |
|
} |
|
|
|
if ( TFGameRules() && TFGameRules()->IsPowerupMode() ) |
|
{ |
|
CTFPlayer *pOwner = ToTFPlayer( dmgInfo->GetAttacker() ); |
|
if ( pOwner && pOwner->m_Shared.GetCarryingRuneType() == RUNE_PRECISION ) |
|
{ |
|
flFalloff = 1.0; |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Attempt to apply the radius damage to the specified entity |
|
//----------------------------------------------------------------------------- |
|
int CTFRadiusDamageInfo::ApplyToEntity( CBaseEntity *pEntity ) |
|
{ |
|
if ( pEntity == pEntityIgnore || pEntity->m_takedamage == DAMAGE_NO ) |
|
return 0; |
|
|
|
trace_t tr; |
|
CBaseEntity *pInflictor = dmgInfo->GetInflictor(); |
|
|
|
// Check that the explosion can 'see' this entity. |
|
Vector vecSpot = pEntity->BodyTarget( vecSrc, false ); |
|
CTraceFilterIgnorePlayers filterPlayers( pInflictor, COLLISION_GROUP_PROJECTILE ); |
|
CTraceFilterIgnoreFriendlyCombatItems filterCombatItems( pInflictor, COLLISION_GROUP_PROJECTILE, pInflictor->GetTeamNumber() ); |
|
CTraceFilterChain filter( &filterPlayers, &filterCombatItems ); |
|
|
|
UTIL_TraceLine( vecSrc, vecSpot, MASK_RADIUS_DAMAGE, &filter, &tr ); |
|
if ( tr.startsolid && tr.m_pEnt ) |
|
{ |
|
// Return when inside an enemy combat shield and tracing against a player of that team ("absorbed") |
|
if ( tr.m_pEnt->IsCombatItem() && pEntity->InSameTeam( tr.m_pEnt ) && ( pEntity != tr.m_pEnt ) ) |
|
return 0; |
|
|
|
filterPlayers.SetPassEntity( tr.m_pEnt ); |
|
CTraceFilterChain filterSelf( &filterPlayers, &filterCombatItems ); |
|
UTIL_TraceLine( vecSrc, vecSpot, MASK_RADIUS_DAMAGE, &filterSelf, &tr ); |
|
} |
|
|
|
// If we don't trace the whole way to the target, and we didn't hit the target entity, we're blocked |
|
if ( tr.fraction != 1.0 && tr.m_pEnt != pEntity ) |
|
return 0; |
|
|
|
// Adjust the damage - apply falloff. |
|
float flAdjustedDamage = 0.0f; |
|
float flDistanceToEntity; |
|
|
|
// Rockets store the ent they hit as the enemy and have already dealt full damage to them by this time |
|
if ( pInflictor && ( pEntity == pInflictor->GetEnemy() ) ) |
|
{ |
|
// Full damage, we hit this entity directly |
|
flDistanceToEntity = 0; |
|
} |
|
else if ( pEntity->IsPlayer() ) |
|
{ |
|
// Use whichever is closer, absorigin or worldspacecenter |
|
float flToWorldSpaceCenter = ( vecSrc - pEntity->WorldSpaceCenter() ).Length(); |
|
float flToOrigin = ( vecSrc - pEntity->GetAbsOrigin() ).Length(); |
|
|
|
flDistanceToEntity = MIN( flToWorldSpaceCenter, flToOrigin ); |
|
} |
|
else |
|
{ |
|
flDistanceToEntity = ( vecSrc - tr.endpos ).Length(); |
|
} |
|
|
|
flAdjustedDamage = RemapValClamped( flDistanceToEntity, 0, flRadius, dmgInfo->GetDamage(), dmgInfo->GetDamage() * flFalloff ); |
|
|
|
CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase *>(dmgInfo->GetWeapon()); |
|
|
|
// Grenades & Pipebombs do less damage to ourselves. |
|
if ( pEntity == dmgInfo->GetAttacker() && pWeapon ) |
|
{ |
|
switch( pWeapon->GetWeaponID() ) |
|
{ |
|
case TF_WEAPON_PIPEBOMBLAUNCHER : |
|
case TF_WEAPON_GRENADELAUNCHER : |
|
case TF_WEAPON_CANNON : |
|
case TF_WEAPON_STICKBOMB : |
|
flAdjustedDamage *= 0.75f; |
|
break; |
|
} |
|
} |
|
|
|
// If we end up doing 0 damage, exit now. |
|
if ( flAdjustedDamage <= 0 ) |
|
return 0; |
|
|
|
// the explosion can 'see' this entity, so hurt them! |
|
if (tr.startsolid) |
|
{ |
|
// if we're stuck inside them, fixup the position and distance |
|
tr.endpos = vecSrc; |
|
tr.fraction = 0.0; |
|
} |
|
|
|
CTakeDamageInfo adjustedInfo = *dmgInfo; |
|
adjustedInfo.SetDamage( flAdjustedDamage ); |
|
|
|
Vector dir = vecSpot - vecSrc; |
|
VectorNormalize( dir ); |
|
|
|
// If we don't have a damage force, manufacture one |
|
if ( adjustedInfo.GetDamagePosition() == vec3_origin || adjustedInfo.GetDamageForce() == vec3_origin ) |
|
{ |
|
CalculateExplosiveDamageForce( &adjustedInfo, dir, vecSrc ); |
|
} |
|
else |
|
{ |
|
// Assume the force passed in is the maximum force. Decay it based on falloff. |
|
float flForce = adjustedInfo.GetDamageForce().Length() * flFalloff; |
|
adjustedInfo.SetDamageForce( dir * flForce ); |
|
adjustedInfo.SetDamagePosition( vecSrc ); |
|
} |
|
|
|
adjustedInfo.ScaleDamageForce( m_flForceScale ); |
|
|
|
int nDamageTaken = 0; |
|
if ( tr.fraction != 1.0 && pEntity == tr.m_pEnt ) |
|
{ |
|
ClearMultiDamage( ); |
|
pEntity->DispatchTraceAttack( adjustedInfo, dir, &tr ); |
|
ApplyMultiDamage(); |
|
} |
|
else |
|
{ |
|
nDamageTaken = pEntity->TakeDamage( adjustedInfo ); |
|
} |
|
|
|
// Now hit all triggers along the way that respond to damage. |
|
pEntity->TraceAttackToTriggers( adjustedInfo, vecSrc, tr.endpos, dir ); |
|
return nDamageTaken; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : &info - |
|
// &vecSrcIn - |
|
// flRadius - |
|
// iClassIgnore - |
|
// *pEntityIgnore - |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::RadiusDamage( const CTakeDamageInfo &info, const Vector &vecSrcIn, float flRadius, int iClassIgnore, CBaseEntity *pEntityIgnore ) |
|
{ |
|
// This shouldn't be used. Call the version above that takes a CTFRadiusDamageInfo pointer. |
|
Assert(0); |
|
|
|
CTakeDamageInfo dmgInfo = info; |
|
Vector vecSrc = vecSrcIn; |
|
CTFRadiusDamageInfo radiusinfo( &dmgInfo, vecSrc, flRadius, pEntityIgnore ); |
|
RadiusDamage(radiusinfo); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::ApplyOnDamageModifyRules( CTakeDamageInfo &info, CBaseEntity *pVictimBaseEntity, bool bAllowDamage ) |
|
{ |
|
info.SetDamageForForceCalc( info.GetDamage() ); |
|
bool bDebug = tf_debug_damage.GetBool(); |
|
|
|
CTFPlayer *pVictim = ToTFPlayer( pVictimBaseEntity ); |
|
CBaseEntity *pAttacker = info.GetAttacker(); |
|
CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker ); |
|
|
|
// damage may not come from a weapon (ie: Bosses, etc) |
|
// The existing code below already checked for NULL pWeapon, anyways |
|
CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase * >( info.GetWeapon() ); |
|
|
|
bool bShowDisguisedCrit = false; |
|
bool bAllSeeCrit = false; |
|
EAttackBonusEffects_t eBonusEffect = kBonusEffect_None; |
|
|
|
if ( pVictim ) |
|
{ |
|
pVictim->SetSeeCrit( false, false, false ); |
|
pVictim->SetAttackBonusEffect( kBonusEffect_None ); |
|
} |
|
|
|
int bitsDamage = info.GetDamageType(); |
|
|
|
// Damage type was already crit (Flares / headshot) |
|
if ( bitsDamage & DMG_CRITICAL ) |
|
{ |
|
info.SetCritType( CTakeDamageInfo::CRIT_FULL ); |
|
} |
|
|
|
// First figure out whether this is going to be a full forced crit for some specific reason. It's |
|
// important that we do this before figuring out whether we're going to be a minicrit or not. |
|
|
|
// Allow attributes to force critical hits on players with specific conditions |
|
if ( pVictim ) |
|
{ |
|
// Crit against players that have these conditions |
|
int iCritDamageTypes = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iCritDamageTypes, or_crit_vs_playercond ); |
|
|
|
if ( iCritDamageTypes ) |
|
{ |
|
// iCritDamageTypes is an or'd list of types. We need to pull each bit out and |
|
// then test against what that bit in the items_master file maps to. |
|
for ( int i = 0; condition_to_attribute_translation[i] != TF_COND_LAST; i++ ) |
|
{ |
|
if ( iCritDamageTypes & ( 1 << i ) ) |
|
{ |
|
if ( pVictim->m_Shared.InCond( condition_to_attribute_translation[ i ] ) ) |
|
{ |
|
bitsDamage |= DMG_CRITICAL; |
|
info.AddDamageType( DMG_CRITICAL ); |
|
info.SetCritType( CTakeDamageInfo::CRIT_FULL ); |
|
|
|
if ( condition_to_attribute_translation[i] == TF_COND_DISGUISED || |
|
condition_to_attribute_translation[i] == TF_COND_DISGUISING ) |
|
{ |
|
// if our attribute specifically crits disguised enemies we need to show it on the client |
|
bShowDisguisedCrit = true; |
|
} |
|
break; |
|
} |
|
} |
|
} |
|
} |
|
|
|
int iCritVsWet = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iCritVsWet, crit_vs_wet_players ); |
|
if ( iCritVsWet ) |
|
{ |
|
float flWaterExitTime = pVictim->GetWaterExitTime(); |
|
|
|
if ( pVictim->m_Shared.InCond( TF_COND_URINE ) || |
|
pVictim->m_Shared.InCond( TF_COND_MAD_MILK ) || |
|
( pVictim->GetWaterLevel() > WL_NotInWater ) || |
|
( ( flWaterExitTime > 0 ) && ( gpGlobals->curtime - flWaterExitTime < 5.0f ) ) ) // or they exited the water in the last few seconds |
|
{ |
|
bitsDamage |= DMG_CRITICAL; |
|
info.AddDamageType( DMG_CRITICAL ); |
|
info.SetCritType( CTakeDamageInfo::CRIT_FULL ); |
|
} |
|
} |
|
|
|
// Crit against players that don't have these conditions |
|
int iCritDamageNotTypes = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iCritDamageNotTypes, or_crit_vs_not_playercond ); |
|
|
|
if ( iCritDamageNotTypes ) |
|
{ |
|
// iCritDamageTypes is an or'd list of types. We need to pull each bit out and |
|
// then test against what that bit in the items_master file maps to. |
|
for ( int i = 0; condition_to_attribute_translation[i] != TF_COND_LAST; i++ ) |
|
{ |
|
if ( iCritDamageNotTypes & ( 1 << i ) ) |
|
{ |
|
if ( !pVictim->m_Shared.InCond( condition_to_attribute_translation[ i ] ) ) |
|
{ |
|
bitsDamage |= DMG_CRITICAL; |
|
info.AddDamageType( DMG_CRITICAL ); |
|
info.SetCritType( CTakeDamageInfo::CRIT_FULL ); |
|
|
|
if ( condition_to_attribute_translation[ i ] == TF_COND_DISGUISED || |
|
condition_to_attribute_translation[ i ] == TF_COND_DISGUISING ) |
|
{ |
|
// if our attribute specifically crits disguised enemies we need to show it on the client |
|
bShowDisguisedCrit = true; |
|
} |
|
break; |
|
} |
|
} |
|
} |
|
} |
|
|
|
// Crit burning behind |
|
int iCritBurning = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iCritBurning, axtinguisher_properties ); |
|
if ( iCritBurning && pVictim->m_Shared.InCond( TF_COND_BURNING ) ) |
|
{ |
|
// Full crit in back, mini in front |
|
Vector toEnt = pVictim->GetAbsOrigin() - pTFAttacker->GetAbsOrigin(); |
|
{ |
|
Vector entForward; |
|
AngleVectors( pVictim->EyeAngles(), &entForward ); |
|
toEnt.z = 0; |
|
toEnt.NormalizeInPlace(); |
|
|
|
if ( DotProduct( toEnt, entForward ) > 0.0f ) // 90 degrees from center (total of 180) |
|
{ |
|
bitsDamage |= DMG_CRITICAL; |
|
info.AddDamageType( DMG_CRITICAL ); |
|
info.SetCritType( CTakeDamageInfo::CRIT_FULL ); |
|
} |
|
else |
|
{ |
|
bAllSeeCrit = true; |
|
info.SetCritType( CTakeDamageInfo::CRIT_MINI ); |
|
eBonusEffect = kBonusEffect_MiniCrit; |
|
} |
|
} |
|
} |
|
} |
|
|
|
int iCritWhileAirborne = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iCritWhileAirborne, crit_while_airborne ); |
|
if ( iCritWhileAirborne && pTFAttacker ) |
|
{ |
|
if ( pTFAttacker->InAirDueToExplosion() ) |
|
{ |
|
bitsDamage |= DMG_CRITICAL; |
|
info.AddDamageType( DMG_CRITICAL ); |
|
info.SetCritType( CTakeDamageInfo::CRIT_FULL ); |
|
} |
|
} |
|
|
|
// For awarding assist damage stat later |
|
ETFCond eDamageBonusCond = TF_COND_LAST; |
|
|
|
// Some forms of damage override long range damage falloff |
|
bool bIgnoreLongRangeDmgEffects = false; |
|
|
|
// Figure out if it's a minicrit or not |
|
// But we never minicrit ourselves. |
|
if ( pAttacker != pVictimBaseEntity ) |
|
{ |
|
if ( info.GetCritType() == CTakeDamageInfo::CRIT_NONE ) |
|
{ |
|
CBaseEntity *pInflictor = info.GetInflictor(); |
|
CTFGrenadePipebombProjectile *pBaseGrenade = dynamic_cast< CTFGrenadePipebombProjectile* >( pInflictor ); |
|
CTFBaseRocket *pBaseRocket = dynamic_cast< CTFBaseRocket* >( pInflictor ); |
|
|
|
if ( pVictim && ( pVictim->m_Shared.InCond( TF_COND_URINE ) || |
|
pVictim->m_Shared.InCond( TF_COND_MARKEDFORDEATH ) || |
|
pVictim->m_Shared.InCond( TF_COND_MARKEDFORDEATH_SILENT ) || |
|
pVictim->m_Shared.InCond( TF_COND_PASSTIME_PENALTY_DEBUFF ) ) ) |
|
{ |
|
bAllSeeCrit = true; |
|
info.SetCritType( CTakeDamageInfo::CRIT_MINI ); |
|
eBonusEffect = kBonusEffect_MiniCrit; |
|
|
|
if ( !pVictim->m_Shared.InCond( TF_COND_MARKEDFORDEATH_SILENT ) ) |
|
{ |
|
eDamageBonusCond = pVictim->m_Shared.InCond( TF_COND_URINE ) ? TF_COND_URINE : TF_COND_MARKEDFORDEATH; |
|
} |
|
} |
|
else if ( pTFAttacker && ( pTFAttacker->m_Shared.InCond( TF_COND_OFFENSEBUFF ) || pTFAttacker->m_Shared.InCond( TF_COND_NOHEALINGDAMAGEBUFF ) ) ) |
|
{ |
|
// Attackers buffed by the soldier do mini-crits. |
|
bAllSeeCrit = true; |
|
info.SetCritType( CTakeDamageInfo::CRIT_MINI ); |
|
eBonusEffect = kBonusEffect_MiniCrit; |
|
|
|
if ( pTFAttacker->m_Shared.InCond( TF_COND_OFFENSEBUFF ) ) |
|
{ |
|
eDamageBonusCond = TF_COND_OFFENSEBUFF; |
|
} |
|
} |
|
else if ( pTFAttacker && (bitsDamage & DMG_RADIUS_MAX) && pWeapon && ( (pWeapon->GetWeaponID() == TF_WEAPON_SWORD) || (pWeapon->GetWeaponID() == TF_WEAPON_BOTTLE)|| (pWeapon->GetWeaponID() == TF_WEAPON_WRENCH) ) ) |
|
{ |
|
// First sword or bottle attack after a charge is a mini-crit. |
|
bAllSeeCrit = true; |
|
info.SetCritType( CTakeDamageInfo::CRIT_MINI ); |
|
eBonusEffect = kBonusEffect_MiniCrit; |
|
} |
|
else if ( ( pInflictor && pInflictor->IsPlayer() == false ) && ( ( pBaseRocket && pBaseRocket->GetDeflected() ) || ( pBaseGrenade && pBaseGrenade->GetDeflected() && ( pBaseGrenade->ShouldMiniCritOnReflect() ) ) ) ) |
|
{ |
|
// Reflected rockets, grenades (non-remote detonate), arrows always mini-crit |
|
info.SetCritType( CTakeDamageInfo::CRIT_MINI ); |
|
eBonusEffect = kBonusEffect_MiniCrit; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_PLASMA_CHARGED ) |
|
{ |
|
// Charged plasma shots do minicrits. |
|
info.SetCritType( CTakeDamageInfo::CRIT_MINI ); |
|
eBonusEffect = kBonusEffect_MiniCrit; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_CLEAVER_CRIT ) |
|
{ |
|
// Long range cleaver hit |
|
info.SetCritType( CTakeDamageInfo::CRIT_MINI ); |
|
eBonusEffect = kBonusEffect_MiniCrit; |
|
} |
|
else if ( pTFAttacker && ( pTFAttacker->m_Shared.InCond( TF_COND_ENERGY_BUFF ) ) ) |
|
{ |
|
// Scouts using crit drink do mini-crits, as well as receive them |
|
info.SetCritType( CTakeDamageInfo::CRIT_MINI ); |
|
eBonusEffect = kBonusEffect_MiniCrit; |
|
} |
|
else if ( ( info.GetDamageType() & DMG_IGNITE ) && pVictim && pVictim->m_Shared.InCond( TF_COND_BURNING ) && info.GetDamageCustom() == TF_DMG_CUSTOM_BURNING_FLARE ) |
|
{ |
|
CTFFlareGun *pFlareGun = dynamic_cast< CTFFlareGun* >( pWeapon ); |
|
if ( pFlareGun && pFlareGun->GetFlareGunType() != FLAREGUN_GRORDBORT ) |
|
{ |
|
info.SetCritType( CTakeDamageInfo::CRIT_MINI ); |
|
eBonusEffect = kBonusEffect_MiniCrit; |
|
} |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_FLARE_PELLET ) |
|
{ |
|
CBaseEntity *pInflictor = info.GetInflictor(); |
|
CTFProjectile_Flare *pFlare = dynamic_cast< CTFProjectile_Flare* >( pInflictor ); |
|
if ( pFlare && pFlare->IsFromTaunt() && pFlare->GetTimeAlive() < 0.05f ) |
|
{ |
|
// Taunt crits fired from the scorch shot at short range are super powerful! |
|
info.SetDamage( 400.0f ); |
|
} |
|
} |
|
else if( pTFAttacker && pWeapon && pWeapon->GetWeaponID() == TF_WEAPON_CANNON && ( info.GetDamageType() & DMG_BLAST ) ) |
|
{ |
|
CTFGrenadeLauncher* pGrenadeLauncher = static_cast<CTFGrenadeLauncher*>( pWeapon ); |
|
if( pGrenadeLauncher->IsDoubleDonk( pVictim ) ) |
|
{ |
|
info.SetCritType( CTakeDamageInfo::CRIT_MINI ); |
|
eBonusEffect = kBonusEffect_DoubleDonk; |
|
info.SetDamage( info.GetMaxDamage() ); // Double donk victims score max damage |
|
EconEntity_OnOwnerKillEaterEvent( pGrenadeLauncher, pTFAttacker, pVictim, kKillEaterEvent_DoubleDonks ); |
|
} |
|
} |
|
else |
|
{ |
|
// Allow Attributes to shortcut out if found, no need to check all of them |
|
for ( int i = 0; i < 1; ++i ) |
|
{ |
|
// Some weapons force minicrits on burning targets. |
|
// Does not work for burn but works for ignite |
|
int iForceMiniCritOnBurning = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iForceMiniCritOnBurning, or_minicrit_vs_playercond_burning ); |
|
if ( iForceMiniCritOnBurning == 1 && pVictim && pVictim->m_Shared.InCond( TF_COND_BURNING ) && !( info.GetDamageType() & DMG_BURN ) ) |
|
{ |
|
bAllSeeCrit = true; |
|
info.SetCritType( CTakeDamageInfo::CRIT_MINI ); |
|
eBonusEffect = kBonusEffect_MiniCrit; |
|
break; |
|
} |
|
|
|
// Some weapons mini-crit airborne targets. Airborne targets are any target that has been knocked |
|
// into the air by an explosive force from an enemy. |
|
int iMiniCritAirborne = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iMiniCritAirborne, mini_crit_airborne ); |
|
if ( iMiniCritAirborne == 1 && pVictim && pVictim->InAirDueToKnockback() ) |
|
{ |
|
bAllSeeCrit = true; |
|
info.SetCritType( CTakeDamageInfo::CRIT_MINI ); |
|
eBonusEffect = kBonusEffect_MiniCrit; |
|
break; |
|
} |
|
|
|
//// Some weapons minicrit *any* target in the air, regardless of how they got there. |
|
//int iMiniCritAirborneDeploy = 0; |
|
//CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iMiniCritAirborneDeploy, mini_crit_airborne_deploy ); |
|
//if ( iMiniCritAirborneDeploy > 0 && |
|
// pWeapon && |
|
// ( gpGlobals->curtime - pWeapon->GetLastDeployTime() ) < iMiniCritAirborneDeploy && |
|
// // |
|
|
|
// pVictim && !( pVictim->GetFlags() & FL_ONGROUND ) && |
|
// ( pVictim->GetWaterLevel() == WL_NotInWater ) ) |
|
//{ |
|
// bAllSeeCrit = true; |
|
// info.SetCritType( CTakeDamageInfo::CRIT_MINI ); |
|
// eBonusEffect = kBonusEffect_MiniCrit; |
|
// break; |
|
//} |
|
|
|
if ( pTFAttacker && pVictim ) |
|
{ |
|
// MiniCrit a victims back at close range |
|
int iMiniCritBackAttack = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iMiniCritBackAttack, closerange_backattack_minicrits ); |
|
Vector toEnt = pVictim->GetAbsOrigin() - pTFAttacker->GetAbsOrigin(); |
|
if ( iMiniCritBackAttack == 1 && toEnt.LengthSqr() < Square( 512.0f ) ) |
|
{ |
|
Vector entForward; |
|
AngleVectors( pVictim->EyeAngles(), &entForward ); |
|
toEnt.z = 0; |
|
toEnt.NormalizeInPlace(); |
|
|
|
if ( DotProduct( toEnt, entForward ) > 0.259f ) // 75 degrees from center (total of 150) |
|
{ |
|
bAllSeeCrit = true; |
|
info.SetCritType( CTakeDamageInfo::CRIT_MINI ); |
|
eBonusEffect = kBonusEffect_MiniCrit; |
|
break; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
// Don't do long range distance falloff when pAttacker has Rocket Specialist attrib and directly hits an enemy |
|
if ( pBaseRocket && pBaseRocket->GetEnemy() && pBaseRocket->GetEnemy() == pVictimBaseEntity ) |
|
{ |
|
int iRocketSpecialist = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pAttacker, iRocketSpecialist, rocket_specialist ); |
|
if ( iRocketSpecialist ) |
|
bIgnoreLongRangeDmgEffects = true; |
|
} |
|
|
|
// Some Powerups remove distance damage falloff |
|
if ( pTFAttacker && ( pTFAttacker->m_Shared.GetCarryingRuneType() == RUNE_STRENGTH || pTFAttacker->m_Shared.GetCarryingRuneType() == RUNE_PRECISION ) ) |
|
{ |
|
bIgnoreLongRangeDmgEffects = true; |
|
} |
|
} |
|
} |
|
|
|
if ( info.GetCritType() == CTakeDamageInfo::CRIT_MINI ) |
|
{ |
|
int iPromoteMiniCritToCrit = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iPromoteMiniCritToCrit, minicrits_become_crits ); |
|
if ( iPromoteMiniCritToCrit == 1 ) |
|
{ |
|
info.SetCritType( CTakeDamageInfo::CRIT_FULL ); |
|
eBonusEffect = kBonusEffect_Crit; |
|
bitsDamage |= DMG_CRITICAL; |
|
info.AddDamageType( DMG_CRITICAL ); |
|
} |
|
} |
|
|
|
if ( pVictim ) |
|
{ |
|
pVictim->SetSeeCrit( bAllSeeCrit, info.GetCritType() == CTakeDamageInfo::CRIT_MINI, bShowDisguisedCrit ); |
|
pVictim->SetAttackBonusEffect( eBonusEffect ); |
|
} |
|
|
|
// If we're invulnerable, force ourselves to only take damage events only, so we still get pushed |
|
if ( pVictim && pVictim->m_Shared.IsInvulnerable() ) |
|
{ |
|
if ( !bAllowDamage ) |
|
{ |
|
int iOldTakeDamage = pVictim->m_takedamage; |
|
pVictim->m_takedamage = DAMAGE_EVENTS_ONLY; |
|
// NOTE: Deliberately skip base player OnTakeDamage, because we don't want all the stuff it does re: suit voice |
|
pVictim->CBaseCombatCharacter::OnTakeDamage( info ); |
|
pVictim->m_takedamage = iOldTakeDamage; |
|
|
|
// Burn sounds are handled in ConditionThink() |
|
if ( !(bitsDamage & DMG_BURN ) ) |
|
{ |
|
pVictim->SpeakConceptIfAllowed( MP_CONCEPT_HURT ); |
|
} |
|
|
|
// If this is critical explosive damage, and the Medic giving us invuln triggered |
|
// it in the last second, he's earned himself an achievement. |
|
if ( (bitsDamage & DMG_CRITICAL) && (bitsDamage & DMG_BLAST) ) |
|
{ |
|
pVictim->m_Shared.CheckForAchievement( ACHIEVEMENT_TF_MEDIC_SAVE_TEAMMATE ); |
|
} |
|
|
|
return false; |
|
} |
|
} |
|
|
|
|
|
if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BACKSTAB ) |
|
{ |
|
// Jarate backstabber |
|
int iJarateBackstabber = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pVictim, iJarateBackstabber, jarate_backstabber ); |
|
if ( iJarateBackstabber > 0 && pTFAttacker ) |
|
{ |
|
pTFAttacker->m_Shared.AddCond( TF_COND_URINE, 10.0f, pVictim ); |
|
pTFAttacker->m_Shared.SetPeeAttacker( pVictim ); |
|
pTFAttacker->SpeakConceptIfAllowed( MP_CONCEPT_JARATE_HIT ); |
|
} |
|
|
|
if ( pVictim && pVictim->CheckBlockBackstab( pTFAttacker ) ) |
|
{ |
|
// The backstab was absorbed by a shield. |
|
info.SetDamage( 0 ); |
|
|
|
// Shake nearby players' screens. |
|
UTIL_ScreenShake( pVictim->GetAbsOrigin(), 25.f, 150.0, 1.0, 50.f, SHAKE_START ); |
|
|
|
// Play the notification sound. |
|
pVictim->EmitSound( "Player.Spy_Shield_Break" ); |
|
|
|
// Unzoom the sniper. |
|
CTFWeaponBase *pWeapon = pVictim->GetActiveTFWeapon(); |
|
if ( pWeapon && WeaponID_IsSniperRifle( pWeapon->GetWeaponID() ) ) |
|
{ |
|
CTFSniperRifle *pSniperRifle = static_cast< CTFSniperRifle* >( pWeapon ); |
|
if ( pSniperRifle->IsZoomed() ) |
|
{ |
|
pSniperRifle->ZoomOut(); |
|
} |
|
} |
|
|
|
// Vibrate the spy's knife. |
|
if ( pTFAttacker && pTFAttacker->GetActiveWeapon() ) |
|
{ |
|
CTFKnife *pKnife = (CTFKnife *) pTFAttacker->GetActiveWeapon(); |
|
if ( pKnife ) |
|
{ |
|
pKnife->BackstabBlocked(); |
|
} |
|
} |
|
|
|
// Tell the clients involved in the jarate |
|
CRecipientFilter involved_filter; |
|
involved_filter.AddRecipient( pVictim ); |
|
involved_filter.AddRecipient( pTFAttacker ); |
|
|
|
UserMessageBegin( involved_filter, "PlayerShieldBlocked" ); |
|
WRITE_BYTE( pTFAttacker->entindex() ); |
|
WRITE_BYTE( pVictim->entindex() ); |
|
MessageEnd(); |
|
} |
|
} |
|
|
|
// Apply attributes that increase damage vs players |
|
if ( pWeapon ) |
|
{ |
|
float flDamage = info.GetDamage(); |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, flDamage, mult_dmg_vs_players ); |
|
|
|
// Check if we're to boost damage against the same class |
|
if( pVictim && pTFAttacker ) |
|
{ |
|
int nVictimClass = pVictim->GetPlayerClass()->GetClassIndex(); |
|
int nAttackerClass = pTFAttacker->GetPlayerClass()->GetClassIndex(); |
|
|
|
// Same class? |
|
if( nVictimClass == nAttackerClass ) |
|
{ |
|
// Potentially boost damage |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, flDamage, mult_dmg_vs_same_class ); |
|
} |
|
} |
|
|
|
info.SetDamage( flDamage ); |
|
} |
|
|
|
if ( pVictim && !pVictim->m_Shared.InCond( TF_COND_BURNING ) ) |
|
{ |
|
if ( bitsDamage & DMG_CRITICAL ) |
|
{ |
|
if ( pTFAttacker && !pTFAttacker->m_Shared.IsCritBoosted() ) |
|
{ |
|
int iNonBurningCritsDisabled = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iNonBurningCritsDisabled, set_nocrit_vs_nonburning ); |
|
if ( iNonBurningCritsDisabled ) |
|
{ |
|
bitsDamage &= ~DMG_CRITICAL; |
|
info.SetDamageType( info.GetDamageType() & (~DMG_CRITICAL) ); |
|
info.SetCritType( CTakeDamageInfo::CRIT_NONE ); |
|
} |
|
} |
|
} |
|
|
|
float flDamage = info.GetDamage(); |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, flDamage, mult_dmg_vs_nonburning ); |
|
info.SetDamage( flDamage ); |
|
} |
|
|
|
// Alien Isolation SetBonus Checking |
|
if ( pVictim && pTFAttacker && pWeapon ) |
|
{ |
|
// Alien->Merc melee bonus |
|
if ( ( info.GetDamageType() & (DMG_CLUB|DMG_SLASH) ) && info.GetDamageCustom() != TF_DMG_CUSTOM_BASEBALL ) |
|
{ |
|
CTFWeaponBaseMelee *pMelee = dynamic_cast<CTFWeaponBaseMelee*>( pWeapon ); |
|
if ( pMelee ) |
|
{ |
|
int iAttackerAlien = 0; |
|
int iVictimMerc = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pTFAttacker, iAttackerAlien, alien_isolation_xeno_bonus_pos ); |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pVictim, iVictimMerc, alien_isolation_merc_bonus_pos ); |
|
|
|
if ( iAttackerAlien && iVictimMerc ) |
|
{ |
|
info.SetDamage( info.GetDamage() * 5.0f ); |
|
} |
|
} |
|
} |
|
|
|
// Merc->Alien MK50 damage, aka flamethrower |
|
if ( ( info.GetDamageType() & DMG_IGNITE ) && pWeapon->GetWeaponID() == TF_WEAPON_FLAMETHROWER ) |
|
{ |
|
int iAttackerMerc = 0; |
|
int iVictimAlien = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pTFAttacker, iAttackerMerc, alien_isolation_merc_bonus_pos ); |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pVictim, iVictimAlien, alien_isolation_xeno_bonus_pos ); |
|
|
|
if ( iAttackerMerc && iVictimAlien ) |
|
{ |
|
info.SetDamage( info.GetDamage() * 3.0f ); |
|
} |
|
} |
|
} |
|
|
|
int iPierceResists = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iPierceResists, mod_ignore_resists_absorbs ); |
|
|
|
// Use defense buffs if it's not a backstab or direct crush damage (telefrage, etc.) |
|
if ( pVictim && info.GetDamageCustom() != TF_DMG_CUSTOM_BACKSTAB && ( info.GetDamageType() & DMG_CRUSH ) == 0 ) |
|
{ |
|
if ( pVictim->m_Shared.InCond( TF_COND_DEFENSEBUFF ) ) |
|
{ |
|
// We take no crits of any kind... |
|
if( eBonusEffect == kBonusEffect_MiniCrit || eBonusEffect == kBonusEffect_Crit ) |
|
eBonusEffect = kBonusEffect_None; |
|
info.SetCritType( CTakeDamageInfo::CRIT_NONE ); |
|
bAllSeeCrit = false; |
|
bShowDisguisedCrit = false; |
|
|
|
pVictim->SetSeeCrit( bAllSeeCrit, false, bShowDisguisedCrit ); |
|
pVictim->SetAttackBonusEffect( eBonusEffect ); |
|
|
|
bitsDamage &= ~DMG_CRITICAL; |
|
info.SetDamageType( bitsDamage ); |
|
info.SetCritType( CTakeDamageInfo::CRIT_NONE ); |
|
} |
|
|
|
if ( !iPierceResists ) |
|
{ |
|
// If we are defense buffed... |
|
if ( pVictim->m_Shared.InCond( TF_COND_DEFENSEBUFF_HIGH ) ) |
|
{ |
|
// We take 75% less damage... still take crits |
|
info.SetDamage( info.GetDamage() * 0.25f ); |
|
} |
|
else if ( pVictim->m_Shared.InCond( TF_COND_DEFENSEBUFF ) || pVictim->m_Shared.InCond( TF_COND_DEFENSEBUFF_NO_CRIT_BLOCK ) ) |
|
{ |
|
// defense buffs gives 50% to sentry dmg and 35% from all other sources |
|
CObjectSentrygun *pSentry = ( info.GetInflictor() && info.GetInflictor()->IsBaseObject() ) ? dynamic_cast< CObjectSentrygun* >( info.GetInflictor() ) : NULL; |
|
if ( pSentry ) |
|
{ |
|
info.SetDamage( info.GetDamage() * 0.50f ); |
|
} |
|
else |
|
{ |
|
// And we take 35% less damage... |
|
info.SetDamage( info.GetDamage() * 0.65f ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
// A note about why crits now go through the randomness/variance code: |
|
// Normally critical damage is not affected by variance. However, we always want to measure what that variance |
|
// would have been so that we can lump it into the DamageBonus value inside the info. This means crits actually |
|
// boost more than 3X when you factor the reduction we avoided. Example: a rocket that normally would do 50 |
|
// damage due to range now does the original 100, which is then multiplied by 3, resulting in a 6x increase. |
|
bool bCrit = ( bitsDamage & DMG_CRITICAL ) ? true : false; |
|
|
|
// If we're not damaging ourselves, apply randomness |
|
if ( pAttacker != pVictimBaseEntity && !(bitsDamage & (DMG_DROWN | DMG_FALL)) ) |
|
{ |
|
float flDamage = info.GetDamage(); |
|
float flDmgVariance = 0.f; |
|
|
|
// Minicrits still get short range damage bonus |
|
bool bForceCritFalloff = ( bitsDamage & DMG_USEDISTANCEMOD ) && |
|
( ( bCrit && tf_weapon_criticals_distance_falloff.GetBool() ) || |
|
( info.GetCritType() == CTakeDamageInfo::CRIT_MINI && tf_weapon_minicrits_distance_falloff.GetBool() ) ); |
|
bool bDoShortRangeDistanceIncrease = !bCrit || info.GetCritType() == CTakeDamageInfo::CRIT_MINI ; |
|
bool bDoLongRangeDistanceDecrease = !bIgnoreLongRangeDmgEffects && ( bForceCritFalloff || ( !bCrit && info.GetCritType() != CTakeDamageInfo::CRIT_MINI ) ); |
|
|
|
// If we're doing any distance modification, we need to do that first |
|
float flRandomDamage = info.GetDamage() * tf_damage_range.GetFloat(); |
|
|
|
float flRandomDamageSpread = 0.10f; |
|
float flMin = 0.5 - flRandomDamageSpread; |
|
float flMax = 0.5 + flRandomDamageSpread; |
|
|
|
if ( bitsDamage & DMG_USEDISTANCEMOD ) |
|
{ |
|
Vector vAttackerPos = pAttacker->WorldSpaceCenter(); |
|
float flOptimalDistance = 512.0; |
|
|
|
// Use Sentry position for distance mod |
|
CObjectSentrygun *pSentry = dynamic_cast<CObjectSentrygun*>( info.GetInflictor() ); |
|
if ( pSentry ) |
|
{ |
|
vAttackerPos = pSentry->WorldSpaceCenter(); |
|
// Sentries have a much further optimal distance |
|
flOptimalDistance = SENTRY_MAX_RANGE; |
|
} |
|
// The base sniper rifle doesn't have DMG_USEDISTANCEMOD, so this isn't used. Unlockable rifle had it for a bit. |
|
else if ( pWeapon && WeaponID_IsSniperRifle( pWeapon->GetWeaponID() ) ) |
|
{ |
|
flOptimalDistance *= 2.5f; |
|
} |
|
|
|
float flDistance = MAX( 1.0, ( pVictimBaseEntity->WorldSpaceCenter() - vAttackerPos).Length() ); |
|
|
|
float flCenter = RemapValClamped( flDistance / flOptimalDistance, 0.0, 2.0, 1.0, 0.0 ); |
|
if ( ( flCenter > 0.5 && bDoShortRangeDistanceIncrease ) || flCenter <= 0.5 ) |
|
{ |
|
if ( bitsDamage & DMG_NOCLOSEDISTANCEMOD ) |
|
{ |
|
if ( flCenter > 0.5 ) |
|
{ |
|
// Reduce the damage bonus at close range |
|
flCenter = RemapVal( flCenter, 0.5, 1.0, 0.5, 0.65 ); |
|
} |
|
} |
|
flMin = MAX( 0.0, flCenter - flRandomDamageSpread ); |
|
flMax = MIN( 1.0, flCenter + flRandomDamageSpread ); |
|
|
|
if ( bDebug ) |
|
{ |
|
Warning(" RANDOM: Dist %.2f, Ctr: %.2f, Min: %.2f, Max: %.2f\n", flDistance, flCenter, flMin, flMax ); |
|
} |
|
} |
|
else |
|
{ |
|
if ( bDebug ) |
|
{ |
|
Warning(" NO DISTANCE MOD: Dist %.2f, Ctr: %.2f, Min: %.2f, Max: %.2f\n", flDistance, flCenter, flMin, flMax ); |
|
} |
|
} |
|
} |
|
//Msg("Range: %.2f - %.2f\n", flMin, flMax ); |
|
float flRandomRangeVal; |
|
if ( tf_damage_disablespread.GetBool() || ( pTFAttacker && pTFAttacker->m_Shared.GetCarryingRuneType() == RUNE_PRECISION ) ) |
|
{ |
|
flRandomRangeVal = flMin + flRandomDamageSpread; |
|
} |
|
else |
|
{ |
|
flRandomRangeVal = RandomFloat( flMin, flMax ); |
|
} |
|
|
|
//if ( bDebug ) |
|
//{ |
|
// Warning( " Val: %.2f\n", flRandomRangeVal ); |
|
//} |
|
|
|
// Weapon Based Damage Mod |
|
if ( pWeapon && pAttacker && pAttacker->IsPlayer() ) |
|
{ |
|
switch ( pWeapon->GetWeaponID() ) |
|
{ |
|
// Rocket launcher only has half the bonus of the other weapons at short range |
|
// Rocket Launchers |
|
case TF_WEAPON_ROCKETLAUNCHER : |
|
case TF_WEAPON_ROCKETLAUNCHER_DIRECTHIT : |
|
case TF_WEAPON_PARTICLE_CANNON : |
|
if ( flRandomRangeVal > 0.5 ) |
|
{ |
|
flRandomDamage *= 0.5f; |
|
} |
|
break; |
|
case TF_WEAPON_PIPEBOMBLAUNCHER : // Stickies |
|
case TF_WEAPON_GRENADELAUNCHER : |
|
case TF_WEAPON_CANNON : |
|
case TF_WEAPON_STICKBOMB: |
|
if ( !( bitsDamage & DMG_NOCLOSEDISTANCEMOD ) ) |
|
{ |
|
flRandomDamage *= 0.2f; |
|
} |
|
break; |
|
case TF_WEAPON_SCATTERGUN : |
|
case TF_WEAPON_SODA_POPPER : |
|
case TF_WEAPON_PEP_BRAWLER_BLASTER : |
|
//case TF_WEAPON_HANDGUN_SCOUT_PRIMARY : // Shortstop |
|
// Scattergun gets 50% bonus at short range |
|
if ( flRandomRangeVal > 0.5 ) |
|
{ |
|
flRandomDamage *= 1.5f; |
|
} |
|
break; |
|
} |
|
} |
|
|
|
// Random damage variance. |
|
flDmgVariance = SimpleSplineRemapValClamped( flRandomRangeVal, 0, 1, -flRandomDamage, flRandomDamage ); |
|
if ( ( bDoShortRangeDistanceIncrease && flDmgVariance > 0.f ) || bDoLongRangeDistanceDecrease ) |
|
{ |
|
flDamage = info.GetDamage() + flDmgVariance; |
|
} |
|
|
|
if ( bDebug ) |
|
{ |
|
Warning(" Out: %.2f -> Final %.2f\n", flDmgVariance, flDamage ); |
|
} |
|
|
|
/* |
|
for ( float flVal = flMin; flVal <= flMax; flVal += 0.05 ) |
|
{ |
|
float flOut = SimpleSplineRemapValClamped( flVal, 0, 1, -flRandomDamage, flRandomDamage ); |
|
Msg("Val: %.2f, Out: %.2f, Dmg: %.2f\n", flVal, flOut, info.GetDamage() + flOut ); |
|
} |
|
*/ |
|
|
|
// Burn sounds are handled in ConditionThink() |
|
if ( !(bitsDamage & DMG_BURN ) && pVictim ) |
|
{ |
|
pVictim->SpeakConceptIfAllowed( MP_CONCEPT_HURT ); |
|
} |
|
|
|
|
|
// Save any bonus damage as a separate value |
|
float flCritDamage = 0.f; |
|
// Yes, it's weird that we sometimes fabs flDmgVariance. Here's why: In the case of a crit rocket, we |
|
// know that number will generally be negative due to dist or randomness. In this case, we want to track |
|
// that effect - even if we don't apply it. In the case of our crit rocket that normally would lose 50 |
|
// damage, we fabs'd so that we can account for it as a bonus - since it's present in a crit. |
|
float flBonusDamage = bForceCritFalloff ? 0.f : fabs( flDmgVariance ); |
|
CTFPlayer *pProvider = NULL; |
|
|
|
if ( info.GetCritType() == CTakeDamageInfo::CRIT_MINI ) |
|
{ |
|
// We should never have both of these flags set or Weird Things will happen with the damage numbers |
|
// that aren't clear to the players. Or us, really. |
|
Assert( !(bitsDamage & DMG_CRITICAL) ); |
|
|
|
if ( bDebug ) |
|
{ |
|
Warning( " MINICRIT: Dmg %.2f -> ", flDamage ); |
|
} |
|
|
|
COMPILE_TIME_ASSERT( TF_DAMAGE_MINICRIT_MULTIPLIER > 1.f ); |
|
flCritDamage = ( TF_DAMAGE_MINICRIT_MULTIPLIER - 1.f ) * flDamage; |
|
|
|
bitsDamage |= DMG_CRITICAL; |
|
info.AddDamageType( DMG_CRITICAL ); |
|
|
|
// Any condition assist stats to send out? |
|
if ( eDamageBonusCond < TF_COND_LAST ) |
|
{ |
|
if ( pVictim ) |
|
{ |
|
pProvider = ToTFPlayer( pVictim->m_Shared.GetConditionProvider( eDamageBonusCond ) ); |
|
if ( pProvider ) |
|
{ |
|
CTF_GameStats.Event_PlayerDamageAssist( pProvider, flCritDamage + flBonusDamage ); |
|
} |
|
} |
|
if ( pTFAttacker ) |
|
{ |
|
pProvider = ToTFPlayer( pTFAttacker->m_Shared.GetConditionProvider( eDamageBonusCond ) ); |
|
if ( pProvider && pProvider != pTFAttacker ) |
|
{ |
|
CTF_GameStats.Event_PlayerDamageAssist( pProvider, flCritDamage + flBonusDamage ); |
|
} |
|
} |
|
} |
|
|
|
if ( bDebug ) |
|
{ |
|
Warning( "reduced to %.2f before crit mult\n", flDamage ); |
|
} |
|
} |
|
|
|
if ( bCrit ) |
|
{ |
|
if ( info.GetCritType() != CTakeDamageInfo::CRIT_MINI ) |
|
{ |
|
COMPILE_TIME_ASSERT( TF_DAMAGE_CRIT_MULTIPLIER > 1.f ); |
|
flCritDamage = ( TF_DAMAGE_CRIT_MULTIPLIER - 1.f ) * flDamage; |
|
} |
|
|
|
if ( bDebug ) |
|
{ |
|
Warning( " CRITICAL! Damage: %.2f\n", flDamage ); |
|
} |
|
|
|
// Burn sounds are handled in ConditionThink() |
|
if ( !(bitsDamage & DMG_BURN ) && pVictim ) |
|
{ |
|
pVictim->SpeakConceptIfAllowed( MP_CONCEPT_HURT, "damagecritical:1" ); |
|
} |
|
|
|
if ( pTFAttacker && pTFAttacker->m_Shared.IsCritBoosted() ) |
|
{ |
|
pProvider = ToTFPlayer( pTFAttacker->m_Shared.GetConditionProvider( TF_COND_CRITBOOSTED ) ); |
|
if ( pProvider && pTFAttacker && pProvider != pTFAttacker ) |
|
{ |
|
CTF_GameStats.Event_PlayerDamageAssist( pProvider, flCritDamage + flBonusDamage ); |
|
} |
|
} |
|
} |
|
|
|
if ( pAttacker && pAttacker->IsPlayer() ) |
|
{ |
|
// Modify damage based on bonuses |
|
flDamage *= pTFAttacker->m_Shared.GetTmpDamageBonus(); |
|
} |
|
|
|
// Store the extra damage and update actual damage |
|
if ( bCrit || info.GetCritType() == CTakeDamageInfo::CRIT_MINI ) |
|
{ |
|
info.SetDamageBonus( flCritDamage + flBonusDamage, pProvider ); // Order-of-operations sensitive, but fine as long as TF_COND_CRITBOOSTED is last |
|
} |
|
|
|
// Crit-A-Cola and Steak Sandwich - only increase normal damage |
|
if ( pVictim && pVictim->m_Shared.InCond( TF_COND_ENERGY_BUFF ) && !bCrit && info.GetCritType() != CTakeDamageInfo::CRIT_MINI ) |
|
{ |
|
float flDmgMult = 1.f; |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flDmgMult, energy_buff_dmg_taken_multiplier ); |
|
flDamage *= flDmgMult; |
|
} |
|
|
|
info.SetDamage( flDamage + flCritDamage ); |
|
} |
|
|
|
if ( pTFAttacker && pTFAttacker->IsPlayerClass( TF_CLASS_SPY ) ) |
|
{ |
|
if ( pTFAttacker->GetActiveWeapon() ) |
|
{ |
|
int iAddCloakOnHit = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pTFAttacker->GetActiveWeapon(), iAddCloakOnHit, add_cloak_on_hit ); |
|
if ( iAddCloakOnHit > 0 ) |
|
{ |
|
pTFAttacker->m_Shared.AddToSpyCloakMeter( iAddCloakOnHit, true ); |
|
} |
|
} |
|
} |
|
|
|
|
|
// Apply on-hit attributes |
|
if ( pVictim && pAttacker && pAttacker->GetTeam() != pVictim->GetTeam() && pAttacker->IsPlayer() && pWeapon ) |
|
{ |
|
pWeapon->ApplyOnHitAttributes( pVictimBaseEntity, pTFAttacker, info ); |
|
} |
|
|
|
// Give assist points to the provider of any stun on the victim - up to half the damage, based on the amount of stun |
|
if ( pVictim && pVictim->m_Shared.InCond( TF_COND_STUNNED ) ) |
|
{ |
|
CTFPlayer *pProvider = ToTFPlayer( pVictim->m_Shared.GetConditionProvider( TF_COND_STUNNED ) ); |
|
if ( pProvider && pTFAttacker && pProvider != pTFAttacker ) |
|
{ |
|
float flStunAmount = pVictim->m_Shared.GetAmountStunned( TF_STUN_MOVEMENT ); |
|
if ( flStunAmount < 1.f && pVictim->m_Shared.IsControlStunned() ) |
|
flStunAmount = 1.f; |
|
|
|
int nAssistPoints = RemapValClamped( flStunAmount, 0.1f, 1.f, 1, ( info.GetDamage() / 2 ) ); |
|
if ( nAssistPoints ) |
|
{ |
|
CTF_GameStats.Event_PlayerDamageAssist( pProvider, nAssistPoints ); |
|
} |
|
} |
|
} |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
static bool CheckForDamageTypeImmunity( int nDamageType, CTFPlayer* pVictim, float &flDamageBase, float &flCritBonusDamage ) |
|
{ |
|
bool bImmune = false; |
|
if( nDamageType & (DMG_BURN|DMG_IGNITE) ) |
|
{ |
|
bImmune = pVictim->m_Shared.InCond( TF_COND_FIRE_IMMUNE ); |
|
} |
|
else if( nDamageType & (DMG_BULLET|DMG_BUCKSHOT) ) |
|
{ |
|
bImmune = pVictim->m_Shared.InCond( TF_COND_BULLET_IMMUNE ); |
|
} |
|
else if( nDamageType & DMG_BLAST ) |
|
{ |
|
bImmune = pVictim->m_Shared.InCond( TF_COND_BLAST_IMMUNE ); |
|
} |
|
|
|
if( bImmune ) |
|
{ |
|
flDamageBase = flCritBonusDamage = 0.f; |
|
|
|
IGameEvent* event = gameeventmanager->CreateEvent( "damage_resisted" ); |
|
if ( event ) |
|
{ |
|
event->SetInt( "entindex", pVictim->entindex() ); |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
|
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
static bool CheckMedicResist( ETFCond ePassiveCond, ETFCond eDeployedCond, CTFPlayer* pVictim, float flRawDamage, float& flDamageBase, bool bCrit, float& flCritBonusDamage ) |
|
{ |
|
// Might be a tank or some other object that's getting shot |
|
if( !pVictim || !pVictim->IsPlayer() ) |
|
return false; |
|
|
|
ETFCond eActiveCond; |
|
// Be in the condition! |
|
if( pVictim->m_Shared.InCond( eDeployedCond ) ) |
|
{ |
|
eActiveCond = eDeployedCond; |
|
} |
|
else if( pVictim->m_Shared.InCond( ePassiveCond ) ) |
|
{ |
|
eActiveCond = ePassiveCond; |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
|
|
// Get our condition provider |
|
CBaseEntity* pProvider = pVictim->m_Shared.GetConditionProvider( eActiveCond ); |
|
CTFPlayer* pTFProvider = ToTFPlayer( pProvider ); |
|
Assert( pTFProvider ); |
|
|
|
float flDamageScale = 0.f; |
|
//float flCritBarDeplete = 0.f; |
|
bool bUberResist = false; |
|
|
|
if( pTFProvider ) |
|
{ |
|
switch( eActiveCond ) |
|
{ |
|
case TF_COND_MEDIGUN_UBER_BULLET_RESIST: |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flDamageScale, medigun_bullet_resist_deployed ); |
|
bUberResist = true; |
|
// if ( bCrit ) |
|
// { |
|
// CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flCritBarDeplete, medigun_crit_bullet_percent_bar_deplete ); |
|
// } |
|
break; |
|
|
|
case TF_COND_MEDIGUN_SMALL_BULLET_RESIST: |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flDamageScale, medigun_bullet_resist_passive ); |
|
break; |
|
|
|
case TF_COND_MEDIGUN_UBER_BLAST_RESIST: |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flDamageScale, medigun_blast_resist_deployed ); |
|
bUberResist = true; |
|
//if( bCrit ) |
|
//{ |
|
// CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flCritBarDeplete, medigun_crit_blast_percent_bar_deplete ); |
|
//} |
|
break; |
|
|
|
case TF_COND_MEDIGUN_SMALL_BLAST_RESIST: |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flDamageScale, medigun_blast_resist_passive ); |
|
break; |
|
|
|
case TF_COND_MEDIGUN_UBER_FIRE_RESIST: |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flDamageScale, medigun_fire_resist_deployed ); |
|
bUberResist = true; |
|
// if( bCrit ) |
|
// { |
|
// CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flCritBarDeplete, medigun_crit_fire_percent_bar_deplete ); |
|
// } |
|
break; |
|
|
|
case TF_COND_MEDIGUN_SMALL_FIRE_RESIST: |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flDamageScale, medigun_fire_resist_passive ); |
|
break; |
|
} |
|
} |
|
|
|
if ( bUberResist && pVictim->m_Shared.InCond( TF_COND_HEALING_DEBUFF ) ) |
|
{ |
|
flDamageScale *= 0.75f; |
|
} |
|
|
|
flDamageScale = 1.f - flDamageScale; |
|
if( flDamageScale < 0.f ) |
|
flDamageScale = 0.f; |
|
|
|
//// Dont let the medic heal themselves when they take damage |
|
//if( pTFProvider && pTFProvider != pVictim ) |
|
//{ |
|
// // Heal the medic for 10% of the incoming damage |
|
// int nHeal = flRawDamage * 0.10f; |
|
// // Heal! |
|
// int iHealed = pTFProvider->TakeHealth( nHeal, DMG_GENERIC ); |
|
|
|
// // Tell them about it! |
|
// if ( iHealed ) |
|
// { |
|
// CTF_GameStats.Event_PlayerHealedOther( pTFProvider, iHealed ); |
|
// } |
|
|
|
// IGameEvent *event = gameeventmanager->CreateEvent( "player_healonhit" ); |
|
// if ( event ) |
|
// { |
|
// event->SetInt( "amount", nHeal ); |
|
// event->SetInt( "entindex", pTFProvider->entindex() ); |
|
// gameeventmanager->FireEvent( event ); |
|
// } |
|
//} |
|
|
|
IGameEvent* event = gameeventmanager->CreateEvent( "damage_resisted" ); |
|
if ( event ) |
|
{ |
|
event->SetInt( "entindex", pVictim->entindex() ); |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
|
|
if ( bCrit && pTFProvider && bUberResist ) |
|
{ |
|
flCritBonusDamage = ( pVictim->m_Shared.InCond( TF_COND_HEALING_DEBUFF ) ) ? flCritBonusDamage *= 0.25f : 0.f; |
|
|
|
//CWeaponMedigun* pMedigun = dynamic_cast<CWeaponMedigun*>( pTFProvider->Weapon_OwnsThisID( TF_WEAPON_MEDIGUN ) ); |
|
//if( pMedigun ) |
|
//{ |
|
// if( pMedigun->GetChargeLevel() > 0.f && pMedigun->IsReleasingCharge() ) |
|
// { |
|
// flCritBonusDamage = 0; |
|
// } |
|
// pMedigun->SubtractCharge( flCritBarDeplete ); |
|
//} |
|
} |
|
|
|
// Scale the damage! |
|
flDamageBase = flDamageBase * flDamageScale; |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
static void PotentiallyFireDamageMitigatedEvent( const CTFPlayer* pMitigator, const CTFPlayer* pDamaged, const CEconEntity* pMitigationProvidingEconItem, float flBeforeDamage, float flAfterDamage ) |
|
{ |
|
int nAmount = flBeforeDamage - flAfterDamage; |
|
// Nothing mitigated! |
|
if ( nAmount == 0 ) |
|
return; |
|
|
|
IGameEvent *pEvent = gameeventmanager->CreateEvent( "damage_mitigated" ); |
|
if ( pEvent ) |
|
{ |
|
item_definition_index_t nDefIndex = INVALID_ITEM_DEF_INDEX; |
|
if ( pMitigationProvidingEconItem && pMitigationProvidingEconItem->GetAttributeContainer() && pMitigationProvidingEconItem->GetAttributeContainer()->GetItem() ) |
|
{ |
|
nDefIndex = pMitigationProvidingEconItem->GetAttributeContainer()->GetItem()->GetItemDefinition()->GetDefinitionIndex(); |
|
} |
|
|
|
pEvent->SetInt( "mitigator", pMitigator ? pMitigator->GetUserID() : -1 ); |
|
pEvent->SetInt( "damaged", pDamaged ? pDamaged->GetUserID() : -1 ); |
|
pEvent->SetInt( "amount", nAmount ); |
|
pEvent->SetInt( "itemdefindex", nDefIndex ); |
|
gameeventmanager->FireEvent( pEvent, true ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
float CTFGameRules::ApplyOnDamageAliveModifyRules( const CTakeDamageInfo &info, CBaseEntity *pVictimBaseEntity, DamageModifyExtras_t& outParams ) |
|
{ |
|
CTFPlayer *pVictim = ToTFPlayer( pVictimBaseEntity ); |
|
CBaseEntity *pAttacker = info.GetAttacker(); |
|
CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker ); |
|
|
|
float flRealDamage = info.GetDamage(); |
|
|
|
if ( pVictimBaseEntity && pVictimBaseEntity->m_takedamage != DAMAGE_EVENTS_ONLY && pVictim ) |
|
{ |
|
int iDamageTypeBits = info.GetDamageType() & DMG_IGNITE; |
|
|
|
// Handle attributes that want to change our damage type, but only if we're taking damage from a non-DOT. This |
|
// stops fire DOT damage from constantly reigniting us. This will also prevent ignites from happening on the |
|
// damage *from-a-bleed-DOT*, but not from the bleed application attack. |
|
if ( !IsDOTDmg( info.GetDamageCustom() ) ) |
|
{ |
|
int iAddBurningDamageType = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iAddBurningDamageType, set_dmgtype_ignite ); |
|
if ( iAddBurningDamageType ) |
|
{ |
|
iDamageTypeBits |= DMG_IGNITE; |
|
} |
|
} |
|
|
|
// Start burning if we took ignition damage |
|
outParams.bIgniting = ( ( iDamageTypeBits & DMG_IGNITE ) && ( !pVictim || pVictim->GetWaterLevel() < WL_Waist ) ); |
|
|
|
if ( outParams.bIgniting && pVictim ) |
|
{ |
|
if ( pVictim->m_Shared.InCond( TF_COND_DISGUISED ) ) |
|
{ |
|
int iDisguiseNoBurn = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pVictim, iDisguiseNoBurn, disguise_no_burn ); |
|
if ( iDisguiseNoBurn == 1 ) |
|
{ |
|
// Do a hard out in the caller |
|
return -1; |
|
} |
|
} |
|
|
|
if ( pVictim->m_Shared.InCond( TF_COND_FIRE_IMMUNE ) ) |
|
{ |
|
// Do a hard out in the caller |
|
return -1; |
|
} |
|
} |
|
|
|
// When obscured by smoke, attacks have a chance to miss |
|
if ( pVictim && pVictim->m_Shared.InCond( TF_COND_OBSCURED_SMOKE ) ) |
|
{ |
|
if ( RandomInt( 1, 4 ) >= 2 ) |
|
{ |
|
flRealDamage = 0.f; |
|
|
|
pVictim->SpeakConceptIfAllowed( MP_CONCEPT_DODGE_SHOT ); |
|
|
|
if ( pTFAttacker ) |
|
{ |
|
CEffectData data; |
|
data.m_nHitBox = GetParticleSystemIndex( "miss_text" ); |
|
data.m_vOrigin = pVictim->WorldSpaceCenter() + Vector( 0.f , 0.f, 32.f ); |
|
data.m_vAngles = vec3_angle; |
|
data.m_nEntIndex = 0; |
|
|
|
CSingleUserRecipientFilter filter( pTFAttacker ); |
|
te->DispatchEffect( filter, 0.f, data.m_vOrigin, "ParticleEffect", data ); |
|
} |
|
|
|
// No damage |
|
return -1.f; |
|
} |
|
} |
|
|
|
// Proc invicibility upon being hit |
|
float flUberChance = 0.f; |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flUberChance, uber_on_damage_taken ); |
|
if( RandomFloat() < flUberChance ) |
|
{ |
|
pVictim->m_Shared.AddCond( TF_COND_INVULNERABLE_CARD_EFFECT, 3.f ); |
|
// Make sure we don't take any damage |
|
flRealDamage = 0.f; |
|
} |
|
|
|
// Resists and Boosts |
|
float flDamageBonus = info.GetDamageBonus(); |
|
float flDamageBase = flRealDamage - flDamageBonus; |
|
Assert( flDamageBase >= 0.f ); |
|
|
|
int iPierceResists = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iPierceResists, mod_pierce_resists_absorbs ); |
|
|
|
// This raw damage wont get scaled. Used for determining how much health to give resist medics. |
|
float flRawDamage = flDamageBase; |
|
|
|
// Check if we're immune |
|
outParams.bPlayDamageReductionSound = CheckForDamageTypeImmunity( info.GetDamageType(), pVictim, flDamageBase, flDamageBonus ); |
|
|
|
if ( !iPierceResists ) |
|
{ |
|
// Reduce only the crit portion of the damage with crit resist |
|
bool bCrit = ( info.GetDamageType() & DMG_CRITICAL ) > 0; |
|
if ( bCrit ) |
|
{ |
|
// Break the damage down and reassemble |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flDamageBonus, mult_dmgtaken_from_crit ); |
|
} |
|
|
|
// Apply general dmg type reductions. Should we only ever apply one of these? (Flaregun is DMG_BULLET|DMG_IGNITE, for instance) |
|
if ( info.GetDamageType() & (DMG_BURN|DMG_IGNITE) ) |
|
{ |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flDamageBase, mult_dmgtaken_from_fire ); |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim->GetActiveWeapon(), flDamageBase, mult_dmgtaken_from_fire_active ); |
|
|
|
// Check for medic resist |
|
outParams.bPlayDamageReductionSound = CheckMedicResist( TF_COND_MEDIGUN_SMALL_FIRE_RESIST, TF_COND_MEDIGUN_UBER_FIRE_RESIST, pVictim, flRawDamage, flDamageBase, bCrit, flDamageBonus ); |
|
} |
|
|
|
if ( pTFAttacker && pVictim && pVictim->m_Shared.InCond( TF_COND_BURNING ) ) |
|
{ |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFAttacker->GetActiveWeapon(), flDamageBase, mult_dmg_vs_burning ); |
|
} |
|
|
|
if ( (info.GetDamageType() & (DMG_BLAST) ) ) |
|
{ |
|
bool bReduceBlast = false; |
|
|
|
// If someone else shot us or we're in MvM |
|
if( pAttacker != pVictimBaseEntity || IsMannVsMachineMode() ) |
|
{ |
|
bReduceBlast = true; |
|
} |
|
|
|
if ( bReduceBlast ) |
|
{ |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flDamageBase, mult_dmgtaken_from_explosions ); |
|
|
|
// Check for medic resist |
|
outParams.bPlayDamageReductionSound = CheckMedicResist( TF_COND_MEDIGUN_SMALL_BLAST_RESIST, TF_COND_MEDIGUN_UBER_BLAST_RESIST, pVictim, flRawDamage, flDamageBase, bCrit, flDamageBonus ); |
|
} |
|
} |
|
|
|
if ( info.GetDamageType() & (DMG_BULLET|DMG_BUCKSHOT) ) |
|
{ |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flDamageBase, mult_dmgtaken_from_bullets ); |
|
|
|
// Check for medic resist |
|
outParams.bPlayDamageReductionSound = CheckMedicResist( TF_COND_MEDIGUN_SMALL_BULLET_RESIST, TF_COND_MEDIGUN_UBER_BULLET_RESIST, pVictim, flRawDamage, flDamageBase, bCrit, flDamageBonus ); |
|
} |
|
|
|
if ( info.GetDamageType() & DMG_MELEE ) |
|
{ |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flDamageBase, mult_dmgtaken_from_melee ); |
|
} |
|
|
|
if ( pVictim->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && pVictim->m_Shared.InCond( TF_COND_AIMING ) && ( ( pVictim->GetHealth() - flRealDamage ) / pVictim->GetMaxHealth() ) <= 0.5f ) |
|
{ |
|
float flOriginalDamage = flDamageBase; |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flDamageBase, spunup_damage_resistance ); |
|
if ( flOriginalDamage != flDamageBase ) |
|
{ |
|
pVictim->PlayDamageResistSound( flOriginalDamage, flDamageBase ); |
|
} |
|
} |
|
} |
|
|
|
// If the damage changed at all play the resist sound |
|
if ( flDamageBase != flRawDamage ) |
|
{ |
|
outParams.bPlayDamageReductionSound = true; |
|
} |
|
|
|
// Stomp flRealDamage with resist adjusted values |
|
flRealDamage = flDamageBase + flDamageBonus; |
|
|
|
// Some Powerups apply a damage multiplier. Backstabs are immune to resist protection |
|
if ( ( pVictim && info.GetDamageCustom() != TF_DMG_CUSTOM_BACKSTAB ) ) |
|
{ |
|
// Plague bleed damage is immune from resist calculation |
|
if ( ( !pVictim->m_Shared.InCond( TF_COND_PLAGUE ) && info.GetDamageCustom() != TF_DMG_CUSTOM_BLEEDING ) ) |
|
{ |
|
if ( pVictim->m_Shared.GetCarryingRuneType() == RUNE_RESIST ) |
|
{ |
|
flRealDamage *= 0.5f; |
|
outParams.bPlayDamageReductionSound = true; |
|
IGameEvent* event = gameeventmanager->CreateEvent( "damage_resisted" ); |
|
if ( event ) |
|
{ |
|
event->SetInt( "entindex", pVictim->entindex() ); |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
} |
|
else if ( ( pVictim->m_Shared.GetCarryingRuneType() == RUNE_VAMPIRE ) ) |
|
{ |
|
flRealDamage *= 0.75f; |
|
outParams.bPlayDamageReductionSound = true; |
|
} |
|
//Plague powerup carrier is resistant to infected enemies |
|
else if ( pTFAttacker && ( pVictim->m_Shared.GetCarryingRuneType() == RUNE_PLAGUE ) && pTFAttacker->m_Shared.InCond( TF_COND_PLAGUE ) ) |
|
{ |
|
flRealDamage *= 0.5f; |
|
outParams.bPlayDamageReductionSound = true; |
|
} |
|
} |
|
} |
|
|
|
|
|
// End Resists |
|
|
|
// Increased damage taken from all sources |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flRealDamage, mult_dmgtaken ); |
|
|
|
if ( info.GetInflictor() && info.GetInflictor()->IsBaseObject() ) |
|
{ |
|
CObjectSentrygun* pSentry = dynamic_cast<CObjectSentrygun*>( info.GetInflictor() ); |
|
if ( pSentry ) |
|
{ |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flRealDamage, dmg_from_sentry_reduced ); |
|
} |
|
} |
|
|
|
if ( IsMannVsMachineMode() ) |
|
{ |
|
if ( pTFAttacker && pTFAttacker->IsBot() && pAttacker != pVictimBaseEntity && pVictim && !pVictim->IsBot() ) |
|
{ |
|
flRealDamage *= g_pPopulationManager ? g_pPopulationManager->GetDamageMultiplier() : tf_populator_damage_multiplier.GetFloat(); |
|
} |
|
} |
|
|
|
// Heavy rage-based knockback+stun effect that also reduces their damage output |
|
if ( pTFAttacker && pTFAttacker->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) ) |
|
{ |
|
int iRage = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pTFAttacker, iRage, generate_rage_on_dmg ); |
|
if ( iRage && pTFAttacker->m_Shared.IsRageDraining() ) |
|
{ |
|
flRealDamage *= 0.5f; |
|
} |
|
} |
|
|
|
if ( pVictim && pTFAttacker && info.GetWeapon() ) |
|
{ |
|
CTFWeaponBase *pWeapon = pTFAttacker->GetActiveTFWeapon(); |
|
if ( pWeapon && pWeapon->GetWeaponID() == TF_WEAPON_SNIPERRIFLE && info.GetWeapon() == pWeapon ) |
|
{ |
|
CTFSniperRifle *pRifle = static_cast< CTFSniperRifle* >( info.GetWeapon() ); |
|
|
|
float flStun = 1.0f; |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pRifle, flStun, applies_snare_effect ); |
|
if ( flStun != 1.0f ) |
|
{ |
|
float flDuration = pRifle->GetJarateTime(); |
|
pVictim->m_Shared.StunPlayer( flDuration, flStun, TF_STUN_MOVEMENT, pTFAttacker ); |
|
} |
|
} |
|
} |
|
|
|
if ( pVictim && pVictim->GetActiveTFWeapon() ) |
|
{ |
|
if ( info.GetDamageType() & (DMG_CLUB) ) |
|
{ |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim->GetActiveTFWeapon(), flRealDamage, dmg_from_melee ); |
|
} |
|
else if ( info.GetDamageType() & (DMG_BLAST|DMG_BULLET|DMG_BUCKSHOT|DMG_IGNITE|DMG_SONIC) ) |
|
{ |
|
float flBeforeDamage = flRealDamage; |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim->GetActiveTFWeapon(), flRealDamage, dmg_from_ranged ); |
|
PotentiallyFireDamageMitigatedEvent( pVictim, pVictim, pVictim->GetActiveTFWeapon(), flBeforeDamage, flRealDamage ); |
|
} |
|
} |
|
|
|
outParams.bSendPreFeignDamage = false; |
|
if ( pVictim && pVictim->IsPlayerClass( TF_CLASS_SPY ) && ( info.GetDamageCustom() != TF_DMG_CUSTOM_TELEFRAG ) && !pVictim->IsTaunting() ) |
|
{ |
|
// STAGING_SPY |
|
// Reduce damage taken if we have recently feigned death. |
|
if ( pVictim->m_Shared.InCond( TF_COND_FEIGN_DEATH ) || pVictim->m_Shared.IsFeignDeathReady() ) |
|
{ |
|
// Damage reduction is proportional to cloak remaining (60%->20%) |
|
float flDamageReduction = RemapValClamped( pVictim->m_Shared.GetSpyCloakMeter(), 50.0f, 0.0f, tf_feign_death_damage_scale.GetFloat(), tf_stealth_damage_reduction.GetFloat() ); |
|
|
|
// On Activate Reduce Remaining Cloak by 50% |
|
if ( pVictim->m_Shared.IsFeignDeathReady() ) |
|
{ |
|
flDamageReduction = tf_feign_death_activate_damage_scale.GetFloat(); |
|
} |
|
outParams.bSendPreFeignDamage = true; |
|
|
|
float flBeforeflRealDamage = flRealDamage; |
|
|
|
flRealDamage *= flDamageReduction; |
|
|
|
CTFWeaponInvis *pWatch = (CTFWeaponInvis *) pVictim->Weapon_OwnsThisID( TF_WEAPON_INVIS ); |
|
PotentiallyFireDamageMitigatedEvent( pVictim, pVictim, pWatch, flBeforeflRealDamage, flRealDamage ); |
|
|
|
// Original damage would've killed the player, but the reduced damage wont |
|
if ( flBeforeflRealDamage >= pVictim->GetHealth() && flRealDamage < pVictim->GetHealth() ) |
|
{ |
|
IGameEvent *pEvent = gameeventmanager->CreateEvent( "deadringer_cheat_death" ); |
|
if ( pEvent ) |
|
{ |
|
pEvent->SetInt( "spy", pVictim->GetUserID() ); |
|
pEvent->SetInt( "attacker", pTFAttacker ? pTFAttacker->GetUserID() : -1 ); |
|
gameeventmanager->FireEvent( pEvent, true ); |
|
} |
|
} |
|
} |
|
// Standard Stealth gives small damage reduction |
|
else if ( pVictim->m_Shared.InCond( TF_COND_STEALTHED ) ) |
|
{ |
|
flRealDamage *= tf_stealth_damage_reduction.GetFloat(); |
|
} |
|
} |
|
|
|
if ( flRealDamage == 0.0f ) |
|
{ |
|
// Do a hard out in the caller |
|
return -1; |
|
} |
|
|
|
if ( pAttacker == pVictimBaseEntity && (info.GetDamageType() & DMG_BLAST) && |
|
info.GetDamagedOtherPlayers() == 0 && (info.GetDamageCustom() != TF_DMG_CUSTOM_TAUNTATK_GRENADE) ) |
|
{ |
|
// If we attacked ourselves, hurt no other players, and it is a blast, |
|
// check the attribute that reduces rocket jump damage. |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( info.GetAttacker(), flRealDamage, rocket_jump_dmg_reduction ); |
|
outParams.bSelfBlastDmg = true; |
|
} |
|
|
|
if ( pAttacker == pVictimBaseEntity ) |
|
{ |
|
enum |
|
{ |
|
kSelfBlastResponse_IgnoreProjectilesFromThisWeapon = 1, // the sticky jumper doesn't disable damage from other explosive weapons |
|
kSelfBlastResponse_IgnoreProjectilesFromAllWeapons = 2, // the rocket jumper doesn't have a special projectile type and so ignores all self-inflicted damage from explosive sources |
|
}; |
|
|
|
if ( info.GetWeapon() ) |
|
{ |
|
int iNoSelfBlastDamage = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iNoSelfBlastDamage, no_self_blast_dmg ); |
|
|
|
const bool bIgnoreThisSelfDamage = ( iNoSelfBlastDamage == kSelfBlastResponse_IgnoreProjectilesFromAllWeapons ) |
|
|| ( (iNoSelfBlastDamage == kSelfBlastResponse_IgnoreProjectilesFromThisWeapon) && (info.GetDamageCustom() == TF_DMG_CUSTOM_PRACTICE_STICKY) ); |
|
if ( bIgnoreThisSelfDamage ) |
|
{ |
|
flRealDamage = 0; |
|
} |
|
|
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( info.GetWeapon(), flRealDamage, blast_dmg_to_self ); |
|
} |
|
} |
|
|
|
// Precision Powerup removes self damage |
|
if ( pTFAttacker == pVictim && pTFAttacker->m_Shared.GetCarryingRuneType() == RUNE_PRECISION ) |
|
{ |
|
flRealDamage = 0.f; |
|
} |
|
|
|
if ( pTFAttacker && ( pTFAttacker != pVictim ) ) |
|
{ |
|
// Vampire Powerup collects health based on damage received on victim. Does not apply to self damage. Do it here to factor in victim resistance calculations |
|
if ( pTFAttacker->m_Shared.GetCarryingRuneType() == RUNE_VAMPIRE ) |
|
{ |
|
if ( flRealDamage > 0 ) |
|
{ |
|
if ( pTFAttacker->GetActiveTFWeapon()->GetWeaponID() == TF_WEAPON_MINIGUN || pTFAttacker->GetActiveTFWeapon()->GetWeaponID() == TF_WEAPON_FLAMETHROWER ) |
|
{ |
|
pTFAttacker->TakeHealth( ( flRealDamage * 0.6f ), DMG_GENERIC ); |
|
} |
|
else if ( info.GetDamageType() & DMG_MELEE ) |
|
{ |
|
pTFAttacker->TakeHealth( ( flRealDamage * 1.25f ), DMG_GENERIC ); |
|
} |
|
else |
|
{ |
|
pTFAttacker->TakeHealth( flRealDamage, DMG_GENERIC ); |
|
} |
|
} |
|
} |
|
|
|
int iHypeOnDamage = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pTFAttacker, iHypeOnDamage, hype_on_damage ); |
|
if ( iHypeOnDamage ) |
|
{ |
|
float flHype = RemapValClamped( flRealDamage, 1.f, 200.f, 1.f, 50.f ); |
|
pTFAttacker->m_Shared.SetScoutHypeMeter( Min( 100.f, flHype + pTFAttacker->m_Shared.GetScoutHypeMeter() ) ); |
|
} |
|
} |
|
} |
|
|
|
return flRealDamage; |
|
} |
|
|
|
// --------------------------------------------------------------------------------------------------- // |
|
// Voice helper |
|
// --------------------------------------------------------------------------------------------------- // |
|
|
|
class CVoiceGameMgrHelper : public IVoiceGameMgrHelper |
|
{ |
|
public: |
|
virtual bool CanPlayerHearPlayer( CBasePlayer *pListener, CBasePlayer *pTalker, bool &bProximity ) |
|
{ |
|
return TFGameRules()->TFVoiceManager( pListener, pTalker ); |
|
} |
|
}; |
|
CVoiceGameMgrHelper g_VoiceGameMgrHelper; |
|
IVoiceGameMgrHelper *g_pVoiceGameMgrHelper = &g_VoiceGameMgrHelper; |
|
|
|
// Load the objects.txt file. |
|
class CObjectsFileLoad : public CAutoGameSystem |
|
{ |
|
public: |
|
virtual bool Init() |
|
{ |
|
LoadObjectInfos( filesystem ); |
|
return true; |
|
} |
|
} g_ObjectsFileLoad; |
|
|
|
// --------------------------------------------------------------------------------------------------- // |
|
// Globals. |
|
// --------------------------------------------------------------------------------------------------- // |
|
/* |
|
// NOTE: the indices here must match TEAM_UNASSIGNED, TEAM_SPECTATOR, TF_TEAM_RED, TF_TEAM_BLUE, etc. |
|
char *sTeamNames[] = |
|
{ |
|
"Unassigned", |
|
"Spectator", |
|
"Red", |
|
"Blue" |
|
}; |
|
*/ |
|
// --------------------------------------------------------------------------------------------------- // |
|
// Global helper functions. |
|
// --------------------------------------------------------------------------------------------------- // |
|
|
|
// World.cpp calls this but we don't use it in TF. |
|
void InitBodyQue() |
|
{ |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
CTFGameRules::~CTFGameRules() |
|
{ |
|
// Note, don't delete each team since they are in the gEntList and will |
|
// automatically be deleted from there, instead. |
|
TFTeamMgr()->Shutdown(); |
|
ShutdownCustomResponseRulesDicts(); |
|
|
|
// clean up cached teleport locations |
|
m_mapTeleportLocations.PurgeAndDeleteElements(); |
|
|
|
// reset this only if we quit MvM to minimize the risk of breaking pub tournament |
|
if ( IsMannVsMachineMode() ) |
|
{ |
|
mp_tournament.SetValue( 0 ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::CheckTauntAchievement( CTFPlayer *pAchiever, int nGibs, int *pTauntCamAchievements ) |
|
{ |
|
if ( !pAchiever || !pAchiever->GetPlayerClass() ) |
|
return; |
|
|
|
int iClass = pAchiever->GetPlayerClass()->GetClassIndex(); |
|
if ( pTauntCamAchievements[ iClass ] ) |
|
{ |
|
bool bAwardAchievement = true; |
|
|
|
// for the Heavy achievement, the player needs to also be invuln |
|
if ( iClass == TF_CLASS_HEAVYWEAPONS && pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_HEAVY_FREEZECAM_TAUNT ) |
|
{ |
|
if ( !pAchiever->m_Shared.InCond( TF_COND_INVULNERABLE_WEARINGOFF ) && !pAchiever->m_Shared.InCond( TF_COND_INVULNERABLE ) ) |
|
{ |
|
bAwardAchievement = false; |
|
} |
|
} |
|
|
|
// for the Spy achievement, we must be in the cig lighter taunt |
|
if ( iClass == TF_CLASS_SPY && pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_SPY_FREEZECAM_FLICK ) |
|
{ |
|
if ( pAchiever->GetActiveTFWeapon() && pAchiever->GetActiveTFWeapon()->GetWeaponID() != TF_WEAPON_PDA_SPY ) |
|
{ |
|
bAwardAchievement = false; |
|
} |
|
} |
|
|
|
// for the two Sniper achievements, we need to check for specific taunts |
|
if ( iClass == TF_CLASS_SNIPER ) |
|
{ |
|
if ( pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_SNIPER_FREEZECAM_HAT ) |
|
{ |
|
if ( pAchiever->GetActiveTFWeapon() && pAchiever->GetActiveTFWeapon()->GetWeaponID() != TF_WEAPON_CLUB ) |
|
{ |
|
bAwardAchievement = false; |
|
} |
|
} |
|
else if ( pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_SNIPER_FREEZECAM_WAVE ) |
|
{ |
|
if ( pAchiever->GetActiveTFWeapon() && WeaponID_IsSniperRifle( pAchiever->GetActiveTFWeapon()->GetWeaponID() ) ) |
|
{ |
|
bAwardAchievement = false; |
|
} |
|
} |
|
} |
|
|
|
// For the Soldier achievements, we need to be doing a specific taunt, or have enough gibs onscreen |
|
if ( iClass == TF_CLASS_SOLDIER ) |
|
{ |
|
if ( pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_SOLDIER_FREEZECAM_TAUNT ) |
|
{ |
|
if ( pAchiever->GetActiveTFWeapon() && pAchiever->GetActiveTFWeapon()->GetWeaponID() != TF_WEAPON_SHOTGUN_SOLDIER ) |
|
{ |
|
bAwardAchievement = false; |
|
} |
|
} |
|
else if ( pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_SOLDIER_FREEZECAM_GIBS ) |
|
{ |
|
// Need at least 3 gibs on-screen |
|
if ( nGibs < 3 ) |
|
{ |
|
bAwardAchievement = false; |
|
} |
|
} |
|
} |
|
|
|
// for the two Demoman achievements, we need to check for specific taunts |
|
if ( iClass == TF_CLASS_DEMOMAN ) |
|
{ |
|
if ( pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_DEMOMAN_FREEZECAM_SMILE ) |
|
{ |
|
if ( pAchiever->GetActiveTFWeapon() && pAchiever->GetActiveTFWeapon()->GetWeaponID() != TF_WEAPON_GRENADELAUNCHER ) |
|
{ |
|
bAwardAchievement = false; |
|
} |
|
} |
|
else if ( pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_DEMOMAN_FREEZECAM_RUMP ) |
|
{ |
|
if ( pAchiever->GetActiveTFWeapon() && pAchiever->GetActiveTFWeapon()->GetAttributeContainer() ) |
|
{ |
|
// Needs to be the Scottish Defender |
|
CEconItemView *pItem = pAchiever->GetActiveTFWeapon()->GetAttributeContainer()->GetItem(); |
|
if ( pItem && pItem->IsValid() && pItem->GetItemDefIndex() != 130 ) // Scottish Defender is item index 130 |
|
{ |
|
bAwardAchievement = false; |
|
} |
|
} |
|
} |
|
} |
|
|
|
// for the Engineer achievement, we must be in the guitar taunt |
|
if ( iClass == TF_CLASS_ENGINEER && pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_ENGINEER_FREEZECAM_TAUNT ) |
|
{ |
|
if ( pAchiever->GetActiveTFWeapon() && pAchiever->GetActiveTFWeapon()->GetWeaponID() != TF_WEAPON_SENTRY_REVENGE ) |
|
{ |
|
bAwardAchievement = false; |
|
} |
|
} |
|
|
|
if ( bAwardAchievement ) |
|
{ |
|
pAchiever->AwardAchievement( pTauntCamAchievements[ iClass ] ); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::TFVoiceManager( CBasePlayer *pListener, CBasePlayer *pTalker ) |
|
{ |
|
// check coaching--we only want coaches and students to talk and listen to each other! |
|
CTFPlayer* pTFListener = (CTFPlayer*)pListener; |
|
CTFPlayer* pTFTalker = (CTFPlayer*)pTalker; |
|
if ( pTFListener->GetStudent() || pTFListener->GetCoach() || |
|
pTFTalker->GetStudent() || pTFTalker->GetCoach() ) |
|
{ |
|
if ( pTFListener->GetStudent() == pTFTalker || pTFTalker->GetStudent() == pTFListener || |
|
pTFListener->GetCoach() == pTalker || pTFTalker->GetCoach() == pTFListener ) |
|
{ |
|
return true; |
|
} |
|
return false; |
|
} |
|
|
|
// Always allow teams to hear each other in TD mode |
|
if ( IsMannVsMachineMode() ) |
|
return true; |
|
|
|
if ( !tf_gravetalk.GetBool() ) |
|
{ |
|
// Dead players can only be heard by other dead team mates but only if a match is in progress |
|
if ( State_Get() != GR_STATE_TEAM_WIN && State_Get() != GR_STATE_GAME_OVER ) |
|
{ |
|
if ( pTalker->IsAlive() == false ) |
|
{ |
|
if ( pListener->IsAlive() == false ) |
|
return ( pListener->InSameTeam( pTalker ) ); |
|
|
|
return false; |
|
} |
|
} |
|
} |
|
|
|
return ( pListener->InSameTeam( pTalker ) ); |
|
|
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: TF2 Specific Client Commands |
|
// Input : |
|
// Output : |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::ClientCommand( CBaseEntity *pEdict, const CCommand &args ) |
|
{ |
|
CTFPlayer *pPlayer = ToTFPlayer( pEdict ); |
|
|
|
const char *pcmd = args[0]; |
|
|
|
if ( IsInTournamentMode() == true && IsInPreMatch() == true ) |
|
{ |
|
if ( FStrEq( pcmd, "tournament_readystate" ) ) |
|
{ |
|
if ( IsMannVsMachineMode() ) |
|
return true; |
|
|
|
if ( UsePlayerReadyStatusMode() ) |
|
return true; |
|
|
|
if ( args.ArgC() < 2 ) |
|
return true; |
|
|
|
if ( pPlayer->GetTeamNumber() <= LAST_SHARED_TEAM ) |
|
return true; |
|
|
|
int iReadyState = atoi( args[1] ); |
|
|
|
//Already this state |
|
if ( iReadyState == (int)IsTeamReady( pPlayer->GetTeamNumber() ) ) |
|
return true; |
|
|
|
SetTeamReadyState( iReadyState == 1, pPlayer->GetTeamNumber() ); |
|
|
|
IGameEvent * event = gameeventmanager->CreateEvent( "tournament_stateupdate" ); |
|
|
|
if ( event ) |
|
{ |
|
event->SetInt( "userid", pPlayer->entindex() ); |
|
event->SetInt( "readystate", iReadyState ); |
|
event->SetBool( "namechange", 0 ); |
|
event->SetString( "oldname", " " ); |
|
event->SetString( "newname", " " ); |
|
|
|
gameeventmanager->FireEvent( event ); |
|
} |
|
|
|
if ( iReadyState == 0 ) |
|
{ |
|
m_flRestartRoundTime.Set( -1.f ); |
|
m_bAwaitingReadyRestart = true; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
if ( FStrEq( pcmd, "tournament_teamname" ) ) |
|
{ |
|
if ( IsMannVsMachineMode() ) |
|
return true; |
|
|
|
if ( args.ArgC() < 2 ) |
|
return true; |
|
|
|
if ( pPlayer->GetTeamNumber() <= LAST_SHARED_TEAM ) |
|
return true; |
|
|
|
const char *commandline = args.GetCommandString(); |
|
|
|
// find the rest of the command line past the bot index |
|
commandline = strstr( commandline, args[1] ); |
|
Assert( commandline ); |
|
|
|
char szName[MAX_TEAMNAME_STRING + 1] = { 0 }; |
|
Q_strncpy( szName, commandline, sizeof( szName )); |
|
|
|
|
|
if ( pPlayer->GetTeamNumber() == TF_TEAM_BLUE ) |
|
{ |
|
if ( FStrEq( szName, mp_tournament_blueteamname.GetString() ) == true ) |
|
return true; |
|
|
|
mp_tournament_blueteamname.SetValue( szName ); |
|
} |
|
else if ( pPlayer->GetTeamNumber() == TF_TEAM_RED ) |
|
{ |
|
if ( FStrEq( szName, mp_tournament_redteamname.GetString() ) == true ) |
|
return true; |
|
|
|
mp_tournament_redteamname.SetValue( szName ); |
|
} |
|
|
|
IGameEvent * event = gameeventmanager->CreateEvent( "tournament_stateupdate" ); |
|
|
|
if ( event ) |
|
{ |
|
event->SetInt( "userid", pPlayer->entindex() ); |
|
event->SetBool( "readystate", 0 ); |
|
event->SetBool( "namechange", 1 ); |
|
event->SetString( "newname", szName ); |
|
|
|
gameeventmanager->FireEvent( event ); |
|
} |
|
|
|
return true; |
|
} |
|
|
|
if ( FStrEq( pcmd, "tournament_player_readystate" ) ) |
|
{ |
|
if ( State_Get() != GR_STATE_BETWEEN_RNDS ) |
|
return true; |
|
|
|
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() ); |
|
if ( pMatchDesc && pMatchDesc->m_params.m_bAutoReady ) |
|
return true; |
|
|
|
// Make sure we have enough to allow ready mode commands |
|
if ( !PlayerReadyStatus_HaveMinPlayersToEnable() ) |
|
return true; |
|
|
|
if ( args.ArgC() < 2 ) |
|
return true; |
|
|
|
bool bReady = ( atoi( args[1] ) == 1 ); |
|
PlayerReadyStatus_UpdatePlayerState( pPlayer, bReady ); |
|
if ( bReady ) |
|
{ |
|
pPlayer->PlayReadySound(); |
|
} |
|
|
|
return true; |
|
} |
|
} |
|
|
|
if ( FStrEq( pcmd, "objcmd" ) ) |
|
{ |
|
if ( args.ArgC() < 3 ) |
|
return true; |
|
|
|
int entindex = atoi( args[1] ); |
|
edict_t* pEdict = INDEXENT(entindex); |
|
if ( pEdict ) |
|
{ |
|
CBaseEntity* pBaseEntity = GetContainingEntity(pEdict); |
|
CBaseObject* pObject = dynamic_cast<CBaseObject*>(pBaseEntity); |
|
|
|
if ( pObject ) |
|
{ |
|
// We have to be relatively close to the object too... |
|
|
|
// BUG! Some commands need to get sent without the player being near the object, |
|
// eg delayed dismantle commands. Come up with a better way to ensure players aren't |
|
// entering these commands in the console. |
|
|
|
//float flDistSq = pObject->GetAbsOrigin().DistToSqr( pPlayer->GetAbsOrigin() ); |
|
//if (flDistSq <= (MAX_OBJECT_SCREEN_INPUT_DISTANCE * MAX_OBJECT_SCREEN_INPUT_DISTANCE)) |
|
{ |
|
// Strip off the 1st two arguments and make a new argument string |
|
CCommand objectArgs( args.ArgC() - 2, &args.ArgV()[2]); |
|
pObject->ClientCommand( pPlayer, objectArgs ); |
|
} |
|
} |
|
} |
|
|
|
return true; |
|
} |
|
|
|
// Handle some player commands here as they relate more directly to gamerules state |
|
if ( FStrEq( pcmd, "nextmap" ) ) |
|
{ |
|
if ( pPlayer->m_flNextTimeCheck < gpGlobals->curtime ) |
|
{ |
|
char szNextMap[MAX_MAP_NAME]; |
|
|
|
if ( nextlevel.GetString() && *nextlevel.GetString() ) |
|
{ |
|
Q_strncpy( szNextMap, nextlevel.GetString(), sizeof( szNextMap ) ); |
|
} |
|
else |
|
{ |
|
GetNextLevelName( szNextMap, sizeof( szNextMap ) ); |
|
} |
|
|
|
ClientPrint( pPlayer, HUD_PRINTTALK, "#TF_nextmap", szNextMap); |
|
|
|
pPlayer->m_flNextTimeCheck = gpGlobals->curtime + 1; |
|
} |
|
|
|
return true; |
|
} |
|
else if ( FStrEq( pcmd, "timeleft" ) ) |
|
{ |
|
if ( pPlayer->m_flNextTimeCheck < gpGlobals->curtime ) |
|
{ |
|
if ( mp_timelimit.GetInt() > 0 ) |
|
{ |
|
int iTimeLeft = GetTimeLeft(); |
|
|
|
char szMinutes[5]; |
|
char szSeconds[3]; |
|
|
|
if ( iTimeLeft <= 0 ) |
|
{ |
|
Q_snprintf( szMinutes, sizeof(szMinutes), "0" ); |
|
Q_snprintf( szSeconds, sizeof(szSeconds), "00" ); |
|
} |
|
else |
|
{ |
|
Q_snprintf( szMinutes, sizeof(szMinutes), "%d", iTimeLeft / 60 ); |
|
Q_snprintf( szSeconds, sizeof(szSeconds), "%02d", iTimeLeft % 60 ); |
|
} |
|
|
|
ClientPrint( pPlayer, HUD_PRINTTALK, "#TF_timeleft", szMinutes, szSeconds ); |
|
} |
|
else |
|
{ |
|
ClientPrint( pPlayer, HUD_PRINTTALK, "#TF_timeleft_nolimit" ); |
|
} |
|
|
|
pPlayer->m_flNextTimeCheck = gpGlobals->curtime + 1; |
|
} |
|
return true; |
|
} |
|
#ifdef STAGING_ONLY |
|
else if ( FStrEq( pcmd, "mvm_allupgrades" ) ) |
|
{ |
|
if ( GameModeUsesUpgrades() && g_hUpgradeEntity ) |
|
{ |
|
g_hUpgradeEntity->GrantOrRemoveAllUpgrades( pPlayer ); |
|
} |
|
|
|
return true; |
|
} |
|
#endif |
|
else if( pPlayer->ClientCommand( args ) ) |
|
{ |
|
return true; |
|
} |
|
|
|
return BaseClass::ClientCommand( pEdict, args ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::LevelShutdown() |
|
{ |
|
if ( IsInTraining() ) |
|
{ |
|
mp_humans_must_join_team.SetValue( "any" ); |
|
training_can_build_sentry.Revert(); |
|
training_can_build_dispenser.Revert(); |
|
training_can_build_tele_entrance.Revert(); |
|
training_can_build_tele_exit.Revert(); |
|
training_can_destroy_buildings.Revert(); |
|
training_can_pickup_sentry.Revert(); |
|
training_can_pickup_dispenser.Revert(); |
|
training_can_pickup_tele_entrance.Revert(); |
|
training_can_pickup_tele_exit.Revert(); |
|
training_can_select_weapon_primary.Revert(); |
|
training_can_select_weapon_secondary.Revert(); |
|
training_can_select_weapon_melee.Revert(); |
|
training_can_select_weapon_building.Revert(); |
|
training_can_select_weapon_pda.Revert(); |
|
training_can_select_weapon_item1.Revert(); |
|
training_can_select_weapon_item2.Revert(); |
|
tf_training_client_message.Revert(); |
|
} |
|
TheTFBots().LevelShutdown(); |
|
hide_server.Revert(); |
|
|
|
DuelMiniGame_LevelShutdown(); |
|
GameCoordinator_NotifyLevelShutdown(); |
|
|
|
g_TFGameModeHistory.SetPrevState( m_nGameType ); |
|
|
|
if ( m_pUpgrades ) |
|
{ |
|
UTIL_Remove( m_pUpgrades ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::Think() |
|
{ |
|
|
|
if ( m_bMapCycleNeedsUpdate ) |
|
{ |
|
m_bMapCycleNeedsUpdate = false; |
|
LoadMapCycleFile(); |
|
} |
|
|
|
if ( g_fGameOver ) |
|
{ |
|
if ( UsePlayerReadyStatusMode() && !IsMannVsMachineMode() ) |
|
{ |
|
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() ); |
|
|
|
static int nLastTimeSent = -1; |
|
int nTimeLeft = ( m_flStateTransitionTime - gpGlobals->curtime ); |
|
int nTimePassed = gpGlobals->curtime - m_flLastRoundStateChangeTime; |
|
if ( pMatchDesc && pMatchDesc->m_params.m_pszMatchEndKickWarning && nTimeLeft <= 50 && nTimeLeft % 10 == 0 && nTimeLeft != nLastTimeSent ) |
|
{ |
|
nLastTimeSent = nTimeLeft; |
|
CBroadcastRecipientFilter filter; |
|
UTIL_ClientPrintFilter( filter, HUD_PRINTTALK, pMatchDesc->m_params.m_pszMatchEndKickWarning, CFmtStr( "%d", nTimeLeft ) ); |
|
} |
|
|
|
if ( BAttemptMapVoteRollingMatch() ) |
|
{ |
|
const CMatchInfo* pMatch = GTFGCClientSystem()->GetMatch(); |
|
if ( pMatch && pMatch->GetNumActiveMatchPlayers() == 0 ) |
|
{ |
|
Msg( "All players left during next map voting period. Ending match.\n" ); |
|
GTFGCClientSystem()->EndManagedMatch( /* bKickPlayersToParties */ false ); |
|
Assert( IsManagedMatchEnded() ); |
|
m_bMatchEnded.Set( true ); |
|
return; |
|
} |
|
|
|
if ( m_eRematchState == NEXT_MAP_VOTE_STATE_WAITING_FOR_USERS_TO_VOTE ) |
|
{ |
|
bool bVotePeriodExpired = false; |
|
// Judgment time has arrived. Force a result below |
|
if ( nTimePassed == tf_mm_next_map_vote_time.GetInt() ) |
|
{ |
|
bVotePeriodExpired = true; |
|
} |
|
|
|
int nVotes[ EUserNextMapVote::NUM_VOTE_STATES ]; |
|
EUserNextMapVote eWinningVote = GetWinningVote( nVotes ); |
|
|
|
if ( bVotePeriodExpired || |
|
( nVotes[ USER_NEXT_MAP_VOTE_UNDECIDED ] == 0 && eWinningVote != USER_NEXT_MAP_VOTE_UNDECIDED ) ) |
|
{ |
|
CBroadcastRecipientFilter filter; |
|
|
|
const MapDef_t *pMap = NULL; |
|
if ( eWinningVote == USER_NEXT_MAP_VOTE_UNDECIDED ) |
|
{ |
|
// Nobody voted! We're playing on the same map again by default |
|
pMap = GetItemSchema()->GetMasterMapDefByName( STRING( gpGlobals->mapname ) ); |
|
} |
|
else |
|
{ |
|
pMap = GetItemSchema()->GetMasterMapDefByIndex( GetNextMapVoteOption( eWinningVote ) ); |
|
} |
|
|
|
if ( pMap == NULL ) |
|
{ |
|
Assert( !"We somehow didn't pick a new map to rotate to! Default to the current one" ); |
|
pMap = GetItemSchema()->GetMasterMapDefByName( STRING( gpGlobals->mapname ) ); |
|
} |
|
|
|
if ( pMap ) |
|
{ |
|
m_eRematchState = NEXT_MAP_VOTE_STATE_MAP_CHOSEN_PAUSE; |
|
GTFGCClientSystem()->RequestNewMatchForLobby( pMap ); |
|
} |
|
} |
|
} |
|
else if ( m_eRematchState == NEXT_MAP_VOTE_STATE_MAP_CHOSEN_PAUSE ) |
|
{ |
|
// CTFGCServerSystem is in control at this point |
|
} |
|
} |
|
|
|
if ( gpGlobals->curtime > m_flStateTransitionTime || !BHavePlayers() ) |
|
{ |
|
nLastTimeSent = -1; |
|
if ( pMatchDesc ) |
|
{ |
|
// Matchmaking path |
|
pMatchDesc->PostMatchClearServerSettings(); |
|
} |
|
else |
|
{ |
|
// Readymode (Tournament) path |
|
g_fGameOver = false; |
|
m_bAllowBetweenRounds = true; |
|
State_Transition( GR_STATE_RESTART ); |
|
SetInWaitingForPlayers( true ); |
|
} |
|
return; |
|
} |
|
} |
|
|
|
if ( ( m_flMatchSummaryTeleportTime > 0 ) && ( gpGlobals->curtime > m_flMatchSummaryTeleportTime ) ) |
|
{ |
|
m_flMatchSummaryTeleportTime = -1.f; |
|
MatchSummaryTeleport(); |
|
} |
|
} |
|
else |
|
{ |
|
if ( gpGlobals->curtime > m_flNextPeriodicThink ) |
|
{ |
|
if ( State_Get() != GR_STATE_BONUS && State_Get() != GR_STATE_TEAM_WIN && State_Get() != GR_STATE_GAME_OVER && IsInWaitingForPlayers() == false ) |
|
{ |
|
if ( CheckCapsPerRound() ) |
|
return; |
|
} |
|
} |
|
|
|
// These network variables mirror the MM system's match state for client's sake. Gamerules should still |
|
// be aware of when these change, either because we caused it or via a callback. This warning will |
|
// detect desync. (Ideally we'd have the ability to just share between the client GC system and server |
|
// GC system directly without passing things through gamerules) |
|
if ( m_bMatchEnded != IsManagedMatchEnded() ) |
|
{ |
|
Assert( false ); |
|
Warning( "Mirrored Match parameters on gamerules don't match MatchInfo\n" ); |
|
m_bMatchEnded.Set( IsManagedMatchEnded() ); |
|
} |
|
|
|
if ( GTFGCClientSystem()->GetMatch() && GetCurrentMatchGroup() != (EMatchGroup)m_nMatchGroupType.Get() ) |
|
{ |
|
Assert( false ); |
|
Warning( "Mirrored Match parameters on gamerules don't match MatchInfo\n" ); |
|
m_nMatchGroupType.Set( GetCurrentMatchGroup() ); |
|
} |
|
|
|
// Managed matches (MvM and competitive) abandon thing |
|
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch(); |
|
bool bEveryoneSafeToLeave = true; |
|
if ( pMatch ) |
|
{ |
|
// Send current safe-to-leave flags down from the GCServerSystem |
|
for ( int i = 1; i <= gpGlobals->maxClients; ++i ) |
|
{ |
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
if ( !pPlayer ) |
|
{ continue; } |
|
|
|
CSteamID steamID; |
|
bool bSafe = !pMatch || !pPlayer->GetSteamID( &steamID ) || pMatch->BPlayerSafeToLeaveMatch( steamID ); |
|
|
|
pPlayer->SetMatchSafeToLeave( bSafe ); |
|
bEveryoneSafeToLeave = bEveryoneSafeToLeave && bSafe; |
|
} |
|
} |
|
|
|
if ( IsCompetitiveMode() ) |
|
{ |
|
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() ); |
|
Assert( pMatch ); // Should not be in competitive mode without a match |
|
|
|
// |
|
// Check if this is mode requires a complete match, but doesn't have one |
|
// |
|
bool bEndMatch = false; |
|
int nActiveMatchPlayers = pMatch->GetNumActiveMatchPlayers(); |
|
int nMissingPlayers = pMatch->GetCanonicalMatchSize() - nActiveMatchPlayers; |
|
if ( pMatchDesc->m_params.m_bRequireCompleteMatch && |
|
!IsManagedMatchEnded() && |
|
nMissingPlayers ) |
|
{ |
|
// See if we are requesting late join right now, and give that time to work |
|
if ( pMatchDesc->ShouldRequestLateJoin() ) |
|
{ |
|
// End match if GC system didn't request late join in response to players leaving |
|
auto *pGCSys = GTFGCClientSystem(); |
|
double flRequestedLateJoin = pGCSys->GetTimeRequestedLateJoin(); |
|
|
|
if ( flRequestedLateJoin == -1.f ) |
|
{ |
|
bEndMatch = true; |
|
Msg( "Failed to request late join, ending competitive match\n" ); |
|
} |
|
else |
|
{ |
|
// Otherwise, since we can't proceed without players, apply a timeout after which we'll |
|
// cancel the match and release these players. The time to wait is shorter if the GC |
|
// hasn't confirmed our late join request, so we're not spending the full time waiting |
|
// when the GC is just non-responsive. |
|
double flTimeWaitingForLateJoin = CRTime::RTime32TimeCur() - flRequestedLateJoin; |
|
bool bGotLateJoin = pGCSys->BLateJoinEligible(); |
|
double flWaitLimit = bGotLateJoin ? tf_competitive_required_late_join_timeout.GetFloat() |
|
: tf_competitive_required_late_join_confirm_timeout.GetFloat(); |
|
if ( flTimeWaitingForLateJoin > flWaitLimit ) |
|
{ |
|
Msg( "Exceeded wait time limit for late joiners, canceling match\n" ); |
|
bEndMatch = true; |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
// Can't request late joiners, tank match if number of active players get below some threshold |
|
int iRedActive = 0; |
|
int iBlueActive = 0; |
|
for ( int idxPlayer = 0; idxPlayer < pMatch->GetNumTotalMatchPlayers(); idxPlayer++ ) |
|
{ |
|
CMatchInfo::PlayerMatchData_t *pMatchPlayer = pMatch->GetMatchDataForPlayer( idxPlayer ); |
|
if ( !pMatchPlayer->bDropped ) |
|
{ |
|
int iTeam = GetGameTeamForGCTeam( pMatchPlayer->eGCTeam ); |
|
if ( iTeam == TF_TEAM_RED ) |
|
iRedActive++; |
|
else |
|
iBlueActive++; |
|
} |
|
} |
|
|
|
int iTeamSize = pMatch->GetCanonicalMatchSize() / 2; |
|
if ( iRedActive == 0 || iBlueActive == 0 || ( iTeamSize - iRedActive ) > tf_mm_abandoned_players_per_team_max.GetInt() || ( iTeamSize - iBlueActive ) > tf_mm_abandoned_players_per_team_max.GetInt() ) |
|
{ |
|
Msg( "Match type requires a complete match, but there are not enough active players left and we are not requesting late join. Stopping match.\n" ); |
|
bEndMatch = true; |
|
} |
|
} |
|
} |
|
else if ( !IsManagedMatchEnded() && nActiveMatchPlayers < 1 ) |
|
{ |
|
// For non-complete mode, just stop the match if we lose all players |
|
Msg( "Competitive managed match in progress, but no remaining match players. Stopping match.\n" ); |
|
bEndMatch = true; |
|
} |
|
|
|
if ( bEndMatch ) |
|
{ |
|
StopCompetitiveMatch( CMsgGC_Match_Result_Status_MATCH_FAILED_ABANDON ); |
|
} |
|
else |
|
{ |
|
// If the match was ended but we're still playing, kick off a timer to remind people that |
|
// they're in a dead match. |
|
AssertMsg( !IsManagedMatchEnded() || ( pMatch->BMatchTerminated() && bEveryoneSafeToLeave ), |
|
"Expect everyone to be safe to leave and the match info to reflect that after the match is over" ); |
|
bool bGameRunning = ( State_Get() == GR_STATE_BETWEEN_RNDS || State_Get() == GR_STATE_RND_RUNNING ); |
|
bool bDeadMatch = bGameRunning && IsManagedMatchEnded() && pMatch->BMatchTerminated() && bEveryoneSafeToLeave; |
|
if ( bDeadMatch && ( m_flSafeToLeaveTimer == -.1f || |
|
m_flSafeToLeaveTimer - gpGlobals->curtime <= 0.f ) ) |
|
{ |
|
// Periodic nag event |
|
m_flSafeToLeaveTimer = gpGlobals->curtime + 30.f; |
|
IGameEvent *pEvent = gameeventmanager->CreateEvent( "player_abandoned_match" ); |
|
if ( pEvent ) |
|
{ |
|
pEvent->SetBool( "game_over", false ); |
|
gameeventmanager->FireEvent( pEvent ); |
|
} |
|
} |
|
} |
|
|
|
// Handle re-spawning the players after the doors have shut at the beginning of a match |
|
if ( ( m_flCompModeRespawnPlayersAtMatchStart > 0 ) && ( m_flCompModeRespawnPlayersAtMatchStart < gpGlobals->curtime ) ) |
|
{ |
|
for ( int i = 1; i <= MAX_PLAYERS; i++ ) |
|
{ |
|
CTFPlayer *pPlayer = static_cast<CTFPlayer*>( UTIL_PlayerByIndex( i ) ); |
|
if ( !pPlayer ) |
|
continue; |
|
|
|
pPlayer->RemoveAllOwnedEntitiesFromWorld(); |
|
pPlayer->ForceRespawn(); |
|
} |
|
|
|
m_flCompModeRespawnPlayersAtMatchStart = -1.f; |
|
} |
|
} |
|
} |
|
|
|
if ( g_bRandomMap == true ) |
|
{ |
|
g_bRandomMap = false; |
|
|
|
char szNextMap[MAX_MAP_NAME]; |
|
GetNextLevelName( szNextMap, sizeof(szNextMap), true ); |
|
IncrementMapCycleIndex(); |
|
|
|
ChangeLevelToMap( szNextMap ); |
|
|
|
return; |
|
} |
|
|
|
if ( IsInArenaMode() == true ) |
|
{ |
|
if ( m_flSendNotificationTime > 0.0f && m_flSendNotificationTime <= gpGlobals->curtime ) |
|
{ |
|
Arena_SendPlayerNotifications(); |
|
} |
|
} |
|
|
|
// periodically count up the fake clients and set the bot_count cvar to update server tags |
|
if ( m_botCountTimer.IsElapsed() ) |
|
{ |
|
m_botCountTimer.Start( 5.0f ); |
|
|
|
int botCount = 0; |
|
for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ ) |
|
{ |
|
CTFPlayer *player = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
|
|
if ( player && player->IsFakeClient() ) |
|
{ |
|
++botCount; |
|
} |
|
} |
|
|
|
tf_bot_count.SetValue( botCount ); |
|
} |
|
|
|
#ifdef GAME_DLL |
|
#ifdef _DEBUG |
|
if ( tf_debug_ammo_and_health.GetBool() ) |
|
{ |
|
CBaseEntity *ent; |
|
|
|
for( int i=0; i<m_healthVector.Count(); ++i ) |
|
{ |
|
ent = m_healthVector[i]; |
|
if ( ent ) |
|
{ |
|
NDebugOverlay::Cross3D( ent->WorldSpaceCenter(), 10.0f, 0, 255, 0, true, 0.1f ); |
|
} |
|
} |
|
|
|
for( int i=0; i<m_ammoVector.Count(); ++i ) |
|
{ |
|
ent = m_ammoVector[i]; |
|
if ( ent ) |
|
{ |
|
NDebugOverlay::Cross3D( ent->WorldSpaceCenter(), 10.0f, 0, 0, 255, true, 0.1f ); |
|
} |
|
} |
|
} |
|
#endif // _DEBUG |
|
|
|
if ( g_voteController ) |
|
{ |
|
ManageServerSideVoteCreation(); |
|
} |
|
|
|
// ... |
|
if ( tf_item_based_forced_holiday.GetInt() == kHoliday_Halloween && engine->Time() >= g_fEternaweenAutodisableTime ) |
|
{ |
|
if ( GCClientSystem() ) |
|
{ |
|
GCSDK::CProtoBufMsg<CMsgGC_GameServer_ServerModificationItemExpired> msg( k_EMsgGC_GameServer_ServerModificationItemExpired ); |
|
msg.Body().set_modification_type( kGameServerModificationItem_Halloween ); |
|
GCClientSystem()->BSendMessage( msg ); |
|
} |
|
|
|
tf_item_based_forced_holiday.SetValue( kHoliday_None ); |
|
FlushAllAttributeCaches(); |
|
} |
|
|
|
// play the bomb alarm if we need to |
|
if ( m_bMannVsMachineAlarmStatus ) |
|
{ |
|
if ( m_flNextFlagAlert < gpGlobals->curtime ) |
|
{ |
|
if ( PlayThrottledAlert( 255, "Announcer.MVM_Bomb_Alert_Near_Hatch", 5.0f ) ) |
|
{ |
|
m_flNextFlagAlarm = gpGlobals->curtime + 3.0; |
|
m_flNextFlagAlert = gpGlobals->curtime + 20.0f; |
|
} |
|
} |
|
|
|
if ( m_flNextFlagAlarm < gpGlobals->curtime ) |
|
{ |
|
m_flNextFlagAlarm = gpGlobals->curtime + 3.0; |
|
|
|
BroadcastSound( 255, "MVM.BombWarning" ); |
|
} |
|
} |
|
else if ( m_flNextFlagAlarm > 0.0f ) |
|
{ |
|
m_flNextFlagAlarm = 0.0f; |
|
m_flNextFlagAlert = gpGlobals->curtime + 5.0f; |
|
} |
|
|
|
if ( m_bPowerupImbalanceMeasuresRunning ) |
|
{ |
|
if ( m_flTimeToStopImbalanceMeasures < gpGlobals->curtime ) |
|
{ |
|
PowerupTeamImbalance( TEAM_UNASSIGNED ); // passing TEAM_UNASSIGNED will fire the ImbalanceMeasuresOver output |
|
m_bPowerupImbalanceMeasuresRunning = false; |
|
} |
|
} |
|
|
|
PeriodicHalloweenUpdate(); |
|
SpawnHalloweenBoss(); |
|
|
|
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) ) |
|
{ |
|
if ( ( State_Get() == GR_STATE_RND_RUNNING ) && ( !m_bHelltowerPlayersInHell ) && ( m_helltowerTimer.IsElapsed() ) ) |
|
{ |
|
// Play our Halloween winning/losing lines for the teams |
|
int iWinningTeam = TEAM_UNASSIGNED; |
|
bool bRareLine = ( RandomFloat( 0, 1 ) < HELLTOWER_RARE_LINE_CHANCE ); |
|
float flRedProgress = 0.0f, flBlueProgress = 0.0f; |
|
for ( int i = 0 ; i < ITFTeamTrainWatcher::AutoList().Count() ; ++i ) |
|
{ |
|
CTeamTrainWatcher *pTrainWatcher = static_cast< CTeamTrainWatcher* >( ITFTeamTrainWatcher::AutoList()[i] ); |
|
if ( !pTrainWatcher->IsDisabled() ) |
|
{ |
|
if ( pTrainWatcher->GetTeamNumber() == TF_TEAM_RED ) |
|
{ |
|
flRedProgress = pTrainWatcher->GetTrainDistanceAlongTrack(); |
|
} |
|
else |
|
{ |
|
flBlueProgress = pTrainWatcher->GetTrainDistanceAlongTrack(); |
|
} |
|
} |
|
} |
|
|
|
if ( flRedProgress > flBlueProgress ) |
|
{ |
|
iWinningTeam = TF_TEAM_RED; |
|
} |
|
else if ( flBlueProgress > flRedProgress ) |
|
{ |
|
iWinningTeam = TF_TEAM_BLUE; |
|
} |
|
|
|
int iRedLine = HELLTOWER_VO_RED_MISC; |
|
int iBlueLine = HELLTOWER_VO_BLUE_MISC; |
|
|
|
// should we play the misc lines or the winning/losing lines? |
|
if ( ( iWinningTeam == TEAM_UNASSIGNED ) || ( RandomFloat( 0, 1 ) < HELLTOWER_MISC_CHANCE ) ) |
|
{ |
|
if ( bRareLine ) |
|
{ |
|
iRedLine = HELLTOWER_VO_RED_MISC_RARE; |
|
iBlueLine = HELLTOWER_VO_BLUE_MISC_RARE; |
|
} |
|
} |
|
else |
|
{ |
|
// play a winning/losing line |
|
iRedLine = ( iWinningTeam == TF_TEAM_RED ) ? HELLTOWER_VO_RED_WINNING : HELLTOWER_VO_RED_LOSING; |
|
iBlueLine = ( iWinningTeam == TF_TEAM_BLUE ) ? HELLTOWER_VO_BLUE_WINNING : HELLTOWER_VO_BLUE_LOSING; |
|
|
|
if ( bRareLine ) |
|
{ |
|
iRedLine = ( iWinningTeam == TF_TEAM_RED ) ? HELLTOWER_VO_RED_WINNING_RARE : HELLTOWER_VO_RED_LOSING_RARE; |
|
iBlueLine = ( iWinningTeam == TF_TEAM_BLUE ) ? HELLTOWER_VO_BLUE_WINNING_RARE : HELLTOWER_VO_BLUE_LOSING_RARE; |
|
|
|
} |
|
} |
|
|
|
PlayHelltowerAnnouncerVO( iRedLine, iBlueLine ); |
|
m_helltowerTimer.Start( HELLTOWER_TIMER_INTERVAL ); |
|
} |
|
} |
|
else if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) ) |
|
{ |
|
if ( ( State_Get() == GR_STATE_RND_RUNNING ) && m_doomsdaySetupTimer.HasStarted() && m_doomsdaySetupTimer.IsElapsed() ) |
|
{ |
|
m_doomsdaySetupTimer.Invalidate(); |
|
|
|
const char *pszSound = NULL; |
|
switch( GetRoundsPlayed() ) |
|
{ |
|
case 0: |
|
pszSound = "sf14.Merasmus.Start.FirstRound"; |
|
if ( RandomInt( 1, 10 ) == 1 ) |
|
{ |
|
pszSound = "sf14.Merasmus.Start.FirstRoundRare"; |
|
} |
|
break; |
|
case 1: |
|
pszSound = "sf14.Merasmus.Start.SecondRound"; |
|
break; |
|
case 2: |
|
default: |
|
pszSound = "sf14.Merasmus.Start.ThirdRoundAndBeyond"; |
|
break; |
|
} |
|
|
|
if ( pszSound && pszSound[0] ) |
|
{ |
|
BroadcastSound( 255, pszSound ); |
|
} |
|
} |
|
} |
|
|
|
#ifdef TF_RAID_MODE |
|
// This check is here for Boss battles that don't have a tf_raid_logic entity |
|
if ( IsBossBattleMode() && !IsInWaitingForPlayers() && State_Get() == GR_STATE_RND_RUNNING ) |
|
{ |
|
CUtlVector< CTFPlayer * > alivePlayerVector; |
|
CollectPlayers( &alivePlayerVector, TF_TEAM_BLUE, COLLECT_ONLY_LIVING_PLAYERS ); |
|
|
|
// if everyone is dead at the same time, they lose |
|
if ( alivePlayerVector.Count() == 0 ) |
|
{ |
|
SetWinningTeam( TF_TEAM_RED, WINREASON_OPPONENTS_DEAD ); |
|
} |
|
} |
|
#endif // TF_RAID_MODE |
|
|
|
// Batched strange event message processing? |
|
if ( engine->Time() > m_flNextStrangeEventProcessTime ) |
|
{ |
|
KillEaterEvents_FlushBatches(); |
|
m_flNextStrangeEventProcessTime = engine->Time() + g_flStrangeEventBatchProcessInterval; |
|
} |
|
|
|
ManageCompetitiveMode(); |
|
|
|
#endif // GAME_DLL |
|
|
|
//============================================================================= |
|
// HPE_BEGIN: |
|
// [msmith] Do training summary screen logic. |
|
//============================================================================= |
|
if ( IsInTraining() == true ) |
|
{ |
|
if ( m_flStateTransitionTime > gpGlobals->curtime ) |
|
{ |
|
int client_message = tf_training_client_message.GetInt(); |
|
switch ( client_message ) |
|
{ |
|
case TRAINING_CLIENT_MESSAGE_IN_SUMMARY_SCREEN: |
|
{ |
|
//Keep adding time to the restart while we are in the end screen menu so that we never restart the round until |
|
//the player presses the replay button (or next button to go to the next map). |
|
m_flStateTransitionTime = gpGlobals->curtime + 5.0f; |
|
} |
|
break; |
|
case TRAINING_CLIENT_MESSAGE_NEXT_MAP: |
|
{ |
|
LoadNextTrainingMap(); |
|
tf_training_client_message.SetValue( (int)TRAINING_CLIENT_MESSAGE_NONE ); |
|
} |
|
break; |
|
case TRAINING_CLIENT_MESSAGE_REPLAY: |
|
{ |
|
// Reload the map |
|
engine->ChangeLevel( STRING( gpGlobals->mapname ), NULL ); |
|
tf_training_client_message.SetValue( (int)TRAINING_CLIENT_MESSAGE_NONE ); |
|
} |
|
break; |
|
} // switch |
|
} |
|
} |
|
//============================================================================= |
|
// HPE_END |
|
//============================================================================= |
|
|
|
// This is ugly, but, population manager needs to sometimes think when we're not simulating, but it is an entity. |
|
// Really, we need to better split out some kind of "sub-gamerules" class for modes like this. |
|
if ( IsMannVsMachineMode() && g_pPopulationManager ) |
|
{ |
|
g_pPopulationManager->GameRulesThink(); |
|
} |
|
|
|
BaseClass::Think(); |
|
} |
|
|
|
#ifdef GAME_DLL |
|
#ifdef STAGING_ONLY |
|
ConVar tf_spawn_halloween_gift_test_enabled( "tf_spawn_halloween_gift_test_enabled", "0", 0, "enable to spawn a gift at the world origin. You probably want to use ConCommand 'SpawnHalloweenGiftTest'" ); |
|
|
|
CON_COMMAND_F( tf_spawn_halloween_gift_test, "Test Halloween Gifts", FCVAR_NONE ) |
|
{ |
|
ConVarRef gift_test( "tf_spawn_halloween_gift_test_enabled" ); |
|
gift_test.SetValue( 1 ); |
|
} |
|
#endif // STAGING_ONLY |
|
|
|
void CTFGameRules::PeriodicHalloweenUpdate() |
|
{ |
|
// DEBUG |
|
#ifdef STAGING_ONLY |
|
if ( tf_spawn_halloween_gift_test_enabled.GetBool() ) |
|
{ |
|
m_flNextHalloweenGiftUpdateTime = gpGlobals->curtime; |
|
tf_spawn_halloween_gift_test_enabled.SetValue( 0 ); |
|
return; |
|
} |
|
#endif //staging_only |
|
|
|
// Are we on a Halloween Map? |
|
// Do we have Halloween Contracts? |
|
if ( !IsHolidayActive( kHoliday_Halloween ) ) |
|
return; |
|
|
|
// Loop through each player that has a quest and spawn them a gift |
|
if ( m_halloweenGiftSpawnLocations.Count() == 0 ) |
|
return; |
|
|
|
// If we've never given out gifts before, set the time |
|
if ( m_flNextHalloweenGiftUpdateTime < 0 ) |
|
{ |
|
m_flNextHalloweenGiftUpdateTime = gpGlobals->curtime + RandomInt( 7, 12 ) * 60; |
|
return; |
|
} |
|
|
|
if ( m_flNextHalloweenGiftUpdateTime > gpGlobals->curtime ) |
|
return; |
|
|
|
m_flNextHalloweenGiftUpdateTime = gpGlobals->curtime + RandomInt( 7, 12 ) * 60; |
|
|
|
CUtlVector< CTFPlayer* > playerVector; |
|
CollectPlayers( &playerVector ); |
|
FOR_EACH_VEC( playerVector, i ) |
|
{ |
|
Vector vLocation = m_halloweenGiftSpawnLocations.Element( RandomInt( 0, m_halloweenGiftSpawnLocations.Count() - 1 ) ); |
|
CHalloweenGiftPickup *pGift = assert_cast<CHalloweenGiftPickup*>( CBaseEntity::CreateNoSpawn( "tf_halloween_gift_pickup", vLocation, vec3_angle, NULL ) ); |
|
if ( pGift ) |
|
{ |
|
pGift->SetTargetPlayer( playerVector[i] ); |
|
DispatchSpawn( pGift ); |
|
} |
|
} |
|
|
|
} |
|
#endif |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::SwitchToNextBestWeapon( CBaseCombatCharacter *pPlayer, CBaseCombatWeapon *pCurrentWeapon ) |
|
{ |
|
if ( pPlayer ) |
|
{ |
|
CBaseCombatWeapon *lastWeapon = ToTFPlayer( pPlayer )->GetLastWeapon(); |
|
|
|
if ( lastWeapon != NULL && lastWeapon->HasAnyAmmo() ) |
|
{ |
|
return pPlayer->Weapon_Switch( lastWeapon ); |
|
} |
|
} |
|
|
|
return BaseClass::SwitchToNextBestWeapon( pPlayer, pCurrentWeapon ); |
|
} |
|
|
|
|
|
#ifdef GAME_DLL |
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::PointsMayBeCaptured( void ) |
|
{ |
|
if ( IsHolidayActive( kHoliday_Halloween ) && GetActiveBoss() ) |
|
{ |
|
switch ( GetHalloweenScenario() ) |
|
{ |
|
case HALLOWEEN_SCENARIO_VIADUCT: |
|
{ |
|
// the eyeball prevents point capturing while he's in play |
|
if ( assert_cast< CEyeballBoss * >( GetActiveBoss() ) ) |
|
{ |
|
return false; |
|
} |
|
} |
|
break; |
|
case HALLOWEEN_SCENARIO_LAKESIDE: |
|
{ |
|
// merasmus prevents point capturing while he's in play |
|
if ( assert_cast< CMerasmus * >( GetActiveBoss() ) ) |
|
{ |
|
return false; |
|
} |
|
} |
|
break; |
|
} |
|
} |
|
|
|
if ( IsMannVsMachineMode() ) |
|
{ |
|
return true; |
|
} |
|
|
|
return BaseClass::PointsMayBeCaptured(); |
|
} |
|
|
|
|
|
extern bool IsSpaceToSpawnHere( const Vector &where ); |
|
|
|
static bool isZombieMobForceSpawning = false; |
|
|
|
#ifdef STAGING_ONLY |
|
// force the boss to spawn where our cursor is pointing |
|
CON_COMMAND_F( tf_halloween_force_zombie_mob, "For testing.", FCVAR_CHEAT ) |
|
{ |
|
isZombieMobForceSpawning = true; |
|
} |
|
#endif |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SpawnZombieMob( void ) |
|
{ |
|
if ( !tf_halloween_zombie_mob_enabled.GetBool() ) |
|
{ |
|
return; |
|
} |
|
|
|
// timer was started and has elapsed - time to spawn the boss |
|
if ( InSetup() || IsInWaitingForPlayers() ) |
|
{ |
|
m_zombieMobTimer.Start( tf_halloween_zombie_mob_spawn_interval.GetFloat() ); |
|
return; |
|
} |
|
|
|
if ( isZombieMobForceSpawning ) |
|
{ |
|
isZombieMobForceSpawning = false; |
|
m_zombieMobTimer.Invalidate(); |
|
} |
|
|
|
// spawn pending mob members |
|
if ( m_zombiesLeftToSpawn > 0 ) |
|
{ |
|
if ( IsSpaceToSpawnHere( m_zombieSpawnSpot ) ) |
|
{ |
|
if ( CZombie::SpawnAtPos( m_zombieSpawnSpot ) ) |
|
{ |
|
--m_zombiesLeftToSpawn; |
|
} |
|
} |
|
} |
|
|
|
// require a minimum number of human players in the game before the boss appears |
|
CUtlVector< CTFPlayer * > playerVector; |
|
CollectPlayers( &playerVector, TF_TEAM_RED, COLLECT_ONLY_LIVING_PLAYERS ); |
|
CollectPlayers( &playerVector, TF_TEAM_BLUE, COLLECT_ONLY_LIVING_PLAYERS, APPEND_PLAYERS ); |
|
|
|
// only count humans |
|
int totalPlayers = 0; |
|
for( int i=0; i<playerVector.Count(); ++i ) |
|
{ |
|
if ( !playerVector[i]->IsBot() ) |
|
{ |
|
++totalPlayers; |
|
} |
|
} |
|
|
|
if ( totalPlayers == 0 ) |
|
{ |
|
return; |
|
} |
|
|
|
// spawn a mob |
|
if ( m_zombieMobTimer.IsElapsed() ) |
|
{ |
|
m_zombieMobTimer.Start( tf_halloween_zombie_mob_spawn_interval.GetFloat() ); |
|
|
|
CUtlVector< CTFNavArea * > ambushVector; // vector of hidden but near-to-victim areas |
|
|
|
for( int i=0; i<playerVector.Count(); ++i ) |
|
{ |
|
CTFPlayer *player = playerVector[i]; |
|
|
|
if ( player->IsBot() ) |
|
{ |
|
continue; |
|
} |
|
|
|
if ( !player->GetLastKnownArea() ) |
|
{ |
|
continue; |
|
} |
|
|
|
const float maxSurroundTravelRange = 2000.0f; |
|
|
|
CUtlVector< CNavArea * > areaVector; |
|
|
|
// collect walkable areas surrounding this player |
|
CollectSurroundingAreas( &areaVector, player->GetLastKnownArea(), maxSurroundTravelRange, StepHeight, StepHeight ); |
|
|
|
// keep subset that isn't visible to any player |
|
for( int j=0; j<areaVector.Count(); ++j ) |
|
{ |
|
CTFNavArea *area = (CTFNavArea *)areaVector[j]; |
|
|
|
if ( !area->IsValidForWanderingPopulation() ) |
|
{ |
|
continue; |
|
} |
|
|
|
if ( area->IsPotentiallyVisibleToTeam( TF_TEAM_BLUE ) || area->IsPotentiallyVisibleToTeam( TF_TEAM_RED ) ) |
|
{ |
|
continue; |
|
} |
|
|
|
ambushVector.AddToTail( area ); |
|
} |
|
} |
|
|
|
if ( ambushVector.Count() == 0 ) |
|
{ |
|
// no place to spawn the mob this time |
|
return; |
|
} |
|
|
|
for( int retry=0; retry<10; ++retry ) |
|
{ |
|
int which = RandomInt( 0, ambushVector.Count()-1 ); |
|
m_zombieSpawnSpot = ambushVector[ which ]->GetCenter() + Vector( 0, 0, StepHeight ); |
|
|
|
if ( !IsSpaceToSpawnHere( m_zombieSpawnSpot ) ) |
|
{ |
|
continue; |
|
} |
|
|
|
// spawn a mob here |
|
m_zombiesLeftToSpawn = tf_halloween_zombie_mob_spawn_count.GetInt(); |
|
|
|
break; |
|
} |
|
} |
|
} |
|
|
|
//--------------------------------------------------------------------------------------------------------- |
|
static bool isBossForceSpawning = false; |
|
|
|
// force the boss to spawn where our cursor is pointing |
|
CON_COMMAND_F( tf_halloween_force_boss_spawn, "For testing.", FCVAR_CHEAT ) |
|
{ |
|
isBossForceSpawning = true; |
|
} |
|
|
|
|
|
CON_COMMAND_F( cc_spawn_merasmus_at_level, "Force Merasmus to spawn at a specific difficulty level", FCVAR_CHEAT ) |
|
{ |
|
if( args.ArgC() != 2 ) |
|
{ |
|
DevMsg( "Must specify a level\n" ); |
|
return; |
|
} |
|
|
|
CMerasmus::DBG_SetLevel( atoi(args[1]) ); |
|
|
|
tf_halloween_force_boss_spawn( args ); |
|
} |
|
|
|
|
|
extern ConVar tf_halloween_bot_min_player_count; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SpawnHalloweenBoss( void ) |
|
{ |
|
if ( !IsHolidayActive( kHoliday_Halloween ) ) |
|
return; |
|
|
|
// only spawn the Halloween Boss on our Halloween maps |
|
HalloweenBossType bossType = HALLOWEEN_BOSS_INVALID; |
|
|
|
float bossInterval = 0.0f; |
|
float bossIntervalVariation = 0.0f; |
|
|
|
HalloweenScenarioType scenario = GetHalloweenScenario(); |
|
if ( scenario == HALLOWEEN_SCENARIO_MANN_MANOR ) |
|
{ |
|
bossType = HALLOWEEN_BOSS_HHH; |
|
bossInterval = tf_halloween_boss_spawn_interval.GetFloat(); |
|
bossIntervalVariation = tf_halloween_boss_spawn_interval_variation.GetFloat(); |
|
|
|
} |
|
else if ( scenario == HALLOWEEN_SCENARIO_VIADUCT ) |
|
{ |
|
bossType = HALLOWEEN_BOSS_MONOCULUS; |
|
bossInterval = tf_halloween_eyeball_boss_spawn_interval.GetFloat(); |
|
bossIntervalVariation = tf_halloween_eyeball_boss_spawn_interval_variation.GetFloat(); |
|
} |
|
else if ( scenario == HALLOWEEN_SCENARIO_LAKESIDE ) |
|
{ |
|
bossType = HALLOWEEN_BOSS_MERASMUS; |
|
|
|
if ( CMerasmus::GetMerasmusLevel() <= 3 ) |
|
{ |
|
bossInterval = tf_merasmus_spawn_interval.GetFloat(); |
|
bossIntervalVariation = tf_merasmus_spawn_interval_variation.GetFloat(); |
|
} |
|
else |
|
{ |
|
// after level 3, spawn Merasmus every 60 secs |
|
bossInterval = 60; |
|
bossIntervalVariation = 0; |
|
} |
|
|
|
// check if the wheel is still spinning |
|
CWheelOfDoom* pWheel = assert_cast< CWheelOfDoom* >( gEntList.FindEntityByClassname( NULL, "wheel_of_doom" ) ); |
|
if ( pWheel && !pWheel->IsDoneBoardcastingEffectSound() ) |
|
{ |
|
return; |
|
} |
|
} |
|
//else if ( scenario == HALLOWEEN_SCENARIO_HIGHTOWER ) |
|
//{ |
|
// bool bWasEnabled = tf_halloween_zombie_mob_enabled.GetBool(); |
|
// tf_halloween_zombie_mob_enabled.SetValue( true ); |
|
|
|
// // not a boss battle map |
|
// SpawnZombieMob(); |
|
|
|
// tf_halloween_zombie_mob_enabled.SetValue( bWasEnabled ); |
|
|
|
// bossType = "eyeball_boss"; |
|
// bossInterval = tf_halloween_eyeball_boss_spawn_interval.GetFloat(); |
|
// bossIntervalVariation = tf_halloween_eyeball_boss_spawn_interval_variation.GetFloat(); |
|
//} |
|
else |
|
{ |
|
// not a boss battle map |
|
SpawnZombieMob(); |
|
|
|
return; |
|
} |
|
|
|
// only one boss at a time |
|
if ( GetActiveBoss() ) |
|
{ |
|
// boss is still out there - restart the timer |
|
StartHalloweenBossTimer( bossInterval, bossIntervalVariation ); |
|
isBossForceSpawning = false; |
|
return; |
|
} |
|
|
|
if ( !m_halloweenBossTimer.IsElapsed() && !isBossForceSpawning ) |
|
return; |
|
|
|
// boss timer has elapsed |
|
if ( m_halloweenBossTimer.HasStarted() || isBossForceSpawning ) |
|
{ |
|
if ( !isBossForceSpawning ) |
|
{ |
|
// timer was started and has elapsed - time to spawn the boss |
|
if ( InSetup() || IsInWaitingForPlayers() ) |
|
return; |
|
|
|
// require a minimum number of human players in the game before the boss appears |
|
CUtlVector< CTFPlayer * > playerVector; |
|
CollectPlayers( &playerVector, TF_TEAM_RED, COLLECT_ONLY_LIVING_PLAYERS ); |
|
CollectPlayers( &playerVector, TF_TEAM_BLUE, COLLECT_ONLY_LIVING_PLAYERS, APPEND_PLAYERS ); |
|
|
|
// only count humans |
|
int totalPlayers = 0; |
|
for( int i=0; i<playerVector.Count(); ++i ) |
|
{ |
|
if ( !playerVector[i]->IsBot() ) |
|
{ |
|
++totalPlayers; |
|
} |
|
} |
|
|
|
if ( totalPlayers < tf_halloween_bot_min_player_count.GetInt() ) |
|
return; |
|
} |
|
|
|
Vector bossSpawnPos = vec3_origin; |
|
|
|
// spawn on the currently contested point |
|
CTeamControlPoint *contestedPoint = NULL; |
|
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL; |
|
if ( pMaster ) |
|
{ |
|
for( int i=0; i<pMaster->GetNumPoints(); ++i ) |
|
{ |
|
contestedPoint = pMaster->GetControlPoint( i ); |
|
if ( contestedPoint && pMaster->IsInRound( contestedPoint ) ) |
|
{ |
|
if ( ObjectiveResource()->GetOwningTeam( contestedPoint->GetPointIndex() ) == TF_TEAM_BLUE ) |
|
continue; |
|
|
|
// blue are the invaders |
|
if ( !TeamplayGameRules()->TeamMayCapturePoint( TF_TEAM_BLUE, contestedPoint->GetPointIndex() ) ) |
|
continue; |
|
|
|
break; |
|
} |
|
} |
|
} |
|
|
|
CBaseEntity *pCustomSpawnBossPos = gEntList.FindEntityByClassname( NULL, "spawn_boss" ); |
|
if ( pCustomSpawnBossPos ) |
|
{ |
|
bossSpawnPos = pCustomSpawnBossPos->GetAbsOrigin(); |
|
} |
|
else if ( contestedPoint ) |
|
{ |
|
bossSpawnPos = contestedPoint->GetAbsOrigin(); |
|
|
|
if ( scenario == HALLOWEEN_SCENARIO_VIADUCT || scenario == HALLOWEEN_SCENARIO_LAKESIDE ) |
|
{ |
|
// revert ownership of point to neutral |
|
contestedPoint->ForceOwner( 0 ); |
|
|
|
// pause the timers |
|
if ( IsInKothMode() ) |
|
{ |
|
variant_t sVariant; |
|
CTeamRoundTimer *pTimer = GetKothTeamTimer( TF_TEAM_BLUE ); |
|
if ( pTimer ) |
|
{ |
|
pTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 ); |
|
} |
|
|
|
pTimer = GetKothTeamTimer( TF_TEAM_RED ); |
|
if ( pTimer ) |
|
{ |
|
pTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 ); |
|
} |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
// pick a random spot |
|
CUtlVector< CTFNavArea * > spawnAreaVector; |
|
for( int i=0; i<TheNavAreas.Count(); ++i ) |
|
{ |
|
CTFNavArea *area = (CTFNavArea *)TheNavAreas[i]; |
|
|
|
if ( area->HasAttributeTF( TF_NAV_SPAWN_ROOM_BLUE | TF_NAV_SPAWN_ROOM_RED | TF_NAV_SPAWN_ROOM_EXIT ) ) |
|
{ |
|
// don't spawn in team spawn rooms |
|
continue; |
|
} |
|
|
|
// don't use small nav areas |
|
const float goodSize = 100.0f; |
|
if ( area->GetSizeX() < goodSize || area->GetSizeY() < goodSize ) |
|
{ |
|
continue; |
|
} |
|
|
|
spawnAreaVector.AddToTail( area ); |
|
} |
|
|
|
if ( spawnAreaVector.Count() == 0 ) |
|
{ |
|
// no place to spawn (!) |
|
return; |
|
} |
|
|
|
int which = RandomInt( 0, spawnAreaVector.Count()-1 ); |
|
bossSpawnPos = spawnAreaVector[ which ]->GetCenter(); |
|
} |
|
|
|
CHalloweenBaseBoss::SpawnBossAtPos( bossType, bossSpawnPos ); |
|
|
|
// pick next spawn time |
|
StartHalloweenBossTimer( bossInterval, bossIntervalVariation ); |
|
|
|
isBossForceSpawning = false; |
|
} |
|
else |
|
{ |
|
// Merasmus has a more reliable initial spawn time |
|
if( IsHalloweenScenario( HALLOWEEN_SCENARIO_LAKESIDE ) ) |
|
{ |
|
StartHalloweenBossTimer( bossInterval, bossIntervalVariation ); |
|
} |
|
else |
|
{ |
|
// initial spawn time |
|
m_halloweenBossTimer.Start( 0.5f * RandomFloat( 0.0f, bossInterval + bossIntervalVariation ) ); |
|
} |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::BeginHaunting( int nDesiredCount, float flMinDuration, float flMaxDuration ) |
|
{ |
|
if ( !IsHolidayActive( kHoliday_Halloween ) ) |
|
return; |
|
|
|
if ( !IsHalloweenScenario( HALLOWEEN_SCENARIO_VIADUCT ) && !IsHalloweenScenario( HALLOWEEN_SCENARIO_LAKESIDE ) ) |
|
{ |
|
CTFHolidayEntity *pHolidayEntity = dynamic_cast<CTFHolidayEntity*> ( gEntList.FindEntityByClassname( NULL, "tf_logic_holiday" ) ); |
|
if ( !pHolidayEntity || !pHolidayEntity->ShouldAllowHaunting() ) |
|
return; |
|
} |
|
|
|
const int desiredGhostCount = nDesiredCount; |
|
|
|
// if there are existing ghosts, extend their time |
|
CUtlVector< CGhost * > priorGhostVector; |
|
for( int g=0; g<m_ghostVector.Count(); ++g ) |
|
{ |
|
if ( m_ghostVector[g] != NULL ) |
|
{ |
|
priorGhostVector.AddToTail( m_ghostVector[g] ); |
|
} |
|
} |
|
|
|
m_ghostVector.RemoveAll(); |
|
|
|
for( int g=0; g<priorGhostVector.Count(); ++g ) |
|
{ |
|
priorGhostVector[g]->SetLifetime( RandomFloat( flMinDuration, flMaxDuration ) ); |
|
|
|
m_ghostVector.AddToTail( priorGhostVector[g] ); |
|
} |
|
|
|
if ( m_ghostVector.Count() >= desiredGhostCount ) |
|
return; |
|
|
|
// spawn ghosts away from players |
|
CUtlVector< CTFPlayer * > playerVector; |
|
CollectPlayers( &playerVector, TF_TEAM_BLUE, COLLECT_ONLY_LIVING_PLAYERS ); |
|
CollectPlayers( &playerVector, TF_TEAM_RED, COLLECT_ONLY_LIVING_PLAYERS, APPEND_PLAYERS ); |
|
|
|
const int ghostCount = desiredGhostCount - m_ghostVector.Count(); |
|
|
|
CUtlVector< Vector > spawnVector; |
|
|
|
for( int i=0; i<TheNavAreas.Count(); ++i ) |
|
{ |
|
CTFNavArea *area = (CTFNavArea *)TheNavAreas.Element(i); |
|
|
|
if ( area->HasAttributeTF( TF_NAV_SPAWN_ROOM_BLUE | TF_NAV_SPAWN_ROOM_RED ) ) |
|
{ |
|
// keep out of spawn rooms |
|
continue; |
|
} |
|
|
|
Vector spot = area->GetCenter(); |
|
|
|
// don't spawn near players (so they aren't instantly scared) |
|
int p; |
|
for( p=0; p<playerVector.Count(); ++p ) |
|
{ |
|
if ( ( playerVector[p]->GetAbsOrigin() - spot ).IsLengthLessThan( 1.25f * GHOST_SCARE_RADIUS ) ) |
|
{ |
|
break; |
|
} |
|
} |
|
|
|
if ( p == playerVector.Count() ) |
|
{ |
|
spawnVector.AddToTail( spot ); |
|
} |
|
} |
|
|
|
if ( spawnVector.Count() == 0 ) |
|
{ |
|
return; |
|
} |
|
|
|
for( int g=0; g<ghostCount; ++g ) |
|
{ |
|
int which = RandomInt( 0, spawnVector.Count()-1 ); |
|
|
|
CGhost *ghost = SpawnGhost( spawnVector[ which ], vec3_angle, RandomFloat( flMinDuration, flMaxDuration ) ); |
|
|
|
m_ghostVector.AddToTail( ghost ); |
|
} |
|
} |
|
|
|
static const int k_RecentPlayerInfoMaxTime = 7200; // 2 hours |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::PlayerHistory_AddPlayer( CTFPlayer *pTFPlayer ) |
|
{ |
|
if ( !pTFPlayer ) |
|
return; |
|
|
|
CSteamID steamID; |
|
pTFPlayer->GetSteamID( &steamID ); |
|
if ( !steamID.IsValid() || !steamID.BIndividualAccount() ) |
|
return; |
|
|
|
// Exists? |
|
FOR_EACH_VEC_BACK( m_vecPlayerHistory, i ) |
|
{ |
|
if ( m_vecPlayerHistory[i].steamID == steamID ) |
|
{ |
|
m_vecPlayerHistory[i].flTime = Plat_FloatTime(); |
|
return; |
|
} |
|
|
|
// Do maintenance here. |
|
if ( Plat_FloatTime() - m_vecPlayerHistory[i].flTime >= (float)k_RecentPlayerInfoMaxTime ) |
|
{ |
|
m_vecPlayerHistory.Remove( i ); |
|
} |
|
} |
|
|
|
PlayerHistoryInfo_t info = |
|
{ |
|
steamID, |
|
(float) Plat_FloatTime(), |
|
pTFPlayer->GetTeamNumber() |
|
}; |
|
m_vecPlayerHistory.AddToTail( info ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
PlayerHistoryInfo_t *CTFGameRules::PlayerHistory_GetPlayerInfo( CTFPlayer *pTFPlayer ) |
|
{ |
|
if ( !pTFPlayer ) |
|
return NULL; |
|
|
|
CSteamID steamID; |
|
pTFPlayer->GetSteamID( &steamID ); |
|
if ( !steamID.IsValid() || !steamID.BIndividualAccount() ) |
|
return NULL; |
|
|
|
FOR_EACH_VEC_BACK( m_vecPlayerHistory, i ) |
|
{ |
|
if ( m_vecPlayerHistory[i].steamID == steamID ) |
|
return &m_vecPlayerHistory[i]; |
|
} |
|
|
|
return NULL; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Returns -1 if we don't have the data |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::PlayerHistory_GetTimeSinceLastSeen( CTFPlayer *pTFPlayer ) |
|
{ |
|
PlayerHistoryInfo_t *pInfo = PlayerHistory_GetPlayerInfo( pTFPlayer ); |
|
if ( !pInfo ) |
|
return -1; |
|
|
|
// We only care about whole seconds |
|
return (int)( Plat_FloatTime() - pInfo->flTime ); |
|
} |
|
#endif |
|
|
|
//============================================================================= |
|
// HPE_BEGIN: |
|
// [msmith] TEMP CODE: needs to be replaced with the final solution for our training mission navigation. |
|
//============================================================================= |
|
void CTFGameRules::LoadNextTrainingMap() |
|
{ |
|
if ( m_hTrainingModeLogic ) |
|
{ |
|
g_fGameOver = true; |
|
const char* pNextMap = m_hTrainingModeLogic->GetNextMap(); |
|
if ( pNextMap && FStrEq( pNextMap, "" ) == false ) |
|
{ |
|
Msg( "CHANGE LEVEL: %s\n", pNextMap ); |
|
engine->ChangeLevel( pNextMap, NULL ); |
|
} |
|
else |
|
{ |
|
Msg( "CHANGE LEVEL: %s\n", STRING( gpGlobals->mapname ) ); |
|
engine->ChangeLevel( STRING( gpGlobals->mapname ), NULL ); |
|
} |
|
return; |
|
} |
|
|
|
Msg( "CHANGE LEVEL: %s\n", STRING( gpGlobals->mapname ) ); |
|
engine->ChangeLevel( STRING( gpGlobals->mapname ), NULL ); |
|
} |
|
//============================================================================= |
|
// HPE_END |
|
//============================================================================= |
|
|
|
//Runs think for all player's conditions |
|
//Need to do this here instead of the player so players that crash still run their important thinks |
|
void CTFGameRules::RunPlayerConditionThink ( void ) |
|
{ |
|
for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ ) |
|
{ |
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
|
|
if ( pPlayer ) |
|
{ |
|
pPlayer->m_Shared.ConditionGameRulesThink(); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::FrameUpdatePostEntityThink() |
|
{ |
|
BaseClass::FrameUpdatePostEntityThink(); |
|
|
|
RunPlayerConditionThink(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::CheckCapsPerRound() |
|
{ |
|
return IsPasstimeMode() |
|
? SetPasstimeWinningTeam() |
|
: SetCtfWinningTeam(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::SetPasstimeWinningTeam() |
|
{ |
|
Assert( IsPasstimeMode() ); |
|
|
|
int iScoreLimit = tf_passtime_scores_per_round.GetInt(); |
|
if ( iScoreLimit <= 0 ) |
|
{ |
|
// no score limit set, play forever |
|
return false; |
|
} |
|
|
|
// TODO need to generalize the "flag captures" parts of CTFTeam to avoid |
|
// this confusing overload of the flag captures concept, or maybe defer |
|
// this logic to the specific object that manages the mode. |
|
CTFTeamManager *pTeamMgr = TFTeamMgr(); |
|
int iBlueScore = pTeamMgr->GetFlagCaptures( TF_TEAM_BLUE ); |
|
int iRedScore = pTeamMgr->GetFlagCaptures( TF_TEAM_RED ); |
|
if ( ( iBlueScore < iScoreLimit ) && ( iRedScore < iScoreLimit ) ) |
|
{ |
|
// no team has exceeded the score limit |
|
return false; |
|
} |
|
|
|
int iWinnerTeam = ( iBlueScore > iRedScore ) |
|
? TF_TEAM_BLUE |
|
: TF_TEAM_RED; |
|
SetWinningTeam( iWinnerTeam, WINREASON_SCORED ); |
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::SetCtfWinningTeam() |
|
{ |
|
Assert( !IsPasstimeMode() ); |
|
if ( tf_flag_caps_per_round.GetInt() > 0 ) |
|
{ |
|
int iMaxCaps = -1; |
|
CTFTeam *pMaxTeam = NULL; |
|
|
|
// check to see if any team has won a "round" |
|
int nTeamCount = TFTeamMgr()->GetTeamCount(); |
|
for ( int iTeam = FIRST_GAME_TEAM; iTeam < nTeamCount; ++iTeam ) |
|
{ |
|
CTFTeam *pTeam = GetGlobalTFTeam( iTeam ); |
|
if ( !pTeam ) |
|
continue; |
|
|
|
// we might have more than one team over the caps limit (if the server op lowered the limit) |
|
// so loop through to see who has the most among teams over the limit |
|
if ( pTeam->GetFlagCaptures() >= tf_flag_caps_per_round.GetInt() ) |
|
{ |
|
if ( pTeam->GetFlagCaptures() > iMaxCaps ) |
|
{ |
|
iMaxCaps = pTeam->GetFlagCaptures(); |
|
pMaxTeam = pTeam; |
|
} |
|
} |
|
} |
|
|
|
if ( iMaxCaps != -1 && pMaxTeam != NULL ) |
|
{ |
|
SetWinningTeam( pMaxTeam->GetTeamNumber(), WINREASON_FLAG_CAPTURE_LIMIT ); |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::CheckWinLimit( bool bAllowEnd /*= true*/, int nAddValueWhenChecking /*= 0*/ ) |
|
{ |
|
if ( IsInPreMatch() ) |
|
return false; |
|
|
|
bool bWinner = false; |
|
int iTeam = TEAM_UNASSIGNED; |
|
int iReason = WINREASON_NONE; |
|
const char *pszReason = ""; |
|
|
|
if ( mp_winlimit.GetInt() != 0 ) |
|
{ |
|
if ( ( TFTeamMgr()->GetTeam( TF_TEAM_BLUE )->GetScore() + nAddValueWhenChecking ) >= mp_winlimit.GetInt() ) |
|
{ |
|
pszReason = "Team \"BLUE\" triggered \"Intermission_Win_Limit\"\n"; |
|
bWinner = true; |
|
iTeam = TF_TEAM_BLUE; |
|
iReason = WINREASON_WINLIMIT; |
|
} |
|
else if ( ( TFTeamMgr()->GetTeam( TF_TEAM_RED )->GetScore() + nAddValueWhenChecking ) >= mp_winlimit.GetInt() ) |
|
{ |
|
pszReason = "Team \"RED\" triggered \"Intermission_Win_Limit\"\n"; |
|
bWinner = true; |
|
iTeam = TF_TEAM_RED; |
|
iReason = WINREASON_WINLIMIT; |
|
} |
|
} |
|
|
|
// has one team go far enough ahead of the other team to trigger the win difference? |
|
if ( !bWinner ) |
|
{ |
|
int iWinLimit = mp_windifference.GetInt(); |
|
if ( iWinLimit > 0 ) |
|
{ |
|
int iBlueScore = TFTeamMgr()->GetTeam( TF_TEAM_BLUE )->GetScore(); |
|
int iRedScore = TFTeamMgr()->GetTeam( TF_TEAM_RED )->GetScore(); |
|
|
|
if ( (iBlueScore - iRedScore) >= iWinLimit ) |
|
{ |
|
if ( (mp_windifference_min.GetInt() == 0) || (iBlueScore >= mp_windifference_min.GetInt()) ) |
|
{ |
|
pszReason = "Team \"BLUE\" triggered \"Intermission_Win_Limit\" due to mp_windifference\n"; |
|
bWinner = true; |
|
iTeam = TF_TEAM_BLUE; |
|
iReason = WINREASON_WINDIFFLIMIT; |
|
} |
|
} |
|
else if ( (iRedScore - iBlueScore) >= iWinLimit ) |
|
{ |
|
if ( (mp_windifference_min.GetInt() == 0) || (iRedScore >= mp_windifference_min.GetInt()) ) |
|
{ |
|
pszReason = "Team \"RED\" triggered \"Intermission_Win_Limit\" due to mp_windifference\n"; |
|
bWinner = true; |
|
iTeam = TF_TEAM_RED; |
|
iReason = WINREASON_WINDIFFLIMIT; |
|
} |
|
} |
|
} |
|
} |
|
|
|
if ( bWinner ) |
|
{ |
|
if ( bAllowEnd ) |
|
{ |
|
IGameEvent *event = gameeventmanager->CreateEvent( "tf_game_over" ); |
|
if ( event ) |
|
{ |
|
if ( iReason == WINREASON_WINDIFFLIMIT ) |
|
{ |
|
event->SetString( "reason", "Reached Win Difference Limit" ); |
|
} |
|
else |
|
{ |
|
event->SetString( "reason", "Reached Win Limit" ); |
|
} |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
|
|
if ( IsInTournamentMode() == true ) |
|
{ |
|
SetWinningTeam( iTeam, iReason, true, false, true ); |
|
} |
|
else |
|
{ |
|
GoToIntermission(); |
|
} |
|
|
|
Assert( V_strlen( pszReason ) ); |
|
UTIL_LogPrintf( "%s", pszReason ); |
|
} |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::CheckRespawnWaves() |
|
{ |
|
BaseClass::CheckRespawnWaves(); |
|
|
|
// Look for overrides |
|
for ( int i = 1; i <= gpGlobals->maxClients; i++ ) |
|
{ |
|
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
if ( !pTFPlayer ) |
|
continue; |
|
|
|
if ( pTFPlayer->IsAlive() ) |
|
continue; |
|
|
|
if ( m_iRoundState == GR_STATE_PREROUND ) |
|
continue; |
|
|
|
// Triggers can force a player to spawn at a specific time |
|
if ( pTFPlayer->GetRespawnTimeOverride() != -1.f && |
|
gpGlobals->curtime > pTFPlayer->GetDeathTime() + pTFPlayer->GetRespawnTimeOverride() ) |
|
{ |
|
pTFPlayer->ForceRespawn(); |
|
} |
|
else if ( IsPVEModeActive() ) |
|
{ |
|
// special stuff for PVE mode |
|
if ( !ShouldRespawnQuickly( pTFPlayer ) ) |
|
continue; |
|
|
|
// If the player hasn't been dead the minimum respawn time, he |
|
// waits until the next wave. |
|
if ( !HasPassedMinRespawnTime( pTFPlayer ) ) |
|
continue; |
|
|
|
if ( !pTFPlayer->IsReadyToSpawn() ) |
|
{ |
|
// Let the player spawn immediately when they do pick a class |
|
if ( pTFPlayer->ShouldGainInstantSpawn() ) |
|
{ |
|
pTFPlayer->AllowInstantSpawn(); |
|
} |
|
continue; |
|
} |
|
|
|
// Respawn this player |
|
pTFPlayer->ForceRespawn(); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::PlayWinSong( int team ) |
|
{ |
|
if ( IsPlayingSpecialDeliveryMode() ) |
|
return; |
|
|
|
bool bGameOver = IsGameOver(); |
|
|
|
if ( !IsInStopWatch() || bGameOver ) |
|
{ |
|
// Give the match a chance to play something custom. It returns true if it handled everything |
|
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() ); |
|
if ( pMatchDesc && pMatchDesc->BPlayWinMusic( team, bGameOver ) ) |
|
{ |
|
return; |
|
} |
|
} |
|
|
|
if ( IsInTournamentMode() && IsInStopWatch() && ObjectiveResource() ) |
|
{ |
|
int iStopWatchTimer = ObjectiveResource()->GetStopWatchTimer(); |
|
CTeamRoundTimer *pStopWatch = dynamic_cast< CTeamRoundTimer* >( UTIL_EntityByIndex( iStopWatchTimer ) ); |
|
if ( ( pStopWatch && pStopWatch->IsWatchingTimeStamps() ) || ( !m_bForceMapReset ) ) |
|
{ |
|
BroadcastSound( 255, "MatchMaking.RoundEndStalemateMusic" ); |
|
return; |
|
} |
|
} |
|
|
|
CTeamplayRoundBasedRules::PlayWinSong( team ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetWinningTeam( int team, int iWinReason, bool bForceMapReset /* = true */, bool bSwitchTeams /* = false*/, bool bDontAddScore /* = false*/, bool bFinal /*= false*/ ) |
|
{ |
|
// matching the value calculated in CTeamplayRoundBasedRules::State_Enter_TEAM_WIN() |
|
// for m_flStateTransitionTime and adding 1 second to make sure we're covered |
|
int nTime = GetBonusRoundTime( bFinal ) + 1; |
|
|
|
for ( int i = 1; i <= gpGlobals->maxClients; i++ ) |
|
{ |
|
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
if ( !pTFPlayer ) |
|
continue; |
|
|
|
// store our team for the response rules at the next round start |
|
// (teams might be switched for attack/defend maps) |
|
pTFPlayer->SetPrevRoundTeamNum( pTFPlayer->GetTeamNumber() ); |
|
|
|
if ( team != TEAM_UNASSIGNED ) |
|
{ |
|
if ( pTFPlayer->GetTeamNumber() == team ) |
|
{ |
|
if ( pTFPlayer->IsAlive() ) |
|
{ |
|
pTFPlayer->m_Shared.AddCond( TF_COND_CRITBOOSTED_BONUS_TIME, nTime ); |
|
} |
|
} |
|
else |
|
{ |
|
pTFPlayer->ClearExpression(); |
|
#ifdef GAME_DLL |
|
// Loser karts get max Damage and stun |
|
if ( pTFPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_KART ) ) |
|
{ |
|
pTFPlayer->AddKartDamage( 666 ); |
|
pTFPlayer->m_Shared.StunPlayer( 1.5f, 1.0f, TF_STUN_BOTH ); // Short full stun then slow |
|
pTFPlayer->m_Shared.StunPlayer( 10.0f, 0.25f, TF_STUN_MOVEMENT ); |
|
} |
|
#endif //GAME_DLL |
|
} |
|
} |
|
} |
|
|
|
DuelMiniGame_AssignWinners(); |
|
|
|
#ifdef TF_RAID_MODE |
|
if ( !IsBossBattleMode() ) |
|
{ |
|
// Don't do a full reset in Raid mode if the defending team didn't win |
|
if ( IsRaidMode() && team != TF_TEAM_PVE_DEFENDERS ) |
|
{ |
|
bForceMapReset = false; |
|
} |
|
} |
|
#endif // TF_RAID_MODE |
|
|
|
SetBirthdayPlayer( NULL ); |
|
|
|
#ifdef GAME_DLL |
|
if ( m_bPlayingKoth ) |
|
{ |
|
// Increment BLUE KOTH cap time |
|
CTeamRoundTimer *pKOTHTimer = TFGameRules()->GetBlueKothRoundTimer(); |
|
GetGlobalTFTeam( TF_TEAM_BLUE )->AddKOTHTime( pKOTHTimer->GetTimerMaxLength() - pKOTHTimer->GetTimeRemaining() ); |
|
|
|
// Increment RED KOTH cap time |
|
pKOTHTimer = TFGameRules()->GetRedKothRoundTimer(); |
|
GetGlobalTFTeam( TF_TEAM_RED )->AddKOTHTime( pKOTHTimer->GetTimerMaxLength() - pKOTHTimer->GetTimeRemaining() ); |
|
} |
|
else if ( HasMultipleTrains() ) |
|
{ |
|
for ( int i = 0 ; i < ITFTeamTrainWatcher::AutoList().Count() ; ++i ) |
|
{ |
|
CTeamTrainWatcher *pTrainWatcher = static_cast< CTeamTrainWatcher* >( ITFTeamTrainWatcher::AutoList()[i] ); |
|
if ( !pTrainWatcher->IsDisabled() ) |
|
{ |
|
if ( pTrainWatcher->GetTeamNumber() == TF_TEAM_RED ) |
|
{ |
|
GetGlobalTFTeam( TF_TEAM_RED )->AddPLRTrack( pTrainWatcher->GetTrainProgress() ); |
|
} |
|
else |
|
{ |
|
GetGlobalTFTeam( TF_TEAM_BLUE )->AddPLRTrack( pTrainWatcher->GetTrainProgress() ); |
|
} |
|
} |
|
} |
|
} |
|
#endif |
|
|
|
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) && CTFMinigameLogic::GetMinigameLogic() ) |
|
{ |
|
CTFMiniGame *pMiniGame = CTFMinigameLogic::GetMinigameLogic()->GetActiveMinigame(); |
|
if ( pMiniGame ) |
|
{ |
|
IGameEvent *event = gameeventmanager->CreateEvent( "minigame_win" ); |
|
if ( event ) |
|
{ |
|
event->SetInt( "team", team ); |
|
event->SetInt( "type", (int)( pMiniGame->GetMinigameType() ) ); |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
} |
|
} |
|
|
|
if ( IsPasstimeMode() ) |
|
{ |
|
CTF_GameStats.m_passtimeStats.summary.nRoundEndReason = iWinReason; |
|
CTF_GameStats.m_passtimeStats.summary.nRoundRemainingSec = (int) GetActiveRoundTimer()->GetTimeRemaining(); |
|
CTF_GameStats.m_passtimeStats.summary.nScoreBlue = GetGlobalTFTeam( TF_TEAM_BLUE )->GetFlagCaptures(); |
|
CTF_GameStats.m_passtimeStats.summary.nScoreRed = GetGlobalTFTeam( TF_TEAM_RED )->GetFlagCaptures(); |
|
|
|
// stats reporting happens as a result of BaseClass::SetWinningTeam, but we need to make sure to |
|
// update ball carry data before stats are reported. |
|
// FIXME: refactor this so we're not calling it just for its side effects :/ |
|
CPasstimeBall *pBall = g_pPasstimeLogic->GetBall(); |
|
if ( pBall ) |
|
{ |
|
pBall->SetStateOutOfPlay(); |
|
} |
|
} |
|
|
|
CTeamplayRoundBasedRules::SetWinningTeam( team, iWinReason, bForceMapReset, bSwitchTeams, bDontAddScore, bFinal ); |
|
|
|
if ( IsCompetitiveMode() ) |
|
{ |
|
HaveAllPlayersSpeakConceptIfAllowed( IsGameOver() ? MP_CONCEPT_MATCH_OVER_COMP : MP_CONCEPT_GAME_OVER_COMP ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetStalemate( int iReason, bool bForceMapReset /* = true */, bool bSwitchTeams /* = false */ ) |
|
{ |
|
DuelMiniGame_AssignWinners(); |
|
|
|
if ( IsPasstimeMode() ) |
|
{ |
|
CTF_GameStats.m_passtimeStats.summary.bStalemate = true; |
|
CTF_GameStats.m_passtimeStats.summary.bSuddenDeath = mp_stalemate_enable.GetBool(); |
|
CTF_GameStats.m_passtimeStats.summary.bMeleeOnlySuddenDeath = mp_stalemate_meleeonly.GetBool(); |
|
} |
|
|
|
BaseClass::SetStalemate( iReason, bForceMapReset, bSwitchTeams ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
float CTFGameRules::GetPreMatchEndTime() const |
|
{ |
|
//TFTODO: implement this. |
|
return gpGlobals->curtime; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::GoToIntermission( void ) |
|
{ |
|
// Tell the clients to recalculate the holiday |
|
IGameEvent *event = gameeventmanager->CreateEvent( "recalculate_holidays" ); |
|
if ( event ) |
|
{ |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
|
|
UTIL_CalculateHolidays(); |
|
|
|
BaseClass::GoToIntermission(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::RecalculateTruce( void ) |
|
{ |
|
bool bTruceActive = false; |
|
|
|
// Call a truce if the teams are fighting a Halloween boss |
|
if ( IsHolidayActive( kHoliday_Halloween ) ) |
|
{ |
|
if ( ( IMerasmusAutoList::AutoList().Count() > 0 ) || ( IEyeballBossAutoList::AutoList().Count() > 0 ) ) |
|
{ |
|
bool bHaveActiveBoss = false; |
|
|
|
for ( int i = 0; i < IMerasmusAutoList::AutoList().Count(); ++i ) |
|
{ |
|
CMerasmus *pBoss = static_cast< CMerasmus* >( IMerasmusAutoList::AutoList()[i] ); |
|
if ( !pBoss->IsMarkedForDeletion() ) |
|
{ |
|
bHaveActiveBoss = true; |
|
} |
|
} |
|
|
|
for ( int i = 0; i < IEyeballBossAutoList::AutoList().Count(); ++i ) |
|
{ |
|
CEyeballBoss *pBoss = static_cast< CEyeballBoss* >( IEyeballBossAutoList::AutoList()[i] ); |
|
if ( !pBoss->IsMarkedForDeletion() ) |
|
{ |
|
if ( ( pBoss->GetTeamNumber() != TF_TEAM_RED ) && ( pBoss->GetTeamNumber() != TF_TEAM_BLUE ) ) |
|
{ |
|
bHaveActiveBoss = true; |
|
} |
|
} |
|
} |
|
|
|
if ( bHaveActiveBoss && ( IsValveMap() || tf_halloween_allow_truce_during_boss_event.GetBool() || IsMapForcedTruceDuringBossFight() ) ) |
|
{ |
|
bTruceActive = true; |
|
} |
|
} |
|
} |
|
|
|
#ifdef STAGING_ONLY |
|
if ( tf_truce.GetBool() ) |
|
{ |
|
bTruceActive = true; |
|
} |
|
#endif |
|
|
|
if ( m_bTruceActive != bTruceActive ) |
|
{ |
|
m_bTruceActive.Set( bTruceActive ); |
|
|
|
CReliableBroadcastRecipientFilter filter; |
|
if ( m_bTruceActive ) |
|
{ |
|
SendHudNotification( filter, HUD_NOTIFY_TRUCE_START, true ); |
|
if ( m_hGamerulesProxy ) |
|
{ |
|
m_hGamerulesProxy->TruceStart(); |
|
} |
|
} |
|
else |
|
{ |
|
SendHudNotification( filter, HUD_NOTIFY_TRUCE_END, true ); |
|
if ( m_hGamerulesProxy ) |
|
{ |
|
m_hGamerulesProxy->TruceEnd(); |
|
} |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::FPlayerCanTakeDamage( CBasePlayer *pPlayer, CBaseEntity *pAttacker, const CTakeDamageInfo &info ) |
|
{ |
|
// guard against NULL pointers if players disconnect |
|
if ( !pPlayer || !pAttacker ) |
|
return false; |
|
|
|
if ( IsTruceActive() && ( pPlayer != pAttacker ) && ( pPlayer->GetTeamNumber() != pAttacker->GetTeamNumber() ) ) |
|
{ |
|
if ( ( ( pAttacker->GetTeamNumber() == TF_TEAM_RED ) && ( pPlayer->GetTeamNumber() == TF_TEAM_BLUE ) ) || ( ( pAttacker->GetTeamNumber() == TF_TEAM_BLUE ) && ( pPlayer->GetTeamNumber() == TF_TEAM_RED ) ) ) |
|
{ |
|
CBaseEntity *pInflictor = info.GetInflictor(); |
|
if ( pInflictor ) |
|
{ |
|
return !( pInflictor->IsTruceValidForEnt() || pAttacker->IsTruceValidForEnt() ); |
|
} |
|
else |
|
{ |
|
return !pAttacker->IsTruceValidForEnt(); |
|
} |
|
} |
|
} |
|
|
|
// if pAttacker is an object, we can only do damage if pPlayer is our builder |
|
if ( pAttacker->IsBaseObject() ) |
|
{ |
|
CBaseObject *pObj = ( CBaseObject *)pAttacker; |
|
|
|
if ( pObj->GetBuilder() == pPlayer || pPlayer->GetTeamNumber() != pObj->GetTeamNumber() ) |
|
{ |
|
// Builder and enemies |
|
return true; |
|
} |
|
else |
|
{ |
|
// Teammates of the builder |
|
return false; |
|
} |
|
} |
|
|
|
// prevent eyeball rockets from hurting teammates if it's a spell |
|
if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_MONOCULUS && pAttacker->GetTeamNumber() == pPlayer->GetTeamNumber() ) |
|
{ |
|
return false; |
|
} |
|
|
|
// in PvE modes, if entities are on the same team, they can't hurt each other |
|
// this is needed since not all entities will be players |
|
if ( IsPVEModeActive() && |
|
pPlayer->GetTeamNumber() == pAttacker->GetTeamNumber() && |
|
pPlayer != pAttacker && |
|
!info.IsForceFriendlyFire() ) |
|
{ |
|
return false; |
|
} |
|
|
|
return BaseClass::FPlayerCanTakeDamage( pPlayer, pAttacker, info ); |
|
} |
|
|
|
Vector DropToGround( |
|
CBaseEntity *pMainEnt, |
|
const Vector &vPos, |
|
const Vector &vMins, |
|
const Vector &vMaxs ) |
|
{ |
|
trace_t trace; |
|
UTIL_TraceHull( vPos, vPos + Vector( 0, 0, -500 ), vMins, vMaxs, MASK_SOLID, pMainEnt, COLLISION_GROUP_NONE, &trace ); |
|
return trace.endpos; |
|
} |
|
|
|
|
|
void TestSpawnPointType( const char *pEntClassName ) |
|
{ |
|
// Find the next spawn spot. |
|
CBaseEntity *pSpot = gEntList.FindEntityByClassname( NULL, pEntClassName ); |
|
|
|
while( pSpot ) |
|
{ |
|
// trace a box here |
|
Vector vTestMins = pSpot->GetAbsOrigin() + VEC_HULL_MIN; |
|
Vector vTestMaxs = pSpot->GetAbsOrigin() + VEC_HULL_MAX; |
|
|
|
if ( UTIL_IsSpaceEmpty( pSpot, vTestMins, vTestMaxs ) ) |
|
{ |
|
// the successful spawn point's location |
|
NDebugOverlay::Box( pSpot->GetAbsOrigin(), VEC_HULL_MIN, VEC_HULL_MAX, 0, 255, 0, 100, 60 ); |
|
|
|
// drop down to ground |
|
Vector GroundPos = DropToGround( NULL, pSpot->GetAbsOrigin(), VEC_HULL_MIN, VEC_HULL_MAX ); |
|
|
|
// the location the player will spawn at |
|
NDebugOverlay::Box( GroundPos, VEC_HULL_MIN, VEC_HULL_MAX, 0, 0, 255, 100, 60 ); |
|
|
|
// draw the spawn angles |
|
QAngle spotAngles = pSpot->GetLocalAngles(); |
|
Vector vecForward; |
|
AngleVectors( spotAngles, &vecForward ); |
|
NDebugOverlay::HorzArrow( pSpot->GetAbsOrigin(), pSpot->GetAbsOrigin() + vecForward * 32, 10, 255, 0, 0, 255, true, 60 ); |
|
} |
|
else |
|
{ |
|
// failed spawn point location |
|
NDebugOverlay::Box( pSpot->GetAbsOrigin(), VEC_HULL_MIN, VEC_HULL_MAX, 255, 0, 0, 100, 60 ); |
|
} |
|
|
|
// increment pSpot |
|
pSpot = gEntList.FindEntityByClassname( pSpot, pEntClassName ); |
|
} |
|
} |
|
|
|
// -------------------------------------------------------------------------------- // |
|
|
|
void TestSpawns() |
|
{ |
|
TestSpawnPointType( "info_player_teamspawn" ); |
|
} |
|
ConCommand cc_TestSpawns( "map_showspawnpoints", TestSpawns, "Dev - test the spawn points, draws for 60 seconds", FCVAR_CHEAT ); |
|
|
|
|
|
// -------------------------------------------------------------------------------- // |
|
|
|
void cc_ShowRespawnTimes() |
|
{ |
|
CTFGameRules *pRules = TFGameRules(); |
|
CBasePlayer *pPlayer = ToBasePlayer( UTIL_GetCommandClient() ); |
|
|
|
if ( pRules && pPlayer ) |
|
{ |
|
float flRedMin = ( pRules->m_TeamRespawnWaveTimes[TF_TEAM_RED] >= 0 ? pRules->m_TeamRespawnWaveTimes[TF_TEAM_RED] : mp_respawnwavetime.GetFloat() ); |
|
float flRedScalar = pRules->GetRespawnTimeScalar( TF_TEAM_RED ); |
|
float flNextRedRespawn = pRules->GetNextRespawnWave( TF_TEAM_RED, NULL ) - gpGlobals->curtime; |
|
|
|
float flBlueMin = ( pRules->m_TeamRespawnWaveTimes[TF_TEAM_BLUE] >= 0 ? pRules->m_TeamRespawnWaveTimes[TF_TEAM_BLUE] : mp_respawnwavetime.GetFloat() ); |
|
float flBlueScalar = pRules->GetRespawnTimeScalar( TF_TEAM_BLUE ); |
|
float flNextBlueRespawn = pRules->GetNextRespawnWave( TF_TEAM_BLUE, NULL ) - gpGlobals->curtime; |
|
|
|
char tempRed[128]; |
|
Q_snprintf( tempRed, sizeof( tempRed ), "Red: Min Spawn %2.2f, Scalar %2.2f, Next Spawn In: %.2f\n", flRedMin, flRedScalar, flNextRedRespawn ); |
|
|
|
char tempBlue[128]; |
|
Q_snprintf( tempBlue, sizeof( tempBlue ), "Blue: Min Spawn %2.2f, Scalar %2.2f, Next Spawn In: %.2f\n", flBlueMin, flBlueScalar, flNextBlueRespawn ); |
|
|
|
ClientPrint( pPlayer, HUD_PRINTTALK, tempRed ); |
|
ClientPrint( pPlayer, HUD_PRINTTALK, tempBlue ); |
|
} |
|
} |
|
|
|
ConCommand mp_showrespawntimes( "mp_showrespawntimes", cc_ShowRespawnTimes, "Show the min respawn times for the teams", FCVAR_CHEAT ); |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
CBaseEntity *CTFGameRules::GetPlayerSpawnSpot( CBasePlayer *pPlayer ) |
|
{ |
|
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer ); |
|
if ( IsInItemTestingMode() && pTFPlayer->m_bItemTestingRespawn ) |
|
{ |
|
pTFPlayer->m_bItemTestingRespawn = false; |
|
return NULL; |
|
} |
|
|
|
// get valid spawn point |
|
CBaseEntity *pSpawnSpot = pPlayer->EntSelectSpawnPoint(); |
|
|
|
// drop down to ground |
|
Vector GroundPos = DropToGround( pPlayer, pSpawnSpot->GetAbsOrigin(), VEC_HULL_MIN_SCALED( pTFPlayer ), VEC_HULL_MAX_SCALED( pTFPlayer ) ); |
|
|
|
// Move the player to the place it said. |
|
pPlayer->SetLocalOrigin( GroundPos + Vector(0,0,1) ); |
|
pPlayer->SetAbsVelocity( vec3_origin ); |
|
pPlayer->SetLocalAngles( pSpawnSpot->GetLocalAngles() ); |
|
pPlayer->m_Local.m_vecPunchAngle = vec3_angle; |
|
pPlayer->m_Local.m_vecPunchAngleVel = vec3_angle; |
|
pPlayer->SnapEyeAngles( pSpawnSpot->GetLocalAngles() ); |
|
|
|
return pSpawnSpot; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Checks to see if the player is on the correct team and whether or |
|
// not the spawn point is available. |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::IsSpawnPointValid( CBaseEntity *pSpot, CBasePlayer *pPlayer, bool bIgnorePlayers, PlayerTeamSpawnMode_t nSpawnMode /* = 0*/ ) |
|
{ |
|
bool bMatchSummary = ShowMatchSummary(); |
|
|
|
// Check the team. |
|
// In Item Testing mode, bots all use the Red team spawns, and the player uses Blue |
|
if ( IsInItemTestingMode() ) |
|
{ |
|
if ( pSpot->GetTeamNumber() != (pPlayer->IsFakeClient() ? TF_TEAM_RED : TF_TEAM_BLUE) ) |
|
return false; |
|
} |
|
else |
|
{ |
|
if ( !bMatchSummary ) |
|
{ |
|
if ( pSpot->GetTeamNumber() != pPlayer->GetTeamNumber() ) |
|
return false; |
|
} |
|
} |
|
|
|
if ( !pSpot->IsTriggered( pPlayer ) ) |
|
return false; |
|
|
|
CTFTeamSpawn *pCTFSpawn = dynamic_cast<CTFTeamSpawn*>( pSpot ); |
|
if ( pCTFSpawn ) |
|
{ |
|
if ( pCTFSpawn->IsDisabled() ) |
|
return false; |
|
|
|
if ( pCTFSpawn->GetTeamSpawnMode() && pCTFSpawn->GetTeamSpawnMode() != nSpawnMode ) |
|
return false; |
|
|
|
if ( bMatchSummary ) |
|
{ |
|
if ( pCTFSpawn->AlreadyUsedForMatchSummary() ) |
|
return false; |
|
|
|
if ( pCTFSpawn->GetMatchSummaryType() == PlayerTeamSpawn_MatchSummary_Winner ) |
|
{ |
|
if ( pPlayer->GetTeamNumber() != GetWinningTeam() ) |
|
return false; |
|
} |
|
else if ( pCTFSpawn->GetMatchSummaryType() == PlayerTeamSpawn_MatchSummary_Loser ) |
|
{ |
|
if ( pPlayer->GetTeamNumber() == GetWinningTeam() ) |
|
return false; |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
} |
|
else |
|
{ |
|
if ( pCTFSpawn->GetMatchSummaryType() != PlayerTeamSpawn_MatchSummary_None ) |
|
return false; |
|
} |
|
} |
|
|
|
Vector mins = VEC_HULL_MIN_SCALED( pPlayer ); |
|
Vector maxs = VEC_HULL_MAX_SCALED( pPlayer ); |
|
|
|
if ( !bIgnorePlayers && !bMatchSummary ) |
|
{ |
|
Vector vTestMins = pSpot->GetAbsOrigin() + mins; |
|
Vector vTestMaxs = pSpot->GetAbsOrigin() + maxs; |
|
return UTIL_IsSpaceEmpty( pPlayer, vTestMins, vTestMaxs ); |
|
} |
|
|
|
trace_t trace; |
|
UTIL_TraceHull( pSpot->GetAbsOrigin(), pSpot->GetAbsOrigin(), mins, maxs, MASK_PLAYERSOLID, pPlayer, COLLISION_GROUP_PLAYER_MOVEMENT, &trace ); |
|
if ( trace.fraction == 1 && trace.allsolid != 1 && (trace.startsolid != 1) ) |
|
{ |
|
if ( bMatchSummary ) |
|
{ |
|
if ( pCTFSpawn ) |
|
{ |
|
pCTFSpawn->SetAlreadyUsedForMatchSummary(); |
|
} |
|
} |
|
|
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
Vector CTFGameRules::VecItemRespawnSpot( CItem *pItem ) |
|
{ |
|
return pItem->GetOriginalSpawnOrigin(); |
|
} |
|
|
|
QAngle CTFGameRules::VecItemRespawnAngles( CItem *pItem ) |
|
{ |
|
return pItem->GetOriginalSpawnAngles(); |
|
} |
|
|
|
int CTFGameRules::ItemShouldRespawn( CItem *pItem ) |
|
{ |
|
return BaseClass::ItemShouldRespawn( pItem ); |
|
} |
|
|
|
float CTFGameRules::FlItemRespawnTime( CItem *pItem ) |
|
{ |
|
return ITEM_RESPAWN_TIME; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
const char *CTFGameRules::GetChatFormat( bool bTeamOnly, CBasePlayer *pPlayer ) |
|
{ |
|
if ( !pPlayer ) // dedicated server output |
|
{ |
|
return NULL; |
|
} |
|
|
|
const char *pszFormat = NULL; |
|
|
|
// coach? |
|
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer ); |
|
if ( pTFPlayer && pTFPlayer->IsCoaching() ) |
|
{ |
|
pszFormat = "TF_Chat_Coach"; |
|
} |
|
// team only |
|
else if ( bTeamOnly == true ) |
|
{ |
|
if ( pPlayer->GetTeamNumber() == TEAM_SPECTATOR ) |
|
{ |
|
pszFormat = "TF_Chat_Spec"; |
|
} |
|
else |
|
{ |
|
if ( pPlayer->IsAlive() == false && State_Get() != GR_STATE_TEAM_WIN ) |
|
{ |
|
pszFormat = "TF_Chat_Team_Dead"; |
|
} |
|
else |
|
{ |
|
const char *chatLocation = GetChatLocation( bTeamOnly, pPlayer ); |
|
if ( chatLocation && *chatLocation ) |
|
{ |
|
pszFormat = "TF_Chat_Team_Loc"; |
|
} |
|
else |
|
{ |
|
pszFormat = "TF_Chat_Team"; |
|
} |
|
} |
|
} |
|
} |
|
// everyone |
|
else |
|
{ |
|
if ( pPlayer->GetTeamNumber() == TEAM_SPECTATOR ) |
|
{ |
|
pszFormat = "TF_Chat_AllSpec"; |
|
} |
|
else |
|
{ |
|
if ( pPlayer->IsAlive() == false && State_Get() != GR_STATE_TEAM_WIN ) |
|
{ |
|
pszFormat = "TF_Chat_AllDead"; |
|
} |
|
else |
|
{ |
|
pszFormat = "TF_Chat_All"; |
|
} |
|
} |
|
} |
|
|
|
return pszFormat; |
|
} |
|
|
|
VoiceCommandMenuItem_t *CTFGameRules::VoiceCommand( CBaseMultiplayerPlayer *pPlayer, int iMenu, int iItem ) |
|
{ |
|
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer ); |
|
if ( pTFPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) ) |
|
{ |
|
engine->ClientCommand( pTFPlayer->edict(), "boo" ); |
|
return NULL; |
|
} |
|
|
|
VoiceCommandMenuItem_t *pItem = BaseClass::VoiceCommand( pPlayer, iMenu, iItem ); |
|
|
|
if ( pItem ) |
|
{ |
|
int iActivity = ActivityList_IndexForName( pItem->m_szGestureActivity ); |
|
|
|
if ( iActivity != ACT_INVALID ) |
|
{ |
|
if ( pTFPlayer ) |
|
{ |
|
pTFPlayer->DoAnimationEvent( PLAYERANIMEVENT_VOICE_COMMAND_GESTURE, iActivity ); |
|
|
|
// Note when we call for a Medic. |
|
// Hardcoding this for menu 0, item 0 is an ugly hack, but we don't have a good way to |
|
// translate this at this level without plumbing a through bunch of stuff (MSB) |
|
if ( iMenu == 0 && iItem == 0 ) |
|
{ |
|
pTFPlayer->NoteMedicCall(); |
|
} |
|
} |
|
} |
|
} |
|
|
|
return pItem; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Actually change a player's name. |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::ChangePlayerName( CTFPlayer *pPlayer, const char *pszNewName ) |
|
{ |
|
const char *pszOldName = pPlayer->GetPlayerName(); |
|
|
|
// Check if they can change their name |
|
// don't show when bots change their names in PvE mode |
|
if ( State_Get() != GR_STATE_STALEMATE && !( IsPVEModeActive() && pPlayer->IsBot() ) ) |
|
{ |
|
CReliableBroadcastRecipientFilter filter; |
|
UTIL_SayText2Filter( filter, pPlayer, false, "#TF_Name_Change", pszOldName, pszNewName ); |
|
|
|
IGameEvent * event = gameeventmanager->CreateEvent( "player_changename" ); |
|
if ( event ) |
|
{ |
|
event->SetInt( "userid", pPlayer->GetUserID() ); |
|
event->SetString( "oldname", pszOldName ); |
|
event->SetString( "newname", pszNewName ); |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
} |
|
|
|
pPlayer->SetPlayerName( pszNewName ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::ClientSettingsChanged( CBasePlayer *pPlayer ) |
|
{ |
|
const char *pszName = engine->GetClientConVarValue( pPlayer->entindex(), "name" ); |
|
|
|
const char *pszOldName = pPlayer->GetPlayerName(); |
|
|
|
CTFPlayer *pTFPlayer = (CTFPlayer*)pPlayer; |
|
|
|
// msg everyone if someone changes their name, and it isn't the first time (changing no name to current name) |
|
// Note, not using FStrEq so that this is case sensitive |
|
if ( pszOldName[0] != 0 && Q_strncmp( pszOldName, pszName, MAX_PLAYER_NAME_LENGTH-1 ) ) |
|
{ |
|
ChangePlayerName( pTFPlayer, pszName ); |
|
} |
|
|
|
// keep track of their hud_classautokill value |
|
int nClassAutoKill = Q_atoi( engine->GetClientConVarValue( pPlayer->entindex(), "hud_classautokill" ) ); |
|
pTFPlayer->SetHudClassAutoKill( nClassAutoKill > 0 ? true : false ); |
|
|
|
// keep track of their tf_medigun_autoheal value |
|
pTFPlayer->SetMedigunAutoHeal( Q_atoi( engine->GetClientConVarValue( pPlayer->entindex(), "tf_medigun_autoheal" ) ) > 0 ); |
|
|
|
// keep track of their cl_autorezoom value |
|
pTFPlayer->SetAutoRezoom( Q_atoi( engine->GetClientConVarValue( pPlayer->entindex(), "cl_autorezoom" ) ) > 0 ); |
|
pTFPlayer->SetAutoReload( Q_atoi( engine->GetClientConVarValue( pPlayer->entindex(), "cl_autoreload" ) ) > 0 ); |
|
|
|
// keep track of their tf_remember_lastswitched value |
|
pTFPlayer->SetRememberActiveWeapon( Q_atoi( engine->GetClientConVarValue( pPlayer->entindex(), "tf_remember_activeweapon" ) ) > 0 ); |
|
pTFPlayer->SetRememberLastWeapon( Q_atoi( engine->GetClientConVarValue( pPlayer->entindex(), "tf_remember_lastswitched" ) ) > 0 ); |
|
|
|
const char *pszFov = engine->GetClientConVarValue( pPlayer->entindex(), "fov_desired" ); |
|
int iFov = atoi(pszFov); |
|
iFov = clamp( iFov, 75, MAX_FOV ); |
|
|
|
pTFPlayer->SetDefaultFOV( iFov ); |
|
|
|
pTFPlayer->m_bFlipViewModels = Q_strcmp( engine->GetClientConVarValue( pPlayer->entindex(), "cl_flipviewmodels" ), "1" ) == 0; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Return true if the specified player can carry any more of the ammo type |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::CanHaveAmmo( CBaseCombatCharacter *pPlayer, int iAmmoIndex ) |
|
{ |
|
if ( iAmmoIndex > -1 ) |
|
{ |
|
CTFPlayer *pTFPlayer = (CTFPlayer*)pPlayer; |
|
|
|
if ( pTFPlayer ) |
|
{ |
|
// Get the max carrying capacity for this ammo |
|
int iMaxCarry = pTFPlayer->GetMaxAmmo(iAmmoIndex); |
|
|
|
// Does the player have room for more of this type of ammo? |
|
if ( pTFPlayer->GetAmmoCount( iAmmoIndex ) < iMaxCarry ) |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool EconEntity_KillEaterEventPassesRestrictionCheck( const IEconItemInterface *pEconInterface, const CEconItemAttributeDefinition *pRestrictionAttribDef, const CEconItemAttributeDefinition *pRestrictionValueAttribDef, const CSteamID VictimSteamID ) |
|
{ |
|
uint32 unRestrictionType = kStrangeEventRestriction_None; |
|
attrib_value_t unRestrictionValue; |
|
DbgVerify( pEconInterface->FindAttribute( pRestrictionAttribDef, &unRestrictionType ) == |
|
pEconInterface->FindAttribute( pRestrictionValueAttribDef, &unRestrictionValue ) ); |
|
|
|
switch (unRestrictionType) |
|
{ |
|
case kStrangeEventRestriction_None: |
|
return true; |
|
|
|
case kStrangeEventRestriction_Map: |
|
{ |
|
const MapDef_t *pMap = GetItemSchema()->GetMasterMapDefByName(STRING(gpGlobals->mapname)); |
|
return pMap && pMap->m_nDefIndex == unRestrictionValue; |
|
} |
|
case kStrangeEventRestriction_VictimSteamAccount: |
|
return VictimSteamID.GetAccountID() == unRestrictionValue; |
|
case kStrangeEventRestriction_Competitive: |
|
{ |
|
if ( TFGameRules() && TFGameRules()->IsMatchTypeCompetitive() ) |
|
{ |
|
// Match Season unRestrictionValue == Season Number |
|
return true; |
|
} |
|
return false; |
|
} |
|
} // end Switch |
|
|
|
AssertMsg1( false, "Unhandled strange event restriction %u!", unRestrictionType ); |
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
static CSteamID GetSteamIDForKillEaterScoring( CTFPlayer *pPlayer ) |
|
{ |
|
if ( pPlayer->IsBot() ) |
|
return k_steamIDNil; |
|
|
|
CSteamID ret; |
|
if ( !pPlayer->GetSteamID( &ret ) ) |
|
return k_steamIDNil; |
|
|
|
return ret; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
class CStrangeEventValidator |
|
{ |
|
public: |
|
CStrangeEventValidator( IEconItemInterface *pEconEntity, CTFPlayer *pOwner, CTFPlayer *pVictim, kill_eater_event_t eEventType ) |
|
: m_unItemID( INVALID_ITEM_ID ) |
|
, m_eEventType( eEventType ) |
|
{ |
|
m_bIsValid = BInitEventParams( pEconEntity, pOwner, pVictim ); |
|
} |
|
|
|
bool BIsValidEvent() const { return m_bIsValid; } |
|
CSteamID GetKillerSteamID() const { Assert( m_bIsValid ); return m_KillerSteamID; } |
|
CSteamID GetVictimSteamID() const { Assert( m_bIsValid ); return m_VictimSteamID; } |
|
itemid_t GetItemID() const { Assert( m_bIsValid ); return m_unItemID; } |
|
kill_eater_event_t GetEventType() const { Assert( m_bIsValid ); return m_eEventType; } |
|
|
|
private: |
|
bool BInitEventParams( IEconItemInterface *pEconEntity, CTFPlayer *pOwner, CTFPlayer *pVictim ) |
|
{ |
|
static CSchemaAttributeDefHandle pAttrDef_KillEater( "kill eater" ); |
|
|
|
// Kill-eater weapons. |
|
if ( !pEconEntity ) |
|
return false; |
|
|
|
if ( !pOwner ) |
|
return false; |
|
|
|
if ( !pVictim ) |
|
return false; |
|
|
|
// Ignore events where we're affecting ourself. |
|
if ( pOwner == pVictim ) |
|
return false; |
|
|
|
// Store off our item ID for reference post-init. |
|
m_unItemID = pEconEntity->GetID(); |
|
|
|
// Always require that we have at least the base kill eater attribute before sending any messages |
|
// to the GC. |
|
if ( !pEconEntity->FindAttribute( pAttrDef_KillEater ) ) |
|
return false; |
|
|
|
// Don't bother sending a message to the GC if either party is a bot, unless we're tracking events against |
|
// bots specifically. |
|
if ( !pOwner->GetSteamID( &m_KillerSteamID ) ) |
|
return false; |
|
|
|
m_VictimSteamID = GetSteamIDForKillEaterScoring( pVictim ); |
|
if ( !m_VictimSteamID.IsValid() ) |
|
{ |
|
if ( !GetItemSchema()->GetKillEaterScoreTypeAllowsBotVictims( m_eEventType ) ) |
|
return false; |
|
} |
|
|
|
// Also require that we have whatever event type we're looking for, unless we're looking for regular |
|
// player kills in which case we may or may not have a field to describe that. |
|
for ( int i = 0; i < GetKillEaterAttrCount(); i++ ) |
|
{ |
|
const CEconItemAttributeDefinition *pScoreAttribDef = GetKillEaterAttr_Score(i); |
|
if ( !pScoreAttribDef ) |
|
continue; |
|
|
|
// If we don't have this attribute, move on. It's possible to be missing this attribute but still |
|
// have the next one in the list if we have user-customized tracking types. |
|
if ( !pEconEntity->FindAttribute( pScoreAttribDef ) ) |
|
continue; |
|
|
|
const CEconItemAttributeDefinition *pScoreTypeAttribDef = GetKillEaterAttr_Type(i); |
|
if ( !pScoreTypeAttribDef ) |
|
continue; |
|
|
|
// If we're missing our type attribute, we interpret that as "track kills" -- none of the original |
|
// kill eaters have score type attributes. |
|
float fKillEaterEventType; |
|
kill_eater_event_t eMatchEvent = FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pEconEntity, pScoreTypeAttribDef, &fKillEaterEventType ) |
|
? (kill_eater_event_t)(int)fKillEaterEventType |
|
: kKillEaterEvent_PlayerKill; |
|
|
|
if ( m_eEventType == eMatchEvent ) |
|
{ |
|
// Does this attribute also specify a restriction (ie., "has to be on this specific map" or "has to be |
|
// against this specific account"? If so, only count this as a match if the restriction check passes. |
|
if ( EconEntity_KillEaterEventPassesRestrictionCheck( pEconEntity, GetKillEaterAttr_Restriction(i), GetKillEaterAttr_RestrictionValue(i), m_VictimSteamID ) ) |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
private: |
|
bool m_bIsValid; |
|
CSteamID m_KillerSteamID; |
|
CSteamID m_VictimSteamID; |
|
itemid_t m_unItemID; |
|
kill_eater_event_t m_eEventType; |
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
template < typename tMsgType > |
|
static void FillOutBaseKillEaterMessage( tMsgType *out_pMsg, const CStrangeEventValidator& Validator ) |
|
{ |
|
Assert( out_pMsg ); |
|
Assert( Validator.BIsValidEvent() ); |
|
|
|
out_pMsg->set_killer_steam_id( Validator.GetKillerSteamID().ConvertToUint64() ); |
|
out_pMsg->set_victim_steam_id( Validator.GetVictimSteamID().ConvertToUint64() ); |
|
out_pMsg->set_item_id( Validator.GetItemID() ); |
|
out_pMsg->set_event_type( Validator.GetEventType() ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Get the actual killeater weapon from a CTakeDamageInfo |
|
//----------------------------------------------------------------------------- |
|
CTFWeaponBase *GetKilleaterWeaponFromDamageInfo( const CTakeDamageInfo *pInfo ) |
|
{ |
|
CTFWeaponBase *pTFWeapon = dynamic_cast<CTFWeaponBase *>( pInfo->GetWeapon() ); |
|
CBaseEntity* pInflictor = pInfo->GetInflictor(); |
|
|
|
// If there's no weapon specified, it might have been from a sentry |
|
if ( !pTFWeapon ) |
|
{ |
|
// If a sentry did the damage with bullets, it's the inflictor |
|
CObjectSentrygun *pSentrygun = dynamic_cast<CObjectSentrygun *>( pInflictor ); |
|
if ( !pSentrygun ) |
|
{ |
|
// If a sentry's rocket did the damage, then the rocket is the inflictor, and the sentry is the rocket's owner |
|
pSentrygun = pInflictor ? dynamic_cast<CObjectSentrygun *>( pInflictor->GetOwnerEntity() ) : NULL; |
|
} |
|
|
|
if ( pSentrygun ) |
|
{ |
|
// Maybe they were using a Wrangler? The builder is the player who owns the sentry |
|
CTFPlayer *pBuilder = pSentrygun->GetBuilder(); |
|
if ( pBuilder ) |
|
{ |
|
// Check if they have a Wrangler and were aiming with it |
|
CTFLaserPointer* pLaserPointer = dynamic_cast< CTFLaserPointer * >( pBuilder->GetEntityForLoadoutSlot( LOADOUT_POSITION_SECONDARY ) ); |
|
if ( pLaserPointer && pLaserPointer->HasLaserDot() ) |
|
{ |
|
pTFWeapon = pLaserPointer; |
|
} |
|
} |
|
} |
|
} |
|
|
|
// need to check for deflected projectiles so the weapon that did the most recent |
|
// deflection will get the killeater credit instead of the original launcher |
|
if ( pInflictor ) |
|
{ |
|
CTFWeaponBaseGrenadeProj *pBaseGrenade = dynamic_cast< CTFWeaponBaseGrenadeProj* >( pInflictor ); |
|
if ( pBaseGrenade ) |
|
{ |
|
if ( pBaseGrenade->GetDeflected() && pBaseGrenade->GetLauncher() ) |
|
{ |
|
pTFWeapon = dynamic_cast< CTFWeaponBase* >( pBaseGrenade->GetLauncher() ); |
|
} |
|
} |
|
else |
|
{ |
|
CTFBaseRocket *pRocket = dynamic_cast< CTFBaseRocket* >( pInflictor ); |
|
if ( pRocket ) |
|
{ |
|
if ( pRocket->GetDeflected() && pRocket->GetLauncher() ) |
|
{ |
|
pTFWeapon = dynamic_cast< CTFWeaponBase* >( pRocket->GetLauncher() ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
return pTFWeapon; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
void EconEntity_ValidateAndSendStrangeMessageToGC( IEconItemInterface *pEconEntity, CTFPlayer *pOwner, CTFPlayer *pVictim, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ ) |
|
{ |
|
CStrangeEventValidator Validator( pEconEntity, pOwner, pVictim, eEventType ); |
|
|
|
if ( !Validator.BIsValidEvent() ) |
|
return; |
|
|
|
GCSDK::CProtoBufMsg<CMsgIncrementKillCountAttribute> msg( k_EMsgGC_IncrementKillCountAttribute ); |
|
FillOutBaseKillEaterMessage( &msg.Body(), Validator ); |
|
|
|
if ( nIncrementValue != 1 ) |
|
{ |
|
msg.Body().set_increment_value( nIncrementValue ); |
|
} |
|
|
|
GCClientSystem()->BSendMessage( msg ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void EconEntity_OnOwnerKillEaterEvent( CEconEntity *pEconEntity, CTFPlayer *pOwner, CTFPlayer *pVictim, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ ) |
|
{ |
|
if ( !pEconEntity ) |
|
return; |
|
|
|
EconItemInterface_OnOwnerKillEaterEvent( pEconEntity->GetAttributeContainer()->GetItem(), pOwner, pVictim, eEventType, nIncrementValue ); |
|
} |
|
//----------------------------------------------------------------------------- |
|
void EconItemInterface_OnOwnerKillEaterEvent( IEconItemInterface *pEconEntity, CTFPlayer *pOwner, CTFPlayer *pVictim, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ ) |
|
{ |
|
bool bEconEntityHandled = false; |
|
|
|
// Fire the kill eater event on all wearables |
|
// Wearables can have all Strange parts |
|
for ( int i = 0; i < pOwner->GetNumWearables(); ++i ) |
|
{ |
|
CTFWearable *pWearableItem = dynamic_cast<CTFWearable *>( pOwner->GetWearable( i ) ); |
|
if ( !pWearableItem ) |
|
continue; |
|
|
|
if ( !pWearableItem->GetAttributeContainer() ) |
|
continue; |
|
|
|
EconEntity_ValidateAndSendStrangeMessageToGC( pWearableItem->GetAttributeContainer()->GetItem(), pOwner, pVictim, eEventType, nIncrementValue ); |
|
|
|
if ( pWearableItem->GetAttributeContainer()->GetItem() == pEconEntity ) |
|
{ |
|
bEconEntityHandled = true; |
|
} |
|
} |
|
|
|
if ( !bEconEntityHandled ) |
|
{ |
|
EconEntity_ValidateAndSendStrangeMessageToGC( pEconEntity, pOwner, pVictim, eEventType, nIncrementValue ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void EconEntity_OnOwnerKillEaterEventNoPartner( CEconEntity *pEconEntity, CTFPlayer *pOwner, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ ) |
|
{ |
|
if ( !pEconEntity ) |
|
return; |
|
|
|
EconItemInterface_OnOwnerKillEaterEventNoPartner( pEconEntity->GetAttributeContainer()->GetItem(), pOwner, eEventType, nIncrementValue ); |
|
} |
|
//----------------------------------------------------------------------------- |
|
void EconItemInterface_OnOwnerKillEaterEventNoPartner( IEconItemInterface *pEconEntity, CTFPlayer *pOwner, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ ) |
|
{ |
|
// Look for another player to pass in. We do two passes over the list of candidates. |
|
// First we look for anyone that we know is a real player. If we don't find any of |
|
// those then we pass in a known bot. This means that things that allow bots will |
|
// still find one and work, but event types that don't allow bots won't be dependent |
|
// on the order of players in the list. |
|
for( int iPass = 1; iPass <= 2; iPass++ ) |
|
{ |
|
for( int playerIndex = 1; playerIndex <= MAX_PLAYERS; playerIndex++ ) |
|
{ |
|
CTFPlayer *pOtherPlayer = ToTFPlayer( UTIL_PlayerByIndex( playerIndex ) ); |
|
if ( !pOtherPlayer ) |
|
continue; |
|
|
|
// Ignore ourself. |
|
if ( pOtherPlayer == pOwner ) |
|
continue; |
|
|
|
|
|
const bool bCandidatePasses = (iPass == 1 && GetSteamIDForKillEaterScoring( pOtherPlayer ).IsValid()) // if we have a real Steam ID we're golden |
|
|| (iPass == 2); // or if we made it to the second pass, any valid player pointer is as good as any other |
|
if ( bCandidatePasses ) |
|
{ |
|
EconItemInterface_OnOwnerKillEaterEvent( pEconEntity, pOwner, pOtherPlayer, eEventType, nIncrementValue ); |
|
return; |
|
} |
|
} |
|
} |
|
|
|
// We couldn't find anyone else at all. This is hard. Let's give up. |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
static GCSDK::CProtoBufMsg<CMsgIncrementKillCountAttribute_Multiple> *s_pmsgIncrementKillCountMessageBatch = NULL; |
|
//----------------------------------------------------------------------------- |
|
void EconEntity_ValidateAndSendStrangeMessageToGC_Batched( IEconItemInterface *pEconInterface, class CTFPlayer *pOwner, class CTFPlayer *pVictim, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ ) |
|
{ |
|
CStrangeEventValidator Validator( pEconInterface, pOwner, pVictim, eEventType ); |
|
|
|
if ( !Validator.BIsValidEvent() ) |
|
return; |
|
|
|
// This has to be dynamically allocated because we can't static-init a protobuf message at startup type. |
|
if ( !s_pmsgIncrementKillCountMessageBatch ) |
|
{ |
|
s_pmsgIncrementKillCountMessageBatch = new GCSDK::CProtoBufMsg<CMsgIncrementKillCountAttribute_Multiple>( k_EMsgGC_IncrementKillCountAttribute_Multiple ); |
|
} |
|
|
|
// Look for an existing message that matches this user and this event. |
|
for ( int i = 0; i < s_pmsgIncrementKillCountMessageBatch->Body().msgs_size(); i++ ) |
|
{ |
|
CMsgIncrementKillCountAttribute *pMsg = s_pmsgIncrementKillCountMessageBatch->Body().mutable_msgs( i ); |
|
Assert( pMsg ); |
|
|
|
if ( pMsg->killer_steam_id() == Validator.GetKillerSteamID().ConvertToUint64() && |
|
pMsg->victim_steam_id() == Validator.GetVictimSteamID().ConvertToUint64() && |
|
pMsg->item_id() == Validator.GetItemID() && |
|
(kill_eater_event_t)pMsg->event_type() == Validator.GetEventType() ) |
|
{ |
|
// We found an existing entry for this message. All we want to do is add to the stat we're tracking |
|
// but still send up this single message. |
|
Assert( pMsg->has_increment_value() ); |
|
|
|
pMsg->set_increment_value( pMsg->increment_value() + nIncrementValue ); |
|
return; |
|
} |
|
} |
|
|
|
// We don't have an existing entry, so make a new one. |
|
CMsgIncrementKillCountAttribute *pNewMsg = s_pmsgIncrementKillCountMessageBatch->Body().add_msgs(); |
|
|
|
FillOutBaseKillEaterMessage( pNewMsg, Validator ); |
|
pNewMsg->set_increment_value( nIncrementValue ); |
|
} |
|
//----------------------------------------------------------------------------- |
|
void EconEntity_OnOwnerKillEaterEvent_Batched( CEconEntity *pEconEntity, class CTFPlayer *pOwner, class CTFPlayer *pVictim, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ ) |
|
{ |
|
if ( !pEconEntity ) |
|
return; |
|
|
|
EconItemInterface_OnOwnerKillEaterEvent_Batched( pEconEntity->GetAttributeContainer()->GetItem(), pOwner, pVictim, eEventType, nIncrementValue ); |
|
} |
|
//----------------------------------------------------------------------------- |
|
void EconItemInterface_OnOwnerKillEaterEvent_Batched( IEconItemInterface *pEconInterface, class CTFPlayer *pOwner, class CTFPlayer *pVictim, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ ) |
|
{ |
|
for ( int i = 0; i < pOwner->GetNumWearables(); ++i ) |
|
{ |
|
CTFWearable *pWearableItem = dynamic_cast<CTFWearable *>( pOwner->GetWearable( i ) ); |
|
if ( !pWearableItem ) |
|
continue; |
|
|
|
if ( !pWearableItem->GetAttributeContainer() ) |
|
continue; |
|
|
|
CEconItemView *pEconItemView = pWearableItem->GetAttributeContainer()->GetItem(); |
|
if ( !pEconItemView ) |
|
continue; |
|
|
|
EconEntity_ValidateAndSendStrangeMessageToGC_Batched( pWearableItem->GetAttributeContainer()->GetItem(), pOwner, pVictim, eEventType, nIncrementValue ); |
|
} |
|
|
|
EconEntity_ValidateAndSendStrangeMessageToGC_Batched( pEconInterface, pOwner, pVictim, eEventType, nIncrementValue ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void KillEaterEvents_FlushBatches() |
|
{ |
|
if ( s_pmsgIncrementKillCountMessageBatch ) |
|
{ |
|
Assert( s_pmsgIncrementKillCountMessageBatch->Body().msgs_size() > 0 ); |
|
|
|
GCClientSystem()->BSendMessage( *s_pmsgIncrementKillCountMessageBatch ); |
|
|
|
delete s_pmsgIncrementKillCountMessageBatch; |
|
s_pmsgIncrementKillCountMessageBatch = NULL; |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void HatAndMiscEconEntities_OnOwnerKillEaterEventNoParter( class CTFPlayer *pOwner, kill_eater_event_t eEventType, int nIncrementValue ) |
|
{ |
|
EconItemInterface_OnOwnerKillEaterEventNoPartner( NULL, pOwner, eEventType, nIncrementValue ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
void HatAndMiscEconEntities_OnOwnerKillEaterEvent( class CTFPlayer *pOwner, class CTFPlayer *pVictim, kill_eater_event_t eEventType, int nIncrementValue ) |
|
{ |
|
EconItemInterface_OnOwnerKillEaterEvent( NULL, pOwner, pVictim, eEventType, nIncrementValue ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
void EconEntity_OnOwnerUniqueEconEvent( IEconItemInterface *pEconEntity, CTFPlayer *pOwner, CTFPlayer *pVictim, kill_eater_event_t eEventType ) |
|
{ |
|
CStrangeEventValidator Validator( pEconEntity, pOwner, pVictim, eEventType ); |
|
|
|
if ( !Validator.BIsValidEvent() ) |
|
return; |
|
|
|
GCSDK::CProtoBufMsg<CMsgTrackUniquePlayerPairEvent> msg( k_EMsgGC_TrackUniquePlayerPairEvent ); |
|
FillOutBaseKillEaterMessage( &msg.Body(), Validator ); |
|
|
|
GCClientSystem()->BSendMessage( msg ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
void EconEntity_OnOwnerUniqueEconEvent( CEconEntity *pEconEntity, CTFPlayer *pOwner, CTFPlayer *pVictim, kill_eater_event_t eEventType ) |
|
{ |
|
if ( !pEconEntity ) |
|
return; |
|
EconEntity_OnOwnerUniqueEconEvent( pEconEntity->GetAttributeContainer()->GetItem(), pOwner, pVictim, eEventType ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
void EconEntity_NonEquippedItemKillTracking( CTFPlayer *pOwner, CTFPlayer *pVictim, item_definition_index_t iDefIndex, kill_eater_event_t eEventType, int nIncrementValue = 1 ) |
|
{ |
|
// Validate |
|
if ( !pOwner || !pVictim || pOwner == pVictim ) |
|
return; |
|
|
|
#ifndef STAGING_ONLY |
|
if ( pOwner->IsBot() || pVictim->IsBot() ) |
|
return; |
|
#endif |
|
|
|
CSteamID pOwnerSteamID; |
|
CSteamID pVictimSteamID; |
|
if ( !pOwner->GetSteamID( &pOwnerSteamID ) || !pVictim->GetSteamID( &pVictimSteamID ) ) |
|
return; |
|
|
|
// Current date |
|
static CSchemaAttributeDefHandle pAttrDef_DeactiveDate( "deactive date" ); |
|
uint32 unCurrentDate = CRTime::RTime32TimeCur(); |
|
|
|
CEconItemView *pNonEquippedItem = pOwner->Inventory()->GetFirstItemOfItemDef( iDefIndex, pOwner->Inventory() ); |
|
if ( pNonEquippedItem ) |
|
{ |
|
// Check the date |
|
uint32 unDeactiveDate = 0; |
|
if ( !pNonEquippedItem->FindAttribute( pAttrDef_DeactiveDate, &unDeactiveDate ) || unDeactiveDate > unCurrentDate ) |
|
{ |
|
GCSDK::CProtoBufMsg<CMsgIncrementKillCountAttribute> msg( k_EMsgGC_IncrementKillCountAttribute ); |
|
msg.Body().set_killer_steam_id( pOwnerSteamID.ConvertToUint64() ); |
|
msg.Body().set_victim_steam_id( pVictimSteamID.ConvertToUint64() ); |
|
|
|
if ( nIncrementValue > 1 ) |
|
{ |
|
msg.Body().set_increment_value( nIncrementValue ); |
|
} |
|
|
|
msg.Body().set_item_id( pNonEquippedItem->GetID() ); |
|
msg.Body().set_event_type( eEventType ); |
|
GCClientSystem()->BSendMessage( msg ); |
|
} |
|
} |
|
|
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
void EconEntity_NonEquippedItemKillTracking_NoPartner( CTFPlayer *pOwner, item_definition_index_t iDefIndex, kill_eater_event_t eEventType, int nIncrementValue ) |
|
{ |
|
// Find a partner or give up |
|
for( int iPass = 1; iPass <= 2; iPass++ ) |
|
{ |
|
for( int playerIndex = 1; playerIndex <= MAX_PLAYERS; playerIndex++ ) |
|
{ |
|
CTFPlayer *pOtherPlayer = ToTFPlayer( UTIL_PlayerByIndex( playerIndex ) ); |
|
if ( !pOtherPlayer ) |
|
continue; |
|
|
|
// Ignore ourself. |
|
if ( pOtherPlayer == pOwner ) |
|
continue; |
|
|
|
|
|
const bool bCandidatePasses = (iPass == 1 && GetSteamIDForKillEaterScoring( pOtherPlayer ).IsValid()) // if we have a real Steam ID we're golden |
|
|| (iPass == 2); // or if we made it to the second pass, any valid player pointer is as good as any other |
|
|
|
if ( bCandidatePasses ) |
|
{ |
|
EconEntity_NonEquippedItemKillTracking( pOwner, pOtherPlayer, iDefIndex, eEventType, nIncrementValue ); |
|
return; |
|
} |
|
} |
|
} |
|
} |
|
|
|
void EconEntity_NonEquippedItemKillTracking_NoPartnerBatched( class CTFPlayer *pOwner, item_definition_index_t iDefIndex, kill_eater_event_t eEventType, int nIncrementValue ) |
|
{ |
|
// Find a partner or give up |
|
for ( int iPass = 1; iPass <= 2; iPass++ ) |
|
{ |
|
for ( int playerIndex = 1; playerIndex <= MAX_PLAYERS; playerIndex++ ) |
|
{ |
|
CTFPlayer *pOtherPlayer = ToTFPlayer( UTIL_PlayerByIndex( playerIndex ) ); |
|
if ( !pOtherPlayer ) |
|
continue; |
|
|
|
// Ignore ourself. |
|
if ( pOtherPlayer == pOwner ) |
|
continue; |
|
|
|
|
|
const bool bCandidatePasses = ( iPass == 1 && GetSteamIDForKillEaterScoring( pOtherPlayer ).IsValid() ) // if we have a real Steam ID we're golden |
|
|| ( iPass == 2 ); // or if we made it to the second pass, any valid player pointer is as good as any other |
|
|
|
if ( bCandidatePasses ) |
|
{ |
|
// find the item |
|
// Current date |
|
static CSchemaAttributeDefHandle pAttrDef_DeactiveDate( "deactive date" ); |
|
uint32 unCurrentDate = CRTime::RTime32TimeCur(); |
|
|
|
CEconItemView *pNonEquippedItem = pOwner->Inventory()->GetFirstItemOfItemDef( iDefIndex, pOwner->Inventory() ); |
|
if ( pNonEquippedItem ) |
|
{ |
|
uint32 unDeactiveDate = 0; |
|
if ( !pNonEquippedItem->FindAttribute( pAttrDef_DeactiveDate, &unDeactiveDate ) || unDeactiveDate > unCurrentDate ) |
|
{ |
|
EconEntity_ValidateAndSendStrangeMessageToGC_Batched( pNonEquippedItem, pOwner, pOtherPlayer, eEventType, nIncrementValue ); |
|
} |
|
} |
|
|
|
return; |
|
} |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// TODO: Remove this call and only use the one above |
|
//----------------------------------------------------------------------------- |
|
void EconEntity_NonEquippedItemKillTracking( CTFPlayer *pOwner, CTFPlayer *pVictim, int nIncrementValue ) |
|
{ |
|
// Validate |
|
if ( !pOwner || !pVictim || pOwner == pVictim ) |
|
return; |
|
|
|
if ( pOwner->IsBot() || pVictim->IsBot() ) |
|
return; |
|
|
|
CSteamID pOwnerSteamID; |
|
CSteamID pVictimSteamID; |
|
if ( ! pOwner->GetSteamID( &pOwnerSteamID ) || !pVictim->GetSteamID( &pVictimSteamID ) ) |
|
return; |
|
|
|
// Find any active operation |
|
const auto& mapOperations = GetItemSchema()->GetOperationDefinitions(); |
|
FOR_EACH_MAP_FAST( mapOperations, i ) |
|
{ |
|
CEconOperationDefinition* pOperation = mapOperations[i]; |
|
if ( pOperation->IsActive() && pOperation->IsCampaign() ) |
|
{ |
|
EconEntity_NonEquippedItemKillTracking( pOwner, pVictim, pOperation->GetRequiredItemDefIndex(), kKillEaterEvent_CosmeticOperationKills, nIncrementValue ); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Sends a soul with the specified value to every living member of the |
|
// specified team, originating from vecPosition. |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::DropHalloweenSoulPackToTeam( int nAmount, const Vector& vecPosition, int nTeamNumber, int nSourceTeam ) |
|
{ |
|
for( int iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ ) |
|
{ |
|
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) ); |
|
if ( !pTFPlayer || !pTFPlayer->IsConnected() ) |
|
continue; |
|
|
|
if ( pTFPlayer->GetTeamNumber() != nTeamNumber || !pTFPlayer->IsAlive() || pTFPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) ) |
|
continue; |
|
|
|
DropHalloweenSoulPack( nAmount, vecPosition, pTFPlayer, nSourceTeam ); |
|
} |
|
} |
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::DropHalloweenSoulPack( int nAmount, const Vector& vecSource, CBaseEntity *pTarget, int nSourceTeam ) |
|
{ |
|
QAngle angles(0,0,0); |
|
CHalloweenSoulPack *pSoulsPack = assert_cast<CHalloweenSoulPack*>( CBaseEntity::CreateNoSpawn( "halloween_souls_pack", vecSource, angles, NULL ) ); |
|
|
|
if ( pSoulsPack ) |
|
{ |
|
pSoulsPack->SetTarget( pTarget ); |
|
pSoulsPack->SetAmount( nAmount ); |
|
pSoulsPack->ChangeTeam( nSourceTeam ); |
|
|
|
DispatchSpawn( pSoulsPack ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::ShouldDropSpellPickup() |
|
{ |
|
if ( IsUsingSpells() ) |
|
{ |
|
return RandomFloat() <= tf_player_spell_drop_on_death_rate.GetFloat(); |
|
} |
|
return false; |
|
} |
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::DropSpellPickup( const Vector& vPosition, int nTier /*= 0*/ ) const |
|
{ |
|
if ( !IsUsingSpells() ) |
|
return; |
|
|
|
CSpellPickup *pSpellPickup = assert_cast<CSpellPickup*>( CBaseEntity::CreateNoSpawn( "tf_spell_pickup", vPosition + Vector( 0, 0, 50 ), vec3_angle, NULL ) ); |
|
if ( pSpellPickup ) |
|
{ |
|
pSpellPickup->SetTier( nTier ); |
|
|
|
DispatchSpawn( pSpellPickup ); |
|
|
|
Vector vecImpulse = RandomVector( -0.5f, 0.5f ); |
|
vecImpulse.z = 1.f; |
|
VectorNormalize( vecImpulse ); |
|
|
|
Vector vecVelocity = vecImpulse * 500.f; |
|
pSpellPickup->DropSingleInstance( vecVelocity, NULL, 0 ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::ShouldDropBonusDuck( void ) |
|
{ |
|
if ( tf_player_drop_bonus_ducks.GetInt() < 0 ) |
|
{ |
|
return IsHolidayActive( kHoliday_EOTL ); |
|
} |
|
else if ( tf_player_drop_bonus_ducks.GetInt() > 0 ) |
|
{ |
|
return true; |
|
} |
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::ShouldDropBonusDuckFromPlayer( CTFPlayer *pTFScorer, CTFPlayer *pTFVictim ) |
|
{ |
|
if ( !pTFScorer || !pTFVictim ) |
|
return false; |
|
|
|
#ifndef STAGING_ONLY |
|
// Only drop if bot is not involved |
|
if ( pTFScorer->IsBot() || pTFVictim->IsBot() || pTFScorer == pTFVictim ) |
|
return false; |
|
#endif |
|
|
|
return ShouldDropBonusDuck(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::GetDuckSkinForClass( int nTeam, int nClass ) const |
|
{ |
|
int nSkin = 0; |
|
if ( nTeam >= FIRST_GAME_TEAM ) |
|
{ |
|
bool bRed = ( nTeam == TF_TEAM_RED ); |
|
|
|
switch ( nClass ) |
|
{ |
|
case TF_CLASS_SCOUT: |
|
nSkin = bRed ? 3 : 12; |
|
break; |
|
case TF_CLASS_SNIPER: |
|
nSkin = bRed ? 4 : 13; |
|
break; |
|
case TF_CLASS_SOLDIER: |
|
nSkin = bRed ? 5 : 14; |
|
break; |
|
case TF_CLASS_DEMOMAN: |
|
nSkin = bRed ? 6 : 15; |
|
break; |
|
case TF_CLASS_MEDIC: |
|
nSkin = bRed ? 7 : 16; |
|
break; |
|
case TF_CLASS_HEAVYWEAPONS: |
|
nSkin = bRed ? 8 : 17; |
|
break; |
|
case TF_CLASS_PYRO: |
|
nSkin = bRed ? 9 : 18; |
|
break; |
|
case TF_CLASS_SPY: |
|
nSkin = bRed ? 10 : 19; |
|
break; |
|
case TF_CLASS_ENGINEER: |
|
nSkin = bRed ? 11 : 20; |
|
break; |
|
default: |
|
nSkin = bRed ? 1 : 2; |
|
break; |
|
} |
|
} |
|
|
|
return nSkin; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
#ifdef STAGING_ONLY |
|
ConVar tf_duck_droprate_min( "tf_duck_droprate_min", "-1", FCVAR_REPLICATED, "Set Minimum Number of Ducks to Spawn. No upgrade" ); |
|
ConVar tf_duck_droprate_bias( "tf_duck_droprate_bias", "0.2", FCVAR_REPLICATED, "Set Bias on Duck Spawns. No upgrade" ); |
|
ConVar tf_duck_power_override( "tf_duck_power_override", "0", FCVAR_REPLICATED, "Override everyone's duck power and use this value when > 0" ); |
|
ConVar tf_duck_random_extra( "tf_duck_random_extra", "3.0f", FCVAR_REPLICATED, "Random Count of Ducks to be added used by bias function" ); |
|
#endif |
|
ConVar tf_duck_edict_limit( "tf_duck_edict_limit", "1900", FCVAR_REPLICATED, "Maximum number of edicts allowed before spawning a duck" ); |
|
ConVar tf_duck_edict_warning( "tf_duck_edict_warning", "1800", FCVAR_REPLICATED, "Maximum number of edicts allowed before slowing duck spawn rate" ); |
|
void CTFGameRules::DropBonusDuck( const Vector& vPosition, CTFPlayer *pTFCreator /*=NULL*/, CTFPlayer *pAssister /*=NULL*/, CTFPlayer *pTFVictim /*=NULL*/, bool bCrit /*=false*/, bool bObjective /*=false*/) const |
|
{ |
|
if ( gEntList.NumberOfEdicts() > tf_duck_edict_limit.GetInt() ) |
|
{ |
|
Warning( "Warning: High level of Edicts, Not spawning Ducks \n" ); |
|
return; |
|
} |
|
|
|
static CSchemaAttributeDefHandle pAttr_DuckLevelBadge( "duck badge level" ); |
|
|
|
// Find Badge and increase number of ducks based on badge level (1 duck per 5 levels) |
|
// Look through equipped items, if one is a duck badge use its level |
|
int iDuckFlags = 0; |
|
if ( pTFCreator == NULL || bObjective ) |
|
{ |
|
iDuckFlags |= EDuckFlags::DUCK_FLAG_OBJECTIVE; |
|
} |
|
uint32 iDuckBadgeLevel = 0; |
|
|
|
if ( pTFCreator ) |
|
{ |
|
for ( int i = 0; i < pTFCreator->GetNumWearables(); ++i ) |
|
{ |
|
CTFWearable* pWearable = dynamic_cast<CTFWearable*>( pTFCreator->GetWearable( i ) ); |
|
if ( !pWearable ) |
|
continue; |
|
|
|
//if ( pWearable->GetAttributeContainer() && pWearable->GetAttributeContainer()->GetItem() ) |
|
{ |
|
//CEconItemView *pItem = pWearable->GetAttributeContainer()->GetItem(); |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWearable, iDuckBadgeLevel, duck_badge_level ); |
|
//if ( pItem && FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pItem, pAttr_DuckLevelBadge, &iDuckBadgeLevel ) ) |
|
{ |
|
iDuckBadgeLevel++; |
|
} |
|
} |
|
} |
|
} |
|
// Badges only go to max of 5 now instead of 10 so just doubling the output value |
|
int iDuckPower = Min( (int)iDuckBadgeLevel * 2, 11 ); |
|
float flBias = RemapValClamped( (float)iDuckPower, 0.0f, 10.0f, 0.2f, 0.5f); |
|
float flBiasScale = 3.0f; |
|
int iMinimum = 0; |
|
bool bSpecial = false; |
|
|
|
// Drop a few bonus ducks, extra ducks for Crits! |
|
#ifdef STAGING_ONLY |
|
flBias = RemapValClamped( (float)iDuckPower, 0.0f, 10.0f, tf_duck_droprate_bias.GetFloat(), 0.5f); |
|
iMinimum = tf_duck_droprate_min.GetInt(); |
|
if ( tf_duck_power_override.GetInt() > 0 ) |
|
{ |
|
iDuckPower = tf_duck_power_override.GetInt(); |
|
} |
|
flBiasScale = tf_duck_random_extra.GetFloat(); |
|
#endif |
|
//tf_duck_droprate_bias |
|
int iDuckCount = (int)( Bias( RandomFloat( 0, 1 ), flBias ) * ( flBiasScale + iDuckPower ) ) + iMinimum; |
|
iDuckCount = Max( iDuckCount, (int)iDuckBadgeLevel ); // min ducks for a badge |
|
|
|
if ( bCrit ) |
|
{ |
|
iDuckCount += RandomInt( 1, 2 ); |
|
} |
|
|
|
if ( pTFCreator && ( iDuckBadgeLevel > 0 ) ) |
|
{ |
|
if ( RandomInt( 0, 600 ) <= iDuckPower ) |
|
{ |
|
// MEGA BONUS DUCKS |
|
iDuckCount += iDuckPower; |
|
bSpecial = true; |
|
} |
|
} |
|
|
|
if ( iDuckCount > 0 ) |
|
{ |
|
// Max of 50 ducks, which is a lot of ducks |
|
iDuckCount = Min( 50, iDuckCount ); |
|
|
|
// High edict count, slow generation |
|
if ( gEntList.NumberOfEdicts() > tf_duck_edict_warning.GetInt() ) |
|
{ |
|
Warning( "Warning: High level of Edicts, Not spawning as many ducks\n" ); |
|
iDuckCount /= 2; |
|
} |
|
|
|
int iCreatorId = pTFCreator ? pTFCreator->entindex() : -1; |
|
int iAssisterId = pAssister ? pAssister->entindex() : -1; |
|
|
|
int iVictimId = -1; |
|
int iDuckTeam = TEAM_UNASSIGNED; |
|
if ( pTFVictim ) |
|
{ |
|
iVictimId = pTFVictim->entindex(); |
|
iDuckTeam = pTFVictim->GetTeamNumber(); |
|
} |
|
|
|
for ( int i = 0; i < iDuckCount; ++i ) |
|
{ |
|
Vector vecOrigin = vPosition + Vector( 0, 0, 50 ); |
|
CBonusDuckPickup *pDuckPickup = assert_cast<CBonusDuckPickup*>( CBaseEntity::CreateNoSpawn( "tf_bonus_duck_pickup", vecOrigin, vec3_angle, NULL ) ); |
|
if ( pDuckPickup ) |
|
{ |
|
DispatchSpawn( pDuckPickup ); |
|
|
|
Vector vecImpulse = RandomVector( -0.5f, 0.5f ); |
|
vecImpulse.z = 1.f; |
|
VectorNormalize( vecImpulse ); |
|
|
|
Vector vecVelocity = vecImpulse * RandomFloat( 350.0f, 450.0f ); |
|
pDuckPickup->DropSingleInstance( vecVelocity, NULL, 1.0f ); |
|
pDuckPickup->SetCreatorId( iCreatorId ); |
|
pDuckPickup->SetVictimId( iVictimId ); |
|
pDuckPickup->SetAssisterId( iAssisterId ); |
|
pDuckPickup->ChangeTeam( iDuckTeam ); |
|
pDuckPickup->SetDuckFlag( iDuckFlags ); |
|
// random chance to have a special duck appear |
|
// Bonus duck implies atleast 1 Saxton |
|
if ( bSpecial || ( RandomInt( 1, 100 ) <= tf_test_special_ducks.GetInt() ) ) |
|
{ |
|
bSpecial = false; |
|
pDuckPickup->m_nSkin = 21; // Quackston Hale |
|
pDuckPickup->SetSpecial(); |
|
|
|
CSingleUserRecipientFilter filter( pTFCreator ); |
|
UserMessageBegin( filter, "BonusDucks" ); |
|
WRITE_BYTE( iCreatorId ); |
|
WRITE_BYTE( true ); |
|
MessageEnd(); |
|
} |
|
else |
|
{ |
|
if ( iDuckPower > 0 ) |
|
{ |
|
pDuckPickup->m_nSkin = GetDuckSkinForClass( iDuckTeam, ( pTFVictim && pTFVictim->GetPlayerClass() ) ? pTFVictim->GetPlayerClass()->GetClassIndex() : -1 ); |
|
} |
|
else |
|
{ |
|
// Scorer without a badge only make normal ducks |
|
pDuckPickup->m_nSkin = iDuckTeam == TF_TEAM_RED ? 1 : 2; |
|
} |
|
pDuckPickup->SetModelScale( 0.7f ); |
|
} |
|
} |
|
} |
|
|
|
// Update duckstreak count on player and assister if they have badges |
|
if ( pTFCreator && PlayerHasDuckStreaks( pTFCreator ) ) |
|
{ |
|
pTFCreator->m_Shared.IncrementStreak( CTFPlayerShared::kTFStreak_Ducks, iDuckCount ); |
|
} |
|
if ( pAssister && PlayerHasDuckStreaks( pAssister ) ) |
|
{ |
|
pAssister->m_Shared.IncrementStreak( CTFPlayerShared::kTFStreak_Ducks, iDuckCount ); |
|
} |
|
|
|
// Duck UserMessage |
|
if ( pTFCreator && pTFVictim && !TFGameRules()->HaveCheatsBeenEnabledDuringLevel() ) |
|
{ |
|
if ( IsHolidayActive( kHoliday_EOTL ) ) |
|
{ |
|
// Send a Message to Creator |
|
{ |
|
// IsCreated, ID of Creator, ID of Victim, Count, IsGolden |
|
CSingleUserRecipientFilter userfilter( pTFCreator ); |
|
UserMessageBegin( userfilter, "EOTLDuckEvent" ); |
|
WRITE_BYTE( true ); |
|
WRITE_BYTE( iCreatorId ); |
|
WRITE_BYTE( iVictimId ); |
|
WRITE_BYTE( 0 ); |
|
WRITE_BYTE( iDuckTeam ); |
|
WRITE_BYTE( iDuckCount ); |
|
WRITE_BYTE( iDuckFlags ); |
|
MessageEnd(); |
|
} |
|
|
|
// To assister |
|
if ( pAssister ) |
|
{ |
|
// IsCreated, ID of Creator, ID of Victim, Count, IsGolden |
|
CSingleUserRecipientFilter userfilter( pAssister ); |
|
UserMessageBegin( userfilter, "EOTLDuckEvent" ); |
|
WRITE_BYTE( true ); |
|
WRITE_BYTE( pAssister->entindex() ); |
|
WRITE_BYTE( iVictimId ); |
|
WRITE_BYTE( 0 ); |
|
WRITE_BYTE( iDuckTeam ); |
|
WRITE_BYTE( iDuckCount ); |
|
WRITE_BYTE( iDuckFlags ); |
|
MessageEnd(); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
static kill_eater_event_t g_eClassKillEvents[] = |
|
{ |
|
kKillEaterEvent_ScoutKill, // TF_CLASS_SCOUT |
|
kKillEaterEvent_SniperKill, // TF_CLASS_SNIPER |
|
kKillEaterEvent_SoldierKill, // TF_CLASS_SOLDIER |
|
kKillEaterEvent_DemomanKill, // TF_CLASS_DEMOMAN |
|
kKillEaterEvent_MedicKill, // TF_CLASS_MEDIC |
|
kKillEaterEvent_HeavyKill, // TF_CLASS_HEAVYWEAPONS |
|
kKillEaterEvent_PyroKill, // TF_CLASS_PYRO |
|
kKillEaterEvent_SpyKill, // TF_CLASS_SPY |
|
kKillEaterEvent_EngineerKill, // TF_CLASS_ENGINEER |
|
}; |
|
COMPILE_TIME_ASSERT( ARRAYSIZE( g_eClassKillEvents ) == (TF_LAST_NORMAL_CLASS - TF_FIRST_NORMAL_CLASS) ); |
|
|
|
//----------------------------------------------------------------------------- |
|
static kill_eater_event_t g_eRobotClassKillEvents[] = |
|
{ |
|
kKillEaterEvent_RobotScoutKill, // TF_CLASS_SCOUT |
|
kKillEaterEvent_RobotSniperKill, // TF_CLASS_SNIPER |
|
kKillEaterEvent_RobotSoldierKill, // TF_CLASS_SOLDIER |
|
kKillEaterEvent_RobotDemomanKill, // TF_CLASS_DEMOMAN |
|
kKillEaterEvent_RobotMedicKill, // TF_CLASS_MEDIC |
|
kKillEaterEvent_RobotHeavyKill, // TF_CLASS_HEAVYWEAPONS |
|
kKillEaterEvent_RobotPyroKill, // TF_CLASS_PYRO |
|
kKillEaterEvent_RobotSpyKill, // TF_CLASS_SPY |
|
kKillEaterEvent_RobotEngineerKill, // TF_CLASS_ENGINEER |
|
}; |
|
COMPILE_TIME_ASSERT( ARRAYSIZE( g_eRobotClassKillEvents ) == (TF_LAST_NORMAL_CLASS - TF_FIRST_NORMAL_CLASS) ); |
|
|
|
static bool BHasWearableOfSpecificQualityEquipped( /*const*/ CTFPlayer *pTFPlayer, EEconItemQuality eQuality ) |
|
{ |
|
Assert( pTFPlayer ); |
|
|
|
// Fire the kill eater event on all wearables |
|
for ( int i = 0; i < pTFPlayer->GetNumWearables(); ++i ) |
|
{ |
|
CTFWearable *pWearableItem = dynamic_cast<CTFWearable *>( pTFPlayer->GetWearable( i ) ); |
|
if ( !pWearableItem ) |
|
continue; |
|
|
|
if ( !pWearableItem->GetAttributeContainer() ) |
|
continue; |
|
|
|
CEconItemView *pEconItemView = pWearableItem->GetAttributeContainer()->GetItem(); |
|
if ( !pEconItemView ) |
|
continue; |
|
|
|
if ( pEconItemView->GetQuality() == eQuality ) |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
void CTFGameRules::PlayerKilled( CBasePlayer *pVictim, const CTakeDamageInfo &info ) |
|
{ |
|
// Find the killer & the scorer |
|
CBaseEntity *pInflictor = info.GetInflictor(); |
|
CBaseEntity *pKiller = info.GetAttacker(); |
|
CBaseMultiplayerPlayer *pScorer = ToBaseMultiplayerPlayer( GetDeathScorer( pKiller, pInflictor, pVictim ) ); |
|
CTFPlayer *pAssister = NULL; |
|
CBaseObject *pObject = NULL; |
|
|
|
// if inflictor or killer is a base object, tell them that they got a kill |
|
// ( depends if a sentry rocket got the kill, sentry may be inflictor or killer ) |
|
if ( pInflictor ) |
|
{ |
|
if ( pInflictor->IsBaseObject() ) |
|
{ |
|
pObject = dynamic_cast<CBaseObject *>( pInflictor ); |
|
} |
|
else |
|
{ |
|
CBaseEntity *pInflictorOwner = pInflictor->GetOwnerEntity(); |
|
if ( pInflictorOwner && pInflictorOwner->IsBaseObject() ) |
|
{ |
|
pObject = dynamic_cast<CBaseObject *>( pInflictorOwner ); |
|
} |
|
} |
|
|
|
} |
|
else if( pKiller && pKiller->IsBaseObject() ) |
|
{ |
|
pObject = dynamic_cast<CBaseObject *>( pKiller ); |
|
} |
|
|
|
if ( pObject ) |
|
{ |
|
if ( pObject->GetBuilder() != pVictim ) |
|
{ |
|
pObject->IncrementKills(); |
|
|
|
// minibosses count for 5 kills |
|
if ( IsMannVsMachineMode() && pVictim && pVictim->IsPlayer() ) |
|
{ |
|
CTFPlayer *playerVictim = ToTFPlayer( pVictim ); |
|
if ( playerVictim->IsMiniBoss() ) |
|
{ |
|
pObject->IncrementKills(); |
|
pObject->IncrementKills(); |
|
pObject->IncrementKills(); |
|
pObject->IncrementKills(); |
|
} |
|
} |
|
} |
|
pInflictor = pObject; |
|
|
|
if ( pObject->ObjectType() == OBJ_SENTRYGUN ) |
|
{ |
|
// notify the sentry |
|
CObjectSentrygun *pSentrygun = dynamic_cast<CObjectSentrygun *>( pObject ); |
|
if ( pSentrygun ) |
|
{ |
|
pSentrygun->OnKilledEnemy( pVictim ); |
|
} |
|
|
|
CTFPlayer *pOwner = pObject->GetOwner(); |
|
if ( pOwner ) |
|
{ |
|
int iKills = pObject->GetKills(); |
|
|
|
// keep track of max kills per a single sentry gun in the player object |
|
if ( pOwner->GetMaxSentryKills() < iKills ) |
|
{ |
|
pOwner->SetMaxSentryKills( iKills ); |
|
} |
|
|
|
// if we just got 10 kills with one sentry, tell the owner's client, which will award achievement if it doesn't have it already |
|
if ( iKills == 10 ) |
|
{ |
|
pOwner->AwardAchievement( ACHIEVEMENT_TF_GET_TURRETKILLS ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
// if not killed by suicide or killed by world, see if the scorer had an assister, and if so give the assister credit |
|
if ( ( pVictim != pScorer ) && pKiller ) |
|
{ |
|
pAssister = ToTFPlayer( GetAssister( pVictim, pScorer, pInflictor ) ); |
|
|
|
CTFPlayer *pTFVictim = ToTFPlayer( pVictim ); |
|
if ( pAssister && pTFVictim ) |
|
{ |
|
EntityHistory_t* entHist = pTFVictim->m_AchievementData.IsSentryDamagerInHistory( pAssister, 5.0 ); |
|
if ( entHist ) |
|
{ |
|
CBaseObject *pObj = dynamic_cast<CBaseObject*>( entHist->hObject.Get() ); |
|
if ( pObj ) |
|
{ |
|
pObj->IncrementAssists(); |
|
} |
|
} |
|
|
|
// Rage On Assists |
|
// Sniper Kill Rage |
|
if ( pAssister->IsPlayerClass( TF_CLASS_SNIPER ) ) |
|
{ |
|
// Item attribute |
|
// Add Sniper Rage On Assists |
|
float flRageGain = 0; |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pAssister, flRageGain, rage_on_assists ); |
|
if (flRageGain != 0) |
|
{ |
|
pAssister->m_Shared.ModifyRage(flRageGain); |
|
} |
|
} |
|
} |
|
} |
|
|
|
if ( pVictim ) |
|
{ |
|
if ( ShouldDropSpellPickup() ) |
|
{ |
|
DropSpellPickup( pVictim->GetAbsOrigin() ); |
|
} |
|
|
|
CTFPlayer *pTFScorer = ToTFPlayer( pScorer ); |
|
CTFPlayer *pTFVictim = ToTFPlayer( pVictim ); |
|
if ( pTFScorer && pTFVictim ) |
|
{ |
|
if ( ShouldDropBonusDuckFromPlayer( pTFScorer, pTFVictim ) ) |
|
{ |
|
DropBonusDuck( pTFVictim->GetAbsOrigin(), pTFScorer, pAssister, pTFVictim, ( info.GetDamageType() & DMG_CRITICAL ) != 0 ); |
|
} |
|
} |
|
|
|
// Drop a halloween soul! |
|
if ( IsHolidayActive( kHoliday_Halloween ) ) |
|
{ |
|
CBaseCombatCharacter* pBaseCombatScorer = dynamic_cast< CBaseCombatCharacter*>( pScorer ? pScorer : pKiller ); |
|
// No souls for a pure suicide |
|
if ( pTFVictim != pBaseCombatScorer ) |
|
{ |
|
// Only spawn a soul if the target is a base combat character. |
|
if ( pTFVictim && pBaseCombatScorer ) |
|
{ |
|
DropHalloweenSoulPack( 1, pVictim->EyePosition(), pBaseCombatScorer, pTFVictim->GetTeamNumber() ); |
|
} |
|
|
|
// Also spawn one for the assister |
|
if ( pAssister ) |
|
{ |
|
DropHalloweenSoulPack( 1, pVictim->EyePosition(), pAssister, pTFVictim->GetTeamNumber() ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
//find the area the player is in and see if his death causes a block |
|
CBaseMultiplayerPlayer *pMultiplayerPlayer = ToBaseMultiplayerPlayer(pVictim); |
|
for ( int i=0; i<ITriggerAreaCaptureAutoList::AutoList().Count(); ++i ) |
|
{ |
|
CTriggerAreaCapture *pArea = static_cast< CTriggerAreaCapture * >( ITriggerAreaCaptureAutoList::AutoList()[i] ); |
|
if ( pArea->IsTouching( pMultiplayerPlayer ) ) |
|
{ |
|
// ACHIEVEMENT_TF_MEDIC_ASSIST_CAPTURER |
|
// kill 3 players |
|
if ( pAssister && pAssister->IsPlayerClass( TF_CLASS_MEDIC ) ) |
|
{ |
|
// the victim is touching a cap point, see if they own it |
|
if ( pMultiplayerPlayer->GetTeamNumber() == pArea->GetOwningTeam() ) |
|
{ |
|
int iDefenderKills = pAssister->GetPerLifeCounterKV( "medic_defender_kills" ); |
|
|
|
if ( ++iDefenderKills == 3 ) |
|
{ |
|
pAssister->AwardAchievement( ACHIEVEMENT_TF_MEDIC_ASSIST_CAPTURER ); |
|
} |
|
|
|
pAssister->SetPerLifeCounterKV( "medic_defender_kills", iDefenderKills ); |
|
} |
|
} |
|
|
|
if ( pArea->CheckIfDeathCausesBlock( pMultiplayerPlayer, pScorer ) ) |
|
break; |
|
} |
|
} |
|
|
|
// determine if this kill affected a nemesis relationship |
|
int iDeathFlags = 0; |
|
CTFPlayer *pTFPlayerVictim = ToTFPlayer( pVictim ); |
|
CTFPlayer *pTFPlayerScorer = ToTFPlayer( pScorer ); |
|
if ( pScorer ) |
|
{ |
|
CalcDominationAndRevenge( pTFPlayerScorer, info.GetWeapon(), pTFPlayerVictim, false, &iDeathFlags ); |
|
if ( pAssister ) |
|
{ |
|
CalcDominationAndRevenge( pAssister, info.GetWeapon(), pTFPlayerVictim, true, &iDeathFlags ); |
|
} |
|
} |
|
pTFPlayerVictim->SetDeathFlags( iDeathFlags ); |
|
|
|
CTFPlayer *pTFPlayerAssister = ToTFPlayer( pAssister ); |
|
if ( pTFPlayerAssister ) |
|
{ |
|
CTF_GameStats.Event_AssistKill( pTFPlayerAssister, pVictim ); |
|
} |
|
|
|
// check for achievements |
|
PlayerKilledCheckAchievements( pTFPlayerScorer, pTFPlayerVictim ); |
|
|
|
if ( IsInTraining() && GetTrainingModeLogic() ) |
|
{ |
|
if ( pVictim->IsFakeClient() == false ) |
|
{ |
|
GetTrainingModeLogic()->OnPlayerDied( ToTFPlayer( pVictim ), pKiller ); |
|
} |
|
else |
|
{ |
|
GetTrainingModeLogic()->OnBotDied( ToTFPlayer( pVictim ), pKiller ); |
|
} |
|
} |
|
|
|
// credit for dueling |
|
if ( pTFPlayerScorer != NULL && pTFPlayerScorer != pTFPlayerVictim ) |
|
{ |
|
DuelMiniGame_NotifyKill( pTFPlayerScorer, pTFPlayerVictim ); |
|
} |
|
if ( pTFPlayerAssister && pTFPlayerAssister != pTFPlayerVictim ) |
|
{ |
|
DuelMiniGame_NotifyAssist( pTFPlayerAssister, pTFPlayerVictim ); |
|
} |
|
|
|
// Count kills from powerup carriers to detect imbalances |
|
if ( IFuncPowerupVolumeAutoList::AutoList().Count() != 0 ) // If there are no func_powerupvolumes in the map, there's no point in checking for imbalances |
|
{ |
|
if ( pTFPlayerScorer && pTFPlayerScorer != pTFPlayerVictim && pTFPlayerScorer->m_Shared.IsCarryingRune() && !pTFPlayerScorer->m_Shared.InCond( TF_COND_RUNE_IMBALANCE ) ) |
|
{ |
|
if ( !m_bPowerupImbalanceMeasuresRunning && !PowerupModeFlagStandoffActive() ) // Only count if imbalance measures aren't running and there is no flag standoff |
|
{ |
|
if ( pTFPlayerScorer->GetTeamNumber() == TF_TEAM_BLUE ) |
|
{ |
|
m_nPowerupKillsBlueTeam++; // Blue team score increases if a powered up blue player makes a kill |
|
} |
|
else if ( pTFPlayerScorer->GetTeamNumber() == TF_TEAM_RED ) |
|
{ |
|
m_nPowerupKillsRedTeam++; |
|
} |
|
|
|
int nBlueAdvantage = m_nPowerupKillsBlueTeam - m_nPowerupKillsRedTeam; // How far ahead is this team? |
|
// Msg( "\nnBlueAdvantage = %d\n", nBlueAdvantage ); |
|
int nRedAdvantage = m_nPowerupKillsRedTeam - m_nPowerupKillsBlueTeam; |
|
// Msg( "nRedAdvantage = %d\n\n", nRedAdvantage ); |
|
|
|
if ( nRedAdvantage >= tf_powerup_mode_imbalance_delta.GetInt() ) |
|
{ |
|
PowerupTeamImbalance( TF_TEAM_BLUE ); // Fire the output to map logic |
|
} |
|
else if ( nBlueAdvantage >= tf_powerup_mode_imbalance_delta.GetInt() ) |
|
{ |
|
PowerupTeamImbalance( TF_TEAM_RED ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
// credit for kill-eating weapons and anything else that might care |
|
if ( pTFPlayerScorer && pTFPlayerVictim && pTFPlayerScorer != pTFPlayerVictim ) |
|
{ |
|
// Increment the server-side kill count for this weapon -- this is used for honorbound |
|
// weapons and has nothing to do with strange weapons/stats. |
|
pTFPlayerScorer->IncrementKillCountSinceLastDeploy( info ); |
|
|
|
CTFWeaponBase *pTFWeapon = GetKilleaterWeaponFromDamageInfo( &info ); |
|
|
|
kill_eater_event_t eKillEaterEvent = pTFWeapon // if we have a weapon... |
|
? pTFWeapon->GetKillEaterKillEventType() // ...then ask it what type of event to report |
|
: info.GetDamageCustom() == TF_DMG_CUSTOM_BOOTS_STOMP // if we don't have a weapon, and we're hacking for kill types from wearables (!)... |
|
? kKillEaterEvent_PlayerKillByBootStomp // ...then use our hard-coded event |
|
: kKillEaterEvent_PlayerKill; // otherwise default to a normal player kill |
|
|
|
CEconEntity *pAttackerEconWeapon = NULL; |
|
|
|
// Cosmetic Kill like manntreads or demo shield |
|
if ( !pTFWeapon ) |
|
{ |
|
pAttackerEconWeapon = dynamic_cast< CEconEntity * >( info.GetWeapon() ); |
|
} |
|
else |
|
{ |
|
pAttackerEconWeapon = dynamic_cast< CEconEntity * >( pTFWeapon ); |
|
} |
|
|
|
|
|
if ( pAttackerEconWeapon ) |
|
{ |
|
if ( !( IsPVEModeActive() && pTFPlayerVictim->GetTeamNumber() == TF_TEAM_PVE_INVADERS ) ) |
|
{ |
|
// Any type of non-robot kill! |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, eKillEaterEvent ); |
|
|
|
// Cosmetic any kill type tracking |
|
{ |
|
HatAndMiscEconEntities_OnOwnerKillEaterEvent( pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_CosmeticKills ); |
|
|
|
// Halloween silliness: overworld kills for Merasmus carnival. |
|
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) && !pTFPlayerScorer->m_Shared.InCond( TF_COND_HALLOWEEN_IN_HELL ) ) |
|
{ |
|
HatAndMiscEconEntities_OnOwnerKillEaterEvent( pTFPlayerScorer, |
|
pTFPlayerVictim, |
|
kKillEaterEvent_Halloween_OverworldKills ); |
|
} |
|
} |
|
|
|
// Operation Kills |
|
EconEntity_NonEquippedItemKillTracking( pTFPlayerScorer, pTFPlayerVictim, 1 ); |
|
|
|
// Unique kill tracking? |
|
EconEntity_OnOwnerUniqueEconEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_UniqueEvent__KilledAccountWithItem ); |
|
|
|
// Optional Taunt Kill tracking |
|
if ( IsTauntDmg( info.GetDamageCustom() ) ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_TauntKill ); |
|
} |
|
// Scorch Shot Taunt is Different |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_FLARE_PELLET ) |
|
{ |
|
CBaseEntity *pInflictor = info.GetInflictor(); |
|
CTFProjectile_Flare *pFlare = dynamic_cast<CTFProjectile_Flare*>(pInflictor); |
|
if ( pFlare && pFlare->IsFromTaunt() ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_TauntKill ); |
|
} |
|
} |
|
|
|
// Optional: also track "killed X players of this specific class". |
|
int iVictimClassIndex = pTFPlayerVictim->GetPlayerClass()->GetClassIndex(); |
|
if ( iVictimClassIndex >= TF_FIRST_NORMAL_CLASS && iVictimClassIndex <= TF_LAST_NORMAL_CLASS ) |
|
{ |
|
const kill_eater_event_t eClassKillType = g_eClassKillEvents[ iVictimClassIndex - TF_FIRST_NORMAL_CLASS ]; |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, eClassKillType ); |
|
} |
|
|
|
// Optional : Kills while in Victory / Bonus time |
|
if ( State_Get() == GR_STATE_TEAM_WIN && GetWinningTeam() != pTFPlayerVictim->GetTeamNumber() ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_VictoryTimeKill ); |
|
} |
|
|
|
// Optional: also track "killed X players while they were in the air". |
|
if ( !(pTFPlayerVictim->GetFlags() & FL_ONGROUND) && (pTFPlayerVictim->GetWaterLevel() == WL_NotInWater) ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_AirborneEnemyKill ); |
|
} |
|
|
|
// Optional: also track "killed X players with headshots". |
|
if ( IsHeadshot( info.GetDamageCustom() ) ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_HeadshotKill ); |
|
} |
|
|
|
// Optional: also track "gibbed X players". |
|
if ( pTFPlayerVictim->ShouldGib( info ) ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_GibKill ); |
|
} |
|
|
|
// Optional: also track "killed X players during full moons". We intentionally don't call into the |
|
// game rules here because we don't want server variables to override this. Setting local time on the |
|
// server will still allow it to happen but it at least takes a little effort. |
|
if ( UTIL_IsHolidayActive( kHoliday_FullMoon ) ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillDuringFullMoon ); |
|
} |
|
|
|
// Optional: also track kills we make while we're dead (afterburn, pre-death-fired rocket, etc.) |
|
if ( !pTFPlayerScorer->IsAlive() ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillPosthumous ); |
|
} |
|
|
|
// Optional: also track kills that were specifically criticals. |
|
if ( (info.GetDamageType() & DMG_CRITICAL) != 0 ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillCritical ); |
|
} |
|
else |
|
{ |
|
// Not special at all kill |
|
if ( pTFPlayerVictim->GetAttackBonusEffect() == kBonusEffect_None ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_NonCritKills ); |
|
} |
|
} |
|
|
|
// Optional: also track kills that were made while we were launched into the air from an explosion (ie., rocket-jumping). |
|
if ( pTFPlayerScorer->InAirDueToExplosion() ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillWhileExplosiveJumping ); |
|
} |
|
|
|
// Optional: also track kills where the victim was a spy who was invisible at the time of death. |
|
if ( iVictimClassIndex == TF_CLASS_SPY && pTFPlayerVictim->m_Shared.GetPercentInvisible() > 0 ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_InvisibleSpiesKilled ); |
|
} |
|
|
|
// Optional: also track kills where the victim was a medic with 100% uber. |
|
if ( pTFPlayerVictim->MedicGetChargeLevel() >= 1.0f ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_MedicsWithFullUberKilled ); |
|
} |
|
|
|
// Optional: also track kills where the killer was at low health when they dealt the final damage. Don't count |
|
// kills with 0 or fewer health -- those would be post-mortem kills instead. |
|
if ( ((float)pTFPlayerScorer->GetHealth() / (float)pTFPlayerScorer->GetMaxHealth()) <= 0.1f && pTFPlayerScorer->GetHealth() > 0 ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_KillWhileLowHealth ); |
|
} |
|
|
|
// Optional: also track kills that take place during the Halloween holiday. We intentionally *do* check against |
|
// the game rules logic here -- if folks want to enable Halloween mode on a server and play around, I don't see any |
|
// reason why we benefit from stopping their fun. |
|
if ( TF_IsHolidayActive( kHoliday_Halloween ) ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_HalloweenKill ); |
|
} |
|
|
|
// Optional: also track kills where the victim was completely underwater. |
|
if ( pTFPlayerVictim->GetWaterLevel() >= WL_Eyes ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_UnderwaterKill ); |
|
} |
|
|
|
// Optional: also track kills where we're under the effects of a medic's ubercharge. |
|
if ( pTFPlayerScorer->m_Shared.InCond( TF_COND_INVULNERABLE ) || pTFPlayerScorer->m_Shared.InCond( TF_COND_INVULNERABLE_WEARINGOFF ) ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_KillWhileUbercharged ); |
|
} |
|
|
|
// Optional: also track kills where the victim was in the process of carrying the intel, capturing a point, or pushing |
|
// the cart. The actual logic for "killed a flag carrier" is handled elsewhere because by this point we've forgotten |
|
// if we had a flag before we died. |
|
if ( pTFPlayerVictim->IsCapturingPoint() ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_DefenderKill ); |
|
} |
|
|
|
// Optional: also track kills where the victim was at least N units from the person dealing the damage, where N is "however far |
|
// you have to be to get the crowd chear noise". This also specifically checks to make sure the damage dealer is alive to avoid |
|
// casing where you spectate far away, etc. |
|
if ( pTFPlayerScorer->IsAlive() && (pTFPlayerScorer->GetAbsOrigin() - pTFPlayerVictim->GetAbsOrigin()).Length() >= 2000.0f ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_LongDistanceKill ); |
|
} |
|
|
|
// Optional: also track kills where the victim was wearing at least one unusual-quality item. |
|
if ( BHasWearableOfSpecificQualityEquipped( pTFPlayerVictim, AE_UNUSUAL ) ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_PlayersWearingUnusualKill ); |
|
} |
|
|
|
// Optional: also track kills where the victim was on fire at the time that they died. We can't check the condition flag |
|
// here because that may or may not be active after they die, but instead we test to see whether they still had a burn queued |
|
// up for the future as a proxy for "was on fire at this point". |
|
if ( pTFPlayerVictim->m_Shared.GetFlameBurnTime() >= gpGlobals->curtime ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_BurningEnemyKill ); |
|
} |
|
|
|
// Optional: also track kills where this kill ended someone else's killstreak, where "killstreak" starts when the first |
|
// announcement happens. If Mike gets to hard-code constants, I do, too. |
|
enum { kFirstKillStreakAnnouncement = 5 }; |
|
if ( pTFPlayerVictim->m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Kills ) >= kFirstKillStreakAnnouncement ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_KillstreaksEnded ); |
|
} |
|
|
|
// Optional: also track kills where the killer and the victim were basically right next to each other. This is hard-coded to |
|
// 1.5x default melee swing range. |
|
if ( pTFPlayerScorer->IsAlive() && (pTFPlayerScorer->GetAbsOrigin() - pTFPlayerVictim->GetAbsOrigin()).Length() <= 72.0f ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_PointBlankKills ); |
|
} |
|
|
|
// Optional : Fullhealth kills |
|
if ( pTFPlayerScorer->GetHealth() >= pTFPlayerScorer->GetMaxHealth() ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_FullHealthKills ); |
|
} |
|
|
|
// Optional : Taunting Player kills |
|
if ( pTFPlayerVictim->IsTaunting() ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_TauntingPlayerKills ); |
|
} |
|
} |
|
else |
|
{ |
|
Assert( pTFPlayerVictim->GetTeamNumber() == TF_TEAM_PVE_INVADERS ); |
|
|
|
// Optional: also track kills where the victim was a robot in MvM |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_RobotsDestroyed ); |
|
|
|
// Optional: also track "killed X Robots of this specific class". |
|
int iVictimClassIndex = pTFPlayerVictim->GetPlayerClass()->GetClassIndex(); |
|
if ( iVictimClassIndex >= TF_FIRST_NORMAL_CLASS && iVictimClassIndex <= TF_LAST_NORMAL_CLASS ) |
|
{ |
|
const kill_eater_event_t eClassKillType = g_eRobotClassKillEvents[ iVictimClassIndex - TF_FIRST_NORMAL_CLASS ]; |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, eClassKillType ); |
|
} |
|
|
|
// Optional: specifically track miniboss kills separately from base robot kills. |
|
if ( pTFPlayerVictim->IsMiniBoss() ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_MinibossRobotsDestroyed ); |
|
} |
|
|
|
// Optional: track whether this shot killed a robot *after* penetrating something else. |
|
if ( info.GetPlayerPenetrationCount() > 0 ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_RobotsDestroyedAfterPenetration ); |
|
} |
|
|
|
// Optional: also track "killed X players with headshots", but for robots specifically. |
|
if ( IsHeadshot( info.GetDamageCustom() ) ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_RobotHeadshotKills ); |
|
} |
|
|
|
// Optional: also track kills that take place during the Halloween holiday. See note for kKillEaterEvent_HalloweenKill |
|
// regarding calling into game rules here. |
|
if ( TF_IsHolidayActive( kHoliday_Halloween ) ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_HalloweenKillRobot ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
BaseClass::PlayerKilled( pVictim, info ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::PlayerKilledCheckAchievements( CTFPlayer *pAttacker, CTFPlayer *pVictim ) |
|
{ |
|
if ( !pAttacker || !pVictim ) |
|
return; |
|
|
|
// HEAVY WEAPONS GUY |
|
if ( pAttacker->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) ) |
|
{ |
|
if ( GetGameType() == TF_GAMETYPE_CP ) |
|
{ |
|
// ACHIEVEMENT_TF_HEAVY_DEFEND_CONTROL_POINT |
|
CTriggerAreaCapture *pAreaTrigger = pAttacker->GetControlPointStandingOn(); |
|
if ( pAreaTrigger ) |
|
{ |
|
CTeamControlPoint *pCP = pAreaTrigger->GetControlPoint(); |
|
if ( pCP ) |
|
{ |
|
if ( pCP->GetOwner() == pAttacker->GetTeamNumber() ) |
|
{ |
|
// no suicides! |
|
if ( pAttacker != pVictim ) |
|
{ |
|
pAttacker->AwardAchievement( ACHIEVEMENT_TF_HEAVY_DEFEND_CONTROL_POINT ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
// ACHIEVEMENT_TF_HEAVY_KILL_CAPPING_ENEMIES |
|
pAreaTrigger = pVictim->GetControlPointStandingOn(); |
|
if ( pAreaTrigger ) |
|
{ |
|
CTeamControlPoint *pCP = pAreaTrigger->GetControlPoint(); |
|
if ( pCP ) |
|
{ |
|
if ( pCP->GetOwner() == pAttacker->GetTeamNumber() && |
|
TeamMayCapturePoint( pVictim->GetTeamNumber(), pCP->GetPointIndex() ) && |
|
PlayerMayCapturePoint( pVictim, pCP->GetPointIndex() ) ) |
|
{ |
|
pAttacker->AwardAchievement( ACHIEVEMENT_TF_HEAVY_KILL_CAPPING_ENEMIES ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
// ACHIEVEMENT_TF_HEAVY_CLEAR_STICKYBOMBS |
|
if ( pVictim->IsPlayerClass( TF_CLASS_DEMOMAN ) ) |
|
{ |
|
int iPipes = pVictim->GetNumActivePipebombs(); |
|
|
|
for (int i = 0; i < iPipes; i++) |
|
{ |
|
pAttacker->AwardAchievement( ACHIEVEMENT_TF_HEAVY_CLEAR_STICKYBOMBS ); |
|
} |
|
} |
|
|
|
// ACHIEVEMENT_TF_HEAVY_DEFEND_MEDIC |
|
int i; |
|
int iNumHealers = pAttacker->m_Shared.GetNumHealers(); |
|
for ( i = 0 ; i < iNumHealers ; i++ ) |
|
{ |
|
CTFPlayer *pMedic = ToTFPlayer( pAttacker->m_Shared.GetHealerByIndex( i ) ); |
|
if ( pMedic && pMedic->m_AchievementData.IsDamagerInHistory( pVictim, 3.0 ) ) |
|
{ |
|
pAttacker->AwardAchievement( ACHIEVEMENT_TF_HEAVY_DEFEND_MEDIC ); |
|
break; // just award it once for each kill...even if the victim attacked more than one medic attached to the killer |
|
} |
|
} |
|
|
|
// ACHIEVEMENT_TF_HEAVY_STAND_NEAR_DISPENSER |
|
for ( i = 0 ; i < iNumHealers ; i++ ) |
|
{ |
|
if ( pAttacker->m_Shared.HealerIsDispenser( i ) ) |
|
{ |
|
pAttacker->AwardAchievement( ACHIEVEMENT_TF_HEAVY_STAND_NEAR_DISPENSER ); |
|
break; // just award it once for each kill...even if the attacker is being healed by more than one dispenser |
|
} |
|
} |
|
} |
|
|
|
int i; |
|
int iNumHealers = pAttacker->m_Shared.GetNumHealers(); |
|
for ( i = 0 ; i < iNumHealers ; i++ ) |
|
{ |
|
CTFPlayer *pMedic = ToTFPlayer( pAttacker->m_Shared.GetHealerByIndex( i ) ); |
|
if ( pMedic && pMedic->m_AchievementData.IsDamagerInHistory( pVictim, 10.0 ) ) |
|
{ |
|
IGameEvent * event = gameeventmanager->CreateEvent( "medic_defended" ); |
|
if ( event ) |
|
{ |
|
event->SetInt( "userid", pAttacker->GetUserID() ); |
|
event->SetInt( "medic", pMedic->GetUserID() ); |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Determines if attacker and victim have gotten domination or revenge |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::CalcDominationAndRevenge( CTFPlayer *pAttacker, CBaseEntity *pWeapon, CTFPlayer *pVictim, bool bIsAssist, int *piDeathFlags ) |
|
{ |
|
//============================================================================= |
|
// HPE_BEGIN: |
|
// [msmith] If we're in training, we want to disable this domination stuff. |
|
//============================================================================= |
|
if ( IsInTraining() ) |
|
return; |
|
//============================================================================= |
|
// HPE_END |
|
//============================================================================= |
|
|
|
// don't do domination stuff in powerup mode |
|
if ( IsPowerupMode() ) |
|
return; |
|
|
|
// no dominations/revenge in competitive mode |
|
if ( IsMatchTypeCompetitive() ) |
|
return; |
|
|
|
PlayerStats_t *pStatsVictim = CTF_GameStats.FindPlayerStats( pVictim ); |
|
|
|
// no dominations/revenge in PvE mode |
|
if ( IsPVEModeActive() ) |
|
return; |
|
|
|
CEconEntity *pEconWeapon = dynamic_cast<CEconEntity *>( pWeapon ); |
|
|
|
// calculate # of unanswered kills between killer & victim - add 1 to include current kill |
|
int iKillsUnanswered = pStatsVictim->statsKills.iNumKilledByUnanswered[pAttacker->entindex()] + 1; |
|
if ( TF_KILLS_DOMINATION == iKillsUnanswered ) |
|
{ |
|
// this is the Nth unanswered kill between killer and victim, killer is now dominating victim |
|
*piDeathFlags |= ( bIsAssist ? TF_DEATH_ASSISTER_DOMINATION : TF_DEATH_DOMINATION ); |
|
// set victim to be dominated by killer |
|
pAttacker->m_Shared.SetPlayerDominated( pVictim, true ); |
|
|
|
int iCurrentlyDominated = pAttacker->GetNumberofDominations() + 1; |
|
pAttacker->SetNumberofDominations( iCurrentlyDominated ); |
|
|
|
// record stats |
|
CTF_GameStats.Event_PlayerDominatedOther( pAttacker ); |
|
|
|
// strange weapon stat tracking? |
|
EconEntity_OnOwnerKillEaterEvent( pEconWeapon, pAttacker, pVictim, kKillEaterEvent_PlayerKillStartDomination ); |
|
} |
|
else if ( pVictim->m_Shared.IsPlayerDominated( pAttacker->entindex() ) ) |
|
{ |
|
// the killer killed someone who was dominating him, gains revenge |
|
*piDeathFlags |= ( bIsAssist ? TF_DEATH_ASSISTER_REVENGE : TF_DEATH_REVENGE ); |
|
// set victim to no longer be dominating the killer |
|
pVictim->m_Shared.SetPlayerDominated( pAttacker, false ); |
|
|
|
int iCurrentlyDominated = pVictim->GetNumberofDominations() - 1; |
|
if (iCurrentlyDominated < 0) |
|
{ |
|
iCurrentlyDominated = 0; |
|
} |
|
pVictim->SetNumberofDominations( iCurrentlyDominated ); |
|
|
|
// record stats |
|
CTF_GameStats.Event_PlayerRevenge( pAttacker ); |
|
|
|
// strange weapon stat tracking? |
|
EconEntity_OnOwnerKillEaterEvent( pEconWeapon, pAttacker, pVictim, kKillEaterEvent_PlayerKillRevenge ); |
|
} |
|
else if ( pAttacker->m_Shared.IsPlayerDominated( pVictim->entindex() ) ) |
|
{ |
|
// the killer killed someone who they were already dominating |
|
|
|
// strange weapon stat tracking? |
|
EconEntity_OnOwnerKillEaterEvent( pEconWeapon, pAttacker, pVictim, kKillEaterEvent_PlayerKillAlreadyDominated ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: create some proxy entities that we use for transmitting data */ |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::CreateStandardEntities() |
|
{ |
|
// Create the player resource |
|
g_pPlayerResource = (CPlayerResource*)CBaseEntity::Create( "tf_player_manager", vec3_origin, vec3_angle ); |
|
|
|
// Create the objective resource |
|
g_pObjectiveResource = (CTFObjectiveResource *)CBaseEntity::Create( "tf_objective_resource", vec3_origin, vec3_angle ); |
|
|
|
Assert( g_pObjectiveResource ); |
|
|
|
// Create the monster resource for PvE battles |
|
g_pMonsterResource = (CMonsterResource *)CBaseEntity::Create( "monster_resource", vec3_origin, vec3_angle ); |
|
|
|
MannVsMachineStats_Init(); |
|
|
|
// Create the entity that will send our data to the client. |
|
m_hGamerulesProxy = assert_cast<CTFGameRulesProxy*>(CBaseEntity::Create( "tf_gamerules", vec3_origin, vec3_angle )); |
|
Assert( m_hGamerulesProxy.Get() ); |
|
m_hGamerulesProxy->SetName( AllocPooledString("tf_gamerules" ) ); |
|
|
|
CBaseEntity::Create("vote_controller", vec3_origin, vec3_angle); |
|
// Vote Issue classes are handled/cleaned-up by g_voteController |
|
new CKickIssue; |
|
new CRestartGameIssue; |
|
new CChangeLevelIssue; |
|
new CNextLevelIssue; |
|
new CExtendLevelIssue; |
|
new CScrambleTeams; |
|
new CMannVsMachineChangeChallengeIssue; |
|
new CEnableTemporaryHalloweenIssue; |
|
new CTeamAutoBalanceIssue; |
|
new CClassLimitsIssue; |
|
new CPauseGameIssue; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: determine the class name of the weapon that got a kill |
|
//----------------------------------------------------------------------------- |
|
const char *CTFGameRules::GetKillingWeaponName( const CTakeDamageInfo &info, CTFPlayer *pVictim, int *iWeaponID ) |
|
{ |
|
CBaseEntity *pInflictor = info.GetInflictor(); |
|
CBaseEntity *pKiller = info.GetAttacker(); |
|
CBasePlayer *pScorer = GetDeathScorer( pKiller, pInflictor, pVictim ); |
|
|
|
const char *killer_weapon_name = "world"; |
|
*iWeaponID = TF_WEAPON_NONE; |
|
|
|
if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BURNING ) |
|
{ |
|
// special-case burning damage, since persistent burning damage may happen after attacker has switched weapons |
|
killer_weapon_name = "tf_weapon_flamethrower"; |
|
*iWeaponID = TF_WEAPON_FLAMETHROWER; |
|
|
|
CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase * >( info.GetWeapon() ); |
|
if ( pWeapon ) |
|
{ |
|
CEconItemView *pItem = pWeapon->GetAttributeContainer()->GetItem(); |
|
if ( pItem && pItem->GetStaticData() && pItem->GetStaticData()->GetIconClassname() ) |
|
{ |
|
killer_weapon_name = pItem->GetStaticData()->GetIconClassname(); |
|
*iWeaponID = TF_WEAPON_NONE; |
|
} |
|
} |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BURNING_FLARE ) |
|
{ |
|
// special-case burning damage, since persistent burning damage may happen after attacker has switched weapons |
|
killer_weapon_name = "tf_weapon_flaregun"; |
|
*iWeaponID = TF_WEAPON_FLAREGUN; |
|
|
|
if ( pInflictor && pInflictor->IsPlayer() == false ) |
|
{ |
|
CTFBaseRocket *pBaseRocket = dynamic_cast<CTFBaseRocket*>( pInflictor ); |
|
|
|
if ( pBaseRocket ) |
|
{ |
|
if ( pBaseRocket->GetDeflected() ) |
|
{ |
|
killer_weapon_name = "deflect_flare"; |
|
} |
|
} |
|
} |
|
|
|
CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase * >( info.GetWeapon() ); |
|
if ( pWeapon && pWeapon->GetWeaponID() == TF_WEAPON_FLAREGUN_REVENGE ) |
|
{ |
|
CEconItemView *pItem = pWeapon->GetAttributeContainer()->GetItem(); |
|
if ( pItem && pItem->GetStaticData() && pItem->GetStaticData()->GetIconClassname() ) |
|
{ |
|
killer_weapon_name = pItem->GetStaticData()->GetIconClassname(); |
|
*iWeaponID = pWeapon->GetWeaponID(); |
|
} |
|
} |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_FLARE_EXPLOSION ) |
|
{ |
|
killer_weapon_name = "tf_weapon_detonator"; |
|
*iWeaponID = TF_WEAPON_FLAREGUN; |
|
|
|
if ( pInflictor && pInflictor->IsPlayer() == false ) |
|
{ |
|
CTFBaseRocket *pBaseRocket = dynamic_cast<CTFBaseRocket*>( pInflictor ); |
|
if ( pBaseRocket ) |
|
{ |
|
if ( pBaseRocket->GetDeflected() ) |
|
{ |
|
killer_weapon_name = "deflect_flare_detonator"; |
|
} |
|
} |
|
} |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_CHARGE_IMPACT ) |
|
{ |
|
CTFWearable *pWearable = dynamic_cast< CTFWearable * >( info.GetWeapon() ); |
|
if ( pWearable ) |
|
{ |
|
CEconItemView *pItem = pWearable->GetAttributeContainer()->GetItem(); |
|
if ( pItem && pItem->GetStaticData() && pItem->GetStaticData()->GetIconClassname() ) |
|
{ |
|
killer_weapon_name = pItem->GetStaticData()->GetIconClassname(); |
|
*iWeaponID = TF_WEAPON_NONE; |
|
} |
|
} |
|
} |
|
else if ( info.GetPlayerPenetrationCount() > 0 ) |
|
{ |
|
// This may be stomped later if the kill was a headshot. |
|
killer_weapon_name = "player_penetration"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_PICKAXE ) |
|
{ |
|
killer_weapon_name = "pickaxe"; |
|
*iWeaponID = TF_WEAPON_SHOVEL; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_CARRIED_BUILDING ) |
|
{ |
|
killer_weapon_name = "tf_weapon_building_carried_destroyed"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_HADOUKEN ) |
|
{ |
|
killer_weapon_name = "tf_weapon_taunt_pyro"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_HIGH_NOON ) |
|
{ |
|
killer_weapon_name = "tf_weapon_taunt_heavy"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_GRAND_SLAM ) |
|
{ |
|
killer_weapon_name = "tf_weapon_taunt_scout"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_BARBARIAN_SWING ) |
|
{ |
|
killer_weapon_name = "tf_weapon_taunt_demoman"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_UBERSLICE ) |
|
{ |
|
killer_weapon_name = "tf_weapon_taunt_medic"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_FENCING ) |
|
{ |
|
killer_weapon_name = "tf_weapon_taunt_spy"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_ARROW_STAB ) |
|
{ |
|
killer_weapon_name = "tf_weapon_taunt_sniper"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_GRENADE ) |
|
{ |
|
CTFPlayer *pTFKiller = ToTFPlayer( pKiller ); |
|
if ( pTFKiller && pTFKiller->IsWormsGearEquipped() ) |
|
{ |
|
killer_weapon_name = "tf_weapon_taunt_soldier_lumbricus"; |
|
} |
|
else |
|
{ |
|
killer_weapon_name = "tf_weapon_taunt_soldier"; |
|
} |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_ENGINEER_GUITAR_SMASH ) |
|
{ |
|
killer_weapon_name = "tf_weapon_taunt_guitar_kill"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_ALLCLASS_GUITAR_RIFF ) |
|
{ |
|
killer_weapon_name = "tf_weapon_taunt_guitar_riff_kill"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_ENGINEER_ARM_KILL ) |
|
{ |
|
killer_weapon_name = "robot_arm_blender_kill"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TELEFRAG ) |
|
{ |
|
killer_weapon_name = "telefrag"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BOOTS_STOMP ) |
|
{ |
|
killer_weapon_name = "mantreads"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BASEBALL ) |
|
{ |
|
killer_weapon_name = "ball"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_COMBO_PUNCH ) |
|
{ |
|
killer_weapon_name = "robot_arm_combo_kill"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BLEEDING ) |
|
{ |
|
killer_weapon_name = "tf_weapon_bleed_kill"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_PLAYER_SENTRY ) |
|
{ |
|
int nGigerCounter = 0; |
|
if ( pScorer ) |
|
{ |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pScorer, nGigerCounter, is_giger_counter ); |
|
} |
|
|
|
if ( nGigerCounter > 0 ) |
|
{ |
|
killer_weapon_name = "giger_counter"; |
|
} |
|
else |
|
{ |
|
killer_weapon_name = "wrangler_kill"; |
|
} |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_DECAPITATION_BOSS ) |
|
{ |
|
killer_weapon_name = "headtaker"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_EYEBALL_ROCKET ) |
|
{ |
|
killer_weapon_name = "eyeball_rocket"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_STICKBOMB_EXPLOSION ) |
|
{ |
|
killer_weapon_name = "ullapool_caber_explosion"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_ARMAGEDDON ) |
|
{ |
|
killer_weapon_name = "armageddon"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SAPPER_RECORDER_DEATH ) |
|
{ |
|
killer_weapon_name = "recorder"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_MERASMUS_DECAPITATION ) |
|
{ |
|
killer_weapon_name = "merasmus_decap"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_MERASMUS_ZAP ) |
|
{ |
|
killer_weapon_name = "merasmus_zap"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_MERASMUS_GRENADE ) |
|
{ |
|
killer_weapon_name = "merasmus_grenade"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_MERASMUS_PLAYER_BOMB ) |
|
{ |
|
killer_weapon_name = "merasmus_player_bomb"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_CANNONBALL_PUSH ) |
|
{ |
|
killer_weapon_name = "loose_cannon_impact"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_TELEPORT ) |
|
{ |
|
killer_weapon_name = "spellbook_teleport"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_SKELETON ) |
|
{ |
|
killer_weapon_name = "spellbook_skeleton"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_MIRV ) |
|
{ |
|
killer_weapon_name = "spellbook_mirv"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_METEOR ) |
|
{ |
|
killer_weapon_name = "spellbook_meteor"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_LIGHTNING ) |
|
{ |
|
killer_weapon_name = "spellbook_lightning"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_FIREBALL ) |
|
{ |
|
killer_weapon_name = "spellbook_fireball"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_MONOCULUS ) |
|
{ |
|
killer_weapon_name = "spellbook_boss"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_BLASTJUMP ) |
|
{ |
|
killer_weapon_name = "spellbook_blastjump"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_BATS ) |
|
{ |
|
killer_weapon_name = "spellbook_bats"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_TINY ) |
|
{ |
|
killer_weapon_name = "spellbook_athletic"; |
|
} |
|
else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_THROWABLE || |
|
info.GetDamageCustom() == TF_DMG_CUSTOM_THROWABLE_KILL ) // Throwables |
|
{ |
|
if ( pVictim && pVictim->GetHealth() <= 0 ) |
|
{ |
|
killer_weapon_name = "water_balloon_kill"; |
|
} |
|
else |
|
{ |
|
killer_weapon_name = "water_balloon_hit"; |
|
} |
|
*iWeaponID = TF_WEAPON_THROWABLE; |
|
} |
|
else if ( pScorer && pInflictor && ( pInflictor == pScorer ) ) |
|
{ |
|
// If this is not a suicide |
|
if ( pVictim != pScorer ) |
|
{ |
|
// If the inflictor is the killer, then it must be their current weapon doing the damage |
|
if ( pScorer->GetActiveWeapon() ) |
|
{ |
|
killer_weapon_name = pScorer->GetActiveWeapon()->GetClassname(); |
|
if ( pScorer->IsPlayer() ) |
|
{ |
|
*iWeaponID = ToTFPlayer(pScorer)->GetActiveTFWeapon()->GetWeaponID(); |
|
} |
|
} |
|
} |
|
} |
|
else if ( pInflictor ) |
|
{ |
|
killer_weapon_name = STRING( pInflictor->m_iClassname ); |
|
|
|
CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase * >( pInflictor ); |
|
if ( pWeapon ) |
|
{ |
|
*iWeaponID = pWeapon->GetWeaponID(); |
|
} |
|
else |
|
{ |
|
CTFBaseRocket *pBaseRocket = dynamic_cast<CTFBaseRocket*>( pInflictor ); |
|
if ( pBaseRocket ) |
|
{ |
|
*iWeaponID = pBaseRocket->GetWeaponID(); |
|
|
|
if ( pBaseRocket->GetDeflected() ) |
|
{ |
|
if ( *iWeaponID == TF_WEAPON_ROCKETLAUNCHER || *iWeaponID == TF_WEAPON_ROCKETLAUNCHER_DIRECTHIT ) |
|
{ |
|
killer_weapon_name = "deflect_rocket"; |
|
} |
|
else if ( *iWeaponID == TF_WEAPON_COMPOUND_BOW ) |
|
{ |
|
CTFProjectile_Arrow* pArrow = dynamic_cast<CTFProjectile_Arrow*>( pBaseRocket ); |
|
if ( pArrow && pArrow->IsAlight() ) |
|
{ |
|
killer_weapon_name = "deflect_huntsman_flyingburn"; |
|
} |
|
else |
|
{ |
|
killer_weapon_name = "deflect_arrow"; |
|
} |
|
} |
|
else if ( *iWeaponID == TF_WEAPON_SHOTGUN_BUILDING_RESCUE ) |
|
{ |
|
killer_weapon_name = "rescue_ranger_reflect"; |
|
} |
|
} |
|
else if ( *iWeaponID == TF_WEAPON_ROCKETLAUNCHER_DIRECTHIT ) |
|
{ |
|
killer_weapon_name = "rocketlauncher_directhit"; |
|
} |
|
} |
|
else |
|
{ |
|
CTFWeaponBaseGrenadeProj *pBaseGrenade = dynamic_cast<CTFWeaponBaseGrenadeProj*>( pInflictor ); |
|
if ( pBaseGrenade ) |
|
{ |
|
*iWeaponID = pBaseGrenade->GetWeaponID(); |
|
|
|
if ( pBaseGrenade->GetDeflected() ) |
|
{ |
|
if ( *iWeaponID == TF_WEAPON_GRENADE_PIPEBOMB ) |
|
{ |
|
killer_weapon_name = "deflect_sticky"; |
|
} |
|
else if ( *iWeaponID == TF_WEAPON_GRENADE_DEMOMAN ) |
|
{ |
|
killer_weapon_name = "deflect_promode"; |
|
} |
|
else if ( *iWeaponID == TF_WEAPON_BAT_WOOD ) |
|
{ |
|
killer_weapon_name = "deflect_ball"; |
|
} |
|
else if ( *iWeaponID == TF_WEAPON_CANNON ) |
|
{ |
|
killer_weapon_name = "loose_cannon_reflect"; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
if ( info.GetDamageCustom() == TF_DMG_CUSTOM_DEFENSIVE_STICKY ) |
|
{ |
|
killer_weapon_name = "sticky_resistance"; |
|
} |
|
|
|
// strip certain prefixes from inflictor's classname |
|
const char *prefix[] = { "tf_weapon_grenade_", "tf_weapon_", "NPC_", "func_" }; |
|
for ( int i = 0; i< ARRAYSIZE( prefix ); i++ ) |
|
{ |
|
// if prefix matches, advance the string pointer past the prefix |
|
int len = Q_strlen( prefix[i] ); |
|
if ( strncmp( killer_weapon_name, prefix[i], len ) == 0 ) |
|
{ |
|
killer_weapon_name += len; |
|
break; |
|
} |
|
} |
|
|
|
// look out for sentry rocket as weapon and map it to sentry gun, so we get the sentry death icon based off level |
|
|
|
if ( 0 == Q_strcmp( killer_weapon_name, "tf_projectile_sentryrocket" ) ) |
|
{ |
|
killer_weapon_name = "obj_sentrygun3"; |
|
} |
|
else if ( 0 == Q_strcmp( killer_weapon_name, "obj_sentrygun" ) ) |
|
{ |
|
CObjectSentrygun *pSentrygun = assert_cast<CObjectSentrygun*>( pInflictor ); |
|
if ( pSentrygun ) |
|
{ |
|
if ( pSentrygun->IsMiniBuilding() ) |
|
{ |
|
killer_weapon_name = "obj_minisentry"; |
|
} |
|
else |
|
{ |
|
int iSentryLevel = pSentrygun->GetUpgradeLevel(); |
|
switch( iSentryLevel) |
|
{ |
|
case 1: |
|
killer_weapon_name = "obj_sentrygun"; |
|
break; |
|
case 2: |
|
killer_weapon_name = "obj_sentrygun2"; |
|
break; |
|
case 3: |
|
killer_weapon_name = "obj_sentrygun3"; |
|
break; |
|
default: |
|
killer_weapon_name = "obj_sentrygun"; |
|
break; |
|
} |
|
} |
|
} |
|
} |
|
else if ( 0 == Q_strcmp( killer_weapon_name, "tf_projectile_healing_bolt" ) ) |
|
{ |
|
killer_weapon_name = "crusaders_crossbow"; |
|
} |
|
else if ( 0 == Q_strcmp( killer_weapon_name, "tf_projectile_pipe" ) ) |
|
{ |
|
// let's look-up the primary weapon to see what type of grenade launcher it is |
|
if ( pScorer ) |
|
{ |
|
CTFPlayer *pTFScorer = ToTFPlayer( pScorer ); |
|
if ( pTFScorer ) |
|
{ |
|
CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase * >( pTFScorer->Weapon_GetWeaponByType( TF_WPN_TYPE_PRIMARY ) ); |
|
if ( pWeapon && ( pWeapon->GetWeaponID() == TF_WEAPON_GRENADELAUNCHER ) && pWeapon->GetAttributeContainer() ) |
|
{ |
|
CEconItemView *pItem = pWeapon->GetAttributeContainer()->GetItem(); |
|
if ( pItem && pItem->GetStaticData() ) |
|
{ |
|
if ( pItem->GetStaticData()->GetIconClassname() ) |
|
{ |
|
killer_weapon_name = pItem->GetStaticData()->GetIconClassname(); |
|
*iWeaponID = TF_WEAPON_NONE; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
else if ( 0 == Q_strcmp( killer_weapon_name, "tf_projectile_energy_ring" ) ) |
|
{ |
|
CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase *>( info.GetWeapon() ); |
|
if ( pWeapon ) |
|
{ |
|
CEconItemView *pItem = pWeapon->GetAttributeContainer()->GetItem(); |
|
if ( pItem && pItem->GetStaticData() && pItem->GetStaticData()->GetIconClassname() ) |
|
{ |
|
killer_weapon_name = pItem->GetStaticData()->GetIconClassname(); |
|
*iWeaponID = TF_WEAPON_NONE; |
|
} |
|
} |
|
} |
|
else if ( 0 == Q_strcmp( killer_weapon_name, "obj_attachment_sapper" ) ) |
|
{ |
|
// let's look-up the sapper weapon to see what type it is |
|
if ( pScorer ) |
|
{ |
|
CTFPlayer *pTFScorer = ToTFPlayer( pScorer ); |
|
if ( pTFScorer ) |
|
{ |
|
CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase *>( pTFScorer->GetEntityForLoadoutSlot( LOADOUT_POSITION_BUILDING ) ); |
|
|
|
if ( pWeapon && ( pWeapon->GetWeaponID() == TF_WEAPON_BUILDER ) && pWeapon->GetAttributeContainer() ) |
|
{ |
|
CEconItemView *pItem = pWeapon->GetAttributeContainer()->GetItem(); |
|
if ( pItem && pItem->GetStaticData() ) |
|
{ |
|
if ( pItem->GetStaticData()->GetIconClassname() ) |
|
{ |
|
killer_weapon_name = pItem->GetStaticData()->GetIconClassname(); |
|
*iWeaponID = TF_WEAPON_NONE; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
else if ( ( info.GetDamageCustom() == TF_DMG_CUSTOM_STANDARD_STICKY ) || ( info.GetDamageCustom() == TF_DMG_CUSTOM_AIR_STICKY_BURST ) ) |
|
{ |
|
// let's look-up the secondary weapon to see what type of sticky launcher it is |
|
if ( pScorer ) |
|
{ |
|
CTFPlayer *pTFScorer = ToTFPlayer( pScorer ); |
|
if ( pTFScorer ) |
|
{ |
|
CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase * >( pTFScorer->Weapon_GetWeaponByType( TF_WPN_TYPE_SECONDARY ) ); |
|
if ( pWeapon && ( pWeapon->GetWeaponID() == TF_WEAPON_PIPEBOMBLAUNCHER ) && pWeapon->GetAttributeContainer() ) |
|
{ |
|
CEconItemView *pItem = pWeapon->GetAttributeContainer()->GetItem(); |
|
if ( pItem && pItem->GetStaticData() ) |
|
{ |
|
if ( pItem->GetStaticData()->GetIconClassname() ) |
|
{ |
|
killer_weapon_name = pItem->GetStaticData()->GetIconClassname(); |
|
*iWeaponID = TF_WEAPON_NONE; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
return killer_weapon_name; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: returns the player who assisted in the kill, or NULL if no assister |
|
//----------------------------------------------------------------------------- |
|
CBasePlayer *CTFGameRules::GetAssister( CBasePlayer *pVictim, CBasePlayer *pScorer, CBaseEntity *pInflictor ) |
|
{ |
|
CTFPlayer *pTFScorer = ToTFPlayer( pScorer ); |
|
CTFPlayer *pTFVictim = ToTFPlayer( pVictim ); |
|
if ( pTFScorer && pTFVictim ) |
|
{ |
|
// if victim killed himself, don't award an assist to anyone else, even if there was a recent damager |
|
if ( pTFScorer == pTFVictim ) |
|
return NULL; |
|
|
|
// If an assist has been specified already, use it. |
|
if ( pTFVictim->m_Shared.GetAssist() ) |
|
{ |
|
return pTFVictim->m_Shared.GetAssist(); |
|
} |
|
|
|
// If a player is healing the scorer, give that player credit for the assist |
|
CTFPlayer *pHealer = ToTFPlayer( pTFScorer->m_Shared.GetFirstHealer() ); |
|
// Must be a medic to receive a healing assist, otherwise engineers get credit for assists from dispensers doing healing. |
|
// Also don't give an assist for healing if the inflictor was a sentry gun, otherwise medics healing engineers get assists for the engineer's sentry kills. |
|
if ( pHealer && ( TF_CLASS_MEDIC == pHealer->GetPlayerClass()->GetClassIndex() ) && ( NULL == dynamic_cast<CObjectSentrygun *>( pInflictor ) ) ) |
|
{ |
|
return pHealer; |
|
} |
|
|
|
// If we're under the effect of a condition that grants assists, give one to the player that buffed us |
|
CTFPlayer *pCondAssister = ToTFPlayer( pTFScorer->m_Shared.GetConditionAssistFromAttacker() ); |
|
if ( pCondAssister ) |
|
return pCondAssister; |
|
|
|
// See who has damaged the victim 2nd most recently (most recent is the killer), and if that is within a certain time window. |
|
// If so, give that player an assist. (Only 1 assist granted, to single other most recent damager.) |
|
CTFPlayer *pRecentDamager = GetRecentDamager( pTFVictim, 1, TF_TIME_ASSIST_KILL ); |
|
if ( pRecentDamager && ( pRecentDamager != pScorer ) ) |
|
return pRecentDamager; |
|
|
|
// if a teammate has recently helped this sentry (ie: wrench hit), they assisted in the kill |
|
CObjectSentrygun *sentry = dynamic_cast< CObjectSentrygun * >( pInflictor ); |
|
if ( sentry ) |
|
{ |
|
CTFPlayer *pAssister = sentry->GetAssistingTeammate( TF_TIME_ASSIST_KILL ); |
|
if ( pAssister ) |
|
return pAssister; |
|
} |
|
} |
|
return NULL; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Returns specified recent damager, if there is one who has done damage |
|
// within the specified time period. iDamager=0 returns the most recent |
|
// damager, iDamager=1 returns the next most recent damager. |
|
//----------------------------------------------------------------------------- |
|
CTFPlayer *CTFGameRules::GetRecentDamager( CTFPlayer *pVictim, int iDamager, float flMaxElapsed ) |
|
{ |
|
EntityHistory_t *damagerHistory = pVictim->m_AchievementData.GetDamagerHistory( iDamager ); |
|
if ( !damagerHistory ) |
|
return NULL; |
|
|
|
if ( damagerHistory->hEntity && ( gpGlobals->curtime - damagerHistory->flTimeDamage <= flMaxElapsed ) ) |
|
{ |
|
CTFPlayer *pRecentDamager = ToTFPlayer( damagerHistory->hEntity ); |
|
if ( pRecentDamager ) |
|
return pRecentDamager; |
|
} |
|
return NULL; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Returns who should be awarded the kill |
|
//----------------------------------------------------------------------------- |
|
CBasePlayer *CTFGameRules::GetDeathScorer( CBaseEntity *pKiller, CBaseEntity *pInflictor, CBaseEntity *pVictim ) |
|
{ |
|
if ( ( pKiller == pVictim ) && ( pKiller == pInflictor ) ) |
|
{ |
|
// If this was an explicit suicide, see if there was a damager within a certain time window. If so, award this as a kill to the damager. |
|
CTFPlayer *pTFVictim = ToTFPlayer( pVictim ); |
|
if ( pTFVictim ) |
|
{ |
|
CTFPlayer *pRecentDamager = GetRecentDamager( pTFVictim, 0, TF_TIME_SUICIDE_KILL_CREDIT ); |
|
if ( pRecentDamager ) |
|
return pRecentDamager; |
|
} |
|
} |
|
|
|
//Handle Pyro's Deflection credit. |
|
CTFWeaponBaseGrenadeProj *pBaseGrenade = dynamic_cast<CTFWeaponBaseGrenadeProj*>( pInflictor ); |
|
|
|
if ( pBaseGrenade ) |
|
{ |
|
if ( pBaseGrenade->GetDeflected() ) |
|
{ |
|
if ( pBaseGrenade->GetWeaponID() == TF_WEAPON_GRENADE_PIPEBOMB ) |
|
{ |
|
CTFPlayer *pDeflectOwner = ToTFPlayer( pBaseGrenade->GetDeflectOwner() ); |
|
|
|
if ( pDeflectOwner ) |
|
{ |
|
if ( pDeflectOwner->InSameTeam( pVictim ) == false ) |
|
return pDeflectOwner; |
|
else |
|
{ |
|
pBaseGrenade->ResetDeflected(); |
|
pBaseGrenade->SetDeflectOwner( NULL ); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
return BaseClass::GetDeathScorer( pKiller, pInflictor, pVictim ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
// Input : *pVictim - |
|
// *pKiller - |
|
// *pInflictor - |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::DeathNotice( CBasePlayer *pVictim, const CTakeDamageInfo &info ) |
|
{ |
|
DeathNotice( pVictim, info, "player_death" ); |
|
} |
|
|
|
void CTFGameRules::DeathNotice( CBasePlayer *pVictim, const CTakeDamageInfo &info, const char* eventName ) |
|
{ |
|
int killer_ID = 0; |
|
|
|
// Find the killer & the scorer |
|
CTFPlayer *pTFPlayerVictim = ToTFPlayer( pVictim ); |
|
CBaseEntity *pInflictor = info.GetInflictor(); |
|
CBaseEntity *pKiller = info.GetAttacker(); |
|
CTFPlayer *pScorer = ToTFPlayer( GetDeathScorer( pKiller, pInflictor, pVictim ) ); |
|
CTFPlayer *pAssister = ToTFPlayer( GetAssister( pVictim, pScorer, pInflictor ) ); |
|
|
|
// You can't assist yourself! |
|
Assert( pScorer != pAssister || !pScorer ); |
|
if ( pScorer == pAssister && pScorer ) |
|
{ |
|
pAssister = NULL; |
|
} |
|
|
|
// Silent killers cause no death notices. |
|
bool bSilentKill = false; |
|
CTFPlayer *pAttacker = (CTFPlayer*)ToTFPlayer( info.GetAttacker() ); |
|
if ( pAttacker ) |
|
{ |
|
CTFWeaponBase *pWpn = pAttacker->GetActiveTFWeapon(); |
|
if ( pWpn && pWpn->IsSilentKiller() && ( info.GetDamageCustom() == TF_DMG_CUSTOM_BACKSTAB ) ) |
|
bSilentKill = true; |
|
} |
|
|
|
// Determine whether it's a feign death fake death notice |
|
bool bFeignDeath = pTFPlayerVictim->IsGoingFeignDeath(); |
|
if ( bFeignDeath ) |
|
{ |
|
CTFPlayer *pDisguiseTarget = ToTFPlayer( pTFPlayerVictim->m_Shared.GetDisguiseTarget() ); |
|
if ( pDisguiseTarget && (pTFPlayerVictim->GetTeamNumber() == pDisguiseTarget->GetTeamNumber()) ) |
|
{ |
|
// We're disguised as a team mate. Pretend to die as that player instead of us. |
|
pVictim = pTFPlayerVictim = pDisguiseTarget; |
|
} |
|
} |
|
|
|
// Work out what killed the player, and send a message to all clients about it |
|
int iWeaponID; |
|
const char *killer_weapon_name = GetKillingWeaponName( info, pTFPlayerVictim, &iWeaponID ); |
|
const char *killer_weapon_log_name = killer_weapon_name; |
|
|
|
// Kill eater events. |
|
{ |
|
// Was this a sentry kill? If the sentry did the kill itself with bullets then it'll be the inflictor. |
|
// If it got the kill by firing a rocket, the rocket will be the inflictor and the sentry will be the |
|
// owner of the rocket. |
|
// |
|
// Holy crap dynamic_cast quagmire of sadness below. |
|
CObjectSentrygun *pSentrygun = dynamic_cast<CObjectSentrygun *>( pInflictor ); |
|
if ( !pSentrygun ) |
|
{ |
|
pSentrygun = pInflictor ? dynamic_cast<CObjectSentrygun *>( pInflictor->GetOwnerEntity() ) : NULL; |
|
} |
|
|
|
if ( pSentrygun ) |
|
{ |
|
// Try to grab the wrench that the engineer has equipped right now. We destroy sentries when wrenches |
|
// get changed so whatever they have equipped right now counts for the wrench that built this sentry. |
|
CTFPlayer *pBuilder = pSentrygun->GetBuilder(); |
|
if ( pBuilder ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( dynamic_cast<CEconEntity *>( pBuilder->GetEntityForLoadoutSlot( LOADOUT_POSITION_MELEE ) ), pScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillsBySentry ); |
|
// PDA's Also count Sentry kills |
|
EconEntity_OnOwnerKillEaterEvent( dynamic_cast<CEconEntity *>( pBuilder->GetEntityForLoadoutSlot( LOADOUT_POSITION_PDA ) ), pScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillsBySentry ); |
|
|
|
// Check if the engineer is using a Wrangler on this sentry |
|
CTFLaserPointer* pLaserPointer = dynamic_cast< CTFLaserPointer * >( pBuilder->GetEntityForLoadoutSlot( LOADOUT_POSITION_SECONDARY ) ); |
|
if ( pLaserPointer && pLaserPointer->HasLaserDot() ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( dynamic_cast<CEconEntity *>( pLaserPointer ), pScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillsByManualControlOfSentry ); |
|
} |
|
} |
|
} |
|
|
|
// Should we award an assist kill to someone? |
|
if ( pAssister ) |
|
{ |
|
EconEntity_OnOwnerKillEaterEvent( dynamic_cast<CEconEntity *>( pAssister->GetActiveWeapon() ), pAssister, pTFPlayerVictim, kKillEaterEvent_PlayerKillAssist ); |
|
HatAndMiscEconEntities_OnOwnerKillEaterEvent( pAssister, pTFPlayerVictim, kKillEaterEvent_CosmeticAssists ); |
|
} |
|
} |
|
|
|
if ( pScorer ) // Is the killer a client? |
|
{ |
|
killer_ID = pScorer->GetUserID(); |
|
} |
|
|
|
CTFWeaponBase *pScorerWeapon = NULL; |
|
if ( pScorer ) |
|
{ |
|
pScorerWeapon = dynamic_cast< CTFWeaponBase * >( pScorer->Weapon_OwnsThisID( iWeaponID ) ); |
|
if ( pScorerWeapon ) |
|
{ |
|
CEconItemView *pItem = pScorerWeapon->GetAttributeContainer()->GetItem(); |
|
|
|
if ( pItem ) |
|
{ |
|
if ( pItem->GetStaticData()->GetIconClassname() ) |
|
{ |
|
killer_weapon_name = pItem->GetStaticData()->GetIconClassname(); |
|
} |
|
|
|
if ( pItem->GetStaticData()->GetLogClassname() ) |
|
{ |
|
killer_weapon_log_name = pItem->GetStaticData()->GetLogClassname(); |
|
} |
|
} |
|
} |
|
} |
|
|
|
// In Arena mode award first blood to the first player that kills an enemy. |
|
bool bKillWasFirstBlood = false; |
|
if ( IsFirstBloodAllowed() ) |
|
{ |
|
if ( pScorer && pVictim && pScorer != pVictim ) |
|
{ |
|
if ( !FStrEq( eventName, "fish_notice" ) && !FStrEq( eventName, "fish_notice__arm" ) && !FStrEq( eventName, "throwable_hit" ) ) |
|
{ |
|
#ifndef _DEBUG |
|
if ( GetGlobalTeam( pVictim->GetTeamNumber() ) && GetGlobalTeam( pVictim->GetTeamNumber() )->GetNumPlayers() > 1 ) |
|
#endif // !DEBUG |
|
{ |
|
float flFastTime = IsCompetitiveMode() ? 120.f : TF_ARENA_MODE_FAST_FIRST_BLOOD_TIME; |
|
float flSlowTime = IsCompetitiveMode() ? 300.f : TF_ARENA_MODE_SLOW_FIRST_BLOOD_TIME; |
|
|
|
if ( ( gpGlobals->curtime - m_flRoundStartTime ) <= flFastTime ) |
|
{ |
|
BroadcastSound( 255, "Announcer.AM_FirstBloodFast" ); |
|
} |
|
else if ( ( gpGlobals->curtime - m_flRoundStartTime ) >= flSlowTime ) |
|
{ |
|
BroadcastSound( 255, "Announcer.AM_FirstBloodFinally" ); |
|
} |
|
else |
|
{ |
|
BroadcastSound( 255, "Announcer.AM_FirstBloodRandom" ); |
|
} |
|
|
|
m_bArenaFirstBlood = true; |
|
bKillWasFirstBlood = true; |
|
|
|
if ( IsCompetitiveMode() ) |
|
{ |
|
// CTF_GameStats.Event_PlayerAwardBonusPoints( pScorer, pVictim, 10 ); |
|
// |
|
// CUtlVector< CTFPlayer* > vecPlayers; |
|
// CollectPlayers( &vecPlayers, pScorer->GetTeamNumber(), false ); |
|
// FOR_EACH_VEC( vecPlayers, i ) |
|
// { |
|
// if ( !vecPlayers[i] ) |
|
// continue; |
|
// |
|
// if ( vecPlayers[i] == pScorer ) |
|
// continue; |
|
// |
|
// CTF_GameStats.Event_PlayerAwardBonusPoints( vecPlayers[i], pVictim, 5 ); |
|
// } |
|
} |
|
else |
|
{ |
|
pScorer->m_Shared.AddCond( TF_COND_CRITBOOSTED_FIRST_BLOOD, TF_ARENA_MODE_FIRST_BLOOD_CRIT_TIME ); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
// so you can't turn on the ConVar in the middle of a round and get the first blood reward |
|
m_bArenaFirstBlood = true; |
|
} |
|
|
|
// Awesome hack for pyroland silliness: if there was no other assister, and the person that got |
|
// the kill has some sort of "pet" item (balloonicorn, brainslug, etc.), we send the name of |
|
// that item down as the assister. We'll use a custom name if available and fall back to the |
|
// localization token (localized on the client) if not. |
|
CUtlConstString sAssisterOverrideDesc; |
|
|
|
if ( pScorer && !pAssister ) |
|
{ |
|
// Find out whether the killer has at least one item that will ask for kill assist credit. |
|
int iKillerHasPetItem = 0; |
|
CUtlVector<CBaseEntity *> vecItems; |
|
CALL_ATTRIB_HOOK_FLOAT_ON_OTHER_WITH_ITEMS( pScorer, iKillerHasPetItem, &vecItems, counts_as_assister ); |
|
|
|
FOR_EACH_VEC( vecItems, i ) |
|
{ |
|
CEconEntity *pEconEntity = dynamic_cast<CEconEntity *>( vecItems[i] ); |
|
if ( !pEconEntity ) |
|
continue; |
|
|
|
CEconItemView *pEconItemView = pEconEntity->GetAttributeContainer()->GetItem(); |
|
if ( !pEconItemView ) |
|
continue; |
|
|
|
if ( pEconItemView->GetCustomName() ) |
|
{ |
|
sAssisterOverrideDesc = CFmtStr( "%c%s", iKillerHasPetItem == 2 ? kHorriblePyroVisionHack_KillAssisterType_CustomName_First : kHorriblePyroVisionHack_KillAssisterType_CustomName, pEconItemView->GetCustomName() ); |
|
} |
|
else |
|
{ |
|
sAssisterOverrideDesc = CFmtStr( "%c%s", iKillerHasPetItem == 2 ? kHorriblePyroVisionHack_KillAssisterType_LocalizationString_First : kHorriblePyroVisionHack_KillAssisterType_LocalizationString, pEconItemView->GetItemDefinition()->GetItemBaseName() ).Get(); |
|
} |
|
break; |
|
} |
|
} |
|
|
|
IGameEvent * event = gameeventmanager->CreateEvent( eventName /* "player_death" */ ); |
|
|
|
//if ( event && FStrEq( eventName, "throwable_hit" ) ) |
|
//{ |
|
// int iHitCount = 1; |
|
// PlayerStats_t *pStats = CTF_GameStats.FindPlayerStats( pScorer ); |
|
// if ( pStats ) |
|
// { |
|
// iHitCount = pStats->statsAccumulated.Get( TFSTAT_THROWABLEHIT ); |
|
// } |
|
|
|
// event->SetInt( "totalhits", iHitCount ); |
|
//} |
|
|
|
if ( event ) |
|
{ |
|
event->SetInt( "userid", pVictim->GetUserID() ); |
|
event->SetInt( "victim_entindex", pVictim->entindex() ); |
|
event->SetInt( "attacker", killer_ID ); |
|
event->SetInt( "assister", pAssister ? pAssister->GetUserID() : -1 ); |
|
event->SetString( "weapon", killer_weapon_name ); |
|
event->SetString( "weapon_logclassname", killer_weapon_log_name ); |
|
event->SetInt( "weaponid", iWeaponID ); |
|
event->SetInt( "damagebits", info.GetDamageType() ); |
|
event->SetInt( "customkill", info.GetDamageCustom() ); |
|
event->SetInt( "inflictor_entindex", pInflictor ? pInflictor->entindex() : -1 ); |
|
event->SetInt( "priority", 7 ); // HLTV event priority, not transmitted |
|
|
|
if ( info.GetPlayerPenetrationCount() > 0 ) |
|
{ |
|
event->SetInt( "playerpenetratecount", info.GetPlayerPenetrationCount() ); |
|
} |
|
|
|
if ( !sAssisterOverrideDesc.IsEmpty() ) |
|
{ |
|
event->SetString( "assister_fallback", sAssisterOverrideDesc.Get() ); |
|
} |
|
|
|
event->SetBool( "silent_kill", bSilentKill ); |
|
|
|
int iDeathFlags = pTFPlayerVictim->GetDeathFlags(); |
|
|
|
if ( bKillWasFirstBlood ) |
|
{ |
|
iDeathFlags |= TF_DEATH_FIRST_BLOOD; |
|
} |
|
|
|
if ( bFeignDeath ) |
|
{ |
|
iDeathFlags |= TF_DEATH_FEIGN_DEATH; |
|
} |
|
|
|
if ( pTFPlayerVictim->WasGibbedOnLastDeath() ) |
|
{ |
|
iDeathFlags |= TF_DEATH_GIBBED; |
|
} |
|
|
|
if ( pTFPlayerVictim->IsInPurgatory() ) |
|
{ |
|
iDeathFlags |= TF_DEATH_PURGATORY; |
|
} |
|
|
|
if ( pTFPlayerVictim->IsMiniBoss() ) |
|
{ |
|
iDeathFlags |= TF_DEATH_MINIBOSS; |
|
} |
|
|
|
// Australium Guns get a Gold Background |
|
IHasAttributes *pAttribInterface = GetAttribInterface( info.GetWeapon() ); |
|
if ( pAttribInterface ) |
|
{ |
|
int iIsAustralium = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iIsAustralium, is_australium_item ); |
|
if ( iIsAustralium ) |
|
{ |
|
iDeathFlags |= TF_DEATH_AUSTRALIUM; |
|
} |
|
} |
|
|
|
// We call this directly since we need more information than provided in the event alone. |
|
if ( FStrEq( eventName, "player_death" ) ) |
|
{ |
|
CTF_GameStats.Event_KillDetail( pScorer, pTFPlayerVictim, pAssister, event, info ); |
|
event->SetInt( "kill_streak_victim", pTFPlayerVictim->m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Kills ) ); |
|
event->SetBool( "rocket_jump", ( pTFPlayerVictim->RocketJumped() == 1 ) ); |
|
event->SetInt( "crit_type", info.GetCritType() ); |
|
|
|
// Kill streak updating |
|
if ( pTFPlayerVictim && pScorer && pTFPlayerVictim != pScorer ) |
|
{ |
|
// Propagate duckstreaks |
|
event->SetInt( "duck_streak_victim", pTFPlayerVictim->m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Ducks ) ); |
|
event->SetInt( "duck_streak_total", pScorer->m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Ducks ) ); |
|
event->SetInt( "ducks_streaked", pScorer->m_Shared.GetLastDuckStreakIncrement() ); |
|
|
|
// Check if they have the appropriate attribute. |
|
int iKillStreak = 0; |
|
int iKills = 0; |
|
CBaseEntity *pKillStreakTarget = NULL; |
|
if ( !pAttribInterface ) |
|
{ |
|
// Check if you are a sentry and if so, use the wrench |
|
// For Sentries Inflictor can be the sentry (bullets) or the Sentry Rocket |
|
|
|
CObjectSentrygun *pSentry = dynamic_cast<CObjectSentrygun*>( pInflictor ); |
|
if ( !pSentry && pInflictor ) |
|
{ |
|
pSentry = dynamic_cast<CObjectSentrygun*>( pInflictor->GetOwnerEntity() ); |
|
} |
|
|
|
if ( pSentry ) |
|
{ |
|
pKillStreakTarget = dynamic_cast<CTFWeaponBase*>( pScorer->GetEntityForLoadoutSlot( LOADOUT_POSITION_MELEE ) ); |
|
} |
|
} |
|
else |
|
{ |
|
pKillStreakTarget = info.GetWeapon(); |
|
} |
|
|
|
if ( pKillStreakTarget ) |
|
{ |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pKillStreakTarget, iKillStreak, killstreak_tier ); |
|
#ifdef STAGING_ONLY |
|
if ( tf_killstreak_alwayson.GetBool() ) |
|
{ |
|
iKillStreak = 1; |
|
} |
|
#endif |
|
// Always track killstreak regardless of the attribute for data collection purposes |
|
pScorer->m_Shared.IncrementStreak( CTFPlayerShared::kTFStreak_KillsAll, 1 ); |
|
if ( iKillStreak ) |
|
{ |
|
iKills = pScorer->m_Shared.IncrementStreak( CTFPlayerShared::kTFStreak_Kills, 1 ); |
|
event->SetInt( "kill_streak_total", iKills ); |
|
|
|
int iWepKills = 0; |
|
CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase*>( pKillStreakTarget ); |
|
if ( pWeapon ) |
|
{ |
|
iWepKills = pWeapon->GetKillStreak() + 1; |
|
pWeapon->SetKillStreak( iWepKills ); |
|
} |
|
else |
|
{ |
|
CTFWearable *pWearable = dynamic_cast<CTFWearable*>( pKillStreakTarget ); |
|
if ( pWearable ) |
|
{ |
|
iWepKills = pWearable->GetKillStreak() + 1; |
|
pWearable->SetKillStreak( iWepKills ); |
|
} |
|
} |
|
|
|
event->SetInt( "kill_streak_wep", iWepKills ); |
|
|
|
// Track each player's max streak per-round |
|
CTF_GameStats.Event_PlayerEarnedKillStreak( pScorer ); |
|
} |
|
} |
|
|
|
if ( pAssister ) |
|
{ |
|
event->SetInt( "duck_streak_assist", pAssister->m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Ducks ) ); |
|
|
|
// Only allow assists for Mediguns |
|
CTFWeaponBase *pAssisterWpn = pAssister->GetActiveTFWeapon(); |
|
if ( pAssisterWpn && pAssister->IsPlayerClass( TF_CLASS_MEDIC ) ) |
|
{ |
|
CWeaponMedigun *pMedigun = dynamic_cast<CWeaponMedigun*>( pAssisterWpn ); |
|
if ( pMedigun ) |
|
{ |
|
iKillStreak = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pAssisterWpn, iKillStreak, killstreak_tier ); |
|
#ifdef STAGING_ONLY |
|
if ( tf_killstreak_alwayson.GetBool() ) |
|
{ |
|
iKillStreak = 1; |
|
} |
|
#endif |
|
if ( iKillStreak ) |
|
{ |
|
iKills = pAssister->m_Shared.IncrementStreak( CTFPlayerShared::kTFStreak_Kills, 1 ); |
|
event->SetInt( "kill_streak_assist", iKills ); |
|
|
|
int iWepKills = pAssisterWpn->GetKillStreak() + 1; |
|
pAssisterWpn->SetKillStreak( iWepKills ); |
|
|
|
// Track each player's max streak per-round |
|
CTF_GameStats.Event_PlayerEarnedKillStreak( pAssister ); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
event->SetInt( "death_flags", iDeathFlags ); |
|
event->SetInt( "stun_flags", pTFPlayerVictim->m_iOldStunFlags ); |
|
|
|
item_definition_index_t weaponDefIndex = INVALID_ITEM_DEF_INDEX; |
|
if ( pScorerWeapon ) |
|
{ |
|
CEconItemView *pItem = pScorerWeapon->GetAttributeContainer()->GetItem(); |
|
if ( pItem ) |
|
{ |
|
weaponDefIndex = pItem->GetItemDefIndex(); |
|
} |
|
} |
|
else if ( pScorer && pScorer->GetActiveTFWeapon() ) |
|
{ |
|
// get from active weapon instead |
|
CEconItemView *pItem = pScorer->GetActiveTFWeapon()->GetAttributeContainer()->GetItem(); |
|
if ( pItem ) |
|
{ |
|
weaponDefIndex = pItem->GetItemDefIndex(); |
|
} |
|
} |
|
event->SetInt( "weapon_def_index", weaponDefIndex ); |
|
|
|
pTFPlayerVictim->m_iOldStunFlags = 0; |
|
|
|
gameeventmanager->FireEvent( event ); |
|
} |
|
} |
|
|
|
void CTFGameRules::ClientDisconnected( edict_t *pClient ) |
|
{ |
|
CTFPlayer *pPlayer = ToTFPlayer( GetContainingEntity( pClient ) ); |
|
if ( pPlayer ) |
|
{ |
|
// ACHIEVEMENT_TF_PYRO_DOMINATE_LEAVESVR - Pyro causes a dominated player to leave the server |
|
for ( int i = 1; i <= gpGlobals->maxClients ; i++ ) |
|
{ |
|
if ( pPlayer->m_Shared.IsPlayerDominatingMe(i) ) |
|
{ |
|
CTFPlayer *pDominatingPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
if ( pDominatingPlayer && pDominatingPlayer != pPlayer ) |
|
{ |
|
if ( pDominatingPlayer->IsPlayerClass(TF_CLASS_PYRO) ) |
|
{ |
|
pDominatingPlayer->AwardAchievement( ACHIEVEMENT_TF_PYRO_DOMINATE_LEAVESVR ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
CTFPlayerResource *pTFResource = dynamic_cast< CTFPlayerResource* >( g_pPlayerResource ); |
|
if ( pTFResource ) |
|
{ |
|
if ( pPlayer->entindex() == pTFResource->GetPartyLeaderIndex( pPlayer->GetTeamNumber() ) ) |
|
{ |
|
// the leader is leaving so reset the player resource index |
|
pTFResource->SetPartyLeaderIndex( pPlayer->GetTeamNumber(), 0 ); |
|
} |
|
} |
|
|
|
// Notify gamestats that the player left. |
|
CTF_GameStats.Event_PlayerDisconnectedTF( pPlayer ); |
|
|
|
// Check Ready status for the player |
|
if ( UsePlayerReadyStatusMode() ) |
|
{ |
|
if ( !pPlayer->IsBot() && State_Get() != GR_STATE_RND_RUNNING ) |
|
{ |
|
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() ); |
|
if ( !pMatchDesc || !pMatchDesc->m_params.m_bAutoReady ) |
|
{ |
|
// Always reset when a player leaves this type of match |
|
PlayerReadyStatus_ResetState(); |
|
} |
|
else if ( !IsTeamReady( pPlayer->GetTeamNumber() ) ) |
|
{ |
|
if ( IsPlayerReady( pPlayer->entindex() ) ) |
|
{ |
|
// Clear the ready status so it doesn't block the rest of the team |
|
PlayerReadyStatus_UpdatePlayerState( pPlayer, false ); |
|
} |
|
else |
|
{ |
|
// Disconnecting player wasn't ready, but is the rest of the team? |
|
// If so, we want to cancel the ready_state so it doesn't start right away when this player disconnects |
|
bool bEveryoneReady = true; |
|
CUtlVector<CTFPlayer *> playerVector; |
|
CollectPlayers( &playerVector, pPlayer->GetTeamNumber() ); |
|
FOR_EACH_VEC( playerVector, i ) |
|
{ |
|
if ( !playerVector[i] ) |
|
continue; |
|
|
|
if ( playerVector[i]->IsBot() ) |
|
continue; |
|
|
|
if ( playerVector[i] == pPlayer ) |
|
continue; |
|
|
|
if ( !IsPlayerReady( playerVector[i]->entindex() ) ) |
|
{ |
|
bEveryoneReady = false; |
|
} |
|
} |
|
|
|
if ( bEveryoneReady ) |
|
{ |
|
PlayerReadyStatus_ResetState(); |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
// If we're currently in a countdown we should cancel it |
|
if ( ( m_flRestartRoundTime > 0 ) || ( mp_restartgame.GetInt() > 0 ) ) |
|
{ |
|
PlayerReadyStatus_ResetState(); |
|
} |
|
} |
|
} |
|
} |
|
|
|
// clean up anything they left behind |
|
pPlayer->TeamFortress_ClientDisconnected(); |
|
Arena_ClientDisconnect( pPlayer->GetPlayerName() ); |
|
} |
|
|
|
BaseClass::ClientDisconnected( pClient ); |
|
|
|
// are any of the spies disguising as this player? |
|
for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ ) |
|
{ |
|
CTFPlayer *pTemp = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
if ( pTemp && pTemp != pPlayer ) |
|
{ |
|
if ( pTemp->m_Shared.GetDisguiseTarget() == pPlayer ) |
|
{ |
|
// choose someone else... |
|
pTemp->m_Shared.FindDisguiseTarget(); |
|
} |
|
} |
|
} |
|
} |
|
|
|
// Falling damage stuff. |
|
#define TF_PLAYER_MAX_SAFE_FALL_SPEED 650 |
|
|
|
float CTFGameRules::FlPlayerFallDamage( CBasePlayer *pPlayer ) |
|
{ |
|
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer ); |
|
if ( !pTFPlayer ) |
|
return 0; |
|
|
|
// Karts don't take fall damage |
|
if ( pTFPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_KART ) ) |
|
{ |
|
return 0; |
|
} |
|
|
|
// grappling hook don't take fall damage |
|
if ( pTFPlayer->GetGrapplingHookTarget() ) |
|
{ |
|
return 0; |
|
} |
|
|
|
if ( pTFPlayer->m_Shared.GetCarryingRuneType() == RUNE_AGILITY ) |
|
{ |
|
return 0; |
|
} |
|
|
|
if ( pPlayer->m_Local.m_flFallVelocity > TF_PLAYER_MAX_SAFE_FALL_SPEED ) |
|
{ |
|
// Old TFC damage formula |
|
float flFallDamage = 5 * (pPlayer->m_Local.m_flFallVelocity / 300); |
|
|
|
// Fall damage needs to scale according to the player's max health, or |
|
// it's always going to be much more dangerous to weaker classes than larger. |
|
float flRatio = (float)pPlayer->GetMaxHealth() / 100.0; |
|
flFallDamage *= flRatio; |
|
|
|
flFallDamage *= random->RandomFloat( 0.8, 1.2 ); |
|
|
|
int iCancelFallingDamage = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer, iCancelFallingDamage, cancel_falling_damage ); |
|
if ( iCancelFallingDamage > 0 ) |
|
flFallDamage = 0; |
|
|
|
return flFallDamage; |
|
} |
|
|
|
// Fall caused no damage |
|
return 0; |
|
} |
|
|
|
void CTFGameRules::SendArenaWinPanelInfo( void ) |
|
{ |
|
IGameEvent *winEvent = gameeventmanager->CreateEvent( "arena_win_panel" ); |
|
|
|
if ( winEvent ) |
|
{ |
|
int iBlueScore = GetGlobalTeam( TF_TEAM_BLUE )->GetScore(); |
|
int iRedScore = GetGlobalTeam( TF_TEAM_RED )->GetScore(); |
|
int iBlueScorePrev = iBlueScore; |
|
int iRedScorePrev = iRedScore; |
|
|
|
// if this is a complete round, calc team scores prior to this win |
|
switch ( m_iWinningTeam ) |
|
{ |
|
case TF_TEAM_BLUE: |
|
{ |
|
iBlueScorePrev = ( iBlueScore - TEAMPLAY_ROUND_WIN_SCORE >= 0 ) ? ( iBlueScore - TEAMPLAY_ROUND_WIN_SCORE ) : 0; |
|
|
|
if ( IsInTournamentMode() == false ) |
|
{ |
|
iRedScore = 0; |
|
} |
|
} |
|
break; |
|
|
|
case TF_TEAM_RED: |
|
{ |
|
iRedScorePrev = ( iRedScore - TEAMPLAY_ROUND_WIN_SCORE >= 0 ) ? ( iRedScore - TEAMPLAY_ROUND_WIN_SCORE ) : 0; |
|
|
|
if ( IsInTournamentMode() == false ) |
|
{ |
|
iBlueScore = 0; |
|
} |
|
|
|
break; |
|
} |
|
case TEAM_UNASSIGNED: |
|
break; // stalemate; nothing to do |
|
} |
|
|
|
winEvent->SetInt( "panel_style", WINPANEL_BASIC ); |
|
winEvent->SetInt( "winning_team", m_iWinningTeam ); |
|
winEvent->SetInt( "winreason", m_iWinReason ); |
|
winEvent->SetString( "cappers", ( m_iWinReason == WINREASON_ALL_POINTS_CAPTURED || m_iWinReason == WINREASON_FLAG_CAPTURE_LIMIT ) ? m_szMostRecentCappers : "" ); |
|
winEvent->SetInt( "blue_score", iBlueScore ); |
|
winEvent->SetInt( "red_score", iRedScore ); |
|
winEvent->SetInt( "blue_score_prev", iBlueScorePrev ); |
|
winEvent->SetInt( "red_score_prev", iRedScorePrev ); |
|
|
|
CTFPlayerResource *pResource = dynamic_cast< CTFPlayerResource * >( g_pPlayerResource ); |
|
if ( !pResource ) |
|
return; |
|
|
|
// build a vector of players & round scores |
|
CUtlVector<PlayerArenaRoundScore_t> vecPlayerScore; |
|
int iPlayerIndex; |
|
for( iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ ) |
|
{ |
|
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) ); |
|
if ( !pTFPlayer || !pTFPlayer->IsConnected() ) |
|
continue; |
|
// filter out spectators and, if not stalemate, all players not on winning team |
|
int iPlayerTeam = pTFPlayer->GetTeamNumber(); |
|
if ( ( iPlayerTeam < FIRST_GAME_TEAM ) ) |
|
continue; |
|
|
|
PlayerStats_t *pStats = CTF_GameStats.FindPlayerStats( pTFPlayer ); |
|
PlayerArenaRoundScore_t &playerRoundScore = vecPlayerScore[vecPlayerScore.AddToTail()]; |
|
|
|
playerRoundScore.iPlayerIndex = iPlayerIndex; |
|
|
|
if ( pStats ) |
|
{ |
|
playerRoundScore.iTotalDamage = pStats->statsCurrentRound.m_iStat[TFSTAT_DAMAGE]; |
|
playerRoundScore.iTotalHealing = pStats->statsCurrentRound.m_iStat[TFSTAT_HEALING]; |
|
|
|
if ( pTFPlayer->IsAlive() == true ) |
|
{ |
|
playerRoundScore.iTimeAlive = (int)gpGlobals->curtime - pTFPlayer->GetSpawnTime(); |
|
} |
|
else |
|
{ |
|
playerRoundScore.iTimeAlive = (int)pTFPlayer->GetDeathTime() - pTFPlayer->GetSpawnTime(); |
|
} |
|
|
|
playerRoundScore.iKillingBlows = pStats->statsCurrentRound.m_iStat[TFSTAT_KILLS]; |
|
playerRoundScore.iScore = CalcPlayerScore( &pStats->statsCurrentRound, pTFPlayer ); |
|
} |
|
} |
|
|
|
// sort the players by round score |
|
vecPlayerScore.Sort( PlayerArenaRoundScoreSortFunc ); |
|
|
|
// set the top (up to) 6 players by round score in the event data |
|
int numPlayers = 6; |
|
int iPlayersAdded = 0; |
|
|
|
// Add winners first |
|
for ( int i = 0; i < vecPlayerScore.Count(); i++ ) |
|
{ |
|
if ( GetWinningTeam() == TEAM_UNASSIGNED ) |
|
{ |
|
if ( iPlayersAdded >= 6 ) |
|
break; |
|
} |
|
else |
|
{ |
|
if ( iPlayersAdded >= 3 ) |
|
break; |
|
} |
|
|
|
int iPlayerIndex = vecPlayerScore[i].iPlayerIndex; |
|
|
|
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) ); |
|
|
|
if ( pTFPlayer && pTFPlayer->GetTeamNumber() != GetWinningTeam() && GetWinningTeam() != TEAM_UNASSIGNED ) |
|
continue; |
|
|
|
winEvent->SetInt( UTIL_VarArgs( "player_%d", iPlayersAdded + 1 ), vecPlayerScore[i].iPlayerIndex ); |
|
winEvent->SetInt( UTIL_VarArgs( "player_%d_damage", iPlayersAdded + 1 ), vecPlayerScore[i].iTotalDamage ); |
|
winEvent->SetInt( UTIL_VarArgs( "player_%d_healing", iPlayersAdded + 1 ), vecPlayerScore[i].iTotalHealing ); |
|
winEvent->SetInt( UTIL_VarArgs( "player_%d_lifetime", iPlayersAdded + 1 ), vecPlayerScore[i].iTimeAlive ); |
|
winEvent->SetInt( UTIL_VarArgs( "player_%d_kills", iPlayersAdded + 1 ), vecPlayerScore[i].iKillingBlows ); |
|
|
|
iPlayersAdded++; |
|
} |
|
|
|
if ( GetWinningTeam() != TEAM_UNASSIGNED ) |
|
{ |
|
//Now add the rest |
|
iPlayersAdded = 3; |
|
|
|
for ( int i = 0; i < vecPlayerScore.Count(); i++ ) |
|
{ |
|
if ( iPlayersAdded >= numPlayers ) |
|
break; |
|
|
|
int iIndex = iPlayersAdded + 1; |
|
|
|
int iPlayerIndex = vecPlayerScore[i].iPlayerIndex; |
|
|
|
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) ); |
|
|
|
if ( pTFPlayer && pTFPlayer->GetTeamNumber() == GetWinningTeam() ) |
|
continue; |
|
|
|
winEvent->SetInt( UTIL_VarArgs( "player_%d", iIndex ), vecPlayerScore[i].iPlayerIndex ); |
|
winEvent->SetInt( UTIL_VarArgs( "player_%d_damage", iIndex ), vecPlayerScore[i].iTotalDamage ); |
|
winEvent->SetInt( UTIL_VarArgs( "player_%d_healing", iIndex ), vecPlayerScore[i].iTotalHealing ); |
|
winEvent->SetInt( UTIL_VarArgs( "player_%d_lifetime", iIndex ), vecPlayerScore[i].iTimeAlive ); |
|
winEvent->SetInt( UTIL_VarArgs( "player_%d_kills", iIndex ), vecPlayerScore[i].iKillingBlows ); |
|
|
|
iPlayersAdded++; |
|
} |
|
} |
|
|
|
// Send the event |
|
gameeventmanager->FireEvent( winEvent ); |
|
} |
|
} |
|
|
|
void CTFGameRules::SendPVEWinPanelInfo( void ) |
|
{ |
|
IGameEvent *winEvent = gameeventmanager->CreateEvent( "pve_win_panel" ); |
|
|
|
if ( winEvent ) |
|
{ |
|
winEvent->SetInt( "panel_style", WINPANEL_BASIC ); |
|
winEvent->SetInt( "winning_team", m_iWinningTeam ); |
|
winEvent->SetInt( "winreason", 0 ); |
|
|
|
// Send the event |
|
gameeventmanager->FireEvent( winEvent ); |
|
} |
|
|
|
/*CBroadcastRecipientFilter filter; |
|
filter.MakeReliable(); |
|
UserMessageBegin( filter, "MVMAnnouncement" ); |
|
WRITE_CHAR( TF_MVM_ANNOUNCEMENT_WAVE_FAILED ); |
|
WRITE_CHAR( -1 ); |
|
MessageEnd();*/ |
|
} |
|
|
|
void CTFGameRules::SendWinPanelInfo( bool bGameOver ) |
|
{ |
|
if ( IsInArenaMode() == true ) |
|
{ |
|
SendArenaWinPanelInfo(); |
|
return; |
|
} |
|
|
|
if ( IsPVEModeActive() ) |
|
{ |
|
SendPVEWinPanelInfo(); |
|
return; |
|
} |
|
|
|
IGameEvent *winEvent = gameeventmanager->CreateEvent( "teamplay_win_panel" ); |
|
|
|
if ( winEvent ) |
|
{ |
|
int iBlueScore = GetGlobalTeam( TF_TEAM_BLUE )->GetScore(); |
|
int iRedScore = GetGlobalTeam( TF_TEAM_RED )->GetScore(); |
|
int iBlueScorePrev = iBlueScore; |
|
int iRedScorePrev = iRedScore; |
|
|
|
bool bRoundComplete = m_bForceMapReset || ( IsGameUnderTimeLimit() && ( GetTimeLeft() <= 0 ) ); |
|
|
|
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL; |
|
bool bScoringPerCapture = ( pMaster ) ? ( pMaster->ShouldScorePerCapture() ) : false; |
|
|
|
if ( m_nGameType == TF_GAMETYPE_CTF ) |
|
{ |
|
if ( tf_flag_caps_per_round.GetInt() == 0 ) |
|
{ |
|
bScoringPerCapture = true; |
|
} |
|
} |
|
|
|
if ( bRoundComplete && !bScoringPerCapture && m_bUseAddScoreAnim ) |
|
{ |
|
// if this is a complete round, calc team scores prior to this win |
|
switch ( m_iWinningTeam ) |
|
{ |
|
case TF_TEAM_BLUE: |
|
iBlueScorePrev = ( iBlueScore - TEAMPLAY_ROUND_WIN_SCORE >= 0 ) ? ( iBlueScore - TEAMPLAY_ROUND_WIN_SCORE ) : 0; |
|
break; |
|
case TF_TEAM_RED: |
|
iRedScorePrev = ( iRedScore - TEAMPLAY_ROUND_WIN_SCORE >= 0 ) ? ( iRedScore - TEAMPLAY_ROUND_WIN_SCORE ) : 0; |
|
break; |
|
case TEAM_UNASSIGNED: |
|
break; // stalemate; nothing to do |
|
} |
|
} |
|
|
|
winEvent->SetInt( "panel_style", WINPANEL_BASIC ); |
|
winEvent->SetInt( "winning_team", m_iWinningTeam ); |
|
winEvent->SetInt( "winreason", m_iWinReason ); |
|
winEvent->SetString( "cappers", ( m_iWinReason == WINREASON_ALL_POINTS_CAPTURED || m_iWinReason == WINREASON_FLAG_CAPTURE_LIMIT ) ? |
|
m_szMostRecentCappers : "" ); |
|
winEvent->SetInt( "flagcaplimit", IsPasstimeMode() ? tf_passtime_scores_per_round.GetInt() : tf_flag_caps_per_round.GetInt() ); |
|
winEvent->SetInt( "blue_score", iBlueScore ); |
|
winEvent->SetInt( "red_score", iRedScore ); |
|
winEvent->SetInt( "blue_score_prev", iBlueScorePrev ); |
|
winEvent->SetInt( "red_score_prev", iRedScorePrev ); |
|
winEvent->SetInt( "round_complete", bRoundComplete ); |
|
|
|
CTFPlayerResource *pResource = dynamic_cast< CTFPlayerResource * >( g_pPlayerResource ); |
|
if ( !pResource ) |
|
return; |
|
|
|
// Highest killstreak |
|
int nMaxStreakPlayerIndex = 0; |
|
int nMaxStreakCount = 0; |
|
|
|
// determine the 3 players on winning team who scored the most points this round |
|
|
|
// build a vector of players & round scores |
|
CUtlVector<PlayerRoundScore_t> vecPlayerScore; |
|
int iPlayerIndex; |
|
for( iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ ) |
|
{ |
|
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) ); |
|
if ( !pTFPlayer || !pTFPlayer->IsConnected() ) |
|
continue; |
|
// filter out spectators and, if not stalemate, all players not on winning team |
|
int iPlayerTeam = pTFPlayer->GetTeamNumber(); |
|
if ( ( iPlayerTeam < FIRST_GAME_TEAM ) || ( m_iWinningTeam != TEAM_UNASSIGNED && ( m_iWinningTeam != iPlayerTeam ) ) ) |
|
continue; |
|
|
|
int iRoundScore = 0, iTotalScore = 0; |
|
PlayerStats_t *pStats = CTF_GameStats.FindPlayerStats( pTFPlayer ); |
|
if ( pStats ) |
|
{ |
|
iRoundScore = CalcPlayerScore( &pStats->statsCurrentRound, pTFPlayer ); |
|
iTotalScore = CalcPlayerScore( &pStats->statsAccumulated, pTFPlayer ); |
|
} |
|
|
|
PlayerRoundScore_t &playerRoundScore = vecPlayerScore[vecPlayerScore.AddToTail()]; |
|
|
|
playerRoundScore.iRoundScore = iRoundScore; |
|
playerRoundScore.iPlayerIndex = iPlayerIndex; |
|
playerRoundScore.iTotalScore = iTotalScore; |
|
|
|
// Highest killstreak? |
|
PlayerStats_t *pPlayerStats = CTF_GameStats.FindPlayerStats( pTFPlayer ); |
|
if ( pPlayerStats ) |
|
{ |
|
int nMax = pPlayerStats->statsCurrentRound.m_iStat[TFSTAT_KILLSTREAK_MAX]; |
|
if ( nMax > nMaxStreakCount ) |
|
{ |
|
nMaxStreakCount = nMax; |
|
nMaxStreakPlayerIndex = iPlayerIndex; |
|
} |
|
} |
|
} |
|
|
|
// sort the players by round score |
|
vecPlayerScore.Sort( PlayerRoundScoreSortFunc ); |
|
|
|
// set the top (up to) 6 players by round score in the event data |
|
int numPlayers = MIN( 6, vecPlayerScore.Count() ); |
|
for ( int i = 0; i < numPlayers; i++ ) |
|
{ |
|
// only include players who have non-zero points this round; if we get to a player with 0 round points, stop |
|
if ( 0 == vecPlayerScore[i].iRoundScore ) |
|
break; |
|
|
|
// set the player index and their round score in the event |
|
char szPlayerIndexVal[64]="", szPlayerScoreVal[64]=""; |
|
Q_snprintf( szPlayerIndexVal, ARRAYSIZE( szPlayerIndexVal ), "player_%d", i+ 1 ); |
|
Q_snprintf( szPlayerScoreVal, ARRAYSIZE( szPlayerScoreVal ), "player_%d_points", i+ 1 ); |
|
winEvent->SetInt( szPlayerIndexVal, vecPlayerScore[i].iPlayerIndex ); |
|
winEvent->SetInt( szPlayerScoreVal, vecPlayerScore[i].iRoundScore ); |
|
} |
|
|
|
winEvent->SetInt( "killstreak_player_1", nMaxStreakPlayerIndex ); |
|
winEvent->SetInt( "killstreak_player_1_count", nMaxStreakCount ); |
|
|
|
#ifdef TF_RAID_MODE |
|
if ( !bRoundComplete && ( TEAM_UNASSIGNED != m_iWinningTeam ) && !IsRaidMode() ) |
|
#else |
|
if ( !bRoundComplete && ( TEAM_UNASSIGNED != m_iWinningTeam ) ) |
|
#endif // TF_RAID_MODE |
|
{ |
|
// is this our new payload race game mode? |
|
if ( ( m_nGameType == TF_GAMETYPE_ESCORT ) && ( m_bMultipleTrains == true ) ) |
|
{ |
|
if ( g_hControlPointMasters.Count() && g_hControlPointMasters[0] && g_hControlPointMasters[0]->PlayingMiniRounds() ) |
|
{ |
|
int nRoundsRemaining = g_hControlPointMasters[0]->NumPlayableControlPointRounds(); |
|
if ( nRoundsRemaining > 0 ) |
|
{ |
|
winEvent->SetInt( "rounds_remaining", nRoundsRemaining ); |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
// if this was not a full round ending, include how many mini-rounds remain for winning team to win |
|
if ( g_hControlPointMasters.Count() && g_hControlPointMasters[0] ) |
|
{ |
|
winEvent->SetInt( "rounds_remaining", g_hControlPointMasters[0]->CalcNumRoundsRemaining( m_iWinningTeam ) ); |
|
} |
|
} |
|
} |
|
|
|
winEvent->SetBool( "game_over", bGameOver ); |
|
|
|
// Send the event |
|
gameeventmanager->FireEvent( winEvent ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Sorts players by round score |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::PlayerRoundScoreSortFunc( const PlayerRoundScore_t *pRoundScore1, const PlayerRoundScore_t *pRoundScore2 ) |
|
{ |
|
// sort first by round score |
|
if ( pRoundScore1->iRoundScore != pRoundScore2->iRoundScore ) |
|
return pRoundScore2->iRoundScore - pRoundScore1->iRoundScore; |
|
|
|
// if round scores are the same, sort next by total score |
|
if ( pRoundScore1->iTotalScore != pRoundScore2->iTotalScore ) |
|
return pRoundScore2->iTotalScore - pRoundScore1->iTotalScore; |
|
|
|
// if scores are the same, sort next by player index so we get deterministic sorting |
|
return ( pRoundScore2->iPlayerIndex - pRoundScore1->iPlayerIndex ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Sorts players by arena stats |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::PlayerArenaRoundScoreSortFunc( const PlayerArenaRoundScore_t *pRoundScore1, const PlayerArenaRoundScore_t *pRoundScore2 ) |
|
{ |
|
//Compare Total points first |
|
//This gives us a rough estimate of performance |
|
if ( pRoundScore1->iScore != pRoundScore2->iScore ) |
|
return pRoundScore2->iScore - pRoundScore1->iScore; |
|
|
|
//Compare healing |
|
if ( pRoundScore1->iTotalHealing != pRoundScore2->iTotalHealing ) |
|
return pRoundScore2->iTotalHealing - pRoundScore1->iTotalHealing; |
|
|
|
//Compare damage |
|
if ( pRoundScore1->iTotalDamage != pRoundScore2->iTotalDamage ) |
|
return pRoundScore2->iTotalDamage - pRoundScore1->iTotalDamage; |
|
|
|
//Compare time alive |
|
if ( pRoundScore1->iTimeAlive != pRoundScore2->iTimeAlive ) |
|
return pRoundScore2->iTimeAlive - pRoundScore1->iTimeAlive; |
|
|
|
//Compare killing blows |
|
if ( pRoundScore1->iKillingBlows != pRoundScore2->iKillingBlows ) |
|
return pRoundScore2->iKillingBlows - pRoundScore1->iKillingBlows; |
|
|
|
// if scores are the same, sort next by player index so we get deterministic sorting |
|
return ( pRoundScore2->iPlayerIndex - pRoundScore1->iPlayerIndex ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Called when the teamplay_round_win event is about to be sent, gives |
|
// this method a chance to add more data to it |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::FillOutTeamplayRoundWinEvent( IGameEvent *event ) |
|
{ |
|
event->SetInt( "flagcaplimit", IsPasstimeMode() ? tf_passtime_scores_per_round.GetInt() : tf_flag_caps_per_round.GetInt() ); |
|
|
|
// determine the losing team |
|
int iLosingTeam; |
|
|
|
switch( event->GetInt( "team" ) ) |
|
{ |
|
case TF_TEAM_RED: |
|
iLosingTeam = TF_TEAM_BLUE; |
|
break; |
|
case TF_TEAM_BLUE: |
|
iLosingTeam = TF_TEAM_RED; |
|
break; |
|
case TEAM_UNASSIGNED: |
|
default: |
|
iLosingTeam = TEAM_UNASSIGNED; |
|
break; |
|
} |
|
|
|
// set the number of caps that team got any time during the round |
|
event->SetInt( "losing_team_num_caps", m_iNumCaps[iLosingTeam] ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetupSpawnPointsForRound( void ) |
|
{ |
|
if ( !g_hControlPointMasters.Count() || !g_hControlPointMasters[0] || !g_hControlPointMasters[0]->PlayingMiniRounds() ) |
|
return; |
|
|
|
CTeamControlPointRound *pCurrentRound = g_hControlPointMasters[0]->GetCurrentRound(); |
|
if ( !pCurrentRound ) |
|
{ |
|
return; |
|
} |
|
|
|
// loop through the spawn points in the map and find which ones are associated with this round or the control points in this round |
|
for ( int i=0; i<ITFTeamSpawnAutoList::AutoList().Count(); ++i ) |
|
{ |
|
CTFTeamSpawn *pTFSpawn = static_cast< CTFTeamSpawn* >( ITFTeamSpawnAutoList::AutoList()[i] ); |
|
|
|
CHandle<CTeamControlPoint> hControlPoint = pTFSpawn->GetControlPoint(); |
|
CHandle<CTeamControlPointRound> hRoundBlue = pTFSpawn->GetRoundBlueSpawn(); |
|
CHandle<CTeamControlPointRound> hRoundRed = pTFSpawn->GetRoundRedSpawn(); |
|
|
|
if ( hControlPoint && pCurrentRound->IsControlPointInRound( hControlPoint ) ) |
|
{ |
|
// this spawn is associated with one of our control points |
|
pTFSpawn->SetDisabled( false ); |
|
pTFSpawn->ChangeTeam( hControlPoint->GetOwner() ); |
|
} |
|
else if ( hRoundBlue && ( hRoundBlue == pCurrentRound ) ) |
|
{ |
|
pTFSpawn->SetDisabled( false ); |
|
pTFSpawn->ChangeTeam( TF_TEAM_BLUE ); |
|
} |
|
else if ( hRoundRed && ( hRoundRed == pCurrentRound ) ) |
|
{ |
|
pTFSpawn->SetDisabled( false ); |
|
pTFSpawn->ChangeTeam( TF_TEAM_RED ); |
|
} |
|
else |
|
{ |
|
// this spawn isn't associated with this round or the control points in this round |
|
pTFSpawn->SetDisabled( true ); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::SetCurrentRoundStateBitString( void ) |
|
{ |
|
m_iPrevRoundState = m_iCurrentRoundState; |
|
|
|
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL; |
|
|
|
if ( !pMaster ) |
|
{ |
|
return 0; |
|
} |
|
|
|
int iState = 0; |
|
|
|
for ( int i=0; i<pMaster->GetNumPoints(); i++ ) |
|
{ |
|
CTeamControlPoint *pPoint = pMaster->GetControlPoint( i ); |
|
|
|
if ( pPoint->GetOwner() == TF_TEAM_BLUE ) |
|
{ |
|
// Set index to 1 for the point being owned by blue |
|
iState |= ( 1<<i ); |
|
} |
|
} |
|
|
|
m_iCurrentRoundState = iState; |
|
|
|
return iState; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetMiniRoundBitMask( int iMask ) |
|
{ |
|
m_iCurrentMiniRoundMask = iMask; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::IsFirstBloodAllowed( void ) |
|
{ |
|
// Already granted |
|
if ( m_bArenaFirstBlood ) |
|
return false; |
|
|
|
if ( IsInArenaMode() && tf_arena_first_blood.GetBool() ) |
|
return true; |
|
|
|
if ( IsCompetitiveMode() && ( State_Get() == GR_STATE_RND_RUNNING ) ) |
|
{ |
|
if ( IsMatchTypeCompetitive() ) |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: NULL pPlayer means show the panel to everyone |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::ShowRoundInfoPanel( CTFPlayer *pPlayer /* = NULL */ ) |
|
{ |
|
KeyValues *data = new KeyValues( "data" ); |
|
|
|
if ( m_iCurrentRoundState < 0 ) |
|
{ |
|
// Haven't set up the round state yet |
|
return; |
|
} |
|
|
|
// if prev and cur are equal, we are starting from a fresh round |
|
if ( m_iPrevRoundState >= 0 && pPlayer == NULL ) // we have data about a previous state |
|
{ |
|
data->SetInt( "prev", m_iPrevRoundState ); |
|
} |
|
else |
|
{ |
|
// don't send a delta if this is just to one player, they are joining mid-round |
|
data->SetInt( "prev", m_iCurrentRoundState ); |
|
} |
|
|
|
data->SetInt( "cur", m_iCurrentRoundState ); |
|
|
|
// get bitmask representing the current miniround |
|
data->SetInt( "round", m_iCurrentMiniRoundMask ); |
|
|
|
if ( pPlayer ) |
|
{ |
|
pPlayer->ShowViewPortPanel( PANEL_ROUNDINFO, true, data ); |
|
} |
|
else |
|
{ |
|
for ( int i = 1; i <= MAX_PLAYERS; i++ ) |
|
{ |
|
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
|
|
if ( pTFPlayer && pTFPlayer->IsReadyToPlay() ) |
|
{ |
|
pTFPlayer->ShowViewPortPanel( PANEL_ROUNDINFO, true, data ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::TimerMayExpire( void ) |
|
{ |
|
// Prevent timers expiring while control points are contested |
|
int iNumControlPoints = ObjectiveResource()->GetNumControlPoints(); |
|
for ( int iPoint = 0; iPoint < iNumControlPoints; iPoint ++ ) |
|
{ |
|
if ( ObjectiveResource()->GetCappingTeam(iPoint) ) |
|
{ |
|
m_flCapInProgressBuffer = gpGlobals->curtime + 0.1f; |
|
return false; |
|
} |
|
} |
|
|
|
// This delay prevents an order-of-operations issue with caps that |
|
// fire an AddTime output, and round timers' OnFinished output |
|
if ( m_flCapInProgressBuffer >= gpGlobals->curtime ) |
|
return false; |
|
|
|
if ( GetOvertimeAllowedForCTF() ) |
|
{ |
|
// Prevent timers expiring while flags are stolen/dropped |
|
for ( int i=0; i<ICaptureFlagAutoList::AutoList().Count(); ++i ) |
|
{ |
|
CCaptureFlag *pFlag = static_cast< CCaptureFlag* >( ICaptureFlagAutoList::AutoList()[i] ); |
|
if ( !pFlag->IsDisabled() && !pFlag->IsHome() ) |
|
return false; |
|
} |
|
} |
|
|
|
for ( int i = 0 ; i < m_CPTimerEnts.Count() ; i++ ) |
|
{ |
|
CCPTimerLogic *pTimer = m_CPTimerEnts[i]; |
|
if ( pTimer ) |
|
{ |
|
if ( pTimer->TimerMayExpire() == false ) |
|
return false; |
|
} |
|
} |
|
|
|
#ifdef TF_RAID_MODE |
|
if ( IsRaidMode() && IsBossBattleMode() && tf_raid_allow_overtime.GetBool() ) |
|
{ |
|
CUtlVector< CTFPlayer * > alivePlayerVector; |
|
CollectPlayers( &alivePlayerVector, TF_TEAM_BLUE, COLLECT_ONLY_LIVING_PLAYERS ); |
|
|
|
// if anyone is alive, go into overtime |
|
if ( alivePlayerVector.Count() > 0 ) |
|
{ |
|
return false; |
|
} |
|
} |
|
#endif |
|
|
|
return BaseClass::TimerMayExpire(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::BHavePlayers( void ) |
|
{ |
|
CMatchInfo *pInfo = GTFGCClientSystem()->GetMatch(); |
|
if ( pInfo ) |
|
{ |
|
// When we have a match, we start reporting we're active as soon as the first person loads, and never stop. |
|
return pInfo->m_bFirstPersonActive; |
|
} |
|
|
|
if ( IsInArenaMode() ) |
|
{ |
|
// At least two in queue, we're always able to play |
|
if ( m_hArenaPlayerQueue.Count() >= 2 ) |
|
return true; |
|
|
|
// Otherwise, return false if nobody is actually on a team, regardless of players ready-to-play state. |
|
if ( GetGlobalTFTeam( TF_TEAM_BLUE )->GetNumPlayers() == 0 || GetGlobalTFTeam( TF_TEAM_RED )->GetNumPlayers() == 0 ) |
|
return false; |
|
|
|
// Otherwise, fall through to base logic (e.g. 1v0 but already running) |
|
} |
|
|
|
return BaseClass::BHavePlayers(); |
|
} |
|
|
|
int SortPlayerSpectatorQueue( CTFPlayer* const *p1, CTFPlayer* const *p2 ) |
|
{ |
|
float flTime1 = (*p1)->GetTeamJoinTime(); |
|
float flTime2 = (*p2)->GetTeamJoinTime(); |
|
|
|
if ( flTime1 == flTime2 ) |
|
{ |
|
flTime1 = (*p1)->GetConnectionTime(); |
|
flTime2 = (*p2)->GetConnectionTime(); |
|
|
|
if ( flTime1 < flTime2 ) |
|
return -1; |
|
} |
|
else |
|
{ |
|
if ( flTime1 > flTime2 ) |
|
return -1; |
|
} |
|
|
|
if ( flTime1 == flTime2 ) |
|
return 0; |
|
|
|
return 1; |
|
} |
|
|
|
int SortPlayersScoreBased( CTFPlayer* const *p1, CTFPlayer* const *p2 ) |
|
{ |
|
CTFPlayerResource *pResource = dynamic_cast<CTFPlayerResource *>( g_pPlayerResource ); |
|
|
|
if ( pResource ) |
|
{ |
|
int nScore2 = pResource->GetTotalScore( ( *p2 )->entindex() ); |
|
int nScore1 = pResource->GetTotalScore( ( *p1 )->entindex() ); |
|
|
|
// check the priority |
|
if ( nScore2 > nScore1 ) |
|
{ |
|
return 1; |
|
} |
|
} |
|
|
|
return -1; |
|
} |
|
|
|
// sort function for the list of players that we're going to use to scramble the teams |
|
int ScramblePlayersSort( CTFPlayer* const *p1, CTFPlayer* const *p2 ) |
|
{ |
|
CTFPlayerResource *pResource = dynamic_cast< CTFPlayerResource * >( g_pPlayerResource ); |
|
|
|
if ( pResource ) |
|
{ |
|
int nScore2 = pResource->GetTotalScore( (*p2)->entindex() ); |
|
int nScore1 = pResource->GetTotalScore( (*p1)->entindex() ); |
|
|
|
// check the priority |
|
if ( nScore2 > nScore1 ) |
|
{ |
|
return 1; |
|
} |
|
} |
|
|
|
return -1; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::Arena_ClientDisconnect( const char *playername ) |
|
{ |
|
if ( IsInArenaMode() == false ) |
|
return; |
|
|
|
if ( IsInWaitingForPlayers() == true ) |
|
return; |
|
|
|
if ( m_iRoundState != GR_STATE_PREROUND ) |
|
return; |
|
|
|
if ( IsInTournamentMode() == true ) |
|
return; |
|
|
|
int iLight, iHeavy; |
|
|
|
if ( AreTeamsUnbalanced( iHeavy, iLight ) == true ) |
|
{ |
|
CTeam *pTeamHeavy = GetGlobalTeam( iHeavy ); |
|
CTeam *pTeamLight = GetGlobalTeam( iLight ); |
|
|
|
if ( pTeamHeavy == NULL || pTeamLight == NULL ) |
|
return; |
|
|
|
int iPlayersNeeded = pTeamHeavy->GetNumPlayers() - pTeamLight->GetNumPlayers(); |
|
|
|
if ( m_hArenaPlayerQueue.Count() == 0 ) |
|
return; |
|
|
|
for ( int iPlayers = 0; iPlayers < iPlayersNeeded; iPlayers++ ) |
|
{ |
|
CTFPlayer *pPlayer = m_hArenaPlayerQueue[iPlayers]; |
|
|
|
if ( pPlayer && pPlayer->IsHLTV() == false && pPlayer->IsReplay() == false ) |
|
{ |
|
pPlayer->ForceChangeTeam( TF_TEAM_AUTOASSIGN ); |
|
|
|
UTIL_ClientPrintAll( HUD_PRINTTALK, "#TF_Arena_ClientDisconnect", pPlayer->GetPlayerName(), GetGlobalTeam( pPlayer->GetTeamNumber() )->GetName(), playername ); |
|
|
|
if ( pPlayer->DidPlayerJustPlay() == false ) |
|
{ |
|
pPlayer->MarkTeamJoinTime(); |
|
} |
|
|
|
m_hArenaPlayerQueue.FindAndRemove( pPlayer ); |
|
pPlayer->PlayerJustPlayed( false ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::Arena_ResetLosersScore( bool bResetAll ) |
|
{ |
|
//Winner gets to keep their score |
|
for ( int i = 0; i < GetNumberOfTeams(); i++ ) |
|
{ |
|
if ( ( i != GetWinningTeam() && GetWinningTeam() > LAST_SHARED_TEAM ) || bResetAll == true ) |
|
{ |
|
GetGlobalTeam( i )->ResetScores(); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::Arena_PrepareNewPlayerQueue( bool bResetAll ) |
|
{ |
|
CUtlVector<CTFPlayer*> pTempPlayerQueue; |
|
|
|
for ( int i = 1; i <= MAX_PLAYERS; i++ ) |
|
{ |
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
|
|
if ( pPlayer && pPlayer->IsHLTV() == false && pPlayer->IsReplay() == false ) |
|
{ |
|
if ( ( GetWinningTeam() > LAST_SHARED_TEAM && pPlayer->GetTeamNumber() != GetWinningTeam() && pPlayer->IsReadyToPlay() ) || bResetAll == true ) |
|
{ |
|
pTempPlayerQueue.AddToTail( pPlayer ); |
|
} |
|
} |
|
} |
|
|
|
//Sort the players going into spectator |
|
//Players that have been longer on the server should go in front of newer players |
|
//We have to do this since player slots are reused for new clients, so looping through players |
|
//using their entindex doesn't work. |
|
|
|
if ( bResetAll == true ) |
|
{ |
|
pTempPlayerQueue.Sort( ScramblePlayersSort ); |
|
} |
|
else |
|
{ |
|
pTempPlayerQueue.Sort( SortPlayerSpectatorQueue ); |
|
} |
|
|
|
for ( int i = 0; i < pTempPlayerQueue.Count(); i++ ) |
|
{ |
|
CTFPlayer *pPlayer = pTempPlayerQueue[i]; |
|
|
|
if ( pPlayer && pPlayer->IsReadyToPlay() ) |
|
{ |
|
//Changing into Spectator Team puts the player at the end of the queue |
|
//Use ForceChangeTeam if you want to move them to the FRONT of the queue |
|
pPlayer->ChangeTeam( TEAM_SPECTATOR ); |
|
pPlayer->PlayerJustPlayed( true ); |
|
} |
|
} |
|
} |
|
|
|
#define TF_ARENA_TEAM_COUNT 3 |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::Arena_PlayersNeededForMatch( void ) |
|
{ |
|
int iMaxPlayers = gpGlobals->maxClients; |
|
|
|
if ( HLTVDirector()->IsActive() ) |
|
{ |
|
iMaxPlayers -= 1; |
|
} |
|
|
|
int iTeamSize; |
|
if ( tf_arena_override_team_size.GetInt() > 0 ) |
|
iTeamSize = tf_arena_override_team_size.GetInt(); |
|
else |
|
iTeamSize = floor( ( (float)iMaxPlayers / TF_ARENA_TEAM_COUNT ) + 0.5f ); |
|
|
|
int iPlayersNeeded = iTeamSize * 2; |
|
int iDesiredTeamSize = iTeamSize; |
|
int iPlayersInWinningTeam = 0; |
|
bool bRebalanceWinners = false; |
|
|
|
int iPlayerNumber = 0; |
|
|
|
for ( int i = 1; i <= MAX_PLAYERS; i++ ) |
|
{ |
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
|
|
if ( pPlayer && pPlayer->IsReadyToPlay() ) |
|
{ |
|
iPlayerNumber++; |
|
} |
|
} |
|
|
|
int iBalancedTeamSize = floor( ((m_hArenaPlayerQueue.Count() + iPlayerNumber ) * 0.5f ) ); |
|
|
|
iPlayersNeeded = (iBalancedTeamSize - iPlayerNumber) + iBalancedTeamSize; |
|
|
|
if ( (iPlayersNeeded + iPlayerNumber) > iDesiredTeamSize*2 ) |
|
{ |
|
iPlayersNeeded = (iDesiredTeamSize*2) - iPlayerNumber; |
|
|
|
if ( iPlayersNeeded < 0 ) |
|
{ |
|
iPlayersNeeded = 0; |
|
} |
|
} |
|
|
|
// If the last round was won by a team, then let's figure out how many players we need. |
|
// Also, if the winning team has more players than are available, then let's have one of them switch teams. |
|
if ( GetWinningTeam() > LAST_SHARED_TEAM ) |
|
{ |
|
iPlayersInWinningTeam = GetGlobalTFTeam( GetWinningTeam() )->GetNumPlayers(); |
|
|
|
if ( iPlayersInWinningTeam > iTeamSize ) |
|
{ |
|
bRebalanceWinners = true; |
|
iDesiredTeamSize = iTeamSize; |
|
} |
|
else if ( iPlayersInWinningTeam > iBalancedTeamSize ) |
|
{ |
|
bRebalanceWinners = true; |
|
iDesiredTeamSize = iBalancedTeamSize; |
|
} |
|
} |
|
|
|
// Msg( "iPlayerNumber: %d - InQueue: %d - iPlayersInWinningTeam: %d - iDesiredTeamSize: %d - iBalancedTeamSize: %d - iPlayersNeeded: %d - bRebalanceWinners %d\n", iPlayerNumber, m_hArenaPlayerQueue.Count(), iPlayersInWinningTeam, iDesiredTeamSize, iBalancedTeamSize, iPlayersNeeded, bRebalanceWinners ); |
|
|
|
|
|
if ( bRebalanceWinners == true ) |
|
{ |
|
while ( iPlayersInWinningTeam > iDesiredTeamSize ) |
|
{ |
|
CTFPlayer *pBalancedWinner = NULL; |
|
float flShortestTeamJoinTime = 9999.9f; |
|
|
|
for ( int i = 1; i <= MAX_PLAYERS; i++ ) |
|
{ |
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
|
|
if ( pPlayer && pPlayer->GetTeamNumber() == GetWinningTeam() && pPlayer->IsHLTV() == false && pPlayer->IsReplay() == false ) |
|
{ |
|
if ( bRebalanceWinners == true ) |
|
{ |
|
//Find the newest guy that joined this team and flag him. |
|
if ( (gpGlobals->curtime - pPlayer->GetTeamJoinTime()) < flShortestTeamJoinTime ) |
|
{ |
|
flShortestTeamJoinTime = (gpGlobals->curtime - pPlayer->GetTeamJoinTime()); |
|
pBalancedWinner = pPlayer; |
|
} |
|
} |
|
} |
|
} |
|
|
|
if ( pBalancedWinner ) |
|
{ |
|
pBalancedWinner->ForceChangeTeam( TEAM_SPECTATOR ); |
|
pBalancedWinner->MarkTeamJoinTime(); |
|
|
|
if ( iPlayersNeeded < iDesiredTeamSize ) |
|
{ |
|
iPlayersNeeded++; |
|
} |
|
|
|
IGameEvent *event = gameeventmanager->CreateEvent( "teamplay_teambalanced_player" ); |
|
if ( event ) |
|
{ |
|
event->SetInt( "player", pBalancedWinner->entindex() ); |
|
event->SetInt( "team", GetWinningTeam() == TF_TEAM_BLUE ? TF_TEAM_RED : TF_TEAM_BLUE ); |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
|
|
// tell people that we've switched this player |
|
UTIL_ClientPrintAll( HUD_PRINTTALK, "#game_player_was_team_balanced", pBalancedWinner->GetPlayerName() ); |
|
} |
|
|
|
iPlayersInWinningTeam = GetGlobalTFTeam( GetWinningTeam() )->GetNumPlayers(); |
|
} |
|
} |
|
|
|
return iPlayersNeeded; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::Arena_CleanupPlayerQueue( void ) |
|
{ |
|
//One more loop to remove players that are currently playing from the queue |
|
//And to mark everyone as not having just played. |
|
for ( int i = 1; i <= MAX_PLAYERS; i++ ) |
|
{ |
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
|
|
if ( pPlayer && pPlayer->IsHLTV() == false && pPlayer->IsReplay() == false ) |
|
{ |
|
if ( pPlayer->GetTeamNumber() != TEAM_SPECTATOR ) |
|
{ |
|
m_hArenaPlayerQueue.FindAndRemove( pPlayer ); |
|
} |
|
|
|
pPlayer->PlayerJustPlayed( false ); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::Arena_RunTeamLogic( void ) |
|
{ |
|
if ( IsInArenaMode() == false ) |
|
return; |
|
|
|
if ( IsInWaitingForPlayers() == true ) |
|
return; |
|
|
|
bool bGameNotReady = !BHavePlayers(); |
|
bool bStreaksReached = false; |
|
|
|
if ( tf_arena_use_queue.GetBool() == false ) |
|
{ |
|
if ( bGameNotReady == true || GetGlobalTFTeam( TF_TEAM_BLUE )->GetNumPlayers() == 0 || GetGlobalTFTeam( TF_TEAM_RED )->GetNumPlayers() == 0 ) |
|
{ |
|
State_Transition( GR_STATE_PREGAME ); |
|
} |
|
|
|
return; |
|
} |
|
|
|
if ( tf_arena_max_streak.GetInt() > 0 ) |
|
{ |
|
if ( GetWinningTeam() != TEAM_UNASSIGNED ) |
|
{ |
|
if ( GetGlobalTFTeam( GetWinningTeam() )->GetScore() >= tf_arena_max_streak.GetInt() ) |
|
{ |
|
bStreaksReached = true; |
|
|
|
IGameEvent *event = gameeventmanager->CreateEvent( "arena_match_maxstreak" ); |
|
if ( event ) |
|
{ |
|
event->SetInt( "team", GetWinningTeam() ); |
|
event->SetInt( "streak", tf_arena_max_streak.GetInt() ); |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
|
|
BroadcastSound( 255, "Announcer.AM_TeamScrambleRandom" ); |
|
|
|
m_iWinningTeam = TEAM_UNASSIGNED; |
|
} |
|
} |
|
} |
|
|
|
if ( IsInTournamentMode() == false ) |
|
{ |
|
Arena_ResetLosersScore( bGameNotReady || bStreaksReached ); |
|
} |
|
|
|
Arena_PrepareNewPlayerQueue( bGameNotReady || bStreaksReached ); |
|
|
|
if ( bGameNotReady == true ) |
|
{ |
|
State_Transition( GR_STATE_PREGAME ); |
|
return; |
|
} |
|
|
|
int iPlayersNeeded = Arena_PlayersNeededForMatch(); |
|
|
|
//Let's add people to teams |
|
//But only do this if there's people in the actual game and teams are unbalanced |
|
//(which they should be since winners are in and everyone else is spectating) |
|
int iLight, iHeavy; |
|
|
|
if ( AreTeamsUnbalanced( iHeavy, iLight ) == true && iPlayersNeeded > 0 ) |
|
{ |
|
if ( iPlayersNeeded > m_hArenaPlayerQueue.Count() ) |
|
{ |
|
iPlayersNeeded = m_hArenaPlayerQueue.Count(); |
|
} |
|
|
|
// Msg( "iTeamSize: %d\n", iTeamSize ); |
|
|
|
int iTeam = GetWinningTeam(); |
|
|
|
int iSwitch = floor( ((GetGlobalTFTeam( GetWinningTeam() )->GetNumPlayers() + iPlayersNeeded) * 0.5f ) - GetGlobalTFTeam( GetWinningTeam() )->GetNumPlayers() ); |
|
|
|
if ( GetWinningTeam() == TEAM_UNASSIGNED ) |
|
{ |
|
iTeam = TF_TEAM_AUTOASSIGN; |
|
} |
|
|
|
//Move people in the queue into a team. |
|
for ( int iPlayers = 0; iPlayers < iPlayersNeeded; iPlayers++ ) |
|
{ |
|
CTFPlayer *pPlayer = m_hArenaPlayerQueue[iPlayers]; |
|
|
|
if ( iPlayers >= iSwitch ) |
|
{ |
|
iTeam = TF_TEAM_AUTOASSIGN; |
|
} |
|
|
|
if ( pPlayer ) |
|
{ |
|
pPlayer->ForceChangeTeam( iTeam ); |
|
|
|
// Msg( "Moving Player to game: %s - team: %d\n", pPlayer->GetPlayerName(), pPlayer->GetTeamNumber() ); |
|
|
|
if ( pPlayer->DidPlayerJustPlay() == false ) |
|
{ |
|
pPlayer->MarkTeamJoinTime(); |
|
} |
|
} |
|
} |
|
} |
|
|
|
|
|
|
|
// show the class composition panel |
|
|
|
m_flSendNotificationTime = gpGlobals->curtime + 1.0f; |
|
|
|
Arena_CleanupPlayerQueue(); |
|
Arena_NotifyTeamSizeChange(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::Arena_NotifyTeamSizeChange( void ) |
|
{ |
|
int iTeamSize = GetGlobalTFTeam( TF_TEAM_BLUE )->GetNumPlayers(); |
|
|
|
if ( iTeamSize == m_iPreviousTeamSize ) |
|
return; |
|
|
|
if ( m_iPreviousTeamSize == 0 ) |
|
{ |
|
m_iPreviousTeamSize = iTeamSize; |
|
return; |
|
} |
|
|
|
if ( m_iPreviousTeamSize > iTeamSize ) |
|
{ |
|
UTIL_ClientPrintAll( HUD_PRINTTALK, "#TF_Arena_TeamSizeDecreased", UTIL_VarArgs( "%d", iTeamSize ) ); |
|
} |
|
else |
|
{ |
|
UTIL_ClientPrintAll( HUD_PRINTTALK, "#TF_Arena_TeamSizeIncreased", UTIL_VarArgs( "%d", iTeamSize ) ); |
|
} |
|
|
|
m_iPreviousTeamSize = iTeamSize; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::Arena_SendPlayerNotifications( void ) |
|
{ |
|
int iTeamPlayers = GetGlobalTFTeam( TF_TEAM_RED )->GetNumPlayers() + GetGlobalTFTeam( TF_TEAM_BLUE )->GetNumPlayers(); |
|
int iNumPlayers = 0; |
|
|
|
m_flSendNotificationTime = 0.0f; |
|
|
|
for ( int i = 1; i <= MAX_PLAYERS; i++ ) |
|
{ |
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
|
|
if ( pPlayer && pPlayer->IsHLTV() == false && pPlayer->IsReplay() == false && pPlayer->GetDesiredPlayerClassIndex() > TF_CLASS_UNDEFINED ) |
|
{ |
|
iNumPlayers++; |
|
|
|
if ( pPlayer->GetTeamNumber() == TEAM_SPECTATOR && pPlayer->GetPreviousTeam() != TEAM_UNASSIGNED ) |
|
{ |
|
CSingleUserRecipientFilter filter( pPlayer ); |
|
|
|
UserMessageBegin( filter, "HudArenaNotify" ); |
|
WRITE_BYTE( pPlayer->entindex() ); |
|
WRITE_BYTE( TF_ARENA_NOTIFICATION_SITOUT ); |
|
MessageEnd(); |
|
} |
|
} |
|
} |
|
|
|
if ( iTeamPlayers == iNumPlayers ) |
|
return; |
|
|
|
int iExtras = iNumPlayers - iTeamPlayers; |
|
|
|
for ( int iTeam = TF_TEAM_RED; iTeam < TF_TEAM_COUNT; iTeam++ ) |
|
{ |
|
CUtlVector<CTFPlayer*> pTempPlayerQueue; |
|
|
|
CTFTeam *pTeam = GetGlobalTFTeam( iTeam ); |
|
|
|
if ( pTeam ) |
|
{ |
|
for ( int iPlayer = 0; iPlayer < pTeam->GetNumPlayers(); iPlayer++ ) |
|
{ |
|
CTFPlayer *pPlayer = ToTFPlayer( pTeam->GetPlayer( iPlayer ) ); |
|
|
|
if ( pPlayer && pPlayer->IsHLTV() == false && pPlayer->IsReplay() == false ) |
|
{ |
|
pTempPlayerQueue.AddToTail( pPlayer ); |
|
} |
|
} |
|
} |
|
|
|
pTempPlayerQueue.Sort( SortPlayerSpectatorQueue ); |
|
|
|
for ( int i = pTempPlayerQueue.Count(); --i >= 0; ) |
|
{ |
|
if ( pTempPlayerQueue.Count() - i > iExtras ) |
|
continue; |
|
|
|
CTFPlayer *pPlayer = pTempPlayerQueue[i]; |
|
|
|
CSingleUserRecipientFilter filter( pPlayer ); |
|
UserMessageBegin( filter, "HudArenaNotify" ); |
|
WRITE_BYTE( pPlayer->entindex() ); |
|
WRITE_BYTE( TF_ARENA_NOTIFICATION_CAREFUL ); |
|
MessageEnd(); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Handle maps that may be in our map cycle/etc changing name or availability |
|
//----------------------------------------------------------------------------- |
|
#ifdef GAME_DLL |
|
void CTFGameRules::OnWorkshopMapUpdated( PublishedFileId_t nUpdatedWorkshopID ) |
|
{ |
|
// Check if this map is in the mapcycle under a different name, reload mapcycle if so. We want the up-to-date names |
|
// in the map cycle as it is used for user-facing things such as votes. |
|
CTFMapsWorkshop *pWorkshop = TFMapsWorkshop(); |
|
if ( pWorkshop ) |
|
{ |
|
FOR_EACH_VEC( m_MapList, i ) |
|
{ |
|
// Check if this represents a workshop map |
|
PublishedFileId_t nWorkshopID = pWorkshop->MapIDFromName( m_MapList[ i ] ); |
|
if ( nWorkshopID == nUpdatedWorkshopID ) |
|
{ |
|
CUtlString newName; |
|
if ( pWorkshop->GetMapName( nWorkshopID, newName ) == CTFMapsWorkshop::eName_Canon && |
|
newName != m_MapList[ i ] ) |
|
{ |
|
// We can't just fixup the name here, as the primary mapcycle is also mirrored to a string |
|
// table. This queues a reload, which will check for workshop names at that point. |
|
m_bMapCycleNeedsUpdate = true; |
|
break; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
#endif |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Hook new map cycle file loads |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::LoadMapCycleFile( void ) |
|
{ |
|
BaseClass::LoadMapCycleFile(); |
|
#ifdef GAME_DLL |
|
// The underlying LoadMapCycleFileIntoVector fixes up workshop names, but for loading the primary map cycle file, we |
|
// also want to tell the workshop to track them. See also: TFGameRules::OnWorkshopMapChanged |
|
TrackWorkshopMapsInMapCycle(); |
|
#endif |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Hook new map cycle file loads |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::TrackWorkshopMapsInMapCycle( void ) |
|
{ |
|
CTFMapsWorkshop *pWorkshop = TFMapsWorkshop(); |
|
if ( pWorkshop ) |
|
{ |
|
unsigned int nAddedMaps = 0; |
|
unsigned int nWorkshopMaps = 0; |
|
FOR_EACH_VEC( m_MapList, i ) |
|
{ |
|
// Check if this represents a workshop map |
|
PublishedFileId_t nWorkshopID = pWorkshop->MapIDFromName( m_MapList[ i ] ); |
|
if ( nWorkshopID != k_PublishedFileIdInvalid ) |
|
{ |
|
nWorkshopMaps++; |
|
// Track it if we're not |
|
if ( pWorkshop->AddMap( nWorkshopID ) ) |
|
{ |
|
nAddedMaps++; |
|
} |
|
} |
|
} |
|
|
|
if ( nAddedMaps ) |
|
{ |
|
Msg( "Tracking %u new workshop maps from map cycle (%u already tracked)\n", nAddedMaps, nWorkshopMaps - nAddedMaps ); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Hook new map cycle file loads |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::LoadMapCycleFileIntoVector( const char *pszMapCycleFile, CUtlVector<char *> &mapList ) |
|
{ |
|
BaseClass::LoadMapCycleFileIntoVector( pszMapCycleFile, mapList ); |
|
|
|
#ifdef GAME_DLL |
|
// Fixup workshop map names if known. E.g. workshop/12345 -> workshop/cp_foo.ugc12345 |
|
CTFMapsWorkshop *pWorkshop = TFMapsWorkshop(); |
|
if ( pWorkshop ) |
|
{ |
|
FOR_EACH_VEC( mapList, i ) |
|
{ |
|
// Check if this represents a workshop map |
|
PublishedFileId_t nWorkshopID = pWorkshop->MapIDFromName( mapList[ i ] ); |
|
if ( nWorkshopID != k_PublishedFileIdInvalid ) |
|
{ |
|
// Workshop map, update name |
|
CUtlString newName; |
|
pWorkshop->GetMapName( nWorkshopID, newName ); |
|
if ( newName.Length() ) |
|
{ |
|
// Alloc replacement |
|
size_t nNewSize = newName.Length() + 1; |
|
char *pNew = new char[ nNewSize ]; |
|
V_strncpy( pNew, newName.Get(), nNewSize ); |
|
|
|
// Replace |
|
delete [] mapList[ i ]; |
|
mapList[ i ] = pNew; |
|
} |
|
} |
|
} |
|
} |
|
#endif |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Server-side vote creation |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::ManageServerSideVoteCreation( void ) |
|
{ |
|
if ( gpGlobals->curtime < m_flVoteCheckThrottle ) |
|
return; |
|
|
|
if ( IsInTournamentMode() ) |
|
return; |
|
|
|
if ( IsInArenaMode() ) |
|
return; |
|
|
|
if ( IsInWaitingForPlayers() ) |
|
return; |
|
|
|
if ( m_bInSetup ) |
|
return; |
|
|
|
if ( IsInTraining() ) |
|
return; |
|
|
|
if ( IsInItemTestingMode() ) |
|
return; |
|
|
|
if ( m_MapList.Count() < 2 ) |
|
return; |
|
|
|
// Ask players which map they would prefer to play next, based |
|
// on "n" lowest playtime from server stats |
|
|
|
ConVarRef sv_vote_issue_nextlevel_allowed( "sv_vote_issue_nextlevel_allowed" ); |
|
ConVarRef sv_vote_issue_nextlevel_choicesmode( "sv_vote_issue_nextlevel_choicesmode" ); |
|
|
|
if ( sv_vote_issue_nextlevel_allowed.GetBool() && sv_vote_issue_nextlevel_choicesmode.GetBool() ) |
|
{ |
|
// Don't do this if we already have a nextlevel set |
|
if ( nextlevel.GetString() && *nextlevel.GetString() ) |
|
return; |
|
|
|
if ( !m_bServerVoteOnReset && !m_bVoteCalled ) |
|
{ |
|
// If we have any round or win limit, ignore time |
|
if ( mp_winlimit.GetInt() || mp_maxrounds.GetInt() ) |
|
{ |
|
int nBlueScore = TFTeamMgr()->GetTeam( TF_TEAM_BLUE )->GetScore(); |
|
int nRedScore = TFTeamMgr()->GetTeam( TF_TEAM_RED)->GetScore(); |
|
int nWinLimit = mp_winlimit.GetInt(); |
|
if ( ( nWinLimit - nBlueScore ) == 1 || ( nWinLimit - nRedScore ) == 1 ) |
|
{ |
|
m_bServerVoteOnReset = true; |
|
} |
|
|
|
int nRoundsPlayed = GetRoundsPlayed(); |
|
if ( ( mp_maxrounds.GetInt() - nRoundsPlayed ) == 1 ) |
|
{ |
|
m_bServerVoteOnReset = true; |
|
} |
|
} |
|
else if ( mp_timelimit.GetInt() > 0 ) |
|
{ |
|
int nTimeLeft = GetTimeLeft(); |
|
if ( nTimeLeft <= 120 && !m_bServerVoteOnReset ) |
|
{ |
|
if ( g_voteController ) |
|
{ |
|
g_voteController->CreateVote( DEDICATED_SERVER, "nextlevel", "" ); |
|
} |
|
m_bVoteCalled = true; |
|
} |
|
} |
|
} |
|
} |
|
|
|
m_flVoteCheckThrottle = gpGlobals->curtime + 0.5f; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Figures out how much money to put in a custom currency pack drop |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::CalculateCurrencyAmount_CustomPack( int nAmount ) |
|
{ |
|
// Entities and events that specify a custom currency value should pass in the amount |
|
// they're worth, and we figure out if there's enough currency to generate a pack. |
|
// If the amount passed in isn't enough to generate a pack, we store it in an accumulator. |
|
|
|
int nMinDrop = kMVM_CurrencyPackMinSize; |
|
if ( nMinDrop > 1 ) |
|
{ |
|
// If we're on the last spawn, drop everything |
|
if ( TFObjectiveResource()->GetMannVsMachineWaveEnemyCount() == 1 ) |
|
{ |
|
nMinDrop = m_nCurrencyAccumulator + nAmount; |
|
m_nCurrencyAccumulator = 0; |
|
return nMinDrop; |
|
} |
|
|
|
// If we're passing in a value above mindrop, just drop it |
|
if ( nAmount >= nMinDrop ) |
|
return nAmount; |
|
|
|
// Accumulate currency if we're getting values below nMinDrop |
|
m_nCurrencyAccumulator += nAmount; |
|
if ( m_nCurrencyAccumulator >= nMinDrop ) |
|
{ |
|
m_nCurrencyAccumulator -= nMinDrop; |
|
//DevMsg( "*MIN REACHED* -- %d left\n", m_nCurrencyAccumulator ); |
|
return nMinDrop; |
|
} |
|
else |
|
{ |
|
// We don't have enough yet, drop nothing |
|
//DevMsg( "*STORE* -- %d stored\n", m_nCurrencyAccumulator ); |
|
return 0; |
|
} |
|
} |
|
else |
|
{ |
|
// We don't have a PopManager - return the amount passed in |
|
return nAmount; |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Figures out how much to give for pre-definied events or types |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::CalculateCurrencyAmount_ByType( CurrencyRewards_t nType ) |
|
{ |
|
// CUSTOM values are usually determined by CalculateCurrencyAmount_CustomPack() and set via CCurrencyPack::SetValue() |
|
Assert ( nType != TF_CURRENCY_PACK_CUSTOM ); |
|
|
|
int nAmount = 0; |
|
|
|
switch ( nType ) |
|
{ |
|
case TF_CURRENCY_KILLED_PLAYER: |
|
nAmount = 40; |
|
break; |
|
|
|
case TF_CURRENCY_KILLED_OBJECT: |
|
nAmount = 40; |
|
break; |
|
|
|
case TF_CURRENCY_ASSISTED_PLAYER: |
|
nAmount = 20; |
|
break; |
|
|
|
case TF_CURRENCY_BONUS_POINTS: |
|
nAmount = 1; |
|
break; |
|
|
|
case TF_CURRENCY_CAPTURED_OBJECTIVE: |
|
nAmount = 100; |
|
break; |
|
|
|
case TF_CURRENCY_ESCORT_REWARD: |
|
nAmount = 10; |
|
break; |
|
|
|
case TF_CURRENCY_PACK_SMALL: |
|
nAmount = 5; |
|
break; |
|
|
|
case TF_CURRENCY_PACK_MEDIUM: |
|
nAmount = 10; |
|
break; |
|
|
|
case TF_CURRENCY_PACK_LARGE: |
|
nAmount = 25; |
|
break; |
|
|
|
case TF_CURRENCY_TIME_REWARD: |
|
nAmount = 5; |
|
break; |
|
|
|
case TF_CURRENCY_WAVE_COLLECTION_BONUS: |
|
nAmount = 100; |
|
break; |
|
|
|
default: |
|
Assert( 0 ); // Unknown type |
|
}; |
|
|
|
return nAmount; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Gives money directly to a team or specific player |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::DistributeCurrencyAmount( int nAmount, CTFPlayer *pTFPlayer /* = NULL */, bool bShared /* = true */, bool bCountAsDropped /*= false */, bool bIsBonus /*= false */ ) |
|
{ |
|
// Group distribution (default) |
|
if ( bShared ) |
|
{ |
|
CUtlVector<CTFPlayer *> playerVector; |
|
|
|
if ( IsMannVsMachineMode() ) |
|
{ |
|
CollectPlayers( &playerVector, TF_TEAM_PVE_DEFENDERS ); |
|
} |
|
#ifdef STAGING_ONLY |
|
else if ( IsBountyMode() ) |
|
{ |
|
// We require a player in order to award the proper team |
|
if ( pTFPlayer ) |
|
{ |
|
CollectPlayers( &playerVector, pTFPlayer->GetTeamNumber() ); |
|
} |
|
} |
|
#endif // STAGING_ONLY |
|
|
|
// Money |
|
FOR_EACH_VEC( playerVector, i ) |
|
{ |
|
if ( playerVector[i] ) |
|
{ |
|
#ifdef STAGING_ONLY |
|
if ( IsBountyMode() ) |
|
{ |
|
// Check for a cap |
|
int nLimit = tf_bountymode_currency_limit.GetInt(); |
|
if ( nLimit > 0 ) |
|
{ |
|
int nNewCurrency = nAmount + pTFPlayer->GetCurrency(); |
|
if ( nNewCurrency > nLimit ) |
|
{ |
|
int nDelta = nNewCurrency - nLimit; |
|
if ( nDelta ) |
|
{ |
|
nAmount -= nDelta; |
|
} |
|
} |
|
} |
|
} |
|
#endif // STAGING_ONLY |
|
|
|
playerVector[i]->AddCurrency( nAmount ); |
|
} |
|
} |
|
} |
|
// Individual distribution |
|
else if ( pTFPlayer ) |
|
{ |
|
#ifdef STAGING_ONLY |
|
if ( IsBountyMode() ) |
|
{ |
|
// Check for a cap |
|
int nLimit = tf_bountymode_currency_limit.GetInt(); |
|
if ( nLimit > 0 ) |
|
{ |
|
int nNewCurrency = nAmount + pTFPlayer->GetCurrency(); |
|
if ( nNewCurrency > nLimit ) |
|
{ |
|
int nDelta = nNewCurrency - nLimit; |
|
if ( nDelta ) |
|
{ |
|
nAmount -= nDelta; |
|
} |
|
} |
|
} |
|
} |
|
#endif // STAGING_ONLY |
|
|
|
pTFPlayer->AddCurrency( nAmount ); |
|
} |
|
|
|
// Accounting |
|
if ( IsMannVsMachineMode() && g_pPopulationManager ) |
|
{ |
|
g_pPopulationManager->OnCurrencyCollected( nAmount, bCountAsDropped, bIsBonus ); |
|
} |
|
|
|
return nAmount; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::RoundRespawn( void ) |
|
{ |
|
#ifdef GAME_DLL |
|
m_hasSpawnedToy = false; |
|
for ( int i = 0; i < TF_TEAM_COUNT; i++ ) |
|
{ |
|
m_bHasSpawnedSoccerBall[i] = false; |
|
} |
|
#endif // GAME_DLL |
|
|
|
// remove any buildings, grenades, rockets, etc. the player put into the world |
|
RemoveAllProjectilesAndBuildings(); |
|
|
|
// re-enable any sentry guns the losing team has built (and not hidden!) |
|
for ( int i=0; i<IBaseObjectAutoList::AutoList().Count(); ++i ) |
|
{ |
|
CBaseObject *pObj = static_cast< CBaseObject* >( IBaseObjectAutoList::AutoList()[i] ); |
|
if ( pObj->ObjectType() == OBJ_SENTRYGUN && pObj->IsEffectActive( EF_NODRAW ) == false && pObj->GetTeamNumber() != m_iWinningTeam ) |
|
{ |
|
pObj->SetDisabled( false ); |
|
} |
|
} |
|
|
|
#ifdef TF_RAID_MODE |
|
// Raid mode: clean up any Red buildings that might be left behind from the previous round |
|
if ( IsRaidMode() ) |
|
{ |
|
CTFTeam *pTeam = TFTeamMgr()->GetTeam( TF_TEAM_RED ); |
|
if ( pTeam ) |
|
{ |
|
int nTeamObjectCount = pTeam->GetNumObjects(); |
|
|
|
for ( int iObject = 0; iObject < nTeamObjectCount; ++iObject ) |
|
{ |
|
CBaseObject *pObj = pTeam->GetObject( iObject ); |
|
|
|
if ( pObj ) |
|
{ |
|
pObj->SetThink( &CBaseEntity::SUB_Remove ); |
|
pObj->SetNextThink( gpGlobals->curtime ); |
|
pObj->SetTouch( NULL ); |
|
pObj->AddEffects( EF_NODRAW ); |
|
} |
|
} |
|
} |
|
} |
|
else if ( IsBossBattleMode() ) |
|
{ |
|
// unspawn entire red team |
|
CTeam *defendingTeam = GetGlobalTeam( TF_TEAM_RED ); |
|
int i; |
|
for( i=0; i<defendingTeam->GetNumPlayers(); ++i ) |
|
{ |
|
engine->ServerCommand( UTIL_VarArgs( "kickid %d\n", defendingTeam->GetPlayer(i)->GetUserID() ) ); |
|
} |
|
} |
|
#endif // TF_RAID_MODE |
|
|
|
if ( IsInTournamentMode() == false ) |
|
{ |
|
Arena_RunTeamLogic(); |
|
} |
|
|
|
m_bArenaFirstBlood = false; |
|
|
|
// reset the flag captures |
|
int nTeamCount = TFTeamMgr()->GetTeamCount(); |
|
for ( int iTeam = FIRST_GAME_TEAM; iTeam < nTeamCount; ++iTeam ) |
|
{ |
|
CTFTeam *pTeam = GetGlobalTFTeam( iTeam ); |
|
if ( !pTeam ) |
|
continue; |
|
|
|
pTeam->SetFlagCaptures( 0 ); |
|
} |
|
|
|
if ( !IsMannVsMachineMode() ) |
|
{ |
|
IGameEvent *event = gameeventmanager->CreateEvent( "scorestats_accumulated_update" ); |
|
if ( event ) |
|
{ |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
} |
|
|
|
// reset player per-round stats |
|
CTF_GameStats.ResetRoundStats(); |
|
|
|
BaseClass::RoundRespawn(); |
|
|
|
// ** AFTER WE'VE BEEN THROUGH THE ROUND RESPAWN, SHOW THE ROUNDINFO PANEL |
|
if ( !IsInWaitingForPlayers() ) |
|
{ |
|
ShowRoundInfoPanel(); |
|
} |
|
|
|
// We've hit some condition where a server-side vote should be called on respawn |
|
if ( m_bServerVoteOnReset ) |
|
{ |
|
if ( g_voteController ) |
|
{ |
|
g_voteController->CreateVote( DEDICATED_SERVER, "nextlevel", "" ); |
|
} |
|
m_bVoteCalled = true; |
|
m_bServerVoteOnReset = false; |
|
} |
|
} |
|
|
|
#ifdef GAME_DLL |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::ShouldSwitchTeams( void ) |
|
{ |
|
if ( IsPVEModeActive() ) |
|
return false; |
|
|
|
return BaseClass::ShouldSwitchTeams(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::ShouldScrambleTeams( void ) |
|
{ |
|
if ( IsPVEModeActive() ) |
|
return false; |
|
|
|
if ( IsCompetitiveMode() ) |
|
return false; |
|
|
|
return BaseClass::ShouldScrambleTeams(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::ClientCommandKeyValues( edict_t *pEntity, KeyValues *pKeyValues ) |
|
{ |
|
CTFPlayer *pTFPlayer = ToTFPlayer( CBaseEntity::Instance( pEntity ) ); |
|
|
|
if ( !pTFPlayer ) |
|
return; |
|
|
|
char const *pszCommand = pKeyValues->GetName(); |
|
if ( pszCommand && pszCommand[0] ) |
|
{ |
|
if ( FStrEq( pszCommand, "FreezeCamTaunt" ) ) |
|
{ |
|
CTFPlayer *pAchiever = ToTFPlayer( UTIL_PlayerByUserId( pKeyValues->GetInt( "achiever" ) ) ); |
|
if ( pAchiever ) |
|
{ |
|
const char *pszCommand = pKeyValues->GetString( "command" ); |
|
if ( pszCommand && pszCommand[0] ) |
|
{ |
|
int nGibs = pKeyValues->GetInt( "gibs" ); |
|
|
|
if ( FStrEq( pszCommand, "freezecam_taunt" ) ) |
|
{ |
|
CheckTauntAchievement( pAchiever, nGibs, g_TauntCamAchievements ); |
|
CheckTauntAchievement( pAchiever, nGibs, g_TauntCamAchievements2 ); |
|
HatAndMiscEconEntities_OnOwnerKillEaterEventNoParter( pAchiever, kKillEaterEvent_KillcamTaunts ); |
|
} |
|
else if ( FStrEq( pszCommand, "freezecam_tauntrag" ) ) |
|
{ |
|
CheckTauntAchievement( pAchiever, nGibs, g_TauntCamRagdollAchievements ); |
|
} |
|
else if ( FStrEq( pszCommand, "freezecam_tauntgibs" ) ) |
|
{ |
|
CheckTauntAchievement( pAchiever, nGibs, g_TauntCamAchievements ); |
|
} |
|
else if ( FStrEq( pszCommand, "freezecam_tauntsentry" ) ) |
|
{ |
|
// Maybe should also require a taunt? Currently too easy to get? |
|
pAchiever->AwardAchievement( ACHIEVEMENT_TF_ENGINEER_FREEZECAM_SENTRY ); |
|
} |
|
} |
|
} |
|
} |
|
else if ( FStrEq( pszCommand, "UsingVRHeadset" ) ) |
|
{ |
|
pTFPlayer->SetUsingVRHeadset( true ); |
|
} |
|
else if ( FStrEq( pszCommand, "TestItems" ) ) |
|
{ |
|
pTFPlayer->ItemTesting_Start( pKeyValues ); |
|
} |
|
else if ( FStrEq( pszCommand, "TestItemsBotUpdate" ) ) |
|
{ |
|
ItemTesting_SetupFromKV( pKeyValues ); |
|
} |
|
else if ( FStrEq( pszCommand, "MVM_Upgrade" ) ) |
|
{ |
|
if ( GameModeUsesUpgrades() ) |
|
{ |
|
#ifndef STAGING_ONLY |
|
if ( IsMannVsMachineMode() ) |
|
{ |
|
if ( sv_cheats && !sv_cheats->GetBool() && !pTFPlayer->m_Shared.IsInUpgradeZone() ) |
|
return; |
|
} |
|
#endif //!STAGING_ONLY |
|
|
|
if ( g_hUpgradeEntity ) |
|
{ |
|
// First sell everything we want to sell |
|
KeyValues *pSubKey = pKeyValues->GetFirstTrueSubKey(); |
|
while ( pSubKey ) |
|
{ |
|
int iCount = pSubKey->GetInt("count"); |
|
if ( iCount < 0 ) |
|
{ |
|
int iItemSlot = pSubKey->GetInt("itemslot"); |
|
int iUpgrade = pSubKey->GetInt("upgrade"); |
|
bool bFree = pSubKey->GetBool( "free", false ); |
|
|
|
while ( iCount < 0 ) |
|
{ |
|
g_hUpgradeEntity->PlayerPurchasingUpgrade( pTFPlayer, iItemSlot, iUpgrade, true, bFree ); |
|
++iCount; |
|
} |
|
} |
|
|
|
pSubKey = pSubKey->GetNextTrueSubKey(); |
|
} |
|
|
|
// Now buy everything we want to buy |
|
pSubKey = pKeyValues->GetFirstTrueSubKey(); |
|
while ( pSubKey ) |
|
{ |
|
int iCount = pSubKey->GetInt("count"); |
|
if ( iCount > 0 ) |
|
{ |
|
int iItemSlot = pSubKey->GetInt("itemslot"); |
|
int iUpgrade = pSubKey->GetInt("upgrade"); |
|
bool bFree = ( sv_cheats && sv_cheats->GetBool() ) ? pSubKey->GetBool( "free", false ) : false; // Never let a client set "free" without sv_cheats 1 |
|
|
|
while ( iCount > 0 ) |
|
{ |
|
g_hUpgradeEntity->PlayerPurchasingUpgrade( pTFPlayer, iItemSlot, iUpgrade, false, bFree ); |
|
--iCount; |
|
} |
|
} |
|
|
|
pSubKey = pSubKey->GetNextTrueSubKey(); |
|
} |
|
} |
|
} |
|
} |
|
else if ( FStrEq( pszCommand, "MvM_UpgradesBegin" ) ) |
|
{ |
|
pTFPlayer->BeginPurchasableUpgrades(); |
|
} |
|
else if ( FStrEq( pszCommand, "MvM_UpgradesDone" ) ) |
|
{ |
|
pTFPlayer->EndPurchasableUpgrades(); |
|
|
|
if ( IsMannVsMachineMode() && pKeyValues->GetInt( "num_upgrades", 0 ) > 0 ) |
|
{ |
|
pTFPlayer->SpeakConceptIfAllowed( MP_CONCEPT_MVM_UPGRADE_COMPLETE ); |
|
} |
|
} |
|
else if ( FStrEq( pszCommand, "MVM_Revive_Response" ) ) |
|
{ |
|
CTFReviveMarker *pReviveMarker = pTFPlayer->GetReviveMarker(); |
|
if ( pReviveMarker ) |
|
{ |
|
if ( pKeyValues->GetBool( "accepted", 0 ) ) |
|
{ |
|
pReviveMarker->ReviveOwner(); |
|
} |
|
else |
|
{ |
|
// They hit cancel after their spawn timer was up |
|
if ( HasPassedMinRespawnTime( pTFPlayer ) ) |
|
{ |
|
pTFPlayer->ForceRespawn(); |
|
} |
|
|
|
UTIL_Remove( pReviveMarker ); |
|
} |
|
} |
|
} |
|
else if ( FStrEq( pszCommand, "MVM_Respec" ) ) |
|
{ |
|
if ( GameModeUsesUpgrades() && IsMannVsMachineRespecEnabled() && CanPlayerUseRespec( pTFPlayer ) ) |
|
{ |
|
#ifndef STAGING_ONLY |
|
if ( IsMannVsMachineMode() ) |
|
{ |
|
if ( sv_cheats && !sv_cheats->GetBool() && !pTFPlayer->m_Shared.IsInUpgradeZone() ) |
|
return; |
|
} |
|
#endif //!STAGING_ONLY |
|
|
|
if ( g_hUpgradeEntity && g_pPopulationManager ) |
|
{ |
|
// Consume a respec credit |
|
g_pPopulationManager->RemoveRespecFromPlayer( pTFPlayer ); |
|
|
|
// Remove the appropriate upgrade info from upgrade histories |
|
g_pPopulationManager->RemovePlayerAndItemUpgradesFromHistory( pTFPlayer ); |
|
|
|
// Remove upgrade attributes from the player and their items |
|
g_hUpgradeEntity->GrantOrRemoveAllUpgrades( pTFPlayer, true ); |
|
|
|
pTFPlayer->ForceRespawn(); |
|
} |
|
} |
|
} |
|
else if ( FStrEq( pszCommand, "use_action_slot_item_server" ) ) |
|
{ |
|
if ( pTFPlayer->ShouldRunRateLimitedCommand( "use_action_slot_item_server" ) ) |
|
{ |
|
pTFPlayer->UseActionSlotItemPressed(); |
|
pTFPlayer->UseActionSlotItemReleased(); |
|
} |
|
} |
|
else if ( FStrEq( pszCommand, "+use_action_slot_item_server" ) ) |
|
{ |
|
if ( !pTFPlayer->IsUsingActionSlot() ) |
|
{ |
|
pTFPlayer->UseActionSlotItemPressed(); |
|
} |
|
} |
|
else if ( FStrEq( pszCommand, "-use_action_slot_item_server" ) ) |
|
{ |
|
if ( pTFPlayer->IsUsingActionSlot() ) |
|
{ |
|
pTFPlayer->UseActionSlotItemReleased(); |
|
} |
|
} |
|
else if ( FStrEq( pszCommand, "+inspect_server" ) ) |
|
{ |
|
pTFPlayer->InspectButtonPressed(); |
|
} |
|
else if ( FStrEq( pszCommand, "-inspect_server" ) ) |
|
{ |
|
pTFPlayer->InspectButtonReleased(); |
|
} |
|
else if ( FStrEq( pszCommand, "cl_drawline" ) ) |
|
{ |
|
BroadcastDrawLine( pTFPlayer, pKeyValues ); |
|
} |
|
else if ( FStrEq( pszCommand, "AutoBalanceVolunteerReply" ) ) |
|
{ |
|
if ( TFAutoBalance() ) |
|
{ |
|
TFAutoBalance()->ReplyReceived( pTFPlayer, pKeyValues->GetBool( "response", false ) ); |
|
} |
|
} |
|
else |
|
{ |
|
BaseClass::ClientCommandKeyValues( pEntity, pKeyValues ); |
|
} |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::BroadcastDrawLine( CTFPlayer *pTFPlayer, KeyValues *pKeyValues ) |
|
{ |
|
int paneltype = clamp( pKeyValues->GetInt( "panel", DRAWING_PANEL_TYPE_NONE ), DRAWING_PANEL_TYPE_NONE, DRAWING_PANEL_TYPE_MAX - 1 ); |
|
|
|
if ( paneltype >= DRAWING_PANEL_TYPE_MATCH_SUMMARY ) |
|
{ |
|
int linetype = clamp( pKeyValues->GetInt( "line", 0 ), 0, 1 ); |
|
float x = pKeyValues->GetFloat( "x", 0.f ); |
|
float y = pKeyValues->GetFloat( "y", 0.f ); |
|
|
|
IGameEvent *event = gameeventmanager->CreateEvent( "cl_drawline" ); |
|
if ( event ) |
|
{ |
|
event->SetInt( "player", pTFPlayer->entindex() ); |
|
event->SetInt( "panel",paneltype ); |
|
event->SetInt( "line", linetype ); |
|
event->SetFloat( "x", x ); |
|
event->SetFloat( "y", y ); |
|
|
|
gameeventmanager->FireEvent( event ); |
|
} |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::RespawnTeam( int iTeam ) |
|
{ |
|
BaseClass::RespawnTeam( iTeam ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SpawnPlayerInHell( CTFPlayer *pPlayer, const char *pszSpawnPointName ) |
|
{ |
|
Vector vTeleportPosition; |
|
QAngle qTeleportAngles; |
|
|
|
int iCachedLocations = m_mapTeleportLocations.Find( MAKE_STRING( pszSpawnPointName ) ); |
|
if ( m_mapTeleportLocations.IsValidIndex( iCachedLocations ) ) |
|
{ |
|
CUtlVector< TeleportLocation_t > *pLocations = m_mapTeleportLocations[iCachedLocations]; |
|
Assert( pLocations ); |
|
if ( !pLocations ) |
|
return; |
|
|
|
const TeleportLocation_t& location = pLocations->Element( RandomInt( 0, pLocations->Count() - 1 ) ); |
|
vTeleportPosition = location.m_vecPosition; |
|
qTeleportAngles = location.m_qAngles; |
|
} |
|
else |
|
{ |
|
CUtlVector< CBaseEntity* > m_vecPossibleSpawns; |
|
CBaseEntity* pSpawn = NULL; |
|
while( (pSpawn = gEntList.FindEntityByName( pSpawn, pszSpawnPointName ) ) != NULL ) |
|
{ |
|
m_vecPossibleSpawns.AddToTail( pSpawn ); |
|
} |
|
|
|
// There had better be a spawnpoint in this map! |
|
Assert( m_vecPossibleSpawns.Count() ); |
|
if ( m_vecPossibleSpawns.Count() == 0 ) |
|
return; |
|
|
|
// Randomly choose one |
|
pSpawn = m_vecPossibleSpawns[ RandomInt( 0, m_vecPossibleSpawns.Count() - 1 ) ]; |
|
vTeleportPosition = pSpawn->GetAbsOrigin(); |
|
qTeleportAngles = pSpawn->GetAbsAngles(); |
|
} |
|
|
|
// Teleport them to hell |
|
pPlayer->Teleport( &vTeleportPosition, &qTeleportAngles, &vec3_origin ); |
|
pPlayer->pl.v_angle = qTeleportAngles; |
|
|
|
// Send us to hell as a ghost! |
|
pPlayer->m_Shared.AddCond( TF_COND_HALLOWEEN_GHOST_MODE ); |
|
pPlayer->m_Shared.AddCond( TF_COND_HALLOWEEN_IN_HELL ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
extern ISoundEmitterSystemBase *soundemitterbase; |
|
void CTFGameRules::PlayHelltowerAnnouncerVO( int iRedLine, int iBlueLine ) |
|
{ |
|
static float flRedAnnouncerTalkingUntil = 0.00f, flBlueAnnouncerTalkingUntil = 0.00f; |
|
|
|
// 01 is the first line for the VO |
|
int iRandomVORed = RandomInt( 1, g_pszHelltowerAnnouncerLines[iRedLine].m_nCount ); |
|
int iRandomVOBlue = RandomInt( 1, g_pszHelltowerAnnouncerLines[iBlueLine].m_nCount ); |
|
|
|
// the misc lines should match up so we'll play the same lines to both teams |
|
if ( ( iRedLine <= HELLTOWER_VO_BLUE_MISC_RARE ) && ( iBlueLine <= HELLTOWER_VO_BLUE_MISC_RARE ) ) |
|
{ |
|
// can we safely set blue to the same value? |
|
if ( iRandomVORed <= g_pszHelltowerAnnouncerLines[iBlueLine].m_nCount ) |
|
{ |
|
iRandomVOBlue = iRandomVORed; |
|
} |
|
} |
|
|
|
char szRedAudio[128]; |
|
char szBlueAudio[128]; |
|
V_sprintf_safe( szRedAudio, g_pszHelltowerAnnouncerLines[iRedLine].m_pszFormatString, iRandomVORed ); |
|
V_sprintf_safe( szBlueAudio, g_pszHelltowerAnnouncerLines[iBlueLine].m_pszFormatString, iRandomVOBlue ); |
|
|
|
bool bForceVO = false; |
|
switch (iRedLine) |
|
{ |
|
case HELLTOWER_VO_RED_WIN: |
|
case HELLTOWER_VO_RED_WIN_RARE: |
|
case HELLTOWER_VO_RED_LOSE: |
|
case HELLTOWER_VO_RED_LOSE_RARE: |
|
bForceVO = true; |
|
} |
|
switch (iBlueLine) |
|
{ |
|
case HELLTOWER_VO_BLUE_WIN: |
|
case HELLTOWER_VO_BLUE_WIN_RARE: |
|
case HELLTOWER_VO_BLUE_LOSE: |
|
case HELLTOWER_VO_BLUE_LOSE_RARE: |
|
bForceVO = true; |
|
} |
|
|
|
CSoundParameters params; |
|
float flSoundDuration = 0; |
|
|
|
if ( gpGlobals->curtime > flRedAnnouncerTalkingUntil || bForceVO ) |
|
{ |
|
BroadcastSound( TF_TEAM_RED, szRedAudio ); |
|
if ( soundemitterbase->GetParametersForSound( szRedAudio, params, GENDER_NONE ) ) |
|
{ |
|
//flSoundDuration = enginesound->GetSoundDuration( params.soundname ); |
|
flRedAnnouncerTalkingUntil = gpGlobals->curtime + flSoundDuration; |
|
} |
|
else |
|
{ |
|
flRedAnnouncerTalkingUntil = 0.00; |
|
} |
|
} |
|
if ( gpGlobals->curtime > flBlueAnnouncerTalkingUntil || bForceVO ) |
|
{ |
|
BroadcastSound( TF_TEAM_BLUE, szBlueAudio ); |
|
if ( soundemitterbase->GetParametersForSound( szBlueAudio, params, GENDER_NONE ) ) |
|
{ |
|
//flSoundDuration = enginesound->GetSoundDuration( params.soundname ); |
|
flBlueAnnouncerTalkingUntil = gpGlobals->curtime + flSoundDuration; |
|
} |
|
else |
|
{ |
|
flBlueAnnouncerTalkingUntil = 0.00; |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Based on connected match players, chooses the 3 maps players can |
|
// vote on as their next map |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::ChooseNextMapVoteOptions() |
|
{ |
|
// Copy chosen maps into the actual fields we're networking to clients |
|
for( int i=0; i < NEXT_MAP_VOTE_OPTIONS; ++i ) |
|
{ |
|
m_nNextMapVoteOptions.Set( i, GTFGCClientSystem()->GetNextMapVoteByIndex( i )->m_nDefIndex ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::CheckHelltowerCartAchievement( int iTeam ) |
|
{ |
|
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) ) |
|
{ |
|
CUtlVector< CTFPlayer * > playerVector; |
|
CollectPlayers( &playerVector, iTeam ); |
|
|
|
FOR_EACH_VEC( playerVector, i ) |
|
{ |
|
CTFPlayer *pPlayer = playerVector[i]; |
|
if ( pPlayer && ( pPlayer->GetObserverMode() <= OBS_MODE_DEATHCAM ) ) // they might be killed by the explosion, so check if they are OBS_MODE_NONE OR OBS_MODE_DEATHCAM |
|
{ |
|
CTriggerAreaCapture *pAreaTrigger = pPlayer->GetControlPointStandingOn(); |
|
if ( pAreaTrigger && pAreaTrigger->TeamCanCap( iTeam ) ) |
|
{ |
|
pPlayer->AwardAchievement( ACHIEVEMENT_TF_HALLOWEEN_HELLTOWER_KILL_BROTHERS ); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::HandleMapEvent( inputdata_t &inputdata ) |
|
{ |
|
if ( FStrEq( "sd_doomsday", STRING( gpGlobals->mapname ) ) ) |
|
{ |
|
// find the flag in the map |
|
CCaptureFlag *pFlag = NULL; |
|
for ( int i=0; i<ICaptureFlagAutoList::AutoList().Count(); ++i ) |
|
{ |
|
pFlag = static_cast< CCaptureFlag* >( ICaptureFlagAutoList::AutoList()[i] ); |
|
if ( !pFlag->IsDisabled() ) |
|
{ |
|
break; |
|
} |
|
} |
|
|
|
// make sure it's being carried by one of the teams |
|
if ( pFlag && pFlag->IsStolen() ) |
|
{ |
|
CTFPlayer *pFlagCarrier = ToTFPlayer( pFlag->GetOwnerEntity() ); |
|
if ( pFlagCarrier ) |
|
{ |
|
// let everyone know which team has opened the rocket |
|
IGameEvent *event = gameeventmanager->CreateEvent( "doomsday_rocket_open" ); |
|
if ( event ) |
|
{ |
|
event->SetInt( "team", pFlagCarrier->GetTeamNumber() ); |
|
gameeventmanager->FireEvent( event ); |
|
} |
|
} |
|
} |
|
} |
|
else if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) ) |
|
{ |
|
const char *pszEvent = inputdata.value.String(); |
|
if ( FStrEq( pszEvent, "midnight" ) ) |
|
{ |
|
HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_PLAYER_HELLTOWER_MIDNIGHT ); |
|
} |
|
else if ( FStrEq( pszEvent, "horde" ) ) |
|
{ |
|
HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_PLAYER_SKELETON_KING_APPEAR ); |
|
PlayHelltowerAnnouncerVO( HELLTOWER_VO_RED_SKELETON_KING, HELLTOWER_VO_BLUE_SKELETON_KING ); |
|
} |
|
else if ( FStrEq( pszEvent, "red_capture" ) ) |
|
{ |
|
CheckHelltowerCartAchievement( TF_TEAM_RED ); |
|
if ( RandomFloat( 0, 1 ) < HELLTOWER_RARE_LINE_CHANCE ) |
|
{ |
|
PlayHelltowerAnnouncerVO( HELLTOWER_VO_RED_WIN_RARE, HELLTOWER_VO_BLUE_LOSE_RARE ); |
|
} |
|
else |
|
{ |
|
PlayHelltowerAnnouncerVO( HELLTOWER_VO_RED_WIN, HELLTOWER_VO_BLUE_LOSE ); |
|
} |
|
} |
|
else if ( FStrEq( pszEvent, "blue_capture" ) ) |
|
{ |
|
CheckHelltowerCartAchievement( TF_TEAM_BLUE ); |
|
if ( RandomFloat( 0, 1 ) < HELLTOWER_RARE_LINE_CHANCE ) |
|
{ |
|
PlayHelltowerAnnouncerVO( HELLTOWER_VO_RED_LOSE_RARE, HELLTOWER_VO_BLUE_WIN_RARE ); |
|
} |
|
else |
|
{ |
|
PlayHelltowerAnnouncerVO( HELLTOWER_VO_RED_LOSE, HELLTOWER_VO_BLUE_WIN ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetCustomUpgradesFile( inputdata_t &inputdata ) |
|
{ |
|
const char *pszPath = inputdata.value.String(); |
|
|
|
// Reload |
|
g_MannVsMachineUpgrades.LoadUpgradesFileFromPath( pszPath ); |
|
|
|
// Tell future clients to load from this path |
|
V_strncpy( m_pszCustomUpgradesFile.GetForModify(), pszPath, MAX_PATH ); |
|
|
|
// Tell connected clients to reload |
|
IGameEvent *pEvent = gameeventmanager->CreateEvent( "upgrades_file_changed" ); |
|
if ( pEvent ) |
|
{ |
|
pEvent->SetString( "path", pszPath ); |
|
gameeventmanager->FireEvent( pEvent ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::ShouldWaitToStartRecording( void ) |
|
{ |
|
if ( IsMannVsMachineMode() ) |
|
{ |
|
// Don't wait for the WaitingForPlayers period to end if we're MvM |
|
return false; |
|
} |
|
|
|
return BaseClass::ShouldWaitToStartRecording(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: return true if this flag is currently allowed to be captured |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::CanFlagBeCaptured( CBaseEntity *pOther ) |
|
{ |
|
if ( pOther && ( tf_flag_return_on_touch.GetBool() || IsPowerupMode() ) ) |
|
{ |
|
for ( int i = 0; i < ICaptureFlagAutoList::AutoList().Count(); ++i ) |
|
{ |
|
CCaptureFlag *pListFlag = static_cast<CCaptureFlag*>( ICaptureFlagAutoList::AutoList()[i] ); |
|
if ( ( pListFlag->GetType() == TF_FLAGTYPE_CTF ) && !pListFlag->IsDisabled() && ( pOther->GetTeamNumber() == pListFlag->GetTeamNumber() ) && !pListFlag->IsHome() ) |
|
return false; |
|
} |
|
} |
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: return true if the game is in a state where both flags are stolen and poisonous |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::PowerupModeFlagStandoffActive( void ) |
|
{ |
|
if ( IsPowerupMode() ) |
|
{ |
|
int nQualifyingFlags = 0; // All flags need to be stolen and poisonous (poisonous time delay gives the flag carriers a chance to get out of the enemy base) |
|
int nEnabledFlags = 0; // Some flags might be in the autolist but be out of play. We don't want them included in the count |
|
for ( int i = 0; i < ICaptureFlagAutoList::AutoList().Count(); ++i ) |
|
{ |
|
CCaptureFlag *pFlag = static_cast<CCaptureFlag*>( ICaptureFlagAutoList::AutoList()[i] ); |
|
if ( !pFlag->IsDisabled() ) |
|
nEnabledFlags++; |
|
if ( pFlag->IsPoisonous() && pFlag->IsStolen() ) |
|
nQualifyingFlags++; |
|
} |
|
if ( nQualifyingFlags == nEnabledFlags ) |
|
{ |
|
return true; |
|
} |
|
} |
|
return false; |
|
} |
|
|
|
void CTFGameRules::TeleportPlayersToTargetEntities( int iTeam, const char *pszEntTargetName, CUtlVector< CTFPlayer * > *pTeleportedPlayers ) |
|
{ |
|
CUtlVector< CTFPlayer * > vecPlayers; |
|
CUtlVector< CTFPlayer * > vecRandomOrderPlayers; |
|
|
|
CollectPlayers( &vecPlayers, iTeam ); |
|
|
|
FOR_EACH_VEC( vecPlayers, i ) |
|
{ |
|
CTFPlayer *pPlayer = vecPlayers[i]; |
|
|
|
// Skip players not on a team or who have not chosen a class |
|
if ( ( pPlayer->GetTeamNumber() != TF_TEAM_RED && pPlayer->GetTeamNumber() != TF_TEAM_BLUE ) |
|
|| pPlayer->IsPlayerClass( TF_CLASS_UNDEFINED ) ) |
|
continue; |
|
|
|
vecRandomOrderPlayers.AddToTail( pPlayer ); |
|
} |
|
|
|
// Randomize the order so players dont go to the same spot every time |
|
vecRandomOrderPlayers.Shuffle(); |
|
|
|
string_t sName = MAKE_STRING( pszEntTargetName ); |
|
int iCachedLocationIndex = m_mapTeleportLocations.Find( sName ); |
|
CUtlVector< TeleportLocation_t > *pCachedLocations = NULL; |
|
// is there any cached entities to teleport to |
|
if ( m_mapTeleportLocations.IsValidIndex( iCachedLocationIndex ) ) |
|
{ |
|
pCachedLocations = m_mapTeleportLocations[iCachedLocationIndex]; |
|
} |
|
|
|
|
|
int iCurrentTeleportLocation = 0; |
|
CBaseEntity *pSpawnPoint = NULL; |
|
FOR_EACH_VEC_BACK( vecRandomOrderPlayers, i ) |
|
{ |
|
// don't do anything if we run out of spawn point |
|
Vector vTeleportPosition; |
|
QAngle qTeleportAngles; |
|
|
|
// if we have cached locations, use them |
|
if ( pCachedLocations ) |
|
{ |
|
Assert( iCurrentTeleportLocation < pCachedLocations->Count() ); |
|
if ( iCurrentTeleportLocation < pCachedLocations->Count() ) |
|
{ |
|
const TeleportLocation_t& location = pCachedLocations->Element( iCurrentTeleportLocation ); |
|
vTeleportPosition = location.m_vecPosition; |
|
qTeleportAngles = location.m_qAngles; |
|
iCurrentTeleportLocation++; |
|
} |
|
else |
|
{ |
|
// we need to add more teleport location in the map for players to teleport to |
|
continue; |
|
} |
|
} |
|
else // use old search for entities by name |
|
{ |
|
pSpawnPoint = gEntList.FindEntityByName( pSpawnPoint, pszEntTargetName ); |
|
|
|
Assert( pSpawnPoint ); |
|
if ( pSpawnPoint ) |
|
{ |
|
vTeleportPosition = pSpawnPoint->GetAbsOrigin(); |
|
qTeleportAngles = pSpawnPoint->GetAbsAngles(); |
|
} |
|
else |
|
{ |
|
// we need to add more teleport location in the map for players to teleport to |
|
continue; |
|
} |
|
} |
|
|
|
CTFPlayer *pPlayer = vecRandomOrderPlayers[ i ]; |
|
pPlayer->m_Shared.RemoveAllCond(); |
|
|
|
// Respawn dead players |
|
if ( !pPlayer->IsAlive() ) |
|
{ |
|
pPlayer->ForceRespawn(); |
|
} |
|
|
|
// Unzoom if we are a sniper zoomed! |
|
pPlayer->m_Shared.InstantlySniperUnzoom(); |
|
|
|
// Teleport |
|
pPlayer->Teleport( &vTeleportPosition, &qTeleportAngles, &vec3_origin ); |
|
pPlayer->SnapEyeAngles( qTeleportAngles ); |
|
|
|
// Force client to update all view angles (including kart and taunt yaw) |
|
pPlayer->ForcePlayerViewAngles( qTeleportAngles ); |
|
|
|
// fill in the teleported player vector |
|
if ( pTeleportedPlayers ) |
|
{ |
|
pTeleportedPlayers->AddToTail( pPlayer ); |
|
} |
|
} |
|
} |
|
|
|
#endif // GAME_DLL |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::InternalHandleTeamWin( int iWinningTeam ) |
|
{ |
|
// remove any spies' disguises and make them visible (for the losing team only) |
|
// and set the speed for both teams (winners get a boost and losers have reduced speed) |
|
for ( int i = 1; i <= MAX_PLAYERS; i++ ) |
|
{ |
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
|
|
if ( pPlayer ) |
|
{ |
|
if ( pPlayer->GetTeamNumber() > LAST_SHARED_TEAM ) |
|
{ |
|
if ( pPlayer->GetTeamNumber() != iWinningTeam ) |
|
{ |
|
pPlayer->RemoveInvisibility(); |
|
// pPlayer->RemoveDisguise(); |
|
|
|
if ( pPlayer->HasTheFlag() ) |
|
{ |
|
pPlayer->DropFlag(); |
|
} |
|
} |
|
|
|
pPlayer->TeamFortress_SetSpeed(); |
|
} |
|
} |
|
} |
|
|
|
for ( int i=0; i<IBaseObjectAutoList::AutoList().Count(); ++i ) |
|
{ |
|
CBaseObject *pObj = static_cast< CBaseObject* >( IBaseObjectAutoList::AutoList()[i] ); |
|
if ( pObj->GetTeamNumber() != iWinningTeam ) |
|
{ |
|
// Stop placing any carried objects or else they will float around |
|
// at our feet at the end of the round |
|
if( pObj->IsPlacing() ) |
|
{ |
|
pObj->StopPlacement(); |
|
} |
|
|
|
// Disable sentry guns that the losing team has built |
|
if( pObj->GetType() == OBJ_SENTRYGUN ) |
|
{ |
|
pObj->SetDisabled( true ); |
|
} |
|
} |
|
} |
|
|
|
if ( m_bForceMapReset ) |
|
{ |
|
m_iPrevRoundState = -1; |
|
m_iCurrentRoundState = -1; |
|
m_iCurrentMiniRoundMask = 0; |
|
} |
|
|
|
if ( IsInStopWatch() == true && GetStopWatchTimer() ) |
|
{ |
|
variant_t sVariant; |
|
GetStopWatchTimer()->AcceptInput( "Pause", NULL, NULL, sVariant, 0 ); |
|
|
|
if ( m_bForceMapReset ) |
|
{ |
|
if ( GetStopWatchTimer()->IsWatchingTimeStamps() == true ) |
|
{ |
|
m_flStopWatchTotalTime = GetStopWatchTimer()->GetStopWatchTotalTime(); |
|
} |
|
else |
|
{ |
|
ShouldResetScores( true, false ); |
|
UTIL_Remove( m_hStopWatchTimer ); |
|
m_hStopWatchTimer = NULL; |
|
m_flStopWatchTotalTime = -1.0f; |
|
m_bStopWatch = false; |
|
m_nStopWatchState.Set( STOPWATCH_CAPTURE_TIME_NOT_SET ); |
|
} |
|
} |
|
} |
|
|
|
#ifdef GAME_DLL |
|
if ( GetHalloweenScenario() == HALLOWEEN_SCENARIO_VIADUCT ) |
|
{ |
|
// send everyone to the underworld! |
|
BroadcastSound( 255, "Halloween.PlayerEscapedUnderworld" ); |
|
|
|
CUtlVector< CTFPlayer * > playerVector; |
|
CollectPlayers( &playerVector, TF_TEAM_RED, COLLECT_ONLY_LIVING_PLAYERS ); |
|
CollectPlayers( &playerVector, TF_TEAM_BLUE, COLLECT_ONLY_LIVING_PLAYERS, APPEND_PLAYERS ); |
|
|
|
CUtlVector< CBaseEntity * > spawnVector; |
|
|
|
CBaseEntity *spawnPoint = NULL; |
|
while( ( spawnPoint = gEntList.FindEntityByClassname( spawnPoint, "info_target" ) ) != NULL ) |
|
{ |
|
if ( FStrEq( STRING( spawnPoint->GetEntityName() ), "spawn_warcrimes" ) ) |
|
{ |
|
spawnVector.AddToTail( spawnPoint ); |
|
} |
|
} |
|
|
|
if ( spawnVector.Count() > 0 ) |
|
{ |
|
// shuffle the order of the spawns |
|
int n = spawnVector.Count(); |
|
while( n > 1 ) |
|
{ |
|
int k = RandomInt( 0, n-1 ); |
|
n--; |
|
|
|
CBaseEntity *tmp = spawnVector[n]; |
|
spawnVector[n] = spawnVector[k]; |
|
spawnVector[k] = tmp; |
|
} |
|
|
|
color32 fadeColor = { 255, 255, 255, 100 }; |
|
|
|
// send players to the underworld |
|
for( int i=0; i<playerVector.Count(); ++i ) |
|
{ |
|
CTFPlayer *player = playerVector[i]; |
|
|
|
player->SetLocalOrigin( spawnVector[n]->GetAbsOrigin() + Vector( 0, 0, 20.0f ) ); |
|
player->SetAbsVelocity( vec3_origin ); |
|
player->SetLocalAngles( spawnVector[n]->GetAbsAngles() ); |
|
player->m_Local.m_vecPunchAngle = vec3_angle; |
|
player->m_Local.m_vecPunchAngleVel = vec3_angle; |
|
player->SnapEyeAngles( spawnVector[n]->GetAbsAngles() ); |
|
|
|
// give them full health since purgatory damages them over time |
|
player->SetHealth( player->GetMaxHealth() ); |
|
|
|
UTIL_ScreenFade( player, fadeColor, 0.25, 0.4, FFADE_IN ); |
|
|
|
n = ( n + 1 ) % spawnVector.Count(); |
|
} |
|
} |
|
} |
|
#endif |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Helper function for scramble teams |
|
//----------------------------------------------------------------------------- |
|
int FindScoreDifferenceBetweenTeams( CUtlVector< CTFPlayer* > &vecSource, CTFPlayerResource *pPR, int &nRedScore, int &nBlueScore ) |
|
{ |
|
if ( !pPR ) |
|
return false; |
|
|
|
nRedScore = 0; |
|
nBlueScore = 0; |
|
|
|
FOR_EACH_VEC( vecSource, i ) |
|
{ |
|
if ( !vecSource[i] ) |
|
continue; |
|
|
|
if ( vecSource[i]->GetTeamNumber() == TF_TEAM_RED ) |
|
{ |
|
nRedScore += pPR->GetTotalScore( vecSource[i]->entindex() ); |
|
} |
|
else |
|
{ |
|
nBlueScore += pPR->GetTotalScore( vecSource[i]->entindex() ); |
|
} |
|
} |
|
|
|
return abs( nRedScore - nBlueScore ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Helper function for scramble teams |
|
//----------------------------------------------------------------------------- |
|
bool FindAndSwapPlayersToBalanceTeams( CUtlVector< CTFPlayer* > &vecSource, int &nDelta, CTFPlayerResource *pPR ) |
|
{ |
|
if ( !pPR ) |
|
return false; |
|
|
|
int nTeamScoreRed = 0; |
|
int nTeamScoreBlue = 0; |
|
FindScoreDifferenceBetweenTeams( vecSource, pPR, nTeamScoreRed, nTeamScoreBlue ); |
|
|
|
FOR_EACH_VEC( vecSource, i ) |
|
{ |
|
if ( !vecSource[i] ) |
|
continue; |
|
|
|
if ( vecSource[i]->GetTeamNumber() != TF_TEAM_RED ) |
|
continue; |
|
|
|
// Check against players on the other team |
|
FOR_EACH_VEC( vecSource, j ) |
|
{ |
|
if ( !vecSource[j] ) |
|
continue; |
|
|
|
if ( vecSource[j]->GetTeamNumber() != TF_TEAM_BLUE ) |
|
continue; |
|
|
|
if ( vecSource[i] == vecSource[j] ) |
|
continue; |
|
|
|
int nRedPlayerScore = pPR->GetTotalScore( vecSource[i]->entindex() ); |
|
int nBluePlayerScore = pPR->GetTotalScore( vecSource[j]->entindex() ); |
|
|
|
int nPlayerDiff = abs( nRedPlayerScore - nBluePlayerScore ); |
|
if ( nPlayerDiff ) |
|
{ |
|
int nNewRedScore = nTeamScoreRed; |
|
int nNewBlueScore = nTeamScoreBlue; |
|
|
|
if ( nRedPlayerScore > nBluePlayerScore ) |
|
{ |
|
nNewRedScore -= nPlayerDiff; |
|
nNewBlueScore += nPlayerDiff; |
|
} |
|
else |
|
{ |
|
nNewRedScore += nPlayerDiff; |
|
nNewBlueScore -= nPlayerDiff; |
|
} |
|
|
|
int nNewDelta = abs( nNewRedScore - nNewBlueScore ); |
|
if ( nNewDelta < nDelta ) |
|
{ |
|
// Swap and recheck |
|
vecSource[i]->ForceChangeTeam( TF_TEAM_BLUE ); |
|
vecSource[j]->ForceChangeTeam( TF_TEAM_RED ); |
|
|
|
nDelta = FindScoreDifferenceBetweenTeams( vecSource, pPR, nTeamScoreRed, nTeamScoreBlue ); |
|
return true; |
|
} |
|
} |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::HandleScrambleTeams( void ) |
|
{ |
|
static CUtlVector< CTFPlayer* > playerVector; |
|
playerVector.RemoveAll(); |
|
|
|
CollectPlayers( &playerVector, TF_TEAM_RED ); |
|
CollectPlayers( &playerVector, TF_TEAM_BLUE, false, APPEND_PLAYERS ); |
|
|
|
// Sort by player score. |
|
playerVector.Sort( ScramblePlayersSort ); |
|
|
|
// Put everyone on Spectator to clear the teams (or the autoteam step won't work correctly) |
|
FOR_EACH_VEC_BACK( playerVector, i ) |
|
{ |
|
if ( !playerVector[i] ) |
|
{ |
|
playerVector.Remove( i ); |
|
continue; |
|
} |
|
else if ( DuelMiniGame_IsInDuel( playerVector[i] ) ) // don't include them if they're in a duel |
|
{ |
|
playerVector.Remove( i ); |
|
continue; |
|
} |
|
|
|
playerVector[i]->ForceChangeTeam( TEAM_SPECTATOR ); |
|
} |
|
|
|
// Assign players using the original, quick method. |
|
FOR_EACH_VEC( playerVector, i ) |
|
{ |
|
if ( !playerVector[i] ) |
|
continue; |
|
|
|
if ( playerVector[i]->GetTeamNumber() >= FIRST_GAME_TEAM ) // are they already on a game team? |
|
continue; |
|
|
|
playerVector[i]->ForceChangeTeam( TF_TEAM_AUTOASSIGN ); |
|
} |
|
|
|
// New method |
|
if ( playerVector.Count() > 2 ) |
|
{ |
|
CTFPlayerResource *pPR = dynamic_cast< CTFPlayerResource* >( g_pPlayerResource ); |
|
if ( pPR ) |
|
{ |
|
int nTeamScoreRed = 0; |
|
int nTeamScoreBlue = 0; |
|
int nDelta = FindScoreDifferenceBetweenTeams( playerVector, pPR, nTeamScoreRed, nTeamScoreBlue ); |
|
|
|
#ifdef _DEBUG |
|
if ( mp_scrambleteams_debug.GetBool() ) |
|
{ |
|
DevMsg( "FIRST PASS -- Team1: %i || Team2: %i || Diff: %i\n", |
|
nTeamScoreRed, |
|
nTeamScoreBlue, |
|
nDelta ); |
|
} |
|
#endif // _DEBUG |
|
|
|
// Try swapping players to bring scores closer |
|
if ( nDelta > 1 ) |
|
{ |
|
int nOrigValue = mp_teams_unbalance_limit.GetInt(); |
|
mp_teams_unbalance_limit.SetValue( 0 ); |
|
|
|
static const int nPassLimit = 8; |
|
for ( int i = 0; i < nPassLimit && FindAndSwapPlayersToBalanceTeams( playerVector, nDelta, pPR ); ++i ) |
|
{ |
|
#ifdef _DEBUG |
|
if ( mp_scrambleteams_debug.GetBool() ) |
|
{ |
|
nTeamScoreRed = 0; |
|
nTeamScoreBlue = 0; |
|
DevMsg( "EXTRA PASS -- Team1: %i || Team2: %i || Diff: %i\n", |
|
nTeamScoreRed, |
|
nTeamScoreBlue, |
|
FindScoreDifferenceBetweenTeams( playerVector, pPR, nTeamScoreRed, nTeamScoreBlue ) ); |
|
} |
|
#endif // _DEBUG |
|
} |
|
|
|
mp_teams_unbalance_limit.SetValue( nOrigValue ); |
|
} |
|
} |
|
} |
|
|
|
// scrambleteams_auto tracking |
|
ResetTeamsRoundWinTracking(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::TeamPlayerCountChanged( CTFTeam *pTeam ) |
|
{ |
|
if ( m_hGamerulesProxy ) |
|
{ |
|
m_hGamerulesProxy->TeamPlayerCountChanged( pTeam ); |
|
} |
|
} |
|
|
|
|
|
#ifdef GAME_DLL |
|
//----------------------------------------------------------------------------- |
|
// Purpose: Should we attempt to roll into a new match for the current match |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::BAttemptMapVoteRollingMatch() |
|
{ |
|
if ( IsManagedMatchEnded() ) |
|
{ return false; } |
|
|
|
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() ); |
|
return pMatchDesc && GTFGCClientSystem()->CanRequestNewMatchForLobby() && pMatchDesc->BUsesMapVoteAfterMatchEnds(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::BIsManagedMatchEndImminent( void ) |
|
{ |
|
/* |
|
if ( IsCompetitiveMode() ) |
|
{ |
|
if ( State_Get() == GR_STATE_RND_RUNNING ) |
|
{ |
|
bool bPotentiallyTheFinalRound = ( CheckWinLimit( false, 1 ) || CheckMaxRounds( false, 1 ) ); |
|
if ( bPotentiallyTheFinalRound ) |
|
{ |
|
bool bPlayingMiniRounds = ( g_hControlPointMasters.Count() && g_hControlPointMasters[0] && g_hControlPointMasters[0]->PlayingMiniRounds() ); |
|
|
|
switch( m_nGameType ) |
|
{ |
|
case TF_GAMETYPE_ESCORT: |
|
{ |
|
if ( HasMultipleTrains() ) |
|
{ |
|
|
|
|
|
} |
|
else |
|
{ |
|
|
|
|
|
|
|
} |
|
} |
|
break; |
|
case TF_GAMETYPE_CP: |
|
|
|
break; |
|
case TF_GAMETYPE_CTF: |
|
if ( tf_flag_caps_per_round.GetInt() > 0 ) |
|
{ |
|
for ( int iTeam = TF_TEAM_RED; iTeam < TF_TEAM_COUNT; iTeam++ ) |
|
{ |
|
C_TFTeam *pTeam = GetGlobalTFTeam( iTeam ); |
|
if ( pTeam ) |
|
{ |
|
if ( ( tf_flag_caps_per_round.GetInt() - pTeam->GetFlagCaptures() ) <= 1 ) |
|
{ |
|
CCaptureFlag *pFlag = NULL; |
|
for ( int iFlag = 0; iFlag < ICaptureFlagAutoList::AutoList().Count(); ++iFlag ) |
|
{ |
|
pFlag = static_cast< CCaptureFlag* >( ICaptureFlagAutoList::AutoList()[iFlag] ); |
|
if ( !pFlag->IsDisabled() && ( pFlag->GetTeamNumber() == iTeam ) && !pFlag->IsHome() ) |
|
return true; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
break; |
|
default: |
|
break; |
|
} |
|
} |
|
} |
|
}*/ |
|
|
|
return false; |
|
} |
|
#endif // GAME_DLL |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::PowerupTeamImbalance( int nTeam ) |
|
{ |
|
if ( m_hGamerulesProxy ) |
|
{ |
|
m_hGamerulesProxy->PowerupTeamImbalance( nTeam ); |
|
|
|
if ( nTeam == TEAM_UNASSIGNED ) |
|
{ |
|
m_bPowerupImbalanceMeasuresRunning = false; |
|
} |
|
else |
|
{ |
|
m_bPowerupImbalanceMeasuresRunning = true; |
|
m_flTimeToStopImbalanceMeasures = gpGlobals->curtime + m_flTimeToRunImbalanceMeasures; |
|
|
|
BroadcastSound( nTeam, "Announcer.Powerup.Volume.Starting" ); |
|
CTeamRecipientFilter filter( nTeam, true ); |
|
UTIL_ClientPrintFilter( filter, HUD_PRINTCENTER, "#TF_Powerupvolume_Available" ); |
|
} |
|
|
|
m_nPowerupKillsBlueTeam = 0; // Reset both scores |
|
m_nPowerupKillsRedTeam = 0; |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Restrict team human players can join |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::GetAssignedHumanTeam( void ) |
|
{ |
|
if ( FStrEq( "blue", mp_humans_must_join_team.GetString() ) ) |
|
{ |
|
return TF_TEAM_BLUE; |
|
} |
|
else if ( FStrEq( "red", mp_humans_must_join_team.GetString() ) ) |
|
{ |
|
return TF_TEAM_RED; |
|
} |
|
else if ( FStrEq( "spectator", mp_humans_must_join_team.GetString() ) ) |
|
{ |
|
return TEAM_SPECTATOR; |
|
} |
|
else |
|
{ |
|
return TEAM_ANY; |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::HandleSwitchTeams( void ) |
|
{ |
|
if ( IsPVEModeActive() ) |
|
return; |
|
|
|
m_bTeamsSwitched.Set( !m_bTeamsSwitched ); |
|
|
|
// switch this as well |
|
if ( FStrEq( mp_humans_must_join_team.GetString(), "blue" ) ) |
|
{ |
|
mp_humans_must_join_team.SetValue( "red" ); |
|
} |
|
else if ( FStrEq( mp_humans_must_join_team.GetString(), "red" ) ) |
|
{ |
|
mp_humans_must_join_team.SetValue( "blue" ); |
|
} |
|
|
|
int i = 0; |
|
|
|
// remove everyone's projectiles and objects |
|
RemoveAllProjectilesAndBuildings(); |
|
|
|
// respawn the players |
|
for ( i = 1 ; i <= gpGlobals->maxClients ; i++ ) |
|
{ |
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
if ( pPlayer ) |
|
{ |
|
if ( pPlayer->GetTeamNumber() == TF_TEAM_RED ) |
|
{ |
|
pPlayer->ForceChangeTeam( TF_TEAM_BLUE, true ); |
|
} |
|
else if ( pPlayer->GetTeamNumber() == TF_TEAM_BLUE ) |
|
{ |
|
pPlayer->ForceChangeTeam( TF_TEAM_RED, true ); |
|
} |
|
} |
|
} |
|
|
|
// switch the team scores |
|
CTFTeam *pRedTeam = GetGlobalTFTeam( TF_TEAM_RED ); |
|
CTFTeam *pBlueTeam = GetGlobalTFTeam( TF_TEAM_BLUE ); |
|
if ( pRedTeam && pBlueTeam ) |
|
{ |
|
int nRed = pRedTeam->GetScore(); |
|
int nBlue = pBlueTeam->GetScore(); |
|
|
|
pRedTeam->SetScore( nBlue ); |
|
pBlueTeam->SetScore( nRed ); |
|
|
|
if ( IsInTournamentMode() == true ) |
|
{ |
|
char szBlueName[16]; |
|
char szRedName[16]; |
|
|
|
Q_strncpy( szBlueName, mp_tournament_blueteamname.GetString(), sizeof ( szBlueName ) ); |
|
Q_strncpy( szRedName, mp_tournament_redteamname.GetString(), sizeof ( szRedName ) ); |
|
|
|
mp_tournament_redteamname.SetValue( szBlueName ); |
|
mp_tournament_blueteamname.SetValue( szRedName ); |
|
} |
|
} |
|
|
|
UTIL_ClientPrintAll( HUD_PRINTTALK, "#TF_TeamsSwitched" ); |
|
|
|
CMatchInfo *pMatchInfo = GTFGCClientSystem()->GetMatch(); |
|
if ( pMatchInfo ) |
|
{ |
|
CTFPlayerResource *pTFResource = dynamic_cast< CTFPlayerResource* >( g_pPlayerResource ); |
|
if ( pTFResource ) |
|
{ |
|
uint32 unEventTeamStatus = pTFResource->GetEventTeamStatus(); |
|
|
|
if ( unEventTeamStatus && m_bTeamsSwitched ) |
|
{ |
|
const uint32 unInvadersArePyro = 1u; |
|
const uint32 unInvadersAreHeavy = 2u; |
|
unEventTeamStatus = ( unEventTeamStatus == unInvadersArePyro ) ? unInvadersAreHeavy : unInvadersArePyro; |
|
} |
|
|
|
pMatchInfo->m_unEventTeamStatus = unEventTeamStatus; |
|
} |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::CanChangeClassInStalemate( void ) |
|
{ |
|
return (gpGlobals->curtime < (m_flStalemateStartTime + tf_stalematechangeclasstime.GetFloat())); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::CanChangeTeam( int iCurrentTeam ) const |
|
{ |
|
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) ) |
|
{ |
|
if ( ( iCurrentTeam == TF_TEAM_RED ) || ( iCurrentTeam == TF_TEAM_BLUE ) ) |
|
{ |
|
return !ArePlayersInHell(); |
|
} |
|
} |
|
|
|
return true; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetRoundOverlayDetails( void ) |
|
{ |
|
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL; |
|
|
|
if ( pMaster && pMaster->PlayingMiniRounds() ) |
|
{ |
|
CTeamControlPointRound *pRound = pMaster->GetCurrentRound(); |
|
|
|
if ( pRound ) |
|
{ |
|
CHandle<CTeamControlPoint> pRedPoint = pRound->GetPointOwnedBy( TF_TEAM_RED ); |
|
CHandle<CTeamControlPoint> pBluePoint = pRound->GetPointOwnedBy( TF_TEAM_BLUE ); |
|
|
|
// do we have opposing points in this round? |
|
if ( pRedPoint && pBluePoint ) |
|
{ |
|
int iMiniRoundMask = ( 1<<pBluePoint->GetPointIndex() ) | ( 1<<pRedPoint->GetPointIndex() ); |
|
SetMiniRoundBitMask( iMiniRoundMask ); |
|
} |
|
else |
|
{ |
|
SetMiniRoundBitMask( 0 ); |
|
} |
|
|
|
SetCurrentRoundStateBitString(); |
|
} |
|
} |
|
|
|
BaseClass::SetRoundOverlayDetails(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Returns whether a team should score for each captured point |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::ShouldScorePerRound( void ) |
|
{ |
|
bool bRetVal = true; |
|
|
|
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL; |
|
if ( pMaster && pMaster->ShouldScorePerCapture() ) |
|
{ |
|
bRetVal = false; |
|
} |
|
|
|
return bRetVal; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::IsValveMap( void ) |
|
{ |
|
char szCurrentMap[MAX_MAP_NAME]; |
|
Q_strncpy( szCurrentMap, STRING( gpGlobals->mapname ), sizeof( szCurrentMap ) ); |
|
|
|
if ( ::IsValveMap( szCurrentMap ) ) |
|
{ |
|
return true; |
|
} |
|
|
|
return BaseClass::IsValveMap(); |
|
} |
|
|
|
void CTFGameRules::PlayTrainCaptureAlert( CTeamControlPoint *pPoint, bool bFinalPointInMap ) |
|
{ |
|
if ( !pPoint ) |
|
return; |
|
|
|
if ( State_Get() != GR_STATE_RND_RUNNING ) |
|
return; |
|
|
|
const char *pszAlert = TEAM_TRAIN_ALERT; |
|
|
|
// is this the final control point in the map? |
|
if ( bFinalPointInMap ) |
|
{ |
|
pszAlert = TEAM_TRAIN_FINAL_ALERT; |
|
} |
|
|
|
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) ) |
|
{ |
|
if ( bFinalPointInMap ) |
|
{ |
|
int iWinningTeam = TEAM_UNASSIGNED; |
|
float flRedProgress = 0.0f, flBlueProgress = 0.0f; |
|
for ( int i = 0 ; i < ITFTeamTrainWatcher::AutoList().Count() ; ++i ) |
|
{ |
|
CTeamTrainWatcher *pTrainWatcher = static_cast< CTeamTrainWatcher* >( ITFTeamTrainWatcher::AutoList()[i] ); |
|
if ( !pTrainWatcher->IsDisabled() ) |
|
{ |
|
if ( pTrainWatcher->GetTeamNumber() == TF_TEAM_RED ) |
|
{ |
|
flRedProgress = pTrainWatcher->GetTrainDistanceAlongTrack(); |
|
} |
|
else |
|
{ |
|
flBlueProgress = pTrainWatcher->GetTrainDistanceAlongTrack(); |
|
} |
|
} |
|
} |
|
|
|
if ( flRedProgress > flBlueProgress ) |
|
{ |
|
iWinningTeam = TF_TEAM_RED; |
|
} |
|
else if ( flBlueProgress > flRedProgress ) |
|
{ |
|
iWinningTeam = TF_TEAM_BLUE; |
|
} |
|
|
|
if ( iWinningTeam != TEAM_UNASSIGNED ) |
|
{ |
|
int iRedLine, iBlueLine; |
|
iRedLine = ( iWinningTeam == TF_TEAM_RED ) ? HELLTOWER_VO_RED_NEAR_WIN : HELLTOWER_VO_RED_NEAR_LOSE; |
|
iBlueLine = ( iWinningTeam == TF_TEAM_BLUE ) ? HELLTOWER_VO_BLUE_NEAR_WIN : HELLTOWER_VO_BLUE_NEAR_LOSE; |
|
PlayHelltowerAnnouncerVO( iRedLine, iBlueLine ); |
|
} |
|
} |
|
return; |
|
} |
|
|
|
CBroadcastRecipientFilter filter; |
|
pPoint->EmitSound( filter, pPoint->entindex(), pszAlert ); |
|
} |
|
|
|
#endif // GAME_DLL |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::GetFarthestOwnedControlPoint( int iTeam, bool bWithSpawnpoints ) |
|
{ |
|
int iOwnedEnd = ObjectiveResource()->GetBaseControlPointForTeam( iTeam ); |
|
if ( iOwnedEnd == -1 ) |
|
return -1; |
|
|
|
int iNumControlPoints = ObjectiveResource()->GetNumControlPoints(); |
|
int iWalk = 1; |
|
int iEnemyEnd = iNumControlPoints-1; |
|
if ( iOwnedEnd != 0 ) |
|
{ |
|
iWalk = -1; |
|
iEnemyEnd = 0; |
|
} |
|
|
|
// Walk towards the other side, and find the farthest owned point that has spawn points |
|
int iFarthestPoint = iOwnedEnd; |
|
for ( int iPoint = iOwnedEnd; iPoint != iEnemyEnd; iPoint += iWalk ) |
|
{ |
|
// If we've hit a point we don't own, we're done |
|
if ( ObjectiveResource()->GetOwningTeam( iPoint ) != iTeam ) |
|
break; |
|
|
|
if ( bWithSpawnpoints && !m_bControlSpawnsPerTeam[iTeam][iPoint] ) |
|
continue; |
|
|
|
iFarthestPoint = iPoint; |
|
} |
|
|
|
return iFarthestPoint; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::TeamMayCapturePoint( int iTeam, int iPointIndex ) |
|
{ |
|
if ( !tf_caplinear.GetBool() ) |
|
return true; |
|
|
|
// Any previous points necessary? |
|
int iPointNeeded = ObjectiveResource()->GetPreviousPointForPoint( iPointIndex, iTeam, 0 ); |
|
|
|
// Points set to require themselves are always cappable |
|
if ( iPointNeeded == iPointIndex ) |
|
return true; |
|
|
|
if ( IsInKothMode() && IsInWaitingForPlayers() ) |
|
return false; |
|
|
|
// Is the point locked? |
|
if ( ObjectiveResource()->GetCPLocked( iPointIndex ) ) |
|
return false; |
|
|
|
// No required points specified? Require all previous points. |
|
if ( iPointNeeded == -1 ) |
|
{ |
|
if ( IsInArenaMode() == true ) |
|
{ |
|
|
|
#ifdef CLIENT_DLL |
|
|
|
if ( m_flCapturePointEnableTime - 5.0f <= gpGlobals->curtime && State_Get() == GR_STATE_STALEMATE ) |
|
return true; |
|
#endif |
|
|
|
if ( m_flCapturePointEnableTime <= gpGlobals->curtime && State_Get() == GR_STATE_STALEMATE ) |
|
return true; |
|
|
|
return false; |
|
} |
|
|
|
if ( !ObjectiveResource()->PlayingMiniRounds() ) |
|
{ |
|
// No custom previous point, team must own all previous points |
|
int iFarthestPoint = GetFarthestOwnedControlPoint( iTeam, false ); |
|
return (abs(iFarthestPoint - iPointIndex) <= 1); |
|
} |
|
else |
|
{ |
|
// No custom previous point, team must own all previous points in the current mini-round |
|
//tagES TFTODO: need to figure out a good algorithm for this |
|
return true; |
|
} |
|
} |
|
|
|
// Loop through each previous point and see if the team owns it |
|
for ( int iPrevPoint = 0; iPrevPoint < MAX_PREVIOUS_POINTS; iPrevPoint++ ) |
|
{ |
|
iPointNeeded = ObjectiveResource()->GetPreviousPointForPoint( iPointIndex, iTeam, iPrevPoint ); |
|
if ( iPointNeeded != -1 ) |
|
{ |
|
if ( ObjectiveResource()->GetOwningTeam( iPointNeeded ) != iTeam ) |
|
return false; |
|
} |
|
} |
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::PlayerMayCapturePoint( CBasePlayer *pPlayer, int iPointIndex, char *pszReason /* = NULL */, int iMaxReasonLength /* = 0 */ ) |
|
{ |
|
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer ); |
|
|
|
if ( !pTFPlayer ) |
|
{ |
|
return false; |
|
} |
|
|
|
// Disguised and invisible spies cannot capture points |
|
if ( pTFPlayer->m_Shared.IsStealthed() ) |
|
{ |
|
if ( pszReason ) |
|
{ |
|
Q_snprintf( pszReason, iMaxReasonLength, "#Cant_cap_stealthed" ); |
|
} |
|
return false; |
|
} |
|
|
|
if ( ( pTFPlayer->m_Shared.IsInvulnerable() || pTFPlayer->m_Shared.InCond( TF_COND_MEGAHEAL ) ) && !pTFPlayer->m_bInPowerPlay && !IsMannVsMachineMode() ) |
|
{ |
|
if ( pszReason ) |
|
{ |
|
Q_snprintf( pszReason, iMaxReasonLength, "#Cant_cap_invuln" ); |
|
} |
|
return false; |
|
} |
|
|
|
if ( pTFPlayer->m_Shared.InCond( TF_COND_PHASE ) ) |
|
{ |
|
if ( pszReason ) |
|
{ |
|
Q_snprintf( pszReason, iMaxReasonLength, "#Cant_cap_invuln" ); |
|
} |
|
|
|
return false; |
|
} |
|
|
|
if ( pTFPlayer->m_Shared.IsControlStunned() ) |
|
{ |
|
if ( pszReason ) |
|
{ |
|
Q_snprintf( pszReason, iMaxReasonLength, "#Cant_cap_stunned" ); |
|
} |
|
|
|
return false; |
|
} |
|
|
|
// spies disguised as the enemy team cannot capture points |
|
if ( pTFPlayer->m_Shared.InCond( TF_COND_DISGUISED ) && pTFPlayer->m_Shared.GetDisguiseTeam() != pTFPlayer->GetTeamNumber() ) |
|
{ |
|
if ( pszReason ) |
|
{ |
|
Q_snprintf( pszReason, iMaxReasonLength, "#Cant_cap_disguised" ); |
|
} |
|
return false; |
|
} |
|
|
|
#ifdef GAME_DLL |
|
if ( IsInTraining() && pTFPlayer->IsBotOfType( TF_BOT_TYPE ) ) |
|
{ |
|
switch( GetGameType() ) |
|
{ |
|
case TF_GAMETYPE_CP: |
|
{ |
|
// in training mode, bots cannot initiate a capture |
|
float flCapPerc = ObjectiveResource()->GetCPCapPercentage( iPointIndex ); |
|
if ( flCapPerc <= 0.0f ) |
|
{ |
|
return false; |
|
} |
|
break; |
|
} |
|
|
|
case TF_GAMETYPE_ESCORT: |
|
{ |
|
// in training mode, the player must push the cart for the first time |
|
// after that, bots can start it moving again |
|
|
|
// assume only one cart in the map |
|
CTeamTrainWatcher *watcher = NULL; |
|
while( ( watcher = dynamic_cast< CTeamTrainWatcher * >( gEntList.FindEntityByClassname( watcher, "team_train_watcher" ) ) ) != NULL ) |
|
{ |
|
if ( !watcher->IsDisabled() ) |
|
{ |
|
break; |
|
} |
|
} |
|
|
|
if ( watcher && !watcher->IsDisabled() ) |
|
{ |
|
return !watcher->IsTrainAtStart(); |
|
} |
|
break; |
|
} |
|
} |
|
} |
|
|
|
#ifdef TF_CREEP_MODE |
|
if ( IsCreepWaveMode() ) |
|
{ |
|
CTFBot *bot = ToTFBot( pTFPlayer ); |
|
|
|
if ( !bot || !bot->HasAttribute( CTFBot::IS_NPC ) ) |
|
{ |
|
// only creeps can capture points |
|
return false; |
|
} |
|
} |
|
#endif |
|
|
|
#endif |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::PlayerMayBlockPoint( CBasePlayer *pPlayer, int iPointIndex, char *pszReason, int iMaxReasonLength ) |
|
{ |
|
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer ); |
|
if ( !pTFPlayer ) |
|
return false; |
|
|
|
#ifdef GAME_DLL |
|
#ifdef TF_CREEP_MODE |
|
if ( IsCreepWaveMode() ) |
|
{ |
|
CTFBot *bot = ToTFBot( pTFPlayer ); |
|
|
|
if ( !bot || !bot->HasAttribute( CTFBot::IS_NPC ) ) |
|
{ |
|
// only creeps can block points |
|
return false; |
|
} |
|
} |
|
#endif |
|
#endif |
|
|
|
// Invuln players can block points |
|
if ( pTFPlayer->m_Shared.IsInvulnerable() ) |
|
{ |
|
if ( pszReason ) |
|
{ |
|
Q_snprintf( pszReason, iMaxReasonLength, "#Cant_cap_invuln" ); |
|
} |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Calculates score for player |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::CalcPlayerScore( RoundStats_t *pRoundStats, CTFPlayer *pPlayer ) |
|
{ |
|
Assert( pRoundStats ); |
|
if ( !pRoundStats ) |
|
return 0; |
|
|
|
// defensive fix for the moment for bug where healing value becomes bogus sometimes: if bogus, slam it to 0 |
|
int iHealing = pRoundStats->m_iStat[TFSTAT_HEALING]; |
|
Assert( iHealing >= 0 ); |
|
Assert( iHealing <= 10000000 ); |
|
if ( iHealing < 0 || iHealing > 10000000 ) |
|
{ |
|
iHealing = 0; |
|
} |
|
|
|
bool bMvM = TFGameRules() && TFGameRules()->IsMannVsMachineMode(); |
|
bool bPowerupMode = TFGameRules() && TFGameRules()->IsPowerupMode(); |
|
|
|
int iScore = ( pRoundStats->m_iStat[TFSTAT_KILLS] * TF_SCORE_KILL ) + |
|
( pRoundStats->m_iStat[TFSTAT_KILLS_RUNECARRIER] * TF_SCORE_KILL_RUNECARRIER ) + // Kill someone who is carrying a rune |
|
( pRoundStats->m_iStat[TFSTAT_CAPTURES] * ( ( bPowerupMode ) ? TF_SCORE_CAPTURE_POWERUPMODE : TF_SCORE_CAPTURE ) ) + |
|
( pRoundStats->m_iStat[TFSTAT_FLAGRETURNS] * TF_SCORE_FLAG_RETURN ) + |
|
( pRoundStats->m_iStat[TFSTAT_DEFENSES] * TF_SCORE_DEFEND ) + |
|
( pRoundStats->m_iStat[TFSTAT_BUILDINGSDESTROYED] * TF_SCORE_DESTROY_BUILDING ) + |
|
( pRoundStats->m_iStat[TFSTAT_HEADSHOTS] / TF_SCORE_HEADSHOT_DIVISOR ) + |
|
( pRoundStats->m_iStat[TFSTAT_BACKSTABS] * TF_SCORE_BACKSTAB ) + |
|
( iHealing / ( ( bMvM ) ? TF_SCORE_DAMAGE : TF_SCORE_HEAL_HEALTHUNITS_PER_POINT ) ) + // MvM values healing more than PvP |
|
( pRoundStats->m_iStat[TFSTAT_KILLASSISTS] / TF_SCORE_KILL_ASSISTS_PER_POINT ) + |
|
( pRoundStats->m_iStat[TFSTAT_TELEPORTS] / TF_SCORE_TELEPORTS_PER_POINT ) + |
|
( pRoundStats->m_iStat[TFSTAT_INVULNS] / TF_SCORE_INVULN ) + |
|
( pRoundStats->m_iStat[TFSTAT_REVENGE] / TF_SCORE_REVENGE ) + |
|
( pRoundStats->m_iStat[TFSTAT_BONUS_POINTS] / TF_SCORE_BONUS_POINT_DIVISOR ); |
|
( pRoundStats->m_iStat[TFSTAT_CURRENCY_COLLECTED] / TF_SCORE_CURRENCY_COLLECTED ); |
|
|
|
if ( pPlayer ) |
|
{ |
|
int nScoreboardMinigame = 0; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer, nScoreboardMinigame, scoreboard_minigame ); |
|
if ( nScoreboardMinigame > 0 ) |
|
{ |
|
// Increment Score |
|
iScore += |
|
( pRoundStats->m_iStat[TFSTAT_KILLS] ) + |
|
( pRoundStats->m_iStat[TFSTAT_CAPTURES] ) + |
|
( pRoundStats->m_iStat[TFSTAT_DEFENSES] ) + |
|
( pRoundStats->m_iStat[TFSTAT_BUILDINGSDESTROYED] ); |
|
|
|
// Subtract Deaths |
|
iScore -= pRoundStats->m_iStat[TFSTAT_DEATHS] * 3; |
|
} |
|
} |
|
|
|
// Previously MvM-only |
|
const int nDivisor = ( bMvM ) ? TF_SCORE_DAMAGE : TF_SCORE_HEAL_HEALTHUNITS_PER_POINT; |
|
iScore += ( pRoundStats->m_iStat[TFSTAT_DAMAGE] / nDivisor ); |
|
iScore += ( pRoundStats->m_iStat[TFSTAT_DAMAGE_ASSIST] / nDivisor ); |
|
iScore += ( pRoundStats->m_iStat[TFSTAT_DAMAGE_BOSS] / nDivisor ); |
|
iScore += ( pRoundStats->m_iStat[TFSTAT_HEALING_ASSIST] / nDivisor ); |
|
iScore += ( pRoundStats->m_iStat[TFSTAT_DAMAGE_BLOCKED] / nDivisor ); |
|
|
|
return Max( iScore, 0 ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Calculates score for player |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::CalcPlayerSupportScore( RoundStats_t *pRoundStats, int iPlayerIdx ) |
|
{ |
|
#ifdef GAME_DLL |
|
Assert( pRoundStats ); |
|
if ( !pRoundStats ) |
|
return 0; |
|
|
|
return ( pRoundStats->m_iStat[TFSTAT_DAMAGE_ASSIST] + |
|
pRoundStats->m_iStat[TFSTAT_HEALING_ASSIST] + |
|
pRoundStats->m_iStat[TFSTAT_DAMAGE_BLOCKED] + |
|
( pRoundStats->m_iStat[TFSTAT_BONUS_POINTS] * 25 ) ); |
|
#else |
|
Assert( g_TF_PR ); |
|
if ( !g_TF_PR ) |
|
return 0; |
|
|
|
return g_TF_PR->GetDamageAssist( iPlayerIdx ) + |
|
g_TF_PR->GetHealingAssist( iPlayerIdx ) + |
|
g_TF_PR->GetDamageBlocked( iPlayerIdx ) + |
|
( g_TF_PR->GetBonusPoints( iPlayerIdx ) * 25 ); |
|
#endif |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::IsBirthday( void ) const |
|
{ |
|
if ( IsX360() ) |
|
return false; |
|
|
|
return tf_birthday.GetBool() || IsHolidayActive( kHoliday_TFBirthday ); |
|
} |
|
|
|
bool CTFGameRules::IsBirthdayOrPyroVision( void ) const |
|
{ |
|
if ( IsBirthday() ) |
|
return true; |
|
|
|
#ifdef CLIENT_DLL |
|
// Use birthday fun if the local player has an item that allows them to see it (Pyro Goggles) |
|
if ( IsLocalPlayerUsingVisionFilterFlags( TF_VISION_FILTER_PYRO ) ) |
|
{ |
|
return true; |
|
} |
|
#endif |
|
|
|
return false; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::IsHolidayActive( /*EHoliday*/ int eHoliday ) const |
|
{ |
|
//if ( IsPVEModeActive() ) |
|
// return false; |
|
|
|
return TF_IsHolidayActive( eHoliday ); |
|
} |
|
|
|
#ifndef GAME_DLL |
|
void CTFGameRules::SetUpVisionFilterKeyValues( void ) |
|
{ |
|
m_pkvVisionFilterShadersMapWhitelist = new KeyValues( "VisionFilterShadersMapWhitelist" ); |
|
m_pkvVisionFilterShadersMapWhitelist->LoadFromFile( g_pFullFileSystem, "cfg/mtp.cfg", "MOD" ); |
|
|
|
m_pkvVisionFilterTranslations = new KeyValues( "VisionFilterTranslations" ); |
|
|
|
// ************************************************************************************************** |
|
// PARTICLES |
|
KeyValues *pKVBlock = new KeyValues( "particles" ); |
|
m_pkvVisionFilterTranslations->AddSubKey( pKVBlock ); |
|
|
|
// No special vision |
|
KeyValues *pKVFlag = new KeyValues( "0" ); |
|
pKVFlag->SetString( "flamethrower_rainbow", "flamethrower" ); |
|
pKVFlag->SetString( "flamethrower_rainbow_FP", "flamethrower" ); |
|
pKVBlock->AddSubKey( pKVFlag ); |
|
|
|
// Pyrovision |
|
pKVFlag = new KeyValues( "1" ); //TF_VISION_FILTER_PYRO |
|
pKVFlag->SetString( "flamethrower_rainbow", "flamethrower_rainbow" ); // Rainblower defaults to rainbows and we want to ensure that we use it |
|
pKVFlag->SetString( "flamethrower_rainbow_FP", "flamethrower_rainbow_FP" ); |
|
pKVFlag->SetString( "burningplayer_blue", "burningplayer_rainbow_blue" ); |
|
pKVFlag->SetString( "burningplayer_red", "burningplayer_rainbow_red" ); |
|
pKVFlag->SetString( "burningplayer_corpse", "burningplayer_corpse_rainbow" ); |
|
pKVFlag->SetString( "water_blood_impact_red_01", "pyrovision_blood" ); |
|
pKVFlag->SetString( "blood_impact_red_01", "pyrovision_blood" ); |
|
pKVFlag->SetString( "blood_spray_red_01", "pyrovision_blood" ); |
|
pKVFlag->SetString( "blood_spray_red_01_far", "pyrovision_blood" ); |
|
pKVFlag->SetString( "ExplosionCore_wall", "pyrovision_explosion" ); |
|
pKVFlag->SetString( "ExplosionCore_buildings", "pyrovision_explosion" ); |
|
pKVFlag->SetString( "ExplosionCore_MidAir", "pyrovision_explosion" ); |
|
pKVFlag->SetString( "rockettrail", "pyrovision_rockettrail" ); |
|
pKVFlag->SetString( "rockettrail_!", "pyrovision_rockettrail" ); |
|
pKVFlag->SetString( "sentry_rocket", "pyrovision_rockettrail" ); |
|
pKVFlag->SetString( "flaregun_trail_blue", "pyrovision_flaregun_trail_blue" ); |
|
pKVFlag->SetString( "flaregun_trail_red", "pyrovision_flaregun_trail_red" ); |
|
pKVFlag->SetString( "flaregun_trail_crit_blue", "pyrovision_flaregun_trail_crit_blue" ); |
|
pKVFlag->SetString( "flaregun_trail_crit_red", "pyrovision_flaregun_trail_crit_red" ); |
|
pKVFlag->SetString( "flaregun_destroyed", "pyrovision_flaregun_destroyed" ); |
|
pKVFlag->SetString( "scorchshot_trail_blue", "pyrovision_scorchshot_trail_blue" ); |
|
pKVFlag->SetString( "scorchshot_trail_red", "pyrovision_scorchshot_trail_red" ); |
|
pKVFlag->SetString( "scorchshot_trail_crit_blue", "pyrovision_scorchshot_trail_crit_blue" ); |
|
pKVFlag->SetString( "scorchshot_trail_crit_red", "pyrovision_scorchshot_trail_crit_red" ); |
|
pKVFlag->SetString( "ExplosionCore_MidAir_Flare", "pyrovision_flaregun_destroyed" ); |
|
pKVFlag->SetString( "pyrotaunt_rainbow_norainbow", "pyrotaunt_rainbow" ); |
|
pKVFlag->SetString( "pyrotaunt_rainbow_bubbles_flame", "pyrotaunt_rainbow_bubbles" ); |
|
pKVFlag->SetString( "v_flaming_arrow", "pyrovision_v_flaming_arrow" ); |
|
pKVFlag->SetString( "flaming_arrow", "pyrovision_flaming_arrow" ); |
|
pKVFlag->SetString( "flying_flaming_arrow", "pyrovision_flying_flaming_arrow" ); |
|
pKVFlag->SetString( "taunt_pyro_balloon", "taunt_pyro_balloon_vision" ); |
|
pKVFlag->SetString( "taunt_pyro_balloon_explosion", "taunt_pyro_balloon_explosion_vision" ); |
|
|
|
pKVBlock->AddSubKey( pKVFlag ); |
|
|
|
//// Spooky Vision |
|
//pKVFlag = new KeyValues( "2" ); //TF_VISION_FILTER_HALLOWEEN |
|
//pKVBlock->AddSubKey( pKVFlag ); |
|
|
|
// ************************************************************************************************** |
|
// SOUNDS |
|
pKVBlock = new KeyValues( "sounds" ); |
|
m_pkvVisionFilterTranslations->AddSubKey( pKVBlock ); |
|
|
|
// No special vision |
|
pKVFlag = new KeyValues( "0" ); |
|
pKVFlag->SetString( "weapons/rainblower/rainblower_start.wav", "weapons/flame_thrower_start.wav" ); |
|
pKVFlag->SetString( "weapons/rainblower/rainblower_loop.wav", "weapons/flame_thrower_loop.wav" ); |
|
pKVFlag->SetString( "weapons/rainblower/rainblower_end.wav", "weapons/flame_thrower_end.wav" ); |
|
pKVFlag->SetString( "weapons/rainblower/rainblower_hit.wav", "weapons/flame_thrower_fire_hit.wav" ); |
|
pKVFlag->SetString( "weapons/rainblower/rainblower_pilot.wav", "weapons/flame_thrower_pilot.wav" ); |
|
pKVFlag->SetString( ")weapons/rainblower/rainblower_start.wav", ")weapons/flame_thrower_start.wav" ); |
|
pKVFlag->SetString( ")weapons/rainblower/rainblower_loop.wav", ")weapons/flame_thrower_loop.wav" ); |
|
pKVFlag->SetString( ")weapons/rainblower/rainblower_end.wav", ")weapons/flame_thrower_end.wav" ); |
|
pKVFlag->SetString( ")weapons/rainblower/rainblower_hit.wav", ")weapons/flame_thrower_fire_hit.wav" ); |
|
pKVFlag->SetString( ")weapons/rainblower/rainblower_pilot.wav", "weapons/flame_thrower_pilot.wav" ); |
|
pKVFlag->SetString( "Weapon_Rainblower.Fire", "Weapon_FlameThrower.Fire" ); |
|
pKVFlag->SetString( "Weapon_Rainblower.FireLoop", "Weapon_FlameThrower.FireLoop" ); |
|
pKVFlag->SetString( "Weapon_Rainblower.WindDown", "Weapon_FlameThrower.WindDown" ); |
|
pKVFlag->SetString( "Weapon_Rainblower.FireHit", "Weapon_FlameThrower.FireHit" ); |
|
pKVFlag->SetString( "Weapon_Rainblower.PilotLoop", "Weapon_FlameThrower.PilotLoop" ); |
|
pKVFlag->SetString( "Taunt.PyroBalloonicorn", "Taunt.PyroHellicorn" ); |
|
pKVFlag->SetString( ")items/pyro_music_tube.wav", "common/null.wav" ); |
|
pKVBlock->AddSubKey( pKVFlag ); |
|
|
|
// Pyrovision |
|
pKVFlag = new KeyValues( "1" ); //TF_VISION_FILTER_PYRO |
|
pKVFlag->SetString( "weapons/rainblower/rainblower_start.wav", "weapons/rainblower/rainblower_start.wav" ); // If we're in PyroVision, explicitly set to ensure this is saved |
|
pKVFlag->SetString( "weapons/rainblower/rainblower_loop.wav", "weapons/rainblower/rainblower_loop.wav" ); |
|
pKVFlag->SetString( "weapons/rainblower/rainblower_end.wav", "weapons/rainblower/rainblower_end.wav" ); |
|
pKVFlag->SetString( "weapons/rainblower/rainblower_hit.wav", "weapons/rainblower/rainblower_hit.wav" ); |
|
pKVFlag->SetString( "weapons/rainblower/rainblower_pilot.wav", "weapons/rainblower/rainblower_pilot.wav" ); |
|
pKVFlag->SetString( ")weapons/rainblower/rainblower_start.wav", ")weapons/rainblower/rainblower_start.wav" ); |
|
pKVFlag->SetString( ")weapons/rainblower/rainblower_loop.wav", ")weapons/rainblower/rainblower_loop.wav" ); |
|
pKVFlag->SetString( ")weapons/rainblower/rainblower_end.wav", ")weapons/rainblower/rainblower_end.wav" ); |
|
pKVFlag->SetString( ")weapons/rainblower/rainblower_hit.wav", ")weapons/rainblower/rainblower_hit.wav" ); |
|
pKVFlag->SetString( ")weapons/rainblower/rainblower_pilot.wav", ")weapons/rainblower/rainblower_pilot.wav" ); |
|
pKVFlag->SetString( "Weapon_Rainblower.Fire", "Weapon_Rainblower.Fire" ); |
|
pKVFlag->SetString( "Weapon_Rainblower.FireLoop", "Weapon_Rainblower.FireLoop" ); |
|
pKVFlag->SetString( "Weapon_Rainblower.WindDown", "Weapon_Rainblower.WindDown" ); |
|
pKVFlag->SetString( "Weapon_Rainblower.FireHit", "Weapon_Rainblower.FireHit" ); |
|
pKVFlag->SetString( "Weapon_Rainblower.PilotLoop", "Weapon_Rainblower.PilotLoop" ); |
|
pKVFlag->SetString( "Taunt.PyroBalloonicorn", "Taunt.PyroBalloonicorn" ); |
|
pKVFlag->SetString( ")items/pyro_music_tube.wav", ")items/pyro_music_tube.wav" ); |
|
|
|
pKVFlag->SetString( "vo/demoman_PainCrticialDeath01.mp3", "vo/demoman_LaughLong01.mp3" ); |
|
pKVFlag->SetString( "vo/demoman_PainCrticialDeath02.mp3", "vo/demoman_LaughLong02.mp3" ); |
|
pKVFlag->SetString( "vo/demoman_PainCrticialDeath03.mp3", "vo/demoman_LaughLong01.mp3" ); |
|
pKVFlag->SetString( "vo/demoman_PainCrticialDeath04.mp3", "vo/demoman_LaughLong02.mp3" ); |
|
pKVFlag->SetString( "vo/demoman_PainCrticialDeath05.mp3", "vo/demoman_LaughLong01.mp3" ); |
|
pKVFlag->SetString( "vo/demoman_PainSevere01.mp3", "vo/demoman_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/demoman_PainSevere02.mp3", "vo/demoman_LaughHappy02.mp3" ); |
|
pKVFlag->SetString( "vo/demoman_PainSevere03.mp3", "vo/demoman_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/demoman_PainSevere04.mp3", "vo/demoman_LaughHappy02.mp3" ); |
|
pKVFlag->SetString( "vo/demoman_PainSharp01.mp3", "vo/demoman_LaughShort01.mp3" ); |
|
pKVFlag->SetString( "vo/demoman_PainSharp02.mp3", "vo/demoman_LaughShort02.mp3" ); |
|
pKVFlag->SetString( "vo/demoman_PainSharp03.mp3", "vo/demoman_LaughShort03.mp3" ); |
|
pKVFlag->SetString( "vo/demoman_PainSharp04.mp3", "vo/demoman_LaughShort04.mp3" ); |
|
pKVFlag->SetString( "vo/demoman_PainSharp05.mp3", "vo/demoman_LaughShort05.mp3" ); |
|
pKVFlag->SetString( "vo/demoman_PainSharp06.mp3", "vo/demoman_LaughShort06.mp3" ); |
|
pKVFlag->SetString( "vo/demoman_PainSharp07.mp3", "vo/demoman_LaughShort01.mp3" ); |
|
pKVFlag->SetString( "vo/demoman_AutoOnFire01.mp3", "vo/demoman_PositiveVocalization02.mp3" ); |
|
pKVFlag->SetString( "vo/demoman_AutoOnFire02.mp3", "vo/demoman_PositiveVocalization03.mp3" ); |
|
pKVFlag->SetString( "vo/demoman_AutoOnFire03.mp3", "vo/demoman_PositiveVocalization04.mp3" ); |
|
|
|
pKVFlag->SetString( "vo/engineer_PainCrticialDeath01.mp3", "vo/engineer_LaughLong01.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_PainCrticialDeath02.mp3", "vo/engineer_LaughLong02.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_PainCrticialDeath03.mp3", "vo/engineer_LaughLong01.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_PainCrticialDeath04.mp3", "vo/engineer_LaughLong02.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_PainCrticialDeath05.mp3", "vo/engineer_LaughLong01.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_PainCrticialDeath06.mp3", "vo/engineer_LaughLong02.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_PainSevere01.mp3", "vo/engineer_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_PainSevere02.mp3", "vo/engineer_LaughHappy02.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_PainSevere03.mp3", "vo/engineer_LaughHappy03.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_PainSevere04.mp3", "vo/engineer_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_PainSevere05.mp3", "vo/engineer_LaughHappy02.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_PainSevere06.mp3", "vo/engineer_LaughHappy03.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_PainSevere07.mp3", "vo/engineer_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_PainSharp01.mp3", "vo/engineer_LaughShort01.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_PainSharp02.mp3", "vo/engineer_LaughShort02.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_PainSharp03.mp3", "vo/engineer_LaughShort03.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_PainSharp04.mp3", "vo/engineer_LaughShort04.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_PainSharp05.mp3", "vo/engineer_LaughShort01.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_PainSharp06.mp3", "vo/engineer_LaughShort02.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_PainSharp07.mp3", "vo/engineer_LaughShort03.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_PainSharp08.mp3", "vo/engineer_LaughShort04.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_AutoOnFire01.mp3", "vo/engineer_PositiveVocalization01.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_AutoOnFire02.mp3", "vo/engineer_Cheers01.mp3" ); |
|
pKVFlag->SetString( "vo/engineer_AutoOnFire03.mp3", "vo/engineer_Cheers02.mp3" ); |
|
|
|
pKVFlag->SetString( "vo/heavy_PainCrticialDeath01.mp3", "vo/heavy_LaughLong01.mp3" ); |
|
pKVFlag->SetString( "vo/heavy_PainCrticialDeath02.mp3", "vo/heavy_LaughLong02.mp3" ); |
|
pKVFlag->SetString( "vo/heavy_PainCrticialDeath03.mp3", "vo/heavy_LaughLong02.mp3" ); |
|
pKVFlag->SetString( "vo/heavy_PainSevere01.mp3", "vo/heavy_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/heavy_PainSevere02.mp3", "vo/heavy_LaughHappy02.mp3" ); |
|
pKVFlag->SetString( "vo/heavy_PainSevere03.mp3", "vo/heavy_LaughHappy03.mp3" ); |
|
pKVFlag->SetString( "vo/heavy_PainSharp01.mp3", "vo/heavy_LaughShort01.mp3" ); |
|
pKVFlag->SetString( "vo/heavy_PainSharp02.mp3", "vo/heavy_LaughShort02.mp3" ); |
|
pKVFlag->SetString( "vo/heavy_PainSharp03.mp3", "vo/heavy_LaughShort03.mp3" ); |
|
pKVFlag->SetString( "vo/heavy_PainSharp04.mp3", "vo/heavy_LaughShort01.mp3" ); |
|
pKVFlag->SetString( "vo/heavy_PainSharp05.mp3", "vo/heavy_LaughShort02.mp3" ); |
|
pKVFlag->SetString( "vo/heavy_AutoOnFire01.mp3", "vo/heavy_PositiveVocalization01.mp3" ); |
|
pKVFlag->SetString( "vo/heavy_AutoOnFire02.mp3", "vo/heavy_PositiveVocalization02.mp3" ); |
|
pKVFlag->SetString( "vo/heavy_AutoOnFire03.mp3", "vo/heavy_PositiveVocalization03.mp3" ); |
|
pKVFlag->SetString( "vo/heavy_AutoOnFire04.mp3", "vo/heavy_PositiveVocalization04.mp3" ); |
|
pKVFlag->SetString( "vo/heavy_AutoOnFire05.mp3", "vo/heavy_PositiveVocalization05.mp3" ); |
|
|
|
pKVFlag->SetString( "vo/medic_PainCrticialDeath01.mp3", "vo/medic_LaughLong01.mp3" ); |
|
pKVFlag->SetString( "vo/medic_PainCrticialDeath02.mp3", "vo/medic_LaughLong02.mp3" ); |
|
pKVFlag->SetString( "vo/medic_PainCrticialDeath03.mp3", "vo/medic_LaughLong01.mp3" ); |
|
pKVFlag->SetString( "vo/medic_PainCrticialDeath04.mp3", "vo/medic_LaughLong02.mp3" ); |
|
pKVFlag->SetString( "vo/medic_PainSevere01.mp3", "vo/medic_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/medic_PainSevere02.mp3", "vo/medic_LaughHappy02.mp3" ); |
|
pKVFlag->SetString( "vo/medic_PainSevere03.mp3", "vo/medic_LaughHappy03.mp3" ); |
|
pKVFlag->SetString( "vo/medic_PainSevere04.mp3", "vo/medic_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/medic_PainSharp01.mp3", "vo/medic_LaughShort01.mp3" ); |
|
pKVFlag->SetString( "vo/medic_PainSharp02.mp3", "vo/medic_LaughShort02.mp3" ); |
|
pKVFlag->SetString( "vo/medic_PainSharp03.mp3", "vo/medic_LaughShort03.mp3" ); |
|
pKVFlag->SetString( "vo/medic_PainSharp04.mp3", "vo/medic_LaughShort01.mp3" ); |
|
pKVFlag->SetString( "vo/medic_PainSharp05.mp3", "vo/medic_LaughShort02.mp3" ); |
|
pKVFlag->SetString( "vo/medic_PainSharp06.mp3", "vo/medic_LaughShort03.mp3" ); |
|
pKVFlag->SetString( "vo/medic_PainSharp07.mp3", "vo/medic_LaughShort01.mp3" ); |
|
pKVFlag->SetString( "vo/medic_PainSharp08.mp3", "vo/medic_LaughShort02.mp3" ); |
|
pKVFlag->SetString( "vo/medic_AutoOnFire01.mp3", "vo/medic_PositiveVocalization01.mp3" ); |
|
pKVFlag->SetString( "vo/medic_AutoOnFire02.mp3", "vo/medic_PositiveVocalization02.mp3" ); |
|
pKVFlag->SetString( "vo/medic_AutoOnFire03.mp3", "vo/medic_PositiveVocalization03.mp3" ); |
|
pKVFlag->SetString( "vo/medic_AutoOnFire04.mp3", "vo/medic_PositiveVocalization04.mp3" ); |
|
pKVFlag->SetString( "vo/medic_AutoOnFire05.mp3", "vo/medic_PositiveVocalization05.mp3" ); |
|
|
|
pKVFlag->SetString( "vo/pyro_PainCrticialDeath01.mp3", "vo/pyro_LaughLong01.mp3" ); |
|
pKVFlag->SetString( "vo/pyro_PainCrticialDeath02.mp3", "vo/pyro_LaughLong01.mp3" ); |
|
pKVFlag->SetString( "vo/pyro_PainCrticialDeath03.mp3", "vo/pyro_LaughLong01.mp3" ); |
|
pKVFlag->SetString( "vo/pyro_PainSevere01.mp3", "vo/pyro_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/pyro_PainSevere02.mp3", "vo/pyro_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/pyro_PainSevere03.mp3", "vo/pyro_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/pyro_PainSevere04.mp3", "vo/pyro_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/pyro_PainSevere05.mp3", "vo/pyro_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/pyro_PainSevere06.mp3", "vo/pyro_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/pyro_AutoOnFire01.mp3", "vo/pyro_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/pyro_AutoOnFire02.mp3", "vo/pyro_LaughHappy01.mp3" ); |
|
|
|
pKVFlag->SetString( "vo/scout_PainCrticialDeath01.mp3", "vo/scout_LaughLong01.mp3" ); |
|
pKVFlag->SetString( "vo/scout_PainCrticialDeath02.mp3", "vo/scout_LaughLong02.mp3" ); |
|
pKVFlag->SetString( "vo/scout_PainCrticialDeath03.mp3", "vo/scout_LaughLong01.mp3" ); |
|
pKVFlag->SetString( "vo/scout_PainSevere01.mp3", "vo/scout_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/scout_PainSevere02.mp3", "vo/scout_LaughHappy02.mp3" ); |
|
pKVFlag->SetString( "vo/scout_PainSevere03.mp3", "vo/scout_LaughHappy03.mp3" ); |
|
pKVFlag->SetString( "vo/scout_PainSevere04.mp3", "vo/scout_LaughHappy04.mp3" ); |
|
pKVFlag->SetString( "vo/scout_PainSevere05.mp3", "vo/scout_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/scout_PainSevere06.mp3", "vo/scout_LaughHappy02.mp3" ); |
|
pKVFlag->SetString( "vo/scout_PainSharp01.mp3", "vo/scout_LaughShort01.mp3" ); |
|
pKVFlag->SetString( "vo/scout_PainSharp02.mp3", "vo/scout_LaughShort02.mp3" ); |
|
pKVFlag->SetString( "vo/scout_PainSharp03.mp3", "vo/scout_LaughShort03.mp3" ); |
|
pKVFlag->SetString( "vo/scout_PainSharp04.mp3", "vo/scout_LaughShort04.mp3" ); |
|
pKVFlag->SetString( "vo/scout_PainSharp05.mp3", "vo/scout_LaughShort05.mp3" ); |
|
pKVFlag->SetString( "vo/scout_PainSharp06.mp3", "vo/scout_LaughShort01.mp3" ); |
|
pKVFlag->SetString( "vo/scout_PainSharp07.mp3", "vo/scout_LaughShort02.mp3" ); |
|
pKVFlag->SetString( "vo/scout_PainSharp08.mp3", "vo/scout_LaughShort03.mp3" ); |
|
pKVFlag->SetString( "vo/scout_AutoOnFire01.mp3", "vo/scout_PositiveVocalization02.mp3" ); |
|
pKVFlag->SetString( "vo/scout_AutoOnFire02.mp3", "vo/scout_PositiveVocalization03.mp3" ); |
|
|
|
pKVFlag->SetString( "vo/sniper_PainCrticialDeath01.mp3", "vo/sniper_LaughLong01.mp3" ); |
|
pKVFlag->SetString( "vo/sniper_PainCrticialDeath02.mp3", "vo/sniper_LaughLong02.mp3" ); |
|
pKVFlag->SetString( "vo/sniper_PainCrticialDeath03.mp3", "vo/sniper_LaughLong01.mp3" ); |
|
pKVFlag->SetString( "vo/sniper_PainCrticialDeath04.mp3", "vo/sniper_LaughLong02.mp3" ); |
|
pKVFlag->SetString( "vo/sniper_PainSevere01.mp3", "vo/sniper_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/sniper_PainSevere02.mp3", "vo/sniper_LaughHappy02.mp3" ); |
|
pKVFlag->SetString( "vo/sniper_PainSevere03.mp3", "vo/sniper_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/sniper_PainSevere04.mp3", "vo/sniper_LaughHappy02.mp3" ); |
|
pKVFlag->SetString( "vo/sniper_PainSharp01.mp3", "vo/sniper_LaughShort01.mp3" ); |
|
pKVFlag->SetString( "vo/sniper_PainSharp02.mp3", "vo/sniper_LaughShort02.mp3" ); |
|
pKVFlag->SetString( "vo/sniper_PainSharp03.mp3", "vo/sniper_LaughShort03.mp3" ); |
|
pKVFlag->SetString( "vo/sniper_PainSharp04.mp3", "vo/sniper_LaughShort04.mp3" ); |
|
pKVFlag->SetString( "vo/sniper_AutoOnFire01.mp3", "vo/sniper_PositiveVocalization02.mp3" ); |
|
pKVFlag->SetString( "vo/sniper_AutoOnFire02.mp3", "vo/sniper_PositiveVocalization03.mp3" ); |
|
pKVFlag->SetString( "vo/sniper_AutoOnFire03.mp3", "vo/sniper_PositiveVocalization05.mp3" ); |
|
|
|
pKVFlag->SetString( "vo/soldier_PainCrticialDeath01.mp3", "vo/soldier_LaughLong01.mp3" ); |
|
pKVFlag->SetString( "vo/soldier_PainCrticialDeath02.mp3", "vo/soldier_LaughLong02.mp3" ); |
|
pKVFlag->SetString( "vo/soldier_PainCrticialDeath03.mp3", "vo/soldier_LaughLong03.mp3" ); |
|
pKVFlag->SetString( "vo/soldier_PainCrticialDeath04.mp3", "vo/soldier_LaughLong01.mp3" ); |
|
pKVFlag->SetString( "vo/soldier_PainSevere01.mp3", "vo/soldier_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/soldier_PainSevere02.mp3", "vo/soldier_LaughHappy02.mp3" ); |
|
pKVFlag->SetString( "vo/soldier_PainSevere03.mp3", "vo/soldier_LaughHappy03.mp3" ); |
|
pKVFlag->SetString( "vo/soldier_PainSevere04.mp3", "vo/soldier_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/soldier_PainSevere05.mp3", "vo/soldier_LaughHappy02.mp3" ); |
|
pKVFlag->SetString( "vo/soldier_PainSevere06.mp3", "vo/soldier_LaughHappy03.mp3" ); |
|
pKVFlag->SetString( "vo/soldier_PainSharp01.mp3", "vo/soldier_LaughShort01.mp3" ); |
|
pKVFlag->SetString( "vo/soldier_PainSharp02.mp3", "vo/soldier_LaughShort02.mp3" ); |
|
pKVFlag->SetString( "vo/soldier_PainSharp03.mp3", "vo/soldier_LaughShort03.mp3" ); |
|
pKVFlag->SetString( "vo/soldier_PainSharp04.mp3", "vo/soldier_LaughShort04.mp3" ); |
|
pKVFlag->SetString( "vo/soldier_PainSharp05.mp3", "vo/soldier_LaughShort01.mp3" ); |
|
pKVFlag->SetString( "vo/soldier_PainSharp06.mp3", "vo/soldier_LaughShort02.mp3" ); |
|
pKVFlag->SetString( "vo/soldier_PainSharp07.mp3", "vo/soldier_LaughShort03.mp3" ); |
|
pKVFlag->SetString( "vo/soldier_PainSharp08.mp3", "vo/soldier_LaughShort04.mp3" ); |
|
pKVFlag->SetString( "vo/soldier_AutoOnFire01.mp3", "vo/soldier_PositiveVocalization01.mp3" ); |
|
pKVFlag->SetString( "vo/soldier_AutoOnFire02.mp3", "vo/soldier_PositiveVocalization02.mp3" ); |
|
pKVFlag->SetString( "vo/soldier_AutoOnFire03.mp3", "vo/soldier_PositiveVocalization03.mp3" ); |
|
|
|
pKVFlag->SetString( "vo/spy_PainCrticialDeath01.mp3", "vo/spy_LaughLong01.mp3" ); |
|
pKVFlag->SetString( "vo/spy_PainCrticialDeath02.mp3", "vo/spy_LaughLong01.mp3" ); |
|
pKVFlag->SetString( "vo/spy_PainCrticialDeath03.mp3", "vo/spy_LaughLong01.mp3" ); |
|
pKVFlag->SetString( "vo/spy_PainSevere01.mp3", "vo/spy_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/spy_PainSevere02.mp3", "vo/spy_LaughHappy02.mp3" ); |
|
pKVFlag->SetString( "vo/spy_PainSevere03.mp3", "vo/spy_LaughHappy03.mp3" ); |
|
pKVFlag->SetString( "vo/spy_PainSevere04.mp3", "vo/spy_LaughHappy01.mp3" ); |
|
pKVFlag->SetString( "vo/spy_PainSevere05.mp3", "vo/spy_LaughHappy02.mp3" ); |
|
pKVFlag->SetString( "vo/spy_PainSharp01.mp3", "vo/spy_LaughShort01.mp3" ); |
|
pKVFlag->SetString( "vo/spy_PainSharp02.mp3", "vo/spy_LaughShort02.mp3" ); |
|
pKVFlag->SetString( "vo/spy_PainSharp03.mp3", "vo/spy_LaughShort03.mp3" ); |
|
pKVFlag->SetString( "vo/spy_PainSharp04.mp3", "vo/spy_LaughShort04.mp3" ); |
|
pKVFlag->SetString( "vo/spy_AutoOnFire01.mp3", "vo/spy_PositiveVocalization02.mp3" ); |
|
pKVFlag->SetString( "vo/spy_AutoOnFire02.mp3", "vo/spy_PositiveVocalization04.mp3" ); |
|
pKVFlag->SetString( "vo/spy_AutoOnFire03.mp3", "vo/spy_PositiveVocalization05.mp3" ); |
|
|
|
pKVBlock->AddSubKey( pKVFlag ); |
|
|
|
// Spooky Vision |
|
//pKVFlag = new KeyValues( "2" ); // TF_VISION_FILTER_HALLOWEEN |
|
//pKVBlock->AddSubKey( pKVFlag ); |
|
|
|
// ************************************************************************************************** |
|
// WEAPONS |
|
pKVBlock = new KeyValues( "weapons" ); |
|
m_pkvVisionFilterTranslations->AddSubKey( pKVBlock ); |
|
|
|
// No special vision |
|
pKVFlag = new KeyValues( "0" ); |
|
pKVFlag->SetString( "models/weapons/c_models/c_rainblower/c_rainblower.mdl", "models/weapons/c_models/c_flamethrower/c_flamethrower.mdl" ); |
|
pKVFlag->SetString( "models/weapons/c_models/c_lollichop/c_lollichop.mdl", "models/weapons/w_models/w_fireaxe.mdl" ); |
|
pKVBlock->AddSubKey( pKVFlag ); |
|
|
|
// Pyrovision |
|
pKVFlag = new KeyValues( "1" ); |
|
pKVFlag->SetString( "models/weapons/c_models/c_rainblower/c_rainblower.mdl", "models/weapons/c_models/c_rainblower/c_rainblower.mdl" ); //explicit set for pyrovision |
|
pKVFlag->SetString( "models/weapons/c_models/c_lollichop/c_lollichop.mdl", "models/weapons/c_models/c_lollichop/c_lollichop.mdl" ); |
|
|
|
pKVFlag->SetString( "models/player/items/demo/demo_bombs.mdl", "models/player/items/all_class/mtp_bottle_demo.mdl" ); |
|
pKVFlag->SetString( "models/player/items/pyro/xms_pyro_bells.mdl", "models/player/items/all_class/mtp_bottle_pyro.mdl" ); |
|
pKVFlag->SetString( "models/player/items/soldier/ds_can_grenades.mdl", "models/player/items/all_class/mtp_bottle_soldier.mdl" ); |
|
pKVBlock->AddSubKey( pKVFlag ); |
|
|
|
// Spooky Vision |
|
//pKVFlag = new KeyValues( "2" ); |
|
//pKVBlock->AddSubKey( pKVFlag ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::UseSillyGibs( void ) |
|
{ |
|
// Use silly gibs if the local player has an item that allows them to see it (Pyro Goggles) |
|
if ( IsLocalPlayerUsingVisionFilterFlags( TF_VISION_FILTER_PYRO ) ) |
|
return true; |
|
if ( UTIL_IsLowViolence() ) |
|
return true; |
|
|
|
return m_bSillyGibs; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::AllowWeatherParticles( void ) |
|
{ |
|
return ( tf_particles_disable_weather.GetBool() == false ); |
|
} |
|
|
|
bool CTFGameRules::AllowMapVisionFilterShaders( void ) |
|
{ |
|
if ( !m_pkvVisionFilterShadersMapWhitelist ) |
|
return false; |
|
|
|
const char *pMapName = engine->GetLevelName(); |
|
while ( pMapName && pMapName[ 0 ] != '\\' && pMapName[ 0 ] != '/' ) |
|
{ |
|
pMapName++; |
|
} |
|
|
|
if ( !pMapName ) |
|
return false; |
|
|
|
pMapName++; |
|
|
|
return m_pkvVisionFilterShadersMapWhitelist->GetInt( pMapName, 0 ) != 0; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
const char* CTFGameRules::TranslateEffectForVisionFilter( const char *pchEffectType, const char *pchEffectName ) |
|
{ |
|
if ( !pchEffectType || !pchEffectName ) |
|
{ |
|
return pchEffectName; |
|
} |
|
|
|
CUtlVector<const char *> vecNames; |
|
vecNames.AddToTail( pchEffectName ); |
|
|
|
// Swap the effect if the local player has an item that allows them to see it (Pyro Goggles) |
|
bool bWeaponsOnly = FStrEq( pchEffectType, "weapons" ); |
|
int nVisionOptInFlags = GetLocalPlayerVisionFilterFlags( bWeaponsOnly ); |
|
|
|
KeyValues *pkvParticles = m_pkvVisionFilterTranslations->FindKey( pchEffectType ); |
|
if ( pkvParticles ) |
|
{ |
|
for ( KeyValues *pkvFlag = pkvParticles->GetFirstTrueSubKey(); pkvFlag != NULL; pkvFlag = pkvFlag->GetNextTrueSubKey() ) |
|
{ |
|
int nFlag = atoi( pkvFlag->GetName() ); |
|
|
|
// Grab any potential translations for this item |
|
// Always grab default (No vision) names if they exist |
|
if ( ( nVisionOptInFlags & nFlag ) != 0 || nFlag == 0 ) |
|
{ |
|
// We either have this vision flag or we have no flags and this is the no flag block |
|
const char *pchTranslatedString = pkvFlag->GetString( pchEffectName, NULL ); |
|
|
|
if ( pchTranslatedString ) |
|
{ |
|
vecNames.AddToHead( pchTranslatedString ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
// Return the top item in the list. Currently Halloween replacements would out prioritize Pyrovision if there is any overlap |
|
return vecNames.Head(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::ModifySentChat( char *pBuf, int iBufSize ) |
|
{ |
|
if ( IsInMedievalMode() && tf_medieval_autorp.GetBool() && english.GetBool() ) |
|
{ |
|
AutoRP()->ApplyRPTo( pBuf, iBufSize ); |
|
} |
|
|
|
// replace all " with ' to prevent exploits related to chat text |
|
// example: ";exit |
|
for ( char *ch = pBuf; *ch != 0; ch++ ) |
|
{ |
|
if ( *ch == '"' ) |
|
{ |
|
*ch = '\''; |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::AllowMapParticleEffect( const char *pszParticleEffect ) |
|
{ |
|
static const char *s_WeatherEffects[] = |
|
{ |
|
"tf_gamerules", |
|
"env_rain_001", |
|
"env_rain_002_256", |
|
"env_rain_ripples", |
|
"env_snow_light_001", |
|
"env_rain_gutterdrip", |
|
"env_rain_guttersplash", |
|
"", // END Marker |
|
}; |
|
|
|
if ( !AllowWeatherParticles() ) |
|
{ |
|
if ( FindInList( s_WeatherEffects, pszParticleEffect ) ) |
|
return false; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::GetTeamGlowColor( int nTeam, float &r, float &g, float &b ) |
|
{ |
|
if ( nTeam == TF_TEAM_RED ) |
|
{ |
|
r = 0.74f; |
|
g = 0.23f; |
|
b = 0.23f; |
|
} |
|
else if ( nTeam == TF_TEAM_BLUE ) |
|
{ |
|
r = 0.49f; |
|
g = 0.66f; |
|
b = 0.77f; |
|
} |
|
else |
|
{ |
|
r = 0.76f; |
|
g = 0.76f; |
|
b = 0.76f; |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::ShouldConfirmOnDisconnect() |
|
{ |
|
// Add any game mode which uses matchmaking here. Note that the disconnect dialog checks if it should be showing abandons and such. |
|
return ( IsMannVsMachineMode() && GTFGCClientSystem()->GetSearchPlayForBraggingRights() ) || |
|
( IsCompetitiveMode() && GTFGCClientSystem()->GetLobby() ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::ShouldShowPreRoundDoors() const |
|
{ |
|
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() ); |
|
if ( pMatchDesc ) |
|
{ |
|
return pMatchDesc->m_params.m_bShowPreRoundDoors; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
#endif |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::GetClassLimit( int iClass ) |
|
{ |
|
if ( IsInTournamentMode() || IsPasstimeMode() ) |
|
{ |
|
switch ( iClass ) |
|
{ |
|
case TF_CLASS_SCOUT: return tf_tournament_classlimit_scout.GetInt(); break; |
|
case TF_CLASS_SNIPER: return tf_tournament_classlimit_sniper.GetInt(); break; |
|
case TF_CLASS_SOLDIER: return tf_tournament_classlimit_soldier.GetInt(); break; |
|
case TF_CLASS_DEMOMAN: return tf_tournament_classlimit_demoman.GetInt(); break; |
|
case TF_CLASS_MEDIC: return tf_tournament_classlimit_medic.GetInt(); break; |
|
case TF_CLASS_HEAVYWEAPONS: return tf_tournament_classlimit_heavy.GetInt(); break; |
|
case TF_CLASS_PYRO: return tf_tournament_classlimit_pyro.GetInt(); break; |
|
case TF_CLASS_SPY: return tf_tournament_classlimit_spy.GetInt(); break; |
|
case TF_CLASS_ENGINEER: return tf_tournament_classlimit_engineer.GetInt(); break; |
|
default: |
|
break; |
|
} |
|
} |
|
else if ( IsInHighlanderMode() ) |
|
{ |
|
return 1; |
|
} |
|
else if ( tf_classlimit.GetInt() ) |
|
{ |
|
return tf_classlimit.GetInt(); |
|
} |
|
|
|
return NO_CLASS_LIMIT; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::CanPlayerChooseClass( CBasePlayer *pPlayer, int iClass ) |
|
{ |
|
int iClassLimit = GetClassLimit( iClass ); |
|
|
|
#ifdef TF_RAID_MODE |
|
if ( IsRaidMode() && !pPlayer->IsBot() ) |
|
{ |
|
// bots are exempt from class limits, to allow for additional support bot "friends" |
|
if ( pPlayer->GetTeamNumber() == TF_TEAM_BLUE ) |
|
{ |
|
if ( tf_raid_allow_all_classes.GetBool() == false ) |
|
{ |
|
if ( iClass == TF_CLASS_SCOUT ) |
|
return false; |
|
|
|
if ( iClass == TF_CLASS_SPY ) |
|
return false; |
|
} |
|
|
|
if ( tf_raid_enforce_unique_classes.GetBool() ) |
|
{ |
|
// only one of each class on the raiding team |
|
iClassLimit = 1; |
|
} |
|
} |
|
} |
|
else if ( IsBossBattleMode() ) |
|
{ |
|
return true; |
|
} |
|
else |
|
#endif // TF_RAID_MODE |
|
|
|
if ( iClassLimit == NO_CLASS_LIMIT ) |
|
return true; |
|
|
|
if ( pPlayer->GetTeamNumber() != TF_TEAM_BLUE && pPlayer->GetTeamNumber() != TF_TEAM_RED ) |
|
return true; |
|
#ifdef GAME_DLL |
|
CTFTeam *pTeam = assert_cast<CTFTeam*>(pPlayer->GetTeam()); |
|
#else |
|
C_TFTeam *pTeam = assert_cast<C_TFTeam*>(pPlayer->GetTeam()); |
|
#endif |
|
if ( !pTeam ) |
|
return true; |
|
|
|
int iTeamClassCount = 0; |
|
for ( int iPlayer = 0; iPlayer < pTeam->GetNumPlayers(); iPlayer++ ) |
|
{ |
|
CTFPlayer *pTFPlayer = ToTFPlayer( pTeam->GetPlayer( iPlayer ) ); |
|
if ( pTFPlayer && pTFPlayer != pPlayer && pTFPlayer->GetPlayerClass()->GetClassIndex() == iClass ) |
|
{ |
|
iTeamClassCount++; |
|
} |
|
} |
|
|
|
return ( iTeamClassCount < iClassLimit ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::ShouldBalanceTeams( void ) |
|
{ |
|
// never autobalance the teams for managed matches using the old system |
|
if ( GetMatchGroupDescription( GetCurrentMatchGroup() ) ) |
|
return false; |
|
|
|
bool bDisableBalancing = false; |
|
#ifdef STAGING_ONLY |
|
bDisableBalancing = IsBountyMode(); |
|
#endif // STAGING_ONLY |
|
|
|
if ( IsPVEModeActive() || bDisableBalancing ) |
|
return false; |
|
|
|
// don't balance the teams while players are in hell |
|
if ( ArePlayersInHell() ) |
|
return false; |
|
|
|
return BaseClass::ShouldBalanceTeams(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::GetBonusRoundTime( bool bGameOver /* = false*/ ) |
|
{ |
|
if ( IsMannVsMachineMode() ) |
|
{ |
|
return 5; |
|
} |
|
else if ( IsCompetitiveMode() && bGameOver ) |
|
{ |
|
if ( IsMatchTypeCompetitive() ) |
|
{ |
|
return 5; |
|
} |
|
} |
|
|
|
return BaseClass::GetBonusRoundTime( bGameOver ); |
|
} |
|
|
|
|
|
#ifdef GAME_DLL |
|
|
|
bool CTFGameRules::CanBotChangeClass( CBasePlayer* pPlayer ) |
|
{ |
|
// if there's a roster for this bot's team, check to see if the level designer has allowed the bot to change class |
|
// used when the bot dies and wants to see if it can change class |
|
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer ); |
|
if ( pTFPlayer && pTFPlayer->GetPlayerClass() && pTFPlayer->GetPlayerClass()->GetClassIndex() != TF_CLASS_UNDEFINED ) |
|
{ |
|
switch ( pPlayer->GetTeamNumber() ) |
|
{ |
|
case TF_TEAM_RED: return m_hRedBotRoster ? m_hRedBotRoster->IsClassChangeAllowed() : true; break; |
|
case TF_TEAM_BLUE: return m_hBlueBotRoster ? m_hBlueBotRoster->IsClassChangeAllowed() : true; break; |
|
} |
|
} |
|
return true; |
|
} |
|
|
|
bool CTFGameRules::CanBotChooseClass( CBasePlayer *pPlayer, int iClass ) |
|
{ |
|
// if there's a roster for this bot's team, then check to see if the class the bot has requested is allowed by the roster |
|
bool bCanChooseClass = CanPlayerChooseClass( pPlayer, iClass ); |
|
if ( bCanChooseClass ) |
|
{ |
|
// now check rosters... |
|
switch ( pPlayer->GetTeamNumber() ) |
|
{ |
|
case TF_TEAM_RED: |
|
bCanChooseClass = m_hRedBotRoster ? m_hRedBotRoster->IsClassAllowed( iClass ) : true; |
|
break; |
|
case TF_TEAM_BLUE: |
|
bCanChooseClass = m_hBlueBotRoster ? m_hBlueBotRoster->IsClassAllowed( iClass ) : true; |
|
break; |
|
default: |
|
// no roster - spectator team |
|
bCanChooseClass = true; |
|
break; |
|
} |
|
} |
|
return bCanChooseClass; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Populate vector with set of control points the player needs to capture |
|
void CTFGameRules::CollectCapturePoints( CBasePlayer *player, CUtlVector< CTeamControlPoint * > *captureVector ) const |
|
{ |
|
if ( !captureVector ) |
|
return; |
|
|
|
captureVector->RemoveAll(); |
|
|
|
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL; |
|
if ( pMaster ) |
|
{ |
|
// special case hack for KotH mode to use control points that are locked at the start of the round |
|
if ( IsInKothMode() && pMaster->GetNumPoints() == 1 ) |
|
{ |
|
captureVector->AddToTail( pMaster->GetControlPoint( 0 ) ); |
|
return; |
|
} |
|
|
|
for( int i=0; i<pMaster->GetNumPoints(); ++i ) |
|
{ |
|
CTeamControlPoint *point = pMaster->GetControlPoint( i ); |
|
if ( point && pMaster->IsInRound( point ) ) |
|
{ |
|
if ( ObjectiveResource()->GetOwningTeam( point->GetPointIndex() ) == player->GetTeamNumber() ) |
|
continue; |
|
|
|
if ( player && player->IsBot() && point->ShouldBotsIgnore() ) |
|
continue; |
|
|
|
if ( ObjectiveResource()->TeamCanCapPoint( point->GetPointIndex(), player->GetTeamNumber() ) ) |
|
{ |
|
if ( TeamplayGameRules()->TeamMayCapturePoint( player->GetTeamNumber(), point->GetPointIndex() ) ) |
|
{ |
|
// unlocked point not on our team available to capture |
|
captureVector->AddToTail( point ); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Populate vector with set of control points the player needs to defend from capture |
|
void CTFGameRules::CollectDefendPoints( CBasePlayer *player, CUtlVector< CTeamControlPoint * > *defendVector ) const |
|
{ |
|
if ( !defendVector ) |
|
return; |
|
|
|
defendVector->RemoveAll(); |
|
|
|
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL; |
|
if ( pMaster ) |
|
{ |
|
for( int i=0; i<pMaster->GetNumPoints(); ++i ) |
|
{ |
|
CTeamControlPoint *point = pMaster->GetControlPoint( i ); |
|
if ( point && pMaster->IsInRound( point ) ) |
|
{ |
|
if ( ObjectiveResource()->GetOwningTeam( point->GetPointIndex() ) != player->GetTeamNumber() ) |
|
continue; |
|
|
|
if ( player && player->IsBot() && point->ShouldBotsIgnore() ) |
|
continue; |
|
|
|
if ( ObjectiveResource()->TeamCanCapPoint( point->GetPointIndex(), GetEnemyTeam( player->GetTeamNumber() ) ) ) |
|
{ |
|
if ( TeamplayGameRules()->TeamMayCapturePoint( GetEnemyTeam( player->GetTeamNumber() ), point->GetPointIndex() ) ) |
|
{ |
|
// unlocked point on our team vulnerable to capture |
|
defendVector->AddToTail( point ); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
CObjectSentrygun *CTFGameRules::FindSentryGunWithMostKills( int team ) const |
|
{ |
|
CObjectSentrygun *dangerousSentry = NULL; |
|
int dangerousSentryKills = -1; |
|
|
|
for ( int i=0; i<IBaseObjectAutoList::AutoList().Count(); ++i ) |
|
{ |
|
CBaseObject *pObj = static_cast< CBaseObject* >( IBaseObjectAutoList::AutoList()[i] ); |
|
if ( pObj->ObjectType() == OBJ_SENTRYGUN && pObj->GetTeamNumber() == team && pObj->GetKills() >= dangerousSentryKills ) |
|
{ |
|
dangerousSentryKills = pObj->GetKills(); |
|
dangerousSentry = static_cast<CObjectSentrygun *>( pObj ); |
|
} |
|
} |
|
|
|
return dangerousSentry; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::ClientConnected( edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen ) |
|
{ |
|
if ( IsMannVsMachineMode() ) |
|
{ |
|
int nCount = 0; |
|
CTFPlayer *pPlayer; |
|
|
|
for ( int i = 1; i <= gpGlobals->maxClients; i++ ) |
|
{ |
|
pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
|
|
if ( !pPlayer || pPlayer->IsFakeClient() ) |
|
continue; |
|
|
|
nCount++; |
|
} |
|
|
|
if ( nCount >= kMVM_MaxConnectedPlayers ) |
|
return false; |
|
} |
|
|
|
bool bRet = BaseClass::ClientConnected( pEntity, pszName, pszAddress, reject, maxrejectlen ); |
|
if ( bRet ) |
|
{ |
|
const CSteamID *steamID = engine->GetClientSteamID( pEntity ); |
|
if ( steamID && steamID->IsValid() ) |
|
{ |
|
// Invalid steamIDs wont be known to the GC system, but it has a SteamIDAllowedToConnect() hook that would |
|
// allow it to reject the connect in the first place in a matchmaking scenario where cares. |
|
GTFGCClientSystem()->ClientConnected( *steamID, pEntity ); |
|
} |
|
} |
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::ShouldMakeChristmasAmmoPack( void ) |
|
{ |
|
if ( IsInTournamentMode() && !IsMatchTypeCasual() ) |
|
return false; |
|
|
|
if ( IsMannVsMachineMode() ) |
|
return false; |
|
|
|
if ( mp_holiday_nogifts.GetBool() == true ) |
|
return false; |
|
|
|
if ( IsHolidayActive( kHoliday_Christmas ) == false ) |
|
return false; |
|
|
|
return ( RandomInt( 0, 100 ) < 10 ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: **** DO NOT SHIP THIS IN REL/HL2 **** |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::UpdatePeriodicEvent( CTFPlayer *pPlayer, eEconPeriodicScoreEvents eEvent, uint32 nCount ) |
|
{ |
|
CSteamID steamID; |
|
if ( !pPlayer || !pPlayer->GetSteamID( &steamID ) || !steamID.IsValid() ) |
|
return; |
|
|
|
GCSDK::CProtoBufMsg<CMsgUpdatePeriodicEvent> msg( k_EMsgGC_UpdatePeriodicEvent ); |
|
msg.Body().set_account_id( steamID.GetAccountID() ); |
|
msg.Body().set_event_type( eEvent ); |
|
msg.Body().set_amount( nCount ); |
|
GCClientSystem()->BSendMessage( msg ); |
|
} |
|
|
|
#endif // GAME_DLL |
|
|
|
#ifndef CLIENT_DLL |
|
|
|
void CTFGameRules::Status( void (*print) (const char *fmt, ...) ) |
|
{ |
|
// print( "Total Time: %d seconds\n", CTF_GameStats.m_currentMap.m_Header.m_iTotalTime ); |
|
// priprint( "Blue Team Wins: %d\n", CTF_GameStats.m_currentMap.m_Header.m_iBlueWins ); |
|
// priprint( "Red Team Wins: %d\n", CTF_GameStats.m_currentMap.m_Header.m_iRedWins ); |
|
// priprint( "Stalemates: %d\n", CTF_GameStats.m_currentMap.m_Header.m_iStalemates ); |
|
|
|
print( " Spawns Points Kills Deaths Assists\n" ); |
|
for ( int iClass = TF_FIRST_NORMAL_CLASS; iClass < TF_LAST_NORMAL_CLASS; iClass++ ) |
|
{ |
|
TF_Gamestats_ClassStats_t &Stats = CTF_GameStats.m_currentMap.m_aClassStats[ iClass ]; |
|
|
|
print( "%-8s %6d %6d %5d %6d %7d\n", |
|
g_aPlayerClassNames_NonLocalized[ iClass ], |
|
Stats.iSpawns, Stats.iScore, Stats.iKills, Stats.iDeaths, Stats.iAssists ); |
|
} |
|
print( "\n" ); |
|
} |
|
|
|
#endif // !CLIENT_DLL |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::ShouldCollide( int collisionGroup0, int collisionGroup1 ) |
|
{ |
|
if ( collisionGroup0 > collisionGroup1 ) |
|
{ |
|
// swap so that lowest is always first |
|
::V_swap( collisionGroup0, collisionGroup1 ); |
|
} |
|
|
|
//Don't stand on COLLISION_GROUP_WEAPONs |
|
if( collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT && |
|
collisionGroup1 == COLLISION_GROUP_WEAPON ) |
|
{ |
|
return false; |
|
} |
|
|
|
// Don't stand on projectiles |
|
if( collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT && |
|
collisionGroup1 == COLLISION_GROUP_PROJECTILE ) |
|
{ |
|
return false; |
|
} |
|
|
|
// Rockets need to collide with players when they hit, but |
|
// be ignored by player movement checks |
|
if ( ( collisionGroup0 == COLLISION_GROUP_PLAYER ) && |
|
( collisionGroup1 == TFCOLLISION_GROUP_ROCKETS || collisionGroup1 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) ) |
|
return true; |
|
|
|
if ( ( collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT ) && |
|
( collisionGroup1 == TFCOLLISION_GROUP_ROCKETS || collisionGroup1 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) ) |
|
return false; |
|
|
|
if ( ( collisionGroup0 == COLLISION_GROUP_WEAPON ) && |
|
( collisionGroup1 == TFCOLLISION_GROUP_ROCKETS || collisionGroup1 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) ) |
|
return false; |
|
|
|
if ( ( collisionGroup0 == TF_COLLISIONGROUP_GRENADES ) && |
|
( collisionGroup1 == TFCOLLISION_GROUP_ROCKETS || collisionGroup1 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) ) |
|
return false; |
|
|
|
if ( ( collisionGroup0 == COLLISION_GROUP_PROJECTILE ) && |
|
( collisionGroup1 == TFCOLLISION_GROUP_ROCKETS || collisionGroup1 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) ) |
|
return false; |
|
|
|
if ( ( collisionGroup0 == TFCOLLISION_GROUP_ROCKETS ) && |
|
( collisionGroup1 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) ) |
|
return false; |
|
|
|
if ( ( collisionGroup0 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) && |
|
( collisionGroup1 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) ) |
|
return false; |
|
|
|
// Grenades don't collide with players. They handle collision while flying around manually. |
|
if ( ( collisionGroup0 == COLLISION_GROUP_PLAYER ) && |
|
( collisionGroup1 == TF_COLLISIONGROUP_GRENADES ) ) |
|
return false; |
|
|
|
if ( ( collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT ) && |
|
( collisionGroup1 == TF_COLLISIONGROUP_GRENADES ) ) |
|
return false; |
|
|
|
// Respawn rooms only collide with players |
|
if ( collisionGroup1 == TFCOLLISION_GROUP_RESPAWNROOMS ) |
|
return ( collisionGroup0 == COLLISION_GROUP_PLAYER ) || ( collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT ); |
|
|
|
/* if ( collisionGroup0 == COLLISION_GROUP_PLAYER ) |
|
{ |
|
// Players don't collide with objects or other players |
|
if ( collisionGroup1 == COLLISION_GROUP_PLAYER ) |
|
return false; |
|
} |
|
|
|
if ( collisionGroup1 == COLLISION_GROUP_PLAYER_MOVEMENT ) |
|
{ |
|
// This is only for probing, so it better not be on both sides!!! |
|
Assert( collisionGroup0 != COLLISION_GROUP_PLAYER_MOVEMENT ); |
|
|
|
// No collide with players any more |
|
// Nor with objects or grenades |
|
switch ( collisionGroup0 ) |
|
{ |
|
default: |
|
break; |
|
case COLLISION_GROUP_PLAYER: |
|
return false; |
|
} |
|
} |
|
*/ |
|
// don't want caltrops and other grenades colliding with each other |
|
// caltops getting stuck on other caltrops, etc.) |
|
if ( ( collisionGroup0 == TF_COLLISIONGROUP_GRENADES ) && |
|
( collisionGroup1 == TF_COLLISIONGROUP_GRENADES ) ) |
|
{ |
|
return false; |
|
} |
|
|
|
|
|
if ( collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT && |
|
collisionGroup1 == TFCOLLISION_GROUP_COMBATOBJECT ) |
|
{ |
|
return false; |
|
} |
|
|
|
if ( collisionGroup0 == COLLISION_GROUP_PLAYER && |
|
collisionGroup1 == TFCOLLISION_GROUP_COMBATOBJECT ) |
|
{ |
|
return false; |
|
} |
|
|
|
if ( ( collisionGroup0 == COLLISION_GROUP_PLAYER || collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT ) && |
|
collisionGroup1 == TFCOLLISION_GROUP_TANK ) |
|
{ |
|
return false; |
|
} |
|
|
|
return BaseClass::ShouldCollide( collisionGroup0, collisionGroup1 ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Return the value of this player towards capturing a point |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::GetCaptureValueForPlayer( CBasePlayer *pPlayer ) |
|
{ |
|
#ifdef GAME_DLL |
|
#ifdef TF_CREEP_MODE |
|
if ( IsCreepWaveMode() ) |
|
{ |
|
CTFBot *bot = ToTFBot( pPlayer ); |
|
|
|
if ( !bot || !bot->HasAttribute( CTFBot::IS_NPC ) ) |
|
{ |
|
// only creeps can influence points |
|
return 0; |
|
} |
|
} |
|
#endif |
|
#endif |
|
|
|
int nValue = BaseClass::GetCaptureValueForPlayer( pPlayer ); |
|
|
|
|
|
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer ); |
|
if ( pTFPlayer->IsPlayerClass( TF_CLASS_SCOUT ) ) |
|
{ |
|
if ( mp_capstyle.GetInt() == 1 ) |
|
{ |
|
// Scouts count for 2 people in timebased capping. |
|
nValue = 2; |
|
} |
|
else |
|
{ |
|
// Scouts can cap all points on their own. |
|
nValue = 10; |
|
} |
|
} |
|
|
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer, nValue, add_player_capturevalue ); |
|
|
|
return nValue; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::GetTimeLeft( void ) |
|
{ |
|
float flTimeLimit = mp_timelimit.GetInt() * 60; |
|
|
|
Assert( flTimeLimit > 0 && "Should not call this function when !IsGameUnderTimeLimit" ); |
|
|
|
float flMapChangeTime = m_flMapResetTime + flTimeLimit; |
|
|
|
int iTime = (int)(flMapChangeTime - gpGlobals->curtime); |
|
if ( iTime < 0 ) |
|
{ |
|
iTime = 0; |
|
} |
|
|
|
return ( iTime ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::FireGameEvent( IGameEvent *event ) |
|
{ |
|
const char *eventName = event->GetName(); |
|
|
|
#ifdef GAME_DLL |
|
if ( !Q_strcmp( eventName, "teamplay_point_captured" ) ) |
|
{ |
|
if ( IsMannVsMachineMode() ) |
|
return; |
|
|
|
// keep track of how many times each team caps |
|
int iTeam = event->GetInt( "team" ); |
|
Assert( iTeam >= FIRST_GAME_TEAM && iTeam < TF_TEAM_COUNT ); |
|
m_iNumCaps[iTeam]++; |
|
|
|
// award a capture to all capping players |
|
const char *cappers = event->GetString( "cappers" ); |
|
|
|
Q_strncpy( m_szMostRecentCappers, cappers, ARRAYSIZE( m_szMostRecentCappers ) ); |
|
for ( int i =0; i < Q_strlen( cappers ); i++ ) |
|
{ |
|
int iPlayerIndex = (int) cappers[i]; |
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) ); |
|
if ( pPlayer ) |
|
{ |
|
CTF_GameStats.Event_PlayerCapturedPoint( pPlayer ); |
|
|
|
if ( pPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && GetGameType() == TF_GAMETYPE_ESCORT ) |
|
{ |
|
pPlayer->AwardAchievement( ACHIEVEMENT_TF_HEAVY_PAYLOAD_CAP_GRIND ); |
|
} |
|
|
|
// Give money and experience |
|
int nAmount = CalculateCurrencyAmount_ByType( TF_CURRENCY_CAPTURED_OBJECTIVE ); |
|
#ifdef STAGING_ONLY |
|
if ( GameModeUsesExperience() ) |
|
{ |
|
pPlayer->AddExperiencePoints( nAmount ); |
|
} |
|
#endif // STAGING_ONLY |
|
DistributeCurrencyAmount( nAmount, pPlayer, false ); |
|
} |
|
} |
|
|
|
// Halloween 2012 doesn't want ghosts to spawn when the point is captured |
|
if( !IsHalloweenScenario( HALLOWEEN_SCENARIO_LAKESIDE ) ) |
|
{ |
|
// for 2011 Halloween map |
|
BeginHaunting( 4, 25.f, 35.f ); |
|
} |
|
} |
|
else if ( !Q_strcmp( eventName, "teamplay_capture_blocked" ) ) |
|
{ |
|
int iPlayerIndex = event->GetInt( "blocker" ); |
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) ); |
|
CTF_GameStats.Event_PlayerDefendedPoint( pPlayer ); |
|
|
|
pPlayer->m_Shared.CheckForAchievement( ACHIEVEMENT_TF_MEDIC_CHARGE_BLOCKER ); |
|
} |
|
else if ( !Q_strcmp( eventName, "teamplay_round_win" ) ) |
|
{ |
|
int iWinningTeam = event->GetInt( "team" ); |
|
bool bFullRound = event->GetBool( "full_round" ); |
|
float flRoundTime = event->GetFloat( "round_time" ); |
|
bool bWasSuddenDeath = event->GetBool( "was_sudden_death" ); |
|
CTF_GameStats.Event_RoundEnd( iWinningTeam, bFullRound, flRoundTime, bWasSuddenDeath ); |
|
} |
|
else if ( !Q_strcmp( eventName, "teamplay_setup_finished" ) ) |
|
{ |
|
if ( IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_DOOMSDAY ) ) |
|
{ |
|
m_doomsdaySetupTimer.Start( 1 ); |
|
} |
|
} |
|
else if ( !Q_strcmp( eventName, "teamplay_flag_event" ) ) |
|
{ |
|
// if this is a capture event, remember the player who made the capture |
|
int iEventType = event->GetInt( "eventtype" ); |
|
if ( TF_FLAGEVENT_CAPTURE == iEventType ) |
|
{ |
|
int iPlayerIndex = event->GetInt( "player" ); |
|
m_szMostRecentCappers[0] = iPlayerIndex; |
|
m_szMostRecentCappers[1] = 0; |
|
} |
|
} |
|
else if ( !Q_strcmp( eventName, "player_escort_score" ) ) |
|
{ |
|
int iPlayer = event->GetInt( "player", 0 ); |
|
int iPoints = event->GetInt( "points", 0 ); |
|
|
|
if ( iPlayer > 0 && iPlayer <= MAX_PLAYERS ) |
|
{ |
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex(iPlayer) ); |
|
if ( pPlayer ) |
|
{ |
|
CTF_GameStats.Event_PlayerScoresEscortPoints( pPlayer, iPoints ); |
|
|
|
int nAmount = CalculateCurrencyAmount_ByType( TF_CURRENCY_ESCORT_REWARD ); |
|
#ifdef STAGING_ONLY |
|
if ( GameModeUsesExperience() ) |
|
{ |
|
pPlayer->AddExperiencePoints( nAmount * iPoints ); |
|
} |
|
#endif // STAGING_ONLY |
|
DistributeCurrencyAmount( ( nAmount * iPoints ), pPlayer, false ); |
|
|
|
if ( pPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && GetGameType() == TF_GAMETYPE_ESCORT ) |
|
{ |
|
for ( int i = 0 ; i < iPoints ; i++ ) |
|
{ |
|
pPlayer->AwardAchievement( ACHIEVEMENT_TF_HEAVY_PAYLOAD_CAP_GRIND ); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
else if ( !Q_strcmp( eventName, "player_disconnect" ) ) |
|
{ |
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByUserId( event->GetInt("userid") ) ); |
|
|
|
// @note Tom Bui: this really sucks, but we don't know the reason other than the string... |
|
const char *pReason = event->GetString( "reason" ); |
|
if ( !Q_strncmp( pReason, "Kicked", ARRAYSIZE( "Kicked" ) - 1 ) ) |
|
{ |
|
if ( pPlayer ) |
|
{ |
|
DuelMiniGame_NotifyPlayerDisconnect( pPlayer, true ); |
|
} |
|
} |
|
} |
|
else if ( !Q_strcmp( eventName, "teamplay_round_start" ) ) |
|
{ |
|
if ( IsMannVsMachineMode() ) |
|
{ |
|
if ( g_pPopulationManager ) |
|
{ |
|
g_pPopulationManager->RestorePlayerCurrency(); |
|
|
|
// make sure all invaders are removed |
|
CUtlVector< CTFPlayer * > playerVector; |
|
CollectPlayers( &playerVector, TF_TEAM_PVE_INVADERS ); |
|
|
|
for( int i=0; i<playerVector.Count(); ++i ) |
|
{ |
|
playerVector[i]->ChangeTeam( TEAM_SPECTATOR, false, true ); |
|
} |
|
} |
|
} |
|
} |
|
else if ( !Q_strcmp( eventName, "recalculate_truce" ) ) |
|
{ |
|
RecalculateTruce(); |
|
} |
|
#else // CLIENT_DLL |
|
if ( !Q_strcmp( eventName, "overtime_nag" ) ) |
|
{ |
|
HandleOvertimeBegin(); |
|
} |
|
else if ( !Q_strcmp( eventName, "recalculate_holidays" ) ) |
|
{ |
|
UTIL_CalculateHolidays(); |
|
} |
|
#endif |
|
|
|
BaseClass::FireGameEvent( event ); |
|
} |
|
|
|
|
|
const char *CTFGameRules::GetGameTypeName( void ) |
|
{ |
|
return ::GetGameTypeName( m_nGameType.Get() ); |
|
} |
|
|
|
|
|
void CTFGameRules::ClientSpawned( edict_t * pPlayer ) |
|
{ |
|
} |
|
|
|
void CTFGameRules::OnFileReceived( const char * fileName, unsigned int transferID ) |
|
{ |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Init ammo definitions |
|
//----------------------------------------------------------------------------- |
|
|
|
// shared ammo definition |
|
// JAY: Trying to make a more physical bullet response |
|
#define BULLET_MASS_GRAINS_TO_LB(grains) (0.002285*(grains)/16.0f) |
|
#define BULLET_MASS_GRAINS_TO_KG(grains) lbs2kg(BULLET_MASS_GRAINS_TO_LB(grains)) |
|
|
|
// exaggerate all of the forces, but use real numbers to keep them consistent |
|
#define BULLET_IMPULSE_EXAGGERATION 1 |
|
|
|
// convert a velocity in ft/sec and a mass in grains to an impulse in kg in/s |
|
#define BULLET_IMPULSE(grains, ftpersec) ((ftpersec)*12*BULLET_MASS_GRAINS_TO_KG(grains)*BULLET_IMPULSE_EXAGGERATION) |
|
|
|
|
|
CAmmoDef* GetAmmoDef() |
|
{ |
|
static CAmmoDef def; |
|
static bool bInitted = false; |
|
|
|
if ( !bInitted ) |
|
{ |
|
bInitted = true; |
|
|
|
// Start at 1 here and skip the dummy ammo type to make CAmmoDef use the same indices |
|
// as our #defines. |
|
for ( int i=1; i < TF_AMMO_COUNT; i++ ) |
|
{ |
|
const char *pszAmmoName = GetAmmoName( i ); |
|
def.AddAmmoType( pszAmmoName, DMG_BULLET | DMG_USEDISTANCEMOD | DMG_NOCLOSEDISTANCEMOD, TRACER_LINE, 0, 0, "ammo_max", 2400, 10, 14 ); |
|
Assert( def.Index( pszAmmoName ) == i ); |
|
} |
|
} |
|
|
|
return &def; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
const char *CTFGameRules::GetTeamGoalString( int iTeam ) |
|
{ |
|
if ( iTeam == TF_TEAM_RED ) |
|
return m_pszTeamGoalStringRed.Get(); |
|
if ( iTeam == TF_TEAM_BLUE ) |
|
return m_pszTeamGoalStringBlue.Get(); |
|
return NULL; |
|
} |
|
|
|
#ifdef GAME_DLL |
|
|
|
Vector MaybeDropToGround( |
|
CBaseEntity *pMainEnt, |
|
bool bDropToGround, |
|
const Vector &vPos, |
|
const Vector &vMins, |
|
const Vector &vMaxs ) |
|
{ |
|
if ( bDropToGround ) |
|
{ |
|
trace_t trace; |
|
UTIL_TraceHull( vPos, vPos + Vector( 0, 0, -500 ), vMins, vMaxs, MASK_SOLID, pMainEnt, COLLISION_GROUP_NONE, &trace ); |
|
return trace.endpos; |
|
} |
|
else |
|
{ |
|
return vPos; |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: This function can be used to find a valid placement location for an entity. |
|
// Given an origin to start looking from and a minimum radius to place the entity at, |
|
// it will sweep out a circle around vOrigin and try to find a valid spot (on the ground) |
|
// where mins and maxs will fit. |
|
// Input : *pMainEnt - Entity to place |
|
// &vOrigin - Point to search around |
|
// fRadius - Radius to search within |
|
// nTries - Number of tries to attempt |
|
// &mins - mins of the Entity |
|
// &maxs - maxs of the Entity |
|
// &outPos - Return point |
|
// Output : Returns true and fills in outPos if it found a spot. |
|
//----------------------------------------------------------------------------- |
|
bool EntityPlacementTest( CBaseEntity *pMainEnt, const Vector &vOrigin, Vector &outPos, bool bDropToGround ) |
|
{ |
|
// This function moves the box out in each dimension in each step trying to find empty space like this: |
|
// |
|
// X |
|
// X X |
|
// Step 1: X Step 2: XXX Step 3: XXXXX |
|
// X X |
|
// X |
|
// |
|
|
|
Vector mins, maxs; |
|
pMainEnt->CollisionProp()->WorldSpaceAABB( &mins, &maxs ); |
|
mins -= pMainEnt->GetAbsOrigin(); |
|
maxs -= pMainEnt->GetAbsOrigin(); |
|
|
|
// Put some padding on their bbox. |
|
float flPadSize = 5; |
|
Vector vTestMins = mins - Vector( flPadSize, flPadSize, flPadSize ); |
|
Vector vTestMaxs = maxs + Vector( flPadSize, flPadSize, flPadSize ); |
|
|
|
// First test the starting origin. |
|
if ( UTIL_IsSpaceEmpty( pMainEnt, vOrigin + vTestMins, vOrigin + vTestMaxs ) ) |
|
{ |
|
outPos = MaybeDropToGround( pMainEnt, bDropToGround, vOrigin, vTestMins, vTestMaxs ); |
|
return true; |
|
} |
|
|
|
Vector vDims = vTestMaxs - vTestMins; |
|
|
|
|
|
// Keep branching out until we get too far. |
|
int iCurIteration = 0; |
|
int nMaxIterations = 15; |
|
|
|
int offset = 0; |
|
do |
|
{ |
|
for ( int iDim=0; iDim < 3; iDim++ ) |
|
{ |
|
float flCurOffset = offset * vDims[iDim]; |
|
|
|
for ( int iSign=0; iSign < 2; iSign++ ) |
|
{ |
|
Vector vBase = vOrigin; |
|
vBase[iDim] += (iSign*2-1) * flCurOffset; |
|
|
|
if ( UTIL_IsSpaceEmpty( pMainEnt, vBase + vTestMins, vBase + vTestMaxs ) ) |
|
{ |
|
// Ensure that there is a clear line of sight from the spawnpoint entity to the actual spawn point. |
|
// (Useful for keeping things from spawning behind walls near a spawn point) |
|
trace_t tr; |
|
UTIL_TraceLine( vOrigin, vBase, MASK_SOLID, pMainEnt, COLLISION_GROUP_NONE, &tr ); |
|
|
|
if ( tr.fraction != 1.0 ) |
|
{ |
|
continue; |
|
} |
|
|
|
outPos = MaybeDropToGround( pMainEnt, bDropToGround, vBase, vTestMins, vTestMaxs ); |
|
return true; |
|
} |
|
} |
|
} |
|
|
|
++offset; |
|
} while ( iCurIteration++ < nMaxIterations ); |
|
|
|
// Warning( "EntityPlacementTest for ent %d:%s failed!\n", pMainEnt->entindex(), pMainEnt->GetClassname() ); |
|
return false; |
|
} |
|
|
|
#else // GAME_DLL |
|
|
|
CTFGameRules::~CTFGameRules() |
|
{ |
|
if ( m_pkvVisionFilterTranslations ) |
|
{ |
|
m_pkvVisionFilterTranslations->deleteThis(); |
|
m_pkvVisionFilterTranslations = NULL; |
|
} |
|
|
|
if ( m_pkvVisionFilterShadersMapWhitelist ) |
|
{ |
|
m_pkvVisionFilterShadersMapWhitelist->deleteThis(); |
|
m_pkvVisionFilterShadersMapWhitelist = NULL; |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::OnDataChanged( DataUpdateType_t updateType ) |
|
{ |
|
BaseClass::OnDataChanged( updateType ); |
|
|
|
m_bRecievedBaseline |= updateType == DATA_UPDATE_CREATED; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::HandleOvertimeBegin() |
|
{ |
|
C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer(); |
|
if ( pTFPlayer ) |
|
{ |
|
pTFPlayer->EmitSound( "Game.Overtime" ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::ShouldShowTeamGoal( void ) |
|
{ |
|
|
|
//============================================================================= |
|
// HPE_BEGIN |
|
// [msmith] We always show the team goal when in training. |
|
//============================================================================= |
|
bool showDuringSetup = InSetup(); |
|
|
|
if ( IsInTraining() || IsInItemTestingMode() ) |
|
{ |
|
showDuringSetup = false; |
|
} |
|
|
|
if ( State_Get() == GR_STATE_PREROUND || State_Get() == GR_STATE_RND_RUNNING || showDuringSetup ) |
|
return true; |
|
|
|
//============================================================================= |
|
// HPE_END |
|
//============================================================================= |
|
return false; |
|
} |
|
|
|
#endif |
|
|
|
#ifdef GAME_DLL |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::ShutdownCustomResponseRulesDicts() |
|
{ |
|
DestroyCustomResponseSystems(); |
|
|
|
if ( m_ResponseRules.Count() != 0 ) |
|
{ |
|
int nRuleCount = m_ResponseRules.Count(); |
|
for ( int iRule = 0; iRule < nRuleCount; ++iRule ) |
|
{ |
|
m_ResponseRules[iRule].m_ResponseSystems.Purge(); |
|
} |
|
m_ResponseRules.Purge(); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::InitCustomResponseRulesDicts() |
|
{ |
|
MEM_ALLOC_CREDIT(); |
|
|
|
// Clear if necessary. |
|
ShutdownCustomResponseRulesDicts(); |
|
|
|
// Initialize the response rules for TF. |
|
m_ResponseRules.AddMultipleToTail( TF_CLASS_COUNT_ALL ); |
|
|
|
char szName[512]; |
|
for ( int iClass = TF_FIRST_NORMAL_CLASS; iClass < TF_CLASS_COUNT_ALL; ++iClass ) |
|
{ |
|
m_ResponseRules[iClass].m_ResponseSystems.AddMultipleToTail( MP_TF_CONCEPT_COUNT ); |
|
|
|
for ( int iConcept = 0; iConcept < MP_TF_CONCEPT_COUNT; ++iConcept ) |
|
{ |
|
AI_CriteriaSet criteriaSet; |
|
criteriaSet.AppendCriteria( "playerclass", g_aPlayerClassNames_NonLocalized[iClass] ); |
|
criteriaSet.AppendCriteria( "Concept", g_pszMPConcepts[iConcept] ); |
|
|
|
// 1 point for player class and 1 point for concept. |
|
float flCriteriaScore = 2.0f; |
|
|
|
// Name. |
|
V_sprintf_safe( szName, "%s_%s\n", g_aPlayerClassNames_NonLocalized[iClass], g_pszMPConcepts[iConcept] ); |
|
m_ResponseRules[iClass].m_ResponseSystems[iConcept] = BuildCustomResponseSystemGivenCriteria( "scripts/talker/response_rules.txt", szName, criteriaSet, flCriteriaScore ); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
#ifdef _DEBUG |
|
CON_COMMAND( hud_notify, "Show a hud notification." ) |
|
{ |
|
if ( args.ArgC() < 2 ) |
|
{ |
|
Warning( "Requires one argument, HudNotification_t, between 0 and %i\n", NUM_STOCK_NOTIFICATIONS ); |
|
return; |
|
} |
|
|
|
if ( !TFGameRules() ) |
|
{ |
|
Warning( "Can't do that right now\n" ); |
|
return; |
|
} |
|
|
|
CRecipientFilter filter; |
|
filter.AddAllPlayers(); |
|
TFGameRules()->SendHudNotification( filter, (HudNotification_t) V_atoi(args.Arg(1)) ); |
|
} |
|
#endif |
|
|
|
void CTFGameRules::SendHudNotification( IRecipientFilter &filter, HudNotification_t iType, bool bForceShow /*= false*/ ) |
|
{ |
|
if ( !bForceShow && IsInWaitingForPlayers() ) |
|
return; |
|
|
|
UserMessageBegin( filter, "HudNotify" ); |
|
WRITE_BYTE( iType ); |
|
WRITE_BOOL( bForceShow ); // Display in cl_hud_minmode |
|
MessageEnd(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SendHudNotification( IRecipientFilter &filter, const char *pszText, const char *pszIcon, int iTeam /*= TEAM_UNASSIGNED*/ ) |
|
{ |
|
if ( IsInWaitingForPlayers() ) |
|
return; |
|
|
|
UserMessageBegin( filter, "HudNotifyCustom" ); |
|
WRITE_STRING( pszText ); |
|
WRITE_STRING( pszIcon ); |
|
WRITE_BYTE( iTeam ); |
|
MessageEnd(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Is the player past the required delays for spawning |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::HasPassedMinRespawnTime( CBasePlayer *pPlayer ) |
|
{ |
|
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer ); |
|
|
|
if ( pTFPlayer && pTFPlayer->GetPlayerClass()->GetClassIndex() == TF_CLASS_UNDEFINED ) |
|
return true; |
|
|
|
float flMinSpawnTime = GetMinTimeWhenPlayerMaySpawn( pPlayer ); |
|
|
|
return ( gpGlobals->curtime > flMinSpawnTime ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::ShouldRespawnQuickly( CBasePlayer *pPlayer ) |
|
{ |
|
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer ); |
|
if ( IsPVEModeActive() && pTFPlayer && pTFPlayer->GetTeamNumber() == TF_TEAM_PVE_DEFENDERS && pTFPlayer->GetPlayerClass()->GetClassIndex() == TF_CLASS_SCOUT ) |
|
{ |
|
return true; |
|
} |
|
|
|
#if defined( _DEBUG ) || defined( STAGING_ONLY ) |
|
if ( mp_developer.GetBool() ) |
|
return true; |
|
#endif // _DEBUG || STAGING_ONLY |
|
|
|
if ( IsCompetitiveMode() && State_Get() == GR_STATE_BETWEEN_RNDS ) |
|
return true; |
|
|
|
return BaseClass::ShouldRespawnQuickly( pPlayer ); |
|
} |
|
|
|
typedef bool (*BIgnoreConvarChangeFunc)(void); |
|
|
|
struct convar_tags_t |
|
{ |
|
const char *pszConVar; |
|
const char *pszTag; |
|
BIgnoreConvarChangeFunc ignoreConvarFunc; |
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
static bool BIgnoreConvarChangeInPVEMode(void) |
|
{ |
|
return TFGameRules() && TFGameRules()->IsPVEModeActive(); |
|
} |
|
|
|
// The list of convars that automatically turn on tags when they're changed. |
|
// Convars in this list need to have the FCVAR_NOTIFY flag set on them, so the |
|
// tags are recalculated and uploaded to the master server when the convar is changed. |
|
convar_tags_t convars_to_check_for_tags[] = |
|
{ |
|
{ "mp_friendlyfire", "friendlyfire", NULL }, |
|
{ "tf_birthday", "birthday", NULL }, |
|
{ "mp_respawnwavetime", "respawntimes", NULL }, |
|
{ "mp_fadetoblack", "fadetoblack", NULL }, |
|
{ "tf_weapon_criticals", "nocrits", NULL }, |
|
{ "mp_disable_respawn_times", "norespawntime", NULL }, |
|
{ "tf_gamemode_arena", "arena", NULL }, |
|
{ "tf_gamemode_cp", "cp", NULL }, |
|
{ "tf_gamemode_ctf", "ctf", NULL }, |
|
{ "tf_gamemode_sd", "sd", NULL }, |
|
{ "tf_gamemode_mvm", "mvm", NULL }, |
|
{ "tf_gamemode_payload", "payload", NULL }, |
|
{ "tf_gamemode_rd", "rd", NULL }, |
|
{ "tf_gamemode_pd", "pd", NULL }, |
|
{ "tf_gamemode_tc", "tc", NULL }, |
|
{ "tf_beta_content", "beta", NULL }, |
|
{ "tf_damage_disablespread", "dmgspread", NULL }, |
|
{ "mp_highlander", "highlander", NULL }, |
|
{ "tf_bot_count", "bots", &BIgnoreConvarChangeInPVEMode }, |
|
{ "tf_pve_mode", "pve" }, |
|
{ "sv_registration_successful", "_registered", NULL }, |
|
{ "tf_server_identity_disable_quickplay", "noquickplay", NULL }, |
|
{ "tf_mm_strict", "hidden", NULL }, |
|
{ "tf_medieval", "medieval", NULL }, |
|
{ "mp_holiday_nogifts", "nogifts" }, |
|
{ "tf_powerup_mode", "powerup", NULL }, |
|
{ "tf_gamemode_passtime", "passtime", NULL }, |
|
{ "tf_gamemode_misc", "misc", NULL }, // catch-all for matchmaking to identify sd, tc, and pd servers via sv_tags |
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Engine asks for the list of convars that should tag the server |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::GetTaggedConVarList( KeyValues *pCvarTagList ) |
|
{ |
|
BaseClass::GetTaggedConVarList( pCvarTagList ); |
|
|
|
for ( int i = 0; i < ARRAYSIZE(convars_to_check_for_tags); i++ ) |
|
{ |
|
if ( convars_to_check_for_tags[i].ignoreConvarFunc && convars_to_check_for_tags[i].ignoreConvarFunc() ) |
|
continue; |
|
|
|
KeyValues *pKV = new KeyValues( "tag" ); |
|
pKV->SetString( "convar", convars_to_check_for_tags[i].pszConVar ); |
|
pKV->SetString( "tag", convars_to_check_for_tags[i].pszTag ); |
|
|
|
pCvarTagList->AddSubKey( pKV ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::PlaySpecialCapSounds( int iCappingTeam, CTeamControlPoint *pPoint ) |
|
{ |
|
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_LAKESIDE ) ) |
|
{ |
|
return; |
|
} |
|
|
|
if ( GetGameType() == TF_GAMETYPE_CP ) |
|
{ |
|
bool bPlayControlPointCappedSound = IsInKothMode(); |
|
if ( !bPlayControlPointCappedSound ) |
|
{ |
|
if ( pPoint && ShouldScorePerRound() ) |
|
{ |
|
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL; |
|
if ( pMaster && !pMaster->WouldNewCPOwnerWinGame( pPoint, iCappingTeam ) ) |
|
{ |
|
bPlayControlPointCappedSound = true; |
|
} |
|
} |
|
} |
|
|
|
if ( bPlayControlPointCappedSound ) |
|
{ |
|
for ( int i = FIRST_GAME_TEAM; i < GetNumberOfTeams(); i++ ) |
|
{ |
|
if ( IsInKothMode() ) |
|
{ |
|
BroadcastSound( i, "Hud.PointCaptured" ); |
|
} |
|
|
|
if ( i == iCappingTeam ) |
|
{ |
|
BroadcastSound( i, "Announcer.Success" ); |
|
} |
|
else |
|
{ |
|
BroadcastSound( i, "Announcer.Failure" ); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Factory to create TF-specific mission manager singleton |
|
//----------------------------------------------------------------------------- |
|
CTacticalMissionManager *CTFGameRules::TacticalMissionManagerFactory( void ) |
|
{ |
|
return new CTFTacticalMissionManager; |
|
} |
|
|
|
#endif |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Get the video file name for the current map. |
|
//----------------------------------------------------------------------------- |
|
#ifdef CLIENT_DLL |
|
const char *CTFGameRules::GetVideoFileForMap( bool bWithExtension /*= true*/ ) |
|
{ |
|
char mapname[MAX_MAP_NAME]; |
|
mapname[0] = 0; |
|
|
|
Q_FileBase( engine->GetLevelName(), mapname, sizeof( mapname ) ); |
|
if ( mapname[0] == 0 ) |
|
{ |
|
return NULL; |
|
} |
|
|
|
Q_strlower( mapname ); |
|
return FormatVideoName( (const char *)mapname, bWithExtension ); |
|
} |
|
|
|
//============================================================================= |
|
// HPE_BEGIN |
|
// [msmith] Used for the client to tell the server that we're watching a movie or not. |
|
// Also contains the name of a movie if it's an in game video. |
|
//============================================================================= |
|
//----------------------------------------------------------------------------- |
|
// Purpose: Format a video file name from the name passed in. |
|
//----------------------------------------------------------------------------- |
|
const char *CTFGameRules::FormatVideoName( const char *videoName, bool bWithExtension /*= true*/ ) |
|
{ |
|
|
|
static char strFullpath[MAX_PATH]; // this buffer is returned to the caller |
|
|
|
#ifdef _X360 |
|
// Should we be modifying a const buffer? |
|
// need to remove the .360 extension on the end of the map name |
|
char *pExt = Q_stristr( videoName, ".360" ); |
|
if ( pExt ) |
|
{ |
|
*pExt = '\0'; |
|
} |
|
#endif |
|
|
|
Q_strncpy( strFullpath, "media/", MAX_PATH ); // Assume we must play out of the media directory |
|
|
|
if ( Q_strstr( videoName, "arena_" ) ) |
|
{ |
|
char strTempPath[MAX_PATH]; |
|
Q_strncpy( strTempPath, "media/", MAX_PATH ); |
|
Q_strncat( strTempPath, videoName, MAX_PATH ); |
|
Q_strncat( strTempPath, FILE_EXTENSION_ANY_MATCHING_VIDEO, MAX_PATH ); |
|
|
|
VideoSystem_t vSystem = VideoSystem::NONE; |
|
|
|
// default to arena_intro video if we can't find the specified video |
|
if ( !g_pVideo || g_pVideo->LocatePlayableVideoFile( strTempPath, "GAME", &vSystem, strFullpath, sizeof(strFullpath), VideoSystemFeature::PLAY_VIDEO_FILE_IN_MATERIAL ) != VideoResult::SUCCESS ) |
|
{ |
|
V_strncpy( strFullpath, "media/" "arena_intro", MAX_PATH ); |
|
} |
|
} |
|
else if ( Q_strstr( videoName, "mvm_" ) ) |
|
{ |
|
char strTempPath[MAX_PATH]; |
|
Q_strncpy( strTempPath, "media/", MAX_PATH ); |
|
Q_strncat( strTempPath, videoName, MAX_PATH ); |
|
Q_strncat( strTempPath, FILE_EXTENSION_ANY_MATCHING_VIDEO, MAX_PATH ); |
|
|
|
VideoSystem_t vSystem = VideoSystem::NONE; |
|
|
|
// default to mvm_intro video if we can't find the specified video |
|
if ( !g_pVideo || g_pVideo->LocatePlayableVideoFile( strTempPath, "GAME", &vSystem, strFullpath, sizeof(strFullpath), VideoSystemFeature::PLAY_VIDEO_FILE_IN_MATERIAL ) != VideoResult::SUCCESS ) |
|
{ |
|
V_strncpy( strFullpath, "media/" "mvm_intro", MAX_PATH ); |
|
} |
|
} |
|
else |
|
{ |
|
Q_strncat( strFullpath, videoName, MAX_PATH ); |
|
} |
|
|
|
if ( bWithExtension ) |
|
{ |
|
Q_strncat( strFullpath, FILE_EXTENSION_ANY_MATCHING_VIDEO, MAX_PATH ); // Don't assume any specific video type, let the video services find it |
|
} |
|
|
|
return strFullpath; |
|
} |
|
#endif |
|
//============================================================================= |
|
// HPE_END |
|
//============================================================================= |
|
|
|
#ifdef CLIENT_DLL |
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
const char *GetMapDisplayName( const char *mapName ) |
|
{ |
|
static char szDisplayName[256]; |
|
char szTempName[256]; |
|
const char *pszSrc = NULL; |
|
|
|
szDisplayName[0] = '\0'; |
|
|
|
if ( !mapName ) |
|
return szDisplayName; |
|
|
|
// check our lookup table |
|
Q_strncpy( szTempName, mapName, sizeof( szTempName ) ); |
|
Q_strlower( szTempName ); |
|
pszSrc = szTempName; |
|
|
|
for ( int i = 0; i < ARRAYSIZE( s_ValveMaps ); ++i ) |
|
{ |
|
if ( !Q_stricmp( s_ValveMaps[i].pDiskName, pszSrc ) ) |
|
{ |
|
return s_ValveMaps[i].pDisplayName; |
|
} |
|
} |
|
|
|
// check the community maps that we've featured |
|
for ( int i = 0; i < ARRAYSIZE( s_CommunityMaps ); ++i ) |
|
{ |
|
if ( !Q_stricmp( s_CommunityMaps[i].pDiskName, pszSrc ) ) |
|
{ |
|
return s_CommunityMaps[i].pDisplayName; |
|
} |
|
} |
|
|
|
char *pszFinal = Q_strstr( pszSrc, "_final" ); |
|
if ( pszFinal ) |
|
{ |
|
// truncate the _final (or _final1) part of the filename if it's at the end of the name |
|
char *pszNextChar = pszFinal + Q_strlen( "_final" ); |
|
if ( pszNextChar ) |
|
{ |
|
if ( ( *pszNextChar == '\0' ) || |
|
( ( *pszNextChar == '1' ) && ( *(pszNextChar+1) == '\0' ) ) ) |
|
{ |
|
*pszFinal = '\0'; |
|
} |
|
} |
|
} |
|
|
|
// Our workshop maps will be of the format workshop/cp_somemap.ugc12345 |
|
const char szWorkshop[] = "workshop/"; |
|
if ( V_strncmp( pszSrc, szWorkshop, sizeof( szWorkshop ) - 1 ) == 0 ) |
|
{ |
|
pszSrc += sizeof( szWorkshop ) - 1; |
|
char *pszUGC = V_strstr( pszSrc, ".ugc" ); |
|
int nUGCLen = pszUGC ? strlen( pszUGC ) : 0; |
|
if ( pszUGC && nUGCLen > 4 ) |
|
{ |
|
int i; |
|
for ( i = 4; i < nUGCLen; i ++ ) |
|
{ |
|
if ( pszUGC[i] < '0' || pszUGC[i] > '9' ) |
|
{ |
|
break; |
|
} |
|
} |
|
|
|
if ( i == nUGCLen ) |
|
{ |
|
*pszUGC = '\0'; |
|
} |
|
} |
|
} |
|
|
|
// we haven't found a "friendly" map name, so let's just clean up what we have |
|
if ( !Q_strncmp( pszSrc, "cp_", 3 ) || |
|
!Q_strncmp( pszSrc, "tc_", 3 ) || |
|
!Q_strncmp( pszSrc, "pl_", 3 ) || |
|
!Q_strncmp( pszSrc, "ad_", 3 ) || |
|
!Q_strncmp( pszSrc, "sd_", 3 ) || |
|
!Q_strncmp( pszSrc, "rd_", 3 ) || |
|
!Q_strncmp( pszSrc, "pd_", 3 ) ) |
|
{ |
|
pszSrc += 3; |
|
} |
|
else if ( !Q_strncmp( pszSrc, "ctf_", 4 ) || |
|
!Q_strncmp( pszSrc, "plr_", 4 ) ) |
|
{ |
|
pszSrc += 4; |
|
} |
|
else if ( !Q_strncmp( szTempName, "koth_", 5 ) || |
|
!Q_strncmp( szTempName, "pass_", 5 ) ) |
|
{ |
|
pszSrc += 5; |
|
} |
|
#ifdef TF_RAID_MODE |
|
else if ( !Q_strncmp( pszSrc, "raid_", 5 ) ) |
|
{ |
|
pszSrc += 5; |
|
} |
|
#endif // TF_RAID_MODE |
|
else if ( !Q_strncmp( pszSrc, "mvm_", 4 ) ) |
|
{ |
|
pszSrc += 4; |
|
} |
|
else if ( !Q_strncmp( pszSrc, "arena_", 6 ) ) |
|
{ |
|
pszSrc += 6; |
|
} |
|
|
|
Q_strncpy( szDisplayName, pszSrc, sizeof( szDisplayName ) ); |
|
Q_strupr( szDisplayName ); |
|
|
|
// replace underscores with spaces |
|
for ( char *pszUnderscore = szDisplayName ; pszUnderscore != NULL && *pszUnderscore != 0 ; pszUnderscore++ ) |
|
{ |
|
// Replace it with a space |
|
if ( *pszUnderscore == '_' ) |
|
{ |
|
*pszUnderscore = ' '; |
|
} |
|
} |
|
|
|
return szDisplayName; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
const char *GetMapType( const char *mapName ) |
|
{ |
|
int i; |
|
|
|
if ( mapName ) |
|
{ |
|
for ( i = 0; i < ARRAYSIZE( s_ValveMaps ); ++i ) |
|
{ |
|
if ( !Q_stricmp( s_ValveMaps[i].pDiskName, mapName ) ) |
|
{ |
|
return s_ValveMaps[i].pGameType; |
|
} |
|
} |
|
|
|
// check the community maps that we've featured |
|
for ( i = 0; i < ARRAYSIZE( s_CommunityMaps ); ++i ) |
|
{ |
|
if ( !Q_stricmp( s_CommunityMaps[i].pDiskName, mapName ) ) |
|
{ |
|
return s_CommunityMaps[i].pGameType; |
|
} |
|
} |
|
} |
|
|
|
if ( !IsX360() ) |
|
{ |
|
// we haven't found a "friendly" map name, so let's just clean up what we have |
|
if ( !Q_strnicmp( mapName, "cp_", 3 ) ) |
|
{ |
|
return "#Gametype_CP"; |
|
} |
|
else if ( !Q_strnicmp( mapName, "tc_", 3 ) ) |
|
{ |
|
return "#TF_TerritoryControl"; |
|
} |
|
else if ( !Q_strnicmp( mapName, "pl_", 3 ) ) |
|
{ |
|
return "#Gametype_Escort"; |
|
} |
|
else if ( !Q_strnicmp( mapName, "plr_", 4 ) ) |
|
{ |
|
return "#Gametype_EscortRace"; |
|
} |
|
else if ( !Q_strnicmp( mapName, "ad_", 3 ) ) |
|
{ |
|
return "#TF_AttackDefend"; |
|
} |
|
else if ( !Q_strnicmp( mapName, "ctf_", 4 ) ) |
|
{ |
|
return "#Gametype_CTF"; |
|
} |
|
else if ( !Q_strnicmp( mapName, "koth_", 5 ) ) |
|
{ |
|
return "#Gametype_Koth"; |
|
} |
|
else if ( !Q_strnicmp( mapName, "arena_", 6 ) ) |
|
{ |
|
return "#Gametype_Arena"; |
|
} |
|
else if ( !Q_strnicmp( mapName, "sd_", 3 ) ) |
|
{ |
|
return "#Gametype_SD"; |
|
} |
|
#ifdef TF_RAID_MODE |
|
else if ( !Q_strnicmp( mapName, "raid_", 5 ) ) |
|
{ |
|
return "#Gametype_Raid"; |
|
} |
|
#endif // TF_RAID_MODE |
|
else if ( !Q_strnicmp( mapName, "mvm_", 4 ) ) |
|
{ |
|
return "#Gametype_MVM"; |
|
} |
|
else if ( !Q_strnicmp( mapName, "pass_", 5 ) ) |
|
{ |
|
return "#GameType_Passtime"; |
|
} |
|
else if ( !Q_strnicmp( mapName, "rd_", 3 ) ) |
|
{ |
|
return "#Gametype_RobotDestruction"; |
|
} |
|
else if ( !Q_strnicmp( mapName, "pd_", 3 ) ) |
|
{ |
|
return "#Gametype_PlayerDestruction"; |
|
} |
|
else |
|
{ |
|
if ( TFGameRules() ) |
|
{ |
|
return TFGameRules()->GetGameTypeName(); |
|
} |
|
} |
|
} |
|
|
|
return ""; |
|
} |
|
#endif |
|
|
|
//Arena Mode |
|
bool CTFGameRules::IsInArenaMode( void ) const |
|
{ |
|
return m_nGameType == TF_GAMETYPE_ARENA; |
|
} |
|
|
|
#ifdef GAME_DLL |
|
|
|
//================================================================================================================== |
|
// ARENA LOGIC |
|
BEGIN_DATADESC( CArenaLogic ) |
|
DEFINE_OUTPUT( m_OnArenaRoundStart, "OnArenaRoundStart" ), |
|
DEFINE_OUTPUT( m_OnCapEnabled, "OnCapEnabled" ), |
|
DEFINE_KEYFIELD( m_flTimeToEnableCapPoint, FIELD_FLOAT, "CapEnableDelay" ), |
|
DEFINE_FUNCTION( ArenaLogicThink ), |
|
END_DATADESC() |
|
|
|
LINK_ENTITY_TO_CLASS( tf_logic_arena, CArenaLogic ); |
|
|
|
|
|
void CArenaLogic::Spawn( void ) |
|
{ |
|
BaseClass::Spawn(); |
|
|
|
SetThink( &CArenaLogic::ArenaLogicThink ); |
|
SetNextThink( gpGlobals->curtime ); |
|
} |
|
|
|
void CArenaLogic::ArenaLogicThink( void ) |
|
{ |
|
SetNextThink( gpGlobals->curtime + 0.1f ); |
|
|
|
if ( TFGameRules()->State_Get() != GR_STATE_STALEMATE ) |
|
return; |
|
|
|
if ( TFGameRules() && TFGameRules()->GetCapturePointTime() <= gpGlobals->curtime ) |
|
{ |
|
if ( m_bFiredOutput == false ) |
|
{ |
|
m_bFiredOutput = true; |
|
m_OnCapEnabled.FireOutput( this, this ); |
|
} |
|
} |
|
else if ( TFGameRules() && TFGameRules()->GetCapturePointTime() > gpGlobals->curtime ) |
|
{ |
|
m_bFiredOutput = false; |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: COMPETITIVE LOGIC (why are we shouting?) |
|
//----------------------------------------------------------------------------- |
|
BEGIN_DATADESC( CCompetitiveLogic ) |
|
DEFINE_OUTPUT( m_OnSpawnRoomDoorsShouldLock, "OnSpawnRoomDoorsShouldLock" ), |
|
DEFINE_OUTPUT( m_OnSpawnRoomDoorsShouldUnlock, "OnSpawnRoomDoorsShouldUnlock" ), |
|
END_DATADESC() |
|
LINK_ENTITY_TO_CLASS( tf_logic_competitive, CCompetitiveLogic ); |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CCompetitiveLogic::OnSpawnRoomDoorsShouldLock( void ) |
|
{ |
|
if ( !TFGameRules() || !TFGameRules()->IsCompetitiveMode() ) |
|
return; |
|
|
|
m_OnSpawnRoomDoorsShouldLock.FireOutput( this, this ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CCompetitiveLogic::OnSpawnRoomDoorsShouldUnlock( void ) |
|
{ |
|
if ( !TFGameRules() || !TFGameRules()->IsCompetitiveMode() ) |
|
return; |
|
|
|
m_OnSpawnRoomDoorsShouldUnlock.FireOutput( this, this ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
BEGIN_DATADESC( CLogicMannPower ) |
|
END_DATADESC() |
|
LINK_ENTITY_TO_CLASS( tf_logic_mannpower, CLogicMannPower ); |
|
|
|
//============================================================================= |
|
// Training Mode |
|
CON_COMMAND( training_continue, "Tells training that it should continue." ) |
|
{ |
|
if ( TFGameRules() == NULL || TFGameRules()->IsInTraining() == false || TFGameRules()->GetTrainingModeLogic() == NULL ) |
|
{ |
|
return; |
|
} |
|
TFGameRules()->GetTrainingModeLogic()->OnPlayerWantsToContinue(); |
|
} |
|
|
|
#define SF_TF_DYNAMICPROP_GRENADE_COLLISION 512 |
|
class CTFTrainingDynamicProp : public CDynamicProp |
|
{ |
|
DECLARE_CLASS( CTFTrainingDynamicProp, CDynamicProp ); |
|
public: |
|
}; |
|
LINK_ENTITY_TO_CLASS( training_prop_dynamic, CTFTrainingDynamicProp ); |
|
|
|
bool PropDynamic_CollidesWithGrenades( CBaseEntity *pBaseEntity ) |
|
{ |
|
CTFTrainingDynamicProp *pTrainingDynamicProp = dynamic_cast< CTFTrainingDynamicProp* >( pBaseEntity ); |
|
return ( pTrainingDynamicProp && pTrainingDynamicProp->HasSpawnFlags( SF_TF_DYNAMICPROP_GRENADE_COLLISION) ); |
|
} |
|
|
|
BEGIN_DATADESC( CTrainingModeLogic ) |
|
DEFINE_KEYFIELD( m_nextMapName, FIELD_STRING, "nextMap" ), |
|
DEFINE_INPUTFUNC( FIELD_STRING, "ShowTrainingMsg", InputShowTrainingMsg ), |
|
DEFINE_INPUTFUNC( FIELD_STRING, "ShowTrainingObjective", InputShowTrainingObjective ), |
|
DEFINE_INPUTFUNC( FIELD_VOID, "ForcePlayerSpawnAsClassOutput", InputForcePlayerSpawnAsClassOutput ), |
|
DEFINE_INPUTFUNC( FIELD_VOID, "KickBots", InputKickAllBots ), |
|
DEFINE_INPUTFUNC( FIELD_VOID, "ShowTrainingHUD", InputShowTrainingHUD ), |
|
DEFINE_INPUTFUNC( FIELD_VOID, "HideTrainingHUD", InputHideTrainingHUD ), |
|
DEFINE_INPUTFUNC( FIELD_STRING, "EndTraining", InputEndTraining ), |
|
DEFINE_INPUTFUNC( FIELD_STRING, "PlaySoundOnPlayer", InputPlaySoundOnPlayer ), |
|
DEFINE_INPUTFUNC( FIELD_STRING, "WaitForTimerOrKeypress", InputWaitForTimerOrKeypress ), |
|
DEFINE_INPUTFUNC( FIELD_STRING, "SetNextMap", InputSetNextMap ), |
|
DEFINE_INPUTFUNC( FIELD_STRING, "ForcePlayerSwapToWeapon", InputForcePlayerSwapToWeapon ), |
|
DEFINE_OUTPUT( m_outputOnPlayerSpawnAsScout, "OnPlayerSpawnAsScout" ), |
|
DEFINE_OUTPUT( m_outputOnPlayerSpawnAsSniper, "OnPlayerSpawnAsSniper" ), |
|
DEFINE_OUTPUT( m_outputOnPlayerSpawnAsSoldier, "OnPlayerSpawnAsSoldier" ), |
|
DEFINE_OUTPUT( m_outputOnPlayerSpawnAsDemoman, "OnPlayerSpawnAsDemoman" ), |
|
DEFINE_OUTPUT( m_outputOnPlayerSpawnAsMedic, "OnPlayerSpawnAsMedic" ), |
|
DEFINE_OUTPUT( m_outputOnPlayerSpawnAsHeavy, "OnPlayerSpawnAsHeavy" ), |
|
DEFINE_OUTPUT( m_outputOnPlayerSpawnAsPyro, "OnPlayerSpawnAsPyro" ), |
|
DEFINE_OUTPUT( m_outputOnPlayerSpawnAsSpy, "OnPlayerSpawnAsSpy" ), |
|
DEFINE_OUTPUT( m_outputOnPlayerSpawnAsEngineer, "OnPlayerSpawnAsEngineer" ), |
|
DEFINE_OUTPUT( m_outputOnPlayerDied, "OnPlayerDied" ), |
|
DEFINE_OUTPUT( m_outputOnBotDied, "OnBotDied" ), |
|
DEFINE_OUTPUT( m_outputOnPlayerSwappedToWeaponSlotPrimary, "OnPlayerSwappedToPrimary" ), |
|
DEFINE_OUTPUT( m_outputOnPlayerSwappedToWeaponSlotSecondary, "OnPlayerSwappedToSecondary" ), |
|
DEFINE_OUTPUT( m_outputOnPlayerSwappedToWeaponSlotMelee, "OnPlayerSwappedToMelee" ), |
|
DEFINE_OUTPUT( m_outputOnPlayerSwappedToWeaponSlotBuilding, "OnPlayerSwappedToBuilding" ), |
|
DEFINE_OUTPUT( m_outputOnPlayerSwappedToWeaponSlotPDA, "OnPlayerSwappedToPDA" ), |
|
DEFINE_OUTPUT( m_outputOnPlayerBuiltOutsideSuggestedArea, "OnBuildOutsideArea" ), |
|
DEFINE_OUTPUT( m_outputOnPlayerDetonateBuilding, "OnPlayerDetonateBuilding" ), |
|
END_DATADESC() |
|
|
|
LINK_ENTITY_TO_CLASS( tf_logic_training_mode, CTrainingModeLogic ); |
|
|
|
void CTrainingModeLogic::SetupOnRoundStart() |
|
{ |
|
m_objText[0] = 0; |
|
SetTrainingMsg( "" ); |
|
} |
|
|
|
void CTrainingModeLogic::SetTrainingMsg(const char *msg) |
|
{ |
|
CBroadcastRecipientFilter allusers; |
|
allusers.MakeReliable(); |
|
UserMessageBegin( allusers, "TrainingMsg" ); |
|
WRITE_STRING( msg ); |
|
MessageEnd(); |
|
} |
|
|
|
void CTrainingModeLogic::SetTrainingObjective(const char *text) |
|
{ |
|
CBroadcastRecipientFilter allusers; |
|
allusers.MakeReliable(); |
|
UserMessageBegin( allusers, "TrainingObjective" ); |
|
WRITE_STRING( text ); |
|
MessageEnd(); |
|
} |
|
|
|
void CTrainingModeLogic::OnPlayerSpawned( CTFPlayer* pPlayer ) |
|
{ |
|
if ( pPlayer->GetDesiredPlayerClassIndex() == TF_CLASS_UNDEFINED ) |
|
{ |
|
return; |
|
} |
|
if ( pPlayer->IsFakeClient() ) |
|
{ |
|
return; |
|
} |
|
int iClass = pPlayer->GetPlayerClass()->GetClassIndex(); |
|
switch ( iClass ) |
|
{ |
|
case TF_CLASS_SCOUT: m_outputOnPlayerSpawnAsScout.FireOutput( this, this ); break; |
|
case TF_CLASS_SNIPER: m_outputOnPlayerSpawnAsSniper.FireOutput( this, this ); break; |
|
case TF_CLASS_SOLDIER: m_outputOnPlayerSpawnAsSoldier.FireOutput( this, this ); break; |
|
case TF_CLASS_DEMOMAN: m_outputOnPlayerSpawnAsDemoman.FireOutput( this, this ); break; |
|
case TF_CLASS_MEDIC: m_outputOnPlayerSpawnAsMedic.FireOutput( this, this ); break; |
|
case TF_CLASS_HEAVYWEAPONS: m_outputOnPlayerSpawnAsHeavy.FireOutput( this, this ); break; |
|
case TF_CLASS_PYRO: m_outputOnPlayerSpawnAsPyro.FireOutput( this, this ); break; |
|
case TF_CLASS_SPY: m_outputOnPlayerSpawnAsSpy.FireOutput( this, this ); break; |
|
case TF_CLASS_ENGINEER: m_outputOnPlayerSpawnAsEngineer.FireOutput( this, this ); break; |
|
} |
|
} |
|
|
|
void CTrainingModeLogic::OnPlayerDied( CTFPlayer *pPlayer, CBaseEntity *pKiller ) |
|
{ |
|
m_outputOnPlayerDied.FireOutput( pKiller, this ); |
|
} |
|
|
|
void CTrainingModeLogic::OnBotDied( CTFPlayer *pPlayer, CBaseEntity *pKiller ) |
|
{ |
|
m_outputOnBotDied.FireOutput( pKiller, this ); |
|
} |
|
|
|
void CTrainingModeLogic::OnPlayerSwitchedWeapons( CTFPlayer *pPlayer ) |
|
{ |
|
CTFWeaponBase *pWeapon = (CTFWeaponBase*)pPlayer->GetActiveWeapon(); |
|
if ( pWeapon == NULL ) |
|
{ |
|
return; |
|
} |
|
switch ( pWeapon->GetTFWpnData().m_iWeaponType ) |
|
{ |
|
case TF_WPN_TYPE_PRIMARY: m_outputOnPlayerSwappedToWeaponSlotPrimary.FireOutput( this, this ); break; |
|
case TF_WPN_TYPE_SECONDARY: m_outputOnPlayerSwappedToWeaponSlotSecondary.FireOutput( this, this ); break; |
|
case TF_WPN_TYPE_MELEE: m_outputOnPlayerSwappedToWeaponSlotMelee.FireOutput( this, this ); break; |
|
case TF_WPN_TYPE_BUILDING: m_outputOnPlayerSwappedToWeaponSlotBuilding.FireOutput( this, this ); break; |
|
case TF_WPN_TYPE_PDA: m_outputOnPlayerSwappedToWeaponSlotPDA.FireOutput( this, this ); break; |
|
} |
|
} |
|
|
|
void CTrainingModeLogic::OnPlayerWantsToContinue() |
|
{ |
|
if ( m_waitingForKeypressTimer.Get() != NULL ) |
|
{ |
|
m_waitingForKeypressTimer->FireNamedOutput( "OnTimer", variant_t(), this, this ); |
|
m_waitingForKeypressTimer = NULL; |
|
TFGameRules()->SetIsWaitingForTrainingContinue( false ); |
|
} |
|
} |
|
|
|
void CTrainingModeLogic::OnPlayerBuiltBuilding( CTFPlayer *pPlayer, CBaseObject *pBaseObject ) |
|
{ |
|
if ( pBaseObject && NotifyObjectBuiltInSuggestedArea( *pBaseObject ) == false ) |
|
{ |
|
m_outputOnPlayerBuiltOutsideSuggestedArea.FireOutput( pBaseObject, this ); |
|
} |
|
} |
|
|
|
void CTrainingModeLogic::OnPlayerUpgradedBuilding( CTFPlayer *pPlayer, CBaseObject *pBaseObject ) |
|
{ |
|
if ( pBaseObject ) |
|
{ |
|
NotifyObjectUpgradedInSuggestedArea( *pBaseObject ); |
|
} |
|
} |
|
|
|
void CTrainingModeLogic::OnPlayerDetonateBuilding( CTFPlayer *pPlayer, CBaseObject *pBaseObject ) |
|
{ |
|
m_outputOnPlayerDetonateBuilding.FireOutput( pPlayer, pBaseObject ); |
|
} |
|
|
|
void CTrainingModeLogic::UpdateHUDObjective() |
|
{ |
|
if ( m_objText[0] != 0 ) |
|
{ |
|
SetTrainingObjective( m_objText ); |
|
} |
|
else |
|
{ |
|
SetTrainingObjective(""); |
|
} |
|
} |
|
|
|
const char* CTrainingModeLogic::GetNextMap() |
|
{ |
|
return m_nextMapName.ToCStr(); |
|
} |
|
|
|
const char* CTrainingModeLogic::GetTrainingEndText() |
|
{ |
|
return m_endTrainingText.ToCStr(); |
|
} |
|
|
|
int CTrainingModeLogic::GetDesiredClass() const |
|
{ |
|
return training_class.GetInt(); |
|
} |
|
|
|
void CTrainingModeLogic::InputForcePlayerSpawnAsClassOutput( inputdata_t &inputdata ) |
|
{ |
|
// This is a bit weird, but we will call this for every player--bots should be ignored |
|
CTFPlayer *pPlayer; |
|
for ( int i = 1; i <= gpGlobals->maxClients; i++ ) |
|
{ |
|
pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
|
|
if ( !pPlayer ) |
|
continue; |
|
OnPlayerSpawned( pPlayer ); |
|
} |
|
} |
|
|
|
void CTrainingModeLogic::InputKickAllBots( inputdata_t &inputdata ) |
|
{ |
|
for ( int i = 1; i <= gpGlobals->maxClients; i++ ) |
|
{ |
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
if ( pPlayer && pPlayer->IsFakeClient() ) |
|
{ |
|
engine->ServerCommand( UTIL_VarArgs( "kickid %d\n", pPlayer->GetUserID() ) ); |
|
} |
|
} |
|
} |
|
|
|
void CTrainingModeLogic::InputShowTrainingMsg( inputdata_t &inputdata ) |
|
{ |
|
if ( TFGameRules()->IsInTraining() ) |
|
{ |
|
SetTrainingMsg( inputdata.value.String() ); |
|
} |
|
} |
|
|
|
void CTrainingModeLogic::InputShowTrainingObjective( inputdata_t &inputdata ) |
|
{ |
|
if ( !TFGameRules()->IsInTraining() ) |
|
return; |
|
|
|
//First try to find the unicode string to send over. |
|
wchar_t *strPtr = NULL; |
|
strPtr = g_pVGuiLocalize->Find( inputdata.value.String() ); |
|
|
|
if (NULL == strPtr) |
|
{ |
|
V_strcpy_safe(m_objText, inputdata.value.String()); |
|
} |
|
else |
|
{ |
|
g_pVGuiLocalize->ConvertUnicodeToANSI(strPtr, m_objText, kMaxLengthObjectiveText); |
|
} |
|
|
|
UpdateHUDObjective(); |
|
} |
|
|
|
void CTrainingModeLogic::InputShowTrainingHUD( inputdata_t &inputdata ) |
|
{ |
|
if ( !TFGameRules()->IsInTraining() ) |
|
return; |
|
TFGameRules()->SetTrainingHUDVisible( true ); |
|
} |
|
|
|
void CTrainingModeLogic::InputHideTrainingHUD( inputdata_t &inputdata ) |
|
{ |
|
if ( !TFGameRules()->IsInTraining() ) |
|
return; |
|
TFGameRules()->SetTrainingHUDVisible( false ); |
|
} |
|
|
|
void CTrainingModeLogic::InputEndTraining( inputdata_t &inputdata ) |
|
{ |
|
if ( !TFGameRules()->IsInTraining() ) |
|
return; |
|
|
|
TFGameRules()->SetAllowTrainingAchievements( true ); |
|
|
|
m_endTrainingText = inputdata.value.StringID(); |
|
|
|
CTFPlayer* pHumanPlayer = ToTFPlayer( UTIL_GetListenServerHost() ); |
|
|
|
if (NULL == pHumanPlayer) return; |
|
|
|
int iTeam = pHumanPlayer->GetTeamNumber(); |
|
|
|
bool force_map_reset = true; |
|
CTeamplayRoundBasedRules *pGameRules = dynamic_cast<CTeamplayRoundBasedRules *>( GameRules() ); |
|
pGameRules->SetWinningTeam( iTeam, pGameRules->GetWinReason(), force_map_reset ); |
|
|
|
// Show a training win screen so send that event instead. |
|
IGameEvent *winEvent = gameeventmanager->CreateEvent( "training_complete" ); |
|
if ( winEvent ) |
|
{ |
|
winEvent->SetString( "map", STRING( gpGlobals->mapname ) ); |
|
winEvent->SetString( "next_map", GetNextMap() ); |
|
winEvent->SetString( "text", GetTrainingEndText() ); |
|
|
|
gameeventmanager->FireEvent( winEvent ); |
|
} |
|
} |
|
|
|
void CTrainingModeLogic::InputPlaySoundOnPlayer( inputdata_t &inputdata ) |
|
{ |
|
if ( !TFGameRules()->IsInTraining() ) |
|
return; |
|
CTFPlayer* pHumanPlayer = ToTFPlayer( UTIL_GetListenServerHost() ); |
|
|
|
if (NULL == pHumanPlayer) |
|
return; |
|
|
|
pHumanPlayer->EmitSound( inputdata.value.String() ); |
|
} |
|
|
|
void CTrainingModeLogic::InputWaitForTimerOrKeypress( inputdata_t &inputdata ) |
|
{ |
|
if ( !TFGameRules()->IsInTraining() ) |
|
return; |
|
|
|
m_waitingForKeypressTimer = gEntList.FindEntityByName( NULL, inputdata.value.String() ); |
|
TFGameRules()->SetIsWaitingForTrainingContinue( m_waitingForKeypressTimer.Get() != NULL ); |
|
} |
|
|
|
void CTrainingModeLogic::InputSetNextMap( inputdata_t &inputdata ) |
|
{ |
|
m_nextMapName = AllocPooledString( inputdata.value.String() ); |
|
} |
|
|
|
void CTrainingModeLogic::InputForcePlayerSwapToWeapon( inputdata_t &inputdata ) |
|
{ |
|
CTFPlayer* pHumanPlayer = ToTFPlayer( UTIL_GetListenServerHost() ); |
|
|
|
if (NULL == pHumanPlayer) |
|
return; |
|
|
|
CBaseCombatWeapon *pWeapon = NULL; |
|
|
|
if ( FStrEq( inputdata.value.String(), "primary" ) ) |
|
{ |
|
pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_PRIMARY ); |
|
} |
|
else if ( FStrEq( inputdata.value.String(), "secondary" ) ) |
|
{ |
|
pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_SECONDARY ); |
|
} |
|
else if ( FStrEq( inputdata.value.String(), "melee" ) ) |
|
{ |
|
pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_MELEE ); |
|
} |
|
else if ( FStrEq( inputdata.value.String(), "grenade" ) ) |
|
{ |
|
pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_GRENADE ); |
|
} |
|
else if ( FStrEq( inputdata.value.String(), "building" ) ) |
|
{ |
|
pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_BUILDING ); |
|
} |
|
else if ( FStrEq( inputdata.value.String(), "pda" ) ) |
|
{ |
|
pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_PDA ); |
|
} |
|
else if ( FStrEq( inputdata.value.String(), "item1" ) ) |
|
{ |
|
pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_ITEM1 ); |
|
} |
|
else if ( FStrEq( inputdata.value.String(), "item2" ) ) |
|
{ |
|
pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_ITEM2 ); |
|
} |
|
|
|
if ( pWeapon ) |
|
{ |
|
pHumanPlayer->Weapon_Switch( pWeapon ); |
|
} |
|
|
|
} |
|
|
|
LINK_ENTITY_TO_CLASS( tf_logic_multiple_escort, CMultipleEscort ); |
|
LINK_ENTITY_TO_CLASS( tf_logic_hybrid_ctf_cp, CHybridMap_CTF_CP ); |
|
LINK_ENTITY_TO_CLASS( tf_logic_medieval, CMedievalLogic ); |
|
|
|
|
|
BEGIN_DATADESC(CTFHolidayEntity) |
|
DEFINE_KEYFIELD( m_nHolidayType, FIELD_INTEGER, "holiday_type" ), |
|
DEFINE_KEYFIELD( m_nTauntInHell, FIELD_INTEGER, "tauntInHell" ), |
|
DEFINE_KEYFIELD( m_nAllowHaunting, FIELD_INTEGER, "allowHaunting" ), |
|
|
|
DEFINE_INPUTFUNC( FIELD_INTEGER, "HalloweenSetUsingSpells", InputHalloweenSetUsingSpells ), |
|
DEFINE_INPUTFUNC( FIELD_STRING, "Halloween2013TeleportToHell", InputHalloweenTeleportToHell ), |
|
END_DATADESC(); |
|
|
|
LINK_ENTITY_TO_CLASS( tf_logic_holiday, CTFHolidayEntity ); |
|
|
|
|
|
void CTFHolidayEntity::InputHalloweenSetUsingSpells( inputdata_t &inputdata ) |
|
{ |
|
if ( !TFGameRules() ) |
|
return; |
|
|
|
TFGameRules()->SetUsingSpells( ( inputdata.value.Int() == 0 ) ? false : true ); |
|
} |
|
|
|
void CTFHolidayEntity::InputHalloweenTeleportToHell( inputdata_t &inputdata ) |
|
{ |
|
m_nWinningTeam = FStrEq( "red", inputdata.value.String() ) ? TF_TEAM_RED : TF_TEAM_BLUE; |
|
|
|
CUtlVector< CTFPlayer * > vecPlayers; |
|
CollectPlayers( &vecPlayers, TEAM_ANY, false ); |
|
|
|
FOR_EACH_VEC( vecPlayers, i ) |
|
{ |
|
CTFPlayer *pPlayer = vecPlayers[i]; |
|
// Only do these effects if the player is alive |
|
if ( !pPlayer->IsAlive() ) |
|
continue; |
|
|
|
// Fade to white |
|
color32 fadeColor = {255,255,255,255}; |
|
UTIL_ScreenFade( pPlayer, fadeColor, 2.f, 0.5, FFADE_OUT | FFADE_PURGE ); |
|
|
|
// Do a zoom in effect |
|
pPlayer->SetFOV( pPlayer, 10.f, 2.5f, 0.f ); |
|
// Rumble like something important happened |
|
UTIL_ScreenShake(pPlayer->GetAbsOrigin(), 100.f, 150, 4.f, 0.f, SHAKE_START, true ); |
|
} |
|
|
|
// Play a sound for all players |
|
TFGameRules()->BroadcastSound( 255, "Halloween.hellride" ); |
|
|
|
SetContextThink( &CTFHolidayEntity::Teleport, gpGlobals->curtime + 2.5f, "TeleportToHell" ); |
|
} |
|
|
|
void CTFHolidayEntity::Teleport() |
|
{ |
|
RemoveAll2013HalloweenTeleportSpellsInMidFlight(); |
|
|
|
const char *pszRedString = ( m_nWinningTeam == TF_TEAM_RED ) ? "winner" : "loser"; |
|
const char *pszBlueString = ( m_nWinningTeam == TF_TEAM_BLUE ) ? "winner" : "loser"; |
|
|
|
CUtlVector< CTFPlayer* > vecTeleportedPlayers; |
|
TFGameRules()->TeleportPlayersToTargetEntities( TF_TEAM_RED, CFmtStr( "spawn_loot_%s" , pszRedString ), &vecTeleportedPlayers ); |
|
TFGameRules()->TeleportPlayersToTargetEntities( TF_TEAM_BLUE, CFmtStr( "spawn_loot_%s" , pszBlueString ), &vecTeleportedPlayers ); |
|
|
|
// clear dancer |
|
m_vecDancers.RemoveAll(); |
|
|
|
// remove players' projectiles and buildings from world |
|
TFGameRules()->RemoveAllProjectilesAndBuildings(); |
|
|
|
FOR_EACH_VEC( vecTeleportedPlayers, i ) |
|
{ |
|
CTFPlayer *pPlayer = vecTeleportedPlayers[i]; |
|
|
|
// Roll a new, low-tier spell |
|
CTFSpellBook *pSpellBook = dynamic_cast< CTFSpellBook* >( pPlayer->GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ) ); |
|
if ( pSpellBook ) |
|
{ |
|
pSpellBook->ClearSpell(); |
|
if ( TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_HIGHTOWER ) ) |
|
{ |
|
pSpellBook->RollNewSpell( 0, true ); |
|
} |
|
} |
|
|
|
// Do a zoom effect |
|
pPlayer->SetFOV( pPlayer, tf_teleporter_fov_start.GetInt() ); |
|
pPlayer->SetFOV( pPlayer, 0, 1.f, tf_teleporter_fov_start.GetInt() ); |
|
|
|
// Screen flash |
|
color32 fadeColor = {255,255,255,100}; |
|
UTIL_ScreenFade( pPlayer, fadeColor, 0.25, 0.4, FFADE_IN ); |
|
|
|
const float flDanceTime = 6.f; |
|
|
|
if ( ShouldTauntInHell() || ( TFGameRules()->GetHalloweenScenario() == CTFGameRules::HALLOWEEN_SCENARIO_HIGHTOWER ) ) |
|
{ |
|
pPlayer->m_Shared.AddCond( TF_COND_HALLOWEEN_THRILLER, flDanceTime ); |
|
} |
|
|
|
pPlayer->m_Shared.AddCond( TF_COND_HALLOWEEN_IN_HELL ); |
|
|
|
// Losers get their health set to max. Winners get overhealed |
|
bool bIsWinner = ( pPlayer->GetTeamNumber() == m_nWinningTeam ); |
|
float flMax = bIsWinner ? ( pPlayer->GetMaxHealth() * 1.6f ) : ( pPlayer->GetMaxHealth() * 1.1 ); |
|
float flToHeal = flMax - pPlayer->GetHealth(); |
|
// Overheal the winning team, and just restore the losing team to full health |
|
pPlayer->m_Shared.Heal( pPlayer, flToHeal / flDanceTime, bIsWinner ? 1.5f : 1.f, 1.0f ); |
|
|
|
// Give them full ammo |
|
pPlayer->GiveAmmo( 1000, TF_AMMO_PRIMARY ); |
|
pPlayer->GiveAmmo( 1000, TF_AMMO_SECONDARY ); |
|
pPlayer->GiveAmmo( 1000, TF_AMMO_METAL ); |
|
pPlayer->GiveAmmo( 1000, TF_AMMO_GRENADES1 ); |
|
pPlayer->GiveAmmo( 1000, TF_AMMO_GRENADES2 ); |
|
pPlayer->GiveAmmo( 1000, TF_AMMO_GRENADES3 ); |
|
|
|
// Refills weapon clips, too |
|
for ( int i = 0; i < MAX_WEAPONS; i++ ) |
|
{ |
|
CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase* >( pPlayer->GetWeapon( i ) ); |
|
if ( !pWeapon ) |
|
continue; |
|
|
|
pWeapon->GiveDefaultAmmo(); |
|
|
|
if ( pWeapon->IsEnergyWeapon() ) |
|
{ |
|
pWeapon->WeaponRegenerate(); |
|
} |
|
} |
|
|
|
m_vecDancers.AddToTail( pPlayer ); |
|
} |
|
|
|
// Set this flag. Lets us check elsewhere if it's hell time |
|
if ( TFGameRules() ) |
|
{ |
|
TFGameRules()->SetPlayersInHell( true ); |
|
} |
|
|
|
if ( ShouldTauntInHell() || ( TFGameRules()->GetHalloweenScenario() == CTFGameRules::HALLOWEEN_SCENARIO_HIGHTOWER ) ) |
|
{ |
|
const float flDanceTime = 0.5f; |
|
const float flDanceDuration = 2.75f; |
|
|
|
SetContextThink( &CTFHolidayEntity::HalloweenTeleportToHellDanceThink, gpGlobals->curtime + flDanceTime, "DanceThink1" ); |
|
SetContextThink( &CTFHolidayEntity::HalloweenTeleportToHellDanceThink, gpGlobals->curtime + flDanceTime + flDanceDuration, "DanceThink2" ); |
|
} |
|
} |
|
|
|
|
|
void CTFHolidayEntity::HalloweenTeleportToHellDanceThink( void ) |
|
{ |
|
FOR_EACH_VEC( m_vecDancers, i ) |
|
{ |
|
CTFPlayer* pPlayer = m_vecDancers[i]; |
|
if ( !pPlayer ) |
|
continue; |
|
|
|
// Dance |
|
pPlayer->Taunt(); |
|
} |
|
} |
|
|
|
void CTFHolidayEntity::FireGameEvent( IGameEvent *event ) |
|
{ |
|
const char *eventName = event->GetName(); |
|
|
|
#ifdef GAME_DLL |
|
if ( !Q_strcmp( eventName, "player_turned_to_ghost" ) |
|
|| !Q_strcmp( eventName, "player_disconnect" ) |
|
|| !Q_strcmp( eventName, "player_team" )) |
|
{ |
|
if ( TFGameRules()->ArePlayersInHell() ) |
|
{ |
|
CUtlVector< CTFPlayer * > vecPlayers; |
|
CollectPlayers( &vecPlayers, TF_TEAM_RED, true ); |
|
CollectPlayers( &vecPlayers, TF_TEAM_BLUE, true, true ); |
|
|
|
FOR_EACH_VEC( vecPlayers, i ) |
|
{ |
|
// If everyone is a ghost |
|
if ( !vecPlayers[i]->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) ) |
|
return; |
|
} |
|
|
|
// Everyone is a ghost. Stalemate! |
|
TFGameRules()->SetWinningTeam( TEAM_UNASSIGNED, WINREASON_STALEMATE, true, false ); |
|
} |
|
} |
|
#endif |
|
} |
|
|
|
BEGIN_DATADESC(CKothLogic) |
|
DEFINE_KEYFIELD( m_nTimerInitialLength, FIELD_INTEGER, "timer_length" ), |
|
DEFINE_KEYFIELD( m_nTimeToUnlockPoint, FIELD_INTEGER, "unlock_point" ), |
|
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "RoundSpawn", InputRoundSpawn ), |
|
DEFINE_INPUTFUNC( FIELD_VOID, "RoundActivate", InputRoundActivate ), |
|
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetRedTimer", InputSetRedTimer ), |
|
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetBlueTimer", InputSetBlueTimer ), |
|
DEFINE_INPUTFUNC( FIELD_INTEGER, "AddRedTimer", InputAddRedTimer ), |
|
DEFINE_INPUTFUNC( FIELD_INTEGER, "AddBlueTimer", InputAddBlueTimer ), |
|
END_DATADESC(); |
|
|
|
LINK_ENTITY_TO_CLASS( tf_logic_koth, CKothLogic ); |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CKothLogic::InputRoundSpawn( inputdata_t &input ) |
|
{ |
|
if ( TFGameRules() && TFGameRules()->IsInKothMode() ) |
|
{ |
|
// create the koth team_round_timer entities |
|
variant_t sVariant; |
|
sVariant.SetInt( m_nTimerInitialLength ); |
|
|
|
CTeamRoundTimer *pTimer = NULL; |
|
|
|
pTimer = (CTeamRoundTimer*)CBaseEntity::Create( "team_round_timer", vec3_origin, vec3_angle ); |
|
if ( pTimer ) |
|
{ |
|
TFGameRules()->SetKothTeamTimer( TF_TEAM_BLUE, pTimer ); |
|
pTimer->SetName( MAKE_STRING( "zz_blue_koth_timer" ) ); |
|
pTimer->SetShowInHud( true ); |
|
pTimer->AcceptInput( "SetTime", NULL, NULL, sVariant, 0 ); |
|
pTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 ); |
|
|
|
m_hBlueTimer = pTimer; |
|
} |
|
|
|
pTimer = (CTeamRoundTimer*)CBaseEntity::Create( "team_round_timer", vec3_origin, vec3_angle ); |
|
if ( pTimer ) |
|
{ |
|
TFGameRules()->SetKothTeamTimer( TF_TEAM_RED, pTimer ); |
|
pTimer->SetName( MAKE_STRING( "zz_red_koth_timer" ) ); |
|
pTimer->SetShowInHud( true ); |
|
pTimer->AcceptInput( "SetTime", NULL, NULL, sVariant, 0 ); |
|
pTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 ); |
|
|
|
m_hRedTimer = pTimer; |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CKothLogic::InputRoundActivate( inputdata_t &inputdata ) |
|
{ |
|
if ( TFGameRules() && TFGameRules()->IsInKothMode() ) |
|
{ |
|
CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL; |
|
if ( pMaster ) |
|
{ |
|
variant_t sVariant; |
|
sVariant.SetInt( m_nTimeToUnlockPoint ); |
|
|
|
for ( int i = 0 ; i < pMaster->GetNumPoints() ; i++ ) |
|
{ |
|
CTeamControlPoint *pPoint = pMaster->GetControlPoint( i ); |
|
if ( pPoint ) |
|
{ |
|
pPoint->AcceptInput( "SetLocked", NULL, NULL, sVariant, 0 ); |
|
|
|
if ( m_nTimeToUnlockPoint > 0 ) |
|
{ |
|
pPoint->AcceptInput( "SetUnlockTime", NULL, NULL, sVariant, 0 ); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CKothLogic::InputSetRedTimer( inputdata_t &inputdata ) |
|
{ |
|
if ( TFGameRules() && TFGameRules()->IsInKothMode() ) |
|
{ |
|
if ( m_hRedTimer ) |
|
{ |
|
m_hRedTimer->SetTimeRemaining( inputdata.value.Int() ); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CKothLogic::InputSetBlueTimer( inputdata_t &inputdata ) |
|
{ |
|
if ( TFGameRules() && TFGameRules()->IsInKothMode() ) |
|
{ |
|
if ( m_hBlueTimer ) |
|
{ |
|
m_hBlueTimer->SetTimeRemaining( inputdata.value.Int() ); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CKothLogic::InputAddRedTimer( inputdata_t &inputdata ) |
|
{ |
|
if ( TFGameRules() && TFGameRules()->IsInKothMode() ) |
|
{ |
|
if ( m_hRedTimer ) |
|
{ |
|
m_hRedTimer->AddTimerSeconds( inputdata.value.Int() ); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CKothLogic::InputAddBlueTimer( inputdata_t &inputdata ) |
|
{ |
|
if ( TFGameRules() && TFGameRules()->IsInKothMode() ) |
|
{ |
|
if ( m_hBlueTimer ) |
|
{ |
|
m_hBlueTimer->AddTimerSeconds( inputdata.value.Int() ); |
|
} |
|
} |
|
} |
|
|
|
BEGIN_DATADESC(CCPTimerLogic) |
|
DEFINE_KEYFIELD( m_iszControlPointName, FIELD_STRING, "controlpoint" ), |
|
DEFINE_KEYFIELD( m_nTimerLength, FIELD_INTEGER, "timer_length" ), |
|
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "RoundSpawn", InputRoundSpawn ), |
|
|
|
DEFINE_OUTPUT( m_onCountdownStart, "OnCountdownStart" ), |
|
DEFINE_OUTPUT( m_onCountdown15SecRemain, "OnCountdown15SecRemain" ), |
|
DEFINE_OUTPUT( m_onCountdown10SecRemain, "OnCountdown10SecRemain" ), |
|
DEFINE_OUTPUT( m_onCountdown5SecRemain, "OnCountdown5SecRemain" ), |
|
DEFINE_OUTPUT( m_onCountdownEnd, "OnCountdownEnd" ), |
|
END_DATADESC(); |
|
|
|
LINK_ENTITY_TO_CLASS( tf_logic_cp_timer, CCPTimerLogic ); |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CCPTimerLogic::InputRoundSpawn( inputdata_t &input ) |
|
{ |
|
if ( m_iszControlPointName != NULL_STRING ) |
|
{ |
|
// We need to re-find our control point, because they're recreated over round restarts |
|
m_hControlPoint = dynamic_cast<CTeamControlPoint*>( gEntList.FindEntityByName( NULL, m_iszControlPointName ) ); |
|
if ( !m_hControlPoint ) |
|
{ |
|
Warning( "%s failed to find control point named '%s'\n", GetClassname(), STRING(m_iszControlPointName) ); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CCPTimerLogic::TimerMayExpire( void ) |
|
{ |
|
if ( m_hControlPoint ) |
|
{ |
|
if ( TeamplayGameRules()->TeamMayCapturePoint( TF_TEAM_BLUE, m_hControlPoint->GetPointIndex() ) ) |
|
return false; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CCPTimerLogic::Think( void ) |
|
{ |
|
if ( !TFGameRules() || !ObjectiveResource() ) |
|
return; |
|
|
|
if ( TFGameRules()->State_Get() == GR_STATE_TEAM_WIN ) |
|
{ |
|
// game has already been won, our job is done |
|
m_pointTimer.Invalidate(); |
|
SetContextThink( &CCPTimerLogic::Think, gpGlobals->curtime + 0.15, CP_TIMER_THINK ); |
|
} |
|
|
|
if ( m_hControlPoint ) |
|
{ |
|
if ( TeamplayGameRules()->TeamMayCapturePoint( TF_TEAM_BLUE, m_hControlPoint->GetPointIndex() ) ) |
|
{ |
|
if ( !m_pointTimer.HasStarted() ) |
|
{ |
|
m_pointTimer.Start( m_nTimerLength ); |
|
m_onCountdownStart.FireOutput( this, this ); |
|
|
|
ObjectiveResource()->SetCPTimerTime( m_hControlPoint->GetPointIndex(), gpGlobals->curtime + m_nTimerLength ); |
|
} |
|
else |
|
{ |
|
if ( m_pointTimer.IsElapsed() ) |
|
{ |
|
// the point must be fully owned by the owner before we reset |
|
if ( ObjectiveResource()->GetCappingTeam( m_hControlPoint->GetPointIndex() ) == TEAM_UNASSIGNED ) |
|
{ |
|
m_pointTimer.Invalidate(); |
|
m_onCountdownEnd.FireOutput( this, this ); |
|
m_bFire15SecRemain = m_bFire10SecRemain = m_bFire5SecRemain = true; |
|
|
|
ObjectiveResource()->SetCPTimerTime( m_hControlPoint->GetPointIndex(), -1.0f ); |
|
} |
|
} |
|
else |
|
{ |
|
float flRemainingTime = m_pointTimer.GetRemainingTime(); |
|
|
|
if ( flRemainingTime <= 15.0f && m_bFire15SecRemain ) |
|
{ |
|
m_bFire15SecRemain = false; |
|
} |
|
else if ( flRemainingTime <= 10.0f && m_bFire10SecRemain ) |
|
{ |
|
m_bFire10SecRemain = false; |
|
} |
|
else if ( flRemainingTime <= 5.0f && m_bFire5SecRemain ) |
|
{ |
|
m_bFire5SecRemain = false; |
|
} |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
m_pointTimer.Invalidate(); |
|
} |
|
} |
|
|
|
SetContextThink( &CCPTimerLogic::Think, gpGlobals->curtime + 0.15, CP_TIMER_THINK ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::AddPlayerToQueue( CTFPlayer *pPlayer ) |
|
{ |
|
//Already in Queue |
|
if ( m_hArenaPlayerQueue.Find( pPlayer ) != m_hArenaPlayerQueue.InvalidIndex() ) |
|
return; |
|
|
|
if ( pPlayer->IsArenaSpectator() == true ) |
|
return; |
|
|
|
// Msg( "AddPlayerToQueue:: Adding to queue: %s\n", pPlayer->GetPlayerName() ); |
|
|
|
m_hArenaPlayerQueue.AddToTail( pPlayer ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::AddPlayerToQueueHead( CTFPlayer *pPlayer ) |
|
{ |
|
//Already in Queue |
|
if ( m_hArenaPlayerQueue.Find( pPlayer ) != m_hArenaPlayerQueue.InvalidIndex() ) |
|
return; |
|
|
|
m_hArenaPlayerQueue.AddToHead( pPlayer ); |
|
|
|
// Msg( "AddPlayerToQueueHead:: Adding to queue: %s\n", pPlayer->GetPlayerName() ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::RemovePlayerFromQueue( CTFPlayer *pPlayer ) |
|
{ |
|
//Not in list? |
|
if ( m_hArenaPlayerQueue.Find( pPlayer ) == m_hArenaPlayerQueue.InvalidIndex() ) |
|
return; |
|
|
|
m_hArenaPlayerQueue.FindAndRemove( pPlayer ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::OnNavMeshLoad( void ) |
|
{ |
|
TheNavMesh->SetPlayerSpawnName( "info_player_teamspawn" ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::OnDispenserBuilt( CBaseEntity *dispenser ) |
|
{ |
|
if ( !m_healthVector.HasElement( dispenser ) ) |
|
{ |
|
m_healthVector.AddToTail( dispenser ); |
|
} |
|
|
|
if ( !m_ammoVector.HasElement( dispenser ) ) |
|
{ |
|
m_ammoVector.AddToTail( dispenser ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::OnDispenserDestroyed( CBaseEntity *dispenser ) |
|
{ |
|
m_healthVector.FindAndFastRemove( dispenser ); |
|
m_ammoVector.FindAndFastRemove( dispenser ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
CPhysicsProp *CreateBeachBall( const Vector &vSpawnPos, const QAngle &qSpawnAngles ); |
|
CPhysicsProp *CreateSoccerBall( const Vector &vSpawnPos, const QAngle &qSpawnAngles ); |
|
|
|
#ifdef STAGING_ONLY |
|
//------------------------------------------------------------------------------ |
|
// Purpose: |
|
//------------------------------------------------------------------------------ |
|
void CC_Spawn_SoccerBall( const CCommand& args ) |
|
{ |
|
CBasePlayer *pPlayer = UTIL_GetCommandClient(); |
|
if ( pPlayer ) |
|
{ |
|
trace_t tr; |
|
Vector forward; |
|
pPlayer->EyeVectors( &forward ); |
|
UTIL_TraceLine( pPlayer->EyePosition(), |
|
pPlayer->EyePosition() + forward * MAX_TRACE_LENGTH,MASK_NPCSOLID, |
|
pPlayer, COLLISION_GROUP_NONE, &tr ); |
|
if ( tr.fraction != 1.0 ) |
|
{ |
|
CreateSoccerBall( tr.endpos, vec3_angle ); |
|
} |
|
} |
|
} |
|
|
|
ConCommand tf_spawn_soccerball( "tf_spawn_soccerball", CC_Spawn_SoccerBall, "", FCVAR_CHEAT ); |
|
#endif // STAGING_ONLY |
|
|
|
static bool CanFindBallSpawnLocation( const Vector& vSearchOrigin, Vector *out_pvDropSpot ) |
|
{ |
|
// find clear space to drop the ball |
|
for( float angle = 0.0f; angle < 2.0f * M_PI; angle += 0.2f ) |
|
{ |
|
Vector forward; |
|
FastSinCos( angle, &forward.y, &forward.x ); |
|
forward.z = 0.0f; |
|
|
|
const float ballRadius = 16.0f; |
|
const float playerRadius = 20.0f; |
|
|
|
Vector hullMins( -ballRadius, -ballRadius, -ballRadius ); |
|
Vector hullMaxs( ballRadius, ballRadius, ballRadius ); |
|
|
|
Vector dropSpot = vSearchOrigin + 1.2f * ( playerRadius + ballRadius ) * forward; |
|
|
|
trace_t result; |
|
UTIL_TraceHull( dropSpot, dropSpot, hullMins, hullMaxs, MASK_PLAYERSOLID, NULL, &result ); |
|
|
|
if ( !result.DidHit() ) |
|
{ |
|
*out_pvDropSpot = dropSpot; |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
void CTFGameRules::OnPlayerSpawned( CTFPlayer *pPlayer ) |
|
{ |
|
// coach? |
|
CSteamID steamIDForPlayer; |
|
if ( pPlayer->GetSteamID( &steamIDForPlayer ) ) |
|
{ |
|
// find out if we are supposed to coach |
|
int idx = m_mapCoachToStudentMap.Find( steamIDForPlayer.GetAccountID() ); |
|
if ( m_mapCoachToStudentMap.IsValidIndex( idx ) ) |
|
{ |
|
// find student |
|
uint32 studentAccountID = m_mapCoachToStudentMap[idx]; |
|
CSteamID steamIDForStudent; |
|
for ( int i = 1; i <= gpGlobals->maxClients; i++ ) |
|
{ |
|
CTFPlayer *pPotentialStudent = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
if ( NULL == pPotentialStudent ) |
|
{ |
|
continue; |
|
} |
|
// is this the student? |
|
if ( pPotentialStudent->GetSteamID( &steamIDForStudent ) && steamIDForStudent.GetAccountID() == studentAccountID ) |
|
{ |
|
Coaching_Start( pPlayer, pPotentialStudent ); |
|
// @todo (Tom Bui): Not sure this is required--nothing seems to use it |
|
// engine->ClientCommand( pPlayer->edict(), "cl_spec_mode %d", OBS_MODE_IN_EYE ); |
|
// finally, notify the GC |
|
GCSDK::CProtoBufMsg< CMsgTFCoaching_CoachJoined > msg( k_EMsgGCCoaching_CoachJoined ); |
|
msg.Body().set_account_id_coach( steamIDForPlayer.GetAccountID() ); |
|
GCClientSystem()->BSendMessage( msg ); |
|
break; |
|
} |
|
} |
|
// remove from the map now so the coach can join later as a normal player if they DC |
|
m_mapCoachToStudentMap.RemoveAt( idx ); |
|
} |
|
} |
|
// warp coach to student? |
|
if ( pPlayer->GetCoach() ) |
|
{ |
|
// warp the coach to student |
|
pPlayer->GetCoach()->SetObserverTarget( pPlayer ); |
|
pPlayer->GetCoach()->StartObserverMode( OBS_MODE_CHASE ); |
|
} |
|
|
|
// notify training |
|
if ( m_hTrainingModeLogic ) |
|
{ |
|
m_hTrainingModeLogic->OnPlayerSpawned( pPlayer ); |
|
} |
|
|
|
#ifdef GAME_DLL |
|
if ( !IsInTraining() ) |
|
{ |
|
// Birthday beachball ball spawning. |
|
if ( IsBirthday() && |
|
!m_hasSpawnedToy && |
|
pPlayer->GetTeamNumber() == TF_TEAM_BLUE && // always give ball to first blue player, since they are often trapped during setup |
|
RandomInt( 0, 100 ) < tf_birthday_ball_chance.GetInt() ) |
|
{ |
|
Vector vDropSpot; |
|
if ( CanFindBallSpawnLocation( pPlayer->WorldSpaceCenter(), &vDropSpot ) ) |
|
{ |
|
CPhysicsProp *ball = CreateBeachBall( vDropSpot, pPlayer->GetAbsAngles() ); |
|
if ( ball ) |
|
{ |
|
m_hasSpawnedToy = true; |
|
|
|
// turn on the birthday skin |
|
ball->m_nSkin = 1; |
|
} |
|
} |
|
} |
|
|
|
// Soccer ball spawning if wearing soccer cleats. |
|
if ( !m_bHasSpawnedSoccerBall[ pPlayer->GetTeamNumber() ] ) |
|
{ |
|
enum |
|
{ |
|
kSpawnWith_Nothing = 0, |
|
kSpawnWith_SoccerBall = 1, |
|
}; |
|
|
|
int iSpawnWithPhysicsToy = kSpawnWith_Nothing; |
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer, iSpawnWithPhysicsToy, spawn_with_physics_toy ); |
|
if ( iSpawnWithPhysicsToy == kSpawnWith_SoccerBall ) |
|
{ |
|
Vector vDropSpot; |
|
if ( CanFindBallSpawnLocation( pPlayer->WorldSpaceCenter(), &vDropSpot ) ) |
|
{ |
|
CPhysicsProp *ball = CreateSoccerBall( vDropSpot, pPlayer->GetAbsAngles() ); |
|
if ( ball ) |
|
{ |
|
m_bHasSpawnedSoccerBall[ pPlayer->GetTeamNumber() ] = true; |
|
|
|
// turn on the birthday skin |
|
ball->m_nSkin = pPlayer->GetTeamNumber() == TF_TEAM_BLUE ? 1 : 0; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
#endif |
|
} |
|
|
|
|
|
class CGCCoaching_CoachJoining : public GCSDK::CGCClientJob |
|
{ |
|
public: |
|
CGCCoaching_CoachJoining( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {} |
|
|
|
virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket ) |
|
{ |
|
GCSDK::CProtoBufMsg< CMsgTFCoaching_CoachJoining > msg( pNetPacket ); |
|
if ( TFGameRules() ) |
|
{ |
|
TFGameRules()->OnCoachJoining( msg.Body().account_id_coach(), msg.Body().account_id_student() ); |
|
} |
|
return true; |
|
} |
|
}; |
|
GC_REG_JOB( GCSDK::CGCClient, CGCCoaching_CoachJoining, "CGCCoaching_CoachJoining", k_EMsgGCCoaching_CoachJoining, GCSDK::k_EServerTypeGCClient ); |
|
|
|
class CGCCoaching_RemoveCurrentCoach : public GCSDK::CGCClientJob |
|
{ |
|
public: |
|
CGCCoaching_RemoveCurrentCoach( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {} |
|
|
|
virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket ) |
|
{ |
|
GCSDK::CProtoBufMsg< CMsgTFCoaching_RemoveCurrentCoach > msg( pNetPacket ); |
|
if ( TFGameRules() ) |
|
{ |
|
TFGameRules()->OnRemoveCoach( msg.Body().account_id_coach() ); |
|
} |
|
return true; |
|
} |
|
}; |
|
GC_REG_JOB( GCSDK::CGCClient, CGCCoaching_RemoveCurrentCoach, "CGCCoaching_RemoveCurrentCoach", k_EMsgGCCoaching_RemoveCurrentCoach, GCSDK::k_EServerTypeGCClient ); |
|
|
|
class CGCUseServerModificationItemJob : public GCSDK::CGCClientJob |
|
{ |
|
public: |
|
CGCUseServerModificationItemJob( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {} |
|
|
|
virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket ) |
|
{ |
|
GCSDK::CProtoBufMsg<CMsgGC_GameServer_UseServerModificationItem> msg( pNetPacket ); |
|
|
|
// If this server doesn't have the capability to call a vote right now for whatever reason, we |
|
// give up and return immediate failure to the GC. If the vote gets called, we'll send up pass/fail |
|
// when it finishes. |
|
if ( !g_voteController || !g_voteController->CreateVote( DEDICATED_SERVER, "eternaween", "" ) ) |
|
{ |
|
GCSDK::CProtoBufMsg<CMsgGC_GameServer_UseServerModificationItem_Response> msgResponse( k_EMsgGC_GameServer_UseServerModificationItem_Response ); |
|
msgResponse.Body().set_server_response_code( CMsgGC_GameServer_UseServerModificationItem_Response::kServerModificationItemServerResponse_NoVoteCalled ); |
|
m_pGCClient->BSendMessage( msgResponse ); |
|
} |
|
|
|
return true; |
|
} |
|
}; |
|
GC_REG_JOB( GCSDK::CGCClient, CGCUseServerModificationItemJob, "CGCUseServerModificationItemJob", k_EMsgGC_GameServer_UseServerModificationItem, GCSDK::k_EServerTypeGCClient ); |
|
|
|
class CGCUpdateServerModificationItemStateJob : public GCSDK::CGCClientJob |
|
{ |
|
public: |
|
CGCUpdateServerModificationItemStateJob( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {} |
|
|
|
virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket ) |
|
{ |
|
GCSDK::CProtoBufMsg<CMsgGC_GameServer_ServerModificationItem> msg( pNetPacket ); |
|
|
|
switch ( msg.Body().modification_type() ) |
|
{ |
|
case kGameServerModificationItem_Halloween: |
|
tf_item_based_forced_holiday.SetValue( msg.Body().active() ? kHoliday_Halloween : kHoliday_None ); |
|
g_fEternaweenAutodisableTime = engine->Time() + (SERVER_MODIFICATION_ITEM_DURATION_IN_MINUTES * 60.0f); |
|
if ( TFGameRules() ) |
|
{ |
|
TFGameRules()->FlushAllAttributeCaches(); |
|
} |
|
break; |
|
default: |
|
Warning( "%s: unknown modification type %u for server item.\n", __FUNCTION__, msg.Body().modification_type() ); |
|
break; |
|
} |
|
|
|
return true; |
|
} |
|
}; |
|
GC_REG_JOB( GCSDK::CGCClient, CGCUpdateServerModificationItemStateJob, "CGCUpdateServerModificationItemStateJob", k_EMsgGC_GameServer_ModificationItemState, GCSDK::k_EServerTypeGCClient ); |
|
|
|
#ifdef _DEBUG |
|
CON_COMMAND( coaching_stop, "Stop coaching" ) |
|
{ |
|
CTFPlayer* pCoach = ToTFPlayer( UTIL_GetListenServerHost() ); |
|
Coaching_Stop( pCoach ); |
|
} |
|
|
|
CON_COMMAND( coaching_remove_coach, "Remove current coach" ) |
|
{ |
|
CTFPlayer* pStudent = ToTFPlayer( UTIL_GetListenServerHost() ); |
|
CTFPlayer *pCoach = pStudent->GetCoach(); |
|
if ( pCoach ) |
|
{ |
|
Coaching_Stop( pCoach ); |
|
} |
|
} |
|
|
|
CON_COMMAND( coaching_force_coach, "Force self as coach" ) |
|
{ |
|
CTFPlayer* pCoachPlayer = ToTFPlayer( UTIL_GetListenServerHost() ); |
|
if ( pCoachPlayer && TFGameRules() ) |
|
{ |
|
for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ ) |
|
{ |
|
CTFPlayer *pStudentPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
if ( pStudentPlayer != pCoachPlayer ) |
|
{ |
|
Coaching_Start( pCoachPlayer, pStudentPlayer ); |
|
break; |
|
} |
|
} |
|
} |
|
} |
|
|
|
CON_COMMAND( coaching_force_student, "Force self as student" ) |
|
{ |
|
CTFPlayer* pStudentPlayer = ToTFPlayer( UTIL_GetListenServerHost() ); |
|
if ( pStudentPlayer && TFGameRules() ) |
|
{ |
|
for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ ) |
|
{ |
|
CTFPlayer *pCoachPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
if ( pCoachPlayer != pStudentPlayer ) |
|
{ |
|
Coaching_Start( pCoachPlayer, pStudentPlayer ); |
|
break; |
|
} |
|
} |
|
} |
|
} |
|
#endif |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::OnCoachJoining( uint32 unCoachAccountID, uint32 unStudentAccountID ) |
|
{ |
|
m_mapCoachToStudentMap.Insert( unCoachAccountID, unStudentAccountID ); |
|
// see if the coach is on the server already |
|
CSteamID steamIDForCoach; |
|
for ( int i = 1; i <= gpGlobals->maxClients; i++ ) |
|
{ |
|
CTFPlayer *pPotentialCoach = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
if ( NULL == pPotentialCoach ) |
|
{ |
|
continue; |
|
} |
|
// coach is here, force them to respawn, which will set them up as a coach |
|
if ( pPotentialCoach->GetSteamID( &steamIDForCoach ) && steamIDForCoach.GetAccountID() == unCoachAccountID ) |
|
{ |
|
pPotentialCoach->ForceRespawn(); |
|
return; |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::OnRemoveCoach( uint32 unCoachAccountID ) |
|
{ |
|
m_mapCoachToStudentMap.Remove( unCoachAccountID ); |
|
for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ ) |
|
{ |
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
CSteamID steamID; |
|
if ( pPlayer && pPlayer->GetSteamID( &steamID ) && steamID.GetAccountID() == unCoachAccountID ) |
|
{ |
|
Coaching_Stop( pPlayer ); |
|
return; |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Activates 100% crits for an entire team for a short period of time |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::HandleCTFCaptureBonus( int nTeam ) |
|
{ |
|
float flBonusTime = GetCTFCaptureBonusTime(); |
|
|
|
if ( flBonusTime <= 0 ) |
|
return; |
|
|
|
for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ ) |
|
{ |
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
if ( pPlayer && pPlayer->IsAlive() && pPlayer->GetTeamNumber() == nTeam ) |
|
{ |
|
pPlayer->m_Shared.AddCond( TF_COND_CRITBOOSTED_CTF_CAPTURE, flBonusTime ); |
|
} |
|
} |
|
} |
|
#endif |
|
|
|
int CTFGameRules::GetStatsMinimumPlayers( void ) |
|
{ |
|
if ( IsInArenaMode() == true ) |
|
{ |
|
return 1; |
|
} |
|
|
|
return 3; |
|
} |
|
|
|
int CTFGameRules::GetStatsMinimumPlayedTime( void ) |
|
{ |
|
if ( IsInArenaMode() == true ) |
|
{ |
|
return tf_arena_preround_time.GetFloat(); |
|
} |
|
|
|
return 4 * 60; //Default of 4 minutes |
|
} |
|
|
|
bool CTFGameRules::IsConnectedUserInfoChangeAllowed( CBasePlayer *pPlayer ) |
|
{ |
|
CTFPlayer* pTFPlayer = NULL; |
|
#ifdef GAME_DLL |
|
pTFPlayer = ToTFPlayer( pPlayer ); |
|
#else |
|
pTFPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() ); |
|
#endif |
|
|
|
if( pTFPlayer ) |
|
{ |
|
// We can change if we're not alive |
|
if( pTFPlayer->m_lifeState != LIFE_ALIVE ) |
|
return true; |
|
|
|
// We can change if we're not on team red or blue |
|
int iPlayerTeam = pTFPlayer->GetTeamNumber(); |
|
if( ( iPlayerTeam != TF_TEAM_RED ) && ( iPlayerTeam != TF_TEAM_BLUE ) ) |
|
return true; |
|
|
|
// We can change if we've respawned/changed classes within the last 2 seconds. |
|
// This allows for <classname>.cfg files to change these types of convars |
|
float flRespawnTime = 0.f; |
|
#ifdef GAME_DLL |
|
flRespawnTime = pTFPlayer->GetSpawnTime(); // Called everytime the player respawns |
|
#else |
|
flRespawnTime = pTFPlayer->GetClassChangeTime(); // Called when the player changes class and respawns |
|
#endif |
|
if( ( gpGlobals->curtime - flRespawnTime ) < 2.f ) |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
//======================================================================================================================== |
|
// BONUS ROUND HANDLING |
|
//======================================================================================================================== |
|
#ifdef GAME_DLL |
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::ShouldGoToBonusRound( void ) |
|
{ |
|
// Only do this on a Valve official server. Use the presence of our DLL as a key. |
|
return false; |
|
|
|
if ( IsInTournamentMode() ) |
|
return false; |
|
|
|
// Don't do this on empty servers |
|
if ( !BHavePlayers() ) |
|
return false; |
|
if ( TFTeamMgr()->GetTeam( TF_TEAM_RED )->GetNumPlayers() <= 0 ) |
|
return false; |
|
if ( TFTeamMgr()->GetTeam( TF_TEAM_BLUE )->GetNumPlayers() <= 0 ) |
|
return false; |
|
|
|
// Random chance per round, based on time. |
|
float flRoundTime = gpGlobals->curtime - m_flRoundStartTime; |
|
float flChance = RemapValClamped( flRoundTime, (3 * 60), (30 * 60), 0.0, 0.75 ); // 75% chance for > 30 min rounds, down to 0% at 3 min rounds |
|
float flRoll = RandomFloat( 0, 1 ); |
|
return ( flRoll < flChance ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetupOnBonusStart( void ) |
|
{ |
|
m_hBonusLogic.Set( dynamic_cast<CBonusRoundLogic*>(CreateEntityByName( "tf_logic_bonusround" )) ); |
|
if ( !m_hBonusLogic.Get()->InitBonusRound() ) |
|
{ |
|
State_Transition( GR_STATE_PREROUND ); |
|
return; |
|
} |
|
|
|
// Bring up the giveaway panel on all the players |
|
for ( int i = 1; i <= MAX_PLAYERS; i++ ) |
|
{ |
|
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i ); |
|
if ( !pPlayer ) |
|
continue; |
|
|
|
pPlayer->ShowViewPortPanel( PANEL_GIVEAWAY_ITEM ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetupOnBonusEnd( void ) |
|
{ |
|
if ( m_hBonusLogic.Get() ) |
|
{ |
|
UTIL_Remove( m_hBonusLogic.Get() ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::BonusStateThink( void ) |
|
{ |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: We need to abort the bonus state because our item generation failed. |
|
// Steam is probably down. |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::BonusStateAbort( void ) |
|
{ |
|
if ( m_hBonusLogic.Get() ) |
|
{ |
|
m_hBonusLogic.Get()->SetBonusStateAborted( true ); |
|
} |
|
|
|
State_Transition( GR_STATE_PREROUND ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::BetweenRounds_Start( void ) |
|
{ |
|
SetSetup( true ); |
|
|
|
if ( IsMannVsMachineMode() ) |
|
{ |
|
mp_tournament.SetValue( true ); |
|
RestartTournament(); |
|
SetInStopWatch( false ); |
|
|
|
char szName[16]; |
|
Q_strncpy( szName, "ROBOTS", MAX_TEAMNAME_STRING + 1 ); |
|
mp_tournament_blueteamname.SetValue( szName ); |
|
Q_strncpy( szName, "MANNCO", MAX_TEAMNAME_STRING + 1 ); |
|
mp_tournament_redteamname.SetValue( szName ); |
|
SetTeamReadyState( true, TF_TEAM_PVE_INVADERS ); |
|
} |
|
|
|
for ( int i = 0; i < IBaseObjectAutoList::AutoList().Count(); ++i ) |
|
{ |
|
CBaseObject *pObj = static_cast<CBaseObject*>( IBaseObjectAutoList::AutoList()[i] ); |
|
if ( pObj->IsDisposableBuilding() || pObj->GetTeamNumber() == TF_TEAM_PVE_INVADERS ) |
|
{ |
|
pObj->DetonateObject(); |
|
} |
|
} |
|
|
|
if ( m_hGamerulesProxy ) |
|
{ |
|
m_hGamerulesProxy->StateEnterBetweenRounds(); |
|
} |
|
|
|
if ( m_hCompetitiveLogicEntity ) |
|
{ |
|
m_hCompetitiveLogicEntity->OnSpawnRoomDoorsShouldUnlock(); |
|
} |
|
|
|
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() ); |
|
if ( pMatchDesc && pMatchDesc->m_params.m_bAutoReady ) |
|
{ |
|
for ( int i = 1; i <= MAX_PLAYERS; i++ ) |
|
{ |
|
CTFPlayer *pPlayer = static_cast<CTFPlayer*>( UTIL_PlayerByIndex( i ) ); |
|
if ( !pPlayer ) |
|
continue; |
|
|
|
if ( IsValidTFTeam( pPlayer->GetTeamNumber() ) && pPlayer->GetPlayerClass() && IsValidTFPlayerClass( pPlayer->GetPlayerClass()->GetClassIndex() ) ) |
|
{ |
|
PlayerReadyStatus_UpdatePlayerState( pPlayer, true ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::BetweenRounds_End( void ) |
|
{ |
|
SetInWaitingForPlayers( false ); |
|
SetSetup( false ); |
|
|
|
if ( IsMannVsMachineMode() ) |
|
{ |
|
SetInStopWatch( false ); |
|
mp_tournament_stopwatch.SetValue( false ); |
|
} |
|
|
|
for ( int i = 1; i <= MAX_PLAYERS; i++ ) |
|
{ |
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) ); |
|
if ( !pPlayer ) |
|
continue; |
|
|
|
// We don't consider inactivity during BetweenRounds as idle |
|
pPlayer->ResetIdleCheck(); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::BetweenRounds_Think( void ) |
|
{ |
|
if ( UsePlayerReadyStatusMode() ) |
|
{ |
|
// Everyone is ready, or the drop-dead timer naturally ticked down to mp_tournament_readymode_countdown |
|
bool bStartFinalCountdown = ( PlayerReadyStatus_ShouldStartCountdown() || ( m_flRestartRoundTime > 0 && (int)( m_flRestartRoundTime - gpGlobals->curtime ) == mp_tournament_readymode_countdown.GetInt() ) ); |
|
|
|
// It's the FINAL COUNTDOOOWWWNNnnnnnnnnn |
|
float flDropDeadTime = gpGlobals->curtime + mp_tournament_readymode_countdown.GetFloat() + 0.1f; |
|
if ( bStartFinalCountdown && ( m_flRestartRoundTime < 0 || m_flRestartRoundTime >= flDropDeadTime ) ) |
|
{ |
|
float flDelay = IsMannVsMachineMode() ? 10.f : mp_tournament_readymode_countdown.GetFloat(); |
|
m_flRestartRoundTime.Set( gpGlobals->curtime + flDelay ); |
|
ShouldResetScores( true, true ); |
|
ShouldResetRoundsPlayed( true ); |
|
|
|
if ( IsCompetitiveMode() ) |
|
{ |
|
m_flCompModeRespawnPlayersAtMatchStart = gpGlobals->curtime + 2.0; |
|
} |
|
} |
|
|
|
// Required for UI state |
|
if ( PlayerReadyStatus_HaveMinPlayersToEnable() ) |
|
{ |
|
CheckReadyRestart(); |
|
} |
|
} |
|
|
|
CheckRespawnWaves(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::PreRound_Start( void ) |
|
{ |
|
if ( m_hGamerulesProxy ) |
|
{ |
|
m_hGamerulesProxy->StateEnterPreRound(); |
|
} |
|
|
|
if ( m_hCompetitiveLogicEntity ) |
|
{ |
|
m_hCompetitiveLogicEntity->OnSpawnRoomDoorsShouldLock(); |
|
} |
|
|
|
BaseClass::PreRound_Start(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::PreRound_End( void ) |
|
{ |
|
if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) && !IsInWaitingForPlayers() ) |
|
{ |
|
if ( RandomFloat( 0, 1 ) < HELLTOWER_RARE_LINE_CHANCE ) |
|
{ |
|
PlayHelltowerAnnouncerVO( HELLTOWER_VO_RED_ROUNDSTART_RARE, HELLTOWER_VO_BLUE_ROUNDSTART_RARE ); |
|
} |
|
else |
|
{ |
|
PlayHelltowerAnnouncerVO( HELLTOWER_VO_RED_ROUNDSTART, HELLTOWER_VO_BLUE_ROUNDSTART ); |
|
} |
|
} |
|
|
|
if ( m_hGamerulesProxy ) |
|
{ |
|
m_hGamerulesProxy->StateExitPreRound(); |
|
} |
|
|
|
if ( m_hCompetitiveLogicEntity ) |
|
{ |
|
m_hCompetitiveLogicEntity->OnSpawnRoomDoorsShouldUnlock(); |
|
} |
|
|
|
BaseClass::PreRound_End(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Compute internal vectors of health and ammo locations |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::ComputeHealthAndAmmoVectors( void ) |
|
{ |
|
m_ammoVector.RemoveAll(); |
|
m_healthVector.RemoveAll(); |
|
|
|
CBaseEntity *pEnt = gEntList.FirstEnt(); |
|
while( pEnt ) |
|
{ |
|
if ( pEnt->ClassMatches( "func_regenerate" ) || pEnt->ClassMatches( "item_healthkit*" ) ) |
|
{ |
|
m_healthVector.AddToTail( pEnt ); |
|
} |
|
|
|
if ( pEnt->ClassMatches( "func_regenerate" ) || pEnt->ClassMatches( "item_ammopack*" ) ) |
|
{ |
|
m_ammoVector.AddToTail( pEnt ); |
|
} |
|
|
|
pEnt = gEntList.NextEnt( pEnt ); |
|
} |
|
|
|
m_areHealthAndAmmoVectorsReady = true; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Return vector of health entities |
|
//----------------------------------------------------------------------------- |
|
const CUtlVector< CHandle< CBaseEntity > > &CTFGameRules::GetHealthEntityVector( void ) |
|
{ |
|
// lazy-populate health and ammo vector since some maps (Dario!) move these entities around between stages |
|
if ( !m_areHealthAndAmmoVectorsReady ) |
|
{ |
|
ComputeHealthAndAmmoVectors(); |
|
} |
|
|
|
return m_healthVector; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Return vector of ammo entities |
|
//----------------------------------------------------------------------------- |
|
const CUtlVector< CHandle< CBaseEntity > > &CTFGameRules::GetAmmoEntityVector( void ) |
|
{ |
|
// lazy-populate health and ammo vector since some maps (Dario!) move these entities around between stages |
|
if ( !m_areHealthAndAmmoVectorsReady ) |
|
{ |
|
ComputeHealthAndAmmoVectors(); |
|
} |
|
|
|
return m_ammoVector; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Return the Payload cart the given team needs to push to win, or NULL if none currently exists |
|
//----------------------------------------------------------------------------- |
|
CHandle< CTeamTrainWatcher > CTFGameRules::GetPayloadToPush( int pushingTeam ) const |
|
{ |
|
if ( TFGameRules()->GetGameType() != TF_GAMETYPE_ESCORT ) |
|
return NULL; |
|
|
|
if ( pushingTeam == TF_TEAM_RED ) |
|
{ |
|
if ( m_redPayloadToPush == NULL ) |
|
{ |
|
// find our cart! |
|
if ( TFGameRules()->HasMultipleTrains() ) |
|
{ |
|
// find the red cart |
|
} |
|
else |
|
{ |
|
// normal Escort scenario, red always blocks |
|
return NULL; |
|
} |
|
} |
|
|
|
return m_redPayloadToPush; |
|
} |
|
|
|
if ( pushingTeam == TF_TEAM_BLUE ) |
|
{ |
|
if ( m_bluePayloadToPush == NULL ) |
|
{ |
|
if ( TFGameRules()->HasMultipleTrains() ) |
|
{ |
|
// find the blue cart |
|
} |
|
else |
|
{ |
|
// only one cart in the map, and we need to push it |
|
CTeamTrainWatcher *watcher = NULL; |
|
while( ( watcher = dynamic_cast< CTeamTrainWatcher * >( gEntList.FindEntityByClassname( watcher, "team_train_watcher" ) ) ) != NULL ) |
|
{ |
|
if ( !watcher->IsDisabled() ) |
|
{ |
|
m_bluePayloadToPush = watcher; |
|
break; |
|
} |
|
} |
|
} |
|
} |
|
|
|
return m_bluePayloadToPush; |
|
} |
|
|
|
return NULL; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Return the Payload cart the given player needs to block from advancing, or NULL if none currently exists |
|
//----------------------------------------------------------------------------- |
|
CHandle< CTeamTrainWatcher > CTFGameRules::GetPayloadToBlock( int blockingTeam ) const |
|
{ |
|
if ( TFGameRules()->GetGameType() != TF_GAMETYPE_ESCORT ) |
|
return NULL; |
|
|
|
if ( blockingTeam == TF_TEAM_RED ) |
|
{ |
|
if ( m_redPayloadToBlock == NULL ) |
|
{ |
|
// find our cart! |
|
if ( TFGameRules()->HasMultipleTrains() ) |
|
{ |
|
// find the red cart |
|
} |
|
else |
|
{ |
|
// normal Escort scenario, red always blocks |
|
CTeamTrainWatcher *watcher = NULL; |
|
while( ( watcher = dynamic_cast< CTeamTrainWatcher * >( gEntList.FindEntityByClassname( watcher, "team_train_watcher" ) ) ) != NULL ) |
|
{ |
|
if ( !watcher->IsDisabled() ) |
|
{ |
|
m_redPayloadToBlock = watcher; |
|
break; |
|
} |
|
} |
|
} |
|
} |
|
|
|
return m_redPayloadToBlock; |
|
} |
|
|
|
if ( blockingTeam == TF_TEAM_BLUE ) |
|
{ |
|
if ( m_bluePayloadToBlock == NULL ) |
|
{ |
|
if ( TFGameRules()->HasMultipleTrains() ) |
|
{ |
|
// find the blue cart |
|
} |
|
else |
|
{ |
|
// normal Payload, blue never blocks |
|
return NULL; |
|
} |
|
} |
|
|
|
return m_bluePayloadToBlock; |
|
} |
|
|
|
return NULL; |
|
} |
|
|
|
|
|
#endif // GAME_DLL |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::BuildBonusPlayerList( void ) |
|
{ |
|
if ( m_hBonusLogic.Get() ) |
|
{ |
|
m_hBonusLogic.Get()->BuildBonusPlayerList(); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Item testing bot controls |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::ItemTesting_SetupFromKV( KeyValues *pKV ) |
|
{ |
|
m_iItemTesting_BotAnim = pKV->GetInt( "bot_anim", TI_BOTANIM_IDLE ); |
|
|
|
int iAnimSpeed = pKV->GetInt( "bot_animspeed", 100 ); |
|
m_flItemTesting_BotAnimSpeed = ( (float)iAnimSpeed / 100.0f ); |
|
|
|
m_bItemTesting_BotForceFire = pKV->GetBool( "bot_force_fire" ); |
|
m_bItemTesting_BotTurntable = pKV->GetBool( "bot_turntable" ); |
|
m_bItemTesting_BotViewScan = pKV->GetBool( "bot_view_scan" ); |
|
} |
|
|
|
//================================================================================================================== |
|
// BONUS ROUND LOGIC |
|
#ifndef CLIENT_DLL |
|
EXTERN_SEND_TABLE( DT_ScriptCreatedItem ); |
|
#else |
|
EXTERN_RECV_TABLE( DT_ScriptCreatedItem ); |
|
#endif |
|
|
|
BEGIN_NETWORK_TABLE_NOBASE( CBonusRoundLogic, DT_BonusRoundLogic ) |
|
#ifdef CLIENT_DLL |
|
RecvPropUtlVector( RECVINFO_UTLVECTOR( m_aBonusPlayerRoll ), MAX_PLAYERS, RecvPropInt( NULL, 0, 4 ) ), |
|
RecvPropEHandle( RECVINFO( m_hBonusWinner ) ), |
|
RecvPropDataTable(RECVINFO_DT(m_Item), 0, &REFERENCE_RECV_TABLE(DT_ScriptCreatedItem)), |
|
#else |
|
SendPropUtlVector( SENDINFO_UTLVECTOR( m_aBonusPlayerRoll ), MAX_PLAYERS, SendPropInt( NULL, 0, 4, 12, SPROP_UNSIGNED ) ), |
|
SendPropEHandle( SENDINFO( m_hBonusWinner ) ), |
|
SendPropDataTable(SENDINFO_DT(m_Item), &REFERENCE_SEND_TABLE(DT_ScriptCreatedItem)), |
|
#endif |
|
END_NETWORK_TABLE() |
|
|
|
LINK_ENTITY_TO_CLASS( tf_logic_bonusround, CBonusRoundLogic ); |
|
IMPLEMENT_NETWORKCLASS_ALIASED( BonusRoundLogic, DT_BonusRoundLogic ) |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CBonusRoundLogic::BuildBonusPlayerList( void ) |
|
{ |
|
m_aBonusPlayerList.Purge(); |
|
|
|
for( int iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ ) |
|
{ |
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) ); |
|
if ( !pPlayer ) |
|
continue; |
|
|
|
m_aBonusPlayerList.InsertNoSort( pPlayer ); |
|
} |
|
|
|
m_aBonusPlayerList.RedoSort( true ); |
|
} |
|
|
|
#ifdef GAME_DLL |
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CBonusRoundLogic::InitBonusRound( void ) |
|
{ |
|
m_bAbortedBonusRound = false; |
|
SetBonusItem( 0 ); |
|
m_hBonusWinner = NULL; |
|
|
|
BuildBonusPlayerList(); |
|
|
|
// We actually precalculate the whole shebang. |
|
m_aBonusPlayerRoll.SetSize( m_aBonusPlayerList.Count() ); |
|
for ( int i = 0; i < m_aBonusPlayerRoll.Count(); i++ ) |
|
{ |
|
m_aBonusPlayerRoll[i] = RandomInt( PLAYER_ROLL_MIN, PLAYER_ROLL_MAX ); |
|
} |
|
|
|
// Sum up the bonus chances |
|
int iTotal = 0; |
|
CUtlVector<int> aBonusPlayerTotals; |
|
aBonusPlayerTotals.SetSize( m_aBonusPlayerList.Count() ); |
|
for ( int i = 0; i < aBonusPlayerTotals.Count(); i++ ) |
|
{ |
|
aBonusPlayerTotals[i] = iTotal + m_aBonusPlayerRoll[i] + m_aBonusPlayerList[i]->m_Shared.GetItemFindBonus(); |
|
iTotal = aBonusPlayerTotals[i]; |
|
} |
|
|
|
// Roll for who gets the item. |
|
int iRoll = RandomInt( 0, iTotal ); |
|
for ( int i = 0; i < aBonusPlayerTotals.Count(); i++ ) |
|
{ |
|
if ( iRoll < aBonusPlayerTotals[i] ) |
|
{ |
|
m_hBonusWinner = m_aBonusPlayerList[i]; |
|
break; |
|
} |
|
} |
|
|
|
if ( !m_hBonusWinner.Get() ) |
|
return false; |
|
|
|
// Generate the item on the server for now |
|
//CSteamID steamID; |
|
//if ( !m_hBonusWinner.Get()->GetSteamID( &steamID ) ) |
|
const CSteamID *steamID = engine->GetGameServerSteamID(); |
|
if ( !steamID || !steamID->IsValid() ) |
|
return false; |
|
|
|
return true; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CBonusRoundLogic::SetBonusItem( itemid_t iItemID ) |
|
{ |
|
m_iBonusItemID = iItemID; |
|
if ( !m_iBonusItemID ) |
|
{ |
|
m_Item.Invalidate(); |
|
return; |
|
} |
|
|
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetBonusItem( itemid_t iItemID ) |
|
{ |
|
if ( m_hBonusLogic.Get() ) |
|
{ |
|
m_hBonusLogic.Get()->SetBonusItem( iItemID ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::ProcessVerboseLogOutput( void ) |
|
{ |
|
for ( int i = 1; i <= gpGlobals->maxClients; i++ ) |
|
{ |
|
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i ); |
|
|
|
if ( pPlayer && ( pPlayer->GetTeamNumber() > TEAM_UNASSIGNED ) ) |
|
{ |
|
UTIL_LogPrintf( "\"%s<%i><%s><%s>\" position_report (position \"%d %d %d\")\n", |
|
pPlayer->GetPlayerName(), |
|
pPlayer->GetUserID(), |
|
pPlayer->GetNetworkIDString(), |
|
pPlayer->GetTeam()->GetName(), |
|
(int)pPlayer->GetAbsOrigin().x, |
|
(int)pPlayer->GetAbsOrigin().y, |
|
(int)pPlayer->GetAbsOrigin().z ); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::MatchSummaryTeleport() |
|
{ |
|
bool bUseMatchSummaryStage = false; |
|
#ifdef STAGING_ONLY |
|
bUseMatchSummaryStage = tf_test_match_summary.GetBool(); |
|
#endif |
|
|
|
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() ); |
|
if ( pMatchDesc && pMatchDesc->m_params.m_bUseMatchSummaryStage ) |
|
{ |
|
bUseMatchSummaryStage = true; |
|
} |
|
|
|
if ( bUseMatchSummaryStage && m_bMapHasMatchSummaryStage ) |
|
{ |
|
RespawnPlayers( true ); |
|
|
|
// find the observer target for the stage |
|
CObserverPoint *pObserverPoint = dynamic_cast<CObserverPoint*>( gEntList.FindEntityByClassname( NULL, "info_observer_point" ) ); |
|
while( pObserverPoint ) |
|
{ |
|
if ( pObserverPoint->IsMatchSummary() ) |
|
{ |
|
pObserverPoint->SetDisabled( false ); |
|
SetRequiredObserverTarget( pObserverPoint ); |
|
break; |
|
} |
|
|
|
pObserverPoint = dynamic_cast<CObserverPoint*>( gEntList.FindEntityByClassname( pObserverPoint, "info_observer_point" ) ); |
|
} |
|
|
|
// need to do this AFTER we respawn the players above or the conditions will be cleared |
|
for ( int i = 1; i <= MAX_PLAYERS; i++ ) |
|
{ |
|
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i ); |
|
if ( !pPlayer ) |
|
continue; |
|
|
|
pPlayer->AddFlag( FL_FROZEN ); |
|
|
|
if ( pPlayer->GetTeamNumber() >= FIRST_GAME_TEAM ) // spectators automatically get the RequiredObserverTarget that was set above |
|
{ |
|
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer ); |
|
if ( pTFPlayer ) |
|
{ |
|
pTFPlayer->m_Shared.AddCond( ( pTFPlayer->GetTeamNumber() == GetWinningTeam() ) ? TF_COND_COMPETITIVE_WINNER : TF_COND_COMPETITIVE_LOSER ); |
|
|
|
if ( pObserverPoint ) |
|
{ |
|
pTFPlayer->SetViewEntity( pObserverPoint ); |
|
pTFPlayer->SetViewOffset( vec3_origin ); |
|
pTFPlayer->SetFOV( pObserverPoint, pObserverPoint->m_flFOV ); |
|
} |
|
|
|
// use this to force the client player anim to face the right direction |
|
pTFPlayer->SetTauntYaw( pTFPlayer->GetAbsAngles()[YAW] ); |
|
} |
|
} |
|
} |
|
|
|
m_bPlayersAreOnMatchSummaryStage.Set( true ); |
|
} |
|
} |
|
|
|
#ifdef STAGING_ONLY |
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::MatchSummaryTest( void ) |
|
{ |
|
mp_waitingforplayers_cancel.SetValue( 1 ); |
|
tf_test_match_summary.SetValue( 1 ); |
|
g_fGameOver = true; |
|
TFGameRules()->State_Transition( GR_STATE_GAME_OVER ); |
|
m_flStateTransitionTime = gpGlobals->curtime + 99999.f; |
|
TFGameRules()->MatchSummaryStart(); |
|
} |
|
|
|
CON_COMMAND ( show_match_summary, "Show the match summary" ) |
|
{ |
|
if ( !UTIL_IsCommandIssuedByServerAdmin() ) |
|
return; |
|
|
|
if ( args.ArgC() < 2 ) |
|
return; |
|
|
|
if ( FStrEq( args[1], "start" ) ) |
|
{ |
|
TFGameRules()->MatchSummaryTest(); |
|
} |
|
else if ( FStrEq( args[1], "end" ) ) |
|
{ |
|
TFGameRules()->MatchSummaryEnd(); |
|
} |
|
} |
|
|
|
#endif // STAGING_ONLY |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::MatchSummaryStart( void ) |
|
{ |
|
if ( BAttemptMapVoteRollingMatch() ) |
|
{ |
|
// Grab the final list of maps for users to vote on |
|
UpdateNextMapVoteOptionsFromLobby(); |
|
m_eRematchState = NEXT_MAP_VOTE_STATE_WAITING_FOR_USERS_TO_VOTE; |
|
} |
|
|
|
for ( int i = 1; i <= MAX_PLAYERS; i++ ) |
|
{ |
|
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i ); |
|
if ( pPlayer ) |
|
{ |
|
pPlayer->AddFlag( FL_FROZEN ); |
|
} |
|
} |
|
|
|
m_bShowMatchSummary.Set( true ); |
|
m_flMatchSummaryTeleportTime = gpGlobals->curtime + 2.f; |
|
|
|
if ( m_hGamerulesProxy ) |
|
{ |
|
m_hGamerulesProxy->MatchSummaryStart(); |
|
} |
|
|
|
CBaseEntity *pLogicCase = NULL; |
|
while ( ( pLogicCase = gEntList.FindEntityByName( pLogicCase, "competitive_stage_logic_case" ) ) != NULL ) |
|
{ |
|
if ( pLogicCase ) |
|
{ |
|
variant_t sVariant; |
|
sVariant.SetInt( GetWinningTeam() ); |
|
pLogicCase->AcceptInput( "InValue", NULL, NULL, sVariant, 0 ); |
|
break; |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::MatchSummaryEnd( void ) |
|
{ |
|
m_bShowMatchSummary.Set( false ); |
|
m_bPlayersAreOnMatchSummaryStage.Set( false ); |
|
|
|
SetRequiredObserverTarget( NULL ); |
|
|
|
for ( int i = 1; i <= MAX_PLAYERS; i++ ) |
|
{ |
|
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i ); |
|
if ( !pPlayer ) |
|
continue; |
|
|
|
pPlayer->RemoveFlag( FL_FROZEN ); |
|
pPlayer->SetViewEntity( NULL ); |
|
pPlayer->SetFOV( pPlayer, 0 ); |
|
} |
|
|
|
// reset bot convars here |
|
static ConVarRef tf_bot_quota( "tf_bot_quota" ); |
|
tf_bot_quota.SetValue( tf_bot_quota.GetDefault() ); |
|
static ConVarRef tf_bot_quota_mode( "tf_bot_quota_mode" ); |
|
tf_bot_quota_mode.SetValue( tf_bot_quota_mode.GetDefault() ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::GetTeamAssignmentOverride( CTFPlayer *pTFPlayer, int iDesiredTeam, bool bAutoBalance /*= false*/ ) |
|
{ |
|
int iTeam = iDesiredTeam; |
|
|
|
// Look up GC managed match info |
|
CSteamID steamID; |
|
pTFPlayer->GetSteamID( &steamID ); |
|
CMatchInfo *pMatch = GTFGCClientSystem()->GetLiveMatch(); |
|
int nMatchPlayers = pMatch ? pMatch->GetNumActiveMatchPlayers() : 0; |
|
CMatchInfo::PlayerMatchData_t *pMatchPlayer = ( pMatch && steamID.IsValid() ) ? pMatch->GetMatchDataForPlayer( steamID ) : NULL; |
|
|
|
if ( IsMannVsMachineMode() ) |
|
{ |
|
if ( !pTFPlayer->IsBot() && iTeam != TEAM_SPECTATOR ) |
|
{ |
|
if ( pMatchPlayer && !pMatchPlayer->bDropped ) |
|
{ |
|
// Part of the lobby match |
|
Log( "MVM assigned %s to defending team (player is in lobby)\n", pTFPlayer->GetPlayerName() ); |
|
return TF_TEAM_PVE_DEFENDERS; |
|
} |
|
|
|
// Count ad-hoc players on defenders team |
|
int nAdHocDefenders = 0; |
|
for ( int i = 1; i <= gpGlobals->maxClients; i++ ) |
|
{ |
|
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i ); |
|
|
|
if ( !pPlayer || ( pPlayer->GetTeamNumber() != TF_TEAM_PVE_DEFENDERS ) ) |
|
{ continue; } |
|
|
|
CSteamID steamID; |
|
if ( pPlayer->GetSteamID( &steamID ) && GTFGCClientSystem()->GetLiveMatchPlayer( steamID ) ) |
|
{ continue; } |
|
|
|
// Player on defenders that doesn't have a live match entry |
|
nAdHocDefenders++; |
|
} |
|
|
|
// Bootcamp mode can mix a lobby with ad-hoc joins |
|
int nSlotsLeft = kMVM_DefendersTeamSize - nMatchPlayers - nAdHocDefenders; |
|
if ( nSlotsLeft >= 1 ) |
|
{ |
|
Log( "MVM assigned %s to defending team (%d more slots remaining after us)\n", pTFPlayer->GetPlayerName(), nSlotsLeft-1 ); |
|
|
|
// Set Their Currency |
|
int nRoundCurrency = MannVsMachineStats_GetAcquiredCredits(); |
|
nRoundCurrency += g_pPopulationManager->GetStartingCurrency(); |
|
|
|
// deduct any cash that has already been spent |
|
int spentCurrency = g_pPopulationManager->GetPlayerCurrencySpent( pTFPlayer ); |
|
pTFPlayer->SetCurrency( nRoundCurrency - spentCurrency ); |
|
|
|
iTeam = TF_TEAM_PVE_DEFENDERS; |
|
} |
|
else |
|
{ |
|
// no room |
|
Log( "MVM assigned %s to spectator, all slots for defending team are in use, or reserved for lobby members\n", |
|
pTFPlayer->GetPlayerName() ); |
|
iTeam = TEAM_SPECTATOR; |
|
} |
|
} |
|
} |
|
else if ( pMatch ) |
|
{ |
|
if ( !bAutoBalance ) |
|
{ |
|
CSteamID steamID; |
|
if ( pMatchPlayer ) |
|
{ |
|
iTeam = GetGameTeamForGCTeam( pMatchPlayer->eGCTeam ); |
|
if ( iTeam < FIRST_GAME_TEAM ) |
|
{ |
|
// We should always have a team assigned by the GC |
|
Warning( "Competitive mode: Lobby player with invalid GC team %i in MatchGroup %i\n", iTeam, (int)pMatch->m_eMatchGroup ); |
|
} |
|
CheckAndSetPartyLeader( pTFPlayer, iTeam ); |
|
} |
|
} |
|
} |
|
|
|
return iTeam; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
static CPhysicsProp *CreatePhysicsToy( const char* pszModelName, const Vector &vSpawnPos, const QAngle &qSpawnAngles ) |
|
{ |
|
if ( pszModelName == NULL ) |
|
return NULL; |
|
|
|
CPhysicsProp *pProp = NULL; |
|
|
|
MDLCACHE_CRITICAL_SECTION(); |
|
|
|
MDLHandle_t h = mdlcache->FindMDL( pszModelName ); |
|
if ( h != MDLHANDLE_INVALID ) |
|
{ |
|
// Must have vphysics to place as a physics prop |
|
studiohdr_t *pStudioHdr = mdlcache->GetStudioHdr( h ); |
|
if ( pStudioHdr && mdlcache->GetVCollide( h ) ) |
|
{ |
|
bool bAllowPrecache = CBaseEntity::IsPrecacheAllowed(); |
|
CBaseEntity::SetAllowPrecache( true ); |
|
|
|
// Try to create entity |
|
pProp = dynamic_cast< CPhysicsProp * >( CreateEntityByName( "prop_physics_override" ) ); |
|
if ( pProp ) |
|
{ |
|
pProp->SetCollisionGroup( COLLISION_GROUP_PUSHAWAY ); |
|
// so it can be pushed by airblast |
|
pProp->AddFlag( FL_GRENADE ); |
|
// so that it will always be interactable with the player |
|
//pProp->SetPhysicsMode( PHYSICS_MULTIPLAYER_SOLID );//PHYSICS_MULTIPLAYER_NON_SOLID ); |
|
char buf[512]; |
|
// Pass in standard key values |
|
Q_snprintf( buf, sizeof(buf), "%.10f %.10f %.10f", vSpawnPos.x, vSpawnPos.y, vSpawnPos.z ); |
|
pProp->KeyValue( "origin", buf ); |
|
Q_snprintf( buf, sizeof(buf), "%.10f %.10f %.10f", qSpawnAngles.x, qSpawnAngles.y, qSpawnAngles.z ); |
|
pProp->KeyValue( "angles", buf ); |
|
pProp->KeyValue( "model", pszModelName ); |
|
pProp->KeyValue( "fademindist", "-1" ); |
|
pProp->KeyValue( "fademaxdist", "0" ); |
|
pProp->KeyValue( "fadescale", "1" ); |
|
pProp->KeyValue( "inertiaScale", "1.0" ); |
|
pProp->KeyValue( "physdamagescale", "0.1" ); |
|
pProp->Precache(); |
|
DispatchSpawn( pProp ); |
|
pProp->m_takedamage = DAMAGE_YES; // Take damage, otherwise this can block trains |
|
pProp->SetHealth( 5000 ); |
|
pProp->Activate(); |
|
} |
|
|
|
CBaseEntity::SetAllowPrecache( bAllowPrecache ); |
|
} |
|
|
|
mdlcache->Release( h ); // counterbalance addref from within FindMDL |
|
} |
|
return pProp; |
|
} |
|
|
|
CPhysicsProp *CreateBeachBall( const Vector &vSpawnPos, const QAngle &qSpawnAngles ) |
|
{ |
|
return CreatePhysicsToy( "models/props_gameplay/ball001.mdl", vSpawnPos, qSpawnAngles ); |
|
} |
|
|
|
CPhysicsProp *CreateSoccerBall( const Vector &vSpawnPos, const QAngle &qSpawnAngles ) |
|
{ |
|
return CreatePhysicsToy( "models/player/items/scout/soccer_ball.mdl", vSpawnPos, qSpawnAngles ); |
|
} |
|
|
|
|
|
void CTFGameRules::PushAllPlayersAway( const Vector& vFromThisPoint, float flRange, float flForce, int nTeam, CUtlVector< CTFPlayer* > *pPushedPlayers /*= NULL*/ ) |
|
{ |
|
CUtlVector< CTFPlayer * > playerVector; |
|
CollectPlayers( &playerVector, nTeam, COLLECT_ONLY_LIVING_PLAYERS ); |
|
|
|
for( int i=0; i<playerVector.Count(); ++i ) |
|
{ |
|
CTFPlayer *pPlayer = playerVector[i]; |
|
|
|
Vector toPlayer = pPlayer->EyePosition() - vFromThisPoint; |
|
|
|
if ( toPlayer.LengthSqr() < flRange * flRange ) |
|
{ |
|
// send the player flying |
|
// make sure we push players up and away |
|
toPlayer.z = 0.0f; |
|
toPlayer.NormalizeInPlace(); |
|
toPlayer.z = 1.0f; |
|
|
|
Vector vPush = flForce * toPlayer; |
|
|
|
pPlayer->ApplyAbsVelocityImpulse( vPush ); |
|
|
|
if ( pPushedPlayers ) |
|
{ |
|
pPushedPlayers->AddToTail( pPlayer ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
#endif // GAME_DLL |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::CanUpgradeWithAttrib( CTFPlayer *pPlayer, int iWeaponSlot, attrib_definition_index_t iAttribIndex, CMannVsMachineUpgrades *pUpgrade ) |
|
{ |
|
if ( !pPlayer ) |
|
return false; |
|
|
|
Assert ( pUpgrade ); |
|
|
|
// Upgrades on players are considered active at all times |
|
if ( pUpgrade->nUIGroup == UIGROUP_UPGRADE_ATTACHED_TO_PLAYER ) |
|
{ |
|
switch ( iAttribIndex ) |
|
{ |
|
case 113: // "metal regen" |
|
{ |
|
return ( pPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) ); |
|
} |
|
break; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
// Get the item entity. We use the entity, not the item in the loadout, because we want |
|
// the dynamic attributes that have already been purchases and attached. |
|
CEconEntity *pEntity; |
|
CEconItemView *pCurItemData = CTFPlayerSharedUtils::GetEconItemViewByLoadoutSlot( pPlayer, iWeaponSlot, &pEntity ); |
|
if ( !pCurItemData || !pEntity ) |
|
return false; |
|
|
|
// bottles can only hold things in the appropriate ui group |
|
if ( dynamic_cast< CTFPowerupBottle *>( pEntity ) ) |
|
{ |
|
if ( pUpgrade->nUIGroup == UIGROUP_POWERUPBOTTLE ) |
|
{ |
|
switch ( iAttribIndex ) |
|
{ |
|
case 327: // "building instant upgrade" |
|
{ |
|
return ( pPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) ); |
|
} |
|
#ifndef _DEBUG |
|
case 480: // "radius stealth" |
|
{ |
|
return ( pPlayer->IsPlayerClass( TF_CLASS_SPY ) ); |
|
} |
|
#endif // !_DEBUG |
|
} |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
else if ( pUpgrade->nUIGroup == UIGROUP_POWERUPBOTTLE ) |
|
{ |
|
return false; |
|
} |
|
|
|
CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase* > ( pEntity ); |
|
CTFWeaponBaseGun *pWeaponGun = dynamic_cast< CTFWeaponBaseGun* > ( pEntity ); |
|
int iWeaponID = ( pWeapon ) ? pWeapon->GetWeaponID() : TF_WEAPON_NONE; |
|
CTFWearableDemoShield *pShield = dynamic_cast< CTFWearableDemoShield* >( pEntity ); |
|
bool bShield = ( pShield ) ? true : false; |
|
|
|
if ( iWeaponID == TF_WEAPON_PARACHUTE ) |
|
return false; |
|
|
|
// Hack to simplify excluding non-weapons from damage upgrades |
|
bool bHideDmgUpgrades = iWeaponID == TF_WEAPON_NONE || |
|
iWeaponID == TF_WEAPON_LASER_POINTER || |
|
iWeaponID == TF_WEAPON_MEDIGUN || |
|
iWeaponID == TF_WEAPON_BUFF_ITEM || |
|
iWeaponID == TF_WEAPON_BUILDER || |
|
iWeaponID == TF_WEAPON_PDA_ENGINEER_BUILD || |
|
iWeaponID == TF_WEAPON_INVIS || |
|
iWeaponID == TF_WEAPON_SPELLBOOK; |
|
|
|
// What tier upgrade is it? |
|
int nQuality = pUpgrade->nQuality; |
|
|
|
// This is crappy, but it's hopefully more maintainable than the allowed attributes block for all current & future items |
|
switch ( iAttribIndex ) |
|
{ |
|
case 2: // "damage bonus" |
|
{ |
|
if ( bHideDmgUpgrades ) |
|
return false; |
|
|
|
// Some classes get a weaker dmg upgrade |
|
if ( nQuality == MVM_UPGRADE_QUALITY_LOW ) |
|
{ |
|
if ( pPlayer->IsPlayerClass( TF_CLASS_DEMOMAN ) && !bShield ) |
|
{ |
|
return ( iWeaponSlot == TF_WPN_TYPE_PRIMARY || iWeaponSlot == TF_WPN_TYPE_SECONDARY ); |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
} |
|
|
|
bool bShieldEquipped = false; |
|
if ( pPlayer->IsPlayerClass( TF_CLASS_DEMOMAN ) ) |
|
{ |
|
for ( int i = 0; i < pPlayer->GetNumWearables(); ++i ) |
|
{ |
|
CTFWearableDemoShield *pWearableShield = dynamic_cast< CTFWearableDemoShield* >( pPlayer->GetWearable( i ) ); |
|
if ( pWearableShield ) |
|
{ |
|
bShieldEquipped = true; |
|
} |
|
} |
|
} |
|
|
|
return ( ( iWeaponSlot == TF_WPN_TYPE_PRIMARY && |
|
( pPlayer->IsPlayerClass( TF_CLASS_SCOUT ) || |
|
pPlayer->IsPlayerClass( TF_CLASS_SNIPER ) || |
|
pPlayer->IsPlayerClass( TF_CLASS_SOLDIER ) || |
|
pPlayer->IsPlayerClass( TF_CLASS_PYRO ) ) ) || |
|
( iWeaponID == TF_WEAPON_SWORD && bShieldEquipped ) ); |
|
} |
|
break; |
|
case 6: // "fire rate bonus" |
|
{ |
|
// Heavy's version of firing speed costs more |
|
bool bMinigun = iWeaponID == TF_WEAPON_MINIGUN; |
|
if ( nQuality == MVM_UPGRADE_QUALITY_LOW ) |
|
{ |
|
return bMinigun; |
|
} |
|
else if ( iWeaponID == TF_WEAPON_GRENADELAUNCHER && pWeapon && pWeapon->AutoFiresFullClipAllAtOnce() ) |
|
{ |
|
return false; |
|
} |
|
|
|
// Non-melee version |
|
return ( dynamic_cast< CTFWeaponBaseMelee* >( pEntity ) == NULL && |
|
iWeaponID != TF_WEAPON_NONE && !bHideDmgUpgrades && |
|
iWeaponID != TF_WEAPON_FLAMETHROWER && |
|
!WeaponID_IsSniperRifleOrBow( iWeaponID ) && |
|
!( pWeapon && pWeapon->HasEffectBarRegeneration() ) && |
|
!bMinigun ); |
|
} |
|
break; |
|
// case 8: // "heal rate bonus" |
|
case 10: // "ubercharge rate bonus" |
|
case 314: // "uber duration bonus" |
|
case 481: // "canteen specialist" |
|
case 482: // "overheal expert" |
|
case 483: // "medic machinery beam" |
|
case 493: // "healing mastery" |
|
{ |
|
return ( iWeaponID == TF_WEAPON_MEDIGUN ); |
|
} |
|
break; |
|
case 31: // "critboost on kill" |
|
{ |
|
CTFWeaponBaseMelee *pMelee = dynamic_cast<CTFWeaponBaseMelee *> ( pEntity ); |
|
return ( pMelee && ( |
|
pPlayer->IsPlayerClass( TF_CLASS_DEMOMAN ) || |
|
pPlayer->IsPlayerClass( TF_CLASS_SPY ) ) ); |
|
} |
|
case 71: // weapon burn dmg increased |
|
case 73: // weapon burn time increased |
|
{ |
|
return ( iWeaponID == TF_WEAPON_FLAMETHROWER || iWeaponID == TF_WEAPON_FLAREGUN ); |
|
} |
|
break; |
|
case 76: // "maxammo primary increased" |
|
{ |
|
return ( pWeapon && pWeapon->GetPrimaryAmmoType() == TF_AMMO_PRIMARY && !pWeapon->IsEnergyWeapon() ); |
|
} |
|
break; |
|
case 78: // "maxammo secondary increased" |
|
{ |
|
return ( pWeapon && pWeapon->GetPrimaryAmmoType() == TF_AMMO_SECONDARY && !pWeapon->IsEnergyWeapon() ); |
|
} |
|
break; |
|
case 90: // "SRifle Charge rate increased" |
|
{ |
|
return WeaponID_IsSniperRifle( iWeaponID ); |
|
} |
|
break; |
|
case 103: // "Projectile speed increased" |
|
{ |
|
if ( pWeaponGun ) |
|
{ |
|
return ( pWeaponGun->GetWeaponProjectileType() == TF_PROJECTILE_PIPEBOMB ); |
|
} |
|
|
|
return false; |
|
} |
|
break; |
|
case 149: // "bleed duration" |
|
case 523: // "arrow mastery" |
|
{ |
|
return ( iWeaponID == TF_WEAPON_COMPOUND_BOW ); |
|
} |
|
break; |
|
case 218: // "mark for death" |
|
{ |
|
return ( iWeaponID == TF_WEAPON_BAT_WOOD ); |
|
} |
|
break; |
|
case 249: // "charge recharge rate increased" |
|
case 252: // "damage force reduction" |
|
{ |
|
return bShield; |
|
} |
|
break; |
|
case 255: // "airblast pushback scale" |
|
{ |
|
return ( iWeaponID == TF_WEAPON_FLAMETHROWER && |
|
pWeaponGun && assert_cast< CTFFlameThrower* >( pWeaponGun )->SupportsAirBlastFunction( TF_FUNCTION_AIRBLAST_PUSHBACK) ); |
|
} |
|
break; |
|
case 266: // "projectile penetration" |
|
{ |
|
if ( pWeaponGun && !bHideDmgUpgrades ) |
|
{ |
|
if ( !( pPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY ) ) |
|
{ |
|
int iProjectile = pWeaponGun->GetWeaponProjectileType(); |
|
return ( iProjectile == TF_PROJECTILE_ARROW || iProjectile == TF_PROJECTILE_BULLET || iProjectile == TF_PROJECTILE_HEALING_BOLT || iProjectile == TF_PROJECTILE_FESTIVE_ARROW || iProjectile == TF_PROJECTILE_FESTIVE_HEALING_BOLT ); |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
break; |
|
case 80: // "maxammo metal increased" |
|
case 276: // "bidirectional teleport" |
|
case 286: // "engy building health bonus" |
|
case 343: // "engy sentry fire rate increased" |
|
case 345: // "engy dispenser radius increased" |
|
case 351: // "engy disposable sentries" |
|
{ |
|
return ( pPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) && iWeaponID == TF_WEAPON_PDA_ENGINEER_BUILD ); |
|
} |
|
break; |
|
case 278: // "effect bar recharge rate increased" |
|
{ |
|
return ( pWeapon && pWeapon->HasEffectBarRegeneration() && iWeaponID != TF_WEAPON_BUILDER && iWeaponID != TF_WEAPON_SPELLBOOK ); |
|
} |
|
break; |
|
case 279: // "maxammo grenades1 increased" |
|
{ |
|
return ( iWeaponID == TF_WEAPON_BAT_WOOD || iWeaponID == TF_WEAPON_BAT_GIFTWRAP ); |
|
} |
|
break; |
|
case 313: // "applies snare effect" |
|
{ |
|
return ( iWeaponID == TF_WEAPON_JAR || iWeaponID == TF_WEAPON_JAR_MILK ); |
|
} |
|
break; |
|
case 318: // "faster reload rate" |
|
{ |
|
return ( ( pWeapon && pWeapon->ReloadsSingly() ) || |
|
WeaponID_IsSniperRifleOrBow( iWeaponID ) || |
|
iWeaponID == TF_WEAPON_FLAREGUN ); |
|
} |
|
break; |
|
case 319: // "increase buff duration" |
|
{ |
|
return ( iWeaponID == TF_WEAPON_BUFF_ITEM ); |
|
} |
|
break; |
|
case 320: // "robo sapper" |
|
#ifdef STAGING_ONLY |
|
case 601: // "ability spy traps" |
|
case 603: // "phase cloak" |
|
#endif // STAGING_ONLY |
|
{ |
|
return ( pPlayer->IsPlayerClass( TF_CLASS_SPY ) && iWeaponID == TF_WEAPON_BUILDER ); |
|
} |
|
break; |
|
case 323: // "attack projectiles" |
|
{ |
|
return ( pPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY ); |
|
} |
|
break; |
|
case 335: // "clip size bonus upgrade" |
|
{ |
|
return ( pWeapon && !pWeapon->IsBlastImpactWeapon() && pWeapon->UsesClipsForAmmo1() && pWeapon->GetMaxClip1() > 1 |
|
&& iWeaponID != TF_WEAPON_FLAREGUN_REVENGE && iWeaponID != TF_WEAPON_SPELLBOOK ); |
|
} |
|
break; |
|
case 375: // "generate rage on damage" |
|
{ |
|
return ( pPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY ); |
|
} |
|
break; |
|
case 395: // "explosive sniper shot" |
|
{ |
|
return ( pPlayer->IsPlayerClass( TF_CLASS_SNIPER ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY && |
|
pWeaponGun && pWeaponGun->GetWeaponProjectileType() == TF_PROJECTILE_BULLET ); |
|
} |
|
break; |
|
case 396: // "melee attack rate bonus" |
|
{ |
|
// Melee version |
|
return ( dynamic_cast< CTFWeaponBaseMelee* >( pEntity ) != NULL && iWeaponID != TF_WEAPON_BUFF_ITEM && |
|
!( pWeapon && pWeapon->HasEffectBarRegeneration() && iWeaponID != TF_WEAPON_BAT_WOOD ) ); |
|
} |
|
break; |
|
case 397: // "projectile penetration heavy" |
|
{ |
|
if ( !bHideDmgUpgrades ) |
|
{ |
|
return ( pPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY ); |
|
} |
|
} |
|
break; |
|
case 399: // "armor piercing" |
|
{ |
|
return ( pPlayer->IsPlayerClass( TF_CLASS_SPY ) && iWeaponID == TF_WEAPON_KNIFE ); |
|
} |
|
break; |
|
case 440: // "clip size upgrade atomic" |
|
{ |
|
return pWeapon && pWeapon->IsBlastImpactWeapon(); |
|
} |
|
break; |
|
case 484: // "mad milk syringes" |
|
{ |
|
return ( iWeaponID == TF_WEAPON_SYRINGEGUN_MEDIC ); |
|
} |
|
case 488: // "rocket specialist" |
|
if ( pWeaponGun ) |
|
{ |
|
return ( pWeaponGun->GetWeaponProjectileType() == TF_PROJECTILE_ROCKET || pWeaponGun->GetWeaponProjectileType() == TF_PROJECTILE_ENERGY_BALL ); |
|
} |
|
case 499: // generate rage on heal (shield) |
|
case 554: // revive |
|
case 555: // medigun specialist |
|
{ |
|
return ( iWeaponID == TF_WEAPON_MEDIGUN ); |
|
} |
|
#ifdef STAGING_ONLY |
|
case 553: // rocket pack |
|
case 558: // mod flamethrower napalm |
|
{ |
|
return ( iWeaponID == TF_WEAPON_FLAMETHROWER ); |
|
} |
|
case 604: // sniper cloak |
|
case 605: // master sniper |
|
{ |
|
return ( pPlayer->IsPlayerClass( TF_CLASS_SNIPER ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY ); |
|
} |
|
case 611: // airborne infantry |
|
{ |
|
return ( pPlayer->IsPlayerClass( TF_CLASS_SOLDIER ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY ); |
|
} |
|
case 624: // construction expert |
|
case 626: // support engineer |
|
{ |
|
return ( pPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) && iWeaponSlot == TF_WPN_TYPE_MELEE ); |
|
} |
|
case 631: // ability doubletap teleport |
|
{ |
|
return ( pPlayer->IsPlayerClass( TF_CLASS_SCOUT ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY ); |
|
} |
|
#endif // STAGING_ONLY |
|
} |
|
|
|
// All weapon related attributes require an item that does damage |
|
if ( pUpgrade->nUIGroup == UIGROUP_UPGRADE_ATTACHED_TO_ITEM ) |
|
{ |
|
// All guns |
|
if ( pWeaponGun ) |
|
return ( iWeaponID != TF_WEAPON_NONE && !bHideDmgUpgrades && |
|
!( pWeapon && pWeapon->HasEffectBarRegeneration() ) ); |
|
|
|
CTFWeaponBaseMelee *pMelee = dynamic_cast< CTFWeaponBaseMelee* >( pEntity ); |
|
if ( pMelee ) |
|
{ |
|
// All melee weapons except buff banners |
|
return ( iWeaponID != TF_WEAPON_BUFF_ITEM && !bHideDmgUpgrades ); |
|
} |
|
|
|
return false; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
//----------------------------------------------------------------------------- |
|
int CTFGameRules::GetUpgradeTier( int iUpgrade ) |
|
{ |
|
if ( !GameModeUsesUpgrades() || iUpgrade < 0 || iUpgrade >= g_MannVsMachineUpgrades.m_Upgrades.Count() ) |
|
return 0; |
|
|
|
return g_MannVsMachineUpgrades.m_Upgrades[iUpgrade].nTier; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Given an upgrade and slot, see if its' tier is enabled/available |
|
//----------------------------------------------------------------------------- |
|
bool CTFGameRules::IsUpgradeTierEnabled( CTFPlayer *pTFPlayer, int iItemSlot, int iUpgrade ) |
|
{ |
|
if ( !pTFPlayer ) |
|
return false; |
|
|
|
// If the upgrade has a tier, it's mutually exclusive with upgrades of the same tier for the same slot |
|
int nTier = GetUpgradeTier( iUpgrade ); |
|
if ( !nTier ) |
|
return false; |
|
|
|
bool bIsAvailable = true; |
|
CEconItemView *pItem = NULL; |
|
float flValue = 0.f; |
|
|
|
// Go through the upgrades and see if it could apply, and if we already have it |
|
for ( int i = 0; i < g_MannVsMachineUpgrades.m_Upgrades.Count(); i++ ) |
|
{ |
|
CMannVsMachineUpgrades upgrade = g_MannVsMachineUpgrades.m_Upgrades[i]; |
|
|
|
// Same upgrade |
|
// if ( !V_strcmp( upgrade.szAttrib, g_MannVsMachineUpgrades.m_Upgrades[iUpgrade].szAttrib ) ) |
|
// continue; |
|
|
|
// Different tier |
|
if ( upgrade.nTier != nTier ) |
|
continue; |
|
|
|
// Wrong type |
|
if ( upgrade.nUIGroup != g_MannVsMachineUpgrades.m_Upgrades[iUpgrade].nUIGroup ) |
|
continue; |
|
|
|
CEconItemAttributeDefinition *pAttribDef = ItemSystem()->GetStaticDataForAttributeByName( upgrade.szAttrib ); |
|
if ( !pAttribDef ) |
|
continue; |
|
|
|
// Can't use |
|
if ( !CanUpgradeWithAttrib( pTFPlayer, iItemSlot, pAttribDef->GetDefinitionIndex(), &upgrade ) ) |
|
continue; |
|
|
|
if ( upgrade.nUIGroup == UIGROUP_UPGRADE_ATTACHED_TO_ITEM ) |
|
{ |
|
pItem = CTFPlayerSharedUtils::GetEconItemViewByLoadoutSlot( pTFPlayer, iItemSlot ); |
|
if ( pItem ) |
|
{ |
|
::FindAttribute_UnsafeBitwiseCast< attrib_value_t >( pItem->GetAttributeList(), pAttribDef, &flValue ); |
|
} |
|
} |
|
else if ( upgrade.nUIGroup == UIGROUP_UPGRADE_ATTACHED_TO_PLAYER ) |
|
{ |
|
::FindAttribute_UnsafeBitwiseCast< attrib_value_t >( pTFPlayer->GetAttributeList(), pAttribDef, &flValue ); |
|
} |
|
|
|
if ( flValue > 0.f ) |
|
{ |
|
bIsAvailable = false; |
|
break; |
|
} |
|
} |
|
|
|
return bIsAvailable; |
|
} |
|
|
|
#ifdef GAME_DLL |
|
//----------------------------------------------------------------------------- |
|
// Helper Functions |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::SetNextMvMPopfile ( const char * next ) |
|
{ |
|
s_strNextMvMPopFile = next; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
const char * CTFGameRules::GetNextMvMPopfile ( ) |
|
{ |
|
return s_strNextMvMPopFile.Get(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CTFGameRules::BalanceTeams( bool bRequireSwitcheesToBeDead ) |
|
{ |
|
// are we playing a managed match via matchmaking? |
|
if ( GetMatchGroupDescription( GetCurrentMatchGroup() ) ) |
|
return; |
|
|
|
if ( mp_autoteambalance.GetInt() == 2 ) |
|
return; |
|
|
|
BaseClass::BalanceTeams( bRequireSwitcheesToBeDead ); |
|
} |
|
#endif |
|
|
|
|