def OnUnloadGamePlay(self): GEUtil.HudMessage( None, "", -1, 0.0, GEUtil.CColor(255,255,255,255), 0, self.scoreDisplayChannel ) GEUtil.HudMessage( None, "", -1, 0.0, GEUtil.CColor(255,255,255,255), 0, self.skipMSgChannel ) GEUtil.HudMessage( None, "", -1, 0.0, GEUtil.CColor(255,255,255,255), 0, self.weaponMsgChannel ) GEUtil.RemoveHudProgressBar(None, self.timerBarIndex) GEUtil.RemoveHudProgressBar(None, self.skipTextIndex) self.setDamageMultiplier( 1 )
def OnCaptureAreaEntered(self, area, player, token):
assert isinstance(area, GEEntity.CBaseEntity)
assert isinstance(player, GEPlayer.CGEMPPlayer)
assert isinstance(token, GEWeapon.CGEWeapon)
if token is None:
return
# If the other team has our token, we have to wait a set period
tokenteam = token.GetTeamNumber()
otherteam = OppositeTeam(player.GetTeamNumber())
if self.ctk_IsTokenHeld(otherteam) and self.rules_overrideTime >= 0:
if self.rules_overrideTime > 0 and not self.game_inOvertime: # Can't capture if other team has your token in overtime.
timer = self.game_timers[tokenteam]
if timer.state is Timer.STATE_STOP:
GEUtil.InitHudProgressBar(
player, self.PROBAR_OVERRIDE,
"#GES_GP_CTK_CAPTURE_OVR", Glb.HUDPB_SHOWBAR,
self.rules_overrideTime, -1, 0.6, 120, 16,
GEUtil.CColor(220, 220, 220, 240))
timer.Start(self.rules_overrideTime)
else:
GEUtil.HudMessage(player, "#GES_GP_CTK_CAPTURE_DENY", -1, 0.6,
GEUtil.CColor(220, 220, 220, 240), 2.0,
self.MSG_MISC_CHANNEL)
else:
self.ctk_CaptureToken(token, player)
def __init__( self ):
super( HoldTheBriefcase, self ).__init__()
self.warmupTimer = GEWarmUp( self )
self.notice_WaitingForPlayers = 0
self.WaitingForPlayers = True
self.teamScoringTimer = 100
self.TokenClass = "token_deathmatch"
self.RoundActive = False
self.caseDict = {}
self.prevCount = 0
self.nextCheckTime = -1
self.roundScoreJanus = 0
self.roundScoreMI6 = 0
# >> Colors >>
self.colorMsg = GEUtil.CColor(255,255,255,240)
self.colorCase = GEUtil.CColor(230,230,230,240)
self.colorMI6 = GEUtil.CColor(0,150,255,255)
self.colorJanus = GEUtil.CColor(255,0,0,255)
self.scoreboardDefault = GEGlobal.SB_COLOR_NORMAL
self.scoreboardOwner = GEGlobal.SB_COLOR_WHITE
# >> Messages & Text
self.caseName = "Briefcase"
self.dropText = " ^1dropped a ^u" + self.caseName
self.grabText = " ^1picked up a ^u" + self.caseName
self.pickText = "Picked up a " + self.caseName
def SetupObjective(self,
entity,
team_filter=GEGlobal.TEAM_NONE,
token_filter="",
text="",
color=GEUtil.CColor(),
min_dist=0,
pulse=False):
'''
Setup an on-screen objective icon. RADAR_TYPE_OBJECTIVE or RADAR_TYPE_TOKEN
automatically become objectives, you can override the defaults with this
function. Use the team_filter to restrict the icon by team number. Use
token_filter to restrict the icon to those who hold the named token, put
a ! in front of the name for the inverse. Text displays above the icon. Set
min_dist to have icons fade out when the player is within this distance to
the objective. Pulse causes the icon to pulse, useful to attract attention.
entity -- Entity to make an objective
Keyword Arguments:
team_filter -- Team ID that can see this objective
token_filter -- Token classname that a player must hold to see this objective
text -- Text to display above the icon
color -- Color of the icon
min_dist -- Minimum viewable distance, useful to prevent griefing
pulse -- Cause the icon to slowly pulse
'''
return
def CanPlayerChangeTeam(self, player, oldteam, newteam, wasforced):
# The hacker cannot change teams
if player.GetUID() == self.hacker_playerUID:
GEUtil.HudMessage(player, "You cannot change teams as the hacker!", -1, -1,
GEUtil.CColor(255, 255, 255, 255), 3.0)
return False
return True
def lc_CreateHackingTool(self):
mgr = GERules.GetTokenMgr()
mgr.SetupToken(self.TOOL_CLASSNAME,
limit=1,
location=Glb.SPAWN_AMMO,
allow_switch=True,
glow_color=GEUtil.CColor(80, 80, 80, 255),
glow_dist=500.0)
def __init__(self):
super(LivingDaylights, self).__init__()
self.TokenClass = 'token_deathmatch'
self.TokenGlow = GEUtil.CColor(244, 192, 11, 64)
self.MI6Flags = 0
self.JanusFlags = 0
self.FlagCount = 0
self.ShowMI6Flags = True
self.ShowJanusFlags = True
def OnTokenSpawned(self, token):
self.ft_registerflag(GEEntity.GetUID(token))
GEMPGameRules.GetRadar().AddRadarContact(token,
GEGlobal.RADAR_TYPE_TOKEN,
True, "", self.COLOR_COLD)
GEMPGameRules.GetRadar().SetupObjective(
token, GEGlobal.TEAM_NONE, "!%s" % self.TokenClass,
"#GES_GP_LD_OBJ_TAKE", GEUtil.CColor(220, 220, 220, 200))
token.SetSkin(0)
self.ft_teambalancebars()
self.ft_showteamflags()
def __init__(self):
super(CasinoRoyaleLTK, self).__init__()
weaponListLTK = [ Weapon("pp7", "PP7s", 50), Weapon("pp7_silenced", "Silenced PP7s", 50), Weapon("dd44", "DD44s", 50), Weapon("sniper_rifle", "Sniper Rifles", 75), Weapon("silver_pp7", "Silver PP7s", 25), Weapon("golden_pp7", "Golden PP7s", 10), Weapon("cmag", "Cougar Magnums", 25), Weapon("golden_gun", "Golden Guns", 10), Weapon("klobb", "Klobbs", 50), Weapon("shotgun", "Shotguns", 20), Weapon("grenade", "Grenades", 3), Weapon("knife_throwing", "Throwing Knives", 5), Weapon("moonraker", "Moonraker Lasers", 0), Weapon("knife", "Hunting Knives", 0) ]
self.weaponList = [weaponListLTK]
# Defines new variable that will track the current weapon, when created it's outside of the weaponlist length
self.weaponIndex = [-1, -1]
# Length of each weapon round
self.timerMax = 40 * 10
# Current weapon timer
self.weaponTimer = self.timerMax
# Creates player tracker
self.playerTracker = GEPlayerTracker( self )
# Defines a toggle that says if round is active or not
self.isRoundActive = False
# Next two keep track of how many kills that team has had during the current weapon round
self.roundScoreJanus = 0
self.roundScoreMI6 = 0
self.skipTextColor = GEUtil.CColor(232,180,2,240)
self.skipTextFadedColor = GEUtil.CColor(232,180,2,10)
self.timerBarColor = GEUtil.CColor(220,220,220,240)
self.skipMsgColor = GEUtil.CColor(232,180,2,230)
self.weaponMsgColor = GEUtil.CColor(220,220,220,240)
self.timerBarIndex = 0
self.skipTextIndex = 1
self.scoreDisplayChannel = 0
self.skipMSgChannel = 1
self.weaponMsgChannel = 2
self.skipTextYPos = 0.67
self.weaponMsgYPos = 0.71
self.winMsgJanus = "^rJanus ^1scored the most kills and ^ugot a point"
self.winMsgMI6 = "^iMI6 ^1scored the most kills and ^ugot a point"
self.winMsgTie = "^1Tie score! Both teams ^ugot a point"
def OnCaptureAreaEntered(self, area, player, token):
aUID = area.GetUID()
if aUID not in self.game_terminals or self.game_terminals[aUID]["hacked"]:
return
if player.GetUID() == self.hacker_playerUID:
time_hack = float(GEUtil.GetCVarValue("lc_hacktime"))
if self.timer_hacking.state is Timer.STATE_STOP or self.game_lastTerminalUID != area.GetUID():
GEUtil.InitHudProgressBar(None, 1, "Hack Progress:", 1, time_hack, -1, 0.75, 120, 15,
GEUtil.CColor(220, 220, 220, 240))
self.game_lastTerminalUID = aUID
self.game_currTerminalUID = aUID
self.timer_hacking.Start(time_hack)
def OnCaptureAreaEntered(self, area, player, token):
aUID = area.GetUID()
if not self.game_terminals.has_key(
aUID) or self.game_terminals[aUID]["hacked"]:
return
if player.GetUID() == self.hacker_playerUID:
if self.timer_hacking.state is Timer.STATE_STOP or self.game_lastTerminalUID != area.GetUID(
):
GEUtil.InitHudProgressBar(None, 1, "Hack Progress:", 1, 10.0,
-1, 0.75, 120, 15,
GEUtil.CColor(220, 220, 220, 240))
self.game_lastTerminalUID = aUID
self.game_currTerminalUID = aUID
self.timer_hacking.Start(10.0)
def OnTokenDropped(self, token, player):
player.SetScoreBoardColor(GEGlobal.SB_COLOR_NORMAL)
if self.ft_flagdebt() >= 0:
GEMPGameRules.GetRadar().AddRadarContact(token,
GEGlobal.RADAR_TYPE_TOKEN,
True, "", self.COLOR_WARM)
GEMPGameRules.GetRadar().SetupObjective(
token, GEGlobal.TEAM_NONE, "!%s" % self.TokenClass,
"#GES_GP_LD_OBJ_TAKE", GEUtil.CColor(220, 220, 220, 200))
GEMPGameRules.GetRadar().DropRadarContact(player)
self.ft_disassociate(token, False)
else:
GEMPGameRules.GetTokenMgr().RemoveTokenEnt(token)
self.ft_teambalancebars()
self.ft_showteamflags()
token.SetSkin(0)
def lc_EnrobeHacker(self, uid):
player = getPlayerFromUID(uid)
if player is not None:
model = self.MI6_HACKER_COSTUME
if player.GetTeamNumber() == Glb.TEAM_JANUS:
model = self.JANUS_HACKER_COSTUME
# Store away his old costume and set him as the hacker
self.hacker_oldCostume = player.GetPlayerModel()
self.hacker_oldSkin = player.GetSkin()
player.SetPlayerModel(model, 0)
# Add me to the radar as always visible
GERules.GetRadar().AddRadarContact(
player, Glb.RADAR_TYPE_PLAYER, True, "sprites/hud/radar/run",
GEUtil.CColor(255, 180, 225, 170))
# Reset notices
self.hacker_notice = 0
self.hacker_playerUID = uid
def __init__(self):
super(IAmInvincible, self).__init__()
self.playerTracker = GEPlayerTracker(self)
self.warmupTimer = GEWarmUp(self)
self.notice_WaitingForPlayers = 0
self.WaitingForPlayers = True
self.roundActive = False
self.currentBorisPlayer = False
self.costumeBoris = "boris"
self.soundError = "Buttons.beep_denied"
self.soundPoint = "GEGamePlay.Token_Chime"
self.soundSpeedBoost = "GEGamePlay.Whoosh"
self.radarIconShapeBoris = ""
self.radarIconColorBoris = GEUtil.Color(206, 43, 43, 255)
self.objectiveColorBoris = GEUtil.Color(206, 43, 43, 255)
self.objectiveTextBoris = "Boris"
self.messageChannel = 0
self.messageDisplayTime = 6.0
self.messageXPos = -1
self.messageYPos = 0.71
self.newBorisMessageColor = GEUtil.Color(206, 43, 43, 255)
self.newBorisMessageText = "You are now Boris. You are invincible!"
self.noBorisMessageColor = GEUtil.CColor(220, 220, 220, 255)
self.noBorisMessageText = "Boris abandoned the match!"
self.isBorisSpeedBoosted = False
self.speedBoostMultiplier = 1.25
self.timerBorisSpeedBoost = 0
self.timerBorisSpeedBoostMax = 30
self.breakpointDamage = 160 #Default max health/armor is 160/160
self.explosionDamageMultiplier = 0.5
self.borisSelfDamageMultiplier = 0.07
def OnThink(self):
# Enter "wait time" if we only have 1 player
if GERules.GetNumActivePlayers() < 2 and self.warmupTimer.HadWarmup():
# Check overtime fail safe
if self.game_inOvertime:
self.game_canFinishRound = True
# Restart the round and count the scores if we were previously not in wait time
if not self.game_inWaitTime:
GERules.EndRound()
self.game_inWaitTime = True
return
# Restart the round (not counting scores) if we were in wait time
if self.game_inWaitTime:
GEUtil.HudMessage(None, "#GES_GP_GETREADY", -1, -1,
GEUtil.CColor(255, 255, 255, 255), 2.5)
GERules.EndRound(False)
self.game_inWaitTime = False
def OnCVarChanged(self, name, oldvalue, newvalue):
if name == "cr_timer":
GEUtil.RemoveHudProgressBar(None, self.timerBarIndex)
self.timerMax = float(newvalue) * 10
if self.weaponTimer >= float(newvalue):
self.weaponTimer = float(newvalue)
self.showTimerBar(None)
if name == "cr_teamscoring" and GEMPGameRules.IsTeamplay():
if int(newvalue) == 0 and int(oldvalue) == 1:
GEMPGameRules.ResetAllTeamsScores()
self.resetRoundScore()
GEMPGameRules.EndRound(False)
GEUtil.HudMessage(None, "", 0.0, 0.0,
GEUtil.CColor(255, 255, 255, 255), 0,
self.scoreDisplayChannel)
elif float(newvalue) == 1 and float(oldvalue) == 0:
GEMPGameRules.ResetAllTeamsScores()
self.resetRoundScore()
GEMPGameRules.EndRound(False)
self.showRoundScore(None)
elif name == "cr_skip":
if int(GEUtil.GetCVarValue("cr_skip")) == 0:
for i in range(32):
if not GEPlayer.IsValidPlayerIndex(i):
continue
player = GEPlayer.GetMPPlayer(i)
GEUtil.RemoveHudProgressBar(player, self.skipTextIndex)
else:
for i in range(32):
if not GEPlayer.IsValidPlayerIndex(i):
continue
player = GEPlayer.GetMPPlayer(i)
self.playerTracker.SetValue(player, self.USED_SKIP, False)
self.showSkipText(player)
elif name == "ge_teamplay" and newvalue == 0:
self.hideRoundScore(None)
def showRoundScore(self, target):
GEUtil.HudMessage(
target, "^r" + str(self.roundScoreJanus) +
" ^w: ^c" + str(self.roundScoreMI6), -1, 0.0,
GEUtil.CColor(255, 255, 255,
255), float('inf'), self.scoreDisplayChannel)
def lc_CreateHackingTool(self):
# Only create the hacking tool if allowed
if GEUtil.GetCVarValue("lc_hackertool") == 1:
mgr = GERules.GetTokenMgr()
mgr.SetupToken(self.TOOL_CLASSNAME, limit=1, location=Glb.SPAWN_AMMO,
allow_switch=True, glow_color=GEUtil.CColor(80, 80, 80, 255), glow_dist=500.0)
class LaunchCode(GEScenario):
# ------------------ #
# GLOBAL CONSTANTS #
# ------------------ #
JANUS_HACKER_COSTUME = "boris"
MI6_HACKER_COSTUME = "female_scientist"
MIN_PLAYERS = 2
LOW_PLAYER_NOTICE_INTERVAL = 10.0
TOOL_CLASSNAME = "token_custom1"
TOOL_WMODEL = "models/weapons/tokens/w_keytoken.mdl"
TOOL_VMODEL = "models/weapons/tokens/v_keytoken.mdl"
COLOR_INFO = GEUtil.CColor(240, 200, 120, 170)
COLOR_NOTICE = GEUtil.CColor(240, 200, 120, 170)
COLOR_RADAR_MI6 = GEUtil.CColor(94, 171, 231, 255)
COLOR_RADAR_JANUS = GEUtil.CColor(206, 43, 43, 255)
TAG = "[LaunchCode]"
DEFAULT_PARAMS = {
# Hacker Variables
"hacker_notice": 0,
"hacker_playerUID": None,
"hacker_oldCostume": "",
"hacker_oldSkin": 0,
"hacker_switched": False,
"hacker_hasTool": False,
"hacker_hasWeapon": False,
# Game Variables
"game_startTime": GEUtil.GetTime(),
"game_hackersWin": False,
"game_tool": None,
"game_lastTerminalUID": None,
"game_currTerminalUID": None,
}
# ---------------- #
# CORE FUNCTIONS #
# ---------------- #
def __init__(self):
super(LaunchCode, self).__init__()
self.warmUpTimer = GEWarmUp(self)
self.timerTracker = TimerTracker(self)
self.__debug = False
# Defining some vars
self.game_terminals = {}
self.team_hacker = None
self.team_preventor = None
self.timer_endRound = None
self.timer_hacking = None
self.game_roundCount = 0
self.hacker_hasWeapon = False
self.hacker_canArm = True
self.game_lastTerminalUID = None
self.game_currTerminalUID = None
self.hacker_hasTool = False
self.game_lowPlayers = True
self.game_lowPlayersNotice = 0
self.game_terminal_model = "models/props/bunker/oldlaptop.mdl"
# Hacker Variables
self.hacker_notice = 0
self.hacker_playerUID = None
self.hacker_oldCostume = ""
self.hacker_oldSkin = 0
self.hacker_switched = False
self.hacker_hasTool = False
self.hacker_hasWeapon = False
# Game Variables
self.game_startTime = GEUtil.GetTime()
self.game_hackersWin = False
self.game_lastTerminalUID = None
self.game_currTerminalUID = None
self.game_tool = None
def Cleanup(self):
super(LaunchCode, self).Cleanup()
self.timer_endRound = None
self.timer_hacking = None
self.warmUpTimer = None
self.timerTracker = None
def GetPrintName(self):
return "Launch Code"
def GetScenarioHelp(self, help_obj):
pass
def GetGameDescription(self):
return "Launch Code"
def GetTeamPlay(self):
return Glb.TEAMPLAY_ALWAYS
def OnLoadGamePlay(self):
# Precache our custom items
GEUtil.PrecacheModel(self.game_terminal_model)
# Clear the timer list
self.timerTracker.RemoveTimer()
# Create the hacking timer
self.timer_hacking = self.timerTracker.CreateTimer("hack")
self.timer_hacking.SetAgeRate(0.75, 2.0)
self.timer_hacking.SetUpdateCallback(self.lc_OnHackTimer)
# Delay of End Round timer
self.timer_endRound = self.timerTracker.CreateTimer("endround")
self.timer_endRound.SetUpdateCallback(self.lc_OnEndRoundTimer)
# Setup all our vars
self.lc_InitRound()
# Reset the some vars
self.game_terminals = {}
self.team_hacker = None
self.team_preventor = None
self.game_roundCount = 0
# Enable team spawns
GERules.SetAllowTeamSpawns(True)
# Exclude hacker costumes
GERules.SetExcludedCharacters("female_scientist, boris")
GERules.GetTokenMgr().SetupCaptureArea("terminals", model=self.game_terminal_model,
limit=4, radius=32, location=Glb.SPAWN_PLAYER)
self.CreateCVar("lc_warmup", "30", "Warmup time before the match begins")
self.CreateCVar("lc_hackerboost", "0", "Allow the hacker to gain an ego-boost")
self.CreateCVar("lc_hackertool", "1", "Allow the Insta-Hack tool")
self.CreateCVar("lc_hacktime", "15", "Base number of seconds to hack a terminal")
self.CreateCVar("lc_hackerdefense", "1", "Allows the hacker to have a DD44 to protect themselves")
self.CreateCVar("lc_debug", "0", "Enabled/Disables debugging prompts")
def OnRoundBegin(self):
self.__debug = GEUtil.GetCVarValue("lc_debug") == 1
if self.__debug:
GEUtil.ClientPrint(None, Glb.HUD_PRINTTALK, self.TAG + "Debugging Enabled")
else:
GEUtil.ClientPrint(None, Glb.HUD_PRINTTALK, self.TAG + "Debugging Disabled")
GERules.GetRadar().SetForceRadar(True)
GERules.ResetAllPlayersScores()
self.hacker_canArm = GEUtil.GetCVarValue("lc_hackerdefense") == 1
self.game_roundCount += 1
self.lc_DerobeHacker()
self.lc_InitRound()
self.lc_ChooseHacker()
self.lc_CreateHackingTool()
def OnRoundEnd(self):
GERules.GetRadar().DropAllContacts()
if self.lc_HavePlayers() and not self.game_hackersWin:
pTeam = GERules.GetTeam(self.team_preventor)
GERules.SetTeamWinner(pTeam)
for t in self.game_terminals.values():
if not t["hacked"]:
pTeam.IncrementRoundScore(1)
def OnPlayerSpawn(self, player):
# Properly arm the hacker
if self.hacker_playerUID == player.GetUID():
if self.hacker_canArm:
self.lc_ArmHacker(player) # Give the hacker back their weapon on respawn
if self.hacker_notice < 3:
self.hacker_notice += 1
GEUtil.HudMessage(player, "You are the hacker, hack the terminals by standing next to them", -1, -1,
self.COLOR_NOTICE, 5.0, 2)
def OnPlayerKilled(self, victim, killer, weapon):
if victim is None:
return
if victim.GetUID() == self.hacker_playerUID:
self.hacker_hasWeapon = False
if self.team_preventor:
GERules.GetTeam(self.team_preventor).IncrementRoundScore(1)
if killer and victim != killer:
killer.IncrementScore(1)
else:
victim.IncrementScore(-1)
def OnCaptureAreaSpawned(self, area):
aUID = area.GetUID()
self.game_terminals[aUID] = {"hacked": False}
GERules.GetRadar().AddRadarContact(area, Glb.RADAR_TYPE_TOKEN, True, "sprites/hud/radar/capture_point",
self.lc_GetHackerTeamColor())
def OnCaptureAreaRemoved(self, area):
aUID = area.GetUID()
if aUID in self.game_terminals:
del self.game_terminals[aUID]
GERules.GetRadar().DropRadarContact(area)
def OnCaptureAreaEntered(self, area, player, token):
aUID = area.GetUID()
if aUID not in self.game_terminals or self.game_terminals[aUID]["hacked"]:
return
if player.GetUID() == self.hacker_playerUID:
time_hack = float(GEUtil.GetCVarValue("lc_hacktime"))
if self.timer_hacking.state is Timer.STATE_STOP or self.game_lastTerminalUID != area.GetUID():
GEUtil.InitHudProgressBar(None, 1, "Hack Progress:", 1, time_hack, -1, 0.75, 120, 15,
GEUtil.CColor(220, 220, 220, 240))
self.game_lastTerminalUID = aUID
self.game_currTerminalUID = aUID
self.timer_hacking.Start(time_hack)
def OnCaptureAreaExited(self, area, player):
if player.GetUID() == self.hacker_playerUID:
self.timer_hacking.Pause()
self.game_currTerminalUID = None
def CanPlayerChangeChar(self, player, ident):
if player is None:
return False
if ident == self.JANUS_HACKER_COSTUME or ident == self.MI6_HACKER_COSTUME:
GEUtil.HudMessage(player, "You cannot impersonate the hacker!", -1, 0.1, self.COLOR_INFO, 2.0)
return False
elif player.GetUID() == self.hacker_playerUID:
if self.lc_CanHackerSwitch():
self.lc_ChooseHacker()
return True
else:
GEUtil.HudMessage(player, "You cannot switch from the hacker!", -1, 0.1, self.COLOR_INFO, 2.0)
return False
return True
def CanPlayerHaveItem(self, player, item):
name = item.GetClassname()
if player.GetUID() == self.hacker_playerUID:
# The hacker can only pickup armor
if name.startswith("item_armorvest"):
return True
elif name == "weapon_slappers" or name == self.TOOL_CLASSNAME:
return True
elif name == "weapon_dd44" and self.hacker_canArm:
return True
return False
else:
if name == self.TOOL_CLASSNAME:
return False
return True
def OnTokenSpawned(self, token):
GERules.GetRadar().AddRadarContact(token, Glb.RADAR_TYPE_TOKEN, True)
def OnTokenRemoved(self, token):
GERules.GetRadar().DropRadarContact(token)
def OnTokenPicked(self, token, player):
self.hacker_hasTool = True
GEUtil.PlaySoundTo(player, "GEGamePlay.Token_Grab")
GEUtil.ClientPrint(None, Glb.HUD_PRINTTALK, self.TAG + " The hacker picked up the Insta-Hack")
GEUtil.HudMessage(self.team_hacker, "The hacker has the Insta-Hack, protect them at all costs!", -1, 0.65,
self.COLOR_NOTICE, 4.0, 1)
GEUtil.HudMessage(self.team_preventor, "Warning! The hacker has the Insta-Hack!!", -1, 0.65, self.COLOR_NOTICE,
4.0, 1)
GEUtil.PlaySoundTo(self.team_hacker, "GEGamePlay.Token_Grab")
GEUtil.PlaySoundTo(self.team_preventor, "GEGamePlay.Token_Grab_Enemy")
GERules.GetRadar().DropRadarContact(token)
def OnTokenDropped(self, token, player):
self.hacker_hasTool = False
GEUtil.ClientPrint(None, Glb.HUD_PRINTTALK, self.TAG + " The Insta-Hack has been destroyed")
GEUtil.HudMessage(None, "The Insta-Hack has been destroyed!", -1, 0.65, self.COLOR_NOTICE, 4.0, 1)
GEUtil.PlaySoundTo(None, "GEGamePlay.Token_Drop_Friend")
GERules.GetTokenMgr().RemoveTokenType(self.TOOL_CLASSNAME)
def OnThink(self):
if self.game_lowPlayers:
if self.lc_HavePlayers():
# We have enough players, start the warmup period
self.warmUpTimer.StartWarmup(float(GEUtil.GetCVarValue("lc_warmup")))
self.game_lowPlayers = False
self.lc_DerobeHacker()
elif GEUtil.GetTime() >= self.game_lowPlayersNotice:
# Notify anyone in the serve that we don't have enough players
GEUtil.HudMessage(None, "Not enough players, please wait...", -1, -1, self.COLOR_NOTICE,
self.LOW_PLAYER_NOTICE_INTERVAL / 4.0)
self.game_lowPlayersNotice = GEUtil.GetTime() + self.LOW_PLAYER_NOTICE_INTERVAL
elif not self.lc_HavePlayers():
# Put us back into low player state
self.warmUpTimer.Reset()
self.game_lowPlayers = True
self.game_lowPlayersNotice = 0
self.lc_DerobeHacker()
def CanPlayerChangeTeam(self, player, oldteam, newteam, wasforced):
# The hacker cannot change teams
if player.GetUID() == self.hacker_playerUID:
GEUtil.HudMessage(player, "You cannot change teams as the hacker!", -1, -1,
GEUtil.CColor(255, 255, 255, 255), 3.0)
return False
return True
def OnPlayerDisconnect(self, player):
# If the hacker disconnects we must choose a new one
if player.GetUID() == self.hacker_playerUID:
self.hacker_hasWeapon = False
self.hacker_hasTool = False
self.lc_ChooseHacker(True)
def OnPlayerSay(self, player, text):
if text == "!voodoo":
if player.GetUID() == self.hacker_playerUID and self.hacker_hasTool and self.game_currTerminalUID:
self.lc_OnHackCompleted()
self.timer_hacking.Stop()
GERules.GetTokenMgr().RemoveTokenType(self.TOOL_CLASSNAME)
return True
return False
# ------------------ #
# CUSTOM FUNCTIONS #
# ------------------ #
def lc_InitRound(self):
# Hacker Variables
self.hacker_notice = 0
self.hacker_playerUID = None
self.hacker_oldCostume = ""
self.hacker_oldSkin = 0
self.hacker_switched = False
self.hacker_hasTool = False
self.hacker_hasWeapon = False
# Game Variables
self.game_startTime = GEUtil.GetTime()
self.game_hackersWin = False
self.game_lastTerminalUID = None
self.game_currTerminalUID = None
self.game_tool = None
# Reset Timers
self.timerTracker.ResetTimer()
# Check for low player counts
self.game_lowPlayersNotice = 0
if not self.lc_HavePlayers():
self.game_lowPlayers = True
else:
self.game_lowPlayers = False
# Setup Teams
if self.team_hacker:
# Swap the teams
tmp = self.team_hacker
self.team_hacker = self.team_preventor
self.team_preventor = tmp
else:
# First time? Pick a random team
self.team_hacker = random.choice([Glb.TEAM_MI6, Glb.TEAM_JANUS])
if self.team_hacker == Glb.TEAM_JANUS:
self.team_preventor = Glb.TEAM_MI6
else:
self.team_preventor = Glb.TEAM_JANUS
def lc_ChooseHacker(self, force=False):
if not self.team_hacker:
self.lc_ErrorShout("Hacker assignment attempted before team chosen!")
return
# Enumerate the number of eligible players
players = self.lc_ListPlayers(self.team_hacker, self.hacker_playerUID)
self.lc_DerobeHacker()
if self.hacker_playerUID:
if len(players) > 1 and (force or self.lc_CanHackerSwitch()):
self.lc_DebugShout("Hacker being switched")
self.lc_EnrobeHacker(random.choice(players))
self.hacker_switched = True
elif len(players) > 0:
self.lc_DebugShout("New hacker being selected")
self.lc_EnrobeHacker(random.choice(players))
self.hacker_switched = False
def lc_CanHackerSwitch(self):
timeIn = GEUtil.GetTime() - self.game_startTime;
plrCount = GERules.GetNumActiveTeamPlayers(self.team_hacker)
if self.hacker_playerUID and plrCount > 1 and not self.hacker_switched and timeIn < 15.0:
return True
return False
def lc_CreateHackingTool(self):
# Only create the hacking tool if allowed
if GEUtil.GetCVarValue("lc_hackertool") == 1:
mgr = GERules.GetTokenMgr()
mgr.SetupToken(self.TOOL_CLASSNAME, limit=1, location=Glb.SPAWN_AMMO,
allow_switch=True, glow_color=GEUtil.CColor(80, 80, 80, 255), glow_dist=500.0)
def lc_EnrobeHacker(self, uid):
player = GEPlayer.ToMPPlayer(uid)
if player is not None:
model = self.MI6_HACKER_COSTUME
if player.GetTeamNumber() == Glb.TEAM_JANUS:
model = self.JANUS_HACKER_COSTUME
# Store away his old costume and set him as the hacker
self.hacker_oldCostume = player.GetPlayerModel()
self.hacker_oldSkin = player.GetSkin()
player.SetPlayerModel(model, 0)
# Add me to the radar as always visible
GERules.GetRadar().AddRadarContact(player, Glb.RADAR_TYPE_PLAYER, True, "sprites/hud/radar/run",
GEUtil.CColor(255, 180, 225, 170))
# Reset notices
self.hacker_notice = 0
self.hacker_playerUID = uid
if self.hacker_canArm:
self.lc_ArmHacker(player)
def lc_DerobeHacker(self):
player = getPlayerFromUID(self.hacker_playerUID)
if player is not None:
# Revert back to the old costume
player.SetPlayerModel(self.hacker_oldCostume, self.hacker_oldSkin)
player.StripAllWeapons()
player.GiveDefaultWeapons()
GERules.GetRadar().DropRadarContact(player)
self.hacker_hasWeapon = False
self.hacker_hasTool = False
self.hacker_playerUID = None
def lc_ArmHacker(self, player):
if player is not None:
player.StripAllWeapons()
player.GiveNamedWeapon("weapon_slappers", 0)
player.GiveNamedWeapon("weapon_dd44", 14) # DD44 starts w/ 10 bullets: 8|16
player.SetArmor(int(Glb.GE_MAX_ARMOR))
def lc_OnHackTimer(self, timer, update_type):
assert isinstance(timer, Timer)
if update_type is Timer.UPDATE_FINISH:
# Complete the hack
self.lc_OnHackCompleted()
elif update_type is Timer.UPDATE_STOP:
GEUtil.RemoveHudProgressBar(None, 1)
# Reset the terminal usage since we abandoned our current effort
self.game_lastTerminalUID = self.game_currTerminalUID = None
elif update_type is Timer.UPDATE_RUN:
GEUtil.UpdateHudProgressBar(None, 1, timer.GetCurrentTime())
def lc_OnHackCompleted(self):
GERules.GetTeam(self.team_hacker).IncrementRoundScore(1)
GERules.GetRadar().DropRadarContact(GEEntity.GetEntByUID(self.game_lastTerminalUID))
GEUtil.PlaySoundTo(self.team_hacker, "GEGameplay.Token_Capture_Friend", True)
GEUtil.PlaySoundTo(self.team_preventor, "GEGamePlay.Token_Capture_Enemy", True)
GEUtil.HudMessage(None, "The hacker has taken over a terminal!", -1, -1, self.COLOR_NOTICE, 2.0, 2)
self.game_terminals[self.game_lastTerminalUID]["hacked"] = True
self.game_lastTerminalUID = self.game_currTerminalUID = None
self.lc_CheckHackerWin()
def lc_OnEndRoundTimer(self, timer, update_type):
if update_type is Timer.UPDATE_FINISH:
GERules.EndRound()
def lc_CheckHackerWin(self):
for t in self.game_terminals.values():
if not t["hacked"]:
return
# If we made it here, hackers won! End the round
self.game_hackersWin = True
hTeam = GERules.GetTeam(self.team_hacker)
GERules.SetTeamWinner(hTeam)
hTeam.IncrementRoundScore(len(self.game_terminals))
# End the round in 3 seconds (this should be a variable in EndRound(...))
self.timer_endRound.Start(3.0)
def lc_GetHackerTeamColor(self):
if self.team_hacker == Glb.TEAM_MI6:
return self.COLOR_RADAR_MI6
else:
return self.COLOR_RADAR_JANUS
def lc_ListPlayers(self, team, ignore=None, npcs=False):
list = []
for j in range(32):
if GEPlayer.IsValidPlayerIndex(j):
player = GEPlayer.GetMPPlayer(j)
if player.GetTeamNumber() == team and player.GetUID() != ignore:
# Favor humans over NPCs
if not npcs and player.IsNPC():
continue
list.append(player.GetUID())
if len(list) == 0: # No humans on hacker team, regrab list without stripping NPCs
self.lc_ListPlayers(team, ignore, True)
return list
def lc_HavePlayers(self):
if GERules.GetNumActivePlayers() >= self.MIN_PLAYERS:
return True
return False
def lc_DebugShout(self, msg):
if self.__debug:
GEUtil.Msg(self.TAG + msg + "\n")
def lc_ErrorShout(self, msg):
if self.__debug:
GEUtil.Warning(self.TAG + msg + "\n")
def hideRoundScore(self, target):
GEUtil.HudMessage(target, "", -1, 0.0,
GEUtil.CColor(255, 255, 255,
255), 0, self.scoreDisplayChannel)
class LivingDaylights(GEScenario):
BAR_CARRY = 100
BAR_ESCAPE = 100
BAR_TEAMBALANCE = 50
BAR_CAP_X = 0.3
COLOR_COLD = GEUtil.CColor(30, 150, 180, 170)
COLOR_HOLD = GEUtil.CColor(255, 180, 225, 170)
COLOR_H_MI = GEUtil.CColor(180, 225, 255, 170)
COLOR_H_JS = GEUtil.CColor(255, 225, 180, 170)
COLOR_P_JS = GEUtil.CColor(255, 180, 180, 170)
COLOR_WARM = GEUtil.CColor(180, 150, 30, 170)
COLOR_CASH = GEUtil.CColor(240, 225, 45, 170)
COLOR_MI6 = GEUtil.CColor(94, 171, 231, 255)
COLOR_JS = GEUtil.CColor(206, 43, 43, 255)
PERK_ADREN = 0.3
PERK_SPEED = 0.025
THEFT_DELTA = 1
# Flag information management
FLAGLIST_LIMIT = 16
FLAGLIST_MAXID = FLAGLIST_LIMIT - 1
flaglist = [LivingDaylightsFlag() for j in range(FLAGLIST_LIMIT)]
def ft_ageflag(self, flagindex, ticks):
if self.flaglist[flagindex].age(ticks, True):
self.ft_creditcarrier(self.flaglist[flagindex])
# Flag Tag functions
def ft_ageflags(self):
for j in range(self.FLAGLIST_LIMIT):
flag = self.flaglist[j]
if flag.exp_to_escape > -1:
self.ft_perk_speed(j)
if flag.age_escape(1):
self.ft_creditescape(flag)
if flag.age(1, True):
self.ft_creditcarrier(flag, 1)
self.ft_perk_speed(j)
if flag.armor_up > -1:
self.ft_escapee_armorapply(flag)
def ft_announceearning(self, flag, frags):
player = ep_player_by_id(flag.player_id)
GEUtil.PlaySoundTo(player, "GEGamePlay.Token_Chime")
self.ft_progressbar(flag, ep_player_by_id(flag.player_id))
def ft_announceescaping(self, flag):
player = ep_player_by_id(flag.player_id)
GEUtil.HudMessage(
player, _(plural(flag.escapes, "#GES_GP_LD_ESCAPED"),
flag.escapes), -1, -1, EP_SHOUT_COLOR, 2.0)
GEUtil.PlaySoundTo(player, "Buttons.beep_ok")
ep_shout("Escaped successfully.")
def ft_associate(self, token, player):
flagindex = self.ft_flagindexbytoken(token)
if (flagindex >= 0):
self.flaglist[flagindex].player_id = GEEntity.GetUID(player)
else:
ep_shout(
"[ft_associate] Token %d does not have associated information."
% (GEEntity.GetUID(token)))
return flagindex
def ft_coldflaglevel(self, index):
if (index >= 0):
self.flaglist[index].level_by_playercount(
GEMPGameRules.GetNumActivePlayers())
def ft_creditcarrier(self, flag, frags):
player = ep_player_by_id(flag.player_id)
ep_incrementscore(player, frags)
self.ft_announceearning(flag, frags)
GEUtil.EmitGameplayEvent("ld_flagpoint", str(player.GetUserID()), "-1",
"timer", str(frags))
def ft_creditescape(self, flag):
player = ep_player_by_id(flag.player_id)
ep_incrementscore(player, flag.escapes)
self.ft_escapee_armorup(flag, player)
self.ft_announceescaping(flag)
self.ft_escapebar_remove(flag)
GEUtil.EmitGameplayEvent("ld_flagpoint", str(player.GetUserID()), "-1",
"escape", str(flag.escapes))
def ft_disassociate(self, token, respawned):
flagindex = self.ft_flagindexbytoken(token)
if (flagindex >= 0):
flag = self.flaglist[flagindex]
self.ft_progressbar_remove(flag)
self.ft_escapebar_remove(flag)
if respawned:
flag.zot()
else:
flag.release()
else:
ep_shout("[Disassociate] Token %d was unregistered when dropped.")
return flagindex
def ft_escapebar(self, flag, player):
GEUtil.InitHudProgressBar(player, 1, "%d " % (flag.escapes + 1),
GEGlobal.HUDPB_SHOWBAR, flag.ESCAPE_TIME, -1,
.72, self.BAR_ESCAPE, 10, self.COLOR_WARM)
def ft_escapebar_remove(self, flag):
GEUtil.RemoveHudProgressBar(ep_player_by_id(flag.player_id), 1)
def ft_escapee_armorapply(self, flag):
ep_player_by_id(flag.player_id).SetArmor(flag.armor_up)
flag.armor_up = -1
def ft_escapee_armorup(self, flag, player):
flag.armor_up = clamp(int(player.GetArmor() + flag.escape_ap), 0,
GEGlobal.GE_MAX_ARMOR)
flag.escape_ap = 0
def ft_flagdebt(self):
return self.ft_flagsdesired() - self.ft_flagsregistered()
def ft_flagindexbytoken(self, token):
uid = GEEntity.GetUID(token)
rtn_j = -1
for j in range(self.FLAGLIST_LIMIT):
if (self.flaglist[j].token_id == uid):
rtn_j = j
break
return rtn_j
def ft_flagindexbyplayer(self, player):
uid = GEEntity.GetUID(player)
rtn_j = -1
for j in range(self.FLAGLIST_LIMIT):
if (self.flaglist[j].player_id == uid):
rtn_j = j
break
return rtn_j
def ft_flagindexbyplayerprevious(self, player):
uid = GEEntity.GetUID(player)
rtn_j = -1
for j in range(self.FLAGLIST_LIMIT):
if (self.flaglist[j].player_previous == uid):
rtn_j = j
break
return rtn_j
def ft_flaglist_openslot(self):
rtn_index = -1
for j in range(self.FLAGLIST_LIMIT):
if self.flaglist[j].token_id == 0:
rtn_index = j
break
return rtn_index
def ft_flagsdesired(self):
if GEMPGameRules.IsTeamplay():
fd = min(
min(
GEMPGameRules.GetTeam(GEGlobal.TEAM_MI6).GetNumPlayers(),
GEMPGameRules.GetTeam(
GEGlobal.TEAM_JANUS).GetNumPlayers()),
self.FLAGLIST_LIMIT)
fd = clamp(
fd, 1,
fd - max(0, int(GEUtil.GetCVarValue("ld_teamguardians"))))
else:
playersperflag = max(1,
int(GEUtil.GetCVarValue("ld_playersperflag")))
fd = min(
int((GEMPGameRules.GetNumActivePlayers() + playersperflag - 1)
/ playersperflag), self.FLAGLIST_LIMIT)
return fd
def ft_flagsregistered(self):
flagsregistered = 0
for j in range(self.FLAGLIST_LIMIT):
if self.flaglist[j].token_id != 0:
flagsregistered += 1
return flagsregistered
def ft_gameislive(self):
return GEMPGameRules.GetNumActivePlayers() > 1 or FT_DEBUG
def ft_omnomnomnom(self, player, itemname):
flagindex = self.ft_flagindexbyplayer(player)
if flagindex >= 0:
quality = -1
if itemname.startswith("item_armorvest_half"):
quality = 2
elif itemname.startswith("item_armorvest"):
quality = 3
elif itemname.startswith("weapon_"):
quality = 1
elif itemname.startswith("ge_ammo"):
quality = 0
if quality >= 0:
if self.ft_gameislive():
self.flaglist[flagindex].age_item(quality, 1.0)
# ep_shout("Consumed %s for %d EXP." % (itemname, self.flaglist[flagindex].BONUS_ITEM[quality]))
return True
def ft_perk_speed(self, flagindex):
if flagindex >= 0 and self.flaglist[flagindex].i_am_held():
flag = self.flaglist[flagindex]
player = ep_player_by_id(flag.player_id)
perk = (1.0 + (float(GEMPGameRules.GetNumActivePlayers()) +
(float(flag.adrenaline) * self.PERK_ADREN)) *
self.PERK_SPEED)**0.5
ep_shout("[Perk Speed] %f" % perk)
player.SetSpeedMultiplier(
min(perk, choice(GEMPGameRules.IsTeamplay(), 1.20, 1.35)))
def ft_playercarries(self, player):
return self.ft_flagindexbyplayer(player) != -1
def ft_progressbar(self, flag, player):
GEUtil.InitHudProgressBar(player, 0, "%d " % flag.earnings,
GEGlobal.HUDPB_SHOWBAR,
flag.exp_this_level(flag.level), -1, .76,
self.BAR_CARRY, 10, self.COLOR_H_MI)
def ft_progressbar_remove(self, flag):
GEUtil.RemoveHudProgressBar(ep_player_by_id(flag.player_id), 0)
def ft_progressbars(self):
for j in range(self.FLAGLIST_LIMIT):
flag = self.flaglist[j]
if flag.player_id != 0:
GEUtil.UpdateHudProgressBar(ep_player_by_id(flag.player_id), 0,
flag.exp_to_next)
if flag.exp_to_escape > -1:
GEUtil.UpdateHudProgressBar(ep_player_by_id(flag.player_id), 1,
flag.exp_to_escape)
def ft_progressbars_legacy(self):
for j in range(self.FLAGLIST_LIMIT):
flag = self.flaglist[j]
if flag.player_id != 0:
step = 4.0
text_lifespan = 0.2
scale = 1.0 / step
width = scale * flag.exp_this_level(flag.level)
fill = scale * flag.exp_to_next
exp_bar = ""
for jj in range(1, int(width), 1):
if jj < fill:
exp_bar = "-%s" % exp_bar
else:
exp_bar = "!%s" % exp_bar
exp_bar = "[%s] %d" % (exp_bar, flag.earnings)
GEUtil.HudMessage(ep_player_by_id(flag.player_id), exp_bar, -1,
.75, EP_SHOUT_COLOR, text_lifespan)
def ft_registerflag(self, newflag_id):
newflag_index = self.ft_flaglist_openslot()
if (newflag_index > -1):
self.flaglist[newflag_index].zot()
self.flaglist[newflag_index].token_id = newflag_id
else:
ep_shout(
"[Register Flag] Failed to find an information slot. (CRITICAL)"
)
return newflag_index
def ft_shepherd(self):
if self.ft_flagdebt() > 0:
GEMPGameRules.GetTokenMgr().SetupToken(
self.TokenClass, limit=self.ft_flagsdesired())
def ft_showteamflags(self, player=None):
if GEMPGameRules.IsTeamplay():
if player is None:
if self.ShowMI6Flags:
GEUtil.HudMessage(
GEGlobal.TEAM_MI6,
_("#GES_GP_LD_TEAMHOLDS", self.MI6Flags,
self.FlagCount), -1, 0.65, self.COLOR_MI6, 5.0, 1)
if self.ShowJanusFlags:
GEUtil.HudMessage(
GEGlobal.TEAM_JANUS,
_("#GES_GP_LD_TEAMHOLDS", self.JanusFlags,
self.FlagCount), -1, 0.65, self.COLOR_JS, 5.0, 1)
self.ShowMI6Flags = self.ShowJanusFlags = False
else:
if player.GetTeamNumber() == GEGlobal.TEAM_MI6:
GEUtil.HudMessage(
player,
_("#GES_GP_LD_TEAMHOLDS", self.MI6Flags,
self.FlagCount), -1, 0.65, self.COLOR_MI6, 5.0, 1)
else:
GEUtil.HudMessage(
player,
_("#GES_GP_LD_TEAMHOLDS", self.JanusFlags,
self.FlagCount), -1, 0.65, self.COLOR_JS, 5.0, 1)
def ft_teambalancebars(self):
if GEMPGameRules.IsTeamplay():
mi_flags = 0
js_flags = 0
barwidth = 0
for j in range(self.FLAGLIST_LIMIT):
if self.flaglist[j].token_id != 0:
barwidth += 1
thisflagteam = self.flaglist[j].my_team()
if thisflagteam == GEGlobal.TEAM_MI6:
mi_flags += 1
if thisflagteam == GEGlobal.TEAM_JANUS:
js_flags += 1
# Store out values before adding micro t
if self.MI6Flags != mi_flags or barwidth != self.FlagCount:
self.ShowMI6Flags = True
if self.JanusFlags != js_flags or barwidth != self.FlagCount:
self.ShowJanusFlags = True
self.MI6Flags = mi_flags
self.JanusFlags = js_flags
self.FlagCount = barwidth
microt = barwidth * 0.05
barwidth += microt
mi_flags += microt
js_flags += microt
GEUtil.InitHudProgressBar(None, 2, "", GEGlobal.HUDPB_SHOWBAR,
barwidth, .1875, .920,
self.BAR_TEAMBALANCE, 10,
self.COLOR_H_MI)
GEUtil.InitHudProgressBar(None, 3, "", GEGlobal.HUDPB_SHOWBAR,
barwidth, .1875, .905,
self.BAR_TEAMBALANCE, 10,
self.COLOR_P_JS)
GEUtil.UpdateHudProgressBar(None, 2, mi_flags)
GEUtil.UpdateHudProgressBar(None, 3, js_flags)
else:
GEUtil.RemoveHudProgressBar(None, 2)
GEUtil.RemoveHudProgressBar(None, 3)
def ft_zot(self):
GEMPGameRules.GetTokenMgr().SetupToken(self.TokenClass, limit=0)
for j in range(self.FLAGLIST_LIMIT):
self.flaglist[j].zot()
def ft_zot_token(self, token):
j = self.ft_flagindexbytoken(token)
if j >= 0:
self.flaglist[j].zot()
else:
ep_shout("[Zot Token] Attempted to remove unregistered token %d" %
GEEntity.GetUID(token))
# Engine callbacks
def __init__(self):
super(LivingDaylights, self).__init__()
self.TokenClass = 'token_deathmatch'
self.TokenGlow = GEUtil.CColor(244, 192, 11, 64)
self.MI6Flags = 0
self.JanusFlags = 0
self.FlagCount = 0
self.ShowMI6Flags = True
self.ShowJanusFlags = True
def GetGameDescription(self):
if GEMPGameRules.IsTeamplay():
return "Team Living Daylights"
return "Living Daylights"
def GetPrintName(self):
return "#GES_GP_LD_NAME"
def GetScenarioHelp(self, help_obj):
assert isinstance(help_obj, GEScenarioHelp)
help_obj.SetInfo("#GES_GPH_LD_TAGLINE",
"http://wiki.geshl2.com/index.php/Living_Daylights")
help_obj.SetDescription("#GES_GP_LD_HELP")
pane = help_obj.AddPane("ld")
help_obj.AddHelp(pane, "ld_earnpoints1", "")
help_obj.AddHelp(pane, "ld_earnpoints2", "#GES_GPH_LD_FLAG_POINTS")
def GetTeamPlay(self):
return GEGlobal.TEAMPLAY_TOGGLE
def OnThink(self):
if self.ft_gameislive():
self.ft_ageflags()
self.ft_progressbars()
def OnPlayerKilled(self, victim, killer, weapon):
if victim == None:
return
# Disconnecting player_previous to prevent multiple penalties.
flagindex = self.ft_flagindexbyplayer(victim)
if flagindex >= 0:
self.flaglist[flagindex].player_previous = 0
GEUtil.EmitGameplayEvent("ld_flagdropped", str(victim.GetUserID()),
str(killer.GetUserID()))
vid = GEEntity.GetUID(victim)
kid = GEEntity.GetUID(killer)
ep_shout("[OPK] Victim %d, Killer %d, VFlag Index %d" %
(vid, kid, flagindex))
bounty = min(self.flaglist[flagindex].earnings,
self.flaglist[flagindex].LEVEL_LIMIT)
# Suicide
if killer == None or killer.GetIndex(
) == 0 or vid == kid or GEMPGameRules.IsTeamplay(
) and victim.GetTeamNumber() == killer.GetTeamNumber():
suicide_bounty = -choice(flagindex >= 0, bounty + bounty, 1)
ep_incrementscore(victim, suicide_bounty)
if flagindex >= 0:
GEUtil.EmitGameplayEvent("ld_flagpoint",
str(victim.GetUserID()), "-1",
"suicide", str(suicide_bounty))
return
# slap and snatch TODO: Verify
if weapon != None and weapon.GetClassname(
) == "weapon_slappers" and flagindex >= 0:
delta = choice(flagindex >= 0, bounty, 0)
if delta > 0:
ep_incrementscore(victim, -delta)
GEUtil.HudMessage(
victim, _(plural(delta, "#GES_GP_LD_LOSEPOINTS"), delta),
-1, -1, EP_SHOUT_COLOR, 2.0)
ep_incrementscore(killer, delta)
GEUtil.HudMessage(
killer, _(plural(delta, "#GES_GP_LD_STOLEPOINTS"), delta),
-1, -1, EP_SHOUT_COLOR, 2.0)
GEUtil.EmitGameplayEvent("ld_flagpoint",
str(victim.GetUserID()),
str(killer.GetUserID()),
"slapperkill", str(-delta))
# credit if token will be removed from play. TODO: Verify
if self.ft_flagdebt() < 0:
if flagindex >= 0:
ep_incrementscore(killer, self.flaglist[flagindex].level)
else:
ep_shout(
"[OPK] No flag index associated with slain carrier whose flag is removed."
)
def OnPlayerSay(self, player, text):
return False
def OnLoadGamePlay(self):
self.CreateCVar("ld_playersperflag", "4",
"Number of players per flag spawned.")
self.CreateCVar(
"ld_teamguardians", "0",
"Flags are withheld to ensure this many players must guard on the shortest team. One flag will always be available."
)
tokenmgr = GEMPGameRules.GetTokenMgr()
tokenmgr.SetupToken(
self.TokenClass,
limit=1,
location=GEGlobal.SPAWN_TOKEN,
allow_switch=False,
glow_color=self.TokenGlow,
respawn_delay=30.0,
print_name="#GES_GP_LD_OBJ",
view_model="models/weapons/tokens/v_flagtoken.mdl",
world_model="models/weapons/tokens/w_flagtoken.mdl")
GEMPGameRules.GetRadar().SetForceRadar(True)
GEUtil.PrecacheSound("GEGamePlay.Token_Chime")
GEUtil.PrecacheSound("GEGamePlay.Token_Knock")
GEUtil.PrecacheSound("GEGamePlay.Token_Grab")
GEUtil.PrecacheSound("Buttons.beep_ok")
GEUtil.PrecacheSound("Buttons.beep_denied")
def OnRoundBegin(self):
self.ft_zot()
GEMPGameRules.ResetAllPlayersScores()
def OnRoundEnd(self):
GEMPGameRules.GetRadar().DropAllContacts()
def OnPlayerSpawn(self, player):
assert isinstance(player, GEPlayer.CGEMPPlayer)
player.SetSpeedMultiplier(1.0)
player.SetScoreBoardColor(GEGlobal.SB_COLOR_NORMAL)
player.SetMaxArmor(int(GEGlobal.GE_MAX_ARMOR))
player.GiveNamedWeapon("weapon_slappers", 0)
self.ft_shepherd()
self.ft_teambalancebars()
self.ft_showteamflags(player)
def CanPlayerChangeTeam(self, player, oldteam, newteam):
# If we switched from DM to Team (or vice versa) or Spectating, reset help
if oldteam == GEGlobal.TEAM_SPECTATOR \
or oldteam == GEGlobal.TEAM_NONE and newteam >= GEGlobal.TEAM_MI6 \
or oldteam >= GEGlobal.TEAM_MI6 and newteam == GEGlobal.TEAM_NONE:
# Reset this players help archive so they don't recall old help
player.SetInitialSpawn(True)
return True
def CanPlayerHaveItem(self, player, item):
# itemname = entity.GetClassname()
return self.ft_omnomnomnom(player, item.GetClassname())
# return not (itemname.startswith("item_armorvest") and self.ft_flagindexbyplayer(player) >= 0)
def ShouldForcePickup(self, player, item):
if self.ft_playercarries(player):
GEUtil.PlaySoundTo(player, "HL2Player.PickupWeapon")
return True
return False
def CalculateCustomDamage(self, victim, info, health, armour):
assert isinstance(victim, GEPlayer.CGEMPPlayer)
if victim == None:
return health, armour
killer = GEPlayer.ToMPPlayer(info.GetAttacker())
v_flagindex = self.ft_flagindexbyplayer(victim)
k_flagindex = self.ft_flagindexbyplayer(killer)
# ep_shout("[SDCD] %d %d" % (v_flagindex, k_flagindex) )
if v_flagindex >= 0:
# Suicide or friendly fire exacerbates but does not trigger escape.
total_damage = health + armour
if killer == None or GEEntity.GetUID(victim) == GEEntity.GetUID(
killer) or GEMPGameRules.IsTeamplay(
) and victim.GetTeamNumber() == killer.GetTeamNumber():
self.flaglist[v_flagindex].escape(False, total_damage)
else:
self.flaglist[v_flagindex].escape(True, total_damage)
self.ft_escapebar(self.flaglist[v_flagindex], victim)
if k_flagindex >= 0:
# Flag carrier steals a point on successful attack.
if victim.GetRoundScore() > 0:
ep_incrementscore(victim, -self.THEFT_DELTA)
ep_incrementscore(killer, self.THEFT_DELTA)
GEUtil.PlaySoundTo(killer, "Buttons.beep_ok")
GEUtil.PlaySoundTo(victim, "Buttons.Token_Knock")
ep_shout("Point stolen from %s via slap." %
victim.GetPlayerName())
GEUtil.EmitGameplayEvent("ld_flagpoint",
str(killer.GetUserID()),
str(victim.GetUserID()), "flaghit",
"1")
return health, armour
def CalcFinalScores(self):
pass
def OnTokenSpawned(self, token):
self.ft_registerflag(GEEntity.GetUID(token))
GEMPGameRules.GetRadar().AddRadarContact(token,
GEGlobal.RADAR_TYPE_TOKEN,
True, "", self.COLOR_COLD)
GEMPGameRules.GetRadar().SetupObjective(
token, GEGlobal.TEAM_NONE, "!%s" % self.TokenClass,
"#GES_GP_LD_OBJ_TAKE", GEUtil.CColor(220, 220, 220, 200))
token.SetSkin(0)
self.ft_teambalancebars()
self.ft_showteamflags()
def OnTokenPicked(self, token, player):
player.SetScoreBoardColor(GEGlobal.SB_COLOR_WHITE)
GEMPGameRules.GetRadar().DropRadarContact(token)
GEMPGameRules.GetRadar().AddRadarContact(
player, GEGlobal.RADAR_TYPE_PLAYER, True, "sprites/hud/radar/run",
choice(
GEMPGameRules.IsTeamplay(),
choice(player.GetTeamNumber() == GEGlobal.TEAM_MI6,
self.COLOR_H_MI, self.COLOR_H_JS), self.COLOR_HOLD))
GEUtil.PlaySoundTo(player, "GEGamePlay.Token_Grab")
GEUtil.EmitGameplayEvent("ld_flagpickup", str(player.GetUserID()))
flagindex = self.ft_flagindexbytoken(token)
if GEMPGameRules.IsTeamplay() and flagindex >= 0 and self.flaglist[
flagindex].team_previous == player.GetTeamNumber():
self.ft_associate(token, player)
else:
self.ft_coldflaglevel(self.ft_associate(token, player))
# Support team colors!
if GEMPGameRules.IsTeamplay():
if player.GetTeamNumber() == GEGlobal.TEAM_MI6:
skin = 1
color = self.COLOR_MI6
else:
skin = 2
color = self.COLOR_JS
token.SetSkin(skin)
GEMPGameRules.GetRadar().SetupObjective(player, GEGlobal.TEAM_NONE,
"!%s" % self.TokenClass,
"", color)
else:
GEMPGameRules.GetRadar().SetupObjective(player, GEGlobal.TEAM_NONE,
"!%s" % self.TokenClass,
"", self.COLOR_HOLD)
health_coefficient = 2.0 * float(player.GetHealth() + player.GetArmor(
)) / float(player.GetMaxHealth() + player.GetMaxArmor())
player.SetHealth(int(GEGlobal.GE_MAX_HEALTH))
player.SetArmor(int(GEGlobal.GE_MAX_ARMOR))
# Suppress Armor pickup
player.SetMaxArmor(0)
self.flaglist[self.ft_flagindexbytoken(token)].age_item(
3, health_coefficient)
self.ft_teambalancebars()
self.ft_showteamflags()
def OnTokenDropped(self, token, player):
player.SetScoreBoardColor(GEGlobal.SB_COLOR_NORMAL)
if self.ft_flagdebt() >= 0:
GEMPGameRules.GetRadar().AddRadarContact(token,
GEGlobal.RADAR_TYPE_TOKEN,
True, "", self.COLOR_WARM)
GEMPGameRules.GetRadar().SetupObjective(
token, GEGlobal.TEAM_NONE, "!%s" % self.TokenClass,
"#GES_GP_LD_OBJ_TAKE", GEUtil.CColor(220, 220, 220, 200))
GEMPGameRules.GetRadar().DropRadarContact(player)
self.ft_disassociate(token, False)
else:
GEMPGameRules.GetTokenMgr().RemoveTokenEnt(token)
self.ft_teambalancebars()
self.ft_showteamflags()
token.SetSkin(0)
def OnTokenRemoved(self, token):
self.ft_disassociate(token, True)
GEMPGameRules.GetRadar().DropRadarContact(token)
GEMPGameRules.GetRadar().DropRadarContact(token.GetOwner())
self.ft_teambalancebars()
self.ft_showteamflags()
#
# GoldenEye: Source's Python Library is distributed in the hope that it will
# be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
# Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GoldenEye: Source's Python Library.
# If not, see <http://www.gnu.org/licenses/>.
#############################################################################
from . import GEScenario, GEScenarioHelp
from Utils import plural, clamp, choice, _
import GEEntity, GEPlayer, GEUtil, GEMPGameRules, GEGlobal
USING_API = GEGlobal.API_VERSION_1_1_1
EP_SHOUT_COLOR = GEUtil.CColor(240, 200, 120, 170)
FT_DEBUG = False
def ep_incrementscore(player, frags):
GEMPGameRules.GetTeam(player.GetTeamNumber()).AddRoundScore(frags)
player.AddRoundScore(frags)
return player
def ep_naturalsubtraction(value, delta):
if value > delta:
return value - delta
return 0
def __init__(self):
super(Uplink, self).__init__()
self.warmupTimer = GEWarmUp(self)
self.notice_WaitingForPlayers = 0
self.WaitingForPlayers = True
self.roundActive = False
# >> Uplink data >>
self.areaDictionary = {
} # Holds each Uplink's data (as a class object)
self.fixDictionary = {
} # Holds player information before an Uplink is added to self.areaDictionary (e.g. an Uplink spawning on a player)
# >> Uplink names >>
self.uplinkNames = [] # List of unused Uplink names
# >> Uplink variables >>
self.pointRadius = 255.0 # Sets radius of each Uplink
self.pointSeperation = 5 * self.pointRadius # Sets minimum distance between Uplink points (changes with map size, see OnLoadGamePlay)
self.uplinkTimerMax = None # Sets amount of time to make an Uplink (changes depending on teamplay setting)
self.uplinkTimerMaxSolo = 145 # Sets amount of time to make an Uplink in free-for-all mode
self.uplinkTimerMaxTeam = 165 # Sets amount of time to make an Uplink in teamplay
self.pointTimerMax = 150 # Sets amount of time between each point being awarded
self.areaTotal = 3 # Sets the number of Uplinks to spawn
self.skinNeutral = 0
self.skinJanus = 2
self.skinMI6 = 1
self.uplinkReward = 2
self.uplinkRewardSoloPoints = 3
self.uplinkRewardSoloHP = 0.25
# >> Ping effect variables >>
self.pingTimerMax = 12 # Sets how long between each "ping" effect on Uplinks
self.pingTimer = self.pingTimerMax + 1 # Keeps track of how long since last "ping" effect on Uplinks
# >> Color variables >>
self.colorNeutral = GEUtil.CColor(255, 255, 255, 255)
self.colorNeutralPing = GEUtil.CColor(255, 255, 255, 100)
self.colorMI6 = GEUtil.CColor(0, 150, 255, 255)
self.colorMI6Ping = GEUtil.CColor(0, 150, 255, 100)
self.colorJanus = GEUtil.CColor(255, 0, 0, 255)
self.colorJanusPing = GEUtil.CColor(255, 0, 0, 100)
# >> Objective color variables
self.colorMI6_Hot = GEUtil.Color(94, 171, 231, 235)
self.colorMI6_Cold = GEUtil.Color(94, 171, 231, 120)
self.colorJanus_Hot = GEUtil.Color(206, 43, 43, 235)
self.colorJanus_Cold = GEUtil.Color(206, 43, 43, 120)
self.colorNeutral_Hot = GEUtil.Color(231, 231, 231, 235)
self.colorNeutral_Cold = GEUtil.Color(231, 231, 231, 120)
# >> Message & Progress Bar colors >>
self.colorMsg = GEUtil.CColor(220, 220, 220, 240)
self.colorMsgContested = GEUtil.CColor(255, 210, 210, 185)
self.colorBarStandard = GEUtil.CColor(
220, 220, 220,
240) # Color of progress bar when player is completing an Uplink
# >> Killticker Message colors >>
self.colorKilltickerJanus = "^r"
self.colorKilltickerMI6 = "^i"
self.colorKilltickerDefault = "^1"
self.colorKilltickerNoTeam = "^1"
# >> Scoreboard color variables >>
self.scoreboardDefault = GEGlobal.SB_COLOR_NORMAL
self.scoreboardOnPoint = GEGlobal.SB_COLOR_WHITE
# >> Round Score Display Colors >>
self.colorOwnershipJanus = "^r" # Since Janus' score displays first, we don't add spaces
self.colorOwnershipMI6 = "^c" # Since MI6's score displays last, we add spaces...
self.colorOwnershipNeutral = " ^w: " # ...same for Neutral score, which is the second to display
# >> Message & Progress Bar information >>
self.barIndex = 0
self.barTitle = "Uplink" # Displays as the title of the progress bar when a player is capturing an Uplink
self.completeMsg = "Uplink Established!" # Displays when a player finishes an Uplink
self.ownedMsg = "Your team controls this Uplink" # Displays when a player steps on an Uplink their team already owns
self.contestedMsg = "Error: Uplink Blocked!" # Displays when a player is making an Uplink and an opposing player enters the Uplink
self.capturedPrintMsg = "^u established an Uplink" # Displays in killticker when team make an Uplink
self.capturedPrintMsgAnd = " ^1and " # Displays before final player who helped complete an Uplink
self.printMI6 = "MI6"
self.printJanus = "Janus"
self.helpMsg = "MI6 and Janus fight for control of key military satellites. Capture and control Uplinks while preventing your opponents from doing the same!\n\nEnter an Uplink to initiate capture and earn points. Team-controlled Uplinks generate points over time.\n\nTeamplay: Toggleable\n\nCreated by Euphonic"
# >> Uplink Distribution display >>
self.distColorJanus = GEUtil.CColor(255, 0, 0, 255)
self.distColorMI6 = GEUtil.CColor(0, 0, 255, 255)
self.distColorNeutral = GEUtil.CColor(255, 255, 255, 255)
# along with GoldenEye: Source's Python Library.
# If not, see <http://www.gnu.org/licenses/>.
#############################################################################
import GEUtil, GEMPGameRules as GERules, GEGlobal as Glb
from GEGlobal import EventHooks
# These are in seconds
PREROUND_END_DELAY = 3.5
NOTICE_INTERVAL_LONG = 15.0
NOTICE_INTERVAL_SHORT = 10.0
NOTICE_INTERVAL_TINY = 0.9
CHAN_TIMER = 4
COLOR_TIMER = GEUtil.CColor(255, 255, 255, 255)
COLOR_GETREADY = GEUtil.CColor(255, 255, 255)
class GEWarmUp:
def __init__(self, parent):
if not hasattr(parent, 'RegisterEventHook'):
raise AttributeError("Parent must be a Gameplay Scenario type!")
parent.RegisterEventHook(EventHooks.GP_THINK, self._think)
parent.RegisterEventHook(EventHooks.GP_PLAYERCONNECT,
self._player_connect)
self.keep_weaponset = False
self.Reset()
