422 lines
12 KiB
Plaintext
422 lines
12 KiB
Plaintext
|
|
object team_gdf {
|
|
void preinit();
|
|
void syncFields();
|
|
void destroy();
|
|
|
|
boolean OnAllowRespawn( entity p );
|
|
void RespawnWaves();
|
|
|
|
void OnNextRespawnTimeChanged();
|
|
void SetRespawnTimer( float t );
|
|
|
|
float GetMineLimit();
|
|
|
|
void GiveSpawnItems( entity p );
|
|
float GetHealthBoost( entity p );
|
|
|
|
void OnSoldierUpgrade( entity p, float oldLevel, float newLevel, boolean isSpawn );
|
|
void OnMedicUpgrade( entity p, float oldLevel, float newLevel, boolean isSpawn );
|
|
void OnCovertOpsUpgrade( entity p, float oldLevel, float newLevel, boolean isSpawn );
|
|
void OnBattleSenseUpgrade( entity p, float oldLevel, float newLevel, boolean isSpawn );
|
|
void OnLightWeaponsUpgrade( entity p, float oldLevel, float newLevel, boolean isSpawn );
|
|
void OnProficiencyUpgrade( entity p, float type, float oldLevel, float newLevel );
|
|
|
|
boolean HasConstructionBonus( entity p );
|
|
boolean HasRepairBonus( entity p );
|
|
boolean HasDisarmBonus( entity p );
|
|
boolean HasChargeArmBonus( entity p );
|
|
boolean HasSelfArmingMines( entity p );
|
|
boolean HasFastFireSupportLock( entity p );
|
|
boolean HasFastFireSupportRecharge( entity p );
|
|
boolean HasFastHackBonus( entity p );
|
|
boolean HasVehicleArmorBonus( entity p );
|
|
boolean HasEnhancedRadar( entity p );
|
|
boolean HasPersonalJammer( entity p );
|
|
boolean CanRequestVehicle( entity p );
|
|
boolean HasEfficientDecoys( entity p );
|
|
boolean HasSpreadBonus( entity p );
|
|
boolean HasFastTargetLock( entity p );
|
|
float GetMaxSupplies( entity p );
|
|
boolean CanStab( entity p );
|
|
|
|
void CreatePersonnelAuras( entity p );
|
|
|
|
float GetFireSupportDelayScale();
|
|
|
|
float GetWeaponSpeedBonus( entity p );
|
|
|
|
void RegenPulse( entity p );
|
|
|
|
void KillSpawnWaves();
|
|
void SetRespawnWait( float time );
|
|
|
|
void OnMapStart();
|
|
|
|
float allowRespawnTime;
|
|
float nextRespawnTime;
|
|
|
|
float GetNextRespawnTime() { return nextRespawnTime; }
|
|
}
|
|
|
|
void team_gdf::syncFields() {
|
|
syncBroadcast( "nextRespawnTime" );
|
|
syncCallback( "nextRespawnTime", "OnNextRespawnTimeChanged" );
|
|
}
|
|
|
|
void team_gdf::OnNextRespawnTimeChanged() {
|
|
SetRespawnTimer( nextRespawnTime );
|
|
}
|
|
|
|
|
|
void team_gdf::preinit() {
|
|
gdfTeam = self;
|
|
|
|
repairItem = "inventory/tools/pliers";
|
|
hackItem = "inventory/tools/pliers_hack";
|
|
chargeArmItem = "inventory/tools/pliers/charge";
|
|
chargeDisarmItem = "inventory/tools/pliers";
|
|
armItem = "inventory/tools/pliers";
|
|
constructItem = "inventory/tools/pliers";
|
|
disguiseItem = "inventory/tools/pliers_hack";
|
|
reviveItem = "inventory/tools/defibrillator";
|
|
stabItem = "inventory/weapons/knife";
|
|
disguisedStabItem = "inventory/weapons/spikes/gdf";
|
|
plantItem = "inventory/items/he_charge";
|
|
spawnHostDisarmItem = "inventory/tools/defibrillator";
|
|
|
|
respawnWait = 20.f;
|
|
|
|
structureName = sys.localizeString( "game/struct/commandcenter" );
|
|
|
|
spottingProficiency = GetProficiency( "pro_covertops_spot" );
|
|
radarSpottingProficiency = GetProficiency( "pro_covertops_radar_spot" );
|
|
repairProficiency = GetProficiency( "pro_engineer_repair" );
|
|
reviveProficiency = GetProficiency( "pro_medic_revive" );
|
|
reviveWaitProficiency = GetProficiency( "pro_battlesense_revive_wait" );
|
|
backstabDisguisedProficiency= GetProficiency( "pro_covertops_backstab_disguised" );
|
|
|
|
reviveMeToolTip1 = GetToolTip( getKey( "tt_player_revive_1" ) );
|
|
reviveMeToolTip2 = GetToolTip( getKey( "tt_player_revive_2" ) );
|
|
parachuteToolTip = GetToolTip( getKey( "tt_player_parachute" ) );
|
|
spawnhostingMeToolTip = GetToolTip( getKey( "tt_spawnhosting_me" ) );
|
|
possessingMeToolTip = GetToolTip( getKey( "tt_possessing_me" ) );
|
|
killedByDisguisedToolTip = GetToolTip( getKey( "tt_killed_by_disguised" ) );
|
|
lowAmmoToolTip = GetToolTip( getKey( "tt_low_ammo" ) );
|
|
lowHealthToolTip = GetToolTip( getKey( "tt_low_health" ) );
|
|
lowAmmoSelfToolTip = GetToolTip( getKey( "tt_low_ammo_self" ) );
|
|
lowHealthSelfToolTip = GetToolTip( getKey( "tt_low_health_self" ) );
|
|
unconsciousToolTip = GetToolTip( getKey( "tt_unconscious" ) );
|
|
criticalClassToolTip = GetToolTip( getKey( "tt_critical_class" ) );
|
|
|
|
vehicleRepairTask = GetPlayerTask( getKey( "task_vehicle_repair" ) );
|
|
captureSpawnTask = GetPlayerTask( getKey( "task_capture_spawn" ) );
|
|
liberateSpawnTaskCovertOnly = GetPlayerTask( getKey( "task_liberate_spawn_covert" ) );
|
|
liberateSpawnTask = GetPlayerTask( getKey( "task_liberate_spawn" ) );
|
|
}
|
|
|
|
void team_gdf::KillSpawnWaves() {
|
|
sys.killThread( "RespawnWaves_gdf" );
|
|
}
|
|
|
|
void team_gdf::OnMapStart() {
|
|
OnMapStart_Base();
|
|
|
|
KillSpawnWaves();
|
|
|
|
if ( !sys.isClient() ) {
|
|
thread RespawnWaves();
|
|
}
|
|
}
|
|
|
|
void team_gdf::destroy() {
|
|
KillSpawnWaves();
|
|
}
|
|
|
|
boolean team_gdf::OnAllowRespawn( entity p ) {
|
|
return sys.getTime() < allowRespawnTime;
|
|
}
|
|
|
|
void team_gdf::RespawnWaves() {
|
|
sys.threadName( "RespawnWaves_gdf" );
|
|
|
|
allowRespawnTime = sys.getTime() + 1.f;
|
|
|
|
sys.wait( 0.5f );
|
|
|
|
while ( true ) {
|
|
nextRespawnTime = sys.getTime() + respawnWait;
|
|
SetRespawnTimer( nextRespawnTime );
|
|
|
|
sys.wait( respawnWait );
|
|
|
|
allowRespawnTime = sys.getTime() + 0.5f;
|
|
MarkWaitingPlayers();
|
|
}
|
|
}
|
|
|
|
void team_gdf::SetRespawnTimer( float t ) {
|
|
player p = sys.getLocalPlayer();
|
|
if( p != $null_entity ) {
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.gdfRespawnTime", nextRespawnTime * 1000 );
|
|
player viewPlayer = sys.getLocalViewPlayer();
|
|
if ( viewPlayer != $null_entity ) {
|
|
team_base team = viewPlayer.getGameTeam();
|
|
if ( team == gdfTeam ) {
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.spectatingRespawnTime", nextRespawnTime * 1000 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
float team_gdf::GetMineLimit() {
|
|
return 3.f;
|
|
}
|
|
|
|
void team_gdf::OnSoldierUpgrade( entity p, float oldLevel, float newLevel, boolean isSpawn ) {
|
|
ON_UPGRADE( 2 ) {
|
|
UpgradeClip( p, g_ammoRocketLauncher, 2 );
|
|
UpgradeClip( p, g_ammoGPMG, 100 );
|
|
|
|
if ( isSpawn ) {
|
|
p.setAmmo( g_ammoRocketLauncher, p.getAmmo( g_ammoRocketLauncher ) + 2 );
|
|
p.setAmmo( g_ammoGPMG, p.getAmmo( g_ammoGPMG ) + 100 );
|
|
}
|
|
}
|
|
}
|
|
|
|
void team_gdf::OnMedicUpgrade( entity p, float oldLevel, float newLevel, boolean isSpawn ) {
|
|
}
|
|
|
|
void team_gdf::OnBattleSenseUpgrade( entity p, float oldLevel, float newLevel, boolean isSpawn ) {
|
|
ON_UPGRADE( 1 ) {
|
|
p.setSprintScale( 1.1f );
|
|
}
|
|
|
|
ON_UPGRADE( 2 ) {
|
|
if ( isSpawn ) {
|
|
p.setArmor( 0.2f );
|
|
}
|
|
}
|
|
|
|
ON_UPGRADE( 4 ) {
|
|
p.vStartRegenThread();
|
|
}
|
|
}
|
|
|
|
void team_gdf::OnLightWeaponsUpgrade( entity p, float oldLevel, float newLevel, boolean isSpawn ) {
|
|
ON_UPGRADE( 1 ) {
|
|
UpgradeClip( p, g_ammoPistol, 10 );
|
|
UpgradeClip( p, g_ammoMachinePistol, 20 );
|
|
UpgradeClip( p, g_ammoAssaultRifle, 40 );
|
|
UpgradeClip( p, g_ammoShotgun, 10 );
|
|
UpgradeClip( p, g_ammoSniperRifle, 10 );
|
|
if ( isSpawn ) {
|
|
UpgradeAmmo( p, g_ammoMachinePistol, 20 );
|
|
UpgradeAmmo( p, g_ammoAssaultRifle, 40 );
|
|
UpgradeAmmo( p, g_ammoShotgun, 10 );
|
|
UpgradeAmmo( p, g_ammoSniperRifle, 10 );
|
|
UpgradeAmmo( p, g_ammoPistol, 10 );
|
|
}
|
|
}
|
|
|
|
ON_UPGRADE( 2 ) {
|
|
UpgradeClip( p, g_ammoGrenade, 1 );
|
|
if ( isSpawn ) {
|
|
UpgradeAmmo( p, g_ammoGrenade, 1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
void team_gdf::OnCovertOpsUpgrade( entity p, float oldLevel, float newLevel, boolean isSpawn ) {
|
|
ON_UPGRADE( 4 ) {
|
|
float index;
|
|
float limit = sys.getMaxClients();
|
|
for ( index = 0; index < limit; index++ ) {
|
|
entity other = sys.getClient( index );
|
|
if ( other == $null_entity ) {
|
|
continue;
|
|
}
|
|
|
|
other.vOnLocalTeamChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
void team_gdf::GiveSpawnItems( entity p ) {
|
|
OnSoldierUpgrade( p, 0, p.getProficiency( g_proficiencySoldier ), true );
|
|
OnMedicUpgrade( p, 0, p.getProficiency( g_proficiencyMedic ), true );
|
|
OnCovertOpsUpgrade( p, 0, p.getProficiency( g_proficiencyCovertOps ), true );
|
|
OnBattleSenseUpgrade( p, 0, p.getProficiency( g_proficiencyBattleSense ), true );
|
|
OnLightWeaponsUpgrade( p, 0, p.getProficiency( g_proficiencyLightWeapons ), true );
|
|
}
|
|
|
|
void team_gdf::OnProficiencyUpgrade( entity p, float type, float oldLevel, float newLevel ) {
|
|
if ( type == g_proficiencySoldier ) {
|
|
OnSoldierUpgrade( p, oldLevel, newLevel, false );
|
|
} else if ( type == g_proficiencyMedic ) {
|
|
OnMedicUpgrade( p, oldLevel, newLevel, false );
|
|
} else if ( type == g_proficiencyCovertOps ) {
|
|
OnCovertOpsUpgrade( p, oldLevel, newLevel, false );
|
|
} else if ( type == g_proficiencyBattleSense ) {
|
|
OnBattleSenseUpgrade( p, oldLevel, newLevel, false );
|
|
} else if ( type == g_proficiencyLightWeapons ) {
|
|
OnLightWeaponsUpgrade( p, oldLevel, newLevel, false );
|
|
}
|
|
}
|
|
|
|
boolean team_gdf::HasConstructionBonus( entity p ) {
|
|
return p.getProficiency( g_proficiencyEngineer ) >= 3;
|
|
}
|
|
|
|
boolean team_gdf::HasRepairBonus( entity p ) {
|
|
return p.getProficiency( g_proficiencyEngineer ) >= 2;
|
|
}
|
|
|
|
boolean team_gdf::HasDisarmBonus( entity p ) {
|
|
return p.getProficiency( g_proficiencyEngineer ) >= 3;
|
|
}
|
|
|
|
boolean team_gdf::HasChargeArmBonus( entity p ) {
|
|
return p.getProficiency( g_proficiencySoldier ) >= 3;
|
|
}
|
|
|
|
boolean team_gdf::HasSelfArmingMines( entity p ) {
|
|
return p.getProficiency( g_proficiencyEngineer ) >= 4;
|
|
}
|
|
|
|
boolean team_gdf::HasFastFireSupportLock( entity p ) {
|
|
return p.getProficiency( g_proficiencyFieldOps ) >= 3;
|
|
}
|
|
|
|
boolean team_gdf::HasFastFireSupportRecharge( entity p ) {
|
|
return p.getProficiency( g_proficiencyFieldOps ) >= 4;
|
|
}
|
|
|
|
boolean team_gdf::HasFastHackBonus( entity p ) {
|
|
return p.getProficiency( g_proficiencyCovertOps ) >= 3;
|
|
}
|
|
|
|
boolean team_gdf::HasVehicleArmorBonus( entity p ) {
|
|
return p.getProficiency( g_proficiencyVehicle ) >= 4;
|
|
}
|
|
|
|
boolean team_gdf::HasEnhancedRadar( entity p ) {
|
|
return p.getProficiency( g_proficiencyCovertOps ) >= 2;
|
|
}
|
|
|
|
boolean team_gdf::HasPersonalJammer( entity p ) {
|
|
if ( p.getPlayerClass() != g_playerClassCovertOps ) {
|
|
return false;
|
|
}
|
|
return p.getProficiency( g_proficiencyCovertOps ) >= 4;
|
|
}
|
|
|
|
boolean team_gdf::HasFastTargetLock( entity p ) {
|
|
return p.getProficiency( g_proficiencySoldier ) >= 1;
|
|
}
|
|
|
|
boolean team_gdf::CanRequestVehicle( entity p ) {
|
|
return p.getProficiency( g_proficiencyVehicle ) >= 1;
|
|
}
|
|
|
|
boolean team_gdf::HasEfficientDecoys( entity p ) {
|
|
return p.getProficiency( g_proficiencyVehicle ) >= 2;
|
|
}
|
|
|
|
boolean team_gdf::HasSpreadBonus( entity p ) {
|
|
return p.getProficiency( g_proficiencyLightWeapons ) >= 3;
|
|
}
|
|
|
|
boolean team_gdf::CanStab( entity p ) {
|
|
return ( p.getPlayerClass() == g_playerClassCovertOps ) || p.isDisguised();
|
|
}
|
|
|
|
float team_gdf::GetMaxSupplies( entity p ) {
|
|
if ( p.getProficiency( g_proficiencyMedic ) >= 2 ) {
|
|
return 2.f;
|
|
}
|
|
return 1.f;
|
|
}
|
|
|
|
float team_gdf::GetWeaponSpeedBonus( entity p ) {
|
|
if ( p.getPlayerClass() == g_playerClassSoldier ) {
|
|
if ( p.getProficiency( g_proficiencySoldier ) >= 4 ) {
|
|
return 0.5f;
|
|
}
|
|
}
|
|
|
|
return 0.f;
|
|
}
|
|
|
|
float team_gdf::GetHealthBoost( entity p ) {
|
|
float bonus = 0.f;
|
|
|
|
float playerClass = p.getPlayerClass();
|
|
if ( playerClass == g_playerClassSoldier ) {
|
|
bonus = bonus + 20.f;
|
|
}
|
|
|
|
float maxClients = sys.getMaxClients();
|
|
float index;
|
|
float boost = 0;
|
|
for ( index = 0; index < maxClients; index++ ) {
|
|
entity other = sys.getClient( index );
|
|
if ( other == $null_entity ) {
|
|
continue;
|
|
}
|
|
|
|
if ( other.getGameTeam() != self ) {
|
|
continue;
|
|
}
|
|
|
|
if ( other.hasAbility( "healthBoost" ) ) {
|
|
boost = boost + HEALTH_BOOST;
|
|
|
|
if ( boost >= MAX_HEALTH_BOOST ) {
|
|
boost = MAX_HEALTH_BOOST;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
bonus = bonus + boost;
|
|
|
|
return bonus;
|
|
}
|
|
|
|
void team_gdf::SetRespawnWait( float time ) {
|
|
respawnWait = time;
|
|
}
|
|
|
|
void team_gdf::CreatePersonnelAuras( entity p ) {
|
|
if ( !sys.isClient() ) {
|
|
if ( p.getProficiency( g_proficiencyBattleSense ) >= 4 ) {
|
|
p.vStartRegenThread();
|
|
}
|
|
}
|
|
}
|
|
|
|
void team_gdf::RegenPulse( entity p ) {
|
|
float current = p.getHealth();
|
|
float limit = p.getMaxHealth();
|
|
if ( current >= limit ) {
|
|
return;
|
|
}
|
|
|
|
current = current + 1;
|
|
if ( current > limit ) {
|
|
current = limit;
|
|
}
|
|
p.setHealth( current );
|
|
}
|
|
|
|
float team_gdf::GetFireSupportDelayScale() {
|
|
float count = CountPlayersOfClass( g_playerClassFieldOps ) - 1;
|
|
float scale = 1.f;
|
|
if ( count > 0 ) {
|
|
scale = scale + ( count * 0.5f );
|
|
}
|
|
return scale;
|
|
}
|