939 lines
33 KiB
Python
939 lines
33 KiB
Python
import copy
|
|
import random
|
|
from direct.directnotify import DirectNotifyGlobal
|
|
from direct.distributed import DistributedObjectAI
|
|
from direct.distributed.ClockDelta import *
|
|
from direct.fsm import ClassicFSM, State
|
|
from direct.task import Timer
|
|
from toontown.toon import NPCToons
|
|
from otp.ai.AIBaseGlobal import *
|
|
from toontown.ai import ToonBarrier
|
|
from toontown.battle import BattleBase
|
|
from toontown.cogdominium import DistributedCogdoBattleBldgAI
|
|
from toontown.building.ElevatorConstants import *
|
|
from toontown.suit.SuitDNA import SuitDNA
|
|
from toontown.toonbase.ToontownBattleGlobals import *
|
|
from toontown.hood import ZoneUtil
|
|
from toontown.minigame.MinigameGlobals import SafeZones
|
|
from toontown.toon import NPCToons
|
|
from .DistributedCogdoElevatorIntAI import DistributedCogdoElevatorIntAI
|
|
from toontown.cogdominium import CogdoBarrelRoomConsts
|
|
from toontown.cogdominium import CogdoBarrelRoomAI
|
|
from .DistCogdoBoardroomGameAI import DistCogdoBoardroomGameAI
|
|
from toontown.cogdominium.DistCogdoCraneGameAI import DistCogdoCraneGameAI
|
|
from toontown.cogdominium.DistCogdoMazeGameAI import DistCogdoMazeGameAI
|
|
from toontown.cogdominium.DistCogdoFlyingGameAI import DistCogdoFlyingGameAI
|
|
from toontown.cogdominium import CogdoGameConsts
|
|
CogdoGames = {
|
|
'boardroom': DistCogdoBoardroomGameAI,
|
|
'crane': DistCogdoCraneGameAI,
|
|
'maze': DistCogdoMazeGameAI,
|
|
'flying': DistCogdoFlyingGameAI}
|
|
IntGames = set([
|
|
'boardroom',
|
|
'crane',
|
|
'flying',
|
|
'defense'])
|
|
simbase.forcedCogdoGame = config.GetString('cogdo-game', '')
|
|
GameRequests = {}
|
|
|
|
class DistributedCogdoInteriorAI(DistributedObjectAI.DistributedObjectAI):
|
|
|
|
def __init__(self, air, elevator):
|
|
self.air = air
|
|
DistributedObjectAI.DistributedObjectAI.__init__(self, air)
|
|
(self.extZoneId, self.zoneId) = elevator.bldg.getExteriorAndInteriorZoneId()
|
|
self._numFloors = elevator.bldg.planner.numFloors
|
|
self.layout = elevator.bldg._cogdoLayout
|
|
self.avatarExitEvents = []
|
|
self.toons = []
|
|
self.toonSkillPtsGained = {}
|
|
self.toonExp = {}
|
|
self.toonOrigQuests = {}
|
|
self.toonItems = {}
|
|
self.toonOrigMerits = {}
|
|
self.toonMerits = {}
|
|
self.toonParts = {}
|
|
self.helpfulToons = []
|
|
self.shopOwnerNpcId = 0
|
|
npcDesc = NPCToons.zone2NpcDict.get(self.zoneId)
|
|
if npcDesc:
|
|
self.shopOwnerNpcId = npcDesc[0]
|
|
|
|
if not self.shopOwnerNpcId:
|
|
self.notify.warning('No npcs found for current cogdo building')
|
|
|
|
self.currentFloor = 0
|
|
self.bldg = elevator.bldg
|
|
self.elevator = elevator
|
|
self._game = None
|
|
self._CogdoGameRepeat = config.GetBool('cogdo-game-repeat', 0)
|
|
self.suits = []
|
|
self.activeSuits = []
|
|
self.reserveSuits = []
|
|
self.joinedReserves = []
|
|
self.suitsKilled = []
|
|
self.suitsKilledPerFloor = []
|
|
self.battle = None
|
|
self.timer = Timer.Timer()
|
|
self._wantBarrelRoom = config.GetBool('cogdo-want-barrel-room', 0)
|
|
self.barrelRoom = None
|
|
self.responses = {}
|
|
self.ignoreResponses = 0
|
|
self.ignoreElevatorDone = 0
|
|
self.ignoreReserveJoinDone = 0
|
|
self.toonIds = copy.copy(elevator.seats)
|
|
for toonId in self.toonIds:
|
|
if toonId != None:
|
|
self.__addToon(toonId)
|
|
|
|
self.savedByMap = {}
|
|
self.fsm = ClassicFSM.ClassicFSM('DistributedCogdoInteriorAI', [
|
|
State.State('WaitForAllToonsInside', self.enterWaitForAllToonsInside, self.exitWaitForAllToonsInside, [
|
|
'Elevator']),
|
|
State.State('Elevator', self.enterElevator, self.exitElevator, [
|
|
'Game']),
|
|
State.State('Game', self.enterGame, self.exitGame, [
|
|
'Resting',
|
|
'Failed',
|
|
'BattleIntro',
|
|
'Off']),
|
|
State.State('BarrelRoomIntro', self.enterBarrelRoomIntro, self.exitBarrelRoomIntro, [
|
|
'CollectBarrels',
|
|
'Off']),
|
|
State.State('CollectBarrels', self.enterCollectBarrels, self.exitCollectBarrels, [
|
|
'BarrelRoomReward',
|
|
'Off']),
|
|
State.State('BarrelRoomReward', self.enterBarrelRoomReward, self.exitBarrelRoomReward, [
|
|
'Battle',
|
|
'ReservesJoining',
|
|
'BattleIntro',
|
|
'Off']),
|
|
State.State('BattleIntro', self.enterBattleIntro, self.exitBattleIntro, [
|
|
'Battle',
|
|
'ReservesJoining',
|
|
'Off']),
|
|
State.State('Battle', self.enterBattle, self.exitBattle, [
|
|
'ReservesJoining',
|
|
'BattleDone',
|
|
'Off']),
|
|
State.State('ReservesJoining', self.enterReservesJoining, self.exitReservesJoining, [
|
|
'Battle',
|
|
'Off']),
|
|
State.State('BattleDone', self.enterBattleDone, self.exitBattleDone, [
|
|
'Resting',
|
|
'Reward',
|
|
'Off']),
|
|
State.State('Resting', self.enterResting, self.exitResting, [
|
|
'Elevator',
|
|
'Off']),
|
|
State.State('Reward', self.enterReward, self.exitReward, [
|
|
'Off']),
|
|
State.State('Failed', self.enterFailed, self.exitFailed, [
|
|
'Off']),
|
|
State.State('Off', self.enterOff, self.exitOff, [
|
|
'WaitForAllToonsInside'])], 'Off', 'Off', onUndefTransition = ClassicFSM.ClassicFSM.ALLOW)
|
|
self.fsm.enterInitialState()
|
|
safeZone = ZoneUtil.getCanonicalHoodId(self.extZoneId)
|
|
difficulty = SafeZones.index(safeZone)
|
|
self.SOSCard = self.chooseSOSCard(difficulty)
|
|
|
|
def generateWithRequired(self, zoneId):
|
|
self._disCleanupTask = None
|
|
self._sadCleanupTask = None
|
|
DistributedObjectAI.DistributedObjectAI.generateWithRequired(self, zoneId)
|
|
|
|
def delete(self):
|
|
self.ignoreAll()
|
|
self.toons = []
|
|
self.toonIds = []
|
|
self.fsm.requestFinalState()
|
|
del self.fsm
|
|
del self.bldg
|
|
del self.elevator
|
|
self.timer.stop()
|
|
del self.timer
|
|
self._cogdoLayout = None
|
|
self.__cleanupFloorBattle()
|
|
if self.barrelRoom:
|
|
self.barrelRoom.destroy()
|
|
self.barrelRoom = None
|
|
|
|
taskName = self.taskName('deleteInterior')
|
|
taskMgr.remove(taskName)
|
|
if self._disCleanupTask:
|
|
taskMgr.remove(self._disCleanupTask)
|
|
|
|
if self._sadCleanupTask:
|
|
taskMgr.remove(self._sadCleanupTask)
|
|
|
|
DistributedObjectAI.DistributedObjectAI.delete(self)
|
|
|
|
def requestDelete(self):
|
|
if self._game:
|
|
self._game.requestDelete()
|
|
|
|
DistributedObjectAI.DistributedObjectAI.requestDelete(self)
|
|
|
|
def getShopOwnerNpcId(self):
|
|
return self.shopOwnerNpcId
|
|
|
|
def getSOSNpcId(self):
|
|
return self.SOSCard
|
|
|
|
def __handleUnexpectedExit(self, toonId):
|
|
self.notify.warning('toon: %d exited unexpectedly' % toonId)
|
|
self.__removeToon(toonId)
|
|
if self._game:
|
|
self._game.handleToonDisconnected(toonId)
|
|
|
|
if len(self.toons) == 0:
|
|
self.timer.stop()
|
|
if self.fsm.getCurrentState().getName() == 'Resting':
|
|
pass
|
|
elif self.battle == None:
|
|
self.fsm.requestFinalState()
|
|
self._disCleanupTask = taskMgr.doMethodLater(20, self._cleanupAfterLastToonWentDis, self.uniqueName('discleanup'))
|
|
|
|
def _cleanupAfterLastToonWentDis(self, task):
|
|
self._disCleanupTask = None
|
|
self.bldg.deleteCogdoInterior()
|
|
return task.done
|
|
|
|
def _handleToonWentSad(self, toonId):
|
|
self.notify.info('toon: %d went sad' % toonId)
|
|
self.__removeToon(toonId)
|
|
toon = self.air.getDo(toonId)
|
|
if toon:
|
|
self.ignore(toon.getGoneSadMessage())
|
|
|
|
if self._game:
|
|
self._game.handleToonWentSad(toonId)
|
|
|
|
if len(self.toons) == 0:
|
|
self.timer.stop()
|
|
if self.fsm.getCurrentState().getName() == 'Resting':
|
|
pass
|
|
elif self.battle == None:
|
|
self._sadCleanupTask = taskMgr.doMethodLater(20, self._cleanupAfterLastToonWentSad, self.uniqueName('sadcleanup'))
|
|
|
|
def _cleanupAfterLastToonWentSad(self, task):
|
|
self._sadCleanupTask = None
|
|
self.bldg.deleteCogdoInterior()
|
|
return task.done
|
|
|
|
def __addToon(self, toonId):
|
|
if toonId not in self.air.doId2do:
|
|
self.notify.warning('addToon() - no toon for doId: %d' % toonId)
|
|
return
|
|
|
|
event = self.air.getAvatarExitEvent(toonId)
|
|
self.avatarExitEvents.append(event)
|
|
self.accept(event, self.__handleUnexpectedExit, extraArgs = [
|
|
toonId])
|
|
self.toons.append(toonId)
|
|
self.responses[toonId] = 0
|
|
|
|
def __removeToon(self, toonId):
|
|
if self.toons.count(toonId):
|
|
self.toons.remove(toonId)
|
|
|
|
if self.toonIds.count(toonId):
|
|
self.toonIds[self.toonIds.index(toonId)] = None
|
|
|
|
if toonId in self.responses:
|
|
del self.responses[toonId]
|
|
|
|
event = self.air.getAvatarExitEvent(toonId)
|
|
if self.avatarExitEvents.count(event):
|
|
self.avatarExitEvents.remove(event)
|
|
|
|
self.ignore(event)
|
|
|
|
def __resetResponses(self):
|
|
self.responses = {}
|
|
for toon in self.toons:
|
|
self.responses[toon] = 0
|
|
|
|
self.ignoreResponses = 0
|
|
|
|
def __allToonsResponded(self):
|
|
for toon in self.toons:
|
|
if self.responses[toon] == 0:
|
|
return 0
|
|
|
|
self.ignoreResponses = 1
|
|
return 1
|
|
|
|
def getZoneId(self):
|
|
return self.zoneId
|
|
|
|
def getExtZoneId(self):
|
|
return self.extZoneId
|
|
|
|
def getDistBldgDoId(self):
|
|
return self.bldg.getDoId()
|
|
|
|
def getNumFloors(self):
|
|
return self._numFloors
|
|
|
|
def d_setToons(self):
|
|
self.sendUpdate('setToons', self.getToons())
|
|
|
|
def getToons(self):
|
|
sendIds = []
|
|
for toonId in self.toonIds:
|
|
if toonId == None:
|
|
sendIds.append(0)
|
|
else:
|
|
sendIds.append(toonId)
|
|
|
|
return [
|
|
sendIds,
|
|
0]
|
|
|
|
def getDroneCogDNA(self):
|
|
dna = SuitDNA()
|
|
dna.newSuitRandom(level = 2)
|
|
return dna
|
|
|
|
def d_setSuits(self):
|
|
self.sendUpdate('setSuits', self.getSuits())
|
|
|
|
def getSuits(self):
|
|
suitIds = []
|
|
for suit in self.activeSuits:
|
|
suitIds.append(suit.doId)
|
|
|
|
reserveIds = []
|
|
values = []
|
|
for info in self.reserveSuits:
|
|
reserveIds.append(info[0].doId)
|
|
values.append(info[1])
|
|
|
|
return [
|
|
suitIds,
|
|
reserveIds,
|
|
values]
|
|
|
|
def b_setState(self, state):
|
|
self.d_setState(state)
|
|
self.setState(state)
|
|
|
|
def d_setState(self, state):
|
|
stime = globalClock.getRealTime() + BattleBase.SERVER_BUFFER_TIME
|
|
self.sendUpdate('setState', [
|
|
state,
|
|
globalClockDelta.localToNetworkTime(stime)])
|
|
|
|
def setState(self, state):
|
|
self.fsm.request(state)
|
|
|
|
def getState(self):
|
|
return [
|
|
self.fsm.getCurrentState().getName(),
|
|
globalClockDelta.getRealNetworkTime()]
|
|
|
|
def setAvatarJoined(self):
|
|
avId = self.air.getAvatarIdFromSender()
|
|
if self.toons.count(avId) == 0:
|
|
self.air.writeServerEvent('suspicious', avId, 'DistributedCogdoInteriorAI.setAvatarJoined from toon not in %s.' % self.toons)
|
|
self.notify.warning('setAvatarJoined() - av: %d not in list' % avId)
|
|
return
|
|
|
|
if self.fsm.getCurrentState().getName() != 'WaitForAllToonsInside':
|
|
self.air.writeServerEvent('suspicious', avId, 'CogdoInteriorAI.setAvatarJoined: not in wait state')
|
|
return
|
|
|
|
avatar = self.air.doId2do.get(avId)
|
|
if avatar == None:
|
|
self.air.writeServerEvent('suspicious', avId, 'CogdoInteriorAI.setAvatarJoined: avatar not present')
|
|
return
|
|
else:
|
|
self.savedByMap[avId] = (avatar.getName(), avatar.dna.asTuple())
|
|
if avId not in self.responses:
|
|
self.air.writeServerEvent('suspicious', avId, 'CogdoInteriorAI.setAvatarJoined: avId not in responses')
|
|
self.notify.warning('CogdoInteriorAI.setAvatarJoined: avId not in responses')
|
|
return
|
|
|
|
if self.responses[avId] > 0:
|
|
self.air.writeServerEvent('suspicious', avId, 'CogdoInteriorAI.setAvatarJoined: av already responded')
|
|
return
|
|
|
|
self.responses[avId] += 1
|
|
if self.__allToonsResponded():
|
|
self.fsm.request('Elevator')
|
|
|
|
def elevatorDone(self):
|
|
toonId = self.air.getAvatarIdFromSender()
|
|
if self.ignoreResponses == 1:
|
|
return
|
|
elif self.toons.count(toonId) == 0:
|
|
self.air.writeServerEvent('suspicious', toonId, 'CogdoInteriorAI.elevatorDone: toon not in participant list')
|
|
self.notify.warning('elevatorDone() - toon not in toon list: %d' % toonId)
|
|
return
|
|
|
|
if self.fsm.getCurrentState().getName() != 'Elevator':
|
|
self.air.writeServerEvent('suspicious', toonId, 'CogdoInteriorAI.elevatorDone: not in Elevator state')
|
|
return
|
|
|
|
if toonId not in self.responses:
|
|
self.air.writeServerEvent('suspicious', toonId, 'CogdoInteriorAI.elevatorDone: toon not in responses')
|
|
self.notify.warning('CogdoInteriorAI.elevatorDone: avId not in responses')
|
|
return
|
|
|
|
self.responses[toonId] += 1
|
|
if self.__allToonsResponded() and self.ignoreElevatorDone == 0:
|
|
self.b_setState('Game')
|
|
|
|
def reserveJoinDone(self):
|
|
toonId = self.air.getAvatarIdFromSender()
|
|
if self.ignoreResponses == 1:
|
|
return
|
|
elif self.toons.count(toonId) == 0:
|
|
self.air.writeServerEvent('suspicious', toonId, 'CogdoInteriorAI.reserveJoinDone: toon not in participant list')
|
|
self.notify.warning('reserveJoinDone() - toon not in list: %d' % toonId)
|
|
return
|
|
|
|
if self.fsm.getCurrentState().getName() != 'ReservesJoining':
|
|
self.air.writeServerEvent('suspicious', toonId, 'CogdoInteriorAI.reserveJoinDone: not in ReservesJoining state')
|
|
return
|
|
|
|
if toonId not in self.responses:
|
|
self.air.writeServerEvent('suspicious', toonId, 'CogdoInteriorAI.reserveJoinDone: toon not in responses')
|
|
self.notify.warning('CogdoInteriorAI.reserveJoinDone: avId not in responses')
|
|
return
|
|
|
|
self.responses[toonId] += 1
|
|
if self.__allToonsResponded() and self.ignoreReserveJoinDone == 0:
|
|
self.b_setState('Battle')
|
|
|
|
def isBossFloor(self, floorNum):
|
|
if self.layout.hasBossBattle():
|
|
if self.layout.getBossBattleFloor() == floorNum:
|
|
return True
|
|
|
|
return False
|
|
|
|
def isTopFloor(self, floorNum):
|
|
return self.layout.getNumFloors() - 1 == floorNum
|
|
|
|
def enterOff(self):
|
|
return None
|
|
|
|
def exitOff(self):
|
|
return None
|
|
|
|
def enterWaitForAllToonsInside(self):
|
|
self.__resetResponses()
|
|
return None
|
|
|
|
def exitWaitForAllToonsInside(self):
|
|
self.__resetResponses()
|
|
return None
|
|
|
|
def enterElevator(self):
|
|
if self.isBossFloor(self.currentFloor):
|
|
self._populateFloorSuits()
|
|
else:
|
|
self.d_setToons()
|
|
self.__resetResponses()
|
|
if self._wantBarrelRoom:
|
|
if self.barrelRoom:
|
|
self.barrelRoom.reset()
|
|
else:
|
|
self.barrelRoom = CogdoBarrelRoomAI.CogdoBarrelRoomAI(self)
|
|
|
|
self._game = self._createGame()
|
|
if self._game:
|
|
self._game.makeVisible()
|
|
|
|
self.d_setState('Elevator')
|
|
self.timer.startCallback(BattleBase.ELEVATOR_T + ElevatorData[ELEVATOR_NORMAL]['openTime'] + BattleBase.SERVER_BUFFER_TIME, self.__serverElevatorDone)
|
|
return None
|
|
|
|
def _createGame(self):
|
|
game = None
|
|
if not self.isBossFloor(self.currentFloor):
|
|
for toonId in self.toonIds:
|
|
if toonId:
|
|
toon = self.air.getDo(toonId)
|
|
if toon:
|
|
self.accept(toon.getGoneSadMessage(), Functor(self._handleToonWentSad, toonId))
|
|
|
|
forcedGame = simbase.forcedCogdoGame
|
|
diff = None
|
|
pgId = None
|
|
for toonId in self.toonIds:
|
|
if toonId:
|
|
if toonId in GameRequests:
|
|
(forcedGame, keep, diff, pgId) = GameRequests[toonId]
|
|
if not keep:
|
|
GameRequests.pop(toonId)
|
|
|
|
if forcedGame:
|
|
gameCtor = CogdoGames[forcedGame]
|
|
else:
|
|
name = None
|
|
while name is None or name in IntGames:
|
|
name = random.choice(list(CogdoGames.keys()))
|
|
gameCtor = CogdoGames[name]
|
|
game = gameCtor(self.air, self)
|
|
game.setExteriorZone(self.extZoneId)
|
|
game.setDifficultyOverrides(diff, pgId)
|
|
game.generateWithRequired(self.zoneId)
|
|
|
|
return game
|
|
|
|
def __serverElevatorDone(self):
|
|
self.ignoreElevatorDone = 1
|
|
self.b_setState('Game')
|
|
|
|
def exitElevator(self):
|
|
self.timer.stop()
|
|
self.__resetResponses()
|
|
return None
|
|
|
|
def enterGame(self):
|
|
self.notify.info('Entering Maze Game')
|
|
self._gameScore = None
|
|
self._rewardedLaff = {}
|
|
self._penaltyLaff = {}
|
|
self.d_setState('Game')
|
|
self.elevator.d_setFloor(self.currentFloor)
|
|
if self._game:
|
|
self._game.start()
|
|
else:
|
|
self._gameDone()
|
|
|
|
def _populateFloorSuits(self):
|
|
suitHandles = self.bldg.planner.genFloorSuits(self.currentFloor)
|
|
self.suits = suitHandles['activeSuits']
|
|
self.activeSuits = []
|
|
for suit in self.suits:
|
|
self.activeSuits.append(suit)
|
|
|
|
self.reserveSuits = suitHandles['reserveSuits']
|
|
self.d_setToons()
|
|
self.d_setSuits()
|
|
|
|
def _setGameScore(self, score):
|
|
self._gameScore = score
|
|
|
|
def getGameScore(self):
|
|
return self._gameScore
|
|
|
|
def _gameDone(self):
|
|
self.__calcLaff()
|
|
for (toonId, reward) in self._rewardedLaff.items():
|
|
if reward:
|
|
av = self.air.doId2do.get(toonId)
|
|
av.toonUp(reward)
|
|
|
|
for (toonId, penalty) in self._penaltyLaff.items():
|
|
if penalty:
|
|
av = self.air.doId2do.get(toonId)
|
|
if config.GetBool('want-cogdo-maze-no-sad', 1):
|
|
avHp = av.getHp()
|
|
if avHp < 1:
|
|
avHp = 1
|
|
|
|
if penalty >= avHp:
|
|
penalty = avHp - 1
|
|
|
|
if penalty:
|
|
av.takeDamage(penalty, quietly = 0)
|
|
|
|
if self._game and self._game.wasEnded():
|
|
self.b_setState('Resting')
|
|
elif self._game and self._game.isDoorOpen():
|
|
self.b_setState('Resting')
|
|
elif self._game and not self._game.isDoorOpen():
|
|
self.b_setState('Failed')
|
|
else:
|
|
self.b_setState('BattleIntro')
|
|
|
|
def exitGame(self):
|
|
self.sendUpdate('setSOSNpcId', [
|
|
self.SOSCard])
|
|
self.sendUpdate('setFOType', [
|
|
ord(self.bldg.track)])
|
|
|
|
def __calcLaff(self):
|
|
self.notify.debug('__calcLaff()')
|
|
self._rewardedLaff = {}
|
|
self._penaltyLaff = {}
|
|
if self._game:
|
|
score = self.getGameScore()
|
|
if score:
|
|
maxToAward = self._game.getDifficulty() * CogdoGameConsts.LaffRewardRange + CogdoGameConsts.LaffRewardMin
|
|
reward = score * maxToAward
|
|
for toonId in self.toons:
|
|
if self._game.isToonInDoor(toonId):
|
|
self._rewardedLaff[toonId] = reward
|
|
|
|
if self._rewardedLaff:
|
|
self.air.writeServerEvent('CogdoLaffReward', list(self._rewardedLaff.keys()), 'Awarded %s Laff for difficulty %s and score %s' % (reward, self._game.getDifficulty(), score))
|
|
|
|
penalty = self._game.getDifficulty() * CogdoGameConsts.LaffPenalty
|
|
for toonId in self.toons:
|
|
if not self._game.isToonInDoor(toonId):
|
|
self._penaltyLaff[toonId] = penalty
|
|
|
|
if self._penaltyLaff:
|
|
self.air.writeServerEvent('CogdoLaffPenalty', list(self._penaltyLaff.keys()), 'Penalized %s Laff for difficulty %s (did not reach exit)' % (penalty, self._game.getDifficulty()))
|
|
|
|
def toonBarrelRoomIntroDone(self):
|
|
avId = self.air.getAvatarIdFromSender()
|
|
if self.fsm.getCurrentState().getName() != 'BarrelRoomIntro':
|
|
self.air.writeServerEvent('suspicious', avId, 'CogdoInteriorAI.toonBarrelRoomIntroDone: not in BarrelRoomIntro state')
|
|
return
|
|
|
|
if avId not in self.responses:
|
|
self.air.writeServerEvent('suspicious', avId, 'CogdoInteriorAI.toonBarrelRoomIntroDone: unknown avId')
|
|
return
|
|
|
|
if hasattr(self, 'brBarrier'):
|
|
self.brBarrier.clear(avId)
|
|
else:
|
|
self.notify.warning('toonBarrelRoomIntroDone from %s in invalid state' % avId)
|
|
|
|
def __brIntroDone(self, clearedAvIds = []):
|
|
self.b_setState('CollectBarrels')
|
|
|
|
def enterBarrelRoomIntro(self):
|
|
if not self._wantBarrelRoom:
|
|
pass
|
|
if self._wantBarrelRoom and not self.isBossFloor(self.currentFloor):
|
|
self.barrelRoom.setScore(1.0)
|
|
self.brBarrier = ToonBarrier.ToonBarrier('waitBrIntroDone', self.uniqueName('waitBrIntroDone'), self.toons, CogdoBarrelRoomConsts.BarrelRoomIntroTimeout, doneFunc = self.__brIntroDone)
|
|
else:
|
|
self.__brIntroDone()
|
|
|
|
def exitBarrelRoomIntro(self):
|
|
if hasattr(self, 'brBarrier'):
|
|
self.brBarrier.cleanup()
|
|
del self.brBarrier
|
|
|
|
def __endCollectBarrels(self):
|
|
if len(self.toons) > 0:
|
|
self.notify.info('%d toons in barrel room.' % len(self.toons))
|
|
self.b_setState('BarrelRoomReward')
|
|
else:
|
|
self.notify.warning('0 toons in barrel room.')
|
|
self.bldg.deleteCogdoInterior()
|
|
|
|
def toonLeftBarrelRoom(self):
|
|
avId = self.air.getAvatarIdFromSender()
|
|
self.notify.info('avId=%s left the barrel room via teleport' % avId)
|
|
if self.fsm.getCurrentState().getName() != 'CollectBarrels':
|
|
self.air.writeServerEvent('suspicious', avId, 'CogdoInteriorAI.toonLeftBarrelRoom called outside of CollectBarrels state')
|
|
return
|
|
|
|
if avId not in self.responses:
|
|
self.air.writeServerEvent('suspicious', avId, 'CogdoInteriorAI.toonLeftBarrelRoom: unknown avId')
|
|
return
|
|
|
|
self.__removeToon(avId)
|
|
self.notify.info('%d toon(s) remaining in barrel room.' % len(self.toons))
|
|
if len(self.toons) == 0:
|
|
self.notify.warning('0 toons in barrel room.')
|
|
self.bldg.deleteCogdoInterior()
|
|
|
|
def enterCollectBarrels(self):
|
|
if self._wantBarrelRoom and not self.isBossFloor(self.currentFloor):
|
|
self.acceptOnce(self.barrelRoom.collectionDoneEvent, self.__endCollectBarrels)
|
|
self.barrelRoom.activate()
|
|
else:
|
|
self.__endCollectBarrels()
|
|
|
|
def exitCollectBarrels(self):
|
|
if self.barrelRoom:
|
|
self.ignore(self.barrelRoom.collectionDoneEvent)
|
|
self.barrelRoom.deactivate()
|
|
|
|
def toonBarrelRoomRewardDone(self):
|
|
avId = self.air.getAvatarIdFromSender()
|
|
if self.fsm.getCurrentState().getName() != 'BarrelRoomReward':
|
|
self.air.writeServerEvent('suspicious', avId, 'CogdoInteriorAI.toonBarrelRoomIntroDone: not in BarrelRoomReward state')
|
|
return
|
|
|
|
if avId not in self.responses:
|
|
self.air.writeServerEvent('suspicious', avId, 'CogdoInteriorAI.toonBarrelRoomRewardDone: unknown avId')
|
|
return
|
|
|
|
if hasattr(self, 'brBarrier'):
|
|
self.brBarrier.clear(avId)
|
|
else:
|
|
self.notify.warning('toonBarrelRoomRewardDone from %s in invalid state' % avId)
|
|
|
|
def __brRewardDone(self, clearedAvIds = []):
|
|
if len(self.toons) > 0:
|
|
if not self.isBossFloor(self.currentFloor):
|
|
self._populateFloorSuits()
|
|
self.b_setState('Battle')
|
|
else:
|
|
self.b_setState('BattleIntro')
|
|
else:
|
|
self.notify.warning('0 toons in barrel room.')
|
|
self.bldg.deleteCogdoInterior()
|
|
|
|
def enterBarrelRoomReward(self):
|
|
if self._wantBarrelRoom and not self.isBossFloor(self.currentFloor):
|
|
self.sendUpdate('setBarrelRoomReward', self.barrelRoom.results)
|
|
self.brBarrier = ToonBarrier.ToonBarrier('waitBrRewardDone', self.uniqueName('waitBrRewardDone'), self.toons, CogdoBarrelRoomConsts.RewardUiTime + 5.0, doneFunc = self.__brRewardDone)
|
|
else:
|
|
self.__brRewardDone()
|
|
|
|
def exitBarrelRoomReward(self):
|
|
if hasattr(self, 'brBarrier'):
|
|
self.brBarrier.cleanup()
|
|
del self.brBarrier
|
|
|
|
def __createFloorBattle(self):
|
|
if self.isBossFloor(self.currentFloor):
|
|
self.notify.info('%d toon(s) in boss battle' % len(self.toons))
|
|
bossBattle = 1
|
|
else:
|
|
self.notify.info('%d toon(s) in barrel battle' % len(self.toons))
|
|
bossBattle = 0
|
|
self.battle = DistributedCogdoBattleBldgAI.DistributedCogdoBattleBldgAI(self.air, self.zoneId, self.__handleRoundDone, self.__handleBattleDone, bossBattle = bossBattle)
|
|
self.battle.suitsKilled = self.suitsKilled
|
|
self.battle.suitsKilledPerFloor = self.suitsKilledPerFloor
|
|
self.battle.battleCalc.toonSkillPtsGained = self.toonSkillPtsGained
|
|
self.battle.toonExp = self.toonExp
|
|
self.battle.toonOrigQuests = self.toonOrigQuests
|
|
self.battle.toonItems = self.toonItems
|
|
self.battle.toonOrigMerits = self.toonOrigMerits
|
|
self.battle.toonMerits = self.toonMerits
|
|
self.battle.toonParts = self.toonParts
|
|
self.battle.helpfulToons = self.helpfulToons
|
|
self.battle.setInitialMembers(self.toons, self.suits)
|
|
self.battle.generateWithRequired(self.zoneId)
|
|
mult = getCreditMultiplier(self.currentFloor)
|
|
if self.air.suitInvasionManager.getInvading():
|
|
mult *= getInvasionMultiplier()
|
|
|
|
self.battle.battleCalc.setSkillCreditMultiplier(mult)
|
|
|
|
def __cleanupFloorBattle(self):
|
|
for suit in self.suits:
|
|
self.notify.debug('cleaning up floor suit: %d' % suit.doId)
|
|
if suit.isDeleted():
|
|
self.notify.debug('whoops, suit %d is deleted.' % suit.doId)
|
|
else:
|
|
suit.requestDelete()
|
|
|
|
self.suits = []
|
|
self.reserveSuits = []
|
|
self.activeSuits = []
|
|
if self.battle != None:
|
|
self.battle.requestDelete()
|
|
|
|
self.battle = None
|
|
|
|
def __handleRoundDone(self, toonIds, totalHp, deadSuits):
|
|
totalMaxHp = 0
|
|
for suit in self.suits:
|
|
totalMaxHp += suit.maxHP
|
|
|
|
for suit in deadSuits:
|
|
self.activeSuits.remove(suit)
|
|
|
|
if len(self.reserveSuits) > 0 and len(self.activeSuits) < 4:
|
|
self.joinedReserves = []
|
|
hpPercent = 100 - (totalHp / totalMaxHp) * 100.0
|
|
for info in self.reserveSuits:
|
|
if info[1] <= hpPercent and len(self.activeSuits) < 4:
|
|
self.suits.append(info[0])
|
|
self.activeSuits.append(info[0])
|
|
self.joinedReserves.append(info)
|
|
|
|
for info in self.joinedReserves:
|
|
self.reserveSuits.remove(info)
|
|
|
|
if len(self.joinedReserves) > 0:
|
|
self.fsm.request('ReservesJoining')
|
|
self.d_setSuits()
|
|
return
|
|
|
|
if len(self.activeSuits) == 0:
|
|
self.fsm.request('BattleDone', [
|
|
toonIds])
|
|
else:
|
|
self.battle.resume()
|
|
|
|
def __handleBattleDone(self, zoneId, toonIds):
|
|
if len(toonIds) == 0:
|
|
self.notify.info('handleBattleDone() - last toon gone')
|
|
taskName = self.taskName('deleteInterior')
|
|
taskMgr.doMethodLater(10, self.__doDeleteInterior, taskName)
|
|
elif self.isTopFloor(self.currentFloor):
|
|
self.setState('Reward')
|
|
else:
|
|
self.b_setState('Resting')
|
|
|
|
def __doDeleteInterior(self, task):
|
|
self.bldg.deleteCogdoInterior()
|
|
|
|
def enterBattleIntro(self):
|
|
timeLeft = 7.0
|
|
self._battleIntroTaskName = self.taskName('BattleIntro')
|
|
taskMgr.doMethodLater(timeLeft, self._battleIntroDone, self._battleIntroTaskName)
|
|
|
|
def _battleIntroDone(self, task):
|
|
self.b_setState('Battle')
|
|
return task.done
|
|
|
|
def exitBattleIntro(self):
|
|
taskMgr.remove(self._battleIntroTaskName)
|
|
self._battleIntroTaskName = None
|
|
|
|
def enterBattle(self):
|
|
if self.battle == None:
|
|
self.__createFloorBattle()
|
|
|
|
def exitBattle(self):
|
|
return None
|
|
|
|
def enterReservesJoining(self):
|
|
self.__resetResponses()
|
|
self.timer.startCallback(ElevatorData[ELEVATOR_NORMAL]['openTime'] + SUIT_HOLD_ELEVATOR_TIME + BattleBase.SERVER_BUFFER_TIME, self.__serverReserveJoinDone)
|
|
return None
|
|
|
|
def __serverReserveJoinDone(self):
|
|
self.ignoreReserveJoinDone = 1
|
|
self.b_setState('Battle')
|
|
|
|
def exitReservesJoining(self):
|
|
self.timer.stop()
|
|
self.__resetResponses()
|
|
for info in self.joinedReserves:
|
|
self.battle.suitRequestJoin(info[0])
|
|
|
|
self.battle.resume()
|
|
self.joinedReserves = []
|
|
return None
|
|
|
|
def enterBattleDone(self, toonIds):
|
|
if len(toonIds) != len(self.toons):
|
|
deadToons = []
|
|
for toon in self.toons:
|
|
if toonIds.count(toon) == 0:
|
|
deadToons.append(toon)
|
|
|
|
for toon in deadToons:
|
|
self.__removeToon(toon)
|
|
|
|
self.d_setToons()
|
|
if len(self.toons) == 0:
|
|
self.bldg.deleteCogdoInterior()
|
|
elif self.isTopFloor(self.currentFloor):
|
|
self.notify.info('%d Toon(s) beat the executive suite building' % len(self.toons))
|
|
self.battle.resume(self.currentFloor, topFloor = 1)
|
|
else:
|
|
self.battle.resume(self.currentFloor, topFloor = 0)
|
|
return None
|
|
|
|
def exitBattleDone(self):
|
|
self.__cleanupFloorBattle()
|
|
self.d_setSuits()
|
|
return None
|
|
|
|
def __handleEnterElevator(self):
|
|
self.fsm.request('Elevator')
|
|
|
|
def enterResting(self):
|
|
if self._game:
|
|
self._game.requestDelete()
|
|
self._game = None
|
|
for toonId in self.toonIds:
|
|
if toonId:
|
|
toon = self.air.getDo(toonId)
|
|
if toon:
|
|
self.ignore(toon.getGoneSadMessage())
|
|
|
|
self.handleAllAboard()
|
|
|
|
def handleAllAboard(self, seats = None):
|
|
if seats == None:
|
|
seats = copy.copy(self.toonIds)
|
|
|
|
if not hasattr(self, 'fsm'):
|
|
return None
|
|
|
|
numOfEmptySeats = seats.count(None)
|
|
if numOfEmptySeats == 4:
|
|
self.bldg.deleteCogdoInterior()
|
|
return None
|
|
elif numOfEmptySeats >= 0 and numOfEmptySeats <= 3:
|
|
pass
|
|
else:
|
|
self.error('Bad number of empty seats: %s' % numOfEmptySeats)
|
|
for toon in self.toons:
|
|
if seats.count(toon) == 0:
|
|
self.__removeToon(toon)
|
|
|
|
self.toonIds = copy.copy(seats)
|
|
self.toons = []
|
|
for toonId in self.toonIds:
|
|
if toonId != None:
|
|
self.toons.append(toonId)
|
|
|
|
self.d_setToons()
|
|
if not self._CogdoGameRepeat:
|
|
self.currentFloor += 1
|
|
|
|
self.fsm.request('Elevator')
|
|
|
|
def exitResting(self):
|
|
return None
|
|
|
|
def enterReward(self):
|
|
victors = self.toonIds[:]
|
|
savedBy = []
|
|
for v in victors:
|
|
tuple = self.savedByMap.get(v)
|
|
if tuple:
|
|
savedBy.append([
|
|
v,
|
|
tuple[0],
|
|
tuple[1]])
|
|
toon = self.air.doId2do.get(v)
|
|
if toon:
|
|
self.notify.info('Reward State: toonId:%d laff:%d/%d get ready for the victors to come outside' % (toon.doId, toon.hp, toon.maxHp))
|
|
if not toon.attemptAddNPCFriend(self.SOSCard, numCalls = 1):
|
|
self.notify.info('%s.unable to add NPCFriend %s to %s.' % (self.doId, self.SOSCard, v))
|
|
|
|
self.bldg.fsm.request('waitForVictorsFromCogdo', [
|
|
victors,
|
|
savedBy])
|
|
self.d_setState('Reward')
|
|
return None
|
|
|
|
def exitReward(self):
|
|
return None
|
|
|
|
def enterFailed(self):
|
|
victors = self.toonIds[:]
|
|
savedBy = []
|
|
anyVictors = victors.count(None) < 4
|
|
if anyVictors:
|
|
self.bldg.fsm.request('waitForVictorsFromCogdo', [
|
|
victors,
|
|
savedBy])
|
|
|
|
def exitFailed(self):
|
|
return None
|
|
|
|
def chooseSOSCard(self, difficulty):
|
|
if difficulty < 0 or difficulty > 5:
|
|
return None
|
|
|
|
if difficulty <= 1:
|
|
card = random.choice(NPCToons.npcFriendsMinMaxStars(0, 1))
|
|
elif difficulty <= 3:
|
|
card = random.choice(NPCToons.npcFriendsMinMaxStars(1, 1))
|
|
else:
|
|
card = random.choice(NPCToons.npcFriendsMinMaxStars(2, 2))
|
|
return card
|