class DistributedEstateAI(DistributedObjectAI):
notify = DirectNotifyGlobal.directNotify.newCategory('DistributedEstateAI')
def __init__(self, air):
DistributedObjectAI.__init__(self, air)
self.houses = [None] * 6
self.estateType = 0
self.closestHouse = 0
self.treasureIds = []
self.dawnTime = 0
self.decorData = []
self.lastEpochTimeStamp = 0
self.rentalType = 0
self.clouds = 0
self.cannons = []
self.rentalTimeStamp = 0
self.lawnItems = [[], [], [], [], [], []]
self.activeToons = [0, 0, 0, 0, 0, 0]
self.idList = []
self.spotPosHpr = [(49.1029, -124.805, 0.344704, 90, 0, 0),
(46.5222, -134.739, 0.390713, 75, 0, 0),
(41.31, -144.559, 0.375978, 45, 0, 0),
(46.8254, -113.682, 0.46015, 135, 0, 0)]
self.pond = None
self.treasurePlanner = None
self.flyingTreasurePlanner = None
self.propGenerator = None
return
def announceGenerate(self):
DistributedObjectAI.announceGenerate(self)
self.treasurePlanner = ETreasurePlannerAI(self.zoneId)
self.treasurePlanner.start()
self.pond = DistributedFishingPondAI(self.air)
self.pond.setArea(ToontownGlobals.MyEstate)
self.pond.generateWithRequired(self.zoneId)
self.pond.generateTargets()
for i in xrange(len(self.spotPosHpr)):
spot = DistributedFishingSpotAI(self.air)
spot.setPondDoId(self.pond.doId)
spot.setPosHpr(*self.spotPosHpr[i])
if not isinstance(spot, DistributedFishingSpotAI):
self.notify.warning('Failed to generate spot for pond %d!' % self.pond.doId)
continue
spot.generateWithRequired(self.zoneId)
self.pond.addSpot(spot)
self.propGenerator = DistributedPropGeneratorAI(self.air, self.zoneId)
self.propGenerator.generateWithRequired(self.zoneId)
self.air.propGenerators[self.zoneId] = self.propGenerator
taskMgr.add(self.__collisionLoop, self.uniqueName('collisionLoop'), sort=30)
def setEstateType(self, estateType):
self.estateType = estateType
def d_setEstateType(self, estateType):
self.sendUpdate('setEstateType', [estateType])
def b_setEstateType(self, estateType):
self.setEstateType(estateType)
self.d_setEstateType(estateType)
def getEstateType(self):
return self.estateType
def setClosestHouse(self, closestHouse):
self.closestHouse = closestHouse
def setTreasureIds(self, treasureIds):
self.treasureIds = treasureIds
def d_setTreasureIds(self, treasureIds):
self.sendUpdate('setTreasureIds', [treasureIds])
def b_setTreasureIds(self, treasureIds):
self.setTreasureIds(treasureIds)
self.d_setTreasureIds(treasureIds)
def getTreasureIds(self):
return self.treasureIds
def requestServerTime(self):
avId = self.air.getAvatarIdFromSender()
if not avId:
return
self.sendUpdateToAvatarId(avId, 'setServerTime', [time.time() % HouseGlobals.DAY_NIGHT_PERIOD])
def setDawnTime(self, dawnTime):
self.dawnTime = dawnTime
def d_setDawnTime(self, dawnTime):
self.sendUpdate('setDawnTime', [dawnTime])
def b_setDawnTime(self, dawnTime):
self.setDawnTime(dawnTime)
self.d_setDawnTime(dawnTime)
def getDawnTime(self):
return self.dawnTime
def placeOnGround(self, obj):
pass
def setDecorData(self, decorData):
self.decorData = decorData
def getDecorData(self):
return self.decorData
def setLastEpochTimeStamp(self, lastEpochTimeStamp):
self.lastEpochTimeStamp = lastEpochTimeStamp
def getLastEpochTimeStamp(self):
return self.lastEpochTimeStamp
def setRentalTimeStamp(self, rentalTimeStamp):
self.rentalTimeStamp = rentalTimeStamp
def d_setRentalTimeStamp(self, rentalTimeStamp):
self.sendUpdate('setRentalTimeStamp', [rentalTimeStamp])
def b_setRentalTimeStamp(self, rentalTimeStamp):
self.setRentalTimeStamp(rentalTimeStamp)
self.d_setRentalTimeStamp(rentalTimeStamp)
def getRentalTimeStamp(self):
return self.rentalTimeStamp
def setRentalType(self, rentalType):
self.rentalType = rentalType
if rentalType:
if time.time() >= self.rentalTimeStamp:
self.b_setRentalType(0)
self.b_setRentalTimeStamp(0)
return
if rentalType == ToontownGlobals.RentalCannon:
target = DistributedTargetAI(self.air)
target.generateWithRequired(self.zoneId)
self.cannons.append(target)
for posHpr in CannonGlobals.cannonDrops:
cannon = DistributedCannonAI(self.air, self.doId, target.doId, *posHpr)
cannon.generateWithRequired(self.zoneId)
self.cannons.append(cannon)
self.b_setClouds(1)
self.flyingTreasurePlanner = EFlyingTreasurePlannerAI(self.zoneId, callback=self.__treasureGrabbed)
self.flyingTreasurePlanner.placeAllTreasures()
self.b_setTreasureIds([ treasure.doId for treasure in self.flyingTreasurePlanner.treasures ])
taskMgr.doMethodLater(self.rentalTimeStamp - time.time(), self.__rentalExpire, self.uniqueName('rentalExpire'))
def b_setRentalType(self, rentalType):
self.setRentalType(rentalType)
self.d_setRentalType(rentalType)
def d_setRentalType(self, rentalType):
self.sendUpdate('setRentalType', [rentalType])
def __treasureGrabbed(self, _):
self.b_setTreasureIds([ treasure.doId for treasure in self.flyingTreasurePlanner.treasures if treasure ])
def __rentalExpire(self, task):
if self.getRentalType() == ToontownGlobals.RentalCannon:
for cannon in self.cannons[:]:
cannon.requestDelete()
self.cannons.remove(cannon)
self.b_setClouds(0)
self.b_setRentalTimeStamp(0)
self.b_setRentalType(0)
self.b_setTreasureIds([])
self.flyingTreasurePlanner.deleteAllTreasuresNow()
self.flyingTreasurePlanner = None
return task.done
def getRentalType(self):
return self.rentalType
def setSlot0ToonId(self, avId):
self.activeToons[0] = avId
def getSlot0ToonId(self):
return self.activeToons[0]
def setSlot0Items(self, item):
self.lawnItems[0] = item
def getSlot0Items(self):
return self.lawnItems[0]
def setSlot1ToonId(self, avId):
self.activeToons[1] = avId
def getSlot1ToonId(self):
return self.activeToons[1]
def setSlot1Items(self, item):
self.lawnItems[1] = item
def getSlot1Items(self):
return self.lawnItems[1]
def setSlot2ToonId(self, avId):
self.activeToons[2] = avId
def getSlot2ToonId(self):
return self.activeToons[2]
def setSlot2Items(self, item):
self.lawnItems[2] = item
def getSlot2Items(self):
return self.lawnItems[2]
def setSlot3ToonId(self, avId):
self.activeToons[3] = avId
def getSlot3ToonId(self):
return self.activeToons[3]
def setSlot3Items(self, item):
self.lawnItems[3] = item
def getSlot3Items(self):
return self.lawnItems[3]
def setSlot4ToonId(self, avId):
self.activeToons[4] = avId
def getSlot4ToonId(self):
return self.activeToons[4]
def setSlot4Items(self, item):
self.lawnItems[4] = item
def getSlot4Items(self):
return self.lawnItems[4]
def setSlot5ToonId(self, avId):
self.activeToons[5] = avId
def getSlot5ToonId(self):
return self.activeToons[5]
def setSlot5Items(self, item):
self.lawnItems[5] = item
def getSlot5Items(self):
return self.lawnItems[5]
def setIdList(self, idList):
self.idList = idList
def d_setIdList(self, idList):
self.sendUpdate('setIdList', [idList])
def b_setIdList(self, idList):
self.setIdList(idList)
self.d_setIdList(idList)
def getIdList(self):
return self.idList
def completeFlowerSale(self, flag):
if not flag:
return
avId = self.air.getAvatarIdFromSender()
av = self.air.doId2do.get(avId)
if not av:
return
collection = av.flowerCollection
earning = 0
newSpecies = 0
for flower in av.flowerBasket.getFlower():
if collection.collectFlower(flower) == GardenGlobals.COLLECT_NEW_ENTRY:
newSpecies += 1
earning += flower.getValue()
av.b_setFlowerBasket([], [])
av.d_setFlowerCollection(*av.flowerCollection.getNetLists())
av.addMoney(earning)
oldSpecies = len(collection) - newSpecies
dt = abs(len(collection) // 10 - oldSpecies // 10)
if dt:
self.notify.info('%d is getting a gardening trophy!' % avId)
maxHp = av.getMaxHp()
maxHp = min(ToontownGlobals.MaxHpLimit, maxHp + dt)
av.b_setMaxHp(maxHp)
av.toonUp(maxHp)
self.sendUpdate('awardedTrophy', [avId])
av.b_setGardenTrophies(range(len(collection) // 10))
def setClouds(self, clouds):
self.clouds = clouds
def d_setClouds(self, clouds):
self.sendUpdate('setClouds', [clouds])
def b_setClouds(self, clouds):
self.setClouds(clouds)
self.d_setClouds(clouds)
def getClouds(self):
return self.clouds
def rentItem(self, typeIndex, duration):
self.b_setRentalTimeStamp(time.time() + duration * 60)
self.b_setRentalType(typeIndex)
def cannonsOver(self):
pass
def gameTableOver(self):
pass
def getAvHouse(self, avId):
if not avId:
return
else:
resp = None
for house in self.houses:
if house is not None:
if house.getAvatarId() == avId:
return house
return
def placeStarterGarden(self, avId):
if not avId:
return
else:
for house in self.houses:
if house is not None:
if house.getAvatarId() == avId:
house.placeStarterGarden()
return
self.notify.warning("Avatar %s tried to place a starter garden when they didn't own a house!" % avId)
return
def delete(self):
if self.treasurePlanner:
self.treasurePlanner.stop()
self.treasurePlanner.deleteAllTreasuresNow()
self.treasurePlanner = None
if self.flyingTreasurePlanner:
self.flyingTreasurePlanner.deleteAllTreasuresNow()
self.flyingTreasurePlanner = None
if self.pond is not None:
self.pond.requestDelete()
self.pond = None
for cannon in self.cannons[:]:
cannon.requestDelete()
self.cannons.remove(cannon)
if self.propGenerator:
self.propGenerator.requestDelete()
self.propGenerator = None
if self.zoneId in self.air.propGenerators:
del self.air.propGenerators[self.zoneId]
taskMgr.remove(self.uniqueName('rentalExpire'))
taskMgr.remove(self.uniqueName('collisionLoop'))
DistributedObjectAI.delete(self)
return
def destroy(self):
for house in self.houses:
if house is not None:
house.requestDelete()
del self.houses[:]
self.requestDelete()
return
def __collisionLoop(self, task):
if hasattr(self, 'pets'):
for pet in self.pets:
if not pet:
continue
collTrav = pet.getCollTrav()
if collTrav:
collTrav.traverse(self.getRender())
return task.cont
def doEpochNow(self, onlyForThisToonIndex):
avId = self.idList[onlyForThisToonIndex]
house = self.getAvHouse(avId)
house.gardenManager.gardens.get(avId).growFlowers()
