1736 lines
57 KiB
Lua
1736 lines
57 KiB
Lua
-- base_cp.lua
|
|
|
|
-- if you want base cp with the default setup,
|
|
-- include base_cp_default.lua in your map's lua file
|
|
-- and then include base_cp.lua
|
|
|
|
if OBJECTIVE_TEAM1 == nil then OBJECTIVE_TEAM1 = nil end
|
|
if OBJECTIVE_TEAM2 == nil then OBJECTIVE_TEAM2 = nil end
|
|
|
|
function startup()
|
|
SetGameDescription( "Sequential Control Points" )
|
|
|
|
-- disable certain teams
|
|
for i,v in pairs(disabled_teams) do
|
|
SetPlayerLimit( v, -1 )
|
|
end
|
|
|
|
-- set up team limits
|
|
for i1,v1 in pairs(teams) do
|
|
local team = GetTeam(v1)
|
|
for i2,v2 in ipairs(team_info[team:GetTeamId()].class_limits) do
|
|
team:SetClassLimit( i2, v2 )
|
|
end
|
|
end
|
|
|
|
RemoveAllCPAmmoAndArmor()
|
|
|
|
ChangeCPDefendingTeam( 1, TEAM1 )
|
|
ChangeCPDefendingTeam( CP_COUNT, TEAM2 )
|
|
|
|
for i,v in ipairs(command_points) do
|
|
RemoveSchedule( "cp" .. v.cp_number .. "_cap_timer" )
|
|
ResetCPCapping( v )
|
|
AddScheduleRepeating( "cp" .. v.cp_number .. "_cap_zone_timer", CAP_ZONE_TIMER_INTERVAL, cap_zone_timer, v )
|
|
end
|
|
|
|
OBJECTIVE_TEAM1 = "cp2_zone"
|
|
OBJECTIVE_TEAM2 = "cp4_zone"
|
|
UpdateTeamObjectiveIcon( GetTeam(TEAM1), GetEntityByName( OBJECTIVE_TEAM1 ) )
|
|
UpdateTeamObjectiveIcon( GetTeam(TEAM2), GetEntityByName( OBJECTIVE_TEAM2 ) )
|
|
end
|
|
|
|
function player_spawn( player_entity )
|
|
local player = CastToPlayer( player_entity )
|
|
|
|
player:AddHealth( 400 )
|
|
player:AddArmor( 400 )
|
|
|
|
player:AddAmmo( Ammo.kNails, 400 )
|
|
player:AddAmmo( Ammo.kShells, 400 )
|
|
player:AddAmmo( Ammo.kRockets, 400 )
|
|
player:AddAmmo( Ammo.kCells, 400 )
|
|
|
|
if player:GetTeamId() == TEAM1 then
|
|
UpdateObjectiveIcon( player, GetEntityByName( OBJECTIVE_TEAM1 ) )
|
|
elseif player:GetTeamId() == TEAM2 then
|
|
UpdateObjectiveIcon( player, GetEntityByName( OBJECTIVE_TEAM2 ) )
|
|
end
|
|
end
|
|
|
|
function precache()
|
|
|
|
-- precache the cap sounds
|
|
for i in pairs(good_cap_sounds) do
|
|
PrecacheSound(good_cap_sounds[i])
|
|
PrecacheSound(bad_cap_sounds[i])
|
|
end
|
|
|
|
PrecacheSound("misc.thunder")
|
|
|
|
PrecacheSound("Buttons.snd9")
|
|
PrecacheSound("Buttons.snd45")
|
|
|
|
PrecacheSound("ff_cz2.teleport_exit")
|
|
|
|
PrecacheSound("k_lab.teleport_post_winddown")
|
|
PrecacheSound("novaprospekt.teleport_post_thunder")
|
|
PrecacheSound("NPC_Ichthyosaur.AttackGrowl")
|
|
PrecacheSound("Streetwar.d3_c17_11_die")
|
|
PrecacheSound("streetwar.Ba_UseConsoleSounds")
|
|
|
|
PrecacheSound("misc.thunder")
|
|
PrecacheSound("misc.woop")
|
|
PrecacheSound("misc.bloop")
|
|
|
|
PrecacheSound("otherteam.flagstolen")
|
|
PrecacheSound("yourteam.flagcap")
|
|
PrecacheSound("otherteam.flagcap")
|
|
end
|
|
|
|
function PlayerStartTouchingCapZone( touch_entity, cp )
|
|
|
|
local player = CastToPlayer(touch_entity)
|
|
|
|
if PLAYER_TOUCHING_CP_ZONE[player:GetId()] == cp then return end
|
|
|
|
if player:GetTeamId() == TEAM1 then
|
|
if cp.cp_number > 1 then
|
|
local last_team1_cp = cp.cp_number - 1
|
|
if command_points[last_team1_cp].defending_team ~= TEAM1 then return end
|
|
end
|
|
elseif player:GetTeamId() == TEAM2 then
|
|
if cp.cp_number < CP_COUNT then
|
|
local last_team2_cp = cp.cp_number + 1
|
|
if command_points[last_team2_cp].defending_team ~= TEAM2 then return end
|
|
end
|
|
end
|
|
|
|
local team_number = player:GetTeamId()
|
|
|
|
PLAYER_TOUCHING_CP_ZONE[player:GetId()] = cp
|
|
|
|
cp.touching_players[team_number]:AddItem( player )
|
|
cp.former_touching_players[team_number]:RemoveItem( player )
|
|
if player:GetClass() == Player.kScout or player:GetClass() == Player.kMedic then
|
|
cp.cap_speed[team_number] = cp.cap_speed[team_number] + ( player:MaxSpeed() * 1.5 / 10 )
|
|
else
|
|
cp.cap_speed[team_number] = cp.cap_speed[team_number] + ( player:MaxSpeed() / 10 )
|
|
end
|
|
|
|
if team_number ~= cp.defending_team then
|
|
player:SetCloakable( false )
|
|
end
|
|
|
|
local cp_zone_hudicon = cp_zone_icons[team_number]
|
|
AddHudIcon( player, cp_zone_hudicon.hudicon, cp_zone_hudicon.hudicon, cp_zone_hudicon.hudx, cp_zone_hudicon.hudy, cp_zone_hudicon.hudwidth, cp_zone_hudicon.hudheight, cp_zone_hudicon.hudalign )
|
|
|
|
event_StartTouchingCP( touch_entity, cp )
|
|
end
|
|
|
|
function PlayerStopTouchingCapZone( touch_entity, cp )
|
|
|
|
local player = CastToPlayer(touch_entity)
|
|
|
|
if PLAYER_TOUCHING_CP_ZONE[player:GetId()] == nil then return end
|
|
|
|
local team_number = player:GetTeamId()
|
|
|
|
PLAYER_TOUCHING_CP_ZONE[player:GetId()] = nil
|
|
|
|
cp.touching_players[team_number]:RemoveItem( player )
|
|
cp.former_touching_players[team_number]:AddItem( player )
|
|
|
|
if player:GetClass() == Player.kScout or player:GetClass() == Player.kMedic then
|
|
cp.cap_speed[team_number] = cp.cap_speed[team_number] - ( player:MaxSpeed() * 1.5 / 10 )
|
|
else
|
|
cp.cap_speed[team_number] = cp.cap_speed[team_number] - ( player:MaxSpeed() / 10 )
|
|
end
|
|
|
|
-- clamp
|
|
if cp.cap_speed[team_number] < 0 then
|
|
cp.cap_speed[team_number] = 0
|
|
end
|
|
|
|
player:SetCloakable( true )
|
|
|
|
RemoveHudItem( player, cp_zone_icons[team_number].hudicon )
|
|
|
|
event_StopTouchingCP( touch_entity, cp )
|
|
|
|
end
|
|
|
|
|
|
function DrawCCAlarmIcon( cc_team_number )
|
|
|
|
-- check whether command centers are enabled
|
|
if not ENABLE_CC then return end
|
|
|
|
-- turn on alarm
|
|
if team_info[cc_team_number].cc_touch_count > 0 then
|
|
|
|
RemoveHudItemFromAll( cc_team_number .. "-ccalarmicon_neutral" )
|
|
AddHudIconToAll( team_info[cc_team_number].ccalarmicon, cc_team_number .. "-ccalarmicon", team_info[cc_team_number].ccalarmiconx, team_info[cc_team_number].ccalarmicony, team_info[cc_team_number].ccalarmiconwidth, team_info[cc_team_number].ccalarmiconheight, team_info[cc_team_number].ccalarmiconalign )
|
|
|
|
-- turn off alarm
|
|
else
|
|
|
|
RemoveHudItemFromAll( cc_team_number .. "-ccalarmicon" )
|
|
AddHudIconToAll( team_info[Team.kUnassigned].ccalarmicon, cc_team_number .. "-ccalarmicon_neutral", team_info[cc_team_number].ccalarmiconx, team_info[cc_team_number].ccalarmicony, team_info[cc_team_number].ccalarmiconwidth, team_info[cc_team_number].ccalarmiconheight, team_info[cc_team_number].ccalarmiconalign )
|
|
|
|
end
|
|
|
|
end
|
|
|
|
function EntityStartTouchingCC( touch_entity, cc_team_number )
|
|
|
|
if ENTITY_TOUCHING_CC[touch_entity:GetId()] ~= nil then return end
|
|
|
|
ENTITY_TOUCHING_CC[touch_entity:GetId()] = cc_team_number
|
|
|
|
team_info[cc_team_number].cc_touch_count = team_info[cc_team_number].cc_touch_count + 1
|
|
|
|
-- turn on alarm
|
|
if team_info[cc_team_number].cc_touch_count > 0 then
|
|
|
|
event_StartTouchingCC( touch_entity, cc_team_number )
|
|
|
|
end
|
|
|
|
DrawCCAlarmIcon( cc_team_number )
|
|
|
|
end
|
|
|
|
function EntityStopTouchingCC( touch_entity, cc_team_number )
|
|
|
|
if ENTITY_TOUCHING_CC[touch_entity:GetId()] == nil then return end
|
|
|
|
ENTITY_TOUCHING_CC[touch_entity:GetId()] = nil
|
|
|
|
team_info[cc_team_number].cc_touch_count = team_info[cc_team_number].cc_touch_count - 1
|
|
|
|
-- turn off alarm
|
|
if team_info[cc_team_number].cc_touch_count <= 0 then
|
|
|
|
team_info[cc_team_number].cc_touch_count = 0
|
|
|
|
event_StopTouchingCC( touch_entity, cc_team_number )
|
|
|
|
end
|
|
|
|
DrawCCAlarmIcon( cc_team_number )
|
|
|
|
end
|
|
|
|
function player_disconnected( player )
|
|
|
|
if PLAYER_TOUCHING_CP_ZONE[player:GetId()] ~= nil then
|
|
PlayerStopTouchingCapZone( player, PLAYER_TOUCHING_CP_ZONE[player:GetId()] )
|
|
end
|
|
|
|
if ENTITY_TOUCHING_CC[player:GetId()] ~= nil then
|
|
EntityStopTouchingCC( player, ENTITY_TOUCHING_CC[player:GetId()] )
|
|
end
|
|
|
|
end
|
|
|
|
function player_switchteam( player, currentteam, desiredteam )
|
|
|
|
if PLAYER_TOUCHING_CP_ZONE[player:GetId()] ~= nil then
|
|
PlayerStopTouchingCapZone( player, PLAYER_TOUCHING_CP_ZONE[player:GetId()] )
|
|
end
|
|
|
|
if ENTITY_TOUCHING_CC[player:GetId()] ~= nil then
|
|
EntityStopTouchingCC( player, ENTITY_TOUCHING_CC[player:GetId()] )
|
|
end
|
|
|
|
return true
|
|
|
|
end
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- timed scoring
|
|
-----------------------------------------------------------------------------
|
|
function cp_score_timer( cp_number, team_number )
|
|
|
|
local team = GetTeam(team_number)
|
|
team:AddScore(command_points[cp_number].point_value[team_number])
|
|
|
|
end
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- notify the players of the total cap.
|
|
-- Also, create a logic_relay in your map named fullcap_trigger to pass outputs to your entities.
|
|
-----------------------------------------------------------------------------
|
|
function complete_control_notification ( team_number )
|
|
local team = GetTeam(team_number)
|
|
SmartTeamSound(team, "yourteam.flagcap", "otherteam.flagcap")
|
|
SmartTeamSpeak(team, "CZ_GOTALL", "CZ_THEYGOTALL")
|
|
SmartTeamMessage(team, "#FF_CZ2_YOURTEAM_COMPLETE", "#FF_CZ2_OTHERTEAM_COMPLETE", Color.kGreen, Color.kRed)
|
|
OutputEvent( "fullcap_trigger", "Trigger" )
|
|
|
|
OBJECTIVE_TEAM1 = "cp2_zone"
|
|
OBJECTIVE_TEAM2 = "cp4_zone"
|
|
UpdateTeamObjectiveIcon( GetTeam(TEAM1), GetEntityByName( OBJECTIVE_TEAM1 ) )
|
|
UpdateTeamObjectiveIcon( GetTeam(TEAM2), GetEntityByName( OBJECTIVE_TEAM2 ) )
|
|
end
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- reset everything after the total cap.
|
|
-----------------------------------------------------------------------------
|
|
function complete_control_respawn ()
|
|
ApplyToAll( { AT.kRemovePacks, AT.kRemoveProjectiles, AT.kRespawnPlayers, AT.kRemoveBuildables, AT.kRemoveRagdolls, kReloadClips } )
|
|
end
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- emit a sound from an entity
|
|
-----------------------------------------------------------------------------
|
|
function EmitSound( entity, sound )
|
|
|
|
entity:EmitSound(sound)
|
|
|
|
end
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- remove all the ammo and armor from the entire map
|
|
-----------------------------------------------------------------------------
|
|
function RemoveAllCPAmmoAndArmor()
|
|
|
|
-- Remove all ammo and armor from CPs
|
|
local c = Collection()
|
|
c:GetByName(cp_ammo_and_armor_names, { CF.kNone })
|
|
for item in c.items do
|
|
item = CastToInfoScript(item)
|
|
item:Remove()
|
|
end
|
|
|
|
end
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- does the player have a flag?
|
|
-----------------------------------------------------------------------------
|
|
function PlayerHasFlag( player )
|
|
|
|
-- check if the player has a flag
|
|
for i,v in ipairs(flags) do
|
|
if player:HasItem(v) then
|
|
-- player has a flag
|
|
return true
|
|
end
|
|
end
|
|
|
|
-- player doesn't have a flag
|
|
return false
|
|
|
|
end
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- return carried flags
|
|
-----------------------------------------------------------------------------
|
|
function ReturnFlagFromPlayer( player )
|
|
|
|
-- Get all carried flags and ...
|
|
local c = Collection()
|
|
c:GetByName(flags, { CF.kInfoScript_Carried, })
|
|
|
|
-- ... return the flag that the player is carrying.
|
|
for item in c.items do
|
|
item = CastToInfoScript(item)
|
|
carrier = item:GetCarrier()
|
|
if player:GetId() == carrier:GetId() then
|
|
item:Return()
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- resupply a player when a cp is capped
|
|
-----------------------------------------------------------------------------
|
|
function CapResupply( player, scale, givethegoodshit )
|
|
|
|
-- give the player health and armor
|
|
if cap_resupply.health ~= nil and cap_resupply.health ~= 0 then player:AddHealth( cap_resupply.health * scale ) end
|
|
if cap_resupply.armor ~= nil and cap_resupply.armor ~= 0 then player:AddArmor( cap_resupply.armor * scale ) end
|
|
|
|
-- give the player ammo
|
|
if cap_resupply.nails ~= nil and cap_resupply.nails ~= 0 then player:AddAmmo( Ammo.kNails, cap_resupply.nails * scale ) end
|
|
if cap_resupply.shells ~= nil and cap_resupply.shells ~= 0 then player:AddAmmo( Ammo.kShells, cap_resupply.shells * scale ) end
|
|
if cap_resupply.rockets ~= nil and cap_resupply.rockets ~= 0 then player:AddAmmo( Ammo.kRockets, cap_resupply.rockets * scale ) end
|
|
if cap_resupply.cells ~= nil and cap_resupply.cells ~= 0 then player:AddAmmo( Ammo.kCells, cap_resupply.cells * scale ) end
|
|
|
|
if givethegoodshit then
|
|
-- give the player the good shit
|
|
if cap_resupply.detpacks ~= nil and cap_resupply.detpacks ~= 0 then player:AddAmmo( Ammo.kDetpack, cap_resupply.detpacks * scale ) end
|
|
if cap_resupply.mancannons ~= nil and cap_resupply.mancannons ~= 0 then player:AddAmmo( Ammo.kManCannon, cap_resupply.mancannons * scale ) end
|
|
if cap_resupply.gren1 ~= nil and cap_resupply.gren1 ~= 0 then player:AddAmmo( Ammo.kGren1, cap_resupply.gren1 * scale ) end
|
|
if cap_resupply.gren2 ~= nil and cap_resupply.gren2 ~= 0 then player:AddAmmo( Ammo.kGren2, cap_resupply.gren2 * scale ) end
|
|
end
|
|
|
|
end
|
|
|
|
function player_killed ( player_victim, damageinfo )
|
|
|
|
-- if no damageinfo do nothing
|
|
if not damageinfo then return end
|
|
|
|
-- Entity that is attacking
|
|
local attacker = damageinfo:GetAttacker()
|
|
|
|
-- If no attacker do nothing
|
|
if not attacker then return end
|
|
|
|
local player_attacker = nil
|
|
|
|
-- get the attacking player
|
|
if IsPlayer(attacker) then
|
|
attacker = CastToPlayer(attacker)
|
|
player_attacker = attacker
|
|
elseif IsSentrygun(attacker) then
|
|
attacker = CastToSentrygun(attacker)
|
|
player_attacker = attacker:GetOwner()
|
|
elseif IsDetpack(attacker) then
|
|
attacker = CastToDetpack(attacker)
|
|
player_attacker = attacker:GetOwner()
|
|
elseif IsDispenser(attacker) then
|
|
attacker = CastToDispenser(attacker)
|
|
player_attacker = attacker:GetOwner()
|
|
end
|
|
|
|
-- if still no attacking player after all that, try the inflictor
|
|
if not player_attacker then
|
|
|
|
-- Entity that is attacking
|
|
local inflictor = damageinfo:GetInflictor()
|
|
|
|
if inflictor then
|
|
if IsSentrygun(inflictor) then
|
|
inflictor = CastToSentrygun(inflictor)
|
|
player_attacker = inflictor:GetOwner()
|
|
elseif IsDetpack(inflictor) then
|
|
inflictor = CastToDetpack(inflictor)
|
|
player_attacker = inflictor:GetOwner()
|
|
elseif IsDispenser(inflictor) then
|
|
inflictor = CastToDispenser(inflictor)
|
|
player_attacker = inflictor:GetOwner()
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
-- if still no attacking player after all that, forget about it
|
|
if not player_attacker then return end
|
|
|
|
-- if victim killed self or teammate do nothing
|
|
if (player_victim:GetId() == player_attacker:GetId()) or (player_victim:GetTeamId() == player_attacker:GetTeamId()) then return end
|
|
|
|
local player_victim_touching_cp = PLAYER_TOUCHING_CP_ZONE[player_victim:GetId()]
|
|
local player_attacker_touching_cp = PLAYER_TOUCHING_CP_ZONE[player_attacker:GetId()]
|
|
|
|
-- the victim is standing in a zone
|
|
if player_victim_touching_cp ~= nil then
|
|
|
|
-- the victim is defending a cp or trying to capture a neutral cp
|
|
if player_victim:GetTeamId() == player_victim_touching_cp.defending_team or player_victim_touching_cp.defending_team == Team.kUnassigned then
|
|
|
|
--CapResupply( player_attacker, 0.25, false )
|
|
player_attacker:AddFortPoints((player_victim_touching_cp.point_value[player_attacker:GetTeamId()]) * 50, "#FF_FORTPOINTS_CAPTUREPOINT_ASSIST")
|
|
|
|
-- the victim is trying to capture the attacker's cp
|
|
else
|
|
|
|
--CapResupply( player_attacker, 0.25, false )
|
|
player_attacker:AddFortPoints((player_victim_touching_cp.point_value[player_attacker:GetTeamId()]) * 50, "#FF_FORTPOINTS_DEFENDPOINT")
|
|
|
|
end
|
|
|
|
end
|
|
|
|
-- the attacker is standing in a zone
|
|
if player_attacker_touching_cp ~= nil then
|
|
|
|
-- the attacker is defending a cp
|
|
if player_attacker:GetTeamId() == player_attacker_touching_cp.defending_team then
|
|
|
|
--CapResupply( player_attacker, 0.25, false )
|
|
player_attacker:AddFortPoints((player_attacker_touching_cp.point_value[player_attacker:GetTeamId()]) * 50, "#FF_FORTPOINTS_DEFENDPOINT")
|
|
|
|
-- the attacker is trying to capture a cp
|
|
else
|
|
|
|
--CapResupply( player_attacker, 0.25, false )
|
|
player_attacker:AddFortPoints((player_attacker_touching_cp.point_value[player_attacker:GetTeamId()]) * 50, "#FF_FORTPOINTS_CAPTUREPOINT_ASSIST")
|
|
|
|
end
|
|
|
|
end
|
|
|
|
-- loop through all former players of each command point
|
|
for k,v in ipairs(command_points) do
|
|
|
|
-- victim's team
|
|
for i in v.former_touching_players[player_victim:GetTeamId()].items do
|
|
|
|
i = CastToPlayer( i )
|
|
|
|
-- the victim was in an active zone
|
|
if i:GetId() == player_victim:GetId() then
|
|
|
|
-- the victim is defending a cp or trying to capture a neutral cp
|
|
if player_victim:GetTeamId() == v.defending_team or v.defending_team == Team.kUnassigned then
|
|
|
|
--CapResupply( player_attacker, 0.25, false )
|
|
player_attacker:AddFortPoints((v.point_value[player_attacker:GetTeamId()]) * 25, "#FF_FORTPOINTS_CAPTUREPOINT_ASSIST")
|
|
|
|
-- the victim is trying to capture the attacker's cp
|
|
else
|
|
|
|
--CapResupply( player_attacker, 0.25, false )
|
|
player_attacker:AddFortPoints((v.point_value[player_attacker:GetTeamId()]) * 25, "#FF_FORTPOINTS_DEFENDPOINT_ASSIST")
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
-- attacker's team
|
|
for i in v.former_touching_players[player_attacker:GetTeamId()].items do
|
|
|
|
i = CastToPlayer( i )
|
|
|
|
-- the attacker was in an active zone
|
|
if i:GetId() == player_attacker:GetId() then
|
|
|
|
-- the attacker is defending a cp
|
|
if player_attacker:GetTeamId() == v.defending_team then
|
|
|
|
--CapResupply( player_attacker, 0.25, false )
|
|
player_attacker:AddFortPoints((v.point_value[player_attacker:GetTeamId()]) * 25, "#FF_FORTPOINTS_DEFENDPOINT_ASSIST")
|
|
|
|
-- the attacker is trying to capture a cp
|
|
else
|
|
|
|
--CapResupply( player_attacker, 0.25, false )
|
|
player_attacker:AddFortPoints((v.point_value[player_attacker:GetTeamId()]) * 25, "#FF_FORTPOINTS_CAPTUREPOINT_ASSIST")
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- change the cp's defending team, its related visuals, and its scoring
|
|
-----------------------------------------------------------------------------
|
|
function ChangeCPDefendingTeam( cp_number, new_defending_team )
|
|
|
|
local cp = command_points[cp_number]
|
|
|
|
if cp_number > 1 and cp_number < CP_COUNT then
|
|
if new_defending_team == TEAM1 then
|
|
ResetCPCapping( command_points[cp_number - 1] )
|
|
elseif new_defending_team == TEAM2 then
|
|
ResetCPCapping( command_points[cp_number + 1] )
|
|
end
|
|
end
|
|
|
|
event_ChangeCPDefendingTeam( cp_number, new_defending_team )
|
|
|
|
-- remove old flaginfo icons and add new ones
|
|
RemoveHudItemFromAll( cp_number .. "-background-" .. cp.defending_team )
|
|
RemoveHudItemFromAll( cp_number .. "-foreground-" .. cp.defending_team )
|
|
|
|
AddHudIconToAll( icons[ new_defending_team ].teamicon, cp_number .. "-background-" .. new_defending_team, cp.hudposx, cp.hudposy, cp.hudwidth, cp.hudheight, cp.hudalign)
|
|
AddHudIconToAll( cp.hudstatusicon, cp_number .. "-foreground-" .. new_defending_team, cp.hudposx, cp.hudposy, cp.hudwidth, cp.hudheight, cp.hudalign)
|
|
|
|
local schedule_name = "cp" .. cp_number .. "_score_timer"
|
|
|
|
-- stop an existing timer
|
|
if cp.defending_team ~= Team.kUnassigned then
|
|
RemoveSchedule( schedule_name )
|
|
end
|
|
|
|
-- only worry with score timer for TEAM1 and TEAM2
|
|
if new_defending_team ~= Team.kUnassigned then
|
|
|
|
-- start the score timer
|
|
AddScheduleRepeating( schedule_name, cp.score_timer_interval[new_defending_team], cp_score_timer, cp_number, new_defending_team )
|
|
|
|
end
|
|
|
|
cp.defending_team = new_defending_team
|
|
|
|
end
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- restore all items in a CP
|
|
-----------------------------------------------------------------------------
|
|
function RestoreCPItems( cp_number, old_defending_team, new_defending_team )
|
|
|
|
local c = Collection()
|
|
c:GetByName( { "cp_cp" .. cp_number .. "_ammo", "cz2_cp" .. cp_number .. "_ammo", "cp_cp" .. cp_number .. "_armor", "cz2_cp" .. cp_number .. "_armor" }, { CF.kNone } )
|
|
for item in c.items do
|
|
item = CastToInfoScript(item)
|
|
|
|
-- restore this CP's ammo and armor
|
|
item:Restore()
|
|
|
|
-- Also set the touchflags so only the defending team can use the packs
|
|
item:SetTouchFlags(team_info[new_defending_team].touchflags)
|
|
end
|
|
|
|
end
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- reset team cp capping stuff
|
|
-----------------------------------------------------------------------------
|
|
function ResetTeamCPCapping( cp, team_number, do_total_reset, set_next_cap_zone_timer )
|
|
|
|
cp.cap_status[team_number] = 0
|
|
cp.next_cap_zone_timer[team_number] = set_next_cap_zone_timer
|
|
|
|
RemoveHudItemFromAll( cp.cp_number .. "-capstatusicon-" .. team_number )
|
|
RemoveHudItemFromAll( cp.cp_number .. "-caplockicon-" .. team_number )
|
|
event_ResetTeamCPCapping( cp, team_number )
|
|
|
|
if cp.former_touching_players[team_number]:Count() > 0 then
|
|
cp.former_touching_players[team_number]:RemoveAllItems()
|
|
end
|
|
|
|
if do_total_reset then
|
|
if cp.touching_players[team_number]:Count() > 0 then
|
|
cp.touching_players[team_number]:RemoveAllItems()
|
|
end
|
|
|
|
cp.cap_speed[team_number] = 0
|
|
end
|
|
|
|
end
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- reset all cp capping stuff
|
|
-----------------------------------------------------------------------------
|
|
function ResetCPCapping( cp )
|
|
|
|
for i,v in pairs(teams) do
|
|
ResetTeamCPCapping( cp, v, true, 0 )
|
|
end
|
|
|
|
end
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- reset and lock a capture point for a certain amount of time
|
|
-----------------------------------------------------------------------------
|
|
function LockCPCapping( cp, lock_time )
|
|
|
|
for i,v in pairs(teams) do
|
|
ResetTeamCPCapping( cp, v, true, lock_time )
|
|
end
|
|
|
|
end
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- reset and lock a capture point for a certain amount of time
|
|
-----------------------------------------------------------------------------
|
|
function StopCPScoring( cp_number )
|
|
|
|
local cp = command_points[cp_number]
|
|
|
|
if cp.defending_team ~= Team.kUnassigned then
|
|
RemoveSchedule( "cp" .. cp_number .. "_score_timer" )
|
|
end
|
|
|
|
end
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- the cp has definitely been captured
|
|
-----------------------------------------------------------------------------
|
|
function CaptureCP( cp_number, new_defending_team )
|
|
|
|
local cp = command_points[cp_number]
|
|
local old_defending_team = cp.defending_team
|
|
|
|
RestoreCPItems(cp_number, old_defending_team, new_defending_team)
|
|
|
|
-- Give points to team and player
|
|
local team = GetTeam(new_defending_team)
|
|
team:AddScore(cp.point_value[new_defending_team])
|
|
|
|
-- Find out if any team has complete control
|
|
local team_with_complete_control = Team.kUnassigned
|
|
local control_count = { [TEAM1] = 0, [TEAM2] = 0 }
|
|
control_count[new_defending_team] = 1
|
|
for i,v in ipairs(command_points) do
|
|
if v.defending_team ~= Team.kUnassigned and v.cp_number ~= cp_number then
|
|
control_count[v.defending_team] = control_count[v.defending_team] + 1
|
|
end
|
|
if control_count[v.defending_team] == CP_COUNT then
|
|
team_with_complete_control = v.defending_team
|
|
break
|
|
end
|
|
end
|
|
|
|
-- update objective icons if not all cp's captured
|
|
if team_with_complete_control == Team.kUnassigned then
|
|
if new_defending_team == TEAM1 then
|
|
OBJECTIVE_TEAM1 = "cp"..(cp_number+1).."_zone"
|
|
if old_defending_team ~= Team.kUnassigned then
|
|
OBJECTIVE_TEAM2 = "cp"..(cp_number).."_zone"
|
|
end
|
|
elseif new_defending_team == TEAM2 then
|
|
OBJECTIVE_TEAM2 = "cp"..(cp_number-1).."_zone"
|
|
if old_defending_team ~= Team.kUnassigned then
|
|
OBJECTIVE_TEAM1 = "cp"..(cp_number).."_zone"
|
|
end
|
|
end
|
|
UpdateTeamObjectiveIcon( GetTeam(TEAM1), GetEntityByName( OBJECTIVE_TEAM1 ) )
|
|
UpdateTeamObjectiveIcon( GetTeam(TEAM2), GetEntityByName( OBJECTIVE_TEAM2 ) )
|
|
end
|
|
|
|
if team_with_complete_control ~= Team.kUnassigned then
|
|
|
|
if ENABLE_COMPLETE_CONTROL_POINTS then
|
|
-- Bonus points for complete control
|
|
team:AddScore(POINTS_FOR_COMPLETE_CONTROL)
|
|
end
|
|
|
|
if ENABLE_COMPLETE_CONTROL_RESET then
|
|
|
|
AddSchedule("complete_control_notification", 0.1, complete_control_notification, team_with_complete_control)
|
|
|
|
if ENABLE_COMPLETE_CONTROL_RESPAWN then
|
|
|
|
-- change the team of the capped cp
|
|
ChangeCPDefendingTeam(cp_number, new_defending_team)
|
|
|
|
-- Lock all command points
|
|
-- Stop periodic scoring for all command points
|
|
for i,v in ipairs(command_points) do
|
|
StopCPScoring( i )
|
|
LockCPCapping( v, COMPLETE_CONTROL_RESPAWN_DELAY )
|
|
end
|
|
|
|
AddSchedule("complete_control", COMPLETE_CONTROL_RESPAWN_DELAY, TeamCompleteControl, team_with_complete_control )
|
|
else
|
|
TeamCompleteControl( team_with_complete_control )
|
|
end
|
|
|
|
-- get out now if resetting
|
|
return
|
|
|
|
end
|
|
|
|
end
|
|
|
|
ChangeCPDefendingTeam(cp_number, new_defending_team)
|
|
|
|
-- change the colors this team's respawn beams
|
|
--local beam_team = team_info[new_defending_team]
|
|
--beam_team.respawnbeam_color[beam_team.color_index] = beam_team.respawnbeam_color[Team.kUnassigned] + (control_count[new_defending_team] * 35)
|
|
--OutputEvent( beam_team.team_name .. "_respawn_beam", "Color", beam_team.respawnbeam_color[0] .. " " .. beam_team.respawnbeam_color[1] .. " " .. beam_team.respawnbeam_color[2] )
|
|
|
|
SmartTeamMessage( team, "#FF_CZ2_YOURTEAM_CP" .. cp_number, "#FF_CZ2_OTHERTEAM_CP" .. cp_number, Color.kGreen, Color.kRed )
|
|
|
|
-- sounds will get more and more crazy
|
|
--SmartTeamSound( team, good_cap_sounds[control_count[new_defending_team]], bad_cap_sounds[control_count[new_defending_team]] )
|
|
|
|
-- caes: changed it to announce the cp number captured/lost
|
|
SmartTeamSpeak( team, good_cap_sounds[cp_number], bad_cap_sounds[cp_number] )
|
|
end
|
|
|
|
function TeamCompleteControl( control_team )
|
|
|
|
-- Reset all command points
|
|
for i,v in ipairs(command_points) do
|
|
ChangeCPDefendingTeam(v.cp_number, Team.kUnassigned)
|
|
ResetCPCapping( v )
|
|
end
|
|
|
|
ChangeCPDefendingTeam( 1, TEAM1 )
|
|
ChangeCPDefendingTeam( CP_COUNT, TEAM2 )
|
|
|
|
-- reset colors of respawn beams
|
|
--OutputEvent( team_info[TEAM1].team_name .. "_respawn_beam", "Color", team_info[Team.kUnassigned].respawnbeam_color[0] .. " " .. team_info[Team.kUnassigned].respawnbeam_color[1] .. " " .. team_info[Team.kUnassigned].respawnbeam_color[2] )
|
|
--OutputEvent( team_info[TEAM2].team_name .. "_respawn_beam", "Color", team_info[Team.kUnassigned].respawnbeam_color[0] .. " " .. team_info[Team.kUnassigned].respawnbeam_color[1] .. " " .. team_info[Team.kUnassigned].respawnbeam_color[2] )
|
|
|
|
if ENABLE_FLAGS then
|
|
-- Return all flags
|
|
local c = Collection()
|
|
c:GetByName(flags, { CF.kNone })
|
|
for item in c.items do
|
|
item = CastToInfoScript(item)
|
|
item:Return()
|
|
end
|
|
end
|
|
|
|
RemoveAllCPAmmoAndArmor()
|
|
|
|
if ENABLE_COMPLETE_CONTROL_RESPAWN then
|
|
complete_control_respawn()
|
|
end
|
|
|
|
end
|
|
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- a cp's defending team successfully defended or capped
|
|
-----------------------------------------------------------------------------
|
|
function SuccessfulCPDefense( cp, team_number, is_a_cap )
|
|
|
|
-- reward the touching players
|
|
for i in cp.touching_players[team_number].items do
|
|
i = CastToPlayer( i )
|
|
if is_a_cap then
|
|
CapResupply( i, 0.50, is_a_cap )
|
|
i:AddFortPoints((cp.point_value[team_number]) * 100, "#FF_FORTPOINTS_CAPTUREPOINT")
|
|
i:SetCloakable( true )
|
|
else
|
|
--CapResupply( i, 0.50, is_a_cap )
|
|
i:AddFortPoints((cp.point_value[team_number]) * 50, "#FF_FORTPOINTS_DEFENDPOINT")
|
|
end
|
|
end
|
|
|
|
-- reward the former touching players
|
|
for i in cp.former_touching_players[team_number].items do
|
|
i = CastToPlayer( i )
|
|
if is_a_cap then
|
|
--CapResupply( i, 0.50, is_a_cap )
|
|
i:AddFortPoints((cp.point_value[team_number]) * 50, "#FF_FORTPOINTS_CAPTUREPOINT_ASSIST")
|
|
else
|
|
--CapResupply( i, 0.25, is_a_cap )
|
|
i:AddFortPoints((cp.point_value[team_number]) * 25, "#FF_FORTPOINTS_DEFENDPOINT_ASSIST")
|
|
end
|
|
end
|
|
|
|
-- no need to keep them around for future rewards
|
|
cp.former_touching_players[team_number]:RemoveAllItems()
|
|
|
|
end
|
|
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- timed cp capping
|
|
-----------------------------------------------------------------------------
|
|
function cap_zone_timer( cp )
|
|
|
|
local new_defending_team = Team.kUnassigned
|
|
local other_team = Team.kUnassigned
|
|
local last_cap_status = {}
|
|
local total_cap_speed = 0
|
|
local total_cap_status = 0
|
|
|
|
for i,v in pairs(teams) do
|
|
total_cap_speed = total_cap_speed + cp.cap_speed[v]
|
|
total_cap_status = total_cap_status + cp.cap_status[v]
|
|
end
|
|
|
|
for i,v in pairs(teams) do
|
|
|
|
-- don't bother doing some stuff if nothing has changed
|
|
last_cap_status[v] = cp.cap_status[v]
|
|
|
|
-- after one team caps a cp, the other team can't touch that cp for X seconds
|
|
if cp.next_cap_zone_timer[v] > 0 then
|
|
|
|
cp.next_cap_zone_timer[v] = cp.next_cap_zone_timer[v] - CAP_ZONE_TIMER_INTERVAL
|
|
|
|
local lock_percent = math.min( 1.0, cp.next_cap_zone_timer[v] / cp.delay_before_retouch[v] )
|
|
local minlockhudwidth = cp.hudwidth * 0.333
|
|
local minlockhudheight = cp.hudheight * 0.333
|
|
|
|
AddHudIconToAll( icons[v].lockicon, cp.cp_number .. "-caplockicon-" .. v, cp.hudposx, cp.hudposy + cp_zone_icons[v].hudposy_offset, minlockhudwidth + ( (cp.hudwidth - minlockhudwidth) * lock_percent ), minlockhudheight + ( (cp.hudheight - minlockhudheight) * lock_percent ), cp.hudalign)
|
|
|
|
-- clamp
|
|
if cp.next_cap_zone_timer[v] <= 0 then
|
|
cp.next_cap_zone_timer[v] = 0
|
|
RemoveHudItemFromAll( cp.cp_number .. "-caplockicon-" .. v )
|
|
end
|
|
|
|
-- this team is standing in the zone
|
|
elseif cp.cap_speed[v] > 0 then
|
|
|
|
-- don't bother with cap_status calculations for the defending team
|
|
if v == cp.defending_team then
|
|
|
|
cp.cap_status[v] = cp.cap_requirement[v]
|
|
|
|
-- calculate cap status
|
|
else
|
|
|
|
-- every vote counts
|
|
local affected_cap_speed = cp.cap_speed[v] - ( total_cap_speed - cp.cap_speed[v] )
|
|
|
|
cp.cap_status[v] = cp.cap_status[v] + affected_cap_speed
|
|
|
|
-- clamp
|
|
if cp.cap_status[v] < 0 then
|
|
|
|
cp.cap_status[v] = 0
|
|
|
|
-- potential capping team
|
|
elseif cp.cap_status[v] >= cp.cap_requirement[v] then
|
|
|
|
new_defending_team = v
|
|
|
|
-- clamp
|
|
cp.cap_status[v] = cp.cap_requirement[v]
|
|
|
|
end
|
|
end
|
|
|
|
-- this team is not standing in the zone
|
|
else
|
|
if v == cp.defending_team then
|
|
-- don't bother with cap_status calculations for the defending team
|
|
cp.cap_status[v] = 0
|
|
else
|
|
-- decrease cap status
|
|
cp.cap_status[v] = cp.cap_status[v] - ( CAP_ZONE_NOTOUCH_SPEED + total_cap_speed )
|
|
|
|
-- clamp
|
|
if cp.cap_status[v] < 0 then
|
|
cp.cap_status[v] = 0
|
|
end
|
|
end
|
|
end
|
|
|
|
-- don't bother doing some stuff if nothing has changed
|
|
if cp.cap_status[v] ~= last_cap_status[v] then
|
|
|
|
-- draw the cap status icon
|
|
if cp.cap_status[v] > 0 then
|
|
|
|
local cap_percent = cp.cap_status[v] / cp.cap_requirement[v]
|
|
local minhudwidth = cp.hudwidth * 0.333
|
|
local minhudheight = cp.hudheight * 0.333
|
|
AddHudIconToAll( cp_zone_icons[v].hudicon, cp.cp_number .. "-capstatusicon-" .. v, cp.hudposx, cp.hudposy + cp_zone_icons[v].hudposy_offset, minhudwidth + ( (cp.hudwidth - minhudwidth) * cap_percent ), minhudheight + ( (cp.hudheight - minhudheight) * cap_percent ), cp.hudalign)
|
|
-- only do this event once, when the team first starts capping
|
|
if last_cap_status[v] <= 0 then
|
|
event_StartTeamCPCapping( cp, v )
|
|
end
|
|
|
|
-- remove the cap status icon, remove former touching players, and reward defenders
|
|
else
|
|
|
|
-- reward the defenders
|
|
if v ~= cp.defending_team and cp.defending_team ~= Team.kUnassigned then
|
|
SuccessfulCPDefense( cp, cp.defending_team, false )
|
|
end
|
|
|
|
-- reset the other team's cp capping stuff
|
|
ResetTeamCPCapping( cp, v, false, 0 )
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if new_defending_team ~= v then
|
|
other_team = v
|
|
end
|
|
|
|
end
|
|
|
|
-- someone capped this cp
|
|
if new_defending_team ~= Team.kUnassigned then
|
|
|
|
-- cap the cp
|
|
SuccessfulCPDefense( cp, new_defending_team, true )
|
|
CaptureCP( cp.cp_number, new_defending_team )
|
|
|
|
-- reset the other team's cp capping stuff
|
|
ResetTeamCPCapping( cp, other_team, false, cp.delay_before_retouch[other_team] )
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- triggers
|
|
-----------------------------------------------------------------------------
|
|
|
|
cp_base_trigger = trigger_ff_script:new({ team = Team.kUnassigned, failtouch_message = "" })
|
|
|
|
function cp_base_trigger:allowed( allowed_entity )
|
|
|
|
if IsPlayer( allowed_entity ) then
|
|
local player = CastToPlayer( allowed_entity )
|
|
if player:GetTeamId() == self.team then
|
|
return EVENT_ALLOWED
|
|
end
|
|
end
|
|
return EVENT_DISALLOWED
|
|
end
|
|
|
|
function cp_base_trigger:onfailtouch( touch_entity )
|
|
|
|
if IsPlayer( touch_entity ) then
|
|
local player = CastToPlayer( touch_entity )
|
|
BroadCastMessageToPlayer( player, failtouch_message )
|
|
end
|
|
end
|
|
|
|
cp_team1_door_trigger = cp_base_trigger:new({ team = TEAM1 , failtouch_message = "#FF_NOTALLOWEDDOOR" })
|
|
cp_team2_door_trigger = cp_base_trigger:new({ team = TEAM2 , failtouch_message = "#FF_NOTALLOWEDDOOR" })
|
|
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- packs
|
|
-----------------------------------------------------------------------------
|
|
cp_base_pack = genericbackpack:new({
|
|
health = 100,
|
|
armor = 300,
|
|
nails = 200,
|
|
shells = 200,
|
|
rockets = 200,
|
|
cells = 200,
|
|
detpacks = 0,
|
|
mancannons = 0,
|
|
gren1 = 0,
|
|
gren2 = 0,
|
|
respawntime = 1,
|
|
touchflags = team_info[Team.kUnassigned].touchflags,
|
|
model = "models/items/backpack/backpack.mdl",
|
|
materializesound = "Item.Materialize",
|
|
touchsound = "Backpack.Touch",
|
|
cp_number = 0,
|
|
botgoaltype = Bot.kBackPack_Ammo,
|
|
})
|
|
|
|
function cp_base_pack:dropatspawn() return false end
|
|
|
|
cp_team1_respawn_pack = cp_base_pack:new( { touchflags = team_info[TEAM1].touchflags } )
|
|
cp_team2_respawn_pack = cp_base_pack:new( { touchflags = team_info[TEAM2].touchflags } )
|
|
|
|
cp_cp1_ammo = ammobackpack:new({cp_number = 1})
|
|
cp_cp2_ammo = ammobackpack:new({cp_number = 2})
|
|
cp_cp3_ammo = ammobackpack:new({cp_number = 3})
|
|
cp_cp4_ammo = ammobackpack:new({cp_number = 4})
|
|
cp_cp5_ammo = ammobackpack:new({cp_number = 5})
|
|
|
|
cp_cp1_armor = armorkit:new({cp_number = 1})
|
|
cp_cp2_armor = armorkit:new({cp_number = 2})
|
|
cp_cp3_armor = armorkit:new({cp_number = 3})
|
|
cp_cp4_armor = armorkit:new({cp_number = 4})
|
|
cp_cp5_armor = armorkit:new({cp_number = 5})
|
|
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- grenade packs
|
|
-----------------------------------------------------------------------------
|
|
cp_base_grenade_pack = cp_base_pack:new({
|
|
detpacks = 1,
|
|
mancannons = 1,
|
|
gren1 = 4,
|
|
gren2 = 4,
|
|
respawntime = 15,
|
|
touchflags = team_info[Team.kUnassigned].touchflags,
|
|
botgoaltype = Bot.kBackPack_Grenades,
|
|
})
|
|
|
|
cp_team1_grenade_pack = cp_base_grenade_pack:new( { touchflags = team_info[TEAM1].touchflags } )
|
|
cp_team2_grenade_pack = cp_base_grenade_pack:new( { touchflags = team_info[TEAM2].touchflags } )
|
|
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- cp zones
|
|
-----------------------------------------------------------------------------
|
|
|
|
cp_base_cp_zone = trigger_ff_script:new({
|
|
item = "",
|
|
team = 0,
|
|
botgoaltype = Bot.kFlagCap,
|
|
cp_number = 0,
|
|
})
|
|
|
|
function cp_base_cp_zone:ontrigger( trigger_entity )
|
|
|
|
-- check whether flags are used, and in turn wheter these triggers are used
|
|
if ENABLE_FLAGS or not ENABLE_CP_TELEPORTERS then return end
|
|
|
|
if IsPlayer( trigger_entity ) then
|
|
local player = CastToPlayer( trigger_entity )
|
|
|
|
-- Allow players on defending team to teleport back to base
|
|
if player:GetTeamId() == command_points[self.cp_number].defending_team then
|
|
|
|
if player:IsInUse() then
|
|
-- respawn the player
|
|
ApplyToPlayer( player, { AT.kRespawnPlayers, kReloadClips } )
|
|
|
|
OutputEvent( "cp" .. self.cp_number .. "_respawn_enter_sound", "PlaySound" )
|
|
AddSchedule("cp" .. self.cp_number .. "_respawn_" .. player:GetId(), 0.1, EmitSound, player, "ff_cz2.teleport_exit")
|
|
else
|
|
BroadCastMessageToPlayer(player, "#FF_CZ2_USE_RESPAWN")
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
function cp_base_cp_zone:ontouch( trigger_entity )
|
|
|
|
-- check whether flags are used, and in turn wheter these zones are used
|
|
if ENABLE_FLAGS then return end
|
|
|
|
if IsPlayer( trigger_entity ) then
|
|
local player = CastToPlayer( trigger_entity )
|
|
local cp = command_points[self.cp_number]
|
|
PlayerStartTouchingCapZone( player, cp )
|
|
end
|
|
|
|
end
|
|
|
|
function cp_base_cp_zone:onendtouch( trigger_entity )
|
|
|
|
-- check whether flags are used, and in turn wheter these zones are used
|
|
if ENABLE_FLAGS then return end
|
|
|
|
if IsPlayer( trigger_entity ) then
|
|
local player = CastToPlayer( trigger_entity )
|
|
local cp = command_points[self.cp_number]
|
|
PlayerStopTouchingCapZone( player, cp )
|
|
end
|
|
end
|
|
|
|
cp_cp1_cp_zone = cp_base_cp_zone:new({ cp_number = 1 })
|
|
cp_cp2_cp_zone = cp_base_cp_zone:new({ cp_number = 2 })
|
|
cp_cp3_cp_zone = cp_base_cp_zone:new({ cp_number = 3 })
|
|
cp_cp4_cp_zone = cp_base_cp_zone:new({ cp_number = 4 })
|
|
cp_cp5_cp_zone = cp_base_cp_zone:new({ cp_number = 5 })
|
|
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- cp triggers
|
|
-----------------------------------------------------------------------------
|
|
|
|
cp_base_cp_trigger = trigger_ff_script:new({
|
|
item = "",
|
|
team = 0,
|
|
botgoaltype = Bot.kFlagCap,
|
|
cp_number = 0,
|
|
})
|
|
|
|
function cp_base_cp_trigger:ontrigger( trigger_entity )
|
|
|
|
-- check whether flags are used, and in turn wheter these triggers are used
|
|
if not ENABLE_FLAGS or not ENABLE_CP_TELEPORTERS then return end
|
|
|
|
if IsPlayer( trigger_entity ) then
|
|
local player = CastToPlayer( trigger_entity )
|
|
|
|
-- Allow players on defending team to teleport back to base
|
|
if player:GetTeamId() == command_points[self.cp_number].defending_team then
|
|
|
|
if player:IsInUse() then
|
|
-- check if the player has a flag
|
|
for i,v in ipairs(flags) do
|
|
-- return the flag
|
|
if player:HasItem(v) then ReturnFlagFromPlayer(player) end
|
|
end
|
|
|
|
-- respawn the player
|
|
ApplyToPlayer( player, { AT.kRespawnPlayers, kReloadClips } )
|
|
|
|
OutputEvent( "cp" .. self.cp_number .. "_respawn_enter_sound", "PlaySound" )
|
|
AddSchedule("cp" .. self.cp_number .. "_respawn_" .. player:GetId(), 0.1, EmitSound, player, "ff_cz2.teleport_exit")
|
|
else
|
|
BroadCastMessageToPlayer(player, "#FF_CZ2_USE_RESPAWN")
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
function cp_base_cp_trigger:ontouch( trigger_entity )
|
|
|
|
-- check whether flags are used, and in turn wheter these triggers are used
|
|
if not ENABLE_FLAGS then return end
|
|
|
|
if IsPlayer( trigger_entity ) then
|
|
local player = CastToPlayer( trigger_entity )
|
|
local cp = command_points[self.cp_number]
|
|
|
|
-- No capping if player's team already defends this CP
|
|
if player:GetTeamId() == cp.defending_team then return end
|
|
|
|
-- get out if player doesn't have flag
|
|
if not PlayerHasFlag(player) then return end
|
|
|
|
ReturnFlagFromPlayer(player)
|
|
|
|
CaptureCP(self.cp_number, player:GetTeamId())
|
|
player:AddFortPoints((cp.point_value[player:GetTeamId()]) * 100, "#FF_FORTPOINTS_CAPTUREPOINT")
|
|
end
|
|
|
|
end
|
|
|
|
cp_cp1_cp_trigger = cp_base_cp_trigger:new({ cp_number = 1 })
|
|
cp_cp2_cp_trigger = cp_base_cp_trigger:new({ cp_number = 2 })
|
|
cp_cp3_cp_trigger = cp_base_cp_trigger:new({ cp_number = 3 })
|
|
cp_cp4_cp_trigger = cp_base_cp_trigger:new({ cp_number = 4 })
|
|
cp_cp5_cp_trigger = cp_base_cp_trigger:new({ cp_number = 5 })
|
|
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- flags
|
|
-----------------------------------------------------------------------------
|
|
|
|
cp_base_flag = info_ff_script:new({
|
|
name = "Base Flag",
|
|
team = 0,
|
|
model = "models/flag/flag.mdl",
|
|
tosssound = "Flag.Toss",
|
|
modelskin = 0,
|
|
dropnotouchtime = 2,
|
|
capnotouchtime = 2,
|
|
botgoaltype = Bot.kFlag,
|
|
hudicon = "",
|
|
hudx = 5,
|
|
hudy = 180,
|
|
hudalign = 1,
|
|
touchflags = team_info[Team.kUnassigned].touchflags
|
|
})
|
|
|
|
function cp_base_flag:precache()
|
|
PrecacheSound(self.tosssound)
|
|
info_ff_script.precache(self)
|
|
end
|
|
|
|
function cp_base_flag:spawn()
|
|
self.notouch = { }
|
|
info_ff_script.spawn(self)
|
|
end
|
|
|
|
function cp_base_flag:addnotouch(player_id, duration)
|
|
self.notouch[player_id] = duration
|
|
AddSchedule(self.name .. "-" .. player_id, duration, self.removenotouch, self, player_id)
|
|
end
|
|
|
|
function cp_base_flag.removenotouch(self, player_id)
|
|
self.notouch[player_id] = nil
|
|
end
|
|
|
|
function cp_base_flag:touch( touch_entity )
|
|
local player = CastToPlayer( touch_entity )
|
|
|
|
if player:GetTeamId() ~= self.team then return end
|
|
|
|
-- pickup if they can
|
|
if self.notouch[player:GetId()] then return end
|
|
|
|
-- make sure they don't have any flags already
|
|
for i,v in ipairs(flags) do
|
|
if player:HasItem(v) then return end
|
|
end
|
|
|
|
-- if the player is a spy, then force him to lose his disguise
|
|
player:SetDisguisable( false )
|
|
player:SetCloakable( false )
|
|
|
|
-- note: this seems a bit backwards (Pickup verb fits Player better)
|
|
local flag = CastToInfoScript(entity)
|
|
flag:Pickup(player)
|
|
player:AddEffect( EF.kSpeedlua1, -1, 0, FLAG_CARRIER_SPEED )
|
|
AddHudIcon( player, self.hudicon, flag:GetName(), self.hudx, self.hudy, self.hudwidth, self.hudheight, self.hudalign )
|
|
end
|
|
|
|
function cp_base_flag:onownerdie( owner_entity )
|
|
-- drop the flag
|
|
local flag = CastToInfoScript(entity)
|
|
flag:Drop(FLAG_RETURN_TIME, 0.0)
|
|
end
|
|
|
|
function cp_base_flag:onownerfeign( owner_entity )
|
|
-- drop the flag
|
|
local flag = CastToInfoScript(entity)
|
|
flag:Drop(FLAG_RETURN_TIME, 0.0)
|
|
end
|
|
function cp_base_flag:onownercloak( owner_entity )
|
|
-- drop the flag
|
|
local flag = CastToInfoScript(entity)
|
|
flag:Drop(FLAG_RETURN_TIME, 0.0)
|
|
end
|
|
function cp_base_flag:dropitemcmd( owner_entity )
|
|
-- throw the flag
|
|
local flag = CastToInfoScript(entity)
|
|
flag:Drop(FLAG_RETURN_TIME, FLAG_THROW_SPEED)
|
|
end
|
|
|
|
function cp_base_flag:ondrop( owner_entity )
|
|
local flag = CastToInfoScript(entity)
|
|
flag:EmitSound(self.tosssound)
|
|
end
|
|
|
|
function cp_base_flag:onloseitem( owner_entity )
|
|
-- let the player that lost the flag put on a disguise
|
|
local player = CastToPlayer( owner_entity )
|
|
player:SetDisguisable(true)
|
|
player:SetCloakable(true)
|
|
|
|
self:addnotouch(player:GetId(), self.capnotouchtime)
|
|
|
|
--player:RemoveEffect( EF.kSpeedlua1 )
|
|
-- remove flag icon from hud
|
|
local flag = CastToInfoScript(entity)
|
|
RemoveHudItem( player, flag:GetName() )
|
|
end
|
|
|
|
function cp_base_flag:onreturn( )
|
|
end
|
|
|
|
cp_team1_flag = cp_base_flag:new({
|
|
team = TEAM1,
|
|
modelskin = 0,
|
|
name = team_info[TEAM1].team_name .. " flag",
|
|
hudicon = "hud_flag_" .. team_info[TEAM1].team_name .. ".vtf",
|
|
hudx = 5,
|
|
hudy = 180,
|
|
hudwidth = 48,
|
|
hudheight = 48,
|
|
touchflags = team_info[TEAM1].touchflags
|
|
})
|
|
|
|
cp_team2_flag = cp_base_flag:new({
|
|
team = TEAM2,
|
|
modelskin = 1,
|
|
name = team_info[TEAM2].team_name .. " flag",
|
|
hudicon = "hud_flag_" .. team_info[TEAM2].team_name .. ".vtf",
|
|
hudx = 5,
|
|
hudy = 180,
|
|
hudwidth = 48,
|
|
hudheight = 48,
|
|
touchflags = team_info[TEAM2].touchflags
|
|
})
|
|
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- flag dispensers
|
|
-----------------------------------------------------------------------------
|
|
cp_base_flag_dispenser = trigger_ff_script:new({
|
|
name = "Base Flag Dispenser",
|
|
team = Team.kUnassigned,
|
|
dropnotouchtime = 2,
|
|
botgoaltype = Bot.kFlag,
|
|
hudicon = "",
|
|
hudx = 5,
|
|
hudy = 180,
|
|
hudwidth = 48,
|
|
hudheight = 48,
|
|
hudalign = 1,
|
|
flags = {"flag"}
|
|
})
|
|
|
|
function cp_base_flag_dispenser:allowed ( allowed_entity )
|
|
|
|
-- check whether flags are used, and in turn wheter these triggers are used
|
|
if not ENABLE_FLAGS then return EVENT_DISALLOWED end
|
|
|
|
if IsPlayer( allowed_entity ) then
|
|
local player = CastToPlayer( allowed_entity )
|
|
if player:GetTeamId() == self.team then
|
|
|
|
-- Player can't have a flag
|
|
local playerhasflag = false
|
|
|
|
for i,v in ipairs(self.flags) do
|
|
if player:HasItem(v) then
|
|
playerhasflag = true
|
|
break
|
|
end
|
|
end
|
|
|
|
-- get out if player doesn't have flag
|
|
if not playerhasflag then
|
|
return EVENT_ALLOWED
|
|
end
|
|
end
|
|
end
|
|
return EVENT_DISALLOWED
|
|
end
|
|
|
|
function cp_base_flag_dispenser:ontouch( trigger_entity )
|
|
|
|
-- check whether flags are used, and in turn wheter these triggers are used
|
|
if not ENABLE_FLAGS then return end
|
|
|
|
if IsPlayer( trigger_entity ) then
|
|
|
|
local player = CastToPlayer( trigger_entity )
|
|
|
|
local c = Collection()
|
|
c:GetByName( self.flags, { CF.kNone } )
|
|
-- give the player an inactive flag
|
|
for item in c.items do
|
|
item = CastToInfoScript(item)
|
|
if item:IsInactive() then
|
|
-- if the player is a spy, then force him to lose his disguise
|
|
player:SetDisguisable( false )
|
|
player:SetCloakable( false )
|
|
|
|
-- note: this seems a bit backwards (Pickup verb fits Player better)
|
|
item:Pickup(player)
|
|
player:AddEffect( EF.kSpeedlua1, -1, 0, FLAG_CARRIER_SPEED )
|
|
AddHudIcon( player, self.hudicon, item:GetName(), self.hudx, self.hudy, self.hudwidth, self.hudheight, self.hudalign )
|
|
|
|
player:EmitSound("Buttons.snd9")
|
|
|
|
-- all done
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
cp_team1_flag_dispenser = cp_base_flag_dispenser:new({
|
|
name = team_info[TEAM1].team_name .. " flag dispenser",
|
|
team = TEAM1,
|
|
hudicon = "hud_flag_" .. team_info[TEAM1].team_name .. ".vtf",
|
|
flags = { team_info[TEAM1].team_name .. "_flag" }
|
|
})
|
|
|
|
cp_team2_flag_dispenser = cp_base_flag_dispenser:new({
|
|
name = team_info[TEAM2].team_name .. " flag dispenser",
|
|
team = TEAM2,
|
|
hudicon = "hud_flag_" .. team_info[TEAM2].team_name .. ".vtf",
|
|
flags = { team_info[TEAM2].team_name .. "_flag" }
|
|
})
|
|
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- command centers
|
|
-----------------------------------------------------------------------------
|
|
|
|
cp_base_command_center = trigger_ff_script:new({ team = Team.kUnassigned, enemy_team = Team.kUnassigned })
|
|
function cp_base_command_center:onexplode( explosion_entity )
|
|
|
|
-- check whether command centers are enabled
|
|
if not ENABLE_CC then return EVENT_ALLOWED end
|
|
|
|
if IsDetpack( explosion_entity ) then
|
|
local detpack = CastToDetpack(explosion_entity)
|
|
|
|
-- don't let assholes destroy their own team's command center
|
|
if detpack:GetTeamId() == self.team then return EVENT_ALLOWED end
|
|
|
|
local points = CC_DESTROY_POINTS
|
|
for i,v in ipairs(command_points) do
|
|
if v.defending_team == self.team then
|
|
-- taking CP 1 away from team2 is worth more than taking CP 5 away from them
|
|
points = points + v.point_value[self.team]
|
|
|
|
-- Remove all ammo and armor from CPs
|
|
local c = Collection()
|
|
c:GetByName({"cp_cp" .. v.cp_number .. "_ammo", "cz2_cp" .. v.cp_number .. "_ammo", "cp_cp" .. v.cp_number .. "_armor", "cz2_cp" .. v.cp_number .. "_armor"}, { CF.kNone })
|
|
for item in c.items do
|
|
item = CastToInfoScript(item)
|
|
item:Remove()
|
|
end
|
|
|
|
-- reset the CP
|
|
ChangeCPDefendingTeam(v.cp_number, Team.kUnassigned)
|
|
end
|
|
|
|
-- reset the other team's cp capping stuff
|
|
ResetTeamCPCapping( v, self.team, false, v.delay_before_retouch[self.team] * 2.0 )
|
|
end
|
|
|
|
local team = detpack:GetTeam()
|
|
team:AddScore(points)
|
|
|
|
local player = detpack:GetOwner()
|
|
player:AddFortPoints(points * 100, "#FF_FORTPOINTS_DESTROY_CC" )
|
|
|
|
SmartSound(player, "misc.thunder", "misc.thunder", "misc.thunder")
|
|
SmartMessage(player, "#FF_CZ2_YOU_CC", "#FF_CZ2_YOURTEAM_CC", "#FF_CZ2_OTHERTEAM_CC", Color.kGreen, Color.kGreen, Color.kRed)
|
|
SpeakAll( team_info[self.team].detcc_sentence )
|
|
|
|
-- EntityStopTouchingCC( detpack, self.team )
|
|
|
|
end
|
|
|
|
return EVENT_ALLOWED
|
|
end
|
|
|
|
function cp_base_command_center:ontouch( trigger_entity )
|
|
|
|
-- check whether command centers are enabled
|
|
if not ENABLE_CC then return end
|
|
|
|
-- if IsDetpack( trigger_entity ) then
|
|
-- local detpack = CastToDetpack( trigger_entity )
|
|
-- if detpack:GetTeamId() ~= self.team then
|
|
-- EntityStartTouchingCC( detpack, self.team )
|
|
-- end
|
|
-- end
|
|
|
|
if IsPlayer( trigger_entity ) then
|
|
local player = CastToPlayer( trigger_entity )
|
|
if player:GetTeamId() ~= self.team then
|
|
EntityStartTouchingCC( player, self.team )
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
function cp_base_command_center:onendtouch( trigger_entity )
|
|
|
|
-- check whether command centers are enabled
|
|
if not ENABLE_CC then return end
|
|
|
|
-- if IsDetpack( trigger_entity ) then
|
|
-- local detpack = CastToDetpack( trigger_entity )
|
|
-- if detpack:GetTeamId() ~= self.team then
|
|
-- EntityStopTouchingCC( detpack, self.team )
|
|
-- end
|
|
-- end
|
|
|
|
if IsPlayer( trigger_entity ) then
|
|
local player = CastToPlayer( trigger_entity )
|
|
if player:GetTeamId() ~= self.team then
|
|
EntityStopTouchingCC( player, self.team )
|
|
end
|
|
end
|
|
end
|
|
|
|
cp_team1_command_center = cp_base_command_center:new({ team = TEAM1, enemy_team = TEAM2 })
|
|
cp_team2_command_center = cp_base_command_center:new({ team = TEAM2, enemy_team = TEAM1 })
|
|
|
|
|
|
-------------------------------------------
|
|
-- cc computers
|
|
-------------------------------------------
|
|
|
|
cp_base_cc_computer = trigger_ff_script:new({ prefix = "unassigned", enemy_team = Team.kUnassigned })
|
|
|
|
function cp_base_cc_computer:ontrigger( trigger_entity )
|
|
|
|
-- check whether command centers are enabled
|
|
if not ENABLE_CC then return end
|
|
|
|
if IsPlayer( trigger_entity ) then
|
|
local player = CastToPlayer( trigger_entity )
|
|
|
|
-- Allow spies to open the enemy doors
|
|
if player:GetTeamId() == self.enemy_team and player:GetClass() == Player.kSpy then
|
|
|
|
if player:IsInUse() then
|
|
for i,v in ipairs(doors) do
|
|
-- open each enemy door
|
|
OutputEvent( self.prefix .. v, "Open" )
|
|
end
|
|
else
|
|
-- tell the player they can open the enemy doors
|
|
BroadCastMessageToPlayer(player, "#FF_CZ2_USE_DOORS")
|
|
end
|
|
|
|
end
|
|
end
|
|
end
|
|
|
|
cp_team1_cc_computer = cp_base_cc_computer:new({ prefix = team_info[TEAM1].team_name, enemy_team = TEAM2 })
|
|
cp_team2_cc_computer = cp_base_cc_computer:new({ prefix = team_info[TEAM2].team_name, enemy_team = TEAM1 })
|
|
|
|
|
|
-------------------------------------------
|
|
-- cp flaginfo
|
|
-------------------------------------------
|
|
|
|
function flaginfo( player_entity )
|
|
|
|
local player = CastToPlayer( player_entity )
|
|
|
|
for i,v in ipairs(command_points) do
|
|
|
|
ConsoleToAll( "CP Number: " .. v.cp_number )
|
|
ConsoleToAll( "Team: " .. v.defending_team )
|
|
ConsoleToAll( "Icon: " .. icons[ v.defending_team ].teamicon )
|
|
|
|
AddHudIcon( player, icons[ v.defending_team ].teamicon , v.cp_number .. "-background-" .. v.defending_team , command_points[v.cp_number].hudposx, command_points[v.cp_number].hudposy, command_points[v.cp_number].hudwidth, command_points[v.cp_number].hudheight, command_points[v.cp_number].hudalign)
|
|
AddHudIcon( player, command_points[v.cp_number].hudstatusicon, v.cp_number .. "-foreground-" .. v.defending_team , command_points[v.cp_number].hudposx, command_points[v.cp_number].hudposy, command_points[v.cp_number].hudwidth, command_points[v.cp_number].hudheight, command_points[v.cp_number].hudalign)
|
|
|
|
end
|
|
|
|
DrawCCAlarmIcon( TEAM1 )
|
|
DrawCCAlarmIcon( TEAM2 )
|
|
|
|
end
|
|
|
|
|
|
-------------------------------------------
|
|
-- cp teleporters
|
|
-------------------------------------------
|
|
|
|
trigger_teleport = trigger_ff_script:new({})
|
|
cp_base_teleporter = trigger_teleport:new({ cp_number = 0, next_teleport_tick = 0 })
|
|
|
|
function cp_base_teleporter:allowed( allowed_entity )
|
|
|
|
-- check whether cc-to-cp teleporters are enabled
|
|
if not ENABLE_CC or not ENABLE_CC_TELEPORTERS then return EVENT_DISALLOWED end
|
|
|
|
local stime = GetServerTime()
|
|
|
|
if self.next_teleport_tick > stime then return end
|
|
|
|
if IsPlayer( allowed_entity ) then
|
|
|
|
local player = CastToPlayer( allowed_entity )
|
|
-- Allow players on defending team to teleport to cp
|
|
if player:GetTeamId() == command_points[self.cp_number].defending_team then
|
|
|
|
if player:IsInUse() then
|
|
-- teleport the player
|
|
local team_name = team_info[player:GetTeamId()].team_name
|
|
|
|
if ENTITY_TOUCHING_CC[player:GetId()] ~= nil then
|
|
team_name = team_info[ENTITY_TOUCHING_CC[player:GetId()]].team_name
|
|
end
|
|
|
|
OutputEvent( team_name .. "_cp" .. self.cp_number .. "_teleport_enter_sound", "PlaySound" )
|
|
--OutputEvent( team_name .. "_cp" .. self.cp_number .. "_teleport_exit_sound", "PlaySound", "", 0.1 )
|
|
OutputEvent( team_name .. "_cp" .. self.cp_number .. "_teleport_tesla", "DoSpark", "", 0.1 )
|
|
|
|
--self.next_teleport_tick = stime + 1.0
|
|
|
|
ApplyToPlayer( player, { AT.kStopPrimedGrens, kReloadClips } )
|
|
|
|
return EVENT_ALLOWED
|
|
else
|
|
-- tell the player they can teleport
|
|
BroadCastMessageToPlayer(player, "#FF_CZ2_USE_TELEPORT")
|
|
end
|
|
|
|
end
|
|
end
|
|
|
|
return EVENT_DISALLOWED
|
|
|
|
end
|
|
|
|
-- team1 teleporters
|
|
cp_team1_teleporter_cp1 = cp_base_teleporter:new({ cp_number = 1 })
|
|
cp_team1_teleporter_cp2 = cp_base_teleporter:new({ cp_number = 2 })
|
|
cp_team1_teleporter_cp3 = cp_base_teleporter:new({ cp_number = 3 })
|
|
cp_team1_teleporter_cp4 = cp_base_teleporter:new({ cp_number = 4 })
|
|
cp_team1_teleporter_cp5 = cp_base_teleporter:new({ cp_number = 5 })
|
|
|
|
-- team2 teleporters
|
|
cp_team2_teleporter_cp1 = cp_base_teleporter:new({ cp_number = 1 })
|
|
cp_team2_teleporter_cp2 = cp_base_teleporter:new({ cp_number = 2 })
|
|
cp_team2_teleporter_cp3 = cp_base_teleporter:new({ cp_number = 3 })
|
|
cp_team2_teleporter_cp4 = cp_base_teleporter:new({ cp_number = 4 })
|
|
cp_team2_teleporter_cp5 = cp_base_teleporter:new({ cp_number = 5 })
|
|
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- locations
|
|
-----------------------------------------------------------------------------
|
|
|
|
location_cp1 = location_info:new({ text = "#FF_LOCATION_COMMAND_POINT_ONE", team = NO_TEAM })
|
|
location_cp2 = location_info:new({ text = "#FF_LOCATION_COMMAND_POINT_TWO", team = NO_TEAM })
|
|
location_cp3 = location_info:new({ text = "#FF_LOCATION_COMMAND_POINT_THREE", team = NO_TEAM })
|
|
location_cp4 = location_info:new({ text = "#FF_LOCATION_COMMAND_POINT_FOUR", team = NO_TEAM })
|
|
location_cp5 = location_info:new({ text = "#FF_LOCATION_COMMAND_POINT_FIVE", team = NO_TEAM })
|
|
|
|
location_cp1_path = location_info:new({ text = "#FF_LOCATION_CP1_PATH", team = TEAM1 })
|
|
location_cp2_path = location_info:new({ text = "#FF_LOCATION_CP2_PATH", team = TEAM1 })
|
|
location_cp3_path = location_info:new({ text = "#FF_LOCATION_CP3_PATH", team = NO_TEAM })
|
|
location_cp4_path = location_info:new({ text = "#FF_LOCATION_CP4_PATH", team = TEAM2 })
|
|
location_cp5_path = location_info:new({ text = "#FF_LOCATION_CP5_PATH", team = TEAM2 })
|
|
|
|
location_catacombs = location_info:new({ text = "#FF_LOCATION_CATACOMBS", team = NO_TEAM })
|
|
|
|
location_blue_base = location_info:new({ text = "#FF_LOCATION_BASE", team = TEAM1 })
|
|
location_blue_cc = location_info:new({ text = "#FF_LOCATION_COMMAND_CENTER", team = TEAM1 })
|
|
location_blue_outside_base = location_info:new({ text = "#FF_LOCATION_OUTSIDE_BASE", team = TEAM1 })
|
|
location_blue_canal = location_info:new({ text = "#FF_LOCATION_CANAL", team = TEAM1 })
|
|
location_blue_catacombs = location_info:new({ text = "#FF_LOCATION_CATACOMBS", team = TEAM1 })
|
|
|
|
location_red_base = location_info:new({ text = "#FF_LOCATION_BASE", team = TEAM2 })
|
|
location_red_cc = location_info:new({ text = "#FF_LOCATION_COMMAND_CENTER", team = TEAM2 })
|
|
location_red_outside_base = location_info:new({ text = "#FF_LOCATION_OUTSIDE_BASE", team = TEAM2 })
|
|
location_red_canal = location_info:new({ text = "#FF_LOCATION_CANAL", team = TEAM2 })
|
|
location_red_catacombs = location_info:new({ text = "#FF_LOCATION_CATACOMBS", team = TEAM2 })
|
|
|
|
|
|
-----------------------------------------------------------------------------
|
|
-- backwards compatiblity - use "cp_*" names in your map instead!
|
|
-----------------------------------------------------------------------------
|
|
base_team_trigger = cp_base_trigger
|
|
blue_door_trigger = cp_team1_door_trigger
|
|
red_door_trigger = cp_team2_door_trigger
|
|
|
|
cz2_base_pack = cp_base_pack
|
|
cz2_blue_respawn_pack = cp_team1_respawn_pack
|
|
cz2_red_respawn_pack = cp_team2_respawn_pack
|
|
|
|
cz2_cp1_ammo = cp_cp1_ammo
|
|
cz2_cp2_ammo = cp_cp2_ammo
|
|
cz2_cp3_ammo = cp_cp3_ammo
|
|
cz2_cp4_ammo = cp_cp4_ammo
|
|
cz2_cp5_ammo = cp_cp5_ammo
|
|
|
|
cz2_cp1_armor = cp_cp1_armor
|
|
cz2_cp2_armor = cp_cp2_armor
|
|
cz2_cp3_armor = cp_cp3_armor
|
|
cz2_cp4_armor = cp_cp4_armor
|
|
cz2_cp5_armor = cp_cp5_armor
|
|
|
|
cz2_base_grenade_pack = cp_base_grenade_pack
|
|
cz2_blue_grenade_pack = cp_team1_grenade_pack
|
|
cz2_red_grenade_pack = cp_team2_grenade_pack
|
|
|
|
base_cp_zone = cp_base_cp_zone
|
|
cp1_zone = cp_cp1_cp_zone
|
|
cp2_zone = cp_cp2_cp_zone
|
|
cp3_zone = cp_cp3_cp_zone
|
|
cp4_zone = cp_cp4_cp_zone
|
|
cp5_zone = cp_cp5_cp_zone
|
|
|
|
base_cp_trigger = cp_base_cp_trigger
|
|
cp1_trigger = cp_cp1_cp_trigger
|
|
cp2_trigger = cp_cp2_cp_trigger
|
|
cp3_trigger = cp_cp3_cp_trigger
|
|
cp4_trigger = cp_cp4_cp_trigger
|
|
cp5_trigger = cp_cp5_cp_trigger
|
|
|
|
base_cp_flag = cp_base_flag
|
|
blue_flag = cp_team1_flag
|
|
red_flag = cp_team2_flag
|
|
|
|
cp_base_flag_dispenser = base_cp_flag_dispenser
|
|
blue_flag_dispenser = cp_team1_flag_dispenser
|
|
red_flag_dispenser = cp_team2_flag_dispenser
|
|
|
|
base_command_center = cp_base_command_center
|
|
blue_command_center = cp_team1_command_center
|
|
red_command_center = cp_team2_command_center
|
|
|
|
base_cp_cc_computer = cp_base_cc_computer
|
|
blue_cc_computer = cp_team1_cc_computer
|
|
red_cc_computer = cp_team2_cc_computer
|
|
|
|
base_cp_teleporter = cp_base_teleporter
|
|
blue_teleporter_cp1 = cp_team1_teleporter_cp1
|
|
blue_teleporter_cp2 = cp_team1_teleporter_cp2
|
|
blue_teleporter_cp3 = cp_team1_teleporter_cp3
|
|
blue_teleporter_cp4 = cp_team1_teleporter_cp4
|
|
blue_teleporter_cp5 = cp_team1_teleporter_cp5
|
|
red_teleporter_cp1 = cp_team2_teleporter_cp1
|
|
red_teleporter_cp2 = cp_team2_teleporter_cp2
|
|
red_teleporter_cp3 = cp_team2_teleporter_cp3
|
|
red_teleporter_cp4 = cp_team2_teleporter_cp4
|
|
red_teleporter_cp5 = cp_team2_teleporter_cp5
|
|
|
|
|