cogdo: stuff

astron/dclass/toon.dc

@@ -1693,72 +1693,6 @@ dclass DistCogdoFlyingGame : DistCogdoGame {
 dclass DistCogdoBoardroomGame : DistCogdoLevelGame {
 };
 
-dclass DistCogdoCraneGame : DistCogdoLevelGame {
-};
-
-dclass DistCogdoCrane : DistributedObject {
-  setCraneGameId(uint32) required broadcast ram;
-  setIndex(uint8) required broadcast ram;
-  setState(char, uint32) broadcast ram;
-  clearSmoothing(int8) broadcast clsend;
-  setCablePos(uint8, int16/100, uint16%360/100, LinkPosition [3], int16) broadcast clsend;
-};
-
-dclass DistCogdoCraneObject : DistributedObject {
-  setCraneGameId(uint32) required broadcast ram;
-  setObjectState(char, uint32, uint32) broadcast ram;
-  requestGrab() airecv clsend;
-  rejectGrab();
-  requestDrop() airecv clsend;
-  hitFloor() clsend;
-  requestFree(int16/10, int16/10, int16/10, uint16%360/100) airecv clsend;
-  hitBoss(uint16/255) airecv clsend;
-  setX(int16/10) broadcast ram clsend airecv;
-  setY(int16/10) broadcast ram clsend airecv;
-  setZ(int16/10) broadcast ram clsend airecv;
-  setH(int16%360/10) broadcast ram clsend airecv;
-  setP(int16%360/10) broadcast ram clsend airecv;
-  setR(int16%360/10) broadcast ram clsend airecv;
-  setPos : setX, setY, setZ;
-  setHpr : setH, setP, setR;
-  setPosHpr : setX, setY, setZ, setH, setP, setR;
-  setXY : setX, setY;
-  setXZ : setX, setZ;
-  setXYH : setX, setY, setH;
-  setXYZH : setX, setY, setZ, setH;
-  setComponentL(uint64) broadcast ram clsend airecv;
-  setComponentX(int16/10) broadcast ram clsend airecv;
-  setComponentY(int16/10) broadcast ram clsend airecv;
-  setComponentZ(int16/10) broadcast ram clsend airecv;
-  setComponentH(int16%360/10) broadcast ram clsend airecv;
-  setComponentP(int16%360/10) broadcast ram clsend airecv;
-  setComponentR(int16%360/10) broadcast ram clsend airecv;
-  setComponentT(int16) broadcast ram clsend airecv;
-  setSmStop : setComponentT;
-  setSmH : setComponentH, setComponentT;
-  setSmZ : setComponentZ, setComponentT;
-  setSmXY : setComponentX, setComponentY, setComponentT;
-  setSmXZ : setComponentX, setComponentZ, setComponentT;
-  setSmPos : setComponentX, setComponentY, setComponentZ, setComponentT;
-  setSmHpr : setComponentH, setComponentP, setComponentR, setComponentT;
-  setSmXYH : setComponentX, setComponentY, setComponentH, setComponentT;
-  setSmXYZH : setComponentX, setComponentY, setComponentZ, setComponentH, setComponentT;
-  setSmPosHpr : setComponentX, setComponentY, setComponentZ, setComponentH, setComponentP, setComponentR, setComponentT;
-  setSmPosHprL : setComponentL, setComponentX, setComponentY, setComponentZ, setComponentH, setComponentP, setComponentR, setComponentT;
-  clearSmoothing(int8) broadcast clsend;
-};
-
-dclass DistCogdoCraneMoneyBag : DistCogdoCraneObject {
-  setIndex(uint8) required broadcast ram;
-  requestInitial() airecv clsend;
-};
-
-dclass DistCogdoCraneCog : DistributedObject {
-  setGameId(uint32) required broadcast ram;
-  setDNAString(blob) required broadcast ram;
-  setSpawnInfo(uint8, int16) required broadcast ram;
-};
-
 dclass DistributedHQInterior : DistributedObject {
   setZoneIdAndBlock(uint32, uint16) required broadcast ram;
   setLeaderBoard(blob) required broadcast ram;

config/general.prc

@@ -108,6 +108,11 @@ want-resistance-dance #f
 # Cog battles:
 base-xp-multiplier 1.0
 
+# Cog Dominiums
+want-emblems #t
+cogdo-want-barrel-room #t
+want-lawbot-cogdo #t
+
 # Cog buildings:
 want-cogbuildings #t
 

otp/distributed/DCClassImports.py

@@ -2,7 +2,7 @@
 from pandac.PandaModules import *
 
 
-hashVal = 1165841663
+hashVal = 2177730225L
 
 
 from toontown.coghq import DistributedCashbotBossSafe, DistributedCashbotBossCrane, DistributedBattleFactory, DistributedCashbotBossTreasure, DistributedCogHQDoor, DistributedSellbotHQDoor, DistributedFactoryElevatorExt, DistributedMintElevatorExt, DistributedLawOfficeElevatorExt, DistributedLawOfficeElevatorInt, LobbyManager, DistributedMegaCorp, DistributedFactory, DistributedLawOffice, DistributedLawOfficeFloor, DistributedLift, DistributedDoorEntity, DistributedSwitch, DistributedButton, DistributedTrigger, DistributedCrushableEntity, DistributedCrusherEntity, DistributedStomper, DistributedStomperPair, DistributedLaserField, DistributedGolfGreenGame, DistributedSecurityCamera, DistributedMover, DistributedElevatorMarker, DistributedBarrelBase, DistributedGagBarrel, DistributedBeanBarrel, DistributedHealBarrel, DistributedGrid, ActiveCell, DirectionalCell, CrusherCell, DistributedCrate, DistributedSinkingPlatform, BattleBlocker, DistributedMint, DistributedMintRoom, DistributedMintBattle, DistributedStage, DistributedStageRoom, DistributedStageBattle, DistributedLawbotBossGavel, DistributedLawbotCannon, DistributedLawbotChair, DistributedCogKart, DistributedCountryClub, DistributedCountryClubRoom, DistributedMoleField, DistributedCountryClubBattle, DistributedMaze, DistributedFoodBelt, DistributedBanquetTable, DistributedGolfSpot

toontown/cogdominium/CogdoBarrelRoom.py

@@ -37,8 +37,6 @@ class CogdoBarrelRoom:
         self.model.setPos(*CogdoBarrelRoomConsts.BarrelRoomModelPos)
         self.model.reparentTo(render)
         self.model.stash()
-        self.dummyElevInNode = self.model.attachNewNode('elevator-in')
-        self.dummyElevInNode.hide()
         self.entranceNode = self.model.attachNewNode('door-entrance')
         self.entranceNode.setPos(0, -65, 0)
         self.nearBattleNode = self.model.attachNewNode('near-battle')
@@ -49,6 +47,11 @@ class CogdoBarrelRoom:
         self.fog = Fog('barrel-room-fog')
         self.fog.setColor(CogdoBarrelRoomConsts.BarrelRoomFogColor)
         self.fog.setLinearRange(*CogdoBarrelRoomConsts.BarrelRoomFogLinearRange)
+        self.brBarrel = render.attachNewNode('@@CogdoBarrels')
+        for i in range(len(CogdoBarrelRoomConsts.BarrelProps)):
+            self.bPath = self.brBarrel.attachNewNode('%s%s'% (CogdoBarrelRoomConsts.BarrelPathName, i))
+            self.bPath.setPos(CogdoBarrelRoomConsts.BarrelProps[i]['pos'])
+            self.bPath.setH(CogdoBarrelRoomConsts.BarrelProps[i]['heading'])
         self._isLoaded = True
 
     def unload(self):
@@ -61,6 +64,7 @@ class CogdoBarrelRoom:
         if self.rewardUi:
             self.rewardUi.destroy()
             self.rewardUi = None
+        if hasattr(self, 'fog'):
             if self.fog:
                 render.setFogOff()
                 del self.fog
@@ -75,6 +79,7 @@ class CogdoBarrelRoom:
     def show(self):
         if not self.cogdoBarrelsNode:
             self.cogdoBarrelsNode = render.find('**/@@CogdoBarrels')
+            if not self.cogdoBarrelsNode.isEmpty():
                 self.cogdoBarrelsNode.reparentTo(self.model)
                 self.cogdoBarrelsNode.unstash()
         self.defaultFar = base.camLens.getFar()
@@ -85,7 +90,7 @@ class CogdoBarrelRoom:
 
     def hide(self):
         self.model.stash()
-        render.setFogOff()
+        #render.setFogOff()
         if self.defaultFar is not None:
             base.camLens.setFar(self.defaultFar)
         return
@@ -103,11 +108,11 @@ class CogdoBarrelRoom:
         self.timer.stash()
 
     def placeToonsAtEntrance(self, toons):
-        for i in xrange(len(toons)):
+        for i in range(len(toons)):
             toons[i].setPosHpr(self.entranceNode, *CogdoBarrelRoomConsts.BarrelRoomPlayerSpawnPoints[i])
 
     def placeToonsNearBattle(self, toons):
-        for i in xrange(len(toons)):
+        for i in range(len(toons)):
             toons[i].setPosHpr(self.nearBattleNode, *CogdoBarrelRoomConsts.BarrelRoomPlayerSpawnPoints[i])
 
     def showBattleAreaLight(self, visible = True):
@@ -158,10 +163,10 @@ class CogdoBarrelRoom:
         track = Sequence(Func(camera.reparentTo, render), Func(camera.setPosHpr, self.model, 0, 0, 11.0, 0, -14, 0), Func(self.showBattleAreaLight, False), name=trackName)
         return (track, trackName)
 
-    def showRewardUi(self, results, callback = None):
+    def showRewardUi(self, callback = None):
         track, trackName = self.__rewardCamera()
         if CogdoBarrelRoomConsts.ShowRewardUI:
-            self.rewardUi.setRewards(results)
+            self.rewardUi.setRewards()
             self.rewardUi.unstash()
         taskMgr.doMethodLater(CogdoBarrelRoomConsts.RewardUiTime, self.__rewardUiTimeout, self.rewardUiTaskName, extraArgs=[callback])
         return (track, trackName)

toontown/cogdominium/CogdoBarrelRoomConsts.py

@@ -1,9 +1,9 @@
 from pandac.PandaModules import *
 CollectionTime = 30
-BarrelRoomIntroTimeout = 15.0
+BarrelRoomIntroTimeout = 12.0
 RewardUiTime = 5.0
-EndWithAllBarrelsCollected = False
+EndWithAllBarrelsCollected = True
-ShowRewardUI = False
+ShowRewardUI = True
 AllBarrelsCollectedTime = 5.0
 ToonUp = (2, 4)
 BarrelProps = [{'pos': (-10, -66, 0),
@@ -26,7 +26,7 @@ BarrelProps = [{'pos': (-10, -66, 0),
   'heading': 141},
  {'pos': (10, -14.4, 0),
   'heading': 2}]
-StomperProps = [{'path': '**/stomper_GRP_01/stomper_cylinder_01',
+StomperProps = [{'path': '**/stomper_GRP_01/stomper_cylinder_034',
   'motion': 'up'},
  {'path': '**/stomper_GRP_02/stomper_cylinder_034',
   'motion': 'down'},
@@ -55,6 +55,7 @@ StomperSound = 'phase_9/audio/sfx/CHQ_FACT_stomper_raise.ogg'
 MaxToons = 4
 BarrelRoomModel = 'phase_5/models/cogdominium/tt_m_ara_cbr_barrelRoom'
 BarrelRoomModelPos = (0, 0, 0)
+BarrelRoomElevatorInPath = '**/elevatorIn_locator'
 BarrelRoomElevatorOutPath = '**/elevatorOut_locator'
 BarrelRoomPlayerSpawnPoints = [(-4,
   0,
@@ -83,6 +84,7 @@ BarrelRoomPlayerSpawnPoints = [(-4,
 BarrelRoomCameraFar = 525.0
 BarrelRoomFogColor = Vec4(0.65, 0.21, 0, 1.0)
 BarrelRoomFogLinearRange = (0.0, 800.0)
+BarrelPathName = 'CogdoBarrel_'
 BarrelModel = 'phase_5/models/cogdominium/tt_m_ara_cbr_laughBarrel'
 BarrelModelScale = 1.0
 BarrelCollParams = (0,
@@ -91,6 +93,8 @@ BarrelCollParams = (0,
  2.0)
 BarrelBumpSound = 'phase_4/audio/sfx/Golf_Hit_Barrier_2.ogg'
 BarrelGrabSound = 'phase_4/audio/sfx/SZ_DD_treasure.ogg'
+BarrelAvailableTexture = 'phase_5/maps/tt_t_ara_cbr_Barrel_notUsed.jpg'
+BarrelUsedTexture = 'phase_5/maps/tt_t_ara_cbr_Barrel_Used.jpg'
 StateHidden, StateAvailable, StateUsed, StateCrushed = range(4)
 
 def numBarrels():

toontown/cogdominium/CogdoBarrelRoomMovies.py

@@ -0,0 +1,118 @@
+from pandac.PandaModules import NodePath, Point3, PlaneNode, TextNode
+from direct.interval.IntervalGlobal import *
+from direct.showbase.ShowBase import Plane
+from direct.directnotify import DirectNotifyGlobal
+from direct.showbase.RandomNumGen import RandomNumGen
+from direct.interval.MetaInterval import Sequence, Parallel
+from direct.interval.FunctionInterval import Func, Wait
+from direct.gui.DirectGui import *
+from toontown.toonbase.ToontownGlobals import *
+from toontown.toonbase import TTLocalizer
+from toontown.suit import Suit, SuitDNA
+from toontown.toon import Toon, ToonHead, ToonDNA
+from DistributedCogdoInterior import *
+from CogdoUtil import CogdoGameMovie
+import CogdoBarrelRoomConsts, CogdoUtil
+
+class CogdoBarrelRoomIntro(CogdoGameMovie):
+    notify = DirectNotifyGlobal.directNotify.newCategory('CogdoElevatorMovie')
+
+    def __init__(self):
+        CogdoGameMovie.__init__(self)
+        self._toonDialogueSfx = None
+        self.toonHead = None
+        self.frame = None
+        return
+
+    def displayLine(self, text):
+        self.notify.debug('displayLine')
+        self._dialogueLabel.node().setText(text)
+        self.toonHead.reparentTo(aspect2d)
+        self._toonDialogueSfx.play()
+        self.toonHead.setClipPlane(self.clipPlane)
+
+    def makeSuit(self, suitType):
+        self.notify.debug('makeSuit()')
+        suit = Suit.Suit()
+        dna = SuitDNA.SuitDNA()
+        dna.newSuit(suitType)
+        suit.setStyle(dna)
+        suit.isDisguised = 1
+        suit.generateSuit()
+        suit.setScale(1, 1, 2)
+        suit.setPos(0, 0, -4.4)
+        suit.reparentTo(self.toonHead)
+        for part in suit.getHeadParts():
+            part.hide()
+
+        suit.loop('neutral')
+
+    def load(self):
+        self.notify.debug('load()')
+        CogdoGameMovie.load(self)
+        backgroundGui = loader.loadModel('phase_5/models/cogdominium/tt_m_gui_csa_flyThru')
+        self.bg = backgroundGui.find('**/background')
+        self.chatBubble = backgroundGui.find('**/chatBubble')
+        self.chatBubble.setScale(6.5, 6.5, 7.3)
+        self.chatBubble.setPos(0.32, 0, -0.78)
+        self.bg.setScale(5.2)
+        self.bg.setPos(0.14, 0, -0.6667)
+        self.bg.reparentTo(aspect2d)
+        self.chatBubble.reparentTo(aspect2d)
+        self.frame = DirectFrame(geom=self.bg, relief=None, pos=(0.2, 0, -0.6667))
+        self.bg.wrtReparentTo(self.frame)
+        self.gameTitleText = DirectLabel(parent=self.frame, text=TTLocalizer.CogdoBarrelRoomTitle, scale=TTLocalizer.MRPgameTitleText * 0.8, text_align=TextNode.ACenter, text_font=getSignFont(), text_fg=(1.0, 0.33, 0.33, 1.0), pos=TTLocalizer.MRgameTitleTextPos, relief=None)
+        self.chatBubble.wrtReparentTo(self.frame)
+        self.frame.hide()
+        backgroundGui.removeNode()
+        self.toonDNA = ToonDNA.ToonDNA()
+        self.toonDNA.newToonFromProperties('dss', 'ss', 'm', 'm', 2, 0, 2, 2, 1, 8, 1, 8, 1, 14)
+        self.toonHead = Toon.Toon()
+        self.toonHead.setDNA(self.toonDNA)
+        self.makeSuit('sc')
+        self.toonHead.getGeomNode().setDepthWrite(1)
+        self.toonHead.getGeomNode().setDepthTest(1)
+        self.toonHead.loop('neutral')
+        self.toonHead.setPosHprScale(-0.73, 0, -1.27, 180, 0, 0, 0.18, 0.18, 0.18)
+        self.toonHead.reparentTo(hidden)
+        self.toonHead.startBlink()
+        self.clipPlane = self.toonHead.attachNewNode(PlaneNode('clip'))
+        self.clipPlane.node().setPlane(Plane(0, 0, 1, 0))
+        self.clipPlane.setPos(0, 0, 2.45)
+        self._toonDialogueSfx = loader.loadSfx('phase_3.5/audio/dial/AV_dog_long.ogg')
+        self._camHelperNode = NodePath('CamHelperNode')
+        self._camHelperNode.reparentTo(render)
+        dialogue = TTLocalizer.CogdoBarrelRoomIntroDialog
+
+        def start():
+            self.frame.show()
+            base.setCellsAvailable(base.bottomCells + base.leftCells + base.rightCells, 0)
+
+        def end():
+            self._dialogueLabel.reparentTo(hidden)
+            self.toonHead.reparentTo(hidden)
+            self.frame.hide()
+            base.setCellsAvailable(base.bottomCells + base.leftCells + base.rightCells, 1)
+            self._stopUpdateTask()
+
+        self._ival = Sequence(Func(start), Func(self.displayLine, dialogue), Wait(CogdoBarrelRoomConsts.BarrelRoomIntroTimeout), Func(end))
+        self._startUpdateTask()
+        return
+
+    def _updateTask(self, task):
+        dt = globalClock.getDt()
+        return task.cont
+
+    def unload(self):
+        self.frame.destroy()
+        del self.frame
+        self.bg.removeNode()
+        del self.bg
+        self.chatBubble.removeNode()
+        del self.chatBubble
+        self.toonHead.stopBlink()
+        self.toonHead.stop()
+        self.toonHead.removeNode()
+        self.toonHead.delete()
+        del self.toonHead
+        CogdoGameMovie.unload(self)

toontown/cogdominium/CogdoBarrelRoomRewardPanel.py

@@ -1,12 +1,13 @@
 from pandac.PandaModules import *
 from direct.gui.DirectGui import *
+from toontown.toon import DistributedToon
 from toontown.toonbase import ToontownGlobals, TTLocalizer
 from toontown.cogdominium import CogdoBarrelRoomConsts
 
 class CogdoBarrelRoomRewardPanel(DirectFrame):
 
     def __init__(self):
-        DirectFrame.__init__(self, relief=None, geom=DGG.getDefaultDialogGeom(), geom_color=ToontownGlobals.GlobalDialogColor, geom_scale=TTLocalizer.RPdirectFrame, pos=(0, 0, 0.587))
+        DirectFrame.__init__(self, relief=None, geom=DGG.getDefaultDialogGeom(), geom_color=ToontownGlobals.GlobalDialogColor, geom_scale=TTLocalizer.RPdirectFrame, pos=(0, 0, -0.587))
         self.initialiseoptions(CogdoBarrelRoomRewardPanel)
         self.avNameLabel = DirectLabel(parent=self, relief=None, pos=(0, 0, 0.3), text='Toon Ups', text_scale=0.08)
         self.rewardLines = []
@@ -22,15 +23,15 @@ class CogdoBarrelRoomRewardPanel(DirectFrame):
 
         return
 
-    def setRewards(self, results):
+    def setRewards(self):
-        for p in xrange(len(results[0])):
+        RewardLineIndex = 0
-            doId = results[0][p]
+        for doId in base.cr.doId2do:
-            laff = results[1][p]
+            toon = base.cr.doId2do.get(doId)
-            if doId > 0 and doId in base.cr.doId2do:
+            if isinstance(toon, DistributedToon.DistributedToon):
-                toon = base.cr.doId2do[doId]
+                self.rewardLines[RewardLineIndex]['name'].setProp('text', toon.getName())
-                self.rewardLines[p]['name'].setProp('text', toon.getName())
+                self.rewardLines[RewardLineIndex]['laff'].setProp('text', '%s/%s' % (str(toon.hp), str(toon.maxHp)))
-                self.rewardLines[p]['laff'].setProp('text', str(laff))
                 if doId == base.localAvatar.getDoId():
-                    self.rewardLines[p]['frame'].setProp('relief', DGG.RIDGE)
+                    self.rewardLines[RewardLineIndex]['frame'].setProp('relief', DGG.RIDGE)
-                    self.rewardLines[p]['frame'].setProp('borderWidth', (0.01, 0.01))
+                    self.rewardLines[RewardLineIndex]['frame'].setProp('borderWidth', (0.01, 0.01))
-                    self.rewardLines[p]['frame'].setProp('frameColor', (1, 1, 1, 0.5))
+                    self.rewardLines[RewardLineIndex]['frame'].setProp('frameColor', (1, 1, 1, 0.5))
+                RewardLineIndex += 1

toontown/cogdominium/CogdoCraneGame.py

@@ -0,0 +1,74 @@
+import CogdoCraneGameConsts as Globals
+from CogdoGameAudioManager import CogdoGameAudioManager
+
+class CogdoCraneGame(DirectObject):
+    notify = directNotify.newCategory('CogdoFlyingGame')
+
+    def __init__(self, distGame):
+        self.distGame = distGame
+        self.toonId2Player = {}
+        self.players = []
+
+    def _initAudio(self):
+        self._audioMgr = CogdoGameAudioManager(Globals.MusicFiles, Globals.SfxFiles, camera, cutoff=Globals.AudioCutoff)
+
+    def _destroyAudio(self):
+        self._audioMgr.destroy()
+        del self._audioMgr
+
+    def load(self):
+        self._initAudio()
+
+    def unload(self):
+        self._destroyAudio()
+        del self.toonId2Player
+
+    def onstage(self):
+        pass
+
+    def offstage(self):
+        pass
+
+    def startIntro(self):
+        self._audioMgr.playMusic('normal')
+
+    def endIntro(self):
+        for player in self.players:
+            self.placePlayer(player)
+            if player.toon is localAvatar:
+                localAvatar.sendCurrentPosition()
+            player.request('Ready')
+
+    def startFinish(self):
+        pass
+
+    def endFinish(self):
+        pass
+
+    def start(self):
+        for player in self.players:
+            player.handleGameStart()
+            player.request('Normal')
+
+    def exit(self):
+        for player in self.players:
+            player.request('Done')
+
+    def _addPlayer(self, player):
+        self.players.append(player)
+        self.toonId2Player[player.toon.doId] = player
+
+    def _removePlayer(self, player):
+        if player in self.players:
+            self.players.remove(player)
+        else:
+            for cPlayer in self.players:
+                if cPlayer.toon == player.toon:
+                    self.players.remove(cPlayer)
+                    break
+
+        if self.toonId2Player.has_key(player.toon.doId):
+            del self.toonId2Player[player.toon.doId]
+
+    def handleToonLeft(self, toonId):
+        self._removePlayer(self.toonId2Player[toonId])

toontown/cogdominium/CogdoCraneGameConsts.py

@@ -1,6 +1,14 @@
 from direct.fsm.StatePush import StateVar
 from otp.level.EntityStateVarSet import EntityStateVarSet
+from CogdoUtil import VariableContainer
 from toontown.cogdominium.CogdoEntityTypes import CogdoCraneGameSettings, CogdoCraneCogSettings
+Gameplay = VariableContainer()
+Gameplay.SecondsUntilGameOver = 60.0 * 3.0
+Gameplay.TimeRunningOutSeconds = 45.0
+Audio = VariableContainer()
+Audio.MusicFiles = {'normal': 'phase_9/audio/bgm/CHQ_FACT_bg.ogg',
+ 'end': 'phase_7/audio/bgm/encntr_toon_winning_indoor.ogg',
+ 'timeRunningOut': 'phase_7/audio/bgm/encntr_suit_winning_indoor.ogg'}
 Settings = EntityStateVarSet(CogdoCraneGameSettings)
 CogSettings = EntityStateVarSet(CogdoCraneCogSettings)
 CranePosHprs = [(13.4, -136.6, 6, -45, 0, 0),

toontown/cogdominium/CogdoElevatorMovie.py

@@ -10,6 +10,7 @@ from toontown.toonbase.ToontownGlobals import *
 from toontown.toonbase import TTLocalizer
 from toontown.suit import Suit, SuitDNA
 from toontown.toon import Toon, ToonHead, ToonDNA
+from DistributedCogdoInterior import *
 from CogdoUtil import CogdoGameMovie
 import CogdoUtil
 
@@ -82,17 +83,17 @@ class CogdoElevatorMovie(CogdoGameMovie):
         self._toonDialogueSfx = loader.loadSfx('phase_3.5/audio/dial/AV_dog_long.ogg')
         self._camHelperNode = NodePath('CamHelperNode')
         self._camHelperNode.reparentTo(render)
-        dialogue = TTLocalizer.CogdoElevatorRewardLaff
+        dialogue = TTLocalizer.CogdoMazeGameElevatorRewardLaff
 
         def start():
             self.frame.show()
-            base.setCellsActive(base.bottomCells + base.leftCells + base.rightCells, 0)
+            base.setCellsAvailable(base.bottomCells + base.leftCells + base.rightCells, 0)
 
         def end():
             self._dialogueLabel.reparentTo(hidden)
             self.toonHead.reparentTo(hidden)
             self.frame.hide()
-            base.setCellsActive(base.bottomCells + base.leftCells + base.rightCells, 1)
+            base.setCellsAvailable(base.bottomCells + base.leftCells + base.rightCells, 1)
             self._stopUpdateTask()
 
         self._ival = Sequence(Func(start), Func(self.displayLine, dialogue), Wait(self.elevatorDuration), Func(end))

toontown/cogdominium/CogdoExecutiveSuiteMovies.py

@@ -91,7 +91,7 @@ class CogdoExecutiveSuiteIntro(CogdoGameMovie):
 
         def start():
             self.frame.show()
-            base.setCellsActive(base.bottomCells + base.leftCells + base.rightCells, 0)
+            base.setCellsAvailable(base.bottomCells + base.leftCells + base.rightCells, 0)
 
         def showShopOwner():
             self._setCamTarget(self._shopOwner, -10, offset=Point3(0, 0, 5))
@@ -100,7 +100,7 @@ class CogdoExecutiveSuiteIntro(CogdoGameMovie):
             self._dialogueLabel.reparentTo(hidden)
             self.toonHead.reparentTo(hidden)
             self.frame.hide()
-            base.setCellsActive(base.bottomCells + base.leftCells + base.rightCells, 1)
+            base.setCellsAvailable(base.bottomCells + base.leftCells + base.rightCells, 1)
             self._stopUpdateTask()
 
         self._ival = Sequence(Func(start), Func(self.displayLine, dialogue), Func(showShopOwner), ParallelEndTogether(camera.posInterval(self.cameraMoveDuration, Point3(8, 0, 13), blendType='easeInOut'), camera.hprInterval(0.5, self._camHelperNode.getHpr(), blendType='easeInOut')), Wait(self.introDuration), Func(end))

toontown/cogdominium/CogdoFlyingCameraManager.py

@@ -161,26 +161,30 @@ class CogdoFlyingCameraManager:
                 name = entry.getIntoNode().getName()
                 if name.find('col_') >= 0:
                     np = entry.getIntoNodePath().getParent()
-                    if np not in nodesInBetween:
+                    if not nodesInBetween.has_key(np):
                         nodesInBetween[np] = np.getParent()
 
         for np in nodesInBetween.keys():
-            if np in self._betweenCamAndToon:
+            if self._betweenCamAndToon.has_key(np):
                 del self._betweenCamAndToon[np]
             else:
                 np.setTransparency(True)
                 np.wrtReparentTo(self._transNP)
                 if np.getName().find('lightFixture') >= 0:
+                    if not np.find('**/*floor_mesh').isEmpty():
                         np.find('**/*floor_mesh').hide()
                 elif np.getName().find('platform') >= 0:
+                    if not np.find('**/*Floor').isEmpty():
                         np.find('**/*Floor').hide()
 
         for np, parent in self._betweenCamAndToon.items():
             np.wrtReparentTo(parent)
             np.setTransparency(False)
             if np.getName().find('lightFixture') >= 0:
+                if not np.find('**/*floor_mesh').isEmpty():
                     np.find('**/*floor_mesh').show()
             elif np.getName().find('platform') >= 0:
+                if not np.find('**/*Floor').isEmpty():
                     np.find('**/*Floor').show()
 
         self._betweenCamAndToon = nodesInBetween

toontown/cogdominium/CogdoFlyingGame.py

@@ -160,13 +160,7 @@ class CogdoFlyingGame(DirectObject):
         self.acceptOnce(CogdoFlyingLocalPlayer.RanOutOfTimeEventName, self.handleLocalPlayerRanOutOfTime)
         self.__startUpdateTask()
         self.isGameComplete = False
-        if __debug__ and base.config.GetBool('schellgames-dev', True):
-            self.acceptOnce('end', self.guiMgr.forceTimerDone)
 
-            def toggleFog():
-                self.levelFog.setVisible(not self.levelFog.isVisible())
-
-            self.accept('home', toggleFog)
         for eagle in self.legalEagles:
             eagle.gameStart(self.distGame.getStartTime())
 
@@ -299,12 +293,14 @@ class CogdoFlyingGame(DirectObject):
                 if gatherable.type in [Globals.Level.GatherableTypes.InvulPowerup]:
                     if player.toon.isLocal():
                         self.audioMgr.playMusic('invul')
+                taskMgr.doMethodLater(30, lambda task: self.debuffPowerup(toonId, gatherable.type, elapsedTime), 'gatherable-timeout')
         else:
             self.notify.warning('Trying to pickup gatherable nonetype:%s' % pickupNum)
         return
 
     def debuffPowerup(self, toonId, pickupType, elapsedTime):
         self.notify.debugCall()
+        if toonId in self.toonId2Player:
             player = self.toonId2Player[toonId]
             if player.isBuffActive(pickupType):
                 if pickupType in [Globals.Level.GatherableTypes.InvulPowerup]:

toontown/cogdominium/CogdoFlyingGameGlobals.py

@@ -9,25 +9,29 @@ AI.SafezoneId2DeathDamage = {2000: 1,
  5000: 4,
  4000: 8,
  3000: 12,
- 9000: 16}
+ 9000: 16,
+ 7000: 20}
 AI.SafezoneId2WhirlwindDamage = {2000: 1,
  1000: 2,
  5000: 4,
  4000: 8,
  3000: 12,
- 9000: 16}
+ 9000: 16,
+ 7000: 20}
 AI.SafezoneId2LegalEagleDamage = {2000: 2,
  1000: 4,
  5000: 8,
  4000: 16,
  3000: 24,
- 9000: 32}
+ 9000: 32,
+ 7000: 36}
 AI.SafezoneId2MinionDamage = {2000: 1,
  1000: 2,
  5000: 4,
  4000: 8,
  3000: 12,
- 9000: 16}
+ 9000: 16,
+ 7000: 20}
 Camera = VariableContainer()
 Camera.Angle = 12.5
 Camera.Distance = 20
@@ -41,6 +45,7 @@ Camera.AlphaBetweenToon = 0.35
 Camera.SpinRadius = 9.0
 Camera.MaxSpinAngle = 20.0
 Camera.MaxSpinX = 16.0
+Camera.GameCameraFar = 400.0
 Gameplay = VariableContainer()
 Gameplay.SecondsUntilGameOver = 60.0 * 3.0
 Gameplay.TimeRunningOutSeconds = 45.0
@@ -95,7 +100,8 @@ Gameplay.SafezoneId2LaffPickupHealAmount = {2000: 1,
  5000: 4,
  4000: 8,
  3000: 12,
- 9000: 16}
+ 9000: 16,
+ 7000: 20}
 Gameplay.InvulBuffTime = 15.0
 Gameplay.InvulBlinkTime = 5.0
 Gameplay.InvulSingleBlinkTime = 0.5
@@ -167,15 +173,15 @@ LegalEagle.PostCooldownHeightOffNest = 40.0
 Dev = DevVariableContainer('cogdoflying')
 Dev.DisableDeath = False
 Dev.InfiniteFuel = False
-Dev.InfiniteTimeLimit = True
+Dev.InfiniteTimeLimit = False
 Dev.Invincibility = False
 Dev.NoLegalEagleAttacks = False
 Audio = VariableContainer()
 Audio.Cutoff = 75.0
-Audio.MusicFiles = {'normal': 'phase_4/audio/bgm/MG_cannon_game.ogg',
+Audio.MusicFiles = {'normal': 'phase_9/audio/bgm/CHQ_FACT_bg.ogg',
- 'end': 'phase_4/audio/bgm/FF_safezone.ogg',
+ 'end': 'phase_7/audio/bgm/encntr_toon_winning_indoor.ogg',
- 'waiting': 'phase_4/audio/bgm/m_match_bg2.ogg',
+ 'waiting': 'phase_7/audio/bgm/encntr_toon_winning_indoor.ogg',
- 'invul': 'phase_4/audio/bgm/MG_CogThief.ogg',
+ 'invul': 'phase_9/audio/bgm/encntr_toon_winning.ogg',
  'timeRunningOut': 'phase_7/audio/bgm/encntr_suit_winning_indoor.ogg'}
 Audio.SfxFiles = {'propeller': 'phase_4/audio/sfx/TB_propeller.ogg',
  'propeller_damaged': 'phase_5/audio/sfx/tt_s_ara_cfg_propellers_damaged.ogg',
@@ -226,7 +232,8 @@ Level.DifficultyOrder = {2000: (1, 1, 1, 2, 1),
  5000: (1, 2, 1, 2, 2),
  4000: (1, 2, 1, 2, 3, 2),
  3000: (1, 2, 2, 3, 2, 3),
- 9000: (2, 3, 2, 3, 2, 3, 2)}
+ 9000: (2, 3, 2, 3, 2, 3, 2),
+ 7000: (2, 3, 2, 3, 2, 3, 2)}
 Dev.WantTempLevel = True
 Dev.DevQuadsOrder = (1, 2, 3, 4, 5, 6, 7, 8)
 Level.AddSparkleToPowerups = True

toontown/cogdominium/CogdoFlyingGameGuis.py

@@ -57,7 +57,10 @@ class CogdoFlyingProgressGui(DirectFrame):
         return
 
     def _getToonMarker(self, toon):
-        return self._laffMeterModel.find('**/' + toon.style.getType() + 'head')
+        type = self._laffMeterModel.find('**/' + toon.style.getType() + 'head')
+        if type.isEmpty():
+            type = self._laffMeterModel.find('**/bunnyhead')
+        return type
 
     def update(self):
         for toon, marker in self._toonMarkers.items():
@@ -144,13 +147,13 @@ class CogdoFlyingFuelGui(DirectFrame):
             return
         numBlades = fuelState - 1
         if len(self.activeBlades) != numBlades:
-            for i in xrange(len(self.activeBlades)):
+            for i in range(len(self.activeBlades)):
                 blade = self.activeBlades.pop()
                 blade.stash()
 
             if numBlades > len(self.blades):
                 numBlades = len(self.blades)
-            for i in xrange(numBlades):
+            for i in range(numBlades):
                 blade = self.blades[i]
                 self.activeBlades.append(blade)
                 blade.unstash()

toontown/cogdominium/CogdoFlyingGuiManager.py

@@ -28,7 +28,7 @@ class CogdoFlyingGuiManager:
         self._progressGui = CogdoFlyingProgressGui(self.root, self._level)
 
     def _initHud(self):
-        self._memoGui = CogdoMemoGui(self.root)
+        self._memoGui = CogdoMemoGui(self.root, 'memo_card')
         self._memoGui.posNextToLaffMeter()
 
     def _initTimer(self):

toontown/cogdominium/CogdoFlyingLegalEagle.py

@@ -70,6 +70,8 @@ class CogdoFlyingLegalEagle(DirectObject, FSM):
         audioMgr = base.cogdoGameAudioMgr
         self._screamSfx = audioMgr.createSfx('legalEagleScream', self.suit)
         self.initIntervals()
+        self.suit.nametag3d.stash()
+        self.suit.nametag.destroy()
         return
 
     def attachPropeller(self):

toontown/cogdominium/CogdoFlyingLevel.py

@@ -7,7 +7,7 @@ import CogdoUtil
 import CogdoFlyingGameGlobals as Globals
 from CogdoFlyingLevelQuadrant import CogdoFlyingLevelQuadrant
 from CogdoFlyingObjects import CogdoFlyingGatherableFactory, CogdoFlyingPlatform, CogdoFlyingLevelFog
-from CogdoFlyingObstacles import CogdoFlyingObtacleFactory
+from CogdoFlyingObstacles import CogdoFlyingObstacleFactory
 from CogdoGameExit import CogdoGameExit
 from otp.otpbase import OTPGlobals
 
@@ -51,7 +51,7 @@ class CogdoFlyingLevel(DirectObject):
         self.forwardLimit = self.quadLengthUnits * 20
         self._frameModel.flattenStrong()
         self.gatherableFactory = CogdoFlyingGatherableFactory()
-        self.obstacleFactory = CogdoFlyingObtacleFactory()
+        self.obstacleFactory = CogdoFlyingObstacleFactory()
         return
 
     def getExit(self):
@@ -159,7 +159,7 @@ class CogdoFlyingLevel(DirectObject):
         if quadNum >= 0:
             if quadNum > 0:
                 self.quadrants[max(quadNum - self.quadVisibiltyBehind, 0)].onstage()
-            for i in xrange(quadNum, min(quadNum + self.quadVisibiltyAhead + 1, self._numQuads)):
+            for i in range(quadNum, min(quadNum + self.quadVisibiltyAhead + 1, self._numQuads)):
                 self.quadrants[i].onstage()
                 self.visibleQuadIndices.append(i)
                 if i == 0:
@@ -168,7 +168,7 @@ class CogdoFlyingLevel(DirectObject):
                     self.endPlatform.onstage()
 
         self._currentQuadNum = quadNum
-        for i in xrange(0, max(self._currentQuadNum - self.quadVisibiltyBehind, 0)) + range(min(self._currentQuadNum + self.quadVisibiltyAhead + 1, self._numQuads), self._numQuads):
+        for i in range(0, max(self._currentQuadNum - self.quadVisibiltyBehind, 0)) + range(min(self._currentQuadNum + self.quadVisibiltyAhead + 1, self._numQuads), self._numQuads):
             self.quadrants[i].offstage()
             if i == 0:
                 self.startPlatform.offstage()
@@ -193,6 +193,7 @@ class CogdoFlyingLevelFactory:
         self.quadVisibiltyAhead = quadVisibilityAhead
         self.quadVisibiltyBehind = quadVisibiltyBehind
         self._rng = rng or RandomNumGen(1)
+        self.isOrg = self._rng.randint(0, 1)
         self._level = None
         return
 
@@ -200,7 +201,8 @@ class CogdoFlyingLevelFactory:
         levelNode = NodePath('level')
         frameModel = CogdoUtil.loadFlyingModel('level')
         startPlatformModel = CogdoUtil.loadFlyingModel('levelStart')
-        endPlatformModel = CogdoUtil.loadFlyingModel('levelEnd')
+        ver = '_org' if self.isOrg else ''
+        endPlatformModel = CogdoUtil.loadFlyingModel('levelEnd%s' % ver)
         for fan in frameModel.findAllMatches('**/*wallFan'):
             fan.flattenStrong()
 
@@ -211,6 +213,7 @@ class CogdoFlyingLevelFactory:
         frameModel.find('**/wallL').setBin('opaque', 2)
         frameModel.find('**/fogTranslucent_top').setBin('fixed', 2)
         frameModel.getChildren().reparentTo(levelNode)
+        if not self.isOrg:
             levelNode.hide()
         self._level = CogdoFlyingLevel(self.parent, levelNode, startPlatformModel, endPlatformModel, self.quadLengthUnits, self.quadVisibiltyAhead, self.quadVisibiltyBehind)
         if Globals.Dev.WantTempLevel:
@@ -223,7 +226,8 @@ class CogdoFlyingLevelFactory:
                 quads.append(quadList[self._rng.randint(0, len(quadList) - 1)])
 
         for i in quads:
-            filePath = CogdoUtil.getModelPath('quadrant%i' % i, 'flying')
+            ver = '_org' if self.isOrg else ''
+            filePath = CogdoUtil.getModelPath('quadrant%i%s' % (i, ver), 'flying')
             quadModel = loader.loadModel(filePath)
             for np in quadModel.findAllMatches('**/*lightCone*'):
                 CogdoUtil.initializeLightCone(np, 'fixed', 3)
@@ -240,4 +244,7 @@ class CogdoFlyingLevelFactory:
     def createLevelFog(self):
         if self._level is None:
             self.loadAndBuildLevel()
+        if self.isOrg:
+            return CogdoFlyingLevelFog(self._level, (0,0,0,1))
+        else:
             return CogdoFlyingLevelFog(self._level)

toontown/cogdominium/CogdoFlyingLevelQuadrant.py

@@ -52,6 +52,7 @@ class CogdoFlyingLevelQuadrant:
         for np in self._model.findAllMatches('**/*LayerStack*'):
             np.wrtReparentTo(self._model)
 
+        if not self._model.find('**/static').isEmpty():
             for np in self._model.find('**/static').getChildren():
                 np.wrtReparentTo(self._model)
 
@@ -138,8 +139,6 @@ class CogdoFlyingLevelQuadrant:
 
         def generatePowerUps():
             for powerupType, locName in Globals.Level.PowerupType2Loc.iteritems():
-                if powerupType == Globals.Level.GatherableTypes.LaffPowerup and Globals.Level.IgnoreLaffPowerups:
-                    continue
                 gatherables = gatherableModel.findAllMatches('**/%s' % locName)
                 for gatherable in gatherables:
                     pickup = self._level.gatherableFactory.createPowerup(powerupType)

toontown/cogdominium/CogdoFlyingLocalPlayer.py

@@ -555,6 +555,7 @@ class CogdoFlyingLocalPlayer(CogdoFlyingPlayer):
                 power = math.fabs(distance / fanHeight - 1.0) * powerRange + min
                 power = clamp(power, min, max)
                 blowVec *= power
+            if fan.index in self.fanIndex2ToonVelocity:
                 fanVelocity = self.fanIndex2ToonVelocity[fan.index]
                 fanVelocity += blowVec
 
@@ -563,6 +564,7 @@ class CogdoFlyingLocalPlayer(CogdoFlyingPlayer):
             if fan not in self.activeFans:
                 blowVec = fan.getBlowDirection()
                 blowVec *= Globals.Gameplay.ToonDeceleration['fan'] * dt
+                if fan.index in self.fanIndex2ToonVelocity:
                     fanVelocity = Vec3(self.fanIndex2ToonVelocity[fan.index])
                     lastLen = fanVelocity.length()
                     fanVelocity -= blowVec
@@ -573,10 +575,12 @@ class CogdoFlyingLocalPlayer(CogdoFlyingPlayer):
 
         for fan in removeList:
             self.fansStillHavingEffect.remove(fan)
+            if fan.index in self.fanIndex2ToonVelocity:
                 del self.fanIndex2ToonVelocity[fan.index]
 
         self.fanVelocity = Vec3(0.0, 0.0, 0.0)
         for fan in self.fansStillHavingEffect:
+            if fan.index in self.fanIndex2ToonVelocity:
                 self.fanVelocity += self.fanIndex2ToonVelocity[fan.index]
 
         minVal = -Globals.Gameplay.ToonVelMax['fan']
@@ -1073,10 +1077,9 @@ class CogdoFlyingLocalPlayer(CogdoFlyingPlayer):
         elif gatherable.type == Globals.Level.GatherableTypes.Propeller:
             self.handleEnterPropeller(gatherable)
         elif gatherable.type == Globals.Level.GatherableTypes.LaffPowerup:
-            self._getLaffSfx.play()
+            self.handleEnterLaffPowerup(gatherable)
         elif gatherable.type == Globals.Level.GatherableTypes.InvulPowerup:
-            self._getRedTapeSfx.play()
+            self.handleEnterInvulPowerup(gatherable)
-            messenger.send(CogdoFlyingGuiManager.InvulnerableEventName)
 
     def handleEnterMemo(self, gatherable):
         self.score += 1
@@ -1097,3 +1100,10 @@ class CogdoFlyingLocalPlayer(CogdoFlyingPlayer):
             self._guiMgr.update()
             self._refuelSfx.play()
             self._refuelSpinSfx.play(volume=0.15)
+
+    def handleEnterLaffPowerup(self, gatherable):
+        self._getLaffSfx.play()
+
+    def handleEnterInvulPowerup(self, gatherable):
+        messenger.send(CogdoFlyingGuiManager.InvulnerableEventName)
+        self._getRedTapeSfx.play()

toontown/cogdominium/CogdoFlyingObjects.py

@@ -242,6 +242,7 @@ class CogdoFlyingPowerup(CogdoFlyingGatherable):
             self._model.setAlphaScale(0.5)
             if Globals.Level.AddSparkleToPowerups:
                 self.f = self.find('**/particleEffect_sparkles')
+                if not self.f.isEmpty():
                     self.f.hide()
 
     def pickUp(self, toon, elapsedSeconds = 0.0):
@@ -339,6 +340,7 @@ class CogdoFlyingLevelFog:
     def __init__(self, level, color = Globals.Level.FogColor):
         self._level = level
         self.color = color
+        self.defaultFar = None
         fogDistance = self._level.quadLengthUnits * max(1, self._level.quadVisibiltyAhead * 0.2)
         self.fog = Fog('RenderFog')
         self.fog.setColor(self.color)
@@ -346,11 +348,16 @@ class CogdoFlyingLevelFog:
         self._visible = False
         self._clearColor = Vec4(base.win.getClearColor())
         self._clearColor.setW(1.0)
+        self.defaultFar = base.camLens.getFar()
+        base.camLens.setFar(Globals.Camera.GameCameraFar)
+        base.setBackgroundColor(self.color)
 
     def destroy(self):
         self.setVisible(False)
         if hasattr(self, 'fog'):
             del self.fog
+        if self.defaultFar is not None:
+            base.camLens.setFar(self.defaultFar)
 
     def isVisible(self):
         return self._visible

toontown/cogdominium/CogdoFlyingObstacles.py

@@ -16,7 +16,7 @@ from direct.particles import ParticleEffect
 from direct.particles import Particles
 from direct.particles import ForceGroup
 
-class CogdoFlyingObtacleFactory:
+class CogdoFlyingObstacleFactory:
 
     def __init__(self):
         self._index = -1
@@ -29,6 +29,7 @@ class CogdoFlyingObtacleFactory:
         self._fanModel.removeNode()
         del self._fanModel
         if Globals.Level.AddParticlesToStreamers:
+            if hasattr(self, 'f'):
                 self.f.cleanup()
                 del self.f
 
@@ -237,6 +238,8 @@ class CogdoFlyingMinion(CogdoFlyingObstacle):
         d.newSuit(Globals.Gameplay.MinionDnaName)
         self.suit.setDNA(d)
         self.suit.setScale(Globals.Gameplay.MinionScale)
+        self.suit.nametag3d.stash()
+        self.suit.nametag.destroy()
         swapAvatarShadowPlacer(self.suit, 'minion-%sShadowPlacer' % index)
         self.mopathNodePath = NodePath('mopathNodePath')
         self.suit.reparentTo(self.mopathNodePath)

toontown/cogdominium/CogdoFlyingPlayer.py

@@ -233,14 +233,14 @@ class CogdoFlyingPlayer(FSM):
             return
         numBlades = fuelState - 1
         if len(self.activeBlades) != numBlades:
-            for i in xrange(len(self.activeBlades)):
+            for i in range(len(self.activeBlades)):
                 blade = self.activeBlades.pop()
                 blade.stash()
 
             if numBlades > len(self.blades):
                 numBlades = len(self.blades)
             if numBlades > 0:
-                for i in xrange(numBlades):
+                for i in range(numBlades):
                     blade = self.blades[i]
                     self.activeBlades.append(blade)
                     blade.unstash()

toontown/cogdominium/CogdoGameGatherable.py

@@ -102,10 +102,7 @@ class CogdoMemo(CogdoGameGatherable):
 
     def __init__(self, serialNum, model = None, pitch = 0, triggerRadius = 1.0, spinRate = 60):
         if model is None:
-            node = CogdoUtil.loadModel('memo', 'shared')
+            model = CogdoUtil.loadModel('joke', 'shared')
-            model = node.find('**/memo')
-            model.detachNode()
-            node.removeNode()
         model.setP(pitch)
         self._spinRate = spinRate
         CogdoGameGatherable.__init__(self, serialNum, model, triggerRadius, name='CogdoMemo')

toontown/cogdominium/CogdoInterior.py

@@ -76,7 +76,7 @@ class CogdoInterior(Place.Place):
         self.parentFSM.getStateNamed('cogdoInterior').addChild(self.fsm)
         self.townBattle = TownBattle.TownBattle('town-battle-done')
         self.townBattle.load()
-        for i in xrange(1, 3):
+        for i in range(1, 3):
             Suit.loadSuits(i)
 
     def unload(self):
@@ -90,7 +90,7 @@ class CogdoInterior(Place.Place):
         self.townBattle.unload()
         self.townBattle.cleanup()
         del self.townBattle
-        for i in xrange(1, 3):
+        for i in range(1, 3):
             Suit.unloadSuits(i)
 
     def setState(self, state, battleEvent = None):

toontown/cogdominium/CogdoMaze.py

@@ -109,8 +109,8 @@ class CogdoMazeFactory:
         quadrantKeys = self._cogdoMazeData.QuadrantCollisions.keys()
         self._rng.shuffle(quadrantKeys)
         i = 0
-        for y in xrange(self.height):
+        for y in range(self.height):
-            for x in xrange(self.width):
+            for x in range(self.width):
                 key = quadrantKeys[i]
                 collTable = self._cogdoMazeData.QuadrantCollisions[key]
                 angle = self._cogdoMazeData.QuadrantAngles[self._rng.randint(0, len(self._cogdoMazeData.QuadrantAngles) - 1)]
@@ -121,9 +121,9 @@ class CogdoMazeFactory:
 
     def _generateBarrierData(self):
         data = []
-        for y in xrange(self.height):
+        for y in range(self.height):
             data.append([])
-            for x in xrange(self.width):
+            for x in range(self.width):
                 if x == self.width - 1:
                     ax = -1
                 else:
@@ -204,12 +204,12 @@ class CogdoMazeFactory:
         self._data['originX'] = int(self._data['width'] / 2)
         self._data['originY'] = int(self._data['height'] / 2)
         collisionTable = []
-        horizontalWall = [ 1 for x in xrange(self._data['width']) ]
+        horizontalWall = [ 1 for x in range(self._data['width']) ]
         collisionTable.append(horizontalWall)
-        for i in xrange(0, len(self.quadrantData), self.width):
+        for i in range(0, len(self.quadrantData), self.width):
-            for y in xrange(self.quadrantSize):
+            for y in range(self.quadrantSize):
                 row = [1]
-                for x in xrange(i, i + self.width):
+                for x in range(i, i + self.width):
                     if x == 1 and y < self.quadrantSize / 2 - 2:
                         newData = []
                         for j in self.quadrantData[x][1][y]:
@@ -227,17 +227,17 @@ class CogdoMazeFactory:
             collisionTable.append(horizontalWall[:])
 
         barriers = Globals.MazeBarriers
-        for i in xrange(len(barriers)):
+        for i in range(len(barriers)):
             for coords in barriers[i]:
                 collisionTable[coords[1]][coords[0]] = 0
 
         y = self._data['originY']
-        for x in xrange(len(collisionTable[y])):
+        for x in range(len(collisionTable[y])):
             if collisionTable[y][x] == 0:
                 collisionTable[y][x] = 2
 
         x = self._data['originX']
-        for y in xrange(len(collisionTable)):
+        for y in range(len(collisionTable)):
             if collisionTable[y][x] == 0:
                 collisionTable[y][x] = 2
 
@@ -254,8 +254,8 @@ class CogdoMazeFactory:
         halfWidth = int(self.width / 2)
         halfHeight = int(self.height / 2)
         i = 0
-        for y in xrange(self.height):
+        for y in range(self.height):
-            for x in xrange(self.width):
+            for x in range(self.width):
                 ax = (x - halfWidth) * size
                 ay = (y - halfHeight) * size
                 extension = ''
@@ -272,7 +272,7 @@ class CogdoMazeFactory:
         quadrantHalfUnitSize = quadrantUnitSize * 0.5
         barrierModel = CogdoUtil.loadMazeModel('grouping_blockerDivider').find('**/divider')
         y = 3
-        for x in xrange(self.width):
+        for x in range(self.width):
             if x == (self.width - 1) / 2:
                 continue
             ax = (x - halfWidth) * size
@@ -284,7 +284,7 @@ class CogdoMazeFactory:
 
         offset = self.cellWidth - 0.5
         for x in (0, 3):
-            for y in xrange(self.height):
+            for y in range(self.height):
                 ax = (x - halfWidth) * size - quadrantHalfUnitSize - frameActualSize + offset
                 ay = (y - halfHeight) * size
                 b = NodePath('barrier')

toontown/cogdominium/CogdoMazeGame.py

@@ -49,20 +49,20 @@ class CogdoMazeGame(DirectObject):
         self.lastBalloonTimestamp = None
         difficulty = self.distGame.getDifficulty()
         serialNum = 0
-        for i in xrange(numSuits[0]):
+        for i in range(numSuits[0]):
             suitRng = RandomNumGen(self.distGame.doId + serialNum * 10)
             suit = CogdoMazeBossSuit(serialNum, self.maze, suitRng, difficulty, startTile=suitSpawnSpot[0][i])
             self.addSuit(suit)
             self.guiMgr.mazeMapGui.addSuit(suit.suit)
             serialNum += 1
 
-        for i in xrange(numSuits[1]):
+        for i in range(numSuits[1]):
             suitRng = RandomNumGen(self.distGame.doId + serialNum * 10)
             suit = CogdoMazeFastMinionSuit(serialNum, self.maze, suitRng, difficulty, startTile=suitSpawnSpot[1][i])
             self.addSuit(suit)
             serialNum += 1
 
-        for i in xrange(numSuits[2]):
+        for i in range(numSuits[2]):
             suitRng = RandomNumGen(self.distGame.doId + serialNum * 10)
             suit = CogdoMazeSlowMinionSuit(serialNum, self.maze, suitRng, difficulty, startTile=suitSpawnSpot[2][i])
             self.addSuit(suit)
@@ -269,7 +269,7 @@ class CogdoMazeGame(DirectObject):
                     self.players.remove(cPlayer)
                     break
 
-        if player.toon.doId in self.toonId2Player:
+        if self.toonId2Player.has_key(player.toon.doId):
             del self.toonId2Player[player.toon.doId]
         self.guiMgr.mazeMapGui.removeToon(player.toon)
 
@@ -302,7 +302,7 @@ class CogdoMazeGame(DirectObject):
 
     def __updateGags(self):
         remove = []
-        for i in xrange(len(self.gags)):
+        for i in range(len(self.gags)):
             balloon = self.gags[i]
             if balloon.isSingleton():
                 remove.append(i)
@@ -353,7 +353,7 @@ class CogdoMazeGame(DirectObject):
             start = math.radians(random.randint(0, 360))
             step = math.radians(360.0 / numDrops)
             radius = 2.0
-            for i in xrange(numDrops):
+            for i in range(numDrops):
                 angle = start + i * step
                 x = radius * math.cos(angle) + suit.suit.getX()
                 y = radius * math.sin(angle) + suit.suit.getY()

toontown/cogdominium/CogdoMazeGameGuis.py

@@ -188,7 +188,7 @@ class CogdoMazeBossGui(DirectFrame):
         self._openDoor.stash()
         spacingX = codeFrameWidth + codeFrameGap
         startX = -0.5 * ((self._codeLength - 1) * spacingX - codeFrameGap)
-        for i in xrange(self._codeLength):
+        for i in range(self._codeLength):
             marker = CogdoMazeBossCodeFrame(i, self._code[i], bossCard)
             marker.reparentTo(self)
             marker.setPos(bossCard, startX + spacingX * i, 0, 0)

toontown/cogdominium/CogdoMazeGameMovies.py

@@ -123,7 +123,7 @@ class CogdoMazeGameIntro(CogdoGameMovie):
         def end():
             self._stopUpdateTask()
 
-        self._ival = Sequence(Func(start), Func(self.displayLine, 'toon', self._getRandomLine(dialogue[0])), showExitIval, Func(showWaterCooler), Func(self.displayLine, 'toon', self._getRandomLine(dialogue[1])), Wait(waitDuration), Func(showBoss), bossSuit.hprInterval(1.0, bossSuit.getHpr() + Point3(180, 0, 0), blendType='easeInOut'), Func(self.displayLine, 'toon', self._getRandomLine(dialogue[2])), Wait(waitDuration - 1.0), Func(end))
+        self._ival = Sequence(Func(start), Func(self.displayLine, 'cog', self._getRandomLine(dialogue[0])), showExitIval, Func(showWaterCooler), Func(self.displayLine, 'toon', self._getRandomLine(dialogue[1])), Wait(waitDuration), Func(showBoss), bossSuit.hprInterval(1.0, bossSuit.getHpr() + Point3(180, 0, 0), blendType='easeInOut'), Func(self.displayLine, 'cog', self._getRandomLine(dialogue[2])), Wait(waitDuration - 1.0), Func(end))
         self._startUpdateTask()
 
     def _setCamTarget(self, targetNP, distance, offset = Point3(0, 0, 0), angle = Point3(0, 0, 0)):

toontown/cogdominium/CogdoMazeGuiManager.py

@@ -102,6 +102,7 @@ class CogdoMazeGuiManager:
             self._initTimer()
         self._timer.setTime(duration)
         self._timer.countdown(duration, timerExpiredCallback)
+        self._timer.show()
         self._presentTimerIval = ToontownIntervals.start(ToontownIntervals.getPresentGuiIval(self._timer, 'present_timer', startPos=(0, 0, 0.35)))
         return
 

toontown/cogdominium/CogdoMazeSuits.py

@@ -19,7 +19,7 @@ class CogdoMazeSuit(MazeSuit, FSM, CogdoMazeSplattable):
         MazeSuit.__init__(self, serialNum, maze, randomNumGen, data['cellWalkPeriod'], difficulty, data['dnaName'], startTile=startTile, walkSameDirectionProb=Globals.SuitWalkSameDirectionProb, walkTurnAroundProb=Globals.SuitWalkTurnAroundProb, uniqueRandomNumGen=False, walkAnimName=walkAnimName)
         FSM.__init__(self, 'CogdoMazeSuit')
         CogdoMazeSplattable.__init__(self, self.suit, '%s-%i' % (Globals.SuitCollisionName, self.serialNum), 1.5)
-        if 'scale' in data:
+        if data.has_key('scale'):
             self.suit.setScale(data['scale'])
         self.hp = data['hp']
         self.type = cogdoSuitType
@@ -228,8 +228,8 @@ class CogdoMazeBossSuit(CogdoMazeSuit):
 
     def pickRandomValidSpot(self, r = 5):
         validSpots = []
-        for x in xrange(self.TX - r, self.TX + r):
+        for x in range(self.TX - r, self.TX + r):
-            for y in xrange(self.TY - r, self.TY + r):
+            for y in range(self.TY - r, self.TY + r):
                 if self.maze.isWalkable(x, y):
                     validSpots.append([x, y])
 

toontown/cogdominium/CogdoMemoGui.py

@@ -9,9 +9,9 @@ MEMOICON_SCALE = 0.2
 
 class CogdoMemoGui(DirectFrame):
 
-    def __init__(self, parent):
+    def __init__(self, parent, type='joke_card'):
         DirectFrame.__init__(self, parent=parent, relief=None, state=DGG.NORMAL, sortOrder=DGG.BACKGROUND_SORT_INDEX)
-        self._initModel()
+        self._initModel(type)
         self.hide()
         return
 
@@ -26,9 +26,9 @@ class CogdoMemoGui(DirectFrame):
     def posNextToLaffMeter(self):
         self.setPos(-0.975, 0, -0.875)
 
-    def _initModel(self):
+    def _initModel(self, type='joke_card'):
         self._countLabel = DirectLabel(parent=self, relief=None, pos=(0.0625, 0, -0.025), scale=CogdoGameConsts.MemoGuiTextScale, text=str(0), text_fg=CogdoGameConsts.MemoGuiTextColor, text_shadow=(0.2, 0.2, 0.2, 1), text_align=TextNode.ALeft, text_font=ToontownGlobals.getToonFont())
-        self._memoIcon = CogdoUtil.loadModel('memo_card', game='shared', group='gui')
+        self._memoIcon = CogdoUtil.loadModel(type, game='shared', group='gui')
         self._memoIcon.reparentTo(self)
         self._memoIcon.setScale(MEMOICON_SCALE)
         return

toontown/cogdominium/CogdoUtil.py

@@ -69,7 +69,7 @@ class CogdoGameMovie:
         textNode.setFont(ToontownGlobals.getToonFont())
         self._dialogueLabel = aspect2d.attachNewNode(textNode)
         self._dialogueLabel.setScale(0.06, 0.06, 0.06)
-        self._dialogueLabel.setPos(0.32, 0, -0.75)
+        self._dialogueLabel.setPos(0.32, 0, -0.7325)
         self._dialogueLabel.reparentTo(hidden)
 
     def unload(self):
@@ -120,9 +120,9 @@ def rotateTable(table, angle):
         t = []
         width = len(table[0])
         height = len(table)
-        for j in xrange(width):
+        for j in range(width):
             row = []
-            for i in xrange(height):
+            for i in range(height):
                 row.append(table[height - 1 - i][j])
 
             t.append(row)
@@ -137,9 +137,9 @@ def rotateTable(table, angle):
         t = []
         width = len(table[0])
         height = len(table)
-        for j in xrange(width):
+        for j in range(width):
             row = []
-            for i in xrange(height):
+            for i in range(height):
                 row.append(table[i][width - 1 - j])
 
             t.append(row)

toontown/cogdominium/DistCogdoCrane.py

@@ -1,20 +1,17 @@
-from direct.distributed import DistributedObject
+from direct.gui.DirectGui import *
+from pandac.PandaModules import *
+from direct.interval.IntervalGlobal import *
 from direct.distributed.ClockDelta import *
 from direct.fsm import FSM
-from direct.gui.DirectGui import *
+from direct.distributed import DistributedObject
-from direct.interval.IntervalGlobal import *
-from direct.showbase import PythonUtil
 from direct.showutil import Rope
+from direct.showbase import PythonUtil
 from direct.task import Task
-from pandac.PandaModules import *
+from toontown.toonbase import ToontownGlobals
-import random
+from toontown.toonbase import TTLocalizer
-
 from otp.otpbase import OTPGlobals
 from toontown.cogdominium import CogdoCraneGameConsts as GameConsts
-from toontown.nametag import NametagGlobals
+import random
-from toontown.toonbase import TTLocalizer
-from toontown.toonbase import ToontownGlobals
-
 
 class DistCogdoCrane(DistributedObject.DistributedObject, FSM.FSM):
     notify = DirectNotifyGlobal.directNotify.newCategory('DistCogdoCrane')
@@ -235,7 +232,7 @@ class DistCogdoCrane(DistributedObject.DistributedObject, FSM.FSM):
             self.physicsActivated = 0
 
     def __straightenCable(self):
-        for linkNum in xrange(self.numLinks):
+        for linkNum in range(self.numLinks):
             an, anp, cnp = self.activeLinks[linkNum]
             an.getPhysicsObject().setVelocity(0, 0, 0)
             z = float(linkNum + 1) / float(self.numLinks) * self.cableLength
@@ -258,7 +255,7 @@ class DistCogdoCrane(DistributedObject.DistributedObject, FSM.FSM):
         self.links = []
         self.links.append((self.topLink, Point3(0, 0, 0)))
         anchor = self.topLink
-        for linkNum in xrange(self.numLinks):
+        for linkNum in range(self.numLinks):
             anchor = self.__makeLink(anchor, linkNum)
 
         self.collisions.stash()
@@ -401,7 +398,7 @@ class DistCogdoCrane(DistributedObject.DistributedObject, FSM.FSM):
         taskMgr.add(self.__watchControls, 'watchCraneControls')
         taskMgr.doMethodLater(5, self.__displayCraneAdvice, self.craneAdviceName)
         taskMgr.doMethodLater(10, self.__displayMagnetAdvice, self.magnetAdviceName)
-        NametagGlobals.setForceOnscreenChat(True)
+        NametagGlobals.setOnscreenChatForced(1)
         self.arrowVert = 0
         self.arrowHorz = 0
 
@@ -418,7 +415,7 @@ class DistCogdoCrane(DistributedObject.DistributedObject, FSM.FSM):
         self.ignore('InputState-turnRight')
         self.arrowVert = 0
         self.arrowHorz = 0
-        NametagGlobals.setForceOnscreenChat(False)
+        NametagGlobals.setOnscreenChatForced(0)
         taskMgr.remove('watchCraneControls')
         self.__setMoveSound(None)
         return
@@ -554,7 +551,7 @@ class DistCogdoCrane(DistributedObject.DistributedObject, FSM.FSM):
     def startFlicker(self):
         self.magnetSoundInterval.start()
         self.lightning = []
-        for i in xrange(4):
+        for i in range(4):
             t = float(i) / 3.0 - 0.5
             l = self.craneGame.lightning.copyTo(self.gripper)
             l.setScale(random.choice([1, -1]), 1, 5)
@@ -683,7 +680,7 @@ class DistCogdoCrane(DistributedObject.DistributedObject, FSM.FSM):
         self.armSmoother.setPos(self.crane.getPos())
         self.armSmoother.setHpr(self.arm.getHpr())
         self.armSmoother.setPhonyTimestamp()
-        for linkNum in xrange(self.numLinks):
+        for linkNum in range(self.numLinks):
             smoother = self.linkSmoothers[linkNum]
             an, anp, cnp = self.activeLinks[linkNum]
             smoother.clearPositions(0)
@@ -692,7 +689,7 @@ class DistCogdoCrane(DistributedObject.DistributedObject, FSM.FSM):
 
     def doSmoothTask(self, task):
         self.armSmoother.computeAndApplySmoothPosHpr(self.crane, self.arm)
-        for linkNum in xrange(self.numLinks):
+        for linkNum in range(self.numLinks):
             smoother = self.linkSmoothers[linkNum]
             anp = self.activeLinks[linkNum][1]
             smoother.computeAndApplySmoothPos(anp)
@@ -719,7 +716,7 @@ class DistCogdoCrane(DistributedObject.DistributedObject, FSM.FSM):
             self.armSmoother.applySmoothPos(self.crane)
             self.armSmoother.applySmoothHpr(self.arm)
         self.armSmoother.clearPositions(1)
-        for linkNum in xrange(self.numLinks):
+        for linkNum in range(self.numLinks):
             smoother = self.linkSmoothers[linkNum]
             an, anp, cnp = self.activeLinks[linkNum]
             if smoother.getLatestPosition():
@@ -735,7 +732,7 @@ class DistCogdoCrane(DistributedObject.DistributedObject, FSM.FSM):
             self.armSmoother.setH(h)
             self.armSmoother.setTimestamp(local)
             self.armSmoother.markPosition()
-            for linkNum in xrange(self.numLinks):
+            for linkNum in range(self.numLinks):
                 smoother = self.linkSmoothers[linkNum]
                 lp = links[linkNum]
                 smoother.setPos(*lp)
@@ -749,7 +746,7 @@ class DistCogdoCrane(DistributedObject.DistributedObject, FSM.FSM):
     def d_sendCablePos(self):
         timestamp = globalClockDelta.getFrameNetworkTime()
         links = []
-        for linkNum in xrange(self.numLinks):
+        for linkNum in range(self.numLinks):
             an, anp, cnp = self.activeLinks[linkNum]
             p = anp.getPos()
             links.append((p[0], p[1], p[2]))

toontown/cogdominium/DistCogdoCraneGame.py

@@ -102,7 +102,7 @@ class DistCogdoCraneGame(CogdoCraneGameBase, DistCogdoLevelGame):
                 self.notify.warning('Not a collision node: %s' % repr(cnp))
                 break
             newCollideMask = newCollideMask | cn.getIntoCollideMask()
-            for i in xrange(cn.getNumSolids()):
+            for i in range(cn.getNumSolids()):
                 solid = cn.getSolid(i)
                 if isinstance(solid, PM.CollisionPolygon):
                     plane = PM.Plane(solid.getPlane())

toontown/cogdominium/DistCogdoCraneGameAI.py

@@ -1,6 +1,70 @@
-from direct.directnotify import DirectNotifyGlobal
+from direct.directnotify.DirectNotifyGlobal import directNotify
 from toontown.cogdominium.DistCogdoLevelGameAI import DistCogdoLevelGameAI
+from toontown.cogdominium.DistCogdoCraneAI import DistCogdoCraneAI
+from toontown.cogdominium import CogdoCraneGameConsts as GameConsts
+from toontown.cogdominium.CogdoCraneGameBase import CogdoCraneGameBase
 
-class DistCogdoCraneGameAI(DistCogdoLevelGameAI):
+class DistCogdoCraneGameAI(DistCogdoLevelGameAI, CogdoCraneGameBase):
-    notify = DirectNotifyGlobal.directNotify.newCategory("DistCogdoCraneGameAI")
+    notify = directNotify.newCategory('DistCogdoCraneGameAI')
     
+    def __init__(self, air, interior):
+        DistCogdoLevelGameAI.__init__(self, air, interior)
+        self._cranes = [
+            None] * self.MaxPlayers
+    
+    def enterLoaded(self):
+        DistCogdoLevelGameAI.enterLoaded(self)
+        for i in xrange(self.MaxPlayers):
+            crane = DistCogdoCraneAI(self.air, self, i)
+            crane.generateWithRequired(self.zoneId)
+            self._cranes[i] = crane
+    
+    def exitLoaded(self):
+        for i in xrange(self.MaxPlayers):
+            if self._cranes[i]:
+                self._cranes[i].requestDelete()
+                self._cranes[i] = None
+                continue
+        
+        DistCogdoLevelGameAI.exitLoaded(self)
+    
+    def enterGame(self):
+        DistCogdoLevelGameAI.enterGame(self)
+        for i in xrange(self.getNumPlayers()):
+            self._cranes[i].request('Controlled', self.getToonIds()[i])
+        
+        self._scheduleGameDone()
+    
+    def _scheduleGameDone(self):
+        timeLeft = GameConsts.Settings.GameDuration.get() - globalClock.getRealTime() - self.getStartTime()
+        if timeLeft > 0:
+            self._gameDoneEvent = taskMgr.doMethodLater(timeLeft, self._gameDoneDL, self.uniqueName('boardroomGameDone'))
+        else:
+            self._gameDoneDL()
+    
+    def exitGame(self):
+        taskMgr.remove(self._gameDoneEvent)
+        self._gameDoneEvent = None
+    
+    def _gameDoneDL(self, task = None):
+        self._handleGameFinished()
+        return task.done
+    
+    def enterFinish(self):
+        DistCogdoLevelGameAI.enterFinish(self)
+        self._finishDoneEvent = taskMgr.doMethodLater(10.0, self._finishDoneDL, self.uniqueName('boardroomFinishDone'))
+    
+    def exitFinish(self):
+        taskMgr.remove(self._finishDoneEvent)
+        self._finishDoneEvent = None
+    
+    def _finishDoneDL(self, task):
+        self.announceGameDone()
+        return task.done
+
+    if __dev__:
+        
+        def _handleGameDurationChanged(self, gameDuration):
+            if hasattr(self, '_gameDoneEvent') and self._gameDoneEvent != None:
+                taskMgr.remove(self._gameDoneEvent)
+                self._scheduleGameDone()

toontown/cogdominium/DistCogdoCraneObject.py

@@ -126,10 +126,12 @@ class DistCogdoCraneObject(DistributedSmoothNode.DistributedSmoothNode, FSM.FSM)
             vel.normalize()
             impact = vel[1]
             if impact >= self.getMinImpact():
+                print 'hit! %s' % impact
                 self.hitBossSoundInterval.start()
                 self.doHitBoss(impact)
             else:
                 self.touchedBossSoundInterval.start()
+                print '--not hard enough: %s' % impact
 
     def doHitBoss(self, impact):
         self.d_hitBoss(impact)

toontown/cogdominium/DistCogdoFlyingGame.py

@@ -10,8 +10,6 @@ class DistCogdoFlyingGame(DistCogdoGame):
 
     def __init__(self, cr):
         DistCogdoGame.__init__(self, cr)
-        if __debug__ and base.config.GetBool('schellgames-dev', True):
-            self.accept('onCodeReload', self.__sgOnCodeReload)
         self.game = CogdoFlyingGame(self)
 
     def delete(self):

toontown/cogdominium/DistCogdoFlyingGameAI.py

@@ -1,42 +1,129 @@
 from direct.directnotify import DirectNotifyGlobal
+from direct.distributed.ClockDelta import *
 from toontown.cogdominium.DistCogdoGameAI import DistCogdoGameAI
+import CogdoFlyingGameGlobals as Globals
 
 class DistCogdoFlyingGameAI(DistCogdoGameAI):
     notify = DirectNotifyGlobal.directNotify.newCategory("DistCogdoFlyingGameAI")
     
-    def requestAction(self, todo0, todo1):
+    def __init__(self, air):
-        pass
+        DistCogdoGameAI.__init__(self, air)
+        self.completed = []
+        self.eagles = {}
+        self.totalMemos = 0
         
-    def requestPickUp(self, todo0, todo1):
+    def requestAction(self, action, data):
-        pass
+        avId = self.air.getAvatarIdFromSender()
+        av = self.air.doId2do.get(avId)
+        if not av:
+            return
         
-    def pickUp(self, todo0, todo1, todo2):
+        if action == Globals.AI.GameActions.LandOnWinPlatform:
-        pass
+            self.completed.append(avId)
+            for toon in self.toons:
+                if toon not in self.completed:
+                    return
                     
-    def debuffPowerup(self, todo0, todo1, todo2):
+            self.gameDone()
-        pass
             
-    def doAction(self, todo0, todo1):
+        elif action == Globals.AI.GameActions.BladeLost:
-        pass
+            self.sendUpdate("toonBladeLost", [avId])
             
-    def eagleExitCooldown(self, todo0, todo1):
+        elif action == Globals.AI.GameActions.SetBlades:
-        pass
+            self.sendUpdate("toonSetBlades", [avId, data])
             
-    def toonSetAsEagleTarget(self, todo0, todo1, todo2):
+        elif action == Globals.AI.GameActions.Died:
-        pass
+            damage = Globals.AI.SafezoneId2DeathDamage[self.getSafezoneId()]
+            self.__damage(av, damage)
+            self.sendUpdate("toonDied", [avId, globalClockDelta.getRealNetworkTime()])
             
-    def toonClearAsEagleTarget(self, todo0, todo1, todo2):
+        elif action == Globals.AI.GameActions.Spawn:
-        pass
+            self.sendUpdate("toonSpawn", [avId, globalClockDelta.getRealNetworkTime()])
             
-    def toonDied(self, todo0, todo1):
+        elif action == Globals.AI.GameActions.RequestEnterEagleInterest:
-        pass
+            if not self.eagles.get(data):
+                self.eagles[data] = avId
+                self.sendUpdate("toonSetAsEagleTarget", [avId, data, globalClockDelta.getRealNetworkTime()])
                 
-    def toonSpawn(self, todo0, todo1):
+        elif action == Globals.AI.GameActions.RequestExitEagleInterest:
-        pass
+            if self.eagles.get(data) == avId:
+                self.eagles[data] = 0
+                self.sendUpdate("toonClearAsEagleTarget", [avId, data, globalClockDelta.getRealNetworkTime()])
                 
-    def toonSetBlades(self, todo0, todo1):
+        elif action == Globals.AI.GameActions.HitLegalEagle:
-        pass
+            damage = Globals.AI.SafezoneId2LegalEagleDamage[self.getSafezoneId()]
+            self.__damage(av, damage)
         
-    def toonBladeLost(self, todo0):
+        elif action == Globals.AI.GameActions.HitMinion:
-        pass
+            damage = Globals.AI.SafezoneId2MinionDamage[self.getSafezoneId()]
+            self.__damage(av, damage)
+            
+        elif action == Globals.AI.GameActions.HitWhirlwind:
+            damage = Globals.AI.SafezoneId2WhirlwindDamage[self.getSafezoneId()]
+            self.__damage(av, damage)
+            
+        elif action == Globals.AI.GameActions.RanOutOfTimePenalty:
+            damage = int(20 * self.getDifficulty())
+            self.__damage(av, damage)
+            
+        else:
+            self.notify.warning('Client requested unknown action \'%s\'' %action)      
+
+    def requestPickUp(self, pickupNum, pickupType):
+        avId = self.air.getAvatarIdFromSender()
+        av = self.air.doId2do.get(avId)
+        if not av:
+            return
+            
+        if pickupType <= len(Globals.Level.GatherableTypes):
+            self.sendUpdate("pickUp", [avId, pickupNum, globalClockDelta.getRealNetworkTime()])
+            if pickupType == Globals.Level.GatherableTypes.LaffPowerup:
+                av.toonUp(int(27 * self.getDifficulty()) + 3)
+                
+            if pickupType == Globals.Level.GatherableTypes.Memo:
+                self.totalMemos += 1
+            
+        else:
+            self.notify.warning('Client requested unknown pickup \'%s\'' % pickupType)     
+
+    def handleStart(self):
+        for toon in self.toons:
+            self.acceptOnce(self.air.getAvatarExitEvent(toon), self.__handleAvExit, [toon])
+            
+    def __handleAvExit(self, toon):
+        if self.air:
+            if toon in self.toons:
+                self.toons.remove(toon)
+                self.ignore(self.air.getAvatarExitEvent(toon))
+                if not self.toons:
+                    self.gameDone(failed=True)
+        
+    def requestDelete(self):
+        DistCogdoGameAI.requestDelete(self)
+        self.ignoreAll()
+        
+    def __removeToon(self, avId):
+        if avId not in self.toons:
+            return
+            
+        self.toons.pop(self.toons.index(avId))
+        if len(self.toons) == 0:
+            self.gameDone(failed=True)
+            
+    def __damage(self, av, damage):
+        av.takeDamage(damage)
+        if av.getHp() < 1:
+            self.__removeToon(av.doId)
+            
+    def getTotalMemos(self):
+        return self.totalMemos
+
+from otp.ai.MagicWordGlobal import *
+
+@magicWord(category=CATEGORY_MODERATOR)
+def endFly():
+    if hasattr(simbase.air, 'cogdoGame'):
+        game = simbase.air.cogdoGame
+        game.requestAction(Globals.AI.GameActions.LandOnWinPlatform, 0)
+        return 'Finished cogdo flying game!'
             

toontown/cogdominium/DistCogdoGame.py

@@ -11,7 +11,7 @@ from toontown.minigame.MinigameRulesPanel import MinigameRulesPanel
 from toontown.cogdominium.CogdoGameRulesPanel import CogdoGameRulesPanel
 from toontown.minigame import MinigameGlobals
 from toontown.toonbase import TTLocalizer as TTL
-SCHELLGAMES_DEV = __debug__ and base.config.GetBool('schellgames-dev', False)
+SCHELLGAMES_DEV = __debug__ and base.config.GetBool('cogdo-enable-cheat', True)
 
 class DistCogdoGame(DistCogdoGameBase, DistributedObject):
     notify = directNotify.newCategory('DistCogdoGame')
@@ -19,6 +19,7 @@ class DistCogdoGame(DistCogdoGameBase, DistributedObject):
     def __init__(self, cr):
         DistributedObject.__init__(self, cr)
         base.cogdoGame = self
+        cr.cogdoGame = self
         self._waitingStartLabel = DirectLabel(text=TTL.MinigameWaitingForOtherPlayers, text_fg=VBase4(1, 1, 1, 1), relief=None, pos=(-0.6, 0, -0.75), scale=0.075)
         self._waitingStartLabel.hide()
         self.loadFSM = ClassicFSM.ClassicFSM('DistCogdoGame.loaded', [State.State('NotLoaded', self.enterNotLoaded, self.exitNotLoaded, ['Loaded']), State.State('Loaded', self.enterLoaded, self.exitLoaded, ['NotLoaded'])], 'NotLoaded', 'NotLoaded')
@@ -71,7 +72,7 @@ class DistCogdoGame(DistCogdoGameBase, DistributedObject):
         return
 
     def getToon(self, toonId):
-        if toonId in self.cr.doId2do:
+        if self.cr.doId2do.has_key(toonId):
             return self.cr.doId2do[toonId]
         else:
             return None
@@ -88,8 +89,8 @@ class DistCogdoGame(DistCogdoGameBase, DistributedObject):
 
     def announceGenerate(self):
         DistributedObject.announceGenerate(self)
-        self._requestInterior()
         self.loadFSM.request('Loaded')
+        self._requestInterior()
         self.notify.info('difficulty: %s, safezoneId: %s' % (self.getDifficulty(), self.getSafezoneId()))
 
     def _requestInterior(self):
@@ -116,6 +117,7 @@ class DistCogdoGame(DistCogdoGameBase, DistributedObject):
 
     def disable(self):
         base.cogdoGame = None
+        self.cr.cogdoGame = None
         self.fsm.requestFinalState()
         self.loadFSM.requestFinalState()
         self.fsm = None
@@ -230,7 +232,7 @@ class DistCogdoGame(DistCogdoGameBase, DistributedObject):
 
     def enterGame(self):
         if SCHELLGAMES_DEV:
-            self.acceptOnce('escape', messenger.send, ['magicWord', ['~endgame']])
+            self.acceptOnce('escape', messenger.send, ['magicWord', ['~endMaze']])
 
     def exitGame(self):
         if SCHELLGAMES_DEV:

toontown/cogdominium/DistCogdoGameAI.py

@@ -1,36 +1,108 @@
 from direct.directnotify import DirectNotifyGlobal
 from direct.distributed.DistributedObjectAI import DistributedObjectAI
+from direct.distributed.ClockDelta import *
+import CogdoGameConsts
 
 class DistCogdoGameAI(DistributedObjectAI):
     notify = DirectNotifyGlobal.directNotify.newCategory("DistCogdoGameAI")
+    delayIntro = .1
     
-    def setInteriorId(self, todo0):
+    def __init__(self, air):
-        pass
+        DistributedObjectAI.__init__(self, air)
+        air.cogdoGame = self
+        self.interiorId = 0
+        self.exteriorZone = 0
+        self.difficultyOverrides = [2147483647, -1]
+        self.requests = {}
+        self.toons = []
         
-    def setExteriorZone(self, todo0):
+    def announceGenerate(self):
-        pass
+        DistributedObjectAI.announceGenerate(self)
         
-    def setDifficultyOverrides(self, todo0, todo1):
+        self.finishEvent = self.uniqueName('CogdoMazeGameDone')
-        pass
+        self.gameOverEvent = self.uniqueName('CogdoMazeGameLose')
         
-    def setVisible(self):
+        self.resetRequests()
-        pass
         
-    def setIntroStart(self):
+    def d_startIntro(self):
-        pass
+        self.sendUpdate('setVisible', [])
+        taskMgr.doMethodLater(self.delayIntro, self.__startIntro, self.taskName('CogdoStartIntro'))
         
-    def setToonSad(self, todo0):
+    def getInterior(self):
-        pass
+        return self.air.doId2do.get(self.interiorId)
         
-    def setToonDisconnect(self, todo0):
+    def resetRequests(self):
-        pass
+        interior = self.getInterior()
+        toons = interior.getToons()[0]
+        for toon in toons:
+            self.requests[toon] = 0
+        
+    def __startIntro(self, task = None):
+        self.sendUpdate('setIntroStart', [])
+        if task:
+            return task.done
         
     def setAvatarReady(self):
+        avId = self.air.getAvatarIdFromSender()
+        self.requests[avId] = 1
+        if not avId in self.toons: self.toons.append(avId)
+        if self.allToonsReady():
+            self.handleStart()
+            self.sendUpdate('setGameStart', [globalClockDelta.getRealNetworkTime()])
+        
+    def allToonsReady(self):
+        interior = self.getInterior()
+        toons = interior.getToons()[0]
+        for toon in toons:
+            if self.requests.get(toon, 0) == 0:
+                return 0
+        return 1
+        
+    def handleStart(self):
         pass
 
-    def setGameStart(self, todo0):
+    def setInteriorId(self, id):
-        pass
+        self.interiorId = id
         
-    def setGameFinish(self, todo0):
+    def getInteriorId(self):
-        pass
+        return self.interiorId
+
+    def setExteriorZone(self, zone):
+        self.exteriorZone = zone
+        
+    def getExteriorZone(self):
+        return self.exteriorZone
+
+    def setDifficultyOverrides(self, difficulty, exteriorDifficulty):
+        self.difficultyOverrides = [difficulty, exteriorDifficulty]
+        
+    def getDifficultyOverrides(self):
+        return self.difficultyOverrides
+
+    def toonWentSad(self, avId):
+        self.sendUpdate('setToonSad', [avId])
+        
+    def setToons(self, toons):
+        self.toons = toons
+        
+    def disable(self):
+        DistributedObjectAI.disable(self)
+        self.air.cogdoGame = None
+        del self.air.cogdoGame
+        
+    def gameDone(self, failed=False):
+        if not failed:
+            if len(self.toons) == 0:
+                failed = True
+                
+        if not failed:
+            messenger.send(self.finishEvent, [self.toons])
+        else:
+            messenger.send(self.gameOverEvent)
+            
+    def getDifficulty(self):
+        return CogdoGameConsts.getDifficulty(self.getSafezoneId())
+
+    def getSafezoneId(self):            
+        return CogdoGameConsts.getSafezoneId(self.exteriorZone)
         

toontown/cogdominium/DistCogdoMazeGame.py

@@ -14,8 +14,6 @@ class DistCogdoMazeGame(DistCogdoGame, DistCogdoMazeGameBase):
         DistCogdoGame.__init__(self, cr)
         self.game = CogdoMazeGame(self)
         self._numSuits = (0, 0, 0)
-        if __debug__ and base.config.GetBool('schellgames-dev', True):
-            self.accept('onCodeReload', self.__sgOnCodeReload)
 
     def delete(self):
         del self.randomNumGen
@@ -45,7 +43,7 @@ class DistCogdoMazeGame(DistCogdoGame, DistCogdoMazeGameBase):
         bossCode = None
         if self._numSuits[0] > 0:
             bossCode = ''
-            for u in xrange(self._numSuits[0]):
+            for u in range(self._numSuits[0]):
                 bossCode += '%X' % self.randomNumGen.randint(0, 15)
 
         self.game.load(mazeFactory, self._numSuits, bossCode)
@@ -230,3 +228,12 @@ class DistCogdoMazeGame(DistCogdoGame, DistCogdoMazeGameBase):
     def setToonDisconnect(self, toonId):
         DistCogdoGame.setToonDisconnect(self, toonId)
         self.game.handleToonDisconnected(toonId)
+
+from otp.ai.MagicWordGlobal import *
+
+@magicWord(category=CATEGORY_MODERATOR)
+def revealMap():
+    if hasattr(base.cr, 'cogdoGame'):
+        game = base.cr.cogdoGame
+        game.game.guiMgr.mazeMapGui.showExit()
+        game.game.guiMgr.mazeMapGui.revealAll()

toontown/cogdominium/DistCogdoMazeGameAI.py

@@ -1,51 +1,249 @@
 from direct.directnotify import DirectNotifyGlobal
 from toontown.cogdominium.DistCogdoGameAI import DistCogdoGameAI
+import CogdoMazeGameGlobals
+from direct.distributed.ClockDelta import *
+from direct.task import Timer
+from toontown.battle import BattleBase
+from toontown.building.ElevatorConstants import *
+
+ALL_ABOARD_LAG = .7
+
+BASE_TOON_UP = 10
+JOKE_TOON_UP = 5
 
 class DistCogdoMazeGameAI(DistCogdoGameAI):
     notify = DirectNotifyGlobal.directNotify.newCategory("DistCogdoMazeGameAI")
+    delayIntro = BattleBase.ELEVATOR_T + ElevatorData[ELEVATOR_NORMAL]['openTime'] + BattleBase.SERVER_BUFFER_TIME
     
-    def requestAction(self, todo0, todo1):
+    def __init__(self, air):
-        pass
+        DistCogdoGameAI.__init__(self, air)
+        self.numSuits = (0,0,0)
+        self.timer = Timer.Timer()
+        self.doorRevealed = False
+        self.toonsInDoor = []
+        self.bosses = {}
+        self.fastMinions = {}
+        self.slowMinions = {}
+        self.suitTypes = [self.bosses, self.fastMinions, self.slowMinions]
+        self.numJokes = {}
         
-    def doAction(self, todo0, todo1, todo2):
+    def announceGenerate(self):
-        pass
+        DistCogdoGameAI.announceGenerate(self)
+        self.setupSuitsAI()
         
-    def setNumSuits(self, todo0):
+    def setupSuitsAI(self):
-        pass
+        bossHp = CogdoMazeGameGlobals.SuitData[0]['hp']
+        fastMiniHp = CogdoMazeGameGlobals.SuitData[1]['hp']
+        slowMiniHp = CogdoMazeGameGlobals.SuitData[2]['hp']
         
-    def requestUseGag(self, todo0, todo1, todo2, todo3):
+        serialNum = 0
-        pass
+        for i in range(self.numSuits[0]):
+            self.bosses[serialNum] = bossHp
+            serialNum += 1
+        for i in range(self.numSuits[1]):
+            self.fastMinions[serialNum] = fastMiniHp
+            serialNum += 1
+        for i in range(self.numSuits[2]):
+            self.slowMinions[serialNum] = slowMiniHp
+            serialNum += 1
     
-    def toonUsedGag(self, todo0, todo1, todo2, todo3, todo4):
+    def setNumSuits(self, num):
-        pass
+        self.numSuits = num
         
-    def requestSuitHitByGag(self, todo0, todo1):
+    def getNumSuits(self):
-        pass
+        return self.numSuits
         
-    def suitHitByGag(self, todo0, todo1, todo2):
+    def requestUseGag(self, x, y, h, timestamp):
-        pass
+        avId = self.air.getAvatarIdFromSender()
+        self.sendUpdate('toonUsedGag', [avId, x, y, h, globalClockDelta.getRealNetworkTime()])
         
-    def requestHitBySuit(self, todo0, todo1, todo2):
+    def requestSuitHitByGag(self, suitType, suitNum):
-        pass
+        hitAI = self.hitSuitAI(suitType, suitNum)
+        if not hitAI:
+            self.notify.warning('Cannot hit suit!')
+            return
+        avId = self.air.getAvatarIdFromSender()
+        self.sendUpdate('suitHitByGag', [avId, suitType, suitNum])
         
-    def toonHitBySuit(self, todo0, todo1, todo2, todo3):
+    def requestHitBySuit(self, suitType, suitNum, nettime):
-        pass
+        avId = self.air.getAvatarIdFromSender()
+        av = self.air.doId2do.get(avId)
+        if av:
+            lostHp = CogdoMazeGameGlobals.SuitData[suitType]['toonDamage'] * self.getDifficulty() * 10
+            av.takeDamage(lostHp)
+            networkTime = globalClockDelta.getRealNetworkTime()
+            self.sendUpdate('toonHitBySuit', [avId, suitType, suitNum, networkTime])
+            if av.getHp() < 1:
+                self.toonWentSad(avId)
             
     def requestHitByDrop(self):
-        pass
+        avId = self.air.getAvatarIdFromSender()
+        av = self.air.doId2do.get(avId)
+        if av:
+            lostHp = CogdoMazeGameGlobals.DropDamage
+            av.takeDamage(lostHp)
+            self.sendUpdate('toonHitByDrop', [avId])
     
-    def toonHitByDrop(self, todo0):
+    def requestPickUp(self, pickupNum):
-        pass
+        avId = self.air.getAvatarIdFromSender()
+        av = self.air.doId2do.get(avId)
+        if av:
+            now = globalClockDelta.getRealNetworkTime()
             
-    def requestPickUp(self, todo0):
+            if avId in self.numJokes:
-        pass
+                self.numJokes[avId] += 1
                 
-    def pickUp(self, todo0, todo1, todo2):
+            else:
-        pass
+                self.numJokes[avId] = 1
                 
-    def requestGag(self, todo0):
+            self.sendUpdate('pickUp', [avId, pickupNum, now])
-        pass
         
-    def hasGag(self, todo0, todo1):
+    def requestGag(self, coolerIndex):
-        pass
+        avId = self.air.getAvatarIdFromSender()
+        self.sendUpdate('hasGag', [avId, globalClockDelta.getRealNetworkTime()])
         
+    def hitSuitAI(self, suitType, suitNum):
+        cogKey = None
+        for cogNum in self.suitTypes[suitType].keys():
+            if cogNum == suitNum:
+                cogKey = cogNum
+                break
+        if cogKey == None:
+            return 0
+        cogHp = self.suitTypes[suitType][cogKey]
+        cogHp -= 1
+        self.suitTypes[suitType][cogKey] = cogHp
+        if cogHp <= 0:
+            del self.suitTypes[suitType][cogKey]
+        return 1
+        
+    def handleStart(self):
+        taskMgr.add(self.__checkGameDone, self.taskName('check-game-done'))
+        taskMgr.add(self.__checkPlayersTask, self.taskName('check-players-task'))
+        serverDelay = 1.0
+        self.timer.startCallback(CogdoMazeGameGlobals.SecondsUntilTimeout + serverDelay, self.__handleGameOver)
+        taskMgr.doMethodLater(serverDelay, self.clientCountdown, self.taskName('client_countdown'))
+        taskMgr.add(self.__timeWarningTask, self.taskName('time-warning-task'))
+        
+    def clientCountdown(self, task):
+        self.doAction(CogdoMazeGameGlobals.GameActions.Countdown, 0)
+        return task.done
+        
+    def __handleGameOver(self):
+        self.removeAll()
+        self.gameDone(failed=True)
+        
+    def __checkGameDone(self, task):
+        bossesLeft = self.bosses
+        if len(bossesLeft) == 0:
+            self.timer.stop()
+            self.doAction(CogdoMazeGameGlobals.GameActions.OpenDoor, 0)
+            self.__startTimeout()
+            return task.done
+            
+        return task.again
+        
+    def __startTimeout(self):
+        self.timer.startCallback(CogdoMazeGameGlobals.SecondsUntilGameEnds, self.__handleTimeout)
+        
+    def __handleTimeout(self):
+        for toon in self.toons:
+            if not toon in self.toonsInDoor:
+                self.killToon(toon)
+        
+        self.removeAll()
+        self.gameDone()
+                
+    def __timeWarningTask(self, task):
+        if self.timer.getT() <= CogdoMazeGameGlobals.SecondsForTimeAlert:
+            self.doAction(CogdoMazeGameGlobals.GameActions.TimeAlert, 0)
+            return task.done
+            
+        return task.again
+                
+    def killToon(self, avId):
+        av = self.air.doId2do.get(avId)
+        if av:
+            if av.getHp() > 0:
+                av.takeDamage(av.getHp())
+            self.toonWentSad(avId)
+        self.__playerDisconnected(avId)
+        
+    def __checkPlayersTask(self, task):
+        for toonId in self.toons:
+            toon = self.air.doId2do.get(toonId)
+            if not toon:
+                self.__playerDisconnected(toonId)
+        
+        return task.again
+                
+    def __playerDisconnected(self, avId):
+        self.sendUpdate('setToonDisconnect', [avId])
+        self.toons.pop(self.toons.index(avId))
+        if len(self.toons) == 0:
+            self.removeAll()
+            self.gameDone(failed=True)
+            
+    def doAction(self, action, data):
+        self.sendUpdate('doAction', [action, data, globalClockDelta.getRealNetworkTime()])
+        
+    def requestAction(self, action, data):
+        Globals = CogdoMazeGameGlobals
+        avId = self.air.getAvatarIdFromSender()
+        if action == Globals.GameActions.RevealDoor:
+            if not self.doorRevealed:
+                self.doAction(action, avId)
+                self.doorRevealed = True
+                
+            else:
+                self.notify.warning('Toon tried to reveal door but it\'s already revealed! Ignoring.')
+                
+        elif action == Globals.GameActions.EnterDoor:
+            if not avId in self.toonsInDoor:
+                self.doAction(action, avId)
+                self.toonsInDoor.append(avId)
+                self.toonUpToon(avId)
+                
+            else:
+                self.notify.warning('Toon tried to enter into door but already entered! Ignoring.')
+                return
+                
+            if len(self.toonsInDoor) >= len(self.toons):
+                self.__handleAllAboard()
+                
+        else:
+            self.notify.warning('Client requested unknown action \'%s\'' %action)
+            
+    def __handleAllAboard(self):
+        if len(self.toonsInDoor) != len(self.toons):
+            self.notify.warning('__handleAllAboard expect all toons aboard!')
+            return
+        self.removeAll()
+        taskMgr.doMethodLater(ALL_ABOARD_LAG, lambda t: self.gameDone(), self.taskName('all-aboard-delay'))
+        
+    def toonUpToon(self, toonId):
+        if toonId in self.toonsInDoor:
+            toon = self.air.doId2do.get(toonId)
+            if toon:
+                val = min(BASE_TOON_UP + JOKE_TOON_UP * self.numJokes.get(toonId, 0), toon.getMaxHp())
+                toon.toonUp(val)
+        
+    def removeAll(self):
+        taskMgr.remove(self.taskName('check-game-done'))
+        taskMgr.remove(self.taskName('check-players-task'))
+        taskMgr.remove(self.taskName('time-warning-task'))
+        taskMgr.remove(self.taskName('all-aboard-delay'))
+        self.timer.stop()
+        
+    def disable(self):
+        DistCogdoGameAI.disable(self)
+        self.removeAll()
+
+from otp.ai.MagicWordGlobal import *
+
+@magicWord(category=CATEGORY_MODERATOR)
+def endMaze():
+    if hasattr(simbase.air, 'cogdoGame'):
+        maze = simbase.air.cogdoGame
+        maze.doAction(CogdoMazeGameGlobals.GameActions.OpenDoor, 0)
+        return 'Finished cogdo maze game!'

toontown/cogdominium/DistributedCogdoBarrel.py

@@ -3,12 +3,15 @@ from direct.directnotify import DirectNotifyGlobal
 from direct.distributed import DistributedObject
 from toontown.toonbase import ToontownGlobals, ToontownIntervals
 from toontown.cogdominium import CogdoBarrelRoomConsts
+from toontown.cogdominium import CogdoBarrelRoom
+import random
 
 class DistributedCogdoBarrel(DistributedObject.DistributedObject):
     notify = DirectNotifyGlobal.directNotify.newCategory('DistributedCogdoBarrel')
 
     def __init__(self, cr):
         DistributedObject.DistributedObject.__init__(self, cr)
+        self.barrelRoom = CogdoBarrelRoom.CogdoBarrelRoom()
         self.index = None
         self.state = None
         self.model = None
@@ -17,6 +20,7 @@ class DistributedCogdoBarrel(DistributedObject.DistributedObject):
         self.collNodePath = None
         self.availableTex = None
         self.usedTex = None
+        self.brLaff = 0
         return
 
     def generate(self):
@@ -32,7 +36,6 @@ class DistributedCogdoBarrel(DistributedObject.DistributedObject):
         cogdoBarrelsNode = render.find('@@CogdoBarrels')
         if not cogdoBarrelsNode or cogdoBarrelsNode.isEmpty():
             cogdoBarrelsNode = render.attachNewNode('CogdoBarrels')
-            cogdoBarrelsNode.stash()
         self.model.reparentTo(cogdoBarrelsNode)
         self.availableTex = loader.loadTexture('phase_5/maps/tt_t_ara_cbr_Barrel_notUsed.jpg')
         self.usedTex = loader.loadTexture('phase_5/maps/tt_t_ara_cbr_Barrel_Used.jpg')
@@ -110,13 +113,18 @@ class DistributedCogdoBarrel(DistributedObject.DistributedObject):
         self.sendUpdate('requestGrab', [])
 
     def setGrab(self, avId):
+        toonup = CogdoBarrelRoomConsts.ToonUp
         if avId == base.localAvatar.doId:
             ToontownIntervals.start(ToontownIntervals.getPulseIval(self.model, self.__pulseIvalName(), 1.15, duration=0.2))
             self.setState(CogdoBarrelRoomConsts.StateUsed)
+            self.brLaff = random.randint(toonup[0], toonup[1])
 
     def setReject(self):
         pass
 
+    def getBarrelLaff(self):
+        return self.brLaff
+
     def __pulseIvalName(self):
         return 'DistributedCogdoBarrelPulse%s' % self.doId
 

toontown/cogdominium/DistributedCogdoBarrelAI.py

@@ -1,21 +1,36 @@
 from direct.directnotify import DirectNotifyGlobal
-from direct.distributed.DistributedObjectAI import DistributedObjectAI
+from direct.distributed import DistributedObjectAI
+import CogdoBarrelRoomConsts
+import random
 
-class DistributedCogdoBarrelAI(DistributedObjectAI):
+class DistributedCogdoBarrelAI(DistributedObjectAI.DistributedObjectAI):
     notify = DirectNotifyGlobal.directNotify.newCategory("DistributedCogdoBarrelAI")
     
+    def __init__(self, air, index):
+        DistributedObjectAI.DistributedObjectAI.__init__(self, air)
+        self.index = index
+        self.state = CogdoBarrelRoomConsts.StateAvailable
+        self.brLaff = 0
+    
     def requestGrab(self):
-        pass
+        toonup = CogdoBarrelRoomConsts.ToonUp
+        if self.state == CogdoBarrelRoomConsts.StateAvailable:
+            self.state = CogdoBarrelRoomConsts.StateUsed
+            self.sendUpdate("setState", [CogdoBarrelRoomConsts.StateUsed])
+            self.sendUpdate("setGrab", [self.air.getAvatarIdFromSender()])
+            self.brLaff = random.randint(toonup[0], toonup[1])
+            self.recieveToonUp()
     
-    def setIndex(self, todo0):
+    def getIndex(self):
-        pass
+        return self.index
     
-    def setState(self, todo0):
+    def getState(self):
-        pass
+        return self.state
     
-    def setGrab(self, todo0):
+    def recieveToonUp(self):
-        pass
+        avId = self.air.getAvatarIdFromSender()
-
+        av = self.air.doId2do.get(avId)
-    def setReject(self):
+        if not av:
-        pass
+            return
         
+        av.toonUp(self.brLaff)

toontown/cogdominium/DistributedCogdoElevatorExt.py

@@ -1,17 +1,22 @@
+# File: D (Python 2.4)
+
 from toontown.building.DistributedElevatorExt import DistributedElevatorExt
+from toontown.building.ElevatorConstants import *
+from toontown.building.ElevatorUtils import *
+from toontown.toonbase import ToontownGlobals
 
 class DistributedCogdoElevatorExt(DistributedElevatorExt):
-
+    def __init__(self, cr):
-    def setupElevator(self):
+        DistributedElevatorExt.__init__(self, cr)
-        DistributedElevatorExt.setupElevator(self)
+        self.type = ELEVATOR_FIELD
-        self.elevatorSphereNodePath.setY(-1.0)
-        self.elevatorSphereNodePath.setZ(1.5)
     
     def getElevatorModel(self):
         return self.bldg.getCogdoElevatorNodePath()
 
+    
     def getBldgDoorOrigin(self):
         return self.bldg.getCogdoDoorOrigin()
 
+    
     def _getDoorsClosedInfo(self):
         return ('cogdoInterior', 'cogdoInterior')

toontown/cogdominium/DistributedCogdoElevatorExtAI.py

@@ -1,6 +1,12 @@
+# File: D (Python 2.4)
+
 from direct.directnotify import DirectNotifyGlobal
 from toontown.building.DistributedElevatorExtAI import DistributedElevatorExtAI
 
 class DistributedCogdoElevatorExtAI(DistributedElevatorExtAI):
-    notify = DirectNotifyGlobal.directNotify.newCategory("DistributedCogdoElevatorExtAI")
+    notify = DirectNotifyGlobal.directNotify.newCategory('DistributedCogdoElevatorExtAI')
+    
+    def _createInterior(self):
+        self.bldg.createCogdoInterior()
+
 

toontown/cogdominium/DistributedCogdoInterior.py

@@ -1,35 +1,38 @@
-from direct.directnotify import DirectNotifyGlobal
+import random
-from direct.distributed import DistributedObject
+from direct.interval.IntervalGlobal import *
 from direct.distributed.ClockDelta import *
+from toontown.building.ElevatorConstants import *
+from toontown.toon import NPCToons
+from pandac.PandaModules import NodePath
+from toontown.building import ElevatorUtils
+from toontown.toonbase import ToontownGlobals
+from toontown.toonbase import ToontownBattleGlobals
+from direct.directnotify import DirectNotifyGlobal
 from direct.fsm import ClassicFSM, State
+from direct.distributed import DistributedObject
 from direct.fsm import State
 from direct.fsm.StatePush import StateVar, FunctionCall
-from direct.interval.IntervalGlobal import *
-from pandac.PandaModules import NodePath
-import random
-
-from CogdoElevatorMovie import CogdoElevatorMovie
-from CogdoExecutiveSuiteMovies import CogdoExecutiveSuiteIntro
 from toontown.battle import BattleBase
-from toontown.building import ElevatorUtils
-from toontown.building.ElevatorConstants import *
-from toontown.chat.ChatGlobals import *
-from toontown.cogdominium import CogdoBarrelRoom, CogdoBarrelRoomConsts
-from toontown.cogdominium import CogdoGameConsts
-from toontown.cogdominium.CogdoLayout import CogdoLayout
-from toontown.distributed import DelayDelete
 from toontown.hood import ZoneUtil
-from toontown.toon import NPCToons
+from toontown.cogdominium.CogdoLayout import CogdoLayout
+from toontown.cogdominium import CogdoGameConsts
+from toontown.cogdominium import CogdoBarrelRoom, CogdoBarrelRoomConsts
+from toontown.distributed import DelayDelete
 from toontown.toonbase import TTLocalizer
-from toontown.toonbase import ToontownBattleGlobals
+from CogdoExecutiveSuiteMovies import CogdoExecutiveSuiteIntro
-from toontown.toonbase import ToontownGlobals
+from CogdoBarrelRoomMovies import CogdoBarrelRoomIntro
-
+from CogdoElevatorMovie import CogdoElevatorMovie
-
+SUITE_DICT = {'s': 'tt_m_ara_crg_penthouse_sell',
+ 'l': 'tt_m_ara_crg_penthouse_law',
+ 'm': 'tt_m_ara_crg_penthouse_sell',
+ 'c': 'tt_m_ara_crg_penthouse_sell'}
 PAINTING_DICT = {'s': 'tt_m_ara_crg_paintingMoverShaker',
  'l': 'tt_m_ara_crg_paintingLegalEagle',
  'm': 'tt_m_ara_crg_paintingMoverShaker',
  'c': 'tt_m_ara_crg_paintingMoverShaker'}
  
+from toontown.nametag.NametagGlobals import *
+
 class DistributedCogdoInterior(DistributedObject.DistributedObject):
     id = 0
     cageHeights = [11.36, 0.01]
@@ -73,7 +76,7 @@ class DistributedCogdoInterior(DistributedObject.DistributedObject):
          120,
          12,
          38]
-        self._wantBarrelRoom = config.GetBool('cogdo-want-barrel-room', 0)
+        self._wantBarrelRoom = config.GetBool('cogdo-want-barrel-room', 1)
         self.barrelRoom = CogdoBarrelRoom.CogdoBarrelRoom()
         self.brResults = [[], []]
         self.barrelRoomIntroTrack = None
@@ -83,8 +86,8 @@ class DistributedCogdoInterior(DistributedObject.DistributedObject):
         self.waitMusic = base.loadMusic('phase_7/audio/bgm/encntr_toon_winning_indoor.ogg')
         self.elevatorMusic = base.loadMusic('phase_7/audio/bgm/tt_elevator.ogg')
         self.fsm = ClassicFSM.ClassicFSM('DistributedCogdoInterior', [State.State('WaitForAllToonsInside', self.enterWaitForAllToonsInside, self.exitWaitForAllToonsInside, ['Elevator']),
-         State.State('Elevator', self.enterElevator, self.exitElevator, ['Game']),
+         State.State('Elevator', self.enterElevator, self.exitElevator, ['Game', 'BattleIntro', 'BarrelRoomIntro']),
-         State.State('Game', self.enterGame, self.exitGame, ['Resting', 'Failed', 'BattleIntro']),
+         State.State('Game', self.enterGame, self.exitGame, ['Resting', 'Failed', 'BattleIntro', 'BarrelRoomIntro', 'Elevator']),
          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',
@@ -121,6 +124,9 @@ class DistributedCogdoInterior(DistributedObject.DistributedObject):
     def setFOType(self, typeId):
         self.FOType = chr(typeId)
 
+    def getFOType(self):
+        return self.FOType
+
     def __uniqueName(self, name):
         DistributedCogdoInterior.id += 1
         return name + '%d' % DistributedCogdoInterior.id
@@ -132,7 +138,7 @@ class DistributedCogdoInterior(DistributedObject.DistributedObject):
         self.elevatorModelIn = loader.loadModel('phase_5/models/cogdominium/tt_m_ara_csa_elevatorB')
         self.leftDoorIn = self.elevatorModelIn.find('**/left_door')
         self.rightDoorIn = self.elevatorModelIn.find('**/right_door')
-        self.elevatorModelOut = loader.loadModel('phase_5/models/cogdominium/tt_m_ara_csa_elevatorB')
+        self.elevatorModelOut = loader.loadModel('phase_5/models/cogdominium/tt_m_ara_csa_elevator')
         self.leftDoorOut = self.elevatorModelOut.find('**/left_door')
         self.rightDoorOut = self.elevatorModelOut.find('**/right_door')
 
@@ -152,12 +158,13 @@ class DistributedCogdoInterior(DistributedObject.DistributedObject):
 
     def setElevatorLights(self, elevatorModel):
         npc = elevatorModel.findAllMatches('**/floor_light_?;+s')
-        for i in xrange(npc.getNumPaths()):
+        for i in range(npc.getNumPaths()):
             np = npc.getPath(i)
+            np.setDepthOffset(120)
             floor = int(np.getName()[-1:]) - 1
             if floor == self.currentFloor:
                 np.setColor(LIGHT_ON_COLOR)
-            elif floor < self.layout.getNumGameFloors():
+            elif floor < self.layout.getNumGameFloors() + (1 if self.FOType != "s" else 0):
                 if self.isBossFloor(self.currentFloor):
                     np.setColor(LIGHT_ON_COLOR)
                 else:
@@ -219,11 +226,11 @@ class DistributedCogdoInterior(DistributedObject.DistributedObject):
         return
 
     def isBossFloor(self, floorNum):
-        if self.layout.hasBossBattle():
+        if not self.layout.hasBossBattle():
-            if self.layout.getBossBattleFloor() == floorNum:
-                return True
             return False
         
+        return (self.layout.getBossBattleFloor() + 0) == floorNum
+
     def __cleanup(self):
         self.toons = []
         self.suits = []
@@ -259,7 +266,7 @@ class DistributedCogdoInterior(DistributedObject.DistributedObject):
         self.ignore(toon.uniqueName('disable'))
 
     def __finishInterval(self, name):
-        if name in self.activeIntervals:
+        if self.activeIntervals.has_key(name):
             interval = self.activeIntervals[name]
             if interval.isPlaying():
                 interval.finish()
@@ -308,7 +315,7 @@ class DistributedCogdoInterior(DistributedObject.DistributedObject):
         self.toons = []
         for toonId in toonIds:
             if toonId != 0:
-                if toonId in self.cr.doId2do:
+                if self.cr.doId2do.has_key(toonId):
                     toon = self.cr.doId2do[toonId]
                     toon.stopSmooth()
                     self.toons.append(toon)
@@ -326,7 +333,7 @@ class DistributedCogdoInterior(DistributedObject.DistributedObject):
         self.suits = []
         self.joiningReserves = []
         for suitId in suitIds:
-            if suitId in self.cr.doId2do:
+            if self.cr.doId2do.has_key(suitId):
                 suit = self.cr.doId2do[suitId]
                 self.suits.append(suit)
                 suit.fsm.request('Battle')
@@ -334,13 +341,20 @@ class DistributedCogdoInterior(DistributedObject.DistributedObject):
                 suit.reparentTo(render)
                 if oldsuits.count(suit) == 0:
                     self.joiningReserves.append(suit)
+                    
+                if 'Elevator' in repr(self.fsm):
+                    # fix the pos
+                    pos, h = BattleBase.BattleBase.suitPoints[len(suitIds) - 1][suitIds.index(suitId)]
+                    suit.setPos(pos)
+                    suit.setH(h)
+                
             else:
                 self.notify.warning('setSuits() - no suit: %d' % suitId)
 
         self.reserveSuits = []
-        for index in xrange(len(reserveIds)):
+        for index in range(len(reserveIds)):
             suitId = reserveIds[index]
-            if suitId in self.cr.doId2do:
+            if self.cr.doId2do.has_key(suitId):
                 suit = self.cr.doId2do[suitId]
                 self.reserveSuits.append((suit, values[index]))
             else:
@@ -405,17 +419,26 @@ class DistributedCogdoInterior(DistributedObject.DistributedObject):
     def __playElevator(self, ts, name, callback):
         SuitHs = []
         SuitPositions = []
+        
         if self.floorModel:
             self.floorModel.removeNode()
             self.floorModel = None
+            
         if self.cage:
             self.cage = None
+            
         if self.currentFloor == 0:
             SuitHs = self.BottomFloor_SuitHs
             SuitPositions = self.BottomFloor_SuitPositions
+
         if self.isBossFloor(self.currentFloor):
+            self.notify.info('__playElevator: currentFloor %s is boss' % self.currentFloor)
             self.barrelRoom.unload()
-            self.floorModel = loader.loadModel('phase_5/models/cogdominium/tt_m_ara_crg_penthouse')
+            if self.FOType:
+                penthouseName = SUITE_DICT.get(self.FOType)
+                for i in range(4):
+                    self.floorModel = loader.loadModel('phase_5/models/cogdominium/%s' % penthouseName)
+
             self.cage = self.floorModel.find('**/cage')
             pos = self.cage.getPos()
             self.cagePos = []
@@ -426,51 +449,73 @@ class DistributedCogdoInterior(DistributedObject.DistributedObject):
             self.cageDoor.wrtReparentTo(self.cage)
             if self.FOType:
                 paintingModelName = PAINTING_DICT.get(self.FOType)
-                for i in xrange(4):
+                for i in range(4):
                     paintingModel = loader.loadModel('phase_5/models/cogdominium/%s' % paintingModelName)
                     loc = self.floorModel.find('**/loc_painting%d' % (i + 1))
                     paintingModel.reparentTo(loc)
 
+            if not self.floorModel.find('**/trophyCase').isEmpty():
+                for i in range(4):
+                    goldEmblem = loader.loadModel('phase_5/models/cogdominium/tt_m_ara_crg_goldTrophy.bam')
+                    loc = self.floorModel.find('**/gold_0%d' % (i + 1))
+                    goldEmblem.reparentTo(loc)
+                for i in range(20):
+                    silverEmblem = loader.loadModel('phase_5/models/cogdominium/tt_m_ara_crg_silverTrophy.bam')
+                    loc = self.floorModel.find('**/silver_0%d' % (i + 1))
+                    silverEmblem.reparentTo(loc)
+
             SuitHs = self.BossOffice_SuitHs
             SuitPositions = self.BossOffice_SuitPositions
             self.__makeShopOwnerNpc()
+
         else:
             if self._wantBarrelRoom:
                 self.barrelRoom.load()
                 self.barrelRoom.hide()
             SuitHs = self.Cubicle_SuitHs
             SuitPositions = self.Cubicle_SuitPositions
+            
         if self.floorModel:
             self.floorModel.reparentTo(render)
             if self.isBossFloor(self.currentFloor):
-                self.notify.debug('Load boss_suit_office')
+                self.notify.info('Load boss_suit_office')
                 elevIn = self.floorModel.find(CogdoGameConsts.PenthouseElevatorInPath).copyTo(render)
                 elevOut = self.floorModel.find(CogdoGameConsts.PenthouseElevatorOutPath)
                 frame = self.elevatorModelOut.find('**/frame')
+                
                 if not frame.isEmpty():
                     frame.hide()
+                    
                 frame = self.elevatorModelIn.find('**/frame')
+                
                 if not frame.isEmpty():
                     frame.hide()
+                    
                 self.elevatorModelOut.reparentTo(elevOut)
+                self.elevatorModelOut.setY(0)
+                
             else:
                 elevIn = self.floorModel.find('**/elevator-in')
                 elevOut = self.floorModel.find('**/elevator-out')
-        elif self._wantBarrelRoom and self.barrelRoom.isLoaded():
+                
-            elevIn = self.barrelRoom.dummyElevInNode
+        elif self._wantBarrelRoom and self.barrelRoom.isLoaded() and self.currentFloor == 2 and self.FOType == 'l': #i know this is really ugly
+            elevIn = self.barrelRoom.model.find(CogdoBarrelRoomConsts.BarrelRoomElevatorInPath)
             elevOut = self.barrelRoom.model.find(CogdoBarrelRoomConsts.BarrelRoomElevatorOutPath)
             y = elevOut.getY(render)
             elevOut = elevOut.copyTo(render)
             elevOut.setY(render, y - 0.75)
+            
         else:
             floorModel = loader.loadModel('phase_7/models/modules/boss_suit_office')
             elevIn = floorModel.find('**/elevator-in').copyTo(render)
             elevOut = floorModel.find('**/elevator-out').copyTo(render)
             floorModel.removeNode()
+            
         self.elevIn = elevIn
         self.elevOut = elevOut
         self._haveEntranceElevator.set(True)
-        for index in xrange(len(self.suits)):
+        for index in range(len(self.suits)):
+            if not self.suits[index].isEmpty():
                 self.suits[index].setPos(SuitPositions[index])
                 if len(self.suits) > 2:
                     self.suits[index].setH(SuitHs[index])
@@ -500,7 +545,6 @@ class DistributedCogdoInterior(DistributedObject.DistributedObject):
         track.append(Func(callback))
         track.start(ts)
         self.activeIntervals[name] = track
-        return
 
     def enterElevator(self, ts = 0):
         if not self._CogdoGameRepeat:
@@ -512,6 +556,7 @@ class DistributedCogdoInterior(DistributedObject.DistributedObject):
             self.elevatorModelOut.detachNode()
             messenger.send('sellbotFieldOfficeChanged', [True])
         else:
+            if self.FOType == 's':
                 self._movie = CogdoElevatorMovie()
                 self._movie.load()
                 self._movie.play()
@@ -531,12 +576,16 @@ class DistributedCogdoInterior(DistributedObject.DistributedObject):
         return None
 
     def __setupBarrelRoom(self):
-        base.cr.playGame.getPlace().fsm.request('stopped')
+        self.currentFloor += 1
         base.transitions.irisOut(0.0)
-        self.elevatorModelIn.detachNode()
+        self.elevatorModelOut.setY(-12)
+        self.elevatorModelIn.reparentTo(self.barrelRoom.model.find(CogdoBarrelRoomConsts.BarrelRoomElevatorInPath))
+        self.leftDoorIn.setPos(3.5, 0, 0)
+        self.rightDoorIn.setPos(-3.5, 0, 0)
         self._showExitElevator()
         self.barrelRoom.show()
         self.barrelRoom.placeToonsAtEntrance(self.toons)
+        self.setElevatorLights(self.elevatorModelOut)
 
     def barrelRoomIntroDone(self):
         self.sendUpdate('toonBarrelRoomIntroDone', [])
@@ -550,6 +599,9 @@ class DistributedCogdoInterior(DistributedObject.DistributedObject):
                 self.accept(self.barrelRoomIntroDoneEvent, self.barrelRoomIntroDone)
                 self.activeIntervals[trackName] = self.barrelRoomIntroTrack
                 self.barrelRoomIntroTrack.start(ts)
+                self._movie = CogdoBarrelRoomIntro()
+                self._movie.load()
+                self._movie.play()
             else:
                 self._showExitElevator()
 
@@ -583,16 +635,13 @@ class DistributedCogdoInterior(DistributedObject.DistributedObject):
     def __brRewardDone(self, task = None):
         self.notify.info('Toon finished watching the barrel room reward.')
         self.sendUpdate('toonBarrelRoomRewardDone', [])
-
+        self.fsm.request('Battle')
-    def setBarrelRoomReward(self, avIds, laffs):
-        self.brResults = [avIds, laffs]
-        self.barrelRoom.setRewardResults(self.brResults)
 
     def enterBarrelRoomReward(self, ts = 0):
         if self._wantBarrelRoom and not self.isBossFloor(self.currentFloor):
             base.cr.playGame.getPlace().fsm.request('stopped')
             self.startAlertElevatorLightIval(self.elevatorModelOut)
-            track, trackName = self.barrelRoom.showRewardUi(self.brResults, callback=self.__brRewardDone)
+            track, trackName = self.barrelRoom.showRewardUi(callback=self.__brRewardDone)
             self.activeIntervals[trackName] = track
             track.start()
             self.barrelRoom.placeToonsNearBattle(self.toons)
@@ -680,7 +729,7 @@ class DistributedCogdoInterior(DistributedObject.DistributedObject):
         self._stashEntranceElevator.set(False)
 
     def _setAvPosToExit(self):
-        base.localAvatar.setPos(self.elevOut, 0, -10, 0)
+        base.localAvatar.setPos(self.elevOut, 0, -22, 0)
         base.localAvatar.setHpr(self.elevOut, 0, 0, 0)
         base.cr.playGame.getPlace().fsm.request('walk')
 
@@ -739,12 +788,12 @@ class DistributedCogdoInterior(DistributedObject.DistributedObject):
             pass
         else:
             self.notify.warning('Invalid floor number for display badges.')
-        for player in xrange(len(self.toons)):
+        for player in range(len(self.toons)):
             goldBadge = loader.loadModel('phase_5/models/cogdominium/tt_m_ara_crg_goldTrophy')
             goldBadge.setScale(1.2)
             goldNode = render.find('**/gold_0' + str(player + 1))
             goldBadge.reparentTo(goldNode)
-            for floor in xrange(numFloors):
+            for floor in range(numFloors):
                 silverBadge = loader.loadModel('phase_5/models/cogdominium/tt_m_ara_crg_silverTrophy.bam')
                 silverBadge.setScale(1.2)
                 silverNode = render.find('**/silver_0' + str(floor * 4 + (player + 1)))
@@ -755,7 +804,13 @@ class DistributedCogdoInterior(DistributedObject.DistributedObject):
         trackName = '__outroPenthouse-%d' % avatar.doId
         track = Parallel(name=trackName)
         base.cr.playGame.getPlace().fsm.request('stopped')
+        
+        if self.FOType == "l":
+            speech = TTLocalizer.CogdoExecutiveSuiteToonThankYouLawbot
+            
+        else:
             speech = TTLocalizer.CogdoExecutiveSuiteToonThankYou % self.SOSToonName
+        
         track.append(Sequence(Func(camera.wrtReparentTo, localAvatar), Func(camera.setPos, 0, -9, 9), Func(camera.lookAt, Point3(5, 15, 0)), Parallel(self.cage.posInterval(0.75, self.cagePos[1], blendType='easeOut'), SoundInterval(self.cageLowerSfx, duration=0.5)), Parallel(self.cageDoor.hprInterval(0.5, VBase3(0, 90, 0), blendType='easeOut'), Sequence(SoundInterval(self.cageDoorSfx), duration=0)), Wait(0.25), Func(self.shopOwnerNpc.wrtReparentTo, render), Func(self.shopOwnerNpc.setScale, 1), Func(self.shopOwnerNpc.loop, 'walk'), Func(self.shopOwnerNpc.headsUp, Point3(0, 10, 0)), ParallelEndTogether(self.shopOwnerNpc.posInterval(1.5, Point3(0, 10, 0)), self.shopOwnerNpc.hprInterval(0.5, VBase3(180, 0, 0), blendType='easeInOut')), Func(self.shopOwnerNpc.setChatAbsolute, TTLocalizer.CagedToonYippee, CFSpeech), ActorInterval(self.shopOwnerNpc, 'jump'), Func(self.shopOwnerNpc.loop, 'neutral'), Func(self.shopOwnerNpc.headsUp, localAvatar), Func(self.shopOwnerNpc.setLocalPageChat, speech, 0), Func(camera.lookAt, self.shopOwnerNpc, Point3(0, 0, 2))))
         self.activeIntervals[trackName] = track
         self.accept('doneChatPage', self.__outroPenthouseChatDone)
@@ -764,6 +819,6 @@ class DistributedCogdoInterior(DistributedObject.DistributedObject):
     def __outroPenthouseChatDone(self, elapsed = None):
         self.shopOwnerNpc.setChatAbsolute(TTLocalizer.CogdoExecutiveSuiteToonBye, CFSpeech)
         self.ignore('doneChatPage')
-        track = Parallel(Sequence(ActorInterval(self.shopOwnerNpc, 'wave'), Func(self.shopOwnerNpc.loop, 'neutral')), Sequence(Wait(2.0), Func(self.exitCogdoBuilding), Func(base.camLens.setMinFov, ToontownGlobals.DefaultCameraFov/(4./3.))))
+        track = Parallel(Sequence(ActorInterval(self.shopOwnerNpc, 'wave'), Func(self.shopOwnerNpc.loop, 'neutral')), Sequence(Wait(2.0), Func(self.exitCogdoBuilding), Func(base.camLens.setFov, ToontownGlobals.DefaultCameraFov)))
         track.start()
         self.penthouseOutroChatDoneTrack = track

toontown/cogdominium/DistributedCogdoInteriorAI.py

@@ -1,57 +1,559 @@
 from direct.directnotify import DirectNotifyGlobal
 from direct.distributed.DistributedObjectAI import DistributedObjectAI
+from direct.distributed.ClockDelta import *
+from direct.fsm import FSM
+from direct.task import Timer
+from toontown.battle import BattleBase
+from toontown.building.ElevatorConstants import *
+from toontown.toonbase.ToontownGlobals import *
+from toontown.toonbase.ToontownBattleGlobals import *
+import DistCogdoMazeGameAI, CogdoMazeGameGlobals, DistributedCogdoElevatorIntAI
+import DistCogdoFlyingGameAI, DistributedCogdoBarrelAI
+from DistributedCogdoBattleBldgAI import DistributedCogdoBattleBldgAI
+from SuitPlannerCogdoInteriorAI import SuitPlannerCogdoInteriorAI
+from toontown.cogdominium import CogdoBarrelRoomConsts
 
-class DistributedCogdoInteriorAI(DistributedObjectAI):
+from toontown.toon import NPCToons
+import random, math
+
+NUM_FLOORS_DICT = {
+                   's': 1,
+                   'l': 2,
+                   'm':1,
+                   'c': 1
+                   }
+                   
+BATTLE_INTRO_DURATION = 10
+BARREL_INTRO_DURATION = 12
+BARREL_ROOM_DURATION = 30
+BARREL_ROOM_REWARD_DURATION = 7
+
+class DistributedCogdoInteriorAI(DistributedObjectAI, FSM.FSM):
     notify = DirectNotifyGlobal.directNotify.newCategory("DistributedCogdoInteriorAI")
     
-    def setZoneId(self, todo0):
+    def __init__(self, air, exterior):
-        pass
+        DistributedObjectAI.__init__(self, air)
+        FSM.FSM.__init__(self, 'CogdoInteriorAIFSM')
+        self.toons = filter(None, exterior.elevator.seats[:])
+        self.responses = {}
+        self.bldgDoId = exterior.doId
+        self.numFloors = NUM_FLOORS_DICT[exterior.track]
+        self.sosNPC = self.__generateSOS(exterior.difficulty)
         
-    def setExtZoneId(self, todo0):
+        self.shopOwnerNpcId = 0
-        pass
         
-    def setDistBldgDoId(self, todo0):
+        self.extZoneId, self.zoneId = exterior.getExteriorAndInteriorZoneId()
-        pass
+        npcIdList = NPCToons.zone2NpcDict.get(self.zoneId, [])
         
-    def setNumFloors(self, todo0):
+        if len(npcIdList) == 0:
-        pass
+            self.notify.info('No NPC in taken cogdo at %s' % self.zoneId)
         
-    def setShopOwnerNpcId(self, todo0):
+        else:
-        pass
+            if len(npcIdList) > 1:
+                self.notify.warning('Multiple NPCs in taken cogdo at %s' % self.zoneId)
                 
-    def setSOSNpcId(self, todo0):
+            self.shopOwnerNpcId = npcIdList[0]
-        pass
 
-    def setFOType(self, todo0):
+        self.gameDone = 0
-        pass
+        self.bossBattleDone = 0
+        self.curFloor = 0
+        self.topFloor = 2
+        self.timer = Timer.Timer()
+        self.exterior = exterior
+        self.planner = self.exterior.planner
+        self.savedByMap = { }
+        self.battle = None
         
-    def setToons(self, todo0, todo1):
+        self.FOType = exterior.track
-        pass
 
-    def setSuits(self, todo0, todo1, todo2):
+        self.gameFloor = 1
-        pass
+        self.battleFloor = 2
+        self.barrelFloor = -1
         
-    def setState(self, todo0, todo1):
+        if self.FOType == 'l':
-        pass
+            self.battleFloor = 3
+            self.barrelFloor = 2
+            self.topFloor += 1
         
-    def setAvatarJoined(self):
+        self.toonSkillPtsGained = { }
-        pass
+        self.toonExp = { }
+        self.toonOrigQuests = { }
+        self.toonItems = { }
+        self.toonOrigMerits = { }
+        self.toonMerits = { }
+        self.toonParts = { }
+        self.helpfulToons = []
+        self.barrels = []
+        self.suits = []
+        self.activeSuits = []
+        self.reserveSuits = []
+        self.joinedReserves = []
+        self.suitsKilled = []
+        self.suitsKilledPerFloor = []
+        self.ignoreResponses = 0
+        self.ignoreElevatorDone = 0
+        self.ignoreReserveJoinDone = 0
         
-    def elevatorDone(self):
+    def __generateSOS(self, difficulty):
-        pass
+        g = lambda: random.choice(NPCToons.FOnpcFriends.keys())
+        v = g()
+        
+        getStars = lambda x: NPCToons.getNPCTrackLevelHpRarity(x)[-1]
+        
+        maxStars = min(2, int(math.ceil(difficulty / 5.)))
+        minStars = max(0, maxStars - 1)
+        
+        while not (minStars <= getStars(v) <= maxStars):
+            v = g()
+            
+        self.notify.info('selected SOS %s (stars = %s)' % (v, getStars(v)))
+        return v
+         
+    def setZoneId(self, zoneId):
+        self.zoneId = zoneId
+        
+    def getZoneId(self):
+        return self.zoneId
+
+    def setExtZoneId(self, extZoneId):
+        self.extZoneId = extZoneId
+        
+    def getExtZoneId(self):
+        return self.extZoneId
+    
+    def setDistBldgDoId(self, bldgDoId):
+        self.bldgDoId = bldgDoId
+        
+    def getDistBldgDoId(self):
+        return self.bldgDoId
+
+    def setNumFloors(self, numFloors):
+        self.numFloors = numFloors
+        
+    def getNumFloors(self):
+        return self.numFloors
+
+    def setShopOwnerNpcId(self, id):
+        self.shopOwnerNpcId = id
+        
+    def getShopOwnerNpcId(self):
+        return self.shopOwnerNpcId
+        
+    def setState(self, state, timestamp):
+        self.request(state)
+        
+    def getState(self):
+        timestamp = globalClockDelta.getRealNetworkTime()
+        return [self.state, timestamp]
+        
+    def b_setState(self, state):
+        self.setState(state, 0)
+        self.d_setState(state)
+        
+    def d_setState(self, state):
+        timestamp = globalClockDelta.getRealNetworkTime()
+        self.sendUpdate('setState', [state, timestamp])
 
     def reserveJoinDone(self):
-        pass
+        toonId = self.air.getAvatarIdFromSender()
+        if self.ignoreResponses == 1:
+            return None
+        elif self.toons.count(toonId) == 0:
+            self.notify.warning('reserveJoinDone() - toon not in list: %d' % toonId)
+            return None
+        self.b_setState('Battle')
         
-    def toonLeftBarrelRoom(self):
+    def elevatorDone(self):
-        pass
+        toonId = self.air.getAvatarIdFromSender()
+        if self.ignoreResponses == 1:
+            return None
             
-    def toonBarrelRoomIntroDone(self):
+        elif self.toons.count(toonId) == 0:
-        pass
+            self.notify.warning('elevatorDone() - toon not in toon list: %d' % toonId)
         
-    def setBarrelRoomReward(self, todo0, todo1):
+    def enterWaitForAllToonsInside(self):
-        pass
+        self.resetResponses()
         
-    def toonBarrelRoomRewardDone(self):
+        if self.FOType == "s":
-        pass
+            self.game = DistCogdoMazeGameAI.DistCogdoMazeGameAI(self.air)
+            self.game.setNumSuits(CogdoMazeGameGlobals.NumSuits)
             
+        elif self.FOType == "l":
+            self.game = DistCogdoFlyingGameAI.DistCogdoFlyingGameAI(self.air)
+            
+        elif self.FOType == "m":
+            self.game = DistCogdoCraneGameAI.DistCogdoCraneGameAI(self.air)
+
+        self.sendUpdate("setSOSNpcId", [self.sosNPC])
+        self.sendUpdate("setFOType", [ord(self.FOType)])
+        
+    def resetResponses(self):
+        for toon in self.toons:
+            self.responses[toon] = 0
+            
+    def setAvatarJoined(self):
+        avId = self.air.getAvatarIdFromSender()
+        self.responses[avId] = 1
+        avatar = self.air.doId2do.get(avId)
+        if avatar != None:
+            self.savedByMap[avId] = (avatar.getName(), avatar.dna.asTuple())
+            self.addToon(avId)
+        if self.allToonsJoined():
+            self.request('Elevator')
+            
+    def addToon(self, avId):
+        if not avId in self.toons:
+            self.toons.append(avId)
+            
+        if self.air.doId2do.has_key(avId):
+            event = self.air.getAvatarExitEvent(avId)
+            self.accept(event, self.__handleUnexpectedExit, [avId])
+            
+    def __handleUnexpectedExit(self, avId):
+        self.removeToon(avId)
+        if len(self.toons) == 0:
+            self.exterior.deleteSuitInterior()
+            if self.battle:
+                self.battle.requestDelete()
+                self.battle = None
+                
+    def removeToon(self, avId):
+        if avId in self.toons: self.toons.pop(avId)
+        
+    def enterElevator(self):
+        self.curFloor += 1
+        self.d_setToons()
+        self.resetResponses()
+        
+        if self.curFloor == self.gameFloor:
+            self.enterGame()
+        
+        self.d_setState('Elevator')
+        self.timer.stop()
+        self.timer.startCallback(BattleBase.ELEVATOR_T + ElevatorData[ELEVATOR_NORMAL]['openTime'] + BattleBase.SERVER_BUFFER_TIME, self.serverElevatorDone)
+        
+        if self.curFloor == self.battleFloor:
+            self.planner.myPrint()
+            suitHandles = self.planner.genFloorSuits(0)
+            
+            self.suits = suitHandles['activeSuits']
+            self.activeSuits = self.suits[:]
+            self.reserveSuits = suitHandles['reserveSuits']
+            
+            self.d_setSuits()
+        
+    def exitElevator(self):
+        self.timer.stop()
+        
+    def serverElevatorDone(self):
+        if self.curFloor == self.gameFloor:
+            self.d_setState('Game')
+            
+        elif self.curFloor == self.battleFloor:
+            self.b_setState('BattleIntro')
+            self.timer.startCallback(BATTLE_INTRO_DURATION, self.battleIntroDone)
+            
+        else:
+            self.notify.warning('Unknown floor %s (track=%s)' % (self.curFloor, self.FOType))
+        
+    def battleIntroDone(self):
+        if self.air:
+            self.createBattle()
+            self.b_setState('Battle')
+        
+    def barrelIntroDone(self):
+        if not self.air:
+            return
+            
+        self.b_setState('CollectBarrels')
+        for i in xrange(len(CogdoBarrelRoomConsts.BarrelProps)):
+            barrel = DistributedCogdoBarrelAI.DistributedCogdoBarrelAI(self.air, i)
+            barrel.generateWithRequired(self.zoneId)
+            self.barrels.append(barrel)
+        self.timer.startCallback(BARREL_ROOM_DURATION, self.barrelReward)
+
+    def barrelReward(self):
+        if not self.air:
+            return
+            
+        self.b_setState('BarrelRoomReward')
+        for i in self.barrels:
+            i.requestDelete()
+        self.timer.startCallback(BARREL_ROOM_REWARD_DURATION, self.barrelRewardDone)
+        
+    def barrelRewardDone(self):
+        if not self.air:
+            return
+            
+        barrelPlanner = SuitPlannerCogdoInteriorAI(self.exterior._cogdoLayout, max(0, self.exterior.difficulty - 5),
+                                                   self.FOType, self.exterior.getExteriorAndInteriorZoneId()[1])
+        barrelPlanner.myPrint()
+        suitHandles = barrelPlanner.genFloorSuits(0)
+            
+        self.suits = suitHandles['activeSuits']
+        self.activeSuits = self.suits[:]
+        self.reserveSuits = suitHandles['reserveSuits']
+        
+        self.d_setSuits()
+        
+        self.battleIntroDone()
+        
+    def handleAllAboard(self, seats):
+        if not hasattr(self, 'air') or not self.air:
+            return None
+        
+        numOfEmptySeats = seats.count(None)
+        if numOfEmptySeats == 4:
+            self.exterior.deleteSuitInterior()
+            return
+            
+        elif not 0 <= numOfEmptySeats <= 3:
+            self.notify.error('Bad number of empty seats: %s' % numOfEmptySeats)
+            
+        for toon in self.toons:
+            if toon not in seats:
+                self.removeToon(toon)
+        
+        self.toons = filter(None, seats)
+        self.d_setToons()
+
+        self.request('Elevator')
+        
+    def enterGame(self):
+        self.game.setToons(self.toons)
+        self.game.setInteriorId(self.doId)
+        self.game.setExteriorZone(self.exterior.zoneId)
+        self.game.setDifficultyOverrides(2147483647, -1)
+        self.game.generateWithRequired(self.zoneId)
+        self.game.d_startIntro()
+        self.accept(self.game.finishEvent, self.__handleGameDone)
+        self.accept(self.game.gameOverEvent, self.__handleGameOver)
+    
+    def __handleGameDone(self, toons):
+        self.game.requestDelete()
+        self.gameDone = 1
+        self.toons = toons
+        if self.curFloor == self.barrelFloor - 1:
+            self.curFloor += 1
+            self.d_setToons()
+            self.resetResponses()
+            self.b_setState('BarrelRoomIntro')
+            self.timer.startCallback(BARREL_INTRO_DURATION, self.barrelIntroDone)
+        else:
+            self.request('Elevator')
+        
+    def __handleGameOver(self):
+        self.game.requestDelete()
+        self.exterior.deleteSuitInterior()
+        
+    def createBattle(self):
+        isBoss = self.curFloor == self.topFloor
+        self.battle = DistributedCogdoBattleBldgAI(self.air, self.zoneId, self.__handleRoundDone, self.__handleBattleDone, bossBattle = isBoss)
+        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.curFloor)
+        
+        self.battle.battleCalc.setSkillCreditMultiplier(self.battle.battleCalc.getSkillCreditMultiplier() * mult)
+                
+    def enterBattleDone(self, toonIds):
+        toonIds = toonIds[0]
+        if len(toonIds) != len(self.toons):
+            deadToons = []
+            for toon in self.toons:
+                if toonIds.count(toon) == 0:
+                    deadToons.append(toon)
+                    continue
+            
+            for toon in deadToons:
+                self.removeToon(toon)
+                
+        self.d_setToons()
+        if len(self.toons) == 0:
+            self.exterior.deleteSuitInterior()
+            
+        elif self.curFloor == self.topFloor:
+            self.battle.resume(self.curFloor, topFloor = 1)
+            
+        else:
+            self.battle.resume(self.curFloor, topFloor = 0)
+            
+    def __doDeleteInterior(self, task):
+        self.exterior.deleteSuitInterior()
+        return task.done
+    
+    def exitBattleDone(self):
+        self.cleanupFloorBattle()
+        
+    def cleanupFloorBattle(self):
+        for suit in self.suits:
+            if suit.isDeleted():
+                continue
+            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)
+                    continue
+            
+            for info in self.joinedReserves:
+                self.reserveSuits.remove(info)
+            
+            if len(self.joinedReserves) > 0:
+                self.d_setSuits()
+                self.request('ReservesJoining')
+                return
+        
+        if len(self.activeSuits) == 0:
+            self.request('BattleDone', [
+                toonIds])
+        else:
+            self.battle.resume()
+            
+    def enterReservesJoining(self):
+        self.resetResponses()
+        self.timer.startCallback(ElevatorData[ELEVATOR_NORMAL]['openTime'] + SUIT_HOLD_ELEVATOR_TIME + BattleBase.SERVER_BUFFER_TIME, self.serverReserveJoinDone)
+
+    def exitReservesJoining(self):
+        self.timer.stop()
+        self.resetResponses()
+        for info in self.joinedReserves:
+            self.battle.suitRequestJoin(info[0])
+        
+        self.battle.resume()
+        self.joinedReserves = []
+        
+    def serverReserveJoinDone(self):
+        self.ignoreReserveJoinDone = 1
+        self.b_setState('Battle')
+        
+    def __handleBattleDone(self, zoneId, toonIds):
+        if len(toonIds) == 0:
+            taskMgr.doMethodLater(10, self.__doDeleteInterior, self.taskName('deleteInterior'))
+        elif self.curFloor == self.topFloor:
+            self.request('Reward')
+        else:
+            self.b_setState('Resting')
+            
+    def enterResting(self):
+        self.intElevator = DistributedCogdoElevatorIntAI.DistributedCogdoElevatorIntAI(self.air, self, self.toons)
+        self.intElevator.generateWithRequired(self.zoneId)
+        
+    def exitResting(self):
+        self.intElevator.requestDelete()
+        
+    def enterReward(self):
+        victors = self.toons[:]
+        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:
+                if self.FOType == 's':
+                    if not toon.attemptAddNPCFriend(self.sosNPC, numCalls=1):
+                        self.notify.info('%s unable to add NPCFriend %s to %s.' % (self.doId, self.sosNPC, v))
+                        
+                elif self.FOType == 'l':
+                    reward = self.getEmblemsReward()
+                    toon.addEmblems(reward)
+                    
+                else:
+                    self.notify.warning('%s unable to reward %s: unknown reward for track %s' % (self.doId, v, self.FOType))
+        
+        self.exterior.fsm.request('waitForVictorsFromCogdo', [
+            victors,
+            savedBy])
+        self.d_setState('Reward')
+        
+    def removeToon(self, toonId):
+        if self.toons.count(toonId):
+            self.toons.remove(toonId)
+        
+    def d_setToons(self):
+        self.sendUpdate('setToons', self.getToons())
+        
+    def getToons(self):
+        return [self.toons, 0]
+        
+    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 allToonsJoined(self):
+        for toon in self.toons:
+            if self.responses[toon] == 0:
+                return 0
+        return 1
+
+    def delete(self):
+        DistributedObjectAI.delete(self)
+        self.timer.stop()
+        
+    def getEmblemsReward(self):
+        hoodIdMap = {2: .5, # ttc
+                     1: 1., # dd
+                     5: 1.5, # dg
+                     4: 2., # mm
+                     3: 2.7, # br
+                     9: 3.5, # dl
+                     7: 4 # ff
+                     }
+        
+        hoodValue = hoodIdMap[int(self.exterior.zoneId // 1000)]
+        diff = max(self.exterior.difficulty, 1)
+        memos = self.game.getTotalMemos()
+        
+        E = (hoodValue * max(memos, 1) * diff) / 2.5
+        return divmod(E, 100)[::-1]

toontown/cogdominium/SuitPlannerCogdoInteriorAI.py

@@ -1,10 +1,206 @@
-from toontown.building.SuitPlannerInteriorAI import SuitPlannerInteriorAI
+from otp.ai.AIBaseGlobal import *
+from toontown.suit import SuitDNA
+from direct.directnotify import DirectNotifyGlobal
+from toontown.suit import DistributedSuitAI
+from toontown.building import SuitBuildingGlobals
+import types, math, random
 
+BASE_RESERVE = 10
 
-class SuitPlannerCogdoInteriorAI(SuitPlannerInteriorAI):
+MAX_RESERVES = {
-    def __init__(self, cogdoLayout, bldgLevel, bldgTrack, zone):
+                's': BASE_RESERVE * .9,
-        self._cogdoLayout = cogdoLayout
+                'm': BASE_RESERVE * 1.1,
-        SuitPlannerInteriorAI.__init__(self, self._cogdoLayout.getNumGameFloors(), bldgLevel, bldgTrack, zone)
+                'l': BASE_RESERVE * 1.25,
+                'c': BASE_RESERVE * 1.5,
+               }
 
-    def _genSuitInfos(self, numFloors, bldgLevel, bldgTrack):
+def filterReviveChance(track, revive):
-        SuitPlannerInteriorAI._genSuitInfos(self, self._cogdoLayout.getNumFloors(), bldgLevel, bldgTrack)
+    if revive >= 0:
+        return revive
+        
+    return random.randint(config.GetInt('min-lt-vs', 0), config.GetInt('max-lt-vs', 2))
+    # implements difficulty 19 / LT
+    
+def getMaxReserves(track):
+    return int(math.ceil(MAX_RESERVES[track]))
+
+class SuitPlannerCogdoInteriorAI:
+    notify = DirectNotifyGlobal.directNotify.newCategory('SuitPlannerCogdoInteriorAI')
+
+    def __init__(self, layout, difficulty, track, zoneId, numFloors = 1):
+        self.zoneId = zoneId
+        self.numFloors = layout.getNumFloors()
+        difficulty = min(difficulty + 4, len(SuitBuildingGlobals.SuitBuildingInfo) - 1)
+        
+        self.respectInvasions = 1
+        
+        if isinstance(difficulty, types.StringType):
+            self.notify.warning('difficulty is a string!')
+            difficulty = int(difficulty)
+            
+        self._genSuitInfos(numFloors, difficulty, track)
+
+    def __genJoinChances(self, num):
+        joinChances = []
+        for currChance in range(num):
+            joinChances.append(random.randint(1, 100))
+
+        joinChances.sort(cmp)
+        return joinChances
+
+    def _genSuitInfos(self, numFloors, difficulty, bldgTrack):
+        self.suitInfos = []
+        self.notify.debug('\n\ngenerating suitsInfos with numFloors (' + str(numFloors) + ') difficulty (' + str(difficulty) + '+1) and bldgTrack (' + str(bldgTrack) + ')')
+        for currFloor in range(numFloors):
+            infoDict = {}
+            lvls = self.__genLevelList(difficulty, currFloor, numFloors)
+            activeDicts = []
+            numActive = random.randint(1, min(4, len(lvls)))
+            
+            if currFloor + 1 == numFloors and len(lvls) > 1:
+                origBossSpot = len(lvls) - 1
+                
+                if numActive == 1:
+                    newBossSpot = numActive - 1
+                    
+                else:
+                    newBossSpot = numActive - 2
+                    
+                tmp = lvls[newBossSpot]
+                lvls[newBossSpot] = lvls[origBossSpot]
+                lvls[origBossSpot] = tmp
+                
+            bldgInfo = SuitBuildingGlobals.SuitBuildingInfo[difficulty]
+            
+            if len(bldgInfo) > SuitBuildingGlobals.SUIT_BLDG_INFO_REVIVES:
+                revives = bldgInfo[SuitBuildingGlobals.SUIT_BLDG_INFO_REVIVES][0]
+                
+            else:
+                revives = 0
+                
+            for currActive in range(numActive - 1, -1, -1):
+                level = lvls[currActive]
+                type = self.__genNormalSuitType(level)
+                activeDict = {}
+                activeDict['type'] = type
+                activeDict['track'] = bldgTrack
+                activeDict['level'] = level
+                activeDict['revives'] = filterReviveChance(bldgTrack, revives)
+                activeDicts.append(activeDict)
+
+            infoDict['activeSuits'] = activeDicts
+            reserveDicts = []
+            numReserve = min(len(lvls) - numActive, getMaxReserves(bldgTrack))
+            joinChances = self.__genJoinChances(numReserve)
+            for currReserve in range(numReserve):
+                level = lvls[currReserve + numActive]
+                type = self.__genNormalSuitType(level)
+                reserveDict = {}
+                reserveDict['type'] = type
+                reserveDict['track'] = bldgTrack
+                reserveDict['level'] = level
+                reserveDict['revives'] = filterReviveChance(bldgTrack, revives)
+                reserveDict['joinChance'] = joinChances[currReserve]
+                reserveDicts.append(reserveDict)
+
+            infoDict['reserveSuits'] = reserveDicts
+            self.suitInfos.append(infoDict)
+
+    def __genNormalSuitType(self, lvl):
+        return SuitDNA.getRandomSuitType(lvl)
+
+    def __genLevelList(self, difficulty, currFloor, numFloors):
+        bldgInfo = SuitBuildingGlobals.SuitBuildingInfo[difficulty]
+
+        lvlPoolRange = bldgInfo[SuitBuildingGlobals.SUIT_BLDG_INFO_LVL_POOL]
+        maxFloors = bldgInfo[SuitBuildingGlobals.SUIT_BLDG_INFO_FLOORS][1]
+        lvlPoolMults = bldgInfo[SuitBuildingGlobals.SUIT_BLDG_INFO_LVL_POOL_MULTS]
+        floorIdx = min(currFloor, maxFloors - 1)
+        lvlPoolMin = lvlPoolRange[0] * lvlPoolMults[floorIdx]
+        lvlPoolMax = lvlPoolRange[1] * lvlPoolMults[floorIdx]
+        lvlPool = random.randint(int(lvlPoolMin), int(lvlPoolMax))
+        lvlMin = bldgInfo[SuitBuildingGlobals.SUIT_BLDG_INFO_SUIT_LVLS][0]
+        lvlMax = bldgInfo[SuitBuildingGlobals.SUIT_BLDG_INFO_SUIT_LVLS][1]
+        self.notify.debug('Level Pool: ' + str(lvlPool))
+        lvlList = []
+        while lvlPool >= lvlMin:
+            newLvl = random.randint(lvlMin, min(lvlPool, lvlMax))
+            lvlList.append(newLvl)
+            lvlPool -= newLvl
+
+        if currFloor + 1 == numFloors:
+            bossLvlRange = bldgInfo[SuitBuildingGlobals.SUIT_BLDG_INFO_BOSS_LVLS]
+            newLvl = random.randint(bossLvlRange[0], bossLvlRange[1])
+            lvlList.append(newLvl)
+        lvlList.sort(cmp)
+        self.notify.debug('LevelList: ' + repr(lvlList))
+        return lvlList
+
+    def __setupSuitInfo(self, suit, bldgTrack, suitLevel, suitType):
+        suitName, skeleton = simbase.air.suitInvasionManager.getInvadingCog()
+        if suitName and self.respectInvasions:
+            suitType = SuitDNA.getSuitType(suitName)
+            bldgTrack = SuitDNA.getSuitDept(suitName)
+            suitLevel = min(max(suitLevel, suitType), suitType + 4)
+        dna = SuitDNA.SuitDNA()
+        dna.newSuitRandom(suitType, bldgTrack)
+        suit.dna = dna
+        self.notify.debug('Creating suit type ' + suit.dna.name + ' of level ' + str(suitLevel) + ' from type ' + str(suitType) + ' and track ' + str(bldgTrack))
+        suit.setLevel(suitLevel)
+        return skeleton
+
+    def __genSuitObject(self, suitZone, suitType, bldgTrack, suitLevel, revives = 0):
+        newSuit = DistributedSuitAI.DistributedSuitAI(simbase.air, None)
+        skel = self.__setupSuitInfo(newSuit, bldgTrack, suitLevel, suitType)
+        if skel:
+            newSuit.setSkelecog(1)
+        newSuit.setSkeleRevives(revives)
+        newSuit.generateWithRequired(suitZone)
+        newSuit.node().setName('suit-%s' % newSuit.doId)
+        return newSuit
+
+    def myPrint(self):
+        print 'Generated suits for cogdo: '
+
+        for floor, currInfo in enumerate(self.suitInfos):
+            floor += 1
+                        
+            actives = currInfo['activeSuits']
+            reserves = currInfo['reserveSuits']
+            
+            print ' Floor %d has %d active suits.' % (floor, len(actives))
+            print ' Floor %d has %d reserve suits.' % (floor, len(reserves))
+            
+            for idx, currActive in enumerate(actives):
+                type, track, level, revives = map(lambda x: currActive[x], ('type', 'track', 'level', 'revives'))
+                
+                print '-- Active suit %d is %s, %s and level %d and revives is %d' % (idx, type, track, level, revives)
+            
+            for idx, currReserve in enumerate(reserves):
+                type, track, level, revives, res = map(lambda x: currReserve[x], ('type', 'track', 'level', 'revives', 'joinChance'))
+                print '- Reserve suit %d is %s, %s and level %d and JC = %d and revives is %d' % (idx, type, track, level, res, revives)
+
+    def genFloorSuits(self, floor):
+        suitHandles = {}
+        floorInfo = self.suitInfos[floor]
+        activeSuits = []
+        for activeSuitInfo in floorInfo['activeSuits']:
+            suit = self.__genSuitObject(self.zoneId, activeSuitInfo['type'], activeSuitInfo['track'], activeSuitInfo['level'], activeSuitInfo['revives'])
+            activeSuits.append(suit)
+
+        suitHandles['activeSuits'] = activeSuits
+        reserveSuits = []
+        for reserveSuitInfo in floorInfo['reserveSuits']:
+            suit = self.__genSuitObject(self.zoneId, reserveSuitInfo['type'], reserveSuitInfo['track'], reserveSuitInfo['level'], reserveSuitInfo['revives'])
+            reserveSuits.append((suit, reserveSuitInfo['joinChance']))
+
+        suitHandles['reserveSuits'] = reserveSuits
+        return suitHandles
+
+    def genSuits(self):
+        suitHandles = []
+        for floor in range(len(self.suitInfos)):
+            floorSuitHandles = self.genFloorSuits(floor)
+            suitHandles.append(floorSuitHandles)
+
+        return suitHandles