Poodletooth-iLand/toontown/coghq/DistributedStageAI.py

from direct.directnotify import DirectNotifyGlobal
from direct.distributed import DistributedObjectAI
from otp.level import DistributedLevelAI
from pandac.PandaModules import *
from toontown.building import DistributedElevatorFloorAI
from toontown.coghq import BattleExperienceAggregatorAI
from toontown.coghq import StageLayout, DistributedStageRoomAI
from toontown.toonbase import ToontownGlobals


class DistributedStageAI(DistributedObjectAI.DistributedObjectAI):
    notify = DirectNotifyGlobal.directNotify.newCategory('DistributedStageAI')

    def __init__(self, air, stageId, zoneId, floorNum, avIds, layoutIndex, battleExpAggreg = None):
        DistributedObjectAI.DistributedObjectAI.__init__(self, air)
        self.stageId = stageId
        self.zoneId = zoneId
        self.floorNum = floorNum
        self.avIds = avIds
        self.elevatorList = []
        self.setLayoutIndex(layoutIndex)
        self.battleExpAggreg = battleExpAggreg
        self.puzzelReward = 5

    def generate(self):
        DistributedObjectAI.DistributedObjectAI.generate(self)
        self.notify.info('generate %s, id=%s, floor=%s' % (self.doId, self.stageId, self.floorNum))
        self.layout = StageLayout.StageLayout(self.stageId, self.floorNum, self.layoutIndex)
        self.rooms = []
        if self.battleExpAggreg is None:
            self.battleExpAggreg = BattleExperienceAggregatorAI.BattleExperienceAggregatorAI()
        for i in xrange(self.layout.getNumRooms()):
            room = DistributedStageRoomAI.DistributedStageRoomAI(self.air, self.stageId, self.doId, self.zoneId, self.layout.getRoomId(i), i * 2, self.avIds, self.battleExpAggreg)
            room.generateWithRequired(self.zoneId)
            self.rooms.append(room)
        roomDoIds = []
        for room in self.rooms:
            roomDoIds.append(room.doId)
        self.sendUpdate('setRoomDoIds', [
            roomDoIds])
        self.placeElevatorsOnMarkers()
        description = '%s|%s|%s' % (self.stageId, self.floorNum, self.avIds)
        for avId in self.avIds:
            self.air.writeServerEvent('stageEntered', avId, description)

    def requestDelete(self):
        self.notify.info('requestDelete: %s' % self.doId)
        if hasattr(self, 'rooms'):
            for room in self.rooms:
                room.requestDelete()
        if hasattr(self, 'elevatorList'):
            for elevator in self.elevatorList:
                elevator.requestDelete()
        DistributedObjectAI.DistributedObjectAI.requestDelete(self)

    def delete(self):
        self.notify.info('delete: %s' % self.doId)
        self.air.deallocateZone(self.zoneId)
        if hasattr(self, 'elevatorList'):
            del self.elevatorList
        if hasattr(self, 'rooms'):
            del self.rooms
        if hasattr(self, 'layout'):
            del self.layout
        if hasattr(self, 'battleExpAggreg'):
            del self.battleExpAggreg
        DistributedObjectAI.DistributedObjectAI.delete(self)

    def getTaskZoneId(self):
        return self.stageId

    def placeElevatorsOnMarkers(self):
        for room in self.rooms:
            if room.entType2ids['elevatorMarker']:
                for markerId in room.entType2ids['elevatorMarker']:
                    marker = room.getEntity(markerId)
                    newElevator = DistributedElevatorFloorAI.DistributedElevatorFloorAI(self.air, self.doId, self, self.avIds, marker.doId)
                    newElevator.generateWithRequired(self.zoneId)
                    self.elevatorList.append(newElevator)

    def allToonsGone(self):
        self.notify.info('allToonsGone')
        self.requestDelete()

    def getZoneId(self):
        return self.zoneId

    def getStageId(self):
        return self.stageId

    def getFloorNum(self):
        return self.floorNum

    def setLayoutIndex(self, layoutIndex):
        self.layoutIndex = layoutIndex

    def getLayoutIndex(self):
        return self.layoutIndex

    def startNextFloor(self):
        floor = self.floorNum + 1
        StageZone = self.air.allocateZone()
        Stage = DistributedStageAI(self.air, self.stageId, StageZone, floor, self.avIds, self.layoutIndex, self.battleExpAggreg)
        Stage.generateWithRequired(StageZone)
        for avId in self.avIds:
            self.sendUpdateToAvatarId(avId, 'setStageZone', [StageZone])
        self.requestDelete()

    def elevatorAlert(self, avId):
        self.sendUpdate('elevatorAlert', [avId])

    def increasePuzzelReward(self):
        self.puzzelReward += 5
        if self.puzzelReward > 10:
            self.puzzelReward = 10

    def resetPuzzelReward(self):
        self.puzzelReward = 5

    def getPuzzelReward(self):
        return self.puzzelReward