from direct.directnotify.DirectNotifyGlobal import *
from direct.distributed import DistributedObjectAI
from direct.task import Task
import random
import DistributedSuitAI
import SuitDNA
import SuitPlannerBase
import SuitTimings
from otp.ai.AIBaseGlobal import *
from toontown.battle import BattleManagerAI
from toontown.battle import SuitBattleGlobals
from toontown.building import HQBuildingAI
from toontown.building import SuitBuildingGlobals
from toontown.dna.DNAParser import DNASuitPoint
from toontown.hood import ZoneUtil
from toontown.suit.SuitInvasionGlobals import IFSkelecog, IFWaiter, IFV2
from libpandadna import *
from toontown.toon import NPCToons
from toontown.toonbase import ToontownBattleGlobals
from toontown.toonbase import ToontownGlobals
ALLOWED_FO_TRACKS = 's'
if config.GetBool('want-lawbot-cogdo', True):
ALLOWED_FO_TRACKS += 'l'
if config.GetBool('want-cashbot-cogdo', False):
ALLOWED_FO_TRACKS += 'c'
if config.GetBool('want-bossbot-cogdo', False):
ALLOWED_FO_TRACKS += 'b'
if config.GetBool('want-omni-cogdo', False):
ALLOWED_FO_TRACKS += 'slcb'
DEFAULT_COGDO_RATIO = .5
class DistributedSuitPlannerAI(DistributedObjectAI.DistributedObjectAI, SuitPlannerBase.SuitPlannerBase):
notify = directNotify.newCategory('DistributedSuitPlannerAI')
CogdoPopFactor = config.GetFloat('cogdo-pop-factor', 1.5)
CogdoRatio = min(1.0, max(0.0, config.GetFloat('cogdo-ratio', DEFAULT_COGDO_RATIO)))
MAX_SUIT_TYPES = 6
POP_UPKEEP_DELAY = 10
POP_ADJUST_DELAY = 300
PATH_COLLISION_BUFFER = 5
TOTAL_MAX_SUITS = 50
MIN_PATH_LEN = 40
MAX_PATH_LEN = 300
MIN_TAKEOVER_PATH_LEN = 2
SUITS_ENTER_BUILDINGS = 1
SUIT_BUILDING_NUM_SUITS = 1.5
SUIT_BUILDING_TIMEOUT = [
None, None, None, None, None, None,
72, 60, 48, 36, 24, 12, 6, 3, 1, 0.5
]
TOTAL_SUIT_BUILDING_PCT = 18 * CogdoPopFactor
BUILDING_HEIGHT_DISTRIBUTION = [14, 18, 25, 23, 20]
defaultSuitName = simbase.config.GetString('suit-type', 'random')
if defaultSuitName == 'random':
defaultSuitName = None
def __init__(self, air, zoneId):
DistributedObjectAI.DistributedObjectAI.__init__(self, air)
SuitPlannerBase.SuitPlannerBase.__init__(self)
self.air = air
self.zoneId = zoneId
self.canonicalZoneId = ZoneUtil.getCanonicalZoneId(zoneId)
if simbase.air.wantCogdominiums:
if not hasattr(self.__class__, 'CogdoPopAdjusted'):
self.__class__.CogdoPopAdjusted = True
for index in xrange(len(self.SuitHoodInfo)):
SuitBuildingGlobals.buildingMinMax[self.zoneId][0] = int(0.5 + self.CogdoPopFactor * SuitBuildingGlobals.buildingMinMax[self.zoneId][0])
SuitBuildingGlobals.buildingMinMax[self.zoneId][1] = int(0.5 + self.CogdoPopFactor * SuitBuildingGlobals.buildingMinMax[self.zoneId][1])
self.hoodInfoIdx = -1
for index in xrange(len(self.SuitHoodInfo)):
currHoodInfo = self.SuitHoodInfo[index]
if currHoodInfo[self.SUIT_HOOD_INFO_ZONE] == self.canonicalZoneId:
self.hoodInfoIdx = index
self.currDesired = None
self.baseNumSuits = (
self.SuitHoodInfo[self.hoodInfoIdx][self.SUIT_HOOD_INFO_MIN] +
self.SuitHoodInfo[self.hoodInfoIdx][self.SUIT_HOOD_INFO_MAX]) / 2
self.targetNumSuitBuildings = SuitBuildingGlobals.buildingMinMax[self.zoneId][0]
if ZoneUtil.isWelcomeValley(self.zoneId):
self.targetNumSuitBuildings = 0
self.pendingBuildingTracks = []
self.pendingBuildingHeights = []
self.suitList = []
self.numFlyInSuits = 0
self.numBuildingSuits = 0
self.numAttemptingTakeover = 0
self.zoneInfo = {}
self.zoneIdToPointMap = None
self.cogHQDoors = []
self.battleList = []
self.battleMgr = BattleManagerAI.BattleManagerAI(self.air)
self.setupDNA()
if self.notify.getDebug():
self.notify.debug('Creating a building manager AI in zone' + str(self.zoneId))
self.buildingMgr = self.air.buildingManagers.get(self.zoneId)
if self.buildingMgr:
(blocks, hqBlocks, gagshopBlocks, petshopBlocks, kartshopBlocks) = self.buildingMgr.getDNABlockLists()
for currBlock in blocks:
bldg = self.buildingMgr.getBuilding(currBlock)
bldg.setSuitPlannerExt(self)
self.dnaStore.resetBlockNumbers()
self.initBuildingsAndPoints()
numSuits = simbase.config.GetInt('suit-count', -1)
if numSuits >= 0:
self.currDesired = numSuits
suitHood = simbase.config.GetInt('suits-only-in-hood', -1)
if suitHood >= 0:
if self.SuitHoodInfo[self.hoodInfoIdx][self.SUIT_HOOD_INFO_ZONE] != suitHood:
self.currDesired = 0
self.suitCountAdjust = 0
def cleanup(self):
taskMgr.remove(self.taskName('sptUpkeepPopulation'))
taskMgr.remove(self.taskName('sptAdjustPopulation'))
for suit in self.suitList:
suit.stopTasks()
if suit.isGenerated():
self.zoneChange(suit, suit.zoneId)
suit.requestDelete()
self.suitList = []
self.numFlyInSuits = 0
self.numBuildingSuits = 0
self.numAttemptingTakeover = 0
def delete(self):
self.cleanup()
DistributedObjectAI.DistributedObjectAI.delete(self)
SuitPlannerBase.SuitPlannerBase.delete(self)
def initBuildingsAndPoints(self):
if not self.buildingMgr:
return
if self.notify.getDebug():
self.notify.debug('Initializing building points')
self.buildingFrontDoors = {}
self.buildingSideDoors = {}
for p in self.frontdoorPointList:
blockNumber = p.getLandmarkBuildingIndex()
if blockNumber < 0:
self.notify.debug('No landmark building for (%s) in zone %s' % (str(p), self.zoneId))
continue
if blockNumber in self.buildingFrontDoors:
self.notify.debug('Multiple front doors for building %s in zone %s' % (blockNumber, self.zoneId))
continue
self.buildingFrontDoors[blockNumber] = p
for p in self.sidedoorPointList:
blockNumber = p.getLandmarkBuildingIndex()
if blockNumber < 0:
self.notify.debug('No landmark building for (%s) in zone %s' % (str(p), self.zoneId))
continue
if blockNumber in self.buildingSideDoors:
self.buildingSideDoors[blockNumber].append(p)
continue
self.buildingSideDoors[blockNumber] = [p]
for bldg in self.buildingMgr.getBuildings():
if isinstance(bldg, HQBuildingAI.HQBuildingAI):
continue
blockNumber = bldg.getBlock()[0]
if blockNumber not in self.buildingFrontDoors:
self.notify.debug('No front door for building %s in zone %s' % (blockNumber, self.zoneId))
if blockNumber not in self.buildingSideDoors:
self.notify.debug('No side door for building %s in zone %s' % (blockNumber, self.zoneId))
def countNumSuitsPerTrack(self, count):
for suit in self.suitList:
if suit.track in count:
count[suit.track] += 1
continue
count[suit.track] = 1
def countNumBuildingsPerTrack(self, count):
if not self.buildingMgr:
return
for building in self.buildingMgr.getBuildings():
if building.isSuitBuilding():
if building.track in count:
count[building.track] += 1
else:
count[building.track] = 1
def countNumBuildingsPerHeight(self, count):
if not self.buildingMgr:
return
for building in self.buildingMgr.getBuildings():
if building.isSuitBuilding():
height = building.numFloors - 1
if height in count:
count[height] += 1
else:
count[height] = 1
def formatNumSuitsPerTrack(self, count):
result = ' '
for (track, num) in count.items():
result += ' %s:%s' % (track, num)
return result[2:]
def calcDesiredNumFlyInSuits(self):
if self.currDesired is not None:
return 0
return self.baseNumSuits + self.suitCountAdjust
def calcDesiredNumBuildingSuits(self):
if self.currDesired is not None:
return self.currDesired
if not self.buildingMgr:
return 0
suitBuildings = self.buildingMgr.getEstablishedSuitBlocks()
return int(len(suitBuildings) * self.SUIT_BUILDING_NUM_SUITS)
def getZoneIdToPointMap(self):
if self.zoneIdToPointMap is not None:
return self.zoneIdToPointMap
self.zoneIdToPointMap = {}
for point in self.streetPointList:
points = self.dnaStore.getAdjacentPoints(point)
i = points.getNumPoints() - 1
while i >= 0:
pi = points.getPointIndex(i)
p = self.pointIndexes[pi]
i -= 1
zoneId = self.dnaStore.getSuitEdgeZone(point.getIndex(), p.getIndex())
if zoneId in self.zoneIdToPointMap:
self.zoneIdToPointMap[zoneId].append(point)
continue
self.zoneIdToPointMap[zoneId] = [point]
return self.zoneIdToPointMap
def getStreetPointsForBuilding(self, blockNumber):
pointList = []
if blockNumber in self.buildingSideDoors:
for doorPoint in self.buildingSideDoors[blockNumber]:
points = self.dnaStore.getAdjacentPoints(doorPoint)
i = points.getNumPoints() - 1
while i >= 0:
pi = points.getPointIndex(i)
point = self.pointIndexes[pi]
if point.getPointType() == DNASuitPoint.STREET_POINT:
pointList.append(point)
i -= 1
if blockNumber in self.buildingFrontDoors:
doorPoint = self.buildingFrontDoors[blockNumber]
points = self.dnaStore.getAdjacentPoints(doorPoint)
i = points.getNumPoints() - 1
while i >= 0:
pi = points.getPointIndex(i)
pointList.append(self.pointIndexes[pi])
i -= 1
return pointList
def createNewSuit(self, blockNumbers, streetPoints, toonBlockTakeover=None,
cogdoTakeover=None, minPathLen=None, maxPathLen=None,
buildingHeight=None, suitLevel=None, suitType=None, suitTrack=None,
suitName=None, skelecog=None, revives=None, waiter=None):
startPoint = None
blockNumber = None
if self.notify.getDebug():
self.notify.debug('Choosing origin from %d+%d possibles.' % (len(streetPoints), len(blockNumbers)))
while startPoint == None and len(blockNumbers) > 0:
bn = random.choice(blockNumbers)
blockNumbers.remove(bn)
if bn in self.buildingSideDoors:
for doorPoint in self.buildingSideDoors[bn]:
points = self.dnaStore.getAdjacentPoints(doorPoint)
i = points.getNumPoints() - 1
while blockNumber == None and i >= 0:
pi = points.getPointIndex(i)
p = self.pointIndexes[pi]
i -= 1
startTime = SuitTimings.fromSuitBuilding
startTime += self.dnaStore.getSuitEdgeTravelTime(doorPoint.getIndex(), pi, self.suitWalkSpeed)
if not self.pointCollision(p, doorPoint, startTime):
startTime = SuitTimings.fromSuitBuilding
startPoint = doorPoint
blockNumber = bn
while startPoint == None and len(streetPoints) > 0:
p = random.choice(streetPoints)
streetPoints.remove(p)
if not self.pointCollision(p, None, SuitTimings.fromSky):
startPoint = p
startTime = SuitTimings.fromSky
continue
if startPoint == None:
return None
newSuit = DistributedSuitAI.DistributedSuitAI(simbase.air, self)
newSuit.startPoint = startPoint
if blockNumber != None:
newSuit.buildingSuit = 1
if suitTrack == None:
suitTrack = self.buildingMgr.getBuildingTrack(blockNumber)
else:
newSuit.flyInSuit = 1
newSuit.attemptingTakeover = self.newSuitShouldAttemptTakeover()
if newSuit.attemptingTakeover:
if suitTrack == None and len(self.pendingBuildingTracks) > 0:
suitTrack = self.pendingBuildingTracks[0]
del self.pendingBuildingTracks[0]
self.pendingBuildingTracks.append(suitTrack)
if buildingHeight == None and len(self.pendingBuildingHeights) > 0:
buildingHeight = self.pendingBuildingHeights[0]
del self.pendingBuildingHeights[0]
self.pendingBuildingHeights.append(buildingHeight)
if suitName is None:
suitDeptIndex, suitTypeIndex, flags = self.air.suitInvasionManager.getInvadingCog()
if flags & IFSkelecog:
skelecog = 1
if flags & IFWaiter:
waiter = True
if flags & IFV2:
revives = 1
if suitDeptIndex is not None:
suitTrack = SuitDNA.suitDepts[suitDeptIndex]
if suitTypeIndex is not None:
suitName = self.air.suitInvasionManager.getSuitName()
else:
suitName = self.defaultSuitName
if (suitType is None) and (suitName is not None):
suitType = SuitDNA.getSuitType(suitName)
suitTrack = SuitDNA.getSuitDept(suitName)
if (suitLevel is None) and (buildingHeight is not None):
suitLevel = self.chooseSuitLevel(self.SuitHoodInfo[self.hoodInfoIdx][self.SUIT_HOOD_INFO_LVL], buildingHeight)
(suitLevel, suitType, suitTrack) = self.pickLevelTypeAndTrack(suitLevel, suitType, suitTrack)
newSuit.setupSuitDNA(suitLevel, suitType, suitTrack)
newSuit.buildingHeight = buildingHeight
gotDestination = self.chooseDestination(newSuit, startTime, toonBlockTakeover = toonBlockTakeover, cogdoTakeover = cogdoTakeover, minPathLen = minPathLen, maxPathLen = maxPathLen)
if not gotDestination:
self.notify.debug("Couldn't get a destination in %d!" % self.zoneId)
newSuit.doNotDeallocateChannel = None
newSuit.delete()
return None
newSuit.initializePath()
self.zoneChange(newSuit, None, newSuit.zoneId)
if skelecog:
newSuit.setSkelecog(skelecog)
newSuit.generateWithRequired(newSuit.zoneId)
if revives is not None:
newSuit.b_setSkeleRevives(revives)
if waiter:
newSuit.b_setWaiter(1)
newSuit.d_setSPDoId(self.doId)
newSuit.moveToNextLeg(None)
self.suitList.append(newSuit)
if newSuit.flyInSuit:
self.numFlyInSuits += 1
if newSuit.buildingSuit:
self.numBuildingSuits += 1
if newSuit.attemptingTakeover:
self.numAttemptingTakeover += 1
return newSuit
def countNumNeededBuildings(self):
if not self.buildingMgr:
return False
numSuitBuildings = len(self.buildingMgr.getSuitBlocks())
if (random.random() * 100) < SuitBuildingGlobals.buildingChance[self.zoneId]:
bmax = SuitBuildingGlobals.buildingMinMax[self.zoneId][1]
if ZoneUtil.isWelcomeValley(self.zoneId):
bmax = 0
numNeeded = bmax - numSuitBuildings
else:
numNeeded = self.targetNumSuitBuildings - numSuitBuildings
return numNeeded
def newSuitShouldAttemptTakeover(self):
if not self.SUITS_ENTER_BUILDINGS:
return False
numNeeded = self.countNumNeededBuildings()
if self.numAttemptingTakeover >= numNeeded:
self.pendingBuildingTracks = []
return False
self.notify.debug('DSP %s is planning a takeover attempt in zone %s' % (self.getDoId(), self.zoneId))
return True
def chooseDestination(self, suit, startTime, toonBlockTakeover=None,
cogdoTakeover=None, minPathLen=None, maxPathLen=None):
possibles = []
backup = []
if toonBlockTakeover is not None:
suit.attemptingTakeover = 1
blockNumber = toonBlockTakeover
if blockNumber in self.buildingFrontDoors:
possibles.append((blockNumber, self.buildingFrontDoors[blockNumber]))
elif suit.attemptingTakeover:
for blockNumber in self.buildingMgr.getToonBlocks():
building = self.buildingMgr.getBuilding(blockNumber)
(extZoneId, intZoneId) = building.getExteriorAndInteriorZoneId()
if not NPCToons.isZoneProtected(intZoneId):
if blockNumber in self.buildingFrontDoors:
possibles.append((blockNumber, self.buildingFrontDoors[blockNumber]))
if cogdoTakeover is None:
if suit.dna.dept in ALLOWED_FO_TRACKS:
cogdoTakeover = random.random() < self.CogdoRatio
elif self.buildingMgr:
for blockNumber in self.buildingMgr.getSuitBlocks():
track = self.buildingMgr.getBuildingTrack(blockNumber)
if (track == suit.track) and (blockNumber in self.buildingSideDoors):
for doorPoint in self.buildingSideDoors[blockNumber]:
possibles.append((blockNumber, doorPoint))
backup = []
for p in self.streetPointList:
backup.append((None, p))
if self.notify.getDebug():
self.notify.debug('Choosing destination point from %s+%s possibles.' % (len(possibles), len(backup)))
if len(possibles) == 0:
possibles = backup
backup = []
if minPathLen is None:
if suit.attemptingTakeover:
minPathLen = self.MIN_TAKEOVER_PATH_LEN
else:
minPathLen = self.MIN_PATH_LEN
if maxPathLen is None:
maxPathLen = self.MAX_PATH_LEN
retryCount = 0
while (len(possibles) > 0) and (retryCount < 50):
p = random.choice(possibles)
possibles.remove(p)
if len(possibles) == 0:
possibles = backup
backup = []
path = self.genPath(suit.startPoint, p[1], minPathLen, maxPathLen)
if path and (not self.pathCollision(path, startTime)):
suit.endPoint = p[1]
suit.minPathLen = minPathLen
suit.maxPathLen = maxPathLen
suit.buildingDestination = p[0]
suit.buildingDestinationIsCogdo = cogdoTakeover
suit.setPath(path)
return 1
retryCount += 1
return 0
def pathCollision(self, path, elapsedTime):
i = 0
pi = path.getPointIndex(i)
point = self.pointIndexes[pi]
adjacentPoint = self.pointIndexes[path.getPointIndex(i + 1)]
while (point.getPointType() == DNASuitPoint.FRONT_DOOR_POINT) or (
point.getPointType() == DNASuitPoint.SIDE_DOOR_POINT):
i += 1
lastPi = pi
pi = path.getPointIndex(i)
adjacentPoint = point
point = self.pointIndexes[pi]
elapsedTime += self.dnaStore.getSuitEdgeTravelTime(lastPi, pi, self.suitWalkSpeed)
result = self.pointCollision(point, adjacentPoint, elapsedTime)
return result
def pointCollision(self, point, adjacentPoint, elapsedTime):
for suit in self.suitList:
if suit.pointInMyPath(point, elapsedTime):
return 1
if adjacentPoint is not None:
return self.battleCollision(point, adjacentPoint)
else:
points = self.dnaStore.getAdjacentPoints(point)
i = points.getNumPoints() - 1
while i >= 0:
pi = points.getPointIndex(i)
p = self.pointIndexes[pi]
i -= 1
if self.battleCollision(point, p):
return 1
return 0
def battleCollision(self, point, adjacentPoint):
zoneId = self.dnaStore.getSuitEdgeZone(point.getIndex(), adjacentPoint.getIndex())
return self.battleMgr.cellHasBattle(zoneId)
def removeSuit(self, suit):
self.zoneChange(suit, suit.zoneId)
if self.suitList.count(suit) > 0:
self.suitList.remove(suit)
if suit.flyInSuit:
self.numFlyInSuits -= 1
if suit.buildingSuit:
self.numBuildingSuits -= 1
if suit.attemptingTakeover:
self.numAttemptingTakeover -= 1
suit.requestDelete()
def countTakeovers(self):
count = 0
for suit in self.suitList:
if suit.attemptingTakeover:
count += 1
return count
def __waitForNextUpkeep(self):
t = random.random() * 2.0 + self.POP_UPKEEP_DELAY
taskMgr.doMethodLater(t, self.upkeepSuitPopulation, self.taskName('sptUpkeepPopulation'))
def __waitForNextAdjust(self):
t = random.random() * 10.0 + self.POP_ADJUST_DELAY
taskMgr.doMethodLater(t, self.adjustSuitPopulation, self.taskName('sptAdjustPopulation'))
def upkeepSuitPopulation(self, task):
targetFlyInNum = self.calcDesiredNumFlyInSuits()
targetFlyInNum = min(targetFlyInNum, self.TOTAL_MAX_SUITS - self.numBuildingSuits)
streetPoints = self.streetPointList[:]
flyInDeficit = ((targetFlyInNum - self.numFlyInSuits) + 3) / 4
while flyInDeficit > 0:
if not self.createNewSuit([], streetPoints):
break
flyInDeficit -= 1
if self.buildingMgr:
suitBuildings = self.buildingMgr.getEstablishedSuitBlocks()
else:
suitBuildings = []
if self.currDesired != None:
targetBuildingNum = max(0, self.currDesired - self.numFlyInSuits)
else:
targetBuildingNum = int(len(suitBuildings) * self.SUIT_BUILDING_NUM_SUITS)
targetBuildingNum += flyInDeficit
targetBuildingNum = min(targetBuildingNum, self.TOTAL_MAX_SUITS - self.numFlyInSuits)
buildingDeficit = ((targetBuildingNum - self.numBuildingSuits) + 3) / 4
while buildingDeficit > 0:
if not self.createNewSuit(suitBuildings, streetPoints):
break
buildingDeficit -= 1
if self.notify.getDebug() and self.currDesired == None:
self.notify.debug('zone %d has %d of %d fly-in and %d of %d building suits.' % (self.zoneId, self.numFlyInSuits, targetFlyInNum, self.numBuildingSuits, targetBuildingNum))
if buildingDeficit != 0:
self.notify.debug('remaining deficit is %d.' % buildingDeficit)
if self.buildingMgr:
suitBuildings = self.buildingMgr.getEstablishedSuitBlocks()
timeoutIndex = min(len(suitBuildings), len(self.SUIT_BUILDING_TIMEOUT) - 1)
timeout = self.SUIT_BUILDING_TIMEOUT[timeoutIndex]
if timeout != None:
timeout *= 3600.0
oldest = None
oldestAge = 0
now = time.time()
for b in suitBuildings:
building = self.buildingMgr.getBuilding(b)
if hasattr(building, 'elevator'):
if building.elevator.fsm.getCurrentState().getName() == 'waitEmpty':
age = now - building.becameSuitTime
if age > oldestAge:
oldest = building
oldestAge = age
if oldestAge > timeout:
self.notify.info('Street %d has %d buildings; reclaiming %0.2f-hour-old building.' % (self.zoneId, len(suitBuildings), oldestAge / 3600.0))
oldest.b_setVictorList([0, 0, 0, 0])
oldest.updateSavedBy(None)
oldest.toonTakeOver()
self.__waitForNextUpkeep()
return Task.done
def adjustSuitPopulation(self, task):
hoodInfo = self.SuitHoodInfo[self.hoodInfoIdx]
if hoodInfo[self.SUIT_HOOD_INFO_MAX] == 0:
self.__waitForNextAdjust()
return Task.done
min = hoodInfo[self.SUIT_HOOD_INFO_MIN]
max = hoodInfo[self.SUIT_HOOD_INFO_MAX]
adjustment = random.choice((-2, -1, -1, 0, 0, 0, 1, 1, 2))
self.suitCountAdjust += adjustment
desiredNum = self.calcDesiredNumFlyInSuits()
if desiredNum < min:
self.suitCountAdjust = min - self.baseNumSuits
elif desiredNum > max:
self.suitCountAdjust = max - self.baseNumSuits
self.__waitForNextAdjust()
return Task.done
def suitTakeOver(self, blockNumber, suitTrack, difficulty, buildingHeight):
if self.pendingBuildingTracks.count(suitTrack) > 0:
self.pendingBuildingTracks.remove(suitTrack)
if self.pendingBuildingHeights.count(buildingHeight) > 0:
self.pendingBuildingHeights.remove(buildingHeight)
building = self.buildingMgr.getBuilding(blockNumber)
if building is None:
return
building.suitTakeOver(suitTrack, difficulty, buildingHeight)
def cogdoTakeOver(self, blockNumber, difficulty, buildingHeight, dept):
if self.pendingBuildingHeights.count(buildingHeight) > 0:
self.pendingBuildingHeights.remove(buildingHeight)
building = self.buildingMgr.getBuilding(blockNumber)
building.cogdoTakeOver(difficulty, buildingHeight, dept)
def recycleBuilding(self):
bmin = SuitBuildingGlobals.buildingMinMax[self.zoneId][0]
current = len(self.buildingMgr.getSuitBlocks())
if (self.targetNumSuitBuildings > bmin) and (current <= self.targetNumSuitBuildings):
self.targetNumSuitBuildings -= 1
self.assignSuitBuildings(1)
def createInitialSuitBuildings(self):
if self.buildingMgr is None:
return
# If we aren't at our minimum number of buildings, let's spawn some!
suitBlockCount = len(self.buildingMgr.getSuitBlocks())
if suitBlockCount < self.targetNumSuitBuildings:
for _ in xrange(self.targetNumSuitBuildings - suitBlockCount):
blockNumber = random.choice(self.buildingMgr.getToonBlocks())
building = self.buildingMgr.getBuilding(blockNumber)
if building is None:
continue
if NPCToons.isZoneProtected(building.getExteriorAndInteriorZoneId()[1]):
continue
suitName = self.air.suitInvasionManager.getInvadingCog()[0]
if suitName is None:
suitName = self.defaultSuitName
suitType = None
suitTrack = None
if suitName is not None:
suitType = SuitDNA.getSuitType(suitName)
suitTrack = SuitDNA.getSuitDept(suitName)
(suitLevel, suitType, suitTrack) = self.pickLevelTypeAndTrack(None, suitType, suitTrack)
building.suitTakeOver(suitTrack, suitLevel, None)
# Save the building manager's state:
self.buildingMgr.save()
def assignInitialSuitBuildings(self):
totalBuildings = 0
targetSuitBuildings = 0
actualSuitBuildings = 0
for sp in self.air.suitPlanners.values():
totalBuildings += len(sp.frontdoorPointList)
targetSuitBuildings += sp.targetNumSuitBuildings
if sp.buildingMgr:
actualSuitBuildings += len(sp.buildingMgr.getSuitBlocks())
wantedSuitBuildings = int((totalBuildings*self.TOTAL_SUIT_BUILDING_PCT) / 100)
self.notify.debug('Want %s out of %s total suit buildings; we currently have %s assigned, %s actual.' % (wantedSuitBuildings, totalBuildings, targetSuitBuildings, actualSuitBuildings))
if actualSuitBuildings > 0:
numReassigned = 0
for sp in self.air.suitPlanners.values():
if sp.buildingMgr:
numBuildings = len(sp.buildingMgr.getSuitBlocks())
else:
numBuildings = 0
if numBuildings > sp.targetNumSuitBuildings:
more = numBuildings - sp.targetNumSuitBuildings
sp.targetNumSuitBuildings += more
targetSuitBuildings += more
numReassigned += more
if numReassigned > 0:
self.notify.debug('Assigned %s buildings where suit buildings already existed.' % numReassigned)
if wantedSuitBuildings > targetSuitBuildings:
additionalBuildings = wantedSuitBuildings - targetSuitBuildings
self.assignSuitBuildings(additionalBuildings)
elif wantedSuitBuildings < targetSuitBuildings:
extraBuildings = targetSuitBuildings - wantedSuitBuildings
self.unassignSuitBuildings(extraBuildings)
def assignSuitBuildings(self, numToAssign):
hoodInfo = self.SuitHoodInfo[:]
totalWeight = self.TOTAL_BWEIGHT
totalWeightPerTrack = self.TOTAL_BWEIGHT_PER_TRACK[:]
totalWeightPerHeight = self.TOTAL_BWEIGHT_PER_HEIGHT[:]
numPerTrack = {
'c': 0,
'l': 0,
'm': 0,
's': 0
}
for sp in self.air.suitPlanners.values():
sp.countNumBuildingsPerTrack(numPerTrack)
numPerTrack['c'] += sp.pendingBuildingTracks.count('c')
numPerTrack['l'] += sp.pendingBuildingTracks.count('l')
numPerTrack['m'] += sp.pendingBuildingTracks.count('m')
numPerTrack['s'] += sp.pendingBuildingTracks.count('s')
numPerHeight = {
0: 0,
1: 0,
2: 0,
3: 0,
4: 0
}
for sp in self.air.suitPlanners.values():
sp.countNumBuildingsPerHeight(numPerHeight)
numPerHeight[0] += sp.pendingBuildingHeights.count(0)
numPerHeight[1] += sp.pendingBuildingHeights.count(1)
numPerHeight[2] += sp.pendingBuildingHeights.count(2)
numPerHeight[3] += sp.pendingBuildingHeights.count(3)
numPerHeight[4] += sp.pendingBuildingHeights.count(4)
while numToAssign > 0:
smallestCount = None
smallestTracks = []
for trackIndex in xrange(4):
if totalWeightPerTrack[trackIndex]:
track = SuitDNA.suitDepts[trackIndex]
count = numPerTrack[track]
if (smallestCount is None) or (count < smallestCount):
smallestTracks = [track]
smallestCount = count
elif count == smallestCount:
smallestTracks.append(track)
if not smallestTracks:
self.notify.info('No more room for buildings, with %s still to assign.' % numToAssign)
return
buildingTrack = random.choice(smallestTracks)
buildingTrackIndex = SuitDNA.suitDepts.index(buildingTrack)
smallestCount = None
smallestHeights = []
for height in xrange(5):
if totalWeightPerHeight[height]:
count = float(numPerHeight[height]) / float(self.BUILDING_HEIGHT_DISTRIBUTION[height])
if (smallestCount is None) or (count < smallestCount):
smallestHeights = [height]
smallestCount = count
elif count == smallestCount:
smallestHeights.append(height)
if not smallestHeights:
self.notify.info('No more room for buildings, with %s still to assign.' % numToAssign)
return
buildingHeight = random.choice(smallestHeights)
self.notify.info('Existing buildings are (%s, %s), choosing from (%s, %s), chose %s, %s.' % (self.formatNumSuitsPerTrack(numPerTrack), self.formatNumSuitsPerTrack(numPerHeight), smallestTracks, smallestHeights, buildingTrack, buildingHeight))
repeat = 1
while repeat and (buildingTrack is not None) and (buildingHeight is not None):
if len(hoodInfo) == 0:
self.notify.warning('No more streets can have suit buildings, with %s buildings unassigned!' % numToAssign)
return
repeat = 0
currHoodInfo = self.chooseStreetWithPreference(hoodInfo, buildingTrackIndex, buildingHeight)
zoneId = currHoodInfo[self.SUIT_HOOD_INFO_ZONE]
if zoneId in self.air.suitPlanners:
sp = self.air.suitPlanners[zoneId]
numTarget = sp.targetNumSuitBuildings
numTotalBuildings = len(sp.frontdoorPointList)
else:
numTarget = 0
numTotalBuildings = 0
if numTarget >= SuitBuildingGlobals.buildingMinMax[self.zoneId][1] or numTarget >= numTotalBuildings:
self.notify.info('Zone %s has enough buildings.' % zoneId)
hoodInfo.remove(currHoodInfo)
weight = currHoodInfo[self.SUIT_HOOD_INFO_BWEIGHT]
tracks = currHoodInfo[self.SUIT_HOOD_INFO_TRACK]
heights = currHoodInfo[self.SUIT_HOOD_INFO_HEIGHTS]
totalWeight -= weight
totalWeightPerTrack[0] -= weight * tracks[0]
totalWeightPerTrack[1] -= weight * tracks[1]
totalWeightPerTrack[2] -= weight * tracks[2]
totalWeightPerTrack[3] -= weight * tracks[3]
totalWeightPerHeight[0] -= weight * heights[0]
totalWeightPerHeight[1] -= weight * heights[1]
totalWeightPerHeight[2] -= weight * heights[2]
totalWeightPerHeight[3] -= weight * heights[3]
totalWeightPerHeight[4] -= weight * heights[4]
if totalWeightPerTrack[buildingTrackIndex] <= 0:
buildingTrack = None
if totalWeightPerHeight[buildingHeight] <= 0:
buildingHeight = None
repeat = 1
if (buildingTrack is not None) and (buildingHeight is not None):
sp.targetNumSuitBuildings += 1
sp.pendingBuildingTracks.append(buildingTrack)
sp.pendingBuildingHeights.append(buildingHeight)
self.notify.info('Assigning building to zone %s, pending tracks = %s, pending heights = %s' % (zoneId, sp.pendingBuildingTracks, sp.pendingBuildingHeights))
numPerTrack[buildingTrack] += 1
numPerHeight[buildingHeight] += 1
numToAssign -= 1
def unassignSuitBuildings(self, numToAssign):
hoodInfo = self.SuitHoodInfo[:]
totalWeight = self.TOTAL_BWEIGHT
while numToAssign > 0:
repeat = 1
while repeat:
if len(hoodInfo) == 0:
self.notify.warning('No more streets can remove suit buildings, with %s buildings too many!' % numToAssign)
return
repeat = 0
currHoodInfo = self.chooseStreetNoPreference(hoodInfo, totalWeight)
zoneId = currHoodInfo[self.SUIT_HOOD_INFO_ZONE]
if zoneId in self.air.suitPlanners:
sp = self.air.suitPlanners[zoneId]
numTarget = sp.targetNumSuitBuildings
numTotalBuildings = len(sp.frontdoorPointList)
else:
numTarget = 0
numTotalBuildings = 0
if numTarget <= SuitBuildingGlobals.buildingMinMax[self.zoneId][0]:
self.notify.info("Zone %s can't remove any more buildings." % zoneId)
hoodInfo.remove(currHoodInfo)
totalWeight -= currHoodInfo[self.SUIT_HOOD_INFO_BWEIGHT]
repeat = 1
self.notify.info('Unassigning building from zone %s.' % zoneId)
sp.targetNumSuitBuildings -= 1
numToAssign -= 1
def chooseStreetNoPreference(self, hoodInfo, totalWeight):
c = random.random() * totalWeight
t = 0
for currHoodInfo in hoodInfo:
weight = currHoodInfo[self.SUIT_HOOD_INFO_BWEIGHT]
t += weight
if c < t:
return currHoodInfo
self.notify.warning('Weighted random choice failed! Total is %s, chose %s' % (t, c))
return random.choice(hoodInfo)
def chooseStreetWithPreference(self, hoodInfo, buildingTrackIndex, buildingHeight):
dist = []
for currHoodInfo in hoodInfo:
weight = currHoodInfo[self.SUIT_HOOD_INFO_BWEIGHT]
thisValue = weight * currHoodInfo[self.SUIT_HOOD_INFO_TRACK][buildingTrackIndex] * currHoodInfo[self.SUIT_HOOD_INFO_HEIGHTS][buildingHeight]
dist.append(thisValue)
totalWeight = sum(dist)
c = random.random() * totalWeight
t = 0
for i in xrange(len(hoodInfo)):
t += dist[i]
if c < t:
return hoodInfo[i]
self.notify.warning('Weighted random choice failed! Total is %s, chose %s' % (t, c))
return random.choice(hoodInfo)
def chooseSuitLevel(self, possibleLevels, buildingHeight):
choices = []
for level in possibleLevels:
(minFloors, maxFloors) = SuitBuildingGlobals.SuitBuildingInfo[level - 1][0]
if buildingHeight >= minFloors - 1 and buildingHeight <= maxFloors - 1:
choices.append(level)
return random.choice(choices)
def initTasks(self):
if self.air.wantCogbuildings:
self.createInitialSuitBuildings()
self.__waitForNextUpkeep()
self.__waitForNextAdjust()
def resyncSuits(self):
for suit in self.suitList:
suit.resync()
def flySuits(self):
for suit in self.suitList:
if suit.pathState == 1:
suit.flyAwayNow()
def requestBattle(self, zoneId, suit, toonId):
self.notify.debug('requestBattle() - zone: %s suit: %s toon: %s' % (zoneId, suit.doId, toonId))
canonicalZoneId = ZoneUtil.getCanonicalZoneId(zoneId)
if canonicalZoneId not in self.battlePosDict:
return 0
toon = self.air.doId2do.get(toonId)
if toon.getBattleId() > 0:
self.notify.warning('We tried to request a battle when the toon was already in battle')
return 0
if toon:
if hasattr(toon, 'doId'):
toon.b_setBattleId(toonId)
pos = self.battlePosDict[canonicalZoneId]
interactivePropTrackBonus = -1
if simbase.config.GetBool('props-buff-battles', True) and canonicalZoneId in self.cellToGagBonusDict:
interactivePropTrackBonus = self.cellToGagBonusDict[canonicalZoneId]
self.battleMgr.newBattle(
zoneId, zoneId, pos, suit, toonId, self.__battleFinished,
self.SuitHoodInfo[self.hoodInfoIdx][self.SUIT_HOOD_INFO_SMAX],
interactivePropTrackBonus)
for currOther in self.zoneInfo[zoneId]:
self.notify.debug('Found suit %s in this new battle zone %s' % (currOther.getDoId(), zoneId))
if currOther != suit:
if currOther.pathState == 1 and currOther.legType == SuitLeg.TWalk:
self.checkForBattle(zoneId, currOther)
return 1
def __battleFinished(self, zoneId):
self.notify.debug('DistSuitPlannerAI: battle in zone ' + str(zoneId) + ' finished')
currBattleIdx = 0
while currBattleIdx < len(self.battleList):
currBattle = self.battleList[currBattleIdx]
if currBattle[0] == zoneId:
self.notify.debug('DistSuitPlannerAI: battle removed')
self.battleList.remove(currBattle)
currBattleIdx = currBattleIdx + 1
def __suitCanJoinBattle(self, zoneId):
battle = self.battleMgr.getBattle(zoneId)
if len(battle.suits) >= 4:
return 0
if battle:
if simbase.config.GetBool('suits-always-join', 0):
return 1
jChanceList = self.SuitHoodInfo[self.hoodInfoIdx][self.SUIT_HOOD_INFO_JCHANCE]
ratioIdx = (len(battle.toons) - battle.numSuitsEver) + 2
if ratioIdx >= 0:
if ratioIdx < len(jChanceList):
if random.randint(0, 99) < jChanceList[ratioIdx]:
return 1
else:
self.notify.warning('__suitCanJoinBattle idx out of range!')
return 1
return 0
def checkForBattle(self, zoneId, suit):
if self.battleMgr.cellHasBattle(zoneId):
if self.__suitCanJoinBattle(zoneId) and self.battleMgr.requestBattleAddSuit(zoneId, suit):
return 1
suit.flyAwayNow()
return 1
else:
return 0
def postBattleResumeCheck(self, suit):
self.notify.debug('DistSuitPlannerAI:postBattleResumeCheck: suit ' + str(suit.getDoId()) + ' is leaving battle')
battleIndex = 0
for currBattle in self.battleList:
if suit.zoneId == currBattle[0]:
self.notify.debug(' battle found' + str(suit.zoneId))
for currPath in currBattle[1]:
for currPathPtSuit in xrange(suit.currWpt, suit.myPath.getNumPoints()):
ptIdx = suit.myPath.getPointIndex(currPathPtSuit)
if self.notify.getDebug():
self.notify.debug(' comparing' + str(ptIdx) + 'with' + str(currPath))
if currPath == ptIdx:
if self.notify.getDebug():
self.notify.debug(' match found, telling' + 'suit to fly')
return 0
battleIndex += 1
pointList = []
for currPathPtSuit in xrange(suit.currWpt, suit.myPath.getNumPoints()):
ptIdx = suit.myPath.getPointIndex(currPathPtSuit)
if self.notify.getDebug():
self.notify.debug(' appending point with index of' + str(ptIdx))
pointList.append(ptIdx)
self.battleList.append([suit.zoneId, pointList])
return 1
def zoneChange(self, suit, oldZone, newZone=None):
if (oldZone in self.zoneInfo) and (suit in self.zoneInfo[oldZone]):
self.zoneInfo[oldZone].remove(suit)
if newZone is not None:
if newZone not in self.zoneInfo:
self.zoneInfo[newZone] = []
self.zoneInfo[newZone].append(suit)
def d_setZoneId(self, zoneId):
self.sendUpdate('setZoneId', [self.getZoneId()])
def getZoneId(self):
return self.zoneId
def suitListQuery(self):
suitIndexList = []
for suit in self.suitList:
suitIndexList.append(SuitDNA.suitHeadTypes.index(suit.dna.name))
self.sendUpdateToAvatarId(self.air.getAvatarIdFromSender(), 'suitListResponse', [suitIndexList])
def buildingListQuery(self):
buildingDict = {}
self.countNumBuildingsPerTrack(buildingDict)
buildingList = [0, 0, 0, 0]
for dept in SuitDNA.suitDepts:
if dept in buildingDict:
buildingList[SuitDNA.suitDepts.index(dept)] = buildingDict[dept]
self.sendUpdateToAvatarId(self.air.getAvatarIdFromSender(), 'buildingListResponse', [buildingList])
def pickLevelTypeAndTrack(self, level=None, type=None, track=None):
if level is None:
level = random.choice(self.SuitHoodInfo[self.hoodInfoIdx][self.SUIT_HOOD_INFO_LVL])
if type is None:
typeChoices = range(max(level - 4, 1), min(level, self.MAX_SUIT_TYPES) + 1)
type = random.choice(typeChoices)
else:
level = min(max(level, type), type + 4)
if track is None:
track = SuitDNA.suitDepts[SuitBattleGlobals.pickFromFreqList(self.SuitHoodInfo[self.hoodInfoIdx][self.SUIT_HOOD_INFO_TRACK])]
self.notify.debug('pickLevelTypeAndTrack: %s %s %s' % (level, type, track))
return (level, type, track)