Print

Add to Reputation:  

What do you think of this post?

I agree I disagree  
Comment:

[Wake[of]theBunT]

Those are badass Kraid! Love how we get a custom game-mode with high quality models that really integrate well. Should make the mode stand out that much more. =)

[kraid]

I'd really like to add some text to it, but i'm not good in finding the right words for it.
Should be something that expresses how disapointed the janus group is about your failture or how mi6 honors your suffering.

Also i'd like to make them a little more differing e.g. make the Janus one old and withered with cracks and dirt on it while the mi6 one remains nice and polished.
Maybe even with a different model shape that has some evil vibe.

But than again this might be a little bit to much for the purpose of a gameplay object.
Rather keeping it simple.

BTW: Is there allready a possibility to see which player can be resurrected on that point, displaying the name of the player or something?

[Joe]

Beta 1.02 may not be released until tomorrow because I've drastically altered its resurrection timer code and I want to make sure the changes haven't created new bugs.

This mode's script now uses a ResurrectionTimer class to handle resurrection timers.

BTW: Is there already a possibility to see which player can be resurrected on that point, displaying the name of the player or something?

Unlike in MOHAA Freeze Tag, resurrection entities aren't associated with eliminated players. Instead each side has a resurrection queue and when a side's RE is used the player who has been in their queue for the longest time is resurrected.

I chose to implement resurrections in this way because I think it's a better way of resurrecting players. With this way of doing it, players have a better idea of when they will be resurrected and no player will have a long wait to be resurrected because the RE associated with them isn't used.

If anyone disagrees with me, then please post a message.

[killermonkey]

Queued resurrections are the best way, for the reasons stated.

Joe, I added in the ability to set an entities' position in Python (players and held weapons will ignore the command for obvious reasons). This will be in the next patch to GE:S.

I am also adding the ability to use the color codes in HUD Messages. So instead of 1 color for HUD messages, you can have many colors. Just slip the code into the mix just like in the localization files.

[Rick Astley]

Thanks for making these great looking gravestones,  I will include them in the beta 1.02 release.

I will try to make a gravestone radar icon.

fantastic work Kraid i love the emblems

[Joe]

There is now a screenshot from Beta 1.02 in this topic's first post.

Joe, I added in the ability to set an entities' position in Python (players and held weapons will ignore the command for obvious reasons). This will be in the next patch to GE:S.

Thanks, when this patch is released I will use this new ability to make resurrection entities appear at player death locations instead of player spawn points.

[WNxEuphonic]

There is now a screenshot from Beta 1.02 in this topic's first post.

Thanks, when this patch is released I will use this new ability to make resurrection entities appear at player death locations instead of player spawn points.

I've been thinking about this, and you should spawn them at player death points only when the player is killed by another player or themselves, not when it's an environmental death -- that way you prevent them spawning at the bottom of pits. You still will have the issue of players killed mid-air (like falling from Cradle and getting shot on the way down), but it's an improvement.

[Troy]

Yea, imagine a floating tombstone lol.

[Joe]

I'm sorry I still haven't released Beta 1.02, it still has bugs which need to be fixed.

I've been thinking about this, and you should spawn them at player death points only when the player is killed by another player or themselves, not when it's an environmental death -- that way you prevent them spawning at the bottom of pits.

Thanks for the help, I will do this.

The Crash Bug
Does anyone know why telling the token manager to delete a capture area in the Beta 1.02 script's OnCaptureAreaSpawned() function is making GE:S regularly crash?

This bug will crash GE:S every 4-10 minutes on the Silo map with 31 bots.

Code: [Select]

def OnCaptureAreaSpawned( self, area ):
        areasID = area.GetGroupName()
        areasTeam = area.GetTeamNumber()
        location = area.GetAbsOrigin() 
            
        #TODO remove when REs are moved to player death locations:
        #Don't allow a MI6 and Janus RE to be located at the same player spawn point.
        if areasTeam == GEGlobal.TEAM_MI6 and location in self.jAreaLocations.values() or areasTeam == GEGlobal.TEAM_JANUS and location in self.mAreaLocations.values():
            self.respawnResurrectionEntity(areasID,areasTeam) #Recursive Function Call Loop
            return
        
        if location in self.mAreaLocations.values() or location in self.jAreaLocations.values():
            GEUtil.Msg("------- Same Team RE Location Overlap -------")
            #Deleting the area in this callback function makes GE:S regularly crash:
            self.tokenManager.RemoveCaptureArea(areasID)

            if area.GetTeamNumber() == GEGlobal.TEAM_MI6: self.mAreaIDs.remove(areasID)
            else: self.jAreaIDs.remove(areasID)
            
            areaIDAssociatedWithLocation = self.getREAreaIDAssociatedWithLocation(location,areasTeam)
            if not self.multiResurrectionRE.has_key(areaIDAssociatedWithLocation): self.multiResurrectionRE[areaIDAssociatedWithLocation] = 1
            
            self.multiResurrectionRE[areaIDAssociatedWithLocation] += 1
        
        else:
            colour = self.getSidesColour(areasTeam)
            
            if areasTeam == GEGlobal.TEAM_MI6: self.mAreaLocations[areasID] = location
            else: self.jAreaLocations[areasID] = location
                    
            self.radar.AddRadarContact(area,GEGlobal.RADAR_TYPE_OBJECTIVE,True,self.RERadarIcon,colour)
            self.radar.SetupObjective(area,areasTeam,"", "",colour,self.REObjectiveIconFadeOutDistance, False)

#TODO remove when REs are moved to player death locations
def getREAreaIDAssociatedWithLocation(self,location,side):
            sidesAreaLocations = None
            if side == GEGlobal.TEAM_MI6: sidesAreaLocations = self.mAreaLocations
            else: sidesAreaLocations = self.jAreaLocations
        
            for areaID in sidesAreaLocations.keys():
                if sidesAreaLocations[areaID] == location: return areaID

Crash Bug Demo Script

Code: [Select]

from . import GEScenario
from GamePlay.Utils.GEPlayerTracker import GEPlayerTracker
from Utils.GETimer import TimerTracker, Timer
from collections import defaultdict

import GEPlayer, GEUtil, GEMPGameRules, GEGlobal

USING_API = GEGlobal.API_VERSION_1_0_0

'''
This mode is based on Mefy's MOHAA Freeze Tag Mode.

I chose to implement this mode by editing the "You Only Live Twice" mode script. So
this script uses lots of code that was created by the author(s) of the YOLT script.

I've also reused code from the "Capture The Key" mode's script.

The gravestones were created by Kraid.

The up and down arrows in the crucifix RE icon were taken from the run icons.

@author: Joe
@version: Crash Bug Demo
'''

class DieAnotherDay( GEScenario ):
    ResurrectionTime = 5.0
    CompletedResPBRemovalDelay = 1.0
    
    MREModel = "models/gameplay/gravestone.mdl"
    JREModel = "models/gameplay/gravestone.mdl"
    
    MRESkin = 0
    JRESkin = 1
    
    RERadarIcon = "sprites/hud/radar/RE"
    
    REObjectiveIconFadeOutDistance = 200
    
    COLOR_MI6_RADAR = GEUtil.Color( 94, 171, 231, 255 )
    COLOR_JANUS_RADAR = GEUtil.Color( 206, 43, 43, 255 )
    
    JBountyFontColour = GEUtil.CColor( 206, 43, 43, 255 )
    MBountyFontColour = GEUtil.CColor( 100, 184, 234, 220 )
    
    #Progress bar positions
    MBountyPBX = 0.315
    MBountyPBY = 0.03
    
    JBountyPBX = 0.515
    JBountyPBY = 0.03
    
    ResurrectionPBX = -1
    ResurrectionPBY = 0.6
    #-------------------------
    
    TR_ELIMINATED = "eliminated"
    TR_SPAWNED = "spawned"
    
    TOKEN_MI6 = 'token_mi6'
    TOKEN_JANUS = 'token_janus'
    
    #Progress Bar Indexs
    MBountyPBIndex = 0
    JBountyPBIndex = 1
    ResurrectionPBIndex = 2

    def __init__( self ):
        super( DieAnotherDay, self ).__init__()
        
        self.radar = None
        
        self.eliminateNewPlayers = False

        self.waitingForPlayers = False
        self.mBounty = 0
        self.jBounty = 0
        self.pltracker = GEPlayerTracker( self )
        
        self.bountiesInitialised = False
        
        self.mBountyMaxPlayers = 0
        self.jBountyMaxPlayers = 0
        
        self.timerTracker = TimerTracker( self )
        self.tokenManager = GEMPGameRules.GetTokenMgr()
        
        #Eliminated player collections
        self.mResurrectionQueue = []
        self.jResurrectionQueue = []
        
        #Collections related to resurrection area entities
        self.mAreaIDs = []
        self.jAreaIDs = []
        
        self.mAreaLocations = {}
        self.jAreaLocations = {}
        
        self.REResTimers = defaultdict(list)
        
        #TODO remove when REs are moved from spawn points to player death locations:
        self.multiResurrectionRE = {}
        
        #Needed because deleting a RE in onCaptureAreaSpawned makes GE:S regularly crash.
        #Emptied in onCaptureAreaEntered.
        #self.REBin = []
        
    def OnLoadGamePlay( self ):
        GEUtil.PrecacheModel( self.MREModel )
        GEUtil.PrecacheModel( self.JREModel )
        
        self.radar = GEMPGameRules.GetRadar()

    def Cleanup( self ):
        super( DieAnotherDay, self ).Cleanup()
        self.pltracker = None

    def GetPrintName( self ):
        return "Die Another Day"

    def GetScenarioHelp( self, help_obj ):
        #TODO use UI Language Files: 
        help_obj.SetDescription( 
                                 """-- Version: Crash Bug Demo --
Eliminate your opponents.

To resurrect a team mate: stand next 
to one of your team's gravestones.
---------- Credits ---------
Based on Mefy's MOHAA Freeze Tag Mode. 
Kraid created the gravestones.
                                 """)
        
    def GetGameDescription( self ):
        return "Die Another Day"

    def OnPlayerConnect( self, player ):
        self.pltracker.SetValue( player, self.TR_SPAWNED, False )

    def OnPlayerDisconnect( self, player ):
        team = player.GetTeamNumber()
        
        if team != GEGlobal.TEAM_SPECTATOR:
            self.decrementTeamsPlayerCount(team)
            
            if self.isEliminatedPlayer(player): 
                self.deleteNotInUseResurrectionEntityFromTeam(team)
                self.removePlayerFromTeamsRQueue(player,team)
            else: self.decreaseTeamBounty(team)
            
            if self.bountiesInitialised: self.updateTeamsDisplayedMaxPlayers(team)
                
    def isEliminatedPlayer(self,player):
        return self.pltracker.GetValue(player,self.TR_ELIMINATED)
    
    #------------------------------- 
    def CanPlayerChangeTeam(self,player,oldTeam,newTeam ):
        if oldTeam == GEGlobal.TEAM_NONE: return True
        elif oldTeam == GEGlobal.TEAM_SPECTATOR and player.IsInitialSpawn(): self.newPlayerWantsToJoinTeam(player,newTeam)
        elif oldTeam == GEGlobal.TEAM_SPECTATOR: self.spectatorWantsToJoinTeam(player,newTeam)
        elif oldTeam != GEGlobal.TEAM_SPECTATOR and newTeam != GEGlobal.TEAM_SPECTATOR: self.playerWantsToChangeTheirTeam(player,oldTeam,newTeam)
        elif newTeam == GEGlobal.TEAM_SPECTATOR: 
            if self.isEliminatedPlayer(player): self.eliminatedPlayerWantsToBecomeSpectator(player,oldTeam)
            else: self.playerWantsToBecomeSpectator(player,oldTeam)
        
        return True

    def newPlayerWantsToJoinTeam(self,player,newTeam):
        self.incrementTeamsPlayerCount(newTeam)
        
        if self.eliminateNewPlayers:
            #TODO use language files
            GEUtil.PopupMessage(player, "You Can't Spawn Yet","New players won't spawn until a team mate spawns them, this prevents resurrection rejoins.")
            self.eliminatePlayer(player)
            self.spawnNewResurrectionEntity(player,newTeam)
            self.addPlayerToResurrectionQueue(player,newTeam)
            if self.playerNotBot(player): self.tellPlayerWhatTheirResurrectionQueuePositionIs(player,newTeam)
            
        else: self.increaseTeamBounty(newTeam)
        
        if self.bountiesInitialised: self.updateTeamsDisplayedMaxPlayers(newTeam)
    
    def playerWantsToChangeTheirTeam(self,player,oldTeam,newTeam):
        self.decrementTeamsPlayerCount(oldTeam)
        self.incrementTeamsPlayerCount(newTeam)
        
        if self.isEliminatedPlayer(player): 
            #Old team
            self.deleteNotInUseResurrectionEntityFromTeam(oldTeam)
            self.removePlayerFromTeamsRQueue(player,oldTeam)
            self.resurrectionQueueUpdateNotify(oldTeam)
            
            #New Team
            self.spawnNewResurrectionEntity(player,newTeam)
            self.addPlayerToResurrectionQueue(player,newTeam)
            if self.playerNotBot(player): self.tellPlayerWhatTheirResurrectionQueuePositionIs(player,newTeam)
            
        else:
            self.decreaseTeamBounty(oldTeam)
            self.increaseTeamBounty(newTeam)
            
        if self.bountiesInitialised: 
            self.updateTeamsDisplayedMaxPlayers(oldTeam)
            self.updateTeamsDisplayedMaxPlayers(newTeam)
            
    def eliminatedPlayerWantsToBecomeSpectator(self,player,oldTeam):
        self.decrementTeamsPlayerCount(oldTeam)
        
        self.deleteNotInUseResurrectionEntityFromTeam(oldTeam)
        self.removePlayerFromTeamsRQueue(player,oldTeam)
        self.resurrectionQueueUpdateNotify(oldTeam)
        
        #Prevent GE:S spectator view bug from being triggered (this bug will be fixed in the next patch):
        self.resurrectPlayer(player)
        player.ForceRespawn()
        self.eliminatePlayer(player) #Doesn't kill them but does set eliminated? attribute to true.
        
        if self.bountiesInitialised: self.updateTeamsDisplayedMaxPlayers(oldTeam)
    
    def playerWantsToBecomeSpectator(self,player,oldTeam):
        self.decrementTeamsPlayerCount(oldTeam)
        self.decreaseTeamBounty(oldTeam)
        
        if self.bountiesInitialised: self.updateTeamsDisplayedMaxPlayers(oldTeam)
    
    def spectatorWantsToJoinTeam(self,player,newTeam):
        self.incrementTeamsPlayerCount(newTeam)
        
        if self.isEliminatedPlayer(player): 
            #TODO use language files
            GEUtil.PopupMessage(player, "You Can't Spawn Yet","You won't spawn until a team mate spawns you because you were eliminated before you became a spectator.")
            self.spawnNewResurrectionEntity(player,newTeam)
            self.addPlayerToResurrectionQueue(player,newTeam)
            if self.playerNotBot(player): self.tellPlayerWhatTheirResurrectionQueuePositionIs(player,newTeam)
            
        else: self.increaseTeamBounty(newTeam)
        
        if self.bountiesInitialised: self.updateTeamsDisplayedMaxPlayers(newTeam)
        
    #-------------------------------    
    def incrementTeamsPlayerCount(self,team):
        if team == GEGlobal.TEAM_MI6: self.mBountyMaxPlayers += 1
        else: self.jBountyMaxPlayers += 1
        
    def decrementTeamsPlayerCount(self,team):
        if team == GEGlobal.TEAM_MI6: self.mBountyMaxPlayers -= 1
        else: self.jBountyMaxPlayers -= 1
    
    def deleteNotInUseResurrectionEntityFromTeam(self,team):
        teamsResurrectionAreaIDs = None
        if team == GEGlobal.TEAM_MI6: teamsResurrectionAreaIDs = self.mAreaIDs
        else: teamsResurrectionAreaIDs = self.jAreaIDs
        
        for areaID in teamsResurrectionAreaIDs:
            if not self.areaInUse(areaID):
                self.deleteResurrectionArea(areaID,team)
                break
            
    def areaInUse(self,areaID):
        return len(self.REResTimers[areaID]) > 0
    
    def deleteResurrectionArea(self,areasID,areasTeam):
        if self.multiResurrectionRE.has_key(areasID): del self.multiResurrectionRE[areasID]
        
        if areasTeam == GEGlobal.TEAM_MI6: 
            self.mAreaIDs.remove(areasID)
            del self.mAreaLocations[areasID]
        else: 
            self.jAreaIDs.remove(areasID)
            del self.jAreaLocations[areasID]
            
        del self.REResTimers[areasID]
        self.tokenManager.RemoveCaptureArea(areasID)
        
    def eliminatePlayer(self,player):
        self.pltracker.SetValue(player,self.TR_ELIMINATED,True)
        
    def announceElimination(self,victim,killer):
        #Emit "Player Eliminated" event
        GEUtil.EmitGameplayEvent( "DieAnotherDay_eliminated", "%i" % victim.GetUserID(), "%i" % killer.GetUserID())
        
        #Tell the other players that a player has been eliminated #TODO use UI Language Files
        GEUtil.ClientPrint(None,GEGlobal.HUD_PRINTTALK, "A " + self.getTeamString(victim.GetTeamNumber()) + " player has been eliminated.") 
        
    def getTeamString(self,teamNumber):
        if(teamNumber == GEGlobal.TEAM_MI6): return "MI6"
        elif(teamNumber == GEGlobal.TEAM_JANUS): return "Janus"    
        else: return "Spectator"
        
    def addPlayerToResurrectionQueue(self,player,team):
        if team == GEGlobal.TEAM_MI6: self.mResurrectionQueue.append(player)
        else: self.jResurrectionQueue.append(player)
        
    def removePlayerFromTeamsRQueue(self,player,team):
        if team == GEGlobal.TEAM_MI6: self.mResurrectionQueue.remove(player)
        else: self.jResurrectionQueue.remove(player)
            
    def spawnNewResurrectionEntity(self,victim,team):
        #Create a new resurrection area id
        newAreasID = str(victim.GetUserID())
        
        #Spawn a new resurrection area
        self.spawnResurrectionEntity(newAreasID,team)
        
        #Create entries for the new area in resurrection entity collections
        if team == GEGlobal.TEAM_MI6: self.mAreaIDs.append(newAreasID)
        else: self.jAreaIDs.append(newAreasID)
        
        #Added to radar in CaptureAreaSpawned()
    
    def respawnResurrectionEntity(self,areaID,team):
        self.tokenManager.RemoveCaptureArea(areaID)
        self.spawnResurrectionEntity(areaID,team)
        
    def spawnResurrectionEntity(self,areaID,team):
        #Get Model Name
        modelName = None
        skinNumber = None
        
        if team == GEGlobal.TEAM_MI6: 
            modelName = self.MREModel
            skinNumber = self.MRESkin
        else: 
            modelName = self.JREModel
            skinNumber = self.JRESkin
        
        #Spawn resurrection entity
        self.tokenManager.SetupCaptureArea(areaID, 
                                   model=modelName,
                                   skin=skinNumber,
                                   limit=1, location=GEGlobal.SPAWN_PLAYER,
                                   rqd_team=team)

    def OnPlayerSpawn(self,player):
        if player.GetTeamNumber() != GEGlobal.TEAM_SPECTATOR: self.pltracker.SetValue(player,self.TR_SPAWNED,True)  
            
        #TODO Use UI Language Files
        if player.IsInitialSpawn(): GEUtil.PopupMessage( player, "Die Another Day", "Eliminate your opponents and resurrect your eliminated team mates." )

    def OnRoundBegin( self ):
        self.mBounty = 0 
        self.jBounty = 0
        
        if not self.waitingForPlayers:
            for i in range( 32 ):
                if not GEPlayer.IsValidPlayerIndex( i ):
                    continue
                self.pltracker.SetValue( GEPlayer.GetMPPlayer( i ), self.TR_ELIMINATED, False )
    
            GEMPGameRules.ResetAllPlayerDeaths()
            GEMPGameRules.ResetAllPlayersScores()

    def OnRoundEnd( self ):
        GEUtil.Msg("One Round End----")
        self.eliminateNewPlayers = False
        self.radar.DropAllContacts()
        self.timerTracker.RemoveTimer(None) #Stop all timers
        
        #Remove all progress bars
        self.bountiesInitialised = False
        
        GEUtil.RemoveHudProgressBar( None,self.MBountyPBIndex) 
        GEUtil.RemoveHudProgressBar( None,self.JBountyPBIndex) 
        GEUtil.RemoveHudProgressBar( None,self.ResurrectionPBIndex)
        
        #Empty resurrection queues
        del self.mResurrectionQueue[:]
        del self.jResurrectionQueue[:]
        
        self.deleteAllCaptureAreasAndTheirCollections()

    def deleteAllCaptureAreasAndTheirCollections(self):
        for areaID in self.mAreaIDs: self.tokenManager.RemoveCaptureArea(areaID)
        for areaID in self.jAreaIDs: self.tokenManager.RemoveCaptureArea(areaID)
        
        del self.mAreaIDs[:]
        del self.jAreaIDs[:]
        
        self.mAreaLocations.clear()
        self.jAreaLocations.clear()
        
        self.REResTimers.clear()

    def OnPlayerKilled( self, victim, killer, weapon ):
        super( DieAnotherDay, self ).OnPlayerKilled( victim, killer, weapon )
        self.InitializePlayerBounty() #if not initialised already
        
        victimsTeam = victim.GetTeamNumber()
        
        #Don't allow players to accidentally/intentionally eliminate their team mates
        if killer.GetTeamNumber()!= victimsTeam: 
            self.eliminatePlayer(victim)
            self.announceElimination(victim,killer)
            
            self.decreaseTeamBounty(victimsTeam)
         
            #Get the survivor count for the victim's team.
            teamsSurvivors = 0
            if victimsTeam == GEGlobal.TEAM_MI6: teamsSurvivors = self.mBounty
            else: teamsSurvivors = self.jBounty
            
            #If the victim was the last player alive on their team then don't create a resurrection area because
            #the game will be ended by OnThink() when this function has finished.
            if teamsSurvivors > 0:
                self.eliminateNewPlayers = True
                self.spawnNewResurrectionEntity(victim,victimsTeam)
                self.addPlayerToResurrectionQueue(victim,victimsTeam)
                
                if self.playerNotBot(victim):
                    self.tellPlayerWhatTheirResurrectionQueuePositionIs(victim)
                
            elif teamsSurvivors < 0: GEUtil.Msg("ERROR:OnPlayerKilled():teamsSurvivors < 0: = " + str(teamsSurvivors))

    def OnCaptureAreaSpawned( self, area ):
        areasID = area.GetGroupName()
        areasTeam = area.GetTeamNumber()
        location = area.GetAbsOrigin() 
            
        #TODO remove when REs are moved to player death locations:
        #Don't allow a MI6 and Janus RE to be located at the same player spawn point.
        if areasTeam == GEGlobal.TEAM_MI6 and location in self.jAreaLocations.values() or areasTeam == GEGlobal.TEAM_JANUS and location in self.mAreaLocations.values():
            self.respawnResurrectionEntity(areasID,areasTeam) #Recursive Function Call Loop
            return
        
        #TODO modify the following statements when REs are moved to player death locations:
        #Deal with the situation of 2 or more RE from the same side being located at the same spawn point (the resurrection function
        #is also responsible for dealing with this situation):
        if location in self.mAreaLocations.values() or location in self.jAreaLocations.values():
            GEUtil.Msg("------- Same Team RE Location Overlap -------")
            #Deleting the area in this callback function makes GE:S regularly crash, on Silo when it has 31 bots.
	    #(it will crash once every 4 - 10 minutes)
            self.tokenManager.RemoveCaptureArea(areasID)

            if area.GetTeamNumber() == GEGlobal.TEAM_MI6: self.mAreaIDs.remove(areasID)
            else: self.jAreaIDs.remove(areasID)
            
            areaIDAssociatedWithLocation = self.getREAreaIDAssociatedWithLocation(location,areasTeam)
            if not self.multiResurrectionRE.has_key(areaIDAssociatedWithLocation): self.multiResurrectionRE[areaIDAssociatedWithLocation] = 1
            
            self.multiResurrectionRE[areaIDAssociatedWithLocation] += 1
        
        else:
            colour = self.getSidesColour(areasTeam)
            
            if areasTeam == GEGlobal.TEAM_MI6: self.mAreaLocations[areasID] = location
            else: self.jAreaLocations[areasID] = location
                    
            self.radar.AddRadarContact(area,GEGlobal.RADAR_TYPE_OBJECTIVE,True,self.RERadarIcon,colour)
            self.radar.SetupObjective(area,areasTeam,"", "",colour,self.REObjectiveIconFadeOutDistance, False)
    
    #TODO remove when REs are moved to player death locations
    def getREAreaIDAssociatedWithLocation(self,location,side):
        sidesAreaLocations = None
        if side == GEGlobal.TEAM_MI6: sidesAreaLocations = self.mAreaLocations
        else: sidesAreaLocations = self.jAreaLocations
        
        for areaID in sidesAreaLocations.keys():
            if sidesAreaLocations[areaID] == location: return areaID
    
    def OnCaptureAreaEntered( self, area, player, token ):
        if area.GetTeamNumber() == player.GetTeamNumber():
            #TODO remove
            GEUtil.ClientPrint(None,GEGlobal.HUD_PRINTNOTIFY,"Multi RE entered")
            
            #Create a new resurrection timer and add it to the resurrection timer collection
            resurrectionTimer = DieAnotherDay.ResurrectionTimer(self,area,player)
            resurrectionTimer.create()
            self.REResTimers[area.GetGroupName()].append(resurrectionTimer)
            
            #Create a resurrection progress bar on the player's screen TODO: use language files
            GEUtil.InitHudProgressBar(player,self.ResurrectionPBIndex, "Resurrecting:", GEGlobal.HUDPB_SHOWBAR, self.ResurrectionTime, self.ResurrectionPBX, self.ResurrectionPBY, 120, 16,self.getSidesColour(area.GetTeamNumber()))
            
            resurrectionTimer.start()
    
#    def emptyREBin(self):
#        if len(self.REBin) != 0: 
#            for RE in self.REBin:
#                areasID = RE.GetGroupName()
#                if RE.GetTeamNumber() == GEGlobal.TEAM_MI6: self.mAreaIDs.remove(areasID)   
#                else: self.jAreaIDs.remove(areasID)
#                
#                self.tokenManager.RemoveCaptureArea(areasID)
            
    def getSidesColour(self,side):
        if side == GEGlobal.TEAM_MI6: return self.COLOR_MI6_RADAR
        else: return self.COLOR_JANUS_RADAR
        
    def OnCaptureAreaExited( self, area, player ):
        if area.GetTeamNumber() == player.GetTeamNumber(): 
            if self.getREUsersResurrectionTimer(area,player) != None:
                self.getREUsersResurrectionTimer(area,player).cancel()
            
    def getREUsersResurrectionTimer(self,area,userP):
        for resurrectionTimer in self.REResTimers[area.GetGroupName()]: 
            if resurrectionTimer.user == userP: return resurrectionTimer
            
        return None
            
    class ResurrectionTimer:
        def __init__(self,DADP,areaP,userP):
            self.timer = None
            self.DAD = DADP
            self.area = areaP
            self.user = userP
            
        def create(self):
            self.timer = self.DAD.timerTracker.CreateTimer(self.area.GetGroupName())
            self.timer.SetUpdateCallback(self.TimerTick,1)
            self.timer.SetAgeRate(1.0,0)
            
        def start(self):
            self.timer.Start(DieAnotherDay.ResurrectionTime,False)
            
        def cancel(self):
            self.timer.Stop()
            self.removeUsersResurrectionPB()
            self.delete()
            
        def delete(self):
            self.DAD.timerTracker.RemoveTimer(self.timer.GetName())
            self.DAD.REResTimers[self.area.GetGroupName()].remove(self)
            
        def TimerTick( self, timer, update_type ):
            if update_type != Timer.UPDATE_STOP:
                self.updateUsersResurrectionPB()
                
                if update_type == Timer.UPDATE_FINISH:
                    self.cancelTimerAreasOtherResTimers()
                    self.startUsersResurrectionPBsDelayedRemovalTimer(self.area.GetGroupName())
                    self.resurrectPlayerFromTimersTeam()
                    self.delete() #Must be called before deleteResurrectionArea()
                    self.DAD.deleteResurrectionArea(self.area.GetGroupName(),self.area.GetTeamNumber()) 
        
        def cancelTimerAreasOtherResTimers(self):
            for resurrectionTimer in self.DAD.REResTimers[self.area.GetGroupName()]:
                if resurrectionTimer != self: resurrectionTimer.cancel()
        
        def removeUsersResurrectionPB(self):
            GEUtil.RemoveHudProgressBar(self.user,DieAnotherDay.ResurrectionPBIndex)
            
        def updateUsersResurrectionPB(self):
            GEUtil.UpdateHudProgressBar(self.user,DieAnotherDay.ResurrectionPBIndex,int(self.timer.GetCurrentTime()))
        
        def startUsersResurrectionPBsDelayedRemovalTimer(self,timerID):
            resPBRemoveTimer = self.DAD.timerTracker.CreateTimer(timerID)
            resPBRemoveTimer.SetUpdateCallback(self.DelayedResurrectionPBRemoval,1)
            resPBRemoveTimer.SetAgeRate(1.0,0)
            
            resPBRemoveTimer.Start(DieAnotherDay.CompletedResPBRemovalDelay,False)
            
        def DelayedResurrectionPBRemoval(self,timer,update_type ):
            if update_type == Timer.UPDATE_FINISH: self.removeUsersResurrectionPB()
                    
        def resurrectPlayerFromTimersTeam(self):
            areasTeam = self.area.GetTeamNumber()
            areasID = self.area.GetGroupName()
            
            #Get team string
            teamString = None
            if areasTeam == GEGlobal.TEAM_MI6: teamString = "MI6"
            else: teamString = "Janus"
            
            #TODO modify when REs are moved from spawn points to death locations:
            numberOfPlayersToResurrect = 1
            if self.DAD.multiResurrectionRE.has_key(areasID): numberOfPlayersToResurrect = self.DAD.multiResurrectionRE[areasID]
            
            #For each resurrection...
            while numberOfPlayersToResurrect > 0:
                numberOfPlayersToResurrect -= 1
                
                #TODO remove
                if numberOfPlayersToResurrect > 1: GEUtil.Msg("*** Multi Resurrection: " + str(numberOfPlayersToResurrect) + " ***")
                
                #Choose player to be resurrected.
                resurrectedPlayer = None
                if areasTeam == GEGlobal.TEAM_MI6 and len(self.DAD.mResurrectionQueue) != 0: resurrectedPlayer = self.DAD.mResurrectionQueue.pop(0)
                elif areasTeam == GEGlobal.TEAM_JANUS and len(self.DAD.jResurrectionQueue) != 0: resurrectedPlayer = self.DAD.jResurrectionQueue.pop(0) 
                
                #If for some reason there is no player to resurrect, don't resurrect anyone.
                if resurrectedPlayer != None:
                    #Resurrect player
                    self.DAD.resurrectPlayer(resurrectedPlayer)
                    
                    #Update player bounty
                    self.DAD.increaseTeamBounty(areasTeam)
                    
                    #Update resurrection queue progress bars for team mates
                    self.DAD.resurrectionQueueUpdateNotify(areasTeam)
                    
                    if self.DAD.playerNotBot(resurrectedPlayer):
                        #Emit player resurrected event
                        GEUtil.EmitGameplayEvent("DieAnotherDay_resurrection", "%s" % resurrectedPlayer.GetName(),"%s" % teamString)
                    
                        #Announce event in console
                        GEUtil.Msg("A " + teamString + " player has been resurrected: " + resurrectedPlayer.GetName())
                    
                    #Announce resurrection
                    GEUtil.ClientPrint(None, GEGlobal.HUD_PRINTTALK,"A " + teamString + " player has been resurrected.")
                    
            #If there are now no eliminated players, allow new players to join without needing to be spawned by their team mates.
            numberOfMPlayers = GEMPGameRules.GetNumInRoundTeamPlayers(GEGlobal.TEAM_MI6)
            numberOfJPlayers = GEMPGameRules.GetNumInRoundTeamPlayers(GEGlobal.TEAM_JANUS)
                                    
            if numberOfMPlayers == self.DAD.mBounty and numberOfJPlayers == self.DAD.jBounty: self.DAD.eliminateNewPlayers = False
    
    #Only called when a resurrection has taken place.
    def DelayedResurrectionPBRemoval( self, timer, update_type ):
        timersAreasID = timer.getName()
        timersUser = self.resurrectionAreaUserLists[timersAreasID][0]
        GEUtil.RemoveHudProgressBar(timersUser,self.ResurrectionPBIndex)
            
    def resurrectionQueueUpdateNotify(self,team):
        resurrectionQueue = None
        if(team == GEGlobal.TEAM_MI6): resurrectionQueue = self.mResurrectionQueue
        else: resurrectionQueue = self.jResurrectionQueue
        
        for player in resurrectionQueue:
            if self.playerNotBot(player):
                self.tellPlayerWhatTheirResurrectionQueuePositionIs(player)
            
    def tellPlayerWhatTheirResurrectionQueuePositionIs(self,player,team=None):
        if team == None: team = player.GetTeamNumber()
        
        queuePosition = None
        if team == GEGlobal.TEAM_MI6: queuePosition = self.mResurrectionQueue.index(player)
        else: queuePosition = self.jResurrectionQueue.index(player)
        
        #TODO use language files
        GEUtil.ClientPrint(player,GEGlobal.HUD_PRINTCONSOLE,"Team mates who will be resurrected before you = ")
        GEUtil.PopupMessage(player, "You've Been Eliminated", "Team mates who will be resurrected before you = " + str(queuePosition))       
            
    def playerNotBot(self,player):
        return player.__class__.__name__ != "CGEBotPlayer"

    def resurrectPlayer(self,player):
        self.pltracker.SetValue(player,self.TR_ELIMINATED,False)

    def OnThink( self ):
        if GEMPGameRules.GetNumActivePlayers() < 2:
            self.waitingForPlayers = True
            return

        if self.waitingForPlayers:
            self.waitingForPlayers = False
            GEUtil.HudMessage( None, "#GES_GP_GETREADY", -1, -1, GEUtil.CColor( 255, 255, 255, 255 ), 2.5 )
            GEMPGameRules.EndRound( False )

        #Check to see if the round is over!:
        
        #check to see if each team has a player...
        inPlayMPlayers = []
        inPlayJPlayers = []

        for i in range( 32 ):
            if not GEPlayer.IsValidPlayerIndex( i ):
                continue

            player = GEPlayer.GetMPPlayer( i )
            if self.IsInPlay( player ):
                if player.GetTeamNumber() == GEGlobal.TEAM_MI6:
                    inPlayMPlayers.append( player )
                elif player.GetTeamNumber() == GEGlobal.TEAM_JANUS:
                    inPlayJPlayers.append( player )

        numMI6Players = len(inPlayMPlayers)
        numJanusPlayers = len(inPlayJPlayers)

        if numMI6Players == 0 and numJanusPlayers == 0: GEMPGameRules.EndRound()
        elif numMI6Players == 0 and numJanusPlayers > 0: self.teamWins(GEGlobal.TEAM_JANUS)
        elif numMI6Players > 0 and numJanusPlayers == 0: self.teamWins(GEGlobal.TEAM_MI6)
            
    def teamWins(self,teamNumber):
        team = GEMPGameRules.GetTeam(teamNumber)
        team.IncrementMatchScore( 5 )
        GEMPGameRules.SetTeamWinner(team)
        GEMPGameRules.EndRound()

    def CanPlayerRespawn( self, player ):
        if self.isEliminatedPlayer(player):
            player.SetScoreBoardColor( GEGlobal.SB_COLOR_ELIMINATED )
            return False

        player.SetScoreBoardColor( GEGlobal.SB_COLOR_NORMAL )
        
        return True

    def InitializePlayerBounty( self ):
        if self.mBounty == 0 and self.jBounty == 0:
            self.mBountyMaxPlayers = GEMPGameRules.GetNumInRoundTeamPlayers(GEGlobal.TEAM_MI6)
            self.jBountyMaxPlayers = GEMPGameRules.GetNumInRoundTeamPlayers(GEGlobal.TEAM_JANUS)
            
            self.mBounty = self.mBountyMaxPlayers
            self.jBounty = self.jBountyMaxPlayers
    
            GEUtil.InitHudProgressBar(None,self.MBountyPBIndex,"MI6:",GEGlobal.HUDPB_SHOWVALUE, self.mBountyMaxPlayers, self.MBountyPBX,self.MBountyPBY, 0, 10, self.MBountyFontColour)
            GEUtil.InitHudProgressBar(None,self.JBountyPBIndex,"Janus:",GEGlobal.HUDPB_SHOWVALUE, self.jBountyMaxPlayers, self.JBountyPBX,self.JBountyPBY, 0, 10,self.JBountyFontColour)
            
            self.bountiesInitialised = True

    def getTeamsPlayerCount(self,team):
        if team == GEGlobal.TEAM_MI6: return self.mBountyMaxPlayers
        else: return self.jBountyMaxPlayers        

    def updateTeamsDisplayedMaxPlayers(self,team):
        numberOfPlayersInTeam = self.getTeamsPlayerCount(team)
        
        if team == GEGlobal.TEAM_MI6: 
            GEUtil.InitHudProgressBar(None, self.MBountyPBIndex,"MI6:", GEGlobal.HUDPB_SHOWVALUE,numberOfPlayersInTeam, self.MBountyPBX,self.MBountyPBY, 0, 10, self.MBountyFontColour)
            GEUtil.UpdateHudProgressBar(None,self.MBountyPBIndex,self.mBounty)
        else:
            GEUtil.InitHudProgressBar(None,self.JBountyPBIndex,"Janus:", GEGlobal.HUDPB_SHOWVALUE,numberOfPlayersInTeam, self.JBountyPBX,self.JBountyPBY, 0, 10,self.JBountyFontColour)
            GEUtil.UpdateHudProgressBar(None,self.JBountyPBIndex,self.jBounty)     

    def decreaseTeamBounty(self,team):
        if team == GEGlobal.TEAM_JANUS: self.jBounty -= 1
        else: self.mBounty -= 1
        self.updateDisplayedBounties()
        
    def increaseTeamBounty(self,team):
        if team == GEGlobal.TEAM_JANUS: self.jBounty += 1
        else: self.mBounty += 1
        self.updateDisplayedBounties()
        
    def updateDisplayedBounties(self):
        GEUtil.UpdateHudProgressBar(None,self.JBountyPBIndex,self.jBounty)
        GEUtil.UpdateHudProgressBar(None,self.MBountyPBIndex,self.mBounty)

    def IsInPlay( self, player ):
        return player.GetTeamNumber() is not GEGlobal.TEAM_SPECTATOR and self.pltracker.GetValue( player, self.TR_SPAWNED ) and not self.pltracker.GetValue( player, self.TR_ELIMINATED )

    def GetTeamPlay(self):
        return GEGlobal.TEAMPLAY_ALWAYS
        

[Joe]

I've now fixed all the Beta 1.02 bugs.

I will do some more bug tests tomorrow and if I don't find any more problems, I will release it.

[The Cy]

Joe, I'm glad you're working on this promising gamemode, keep it up!

[Joe]

I've now released beta 1.02, it can be downloaded from this topic's first post.

Beta 1.02 Improvements:
1. Bugs from the previously released versions have been fixed.
2. REs are now represented by Kraid's gravestones
3. REs are now represented by a cross icon on the radar.
4. Players who kill themselves will now be eliminated.
5. Players are now shown a resurrection progress bar, instead of a remaining seconds count.
6. The count of survivors on each team will now be displayed from the start of a round, instead of becoming visible when the first elimination has taken place.
7. REs will now only been spawned when there is a free player spawn point. When a RE can't be spawned it will be added to a queue and spawned when a spawned RE is deleted.
8. The resurrection timer code is now simpler and better than it was in the previous versions.

Joe, I'm glad you're working on this promising gamemode, keep it up!

Thanks

[Joe]

Beta 1.03
I was going to release Beta 1.03 yesterday but I didn't because I found out that this game doesn't have a kick voting system.

This is a problem for Beta 1.03 because its purpose was going to be to fix two gameplay exploits by allowing players to eliminate their team mates when friendly fire is enabled.

I was going to make this change because I think players would be much more likely to use the gameplay exploits than to eliminate their team mates intentionally or accidentally because by not using these gameplay exploits they would put themselves and their team at a competitive disadvantage.

I Will Be Able To Implement A Long Range Resurrection Ability
Players will be able to use this ability by aiming at one of their team's gravestones and holding down a key on their keyboard for 5 seconds.

There won't be a resurrection ray like in MOHAA Freeze Tag because I don't think this can be implemented with the available scripting functions. I don't want to use the debug line drawing function because it's only meant to be used for debugging.

The drawback of using a RE from long range will be that your enemies will be able to see that it is being used on their radar because its radar cross icon will become yellow. If this didn't happen, the players on a RE's opposing team would not be able to see that an enemy was using it.

[TriDefiance]

Do you have an estimated date of when this will be finished?

[Joe]

Do you have an estimated date of when this will be finished?

I won't be able to finish this mode until the next GE:S patch is released because it will allow me to move REs to player death locations. I will try to have everything else implemented by the 1st of January.

I will start implementing the long range resurrection ability tomorrow.

I'm going to rent a GE:S server from a dedicated server provider. This dedicated server would be dedicated to running DAD mode and I will only rent it for a month. The purpose of this server will be to promote DAD mode and to provide a server where beta version test events can take place.

Before I release version 2.00 with its addition of the long range resurrection ability, I would like to run a weekend beta test event on my DAD server for Beta 1.02. I'm hoping that some players will attend this event if I announce it in this forum topic.

When I've finished working on this mode's script, I'm hoping that the GE:S developers will be willing to make this mode into an official game mode. If they will be willing to make it into an official mode, then I won't mind if they modify its script.