Beispiel #1
0
 def delete(self):
     try:
         self.DistributedSuitAI_deleted
     except:
         self.DistributedSuitAI_deleted = 1
         del self.aiChar
         del self.brain
         del self.aiBehaviors
         del self.boss
         del self.continuePathId
         del self.attackId
         del self.name
         del self.anim
         del self.state
         del self.damage
         del self.health
         del self.type
         del self.team
         del self.head
         del self.skeleton
         del self.dmg_lbl
         del self.lbl_int
         del self.bean
         del self.currentPath
         del self.avatarType
         del self.walkTrack
         del self.suitHealTrack
         del self.backup
         del self.lateX
         del self.lateY
         del self.currentPathQueue
         DistributedAvatarAI.delete(self)
         DistributedSmoothNodeAI.delete(self)
     return
Beispiel #2
0
 def delete(self):
     self.DELETED = True
     del self.brain
     del self.itemDropper
     del self.lateX
     del self.lateY
     del self.anim
     del self.currentPath
     del self.currentPathQueue
     del self.suitState
     del self.suitPlan
     del self.variant
     del self.stateTimestamp
     del self.startPoint
     del self.endPoint
     del self.level
     del self.suitMgr
     del self.healthChangeEvent
     del self.animStateChangeEvent
     del self.requestedBehaviors
     del self.track
     del self.deathAnim
     del self.deathTimeLeft
     del self.comboData
     del self.comboDataTaskName
     del self.clearComboDataTime
     del self.showComboDamageTime
     del self.comboDamage
     DistributedAvatarAI.delete(self)
     DistributedSmoothNodeAI.delete(self)
Beispiel #3
0
 def __init__(self, air):
     DistributedAvatarAI.__init__(self, air)
     DistributedSmoothNodeAI.__init__(self, air)
     self.anim = 'neutral'
     self.brain = None
     self.track = None
     self.currentPath = None
     self.currentPathQueue = []
     self.suitMgr = None
     self.suitPlan = 0
     self.variant = Variant.NORMAL
     self.itemDropper = SuitItemDropper(self)
     self.suitState = 0
     self.startPoint = -1
     self.endPoint = -1
     self.stateTimestamp = 0
     self.level = 0
     self.lateX = 0
     self.lateY = 0
     self.healthChangeEvent = SuitGlobals.healthChangeEvent
     self.animStateChangeEvent = SuitGlobals.animStateChangeEvent
     self.requestedBehaviors = []
     self.deathAnim = None
     self.deathTimeLeft = 0
     self.deathTaskName = None
     return
Beispiel #4
0
 def disable(self):
     DistributedAvatarAI.disable(self)
     self.clearTrack()
     taskMgr.remove(self.uniqueName('monitorHealth'))
     if self.brain:
         self.brain.stopThinking()
         self.brain = None
     self.itemDropper.cleanup()
     self.itemDropper = None
     self.lateX = None
     self.lateY = None
     self.anim = None
     self.currentPath = None
     self.currentPathQueue = None
     self.suitState = None
     self.suitPlan = None
     self.variant = None
     self.stateTimestamp = None
     self.startPoint = None
     self.endPoint = None
     self.level = None
     self.suitMgr = None
     self.healthChangeEvent = None
     self.animStateChangeEvent = None
     self.requestedBehaviors = None
     self.deathAnim = None
     self.deathTimeLeft = None
     return
Beispiel #5
0
 def delete(self):
     self.DELETED = True
     del self.brain
     del self.itemDropper
     del self.lateX
     del self.lateY
     del self.anim
     del self.currentPath
     del self.currentPathQueue
     del self.suitState
     del self.suitPlan
     del self.variant
     del self.stateTimestamp
     del self.startPoint
     del self.endPoint
     del self.level
     del self.suitMgr
     del self.healthChangeEvent
     del self.animStateChangeEvent
     del self.requestedBehaviors
     del self.track
     del self.deathAnim
     del self.deathTimeLeft
     DistributedAvatarAI.delete(self)
     DistributedSmoothNodeAI.delete(self)
Beispiel #6
0
 def disable(self):
     DistributedAvatarAI.disable(self)
     self.clearTrack()
     taskMgr.remove(self.uniqueName('__handleDeath'))
     taskMgr.remove(self.uniqueName('Resume Thinking'))
     taskMgr.remove(self.uniqueName('monitorHealth'))
     taskMgr.remove(self.comboDataTaskName)
     if self.brain:
         self.brain.stopThinking()
         self.brain.unloadBehaviors()
         self.brain = None
     self.itemDropper.cleanup()
     self.itemDropper = None
     self.lateX = None
     self.lateY = None
     self.anim = None
     self.currentPath = None
     self.currentPathQueue = None
     self.suitState = None
     self.suitPlan = None
     self.variant = None
     self.stateTimestamp = None
     self.startPoint = None
     self.endPoint = None
     self.level = None
     self.suitMgr = None
     self.healthChangeEvent = None
     self.animStateChangeEvent = None
     self.requestedBehaviors = None
     self.deathAnim = None
     self.deathTimeLeft = None
     self.comboData = None
     self.clearComboDataTime = None
     self.showComboDamageTime = None
     self.comboDamage = None
Beispiel #7
0
    def setHealth(self, health):
        prevHealth = self.health
        DistributedAvatarAI.setHealth(self, health)
        messenger.send(self.healthChangeEvent, [health, prevHealth])

        if not self.isDead() or self.isDead() and self.deathTimeLeft > 0:
            self.d_announceHealth(0, prevHealth - self.health)
 def disable(self):
     base.taskMgr.remove(self.uniqueName("DistributedPieTurretAI-scan"))
     self.owner = None
     self.mgr = None
     DistributedSmoothNodeAI.disable(self)
     DistributedAvatarAI.disable(self)
     return
Beispiel #9
0
 def setHealth(self, hp):
     DistributedAvatarAI.setHealth(self, hp)
     if hp < 1:
         self.getManager().sendUpdateToAvatarId(self.getOwner(),
                                                'yourTurretIsDead', [])
         self.sendUpdate('die', [])
         Sequence(Wait(2.0), Func(self.getManager().killTurret,
                                  self.doId)).start()
Beispiel #10
0
    def announceGenerate(self):
        DistributedAvatarAI.announceGenerate(self)
        self.clearTrack()
        self.track = Sequence(Wait(0.1), Func(self.spawn))
        self.track.start()

        # Let's set the combo data task name and start the task.
        self.comboDataTaskName = self.uniqueName('clearComboData')
        taskMgr.add(self.clearComboData, self.comboDataTaskName)
Beispiel #11
0
    def delete(self):
        try:
            self.DistributedToonAI_deleted
        except:
            gagIds = []
            for gag in self.backpack.getGags():
                gagIds.append(gag.getID())

            self.b_setBackpackAmmo(gagIds, self.buildAmmoList(gagIds))
            self.DistributedToonAI_deleted = 1
            DistributedAvatarAI.delete(self)
            DistributedSmoothNodeAI.delete(self)
            self.questManager.cleanup()
            self.questManager = None
            self.tutDone = None
            self.token = None
            self.name = None
            self.anim = None
            self.chat = None
            self.health = None
            self.damage = None
            self.height = None
            self.gender = None
            self.headtype = None
            self.head = None
            self.legtype = None
            self.torsotype = None
            self.hr = None
            self.hg = None
            self.hb = None
            self.tr = None
            self.tg = None
            self.tb = None
            self.lr = None
            self.lg = None
            self.lb = None
            self.shir = None
            self.shig = None
            self.shib = None
            self.shor = None
            self.shog = None
            self.shob = None
            self.shirt = None
            self.short = None
            self.sleeve = None
            self.isdying = None
            self.isdead = None
            self.toon_legs = None
            self.toon_torso = None
            self.toon_head = None
            self.portal = None
            self.book = None
            self.place = None
            self.attackers = None

        return
 def delete(self):
     try:
         self.DistributedToonAI_deleted
     except:
         if type(self.backpack) != types.IntType and self.backpack is not None:
             self.backpack.cleanup()
             self.backpack = None
         self.DistributedToonAI_deleted = 1
         DistributedAvatarAI.delete(self)
         DistributedSmoothNodeAI.delete(self)
         self.questManager.cleanup()
         self.questManager = None
         self.tutDone = None
         self.token = None
         self.anim = None
         self.chat = None
         self.health = None
         self.damage = None
         self.height = None
         self.gender = None
         self.headtype = None
         self.head = None
         self.legtype = None
         self.torsotype = None
         self.hr = None
         self.hg = None
         self.hb = None
         self.tr = None
         self.tg = None
         self.tb = None
         self.lr = None
         self.lg = None
         self.lb = None
         self.shir = None
         self.shig = None
         self.shib = None
         self.shor = None
         self.shog = None
         self.shob = None
         self.shirt = None
         self.short = None
         self.sleeve = None
         self.isdying = None
         self.isdead = None
         self.toon_legs = None
         self.toon_torso = None
         self.toon_head = None
         self.portal = None
         self.book = None
         self.place = None
         self.attackers = None
     return
Beispiel #13
0
 def disable(self):
     try:
         self.DistributedSuitAI_disabled
     except:
         self.DistributedSuitAI_disabled = 1
         if self.track:
             self.track.pause()
             self.track = None
         taskMgr.remove(self.uniqueName('monitorHealth'))
         taskMgr.remove(self.uniqueName('attackTask'))
         taskMgr.remove(self.uniqueName('continueSuitRoam'))
         if self.suitHealTrack:
             self.suitHealTrack.pause()
             self.suitHealTrack = None
         if self.walkTrack:
             self.ignore(self.walkTrack.getName())
             self.walkTrack.clearToInitial()
             self.walkTrack = None
         if self.boss:
             self.boss.stopBoss()
             self.boss = None
         if self.brain:
             self.brain.end()
             self.brain = None
         self.itemDropper.cleanup()
         self.itemDropper = None
         self.aiChar = None
         self.aiBehaviors = None
         self.continuePathId = None
         self.attackId = None
         self.name = None
         self.anim = None
         self.state = None
         self.damage = None
         self.health = None
         self.backup = None
         self.type = None
         self.team = None
         self.head = None
         self.skeleton = 0
         self.dmg_lbl = None
         self.currentPath = None
         self.lbl_int = None
         self.bean = None
         self.avatarType = None
         self.lateX = None
         self.lateY = None
         self.currentPathQueue = None
         DistributedAvatarAI.disable(self)
     return
Beispiel #14
0
    def __init__(self, air):
        DistributedAvatarAI.__init__(self, air)
        DistributedSmoothNodeAI.__init__(self, air)
        self.owner = 0
        self.mgr = None

        # This is to optimize the turrets.
        self.targets = []
        self.shooting = False

        # This is for abandoning targets.
        self.initialTargetHealth = 0
        self.piesShot = 0
        self.currentTarget = None
        self.deathEvent = None
Beispiel #15
0
 def disable(self):
     base.taskMgr.removeTasksMatching(
         self.uniqueName('DistributedPieTurretAI-scan'))
     base.taskMgr.removeTasksMatching(
         self.uniqueName('DistributedPieTurretAI-shootClosestTarget'))
     self.owner = None
     self.mgr = None
     self.targets = None
     self.shooting = None
     self.initialTargetHealth = None
     self.piesShot = None
     self.currentTarget = None
     self.deathEvent = None
     DistributedSmoothNodeAI.disable(self)
     DistributedAvatarAI.disable(self)
Beispiel #16
0
 def __init__(self, air, charId):
     DistributedAvatarAI.__init__(self, air)
     DistributedSmoothNodeAI.__init__(self, air)
     self.fsm = ClassicFSM('DDCharAI',
                           [State('off', self.enterOff, self.exitOff),
                            State('neutral', self.enterNeutral, self.exitNeutral),
                            State('walking', self.enterWalking, self.exitWalking)],
                           'off', 'off')
     self.fsm.enterInitialState()
     self.charId = charId
     self.avatars = []
     self.inConvo = False
     self.chatsThisConvo = 0
     self.toonOfInterest = 0
     self.saidGoodbye = False
     self.currentPointLetter = None
     self.lastPointLetter = None
     self.talkEnabled = True
    def announceGenerate(self):
        DistributedAvatarAI.announceGenerate(self)
        DistributedSmoothNodeAI.announceGenerate(self)
        if self.parentId != self.getDefaultShard():
            self.b_setDefaultShard(self.parentId)

        if self.__class__.__name__ == "DistributedToonAI":
            # TEMPORARY: Any new gags that we make have to be given to toons automatically.
            newGags = GagGlobals.gagIds.keys()
            currentGags = self.backpack.gags
            needsToUpdate = False
            for newGag in newGags:
                if not newGag in currentGags.keys():
                    print 'This player is missing {0}'.format(GagGlobals.getGagByID(newGag))
                    self.backpack.addGag(newGag)
                    if not needsToUpdate:
                        needsToUpdate = True
            if needsToUpdate:
                self.backpack.updateNetAmmo()
Beispiel #18
0
    def __init__(self, air):
        DistributedAvatarAI.__init__(self, air)
        DistributedSmoothNodeAI.__init__(self, air)
        self.anim = 'neutral'
        self.brain = None
        self.track = None
        self.currentPath = None
        self.currentPathQueue = []
        self.suitMgr = None
        self.suitPlan = 0
        self.variant = Variant.NORMAL
        self.itemDropper = SuitItemDropper(self)
        self.suitState = 0
        self.startPoint = -1
        self.endPoint = -1
        self.stateTimestamp = 0
        self.level = 0
        self.lateX = 0
        self.lateY = 0
        self.healthChangeEvent = SuitGlobals.healthChangeEvent
        self.animStateChangeEvent = SuitGlobals.animStateChangeEvent
        self.requestedBehaviors = []

        # This is for handling death.
        self.deathAnim = None
        self.deathTimeLeft = 0
        self.deathTaskName = None

        # This is for handling combos.
        # Combo data stores an avId and gag type pair.
        # Avatar Ids are cheaper to store, so we use those.
        # comboDataTaskName is the name of the task that clears the data.
        self.comboData = {}
        self.comboDataTaskName = None
        self.clearComboDataTime = 3
        self.showComboDamageTime = 0.75
        self.comboDamage = 0

        self.allowHits = True
Beispiel #19
0
 def __init__(self, air):
     try:
         self.DistributedSuitAI_initialized
         return
     except:
         self.DistributedSuitAI_initialized = 1
     DistributedAvatarAI.__init__(self, air)
     DistributedSmoothNodeAI.__init__(self, air)
     self.itemDropper = SuitItemDropper(self)
     self.avatarType = CIGlobals.Suit
     self.aiChar = None
     self.aiBehaviors = None
     self.walkTrack = None
     self.name = ""
     self.anim = "neutral"
     self.state = "alive"
     self.damage = 0
     self.health = 132
     self.type = "A"
     self.team = "c"
     self.head = "bigcheese"
     self.name = "The Big Cheese"
     self.skeleton = 0
     self.dmg_lbl = None
     self.lbl_int = None
     self.bean = None
     self.boss = None
     self.brain = None
     self.startPoint = -1
     self.endPoint = -1
     self.suitState = 0
     self.walkPaused = 0
     self.attacking = False
     self.suitHealTrack = None
     self.continuePathId = 0
     self.attackId = 0
     self.mgr = None
     self.backup = 0
     self.difficulty = None
     self.track = None
     self.lateX = 0
     self.lateY = 0
     self.stateTimestamp = 0
     self.animState2animId = {
         'off': 13,
         'neutral': 10,
         'walk': 9,
         'die': 5,
         'attack': 7,
         'flydown': 1,
         'pie': 4,
         'win': 12,
         'flyaway': 14,
         'rollodex': 3,
         'flyNeutral': 15,
         'flail': 0,
         'drop': 6,
         'drop-react': 16,
         'squirt-large': 8,
         'squirt-small': 11,
         'soak': 2,
     }
     self.animId2animState = {
         v: k
         for k, v in self.animState2animId.items()
     }
     self.level = 0
     self.currentPathQueue = []
     return
 def __init__(self, air):
     try:
         self.DistributedToonAI_initialized
         return
     except:
         self.DistributedToonAI_initialized = 1
     DistributedAvatarAI.__init__(self, air)
     DistributedSmoothNodeAI.__init__(self, air)
     ToonDNA.ToonDNA.__init__(self)
     self.questManager = QuestManagerAI(self)
     self.avatarType = CIGlobals.Toon
     self.money = 0
     self.anim = "neutral"
     self.chat = ""
     self.health = 50
     self.damage = 0
     self.height = 3
     self.gender = "boy"
     self.headtype = "dgm_skirt"
     self.head = "dog"
     self.legtype = "dgm"
     self.torsotype = "dgm_shorts"
     self.hr = 1
     self.hg = 1
     self.hb = 1
     self.tr = 1
     self.tg = 1
     self.tb = 1
     self.lr = 1
     self.lg = 1
     self.lb = 1
     self.shir = 1
     self.shig = 1
     self.shib = 1
     self.shor = 1
     self.shog = 1
     self.shob = 1
     self.shirt = "phase_3/maps/desat_shirt_1.jpg"
     self.short = "phase_3/maps/desat_shorts_1.jpg"
     self.sleeve = "phase_3/maps/desat_sleeve_1.jpg"
     self.isdying = False
     self.isdead = False
     self.toon_legs = None
     self.toon_torso = None
     self.toon_head = None
     self.portal = None
     self.book = None
     self.token = -1
     self.ghost = 0
     self.attackers = []
     self.puInventory = []
     self.equippedPU = -1
     self.backpack = None
     self.quests = [[], [], []]
     self.questHistory = []
     self.tier = -1
     self.friends = []
     self.tutDone = 0
     self.hoodsDiscovered = []
     self.teleportAccess = []
     self.lastHood = 0
     self.defaultShard = 0
     return
Beispiel #21
0
 def announceGenerate(self):
     DistributedAvatarAI.announceGenerate(self)
     data = CHAR_DATA[self.charId]
     self.talkEnabled = data[4]
     self.fsm.request('neutral', [True])
Beispiel #22
0
 def announceGenerate(self):
     DistributedAvatarAI.announceGenerate(self)
     self.clearTrack()
     self.track = Sequence(Wait(0.1), Func(self.spawn))
     self.track.start()
Beispiel #23
0
 def generate(self):
     DistributedAvatarAI.generate(self)
     DistributedSmoothNodeAI.generate(self)
Beispiel #24
0
 def announceGenerate(self):
     DistributedAvatarAI.announceGenerate(self)
     DistributedSmoothNodeAI.announceGenerate(self)
Beispiel #25
0
 def setHealth(self, health):
     prevHealth = self.health
     DistributedAvatarAI.setHealth(self, health)
     messenger.send(self.healthChangeEvent, [health, prevHealth])
     if not self.isDead() or self.isDead() and self.deathTimeLeft > 0:
         self.d_announceHealth(0, prevHealth - self.health)
 def setHealth(self, hp):
     DistributedAvatarAI.setHealth(self, hp)
     if hp < 1:
         self.getManager().sendUpdateToAvatarId(self.getOwner(), "yourTurretIsDead", [])
         self.sendUpdate("die", [])
         Sequence(Wait(2.0), Func(self.getManager().killTurret, self.doId)).start()
Beispiel #27
0
    def __init__(self, air):
        try:
            self.DistributedToonAI_initialized
            return
        except:
            self.DistributedToonAI_initialized = 1

        DistributedAvatarAI.__init__(self, air)
        DistributedSmoothNodeAI.__init__(self, air)
        ToonDNA.ToonDNA.__init__(self)
        self.questManager = QuestManagerAI(self)
        self.avatarType = CIGlobals.Toon
        self.money = 0
        self.name = ''
        self.anim = 'neutral'
        self.chat = ''
        self.health = 50
        self.damage = 0
        self.height = 3
        self.gender = 'boy'
        self.headtype = 'dgm_skirt'
        self.head = 'dog'
        self.legtype = 'dgm'
        self.torsotype = 'dgm_shorts'
        self.hr = 1
        self.hg = 1
        self.hb = 1
        self.tr = 1
        self.tg = 1
        self.tb = 1
        self.lr = 1
        self.lg = 1
        self.lb = 1
        self.shir = 1
        self.shig = 1
        self.shib = 1
        self.shor = 1
        self.shog = 1
        self.shob = 1
        self.ammo = []
        self.shirt = 'phase_3/maps/desat_shirt_1.jpg'
        self.short = 'phase_3/maps/desat_shorts_1.jpg'
        self.sleeve = 'phase_3/maps/desat_sleeve_1.jpg'
        self.isdying = False
        self.isdead = False
        self.toon_legs = None
        self.toon_torso = None
        self.toon_head = None
        self.portal = None
        self.book = None
        self.token = -1
        self.ghost = 0
        self.attackers = []
        self.puInventory = []
        self.equippedPU = -1
        self.backpack = -1
        self.gagMgr = GagManager()
        self.setupGags = False
        self.quests = [[], [], []]
        self.questHistory = []
        self.tier = -1
        self.friends = []
        self.tutDone = 0
        self.hoodsDiscovered = []
        self.teleportAccess = []
        self.lastHood = 0
        return
Beispiel #28
0
 def announceGenerate(self):
     DistributedAvatarAI.announceGenerate(self)
     if self.track:
         self.track.pause()
         self.track = None
     Sequence(Wait(0.1), Func(self.spawn)).start()
Beispiel #29
0
 def generate(self):
     DistributedAvatarAI.generate(self)
     DistributedSmoothNodeAI.generate(self)
 def __init__(self, air):
     DistributedAvatarAI.__init__(self, air)
     DistributedSmoothNodeAI.__init__(self, air)
     self.owner = 0
     self.mgr = None
     return