def __init__(self, parent=None, z=textStartHeight, text_wordwrap=16, text='', orientation='left', **kw): loadModels() if parent is None: parent = aspect2d if orientation == 'left': pos = (leftMargin, 0, z) text_align = TextNode.ALeft else: pos = kw['pos'] text_align = TextNode.ACenter optiondefs = ( ('relief', None, None), ('pos', pos, None), ('text_align', text_align, None), ('text_scale', 0.052, None), ('text_wordwrap', text_wordwrap, None), ('text', text, None) ) self.defineoptions(kw, optiondefs) DirectLabel.__init__(self, parent) self.initialiseoptions(OptionLabel)
class CogdoMemoGui(DirectFrame): def __init__(self, parent): DirectFrame.__init__(self, parent=parent, relief=None, state=DGG.NORMAL, sortOrder=DGG.BACKGROUND_SORT_INDEX) self._initModel() self.hide() return def destroy(self): ToontownIntervals.cleanup('memocount_pulse') self._countLabel.removeNode() del self._countLabel self._memoIcon.removeNode() del self._memoIcon DirectFrame.destroy(self) def posNextToLaffMeter(self): self.setPos(-0.975, 0, -0.875) def _initModel(self): 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.reparentTo(self) self._memoIcon.setScale(MEMOICON_SCALE) return def setCount(self, count): self._countLabel['text'] = str(count) self._countLabel.setText() ToontownIntervals.cleanup('memocount_pulse') ToontownIntervals.start(ToontownIntervals.getPulseLargerIval(self._memoIcon, 'memocount_pulse', scale=MEMOICON_SCALE))
class Vehicle: """A moving 'vehicle' represented by a circle and with a floating text label that changes over time. Each vehicle uses its own Draw object, and moves itself around by moving the NodePath to which the Draw object is attached. A DirectLabel is attached to the same NodePath for textual annotation.""" def __init__(self): """Initialise the vehicle.""" # Draw a circle to represent this vehicle. d = Draw() d.drawXYCircle(pos = Vec3(0,0,0)) node = d.create() self.np = NodePath(node) self.np.reparentTo(render) # Add a text label above and to the side of this vehicle. self.label=DirectLabel( parent=self.np, text="Hello! :)", text_wordwrap=10, relief=None, text_scale=(0.5,0.5), text_frame=(0,0,0,0), text_bg=(0,0,0,0), color=(0.88,0,0.88,1)) self.label.setPos(2,4,2) # Offset text a little from vehicle. self.label.setBillboardAxis() # Compute a random direction for this vehicle to move in. self.direction = Vec3(random.random()-0.5,random.random()-0.5,0) self.direction.normalize() # Add a task to move this vehicle around. self.prevtime = 0 taskMgr.add(self.move,"moveTask") def move(self,task): """Move the vehicle around by moving it's NodePath.""" speed = 5 elapsed = task.time - self.prevtime # A hard-coded ugly hack to make the vehicle bounce around inside # the grid. self.np.setPos(self.np.getPos()+((self.direction*speed)*elapsed)) text = 'X: ' + str(self.np.getPos().getX()) + '\n' text += 'Y: ' + str(self.np.getPos().getY()) + '\n' self.label['text'] = text if (self.np.getPos().getX() < -50 or self.np.getPos().getX() > 50 or self.np.getPos().getY() < -50 or self.np.getPos().getY() > 50 ): self.direction = -self.direction self.prevtime = task.time return Task.cont
def createPartyListAndLabel(self, typeString, numItems): list = DirectScrolledList(parent=self, relief=None, incButton_image=(self.gui.find('**/%sButtonDown_up' % typeString), self.gui.find('**/%sButtonDown_down' % typeString), self.gui.find('**/%sButtonDown_rollover' % typeString), self.gui.find('**/%sButtonDown_inactive' % typeString)), incButton_relief=None, decButton_image=(self.gui.find('**/%sButtonUp_up' % typeString), self.gui.find('**/%sButtonUp_down' % typeString), self.gui.find('**/%sButtonUp_rollover' % typeString), self.gui.find('**/%sButtonUp_inactive' % typeString)), decButton_relief=None, itemFrame_pos=self.gui.find('**/%s_locator' % typeString).getPos(), itemFrame_relief=None, numItemsVisible=numItems, forceHeight=0.055) strings = {'activities': TTLocalizer.EventsPageHostingTabActivityListTitle, 'parties': TTLocalizer.PartyGatePartiesListTitle} hostPos = self.gui.find('**/%sText_locator' % typeString).getPos() label = DirectLabel(parent=self, text_align=TextNode.ALeft, relief=None, text=strings[typeString], text_scale=0.06, pos=hostPos) curPos = label.getPos() curPos.setX(curPos.getX() + 0.5) if not self.gui.find('**/partiesText_locator1').isEmpty(): curPos = self.gui.find('**/partiesText_locator1').getPos() hpr = Point3(0, 0, -40) toonsLabel = DirectLabel(parent=self, text_align=TextNode.ALeft, relief=None, text=TTLocalizer.PartyGatesPartiesListToons, text_scale=TTLocalizer.PPGtoonsLabel, pos=curPos, hpr=hpr) curPos.setX(curPos.getX() + 0.1) if not self.gui.find('**/partiesText_locator2').isEmpty(): curPos = self.gui.find('**/partiesText_locator2').getPos() activitiesLabel = DirectLabel(parent=self, text_align=TextNode.ALeft, relief=None, text=TTLocalizer.PartyGatesPartiesListActivities, text_scale=TTLocalizer.PPGactivitiesLabel, pos=curPos, hpr=hpr) curPos.setX(curPos.getX() + 0.1) if not self.gui.find('**/partiesText_locator3').isEmpty(): curPos = self.gui.find('**/partiesText_locator3').getPos() minLeftLabel = DirectLabel(parent=self, text_align=TextNode.ALeft, relief=None, text=TTLocalizer.PartyGatesPartiesListMinLeft, text_scale=TTLocalizer.PPGminLeftLabel, pos=curPos, hpr=hpr) return (list, label)
def load(self): gui = loader.loadModel('phase_4/models/questmap/questmap_gui') icon = gui.find('**/tt_t_gui_qst_arrow') iconNP = aspect2d.attachNewNode('iconNP') icon.reparentTo(iconNP) icon.setR(90) self.marker['geom'] = iconNP self.marker['image'] = iconNP self.marker.setScale(0.05) iconNP.removeNode() self.mapOpenButton = DirectButton(image=(gui.find('**/tt_t_gui_qst_mapClose'), gui.find('**/tt_t_gui_qst_mapClose'), gui.find('**/tt_t_gui_qst_mapTryToOpen')), relief=None, pos=(-0.08, 0, 0.37), parent=base.a2dBottomRight, scale=0.205, command=self.show) self.mapCloseButton = DirectButton(image=(gui.find('**/tt_t_gui_qst_mapOpen'), gui.find('**/tt_t_gui_qst_mapOpen'), gui.find('**/tt_t_gui_qst_mapTryToClose')), relief=None, pos=(-0.08, 0, 0.37), parent=base.a2dBottomRight, scale=0.205, command=self.hide) self.mapOpenButton.hide() self.mapCloseButton.hide() gui.removeNode() icons = loader.loadModel('phase_3/models/gui/cog_icons') cIcon = icons.find('**/CorpIcon') lIcon = icons.find('**/LegalIcon') mIcon = icons.find('**/MoneyIcon') sIcon = icons.find('**/SalesIcon') cogInfoTextColor = (0.2, 0.2, 0.2, 1) textPos = (1.2, -0.2) textScale = 0.8 self.cInfo = DirectLabel(parent=self.cogInfoFrame, text='', text_fg=cogInfoTextColor, text_pos=textPos, text_scale=textScale, geom=cIcon, geom_pos=(-0.2, 0, 0), geom_scale=0.8, relief=None) self.cInfo.setPos(-2.2, 0, 0.5) self.lInfo = DirectLabel(parent=self.cogInfoFrame, text_fg=cogInfoTextColor, text='', text_pos=textPos, text_scale=textScale, geom=lIcon, geom_pos=(-0.2, 0, 0), geom_scale=0.8, relief=None) self.lInfo.setPos(-2.2, 0, -0.5) self.mInfo = DirectLabel(parent=self.cogInfoFrame, text_fg=cogInfoTextColor, text='', text_pos=textPos, text_scale=textScale, geom=mIcon, geom_pos=(-0.2, 0, 0), geom_scale=0.8, relief=None) self.mInfo.setPos(0.8, 0, 0.5) self.sInfo = DirectLabel(parent=self.cogInfoFrame, text_fg=cogInfoTextColor, text='', text_pos=textPos, text_scale=textScale, geom=sIcon, geom_pos=(-0.2, 0, 0), geom_scale=0.8, relief=None) self.sInfo.setPos(0.8, 0, -0.5) icons.removeNode() return
def __init__(self, doneEvent): self.doneEvent = doneEvent DirectFrame.__init__(self) self.reparentTo(aspect2d) self.setPos(0.0, 0.0, 0.16) self.stash() publicPartyGui = loader.loadModel('phase_4/models/parties/publicPartyGUI') self.frame = DirectFrame(parent=self, geom=publicPartyGui.find('**/activities_background'), geom_pos=(-0.8, 0.0, 0.2), geom_scale=2.0, relief=None) self.earnedLabel = DirectLabel(parent=self, relief=None, text=str(0), text_align=TextNode.ACenter, text_pos=(0.0, -0.07), text_scale=0.2, text_fg=(0.95, 0.95, 0.0, 1.0), text_font=ToontownGlobals.getSignFont(), textMayChange=True, image=DirectGuiGlobals.getDefaultDialogGeom(), image_scale=(0.33, 1.0, 0.33), pos=(-0.3, 0.0, 0.2), scale=0.9) purchaseModels = loader.loadModel('phase_4/models/gui/purchase_gui') jarImage = purchaseModels.find('**/Jar') self.jarLabel = DirectLabel(parent=self, relief=None, text=str(0), text_align=TextNode.ACenter, text_pos=(0.0, -0.07), text_scale=0.2, text_fg=JellybeanRewardGui.JarLabelTextColor, text_font=ToontownGlobals.getSignFont(), textMayChange=True, image=jarImage, scale=0.7, pos=(0.3, 0.0, 0.17)) purchaseModels.removeNode() del purchaseModels jarImage.removeNode() del jarImage self.messageLabel = DirectLabel(parent=self, relief=None, text='', text_align=TextNode.ALeft, text_wordwrap=16.0, text_scale=0.07, pos=(-0.52, 0.0, -0.1), textMayChange=True) self.doubledJellybeanLabel = DirectLabel(parent=self, relief=None, text=TTLocalizer.PartyRewardDoubledJellybean, text_align=TextNode.ACenter, text_wordwrap=12.0, text_scale=0.09, text_fg=(1.0, 0.125, 0.125, 1.0), pos=(0.0, 0.0, -0.465), textMayChange=False) self.doubledJellybeanLabel.hide() self.closeButton = DirectButton(parent=self, relief=None, text=TTLocalizer.PartyJellybeanRewardOK, text_align=TextNode.ACenter, text_scale=0.065, text_pos=(0.0, -0.625), geom=(publicPartyGui.find('**/startButton_up'), publicPartyGui.find('**/startButton_down'), publicPartyGui.find('**/startButton_rollover'), publicPartyGui.find('**/startButton_inactive')), geom_pos=(-0.39, 0.0, 0.125), command=self._close) publicPartyGui.removeNode() del publicPartyGui self.countSound = base.loadSfx('phase_13/audio/sfx/tick_counter_short.mp3') self.overMaxSound = base.loadSfx('phase_13/audio/sfx/tick_counter_overflow.mp3') return
def setupButtons(self): gui = loader.loadModel('phase_3/models/gui/tt_m_gui_mat_mainGui') arrowImage = (gui.find('**/tt_t_gui_mat_shuffleArrowUp'), gui.find('**/tt_t_gui_mat_shuffleArrowDown')) buttonImage = (gui.find('**/tt_t_gui_mat_shuffleUp'), gui.find('**/tt_t_gui_mat_shuffleDown')) self.title = DirectLabel(aspect2d, relief=None, text=TTLocalizer.GloveGuiTitle, text_fg=(0, 1, 0, 1), text_scale=0.15, text_font=ToontownGlobals.getSignFont(), pos=(0, 0, -0.30), text_shadow=(1, 1, 1, 1)) self.notice = DirectLabel(aspect2d, relief=None, text='', text_fg=(1, 0, 0, 1), text_scale=0.11, text_font=ToontownGlobals.getSignFont(), pos=(0, 0, -0.45), text_shadow=(1, 1, 1, 1)) self.color = DirectLabel(aspect2d, relief=None, text='', text_scale=0.11, text_font=ToontownGlobals.getSignFont(), pos=(0, 0, -0.70), text_shadow=(1, 1, 1, 1)) self.buyButton = DirectButton(aspect2d, relief=None, image=buttonImage, text=TTLocalizer.GloveGuiBuy, text_font=ToontownGlobals.getInterfaceFont(), text_scale=0.11, text_pos=(0, -0.02), pos=(-0.60, 0, -0.90), text_fg=(1, 1, 1, 1), text_shadow=(0, 0, 0, 1), command=self.__exit, extraArgs=[GloveNPCGlobals.CHANGE]) self.cancelButton = DirectButton(aspect2d, relief=None, image=buttonImage, text=TTLocalizer.lCancel, text_font=ToontownGlobals.getInterfaceFont(), text_scale=0.11, text_pos=(0, -0.02), pos=(0.60, 0, -0.90), text_fg=(1, 1, 1, 1), text_shadow=(0, 0, 0, 1), command=self.__exit, extraArgs=[GloveNPCGlobals.USER_CANCEL]) self.downArrow = DirectButton(aspect2d, relief=None, image=arrowImage, pos=(-0.60, 0, -0.66)) self.upArrow = DirectButton(aspect2d, relief=None, image=arrowImage, pos=(0.60, 0, -0.66), scale=-1) gui.removeNode()
def load(self): gui = loader.loadModel("phase_3/models/gui/laff_o_meter") if self.isToon: hType = self.style.getType() if hType == "dog": headModel = gui.find("**/doghead") elif hType == "cat": headModel = gui.find("**/cathead") elif hType == "mouse": headModel = gui.find("**/mousehead") elif hType == "horse": headModel = gui.find("**/horsehead") elif hType == "rabbit": headModel = gui.find("**/bunnyhead") elif hType == "duck": headModel = gui.find("**/duckhead") elif hType == "monkey": headModel = gui.find("**/monkeyhead") elif hType == "bear": headModel = gui.find("**/bearhead") elif hType == "pig": headModel = gui.find("**/pighead") else: raise StandardError("unknown toon species: ", hType) self.color = self.style.getHeadColor() self.container["image"] = headModel self.container["image_color"] = self.color self.resetFrameSize() self.setScale(0.1) self.frown = DirectFrame(parent=self.container, relief=None, image=gui.find("**/frown")) self.smile = DirectFrame(parent=self.container, relief=None, image=gui.find("**/smile")) self.eyes = DirectFrame(parent=self.container, relief=None, image=gui.find("**/eyes")) self.openSmile = DirectFrame(parent=self.container, relief=None, image=gui.find("**/open_smile")) self.tooth1 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find("**/tooth_1")) self.tooth2 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find("**/tooth_2")) self.tooth3 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find("**/tooth_3")) self.tooth4 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find("**/tooth_4")) self.tooth5 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find("**/tooth_5")) self.tooth6 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find("**/tooth_6")) self.maxLabel = DirectLabel( parent=self.eyes, relief=None, pos=(0.442, 0, 0.051), text="120", text_scale=0.4, text_font=ToontownGlobals.getInterfaceFont(), ) self.hpLabel = DirectLabel( parent=self.eyes, relief=None, pos=(-0.398, 0, 0.051), text="120", text_scale=0.4, text_font=ToontownGlobals.getInterfaceFont(), ) self.teeth = [self.tooth6, self.tooth5, self.tooth4, self.tooth3, self.tooth2, self.tooth1] self.fractions = [0.0, 0.166666, 0.333333, 0.5, 0.666666, 0.833333] gui.removeNode() return
def load(self): gui = loader.loadModel('phase_3/models/gui/laff_o_meter') if self.isToon: hType = self.style.getType() if hType == 'dog': headModel = gui.find('**/doghead') elif hType == 'cat': headModel = gui.find('**/cathead') elif hType == 'mouse': headModel = gui.find('**/mousehead') elif hType == 'horse': headModel = gui.find('**/horsehead') elif hType == 'rabbit': headModel = gui.find('**/bunnyhead') elif hType == 'duck': headModel = gui.find('**/duckhead') elif hType == 'monkey': headModel = gui.find('**/monkeyhead') elif hType == 'bear': headModel = gui.find('**/bearhead') elif hType == 'pig': headModel = gui.find('**/pighead') else: raise StandardError('unknown toon species: ', hType) self.color = self.style.getHeadColor() self.container['image'] = headModel self.container['image_color'] = self.color self.resetFrameSize() self.setScale(0.10000000000000001) self.frown = DirectFrame(parent = self.container, relief = None, image = gui.find('**/frown')) self.smile = DirectFrame(parent = self.container, relief = None, image = gui.find('**/smile')) self.eyes = DirectFrame(parent = self.container, relief = None, image = gui.find('**/eyes')) self.openSmile = DirectFrame(parent = self.container, relief = None, image = gui.find('**/open_smile')) self.tooth1 = DirectFrame(parent = self.openSmile, relief = None, image = gui.find('**/tooth_1')) self.tooth2 = DirectFrame(parent = self.openSmile, relief = None, image = gui.find('**/tooth_2')) self.tooth3 = DirectFrame(parent = self.openSmile, relief = None, image = gui.find('**/tooth_3')) self.tooth4 = DirectFrame(parent = self.openSmile, relief = None, image = gui.find('**/tooth_4')) self.tooth5 = DirectFrame(parent = self.openSmile, relief = None, image = gui.find('**/tooth_5')) self.tooth6 = DirectFrame(parent = self.openSmile, relief = None, image = gui.find('**/tooth_6')) self.maxLabel = DirectLabel(parent = self.eyes, relief = None, pos = (0.442, 0, 0.050999999999999997), text = '120', text_scale = 0.40000000000000002, text_font = ToontownGlobals.getInterfaceFont()) self.hpLabel = DirectLabel(parent = self.eyes, relief = None, pos = (-0.39800000000000002, 0, 0.050999999999999997), text = '120', text_scale = 0.40000000000000002, text_font = ToontownGlobals.getInterfaceFont()) self.teeth = [ self.tooth6, self.tooth5, self.tooth4, self.tooth3, self.tooth2, self.tooth1] self.fractions = [ 0.0, 0.16666600000000001, 0.33333299999999999, 0.5, 0.66666599999999998, 0.83333299999999999] gui.removeNode()
def generateStation(self): GroupStation.generateStation(self, self.Slots) circleTexture = loader.loadTexture('phase_13/maps/stand_here_cog.png') for circle in self.circles: circle.setTexture(circleTexture, 1) title = DirectLabel(text=self.Title, relief=None, text_fg=(0.5, 0.5, 0.5, 1.0), text_decal=True, text_font=CIGlobals.getMickeyFont(), text_pos=(0, 0), parent=self.sign.find('**/signText_locator'), text_scale=0.3, text_wordwrap=7.0) title.setBillboardAxis(2) return
def __init__(self, cr): DistributedMinigame.DistributedMinigame.__init__(self, cr) DistributedIceWorld.DistributedIceWorld.__init__(self, cr) self.gameFSM = ClassicFSM.ClassicFSM('DistributedIceGame', [ State.State('off', self.enterOff, self.exitOff, [ 'inputChoice']), State.State('inputChoice', self.enterInputChoice, self.exitInputChoice, [ 'waitServerChoices', 'moveTires', 'displayVotes', 'cleanup']), State.State('waitServerChoices', self.enterWaitServerChoices, self.exitWaitServerChoices, [ 'moveTires', 'cleanup']), State.State('moveTires', self.enterMoveTires, self.exitMoveTires, [ 'synch', 'cleanup']), State.State('synch', self.enterSynch, self.exitSynch, [ 'inputChoice', 'scoring', 'cleanup']), State.State('scoring', self.enterScoring, self.exitScoring, [ 'cleanup', 'finalResults', 'inputChoice']), State.State('finalResults', self.enterFinalResults, self.exitFinalResults, [ 'cleanup']), State.State('cleanup', self.enterCleanup, self.exitCleanup, [])], 'off', 'cleanup') self.addChildGameFSM(self.gameFSM) self.cameraThreeQuarterView = (0, -22, 45, 0, -62.890000000000001, 0) self.tireDict = { } self.forceArrowDict = { } self.canDrive = False self.timer = None self.timerStartTime = None self.curForce = 0 self.curHeading = 0 self.headingMomentum = 0.0 self.forceMomentum = 0.0 self.allTireInputs = None self.curRound = 0 self.curMatch = 0 self.controlKeyWarningLabel = DirectLabel(text = TTLocalizer.IceGameControlKeyWarning, text_fg = VBase4(1, 0, 0, 1), relief = None, pos = (0.0, 0, 0), scale = 0.14999999999999999) self.controlKeyWarningLabel.hide() self.waitingMoveLabel = DirectLabel(text = TTLocalizer.IceGameWaitingForPlayersToFinishMove, text_fg = VBase4(1, 1, 1, 1), relief = None, pos = (-0.59999999999999998, 0, -0.75), scale = 0.074999999999999997) self.waitingMoveLabel.hide() self.waitingSyncLabel = DirectLabel(text = TTLocalizer.IceGameWaitingForAISync, text_fg = VBase4(1, 1, 1, 1), relief = None, pos = (-0.59999999999999998, 0, -0.75), scale = 0.074999999999999997) self.waitingSyncLabel.hide() self.infoLabel = DirectLabel(text = '', text_fg = VBase4(0, 0, 0, 1), relief = None, pos = (0.0, 0, 0.69999999999999996), scale = 0.074999999999999997) self.updateInfoLabel() self.lastForceArrowUpdateTime = 0 self.sendForceArrowUpdateAsap = False self.treasures = [] self.penalties = [] self.obstacles = [] self.controlKeyPressed = False self.controlKeyWarningIval = None
class DistributedBattleShop(DistributedShop): notify = directNotify.newCategory('DistributedBattleShop') def __init__(self, cr): DistributedShop.__init__(self, cr) self.shop = BattleShop(self, 'battleShopDone') self.stand = None self.standText = None return def setupClerk(self): self.clerk = Toon(self.cr) self.clerk.setName('Coach') self.clerk.setDNAStrand(NPC_DNA['Coach']) self.clerk.reparentTo(self) self.clerk.animFSM.request('neutral') self.clerk.setH(180) self.clerk.setPos(0, 2.2, 1) self.stand = loader.loadModel('phase_4/models/props/bubblestand.egg') self.stand.reparentTo(self) self.stand.setScale(1.1) self.standText = DirectLabel(text="Coach's Battle Shop", text_fg=(0.6, 0, 0, 1), text_decal=True, relief=None, parent=self.stand, pos=(0, -0.875, 5.2), scale=0.45, text_font=CIGlobals.getMickeyFont()) return def deleteClerk(self): DistributedShop.deleteClerk(self) if hasattr(self, 'standText'): self.standText.destroy() self.stand.removeNode() del self.standText del self.stand def enterAccepted(self): if not self.inShop: self.shop.load() self.shop.enter() self.acceptOnce(self.shop.doneEvent, self.handleShopDone) self.inShop = True def handleShopDone(self): self.shop.exit() self.shop.unload() self.d_requestExit() def disable(self): DistributedShop.disable(self) self.ignore(self.shop.doneEvent) if self.inShop: self.handleShopDone() def delete(self): DistributedShop.delete(self) self.shop = None return
class LoadingScreen(): def __init__(self): # a fill panel so the player doesn't see how everything # gets loaded in the background self.frameMain = DirectFrame( # size of the frame frameSize = (base.a2dLeft, base.a2dRight, base.a2dTop, base.a2dBottom), image = "Logo.png", image_scale = (0.612/2.0, 1, 0.495/2.0), image_pos = (0, 0, 0.7), # tramsparent bg color frameColor = (0, 0, 0, 1)) self.frameMain.setTransparency(1) # the text Loading... on top self.lblLoading = DirectLabel( scale = 0.25, pos = (0, 0, 0), frameColor = (0, 0, 0, 0), text = _("Loading..."), text_align = TextNode.ACenter, text_fg = (1,1,1,1)) self.lblLoading.reparentTo(self.frameMain) # the waitbar on the bottom self.wbLoading = DirectWaitBar( text = "0%", text_fg = (1,1,1,1), value = 0, pos = (0, 0, -0.5), barColor = (0.5, 0.4, 0.1, 1), frameColor = (0.1, 0.1, 0.1, 1)) self.wbLoading.reparentTo(self.frameMain) def show(self): self.frameMain.show() # and render two frames so the loading screen # is realy shown on screen base.graphicsEngine.renderFrame() base.graphicsEngine.renderFrame() def hide(self): self.frameMain.hide() def setLoadingValue(self, value): """Set the waitbar value to the given value, where value has to be a integer from 0 to 100""" if value > 100: value = 100 if value < 0: value = 0 self.wbLoading["value"] = value self.wbLoading["text"] = "{0}%".format(value) base.graphicsEngine.renderFrame() base.graphicsEngine.renderFrame()
def _initVisuals(self): self.countDownLabel = DirectLabel(text = self.startText, text_fg = (1.0, 1.0, 1.0, 1.0), text_shadow = (0.0, 0.0, 0.0, 1.0), text_font = PiratesGlobals.getPirateFont(), scale = (0.16, 0.16, 0.16), pos = (0.0, 0.0, 0.14999999999999999), parent = self, relief = None, textMayChange = 1) self.countDownLabel.setBin('fixed', 37) self.winLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Win, text_fg = (1.0, 1.0, 1.0, 1.0), text_font = PiratesGlobals.getPirateFont(), text_shadow = (0.0, 0.0, 0.0, 1.0), scale = (0.16, 0.16, 0.16), pos = RepairGlobals.Common.youWinPos[self.name], relief = None, parent = self) self.winLabel.setBin('fixed', 37) self.winLabel.stash() self.scoreLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Win, text_fg = (1.0, 1.0, 1.0, 1.0), text_font = PiratesGlobals.getPirateFont(), text_shadow = (0.0, 0.0, 0.0, 1.0), scale = (0.10000000000000001, 0.10000000000000001, 0.10000000000000001), pos = RepairGlobals.Common.scorePos[self.name], relief = None, parent = self) self.scoreLabel.setBin('fixed', 37) self.scoreLabel.stash() self.postWinLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Pick_New_Game, text_fg = (1.0, 1.0, 1.0, 1.0), text_font = PiratesGlobals.getPirateFont(), text_shadow = (0.0, 0.0, 0.0, 1.0), scale = (0.14000000000000001, 0.14000000000000001, 0.14000000000000001), pos = RepairGlobals.Common.youWinPos[self.name], relief = None, textMayChange = 1, parent = self.repairGame.gui) self.postWinLabel.setBin('fixed', 37) self.postWinLabel.stash()
def addSongToQueue(self, text, highlight = False, moveToTopButton = False): listItem = DirectLabel(relief=None, parent=self._queueList, text=text, text_align=TextNode.ALeft, text_pos=(0.0, 0.0, 0.0), text_scale=TTLocalizer.JGlistItem) self._queueList.addItem(listItem) if highlight: listItem['text_fg'] = (0.0, 0.5, 0.0, 1.0) self._addSongButton['text'] = TTLocalizer.JukeboxReplaceSong listItem.setPythonTag('highlighted', True) if moveToTopButton and len(self._queueList['items']) > 1: self._moveToTopButton.reparentTo(listItem) self._moveToTopButton.setScale(self._windowFrame, 1.0) self._moveToTopButton.setPos(10.0, 0.0, 0.25) self._queueList.scrollTo(len(self._queueList['items']) - 1) return listItem
def _initVisuals(self): RepairMincroGame._initVisuals(self) self.model = loader.loadModel('models/gui/pir_m_gui_srp_pumping_main') self.visual = self.attachNewNode('visual') self.visual.setPos(-0.25, 0.0, 0.074999999999999997) goalTopLoc = self.model.find('**/locator_top') goalTopLoc.reparentTo(self.visual) goalBottomLoc = self.model.find('**/locator_bottom') goalBottomLoc.reparentTo(self.visual) self.goalPositions = (goalBottomLoc.getPos(self), goalTopLoc.getPos(self)) self.greatLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Pumping_Great, text_fg = (0.20000000000000001, 0.80000000000000004, 0.29999999999999999, 1.0), text_pos = (0.0, 0.59999999999999998), text_align = TextNode.ACenter, text_font = PiratesGlobals.getPirateFont(), relief = None, text_shadow = (0.0, 0.0, 0.0, 1.0), scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.46500000000000002, 0.0, 0.0), parent = self) self.failLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Pumping_Fail, text_fg = (0.80000000000000004, 0.20000000000000001, 0.29999999999999999, 1.0), text_pos = (0.0, 0.59999999999999998), text_align = TextNode.ARight, text_font = PiratesGlobals.getPirateFont(), text_shadow = (0.0, 0.0, 0.0, 1.0), relief = None, scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.625, 0.0, 0.0), parent = self) self.shipBackground = self.model.find('**/static_ship_background') self.shipBackground.reparentTo(self.visual) self.waterMeter = self.model.find('**/sprite_waterBottom') self.waterMeter.reparentTo(self.visual) self.waterTop = self.model.find('**/sprite_waterTop') self.waterTop.reparentTo(self.visual) self.waterMeterTopLoc = self.waterMeter.find('**/locator_topOfShipWater') self.pumpBackground = self.model.find('**/pumpBackground') self.pumpBackground.reparentTo(self.visual) self.pumpWaterTop = self.model.find('**/sprite_pumpWaterTop') self.pumpWaterTop.reparentTo(self.visual) self.pumpWaterBottom = self.model.find('**/sprite_pumpWaterBottom') self.pumpWaterBottom.reparentTo(self.visual) self.pumpWaterTopLoc = self.pumpWaterBottom.find('**/locator_topOfPumpWater') self.pumpHandle = self.model.find('**/sprite_handle') self.pumpHandle.reparentTo(self.visual) self.pumpBar = self.model.find('**/static_pump') self.pumpBar.reparentTo(self.visual) self.goalBox = self.model.find('**/sprite_clickField') self.goalBox.reparentTo(self.visual) self.goalBox.setTransparency(1) self.enableGoalBox() self.pumpLine = self.model.find('**/sprite_bar') self.pumpLine.reparentTo(self.visual) self.ghostLine = self.visual.attachNewNode('ghostLine') self.pumpLine.getChild(0).copyTo(self.ghostLine) self.ghostLine.setScale(self.pumpLine.getScale()) self.ghostLine.setColor(1.0, 0.20000000000000001, 0.20000000000000001, 1.0) self.shipForground = self.model.find('**/static_ship_foreground') self.shipForground.reparentTo(self.visual) cm = CardMaker('cardMaker') cm.setFrame(-0.33000000000000002, 0.33000000000000002, 0.0, 1.0) self.goalBox.setZ(self.goalPositions[TOP].getZ()) self.goalBoxStartScale = self.goalBox.getSz() self.enableGoalBox() self.pumpWaterUpLerp = LerpFunc(self.setPumpWater, fromData = -0.10000000000000001, toData = 1.0, duration = 0.5) self.pumpWaterDownLerp = LerpFunc(self.setPumpWater, fromData = 1.0, toData = -0.10000000000000001, duration = 0.5) self.model.removeNode() del self.model
def __makeListItem(self, action, event, index): def dummy(): pass if index % 2 == 0: bg = self.listBGEven else: bg = self.listBGOdd item = DirectFrame( text=action, geom=bg, geom_scale=(base.a2dRight-0.05, 1, 0.1), frameSize=VBase4(base.a2dLeft+0.05, base.a2dRight-0.05, -0.05, 0.05), frameColor=VBase4(1,0,0,0), text_align=TextNode.ALeft, text_scale=0.05, text_fg=VBase4(1,1,1,1), text_pos=(base.a2dLeft + 0.3, -0.015), text_shadow=VBase4(0, 0, 0, 0.35), text_shadowOffset=Vec2(-0.05, -0.05), pos=(0.05, 0, -(0.10 * index))) item.setTransparency(True) lbl = DirectLabel( text=event, text_fg=VBase4(1, 1, 1, 1), text_scale=0.05, text_pos=Vec2(0, -0.015), frameColor=VBase4(0, 0, 0, 0), ) lbl.reparentTo(item) lbl.setTransparency(True) self.actionLabels[action] = lbl buttonScale = 0.15 btn = DirectButton( text="Change", geom=self.buttonGeom, scale=buttonScale, text_scale=0.25, text_align=TextNode.ALeft, text_fg=VBase4(0.898, 0.839, 0.730, 1.0), text_pos=Vec2(-0.9, -0.085), relief=1, pad=Vec2(0.01, 0.01), frameColor=VBase4(0, 0, 0, 0), frameSize=VBase4(-1.0, 1.0, -0.25, 0.25), pos=(base.a2dRight-(0.898*buttonScale+0.3), 0, 0), pressEffect=False, command=self.changeMapping, extraArgs=[action]) btn.setTransparency(True) btn.reparentTo(item) return item
def load(self): gui = loader.loadModel('phase_3/models/gui/laff_o_meter.bam') hType = self.av.getData().get("Animal") if hType == 'dog': headModel = gui.find('**/doghead') elif hType == 'cat': headModel = gui.find('**/cathead') elif hType == 'mouse': headModel = gui.find('**/mousehead') elif hType == 'horse': headModel = gui.find('**/horsehead') elif hType == 'rabbit': headModel = gui.find('**/bunnyhead') elif hType == 'duck': headModel = gui.find('**/duckhead') elif hType == 'monkey': headModel = gui.find('**/monkeyhead') elif hType == 'bear': headModel = gui.find('**/bearhead') elif hType == 'pig': headModel = gui.find('**/pighead') self.color = self.av.getData().get('Color') self.container['image'] = headModel self.container['image_color'] = self.color self.resetFrameSize() self.setScale(0.1) self.frown = DirectFrame(parent=self.container, relief=None, image=gui.find('**/frown')) self.smile = DirectFrame(parent=self.container, relief=None, image=gui.find('**/smile')) self.eyes = DirectFrame(parent=self.container, relief=None, image=gui.find('**/eyes')) self.openSmile = DirectFrame(parent=self.container, relief=None, image=gui.find('**/open_smile')) self.tooth1 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_1')) self.tooth2 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_2')) self.tooth3 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_3')) self.tooth4 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_4')) self.tooth5 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_5')) self.tooth6 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_6')) self.maxLabel = DirectLabel(parent=self.eyes, relief=None, pos=(0.442, 0, 0.051), text='120', text_scale=0.4, text_font=Globals.getFont('ImpressBT.ttf')) self.hpLabel = DirectLabel(parent=self.eyes, relief=None, pos=(-0.398, 0, 0.051), text='120', text_scale=0.4, text_font=Globals.getFont('ImpressBT.ttf')) self.teeth = [self.tooth6, self.tooth5, self.tooth4, self.tooth3, self.tooth2, self.tooth1] self.fractions = [0.0, 0.166666, 0.333333, 0.5, 0.666666, 0.833333] gui.removeNode()
def __init__(self, parent = None, **kw): self.__qtd_conexao = 0 self.__frmAuth = DirectFrame( frameColor = (0,0,0,.3), frameSize = (-.5,.5,0,0.45), pos = (0,0,-.1), enableEdit = 1 ) self.__lblLogin = DirectLabel( text = "Login: "******"Senha: ", scale = 0.05, pos = (-0.3, 0, 0.2), frameColor = (0,0,0,0), text_fg = (1,1,1,1) ) self.__etySenha = DirectEntry( scale = 0.05, width = 12, pos = (-.2, 0, 0.2), cursorKeys = 1, obscured = 1, focusInCommand = self.__command_clear_senha) self.__btnEntrar = DirectButton( frameColor = (0,0,0,1), text = "Entrar", scale = 0.06, pos = (0.3, 0, 0.1), text_fg = (1,1,1,1), rolloverSound = None, clickSound = None, command = self.__command_entrar) self.__lblLogin.reparentTo(self.__frmAuth) self.__etyLogin.reparentTo(self.__frmAuth) self.__lblSenha.reparentTo(self.__frmAuth) self.__etySenha.reparentTo(self.__frmAuth) self.__btnEntrar.reparentTo(self.__frmAuth) self.__etyLogin.set("viner") self.__etySenha.set("viner")
def _initVisuals(self): RepairMincroGame._initVisuals(self) self.setBin('fixed', 36) self.model = loader.loadModel('models/gui/pir_m_gui_srp_sawing_main') sawModel = self.model.find('**/saw') sawModel.setR(193) sawModel.setPos(0.90000000000000002, 0.0, -0.16500000000000001) sawModel.setBin('gui-popup', 0) self.sawButton = RepairSaw(parent = self, clickDownCommand = self.sawAttachedToMouse, clickUpCommand = self.sawRemovedFromMouse, geom = sawModel, text_pos = (0.20000000000000001, -0.29999999999999999), text_fg = (1, 0, 0, 1), scale = (0.29999999999999999, 0.29999999999999999, 0.29999999999999999), relief = None, pressEffect = 0, frameSize = (-0.050000000000000003, 1.05, -0.29999999999999999, 0.050000000000000003), rolloverSound = None, clickSound = None) self.sawingLine = RepairSawingLine(self, self.config.sawlineLineThickness, self.config.sawlineColor, self.config.sawlineLinespawnDist) self.progressDescriptionLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Sawing_Description, text_fg = (1.0, 1.0, 1.0, 1.0), text_pos = (0.0, 0.0), text_shadow = (0.0, 0.0, 0.0, 1.0), text_font = PiratesGlobals.getPirateFont(), text_align = TextNode.ARight, relief = None, scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.20000000000000001, 0.0, 0.5), parent = self) self.progressLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Sawing_Thresholds[3], text_fg = (1.0, 1.0, 1.0, 1.0), text_pos = (0.0, 0.0), text_shadow = (0.0, 0.0, 0.0, 1.0), text_font = PiratesGlobals.getPirateFont(), text_align = TextNode.ALeft, relief = None, scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.17999999999999999, 0.0, 0.5), parent = self) self.boardDestroyedLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Sawing_Board_Destroyed, text_fg = (1.0, 0.0, 0.0, 1.0), text_pos = (0.0, 0.0), text_font = PiratesGlobals.getPirateFont(), text_shadow = (0.0, 0.0, 0.0, 1.0), relief = None, scale = (0.10000000000000001, 0.10000000000000001, 0.10000000000000001), pos = (0.0, 0.0, 0.10000000000000001), parent = self) self.boardDestroyedLabel.setBin('fixed', 38) self.boardDestroyedLabel.stash()
class LoadingScreen(): """Show a directWaitbar to display the current loading state of the application""" def __init__(self): # a fill panel so the player doesn't see how everything # gets loaded in the background self.frameMain = DirectFrame( image="gui/MenuBackground.png", image_scale=(1.7778, 1, 1), #image_pos=(0, 0, 0.25), frameSize=( base.a2dLeft, base.a2dRight, base.a2dTop, base.a2dBottom), frameColor=(0,0,0,0)) self.frameMain.setTransparency(True) self.frameMain.setBin("fixed", 6000) self.frameMain.setDepthWrite(False) self.logo = DirectFrame( image="Logo.png", image_scale=0.25, image_pos=(0, 0, 0.55), frameSize=( base.a2dLeft, base.a2dRight, base.a2dTop, base.a2dBottom), frameColor=(0,0,0,0)) self.logo.reparentTo(self.frameMain) # the text Loading... self.lblLoading = DirectLabel( scale=0.10, pos=(0, 0, -0.15), frameColor=(0, 0, 0, 0), text=_("Loading..."), text_align=TextNode.ACenter, text_fg=(1, 1, 1, 1)) self.lblLoading.reparentTo(self.frameMain) self.stop() def start(self): self.frameMain.show() base.graphicsEngine.renderFrame() base.graphicsEngine.renderFrame() def stop(self): self.frameMain.hide()
def message(self,text,duration=5): """Display a text message to the user for a given duration in seconds. """ # If we're already displaying a message, finish it early. if hasattr(self,'help'): self.help.detachNode() self.sequence.finish() # The new message. self.help = DirectLabel(text = text, text_scale=.1, text_fg=(.8,.8,.8,1), frameColor=(.2,.2,.2,0), frameVisibleScale=(1.2,1.2)) self.help.setPos(0,0,-.7) self.help.setAlphaScale(0) # At first the message is fully transparent. # This function is used to fade the message in and out. def fade(t): """Set the alpha of the message to t (multiplied by a constant factor).""" self.help.setAlphaScale(t*.9) self.help.setColor(.2,.2,.2,t*.7) # Create a sequence of intervals to fade in the message, wait for # `duration`, then fade it out. fade_in = LerpFunc(fade, fromData = 0, toData = 1, duration = .5, blendType = 'noBlend', extraArgs = [], name = None) fade_out = LerpFunc(fade, fromData = 1, toData = 0, duration = .5, blendType = 'noBlend', extraArgs = [], name = None) self.sequence = Sequence(fade_in,Wait(duration),fade_out) self.sequence.setDoneEvent('message ended') self.sequence.start() messager.send('message started',MessageStarted(text,duration))
def createGui(self): self.deleteGui() phase = 'phase_3.5/maps/' posGroup = self.threeSlotsPos self.inventoryFrame = DirectFrame(parent=base.a2dRightCenter, pos=(-0.2, 0, 0)) if self.defaultSlots == 4: posGroup = self.fourSlotPos for slot in range(len(posGroup) + 1): if slot == 3: posGroup = self.fourSlotPos slotIdle = loader.loadTexture(phase + 'slot_%s_idle.png' % str(slot + 1)) slotObj = Slot(slot + 1, posGroup[slot], self.inventoryFrame) slotOutline = OnscreenImage(image=slotIdle, color=(1, 1, 1, 0.5), parent=slotObj) slotOutline.setTransparency(TransparencyAttrib.MAlpha) slotObj.setOutline(slotOutline) self.slots.append(slotObj) if slot == 3: slotObj.hide() self.ammoLabel = DirectLabel(text='Ammo: 0', text_fg=(1, 1, 1, 1), relief=None, text_shadow=(0, 0, 0, 1), text_scale=0.08, pos=(0.2, 0, 0.35), parent=base.a2dBottomLeft) self.ammoLabel.hide() self.enableWeaponSwitch() self.resetScroll() self.update() return
def __init__(self): # a fill panel so the player doesn't see how everything # gets loaded in the background self.frameMain = DirectFrame( # size of the frame frameSize = (base.a2dLeft, base.a2dRight, base.a2dTop, base.a2dBottom), image = "Logo.png", image_scale = (0.612/2.0, 1, 0.495/2.0), image_pos = (0, 0, 0.7), # tramsparent bg color frameColor = (0, 0, 0, 1)) self.frameMain.setTransparency(1) # the text Loading... on top self.lblLoading = DirectLabel( scale = 0.25, pos = (0, 0, 0), frameColor = (0, 0, 0, 0), text = _("Loading..."), text_align = TextNode.ACenter, text_fg = (1,1,1,1)) self.lblLoading.reparentTo(self.frameMain) # the waitbar on the bottom self.wbLoading = DirectWaitBar( text = "0%", text_fg = (1,1,1,1), value = 0, pos = (0, 0, -0.5), barColor = (0.5, 0.4, 0.1, 1), frameColor = (0.1, 0.1, 0.1, 1)) self.wbLoading.reparentTo(self.frameMain)
def initFishStaminaBar(self): self.legendaryGui = loader.loadModel('models/minigames/pir_m_gam_fsh_legendaryGui') self.iconBaseFrame = DirectFrame(relief = None, state = DGG.DISABLED, pos = (0, 0, 0), sortOrder = 30, image = self.legendaryGui.find('**/pir_t_gui_fsh_fishPortraitFrame'), image_scale = 0.17999999999999999, image_pos = (0, 0, 0)) self.iconBaseFrame.setTransparency(TransparencyAttrib.MAlpha) self.fishUINodePath = NodePath(self.iconBaseFrame) self.fishUINodePath.setPos(-0.29999999999999999, 0.0, 0.82999999999999996) self.fishUINodePath.reparentTo(hidden) self.iconCard = loader.loadModel('models/gui/treasure_gui') self.iconBaseFrame.iconImage = OnscreenImage(parent = self.iconBaseFrame, image = self.iconCard.find('**/%s*' % CollectionMap.Assets[self.myData['id']]), scale = 0.34999999999999998, hpr = (0, 0, 0), pos = (0.0, 0, 0.0)) self.fishNameLabel = TextNode('fishNameLabel') name = self.getName().split('_') self.fishNameLabel.setText(name[0]) self.fishNameLabel.setTextColor(1.0, 1.0, 1.0, 1.0) self.fishNameLabelNodePath = NodePath(self.fishNameLabel) self.fishNameLabelNodePath.setPos(0.29999999999999999, 0, 0.040000000000000001) self.fishNameLabelNodePath.setScale(0.044999999999999998) self.fishNameLabelNodePath.reparentTo(self.iconBaseFrame) self.fishStaminaBar = DirectWaitBar(parent = self.iconBaseFrame, relief = DGG.FLAT, state = DGG.DISABLED, range = 100, value = 0, sortOrder = 20, frameColor = (0, 0, 0, 1.0), pos = (0.070000000000000007, 0.0, -0.014999999999999999), hpr = (0, 0, 0), frameSize = (0, 0.71999999999999997, 0, 0.028000000000000001)) self.fishStaminaBar['value'] = self.staminaValue self.fishStaminaBar['barColor'] = FishingGlobals.fishingStaminaBarColor[int((self.staminaValue / 100.0) * (len(FishingGlobals.fishingStaminaBarColor) - 1))] self.fishStaminaValueLabel = TextNode('fishStaminaValueLabel') self.fishStaminaValueLabel.setText(str(self.staminaValue) + '//' + str(self.staminaValue)) self.fishStaminaValueLabel.setTextColor(1.0, 1.0, 1.0, 1.0) self.fishStaminaValueLabelNodePath = NodePath(self.fishStaminaValueLabel) self.fishStaminaValueLabelNodePath.setPos(0.66000000000000003, 0, -0.059999999999999998) self.fishStaminaValueLabelNodePath.setScale(0.044999999999999998) self.fishStaminaValueLabelNodePath.reparentTo(self.iconBaseFrame) self.fishStaminaBarFrame = DirectLabel(parent = self.iconBaseFrame, relief = None, state = DGG.DISABLED, frameColor = (1, 1, 1, 0.10000000000000001), pos = (0.44, 0.0, 0.0), hpr = (0, 0, 0), sortOrder = 25, image = self.legendaryGui.find('**/pir_t_gui_fsh_staminaBarForeground'), image_scale = (1.0, 0.0, 0.050000000000000003), image_pos = (0.0, 0.0, 0.0), image_hpr = (0.0, 0.0, 0.0)) self.fishStaminaBarFrame.setTransparency(TransparencyAttrib.MAlpha) self.fishStaminaBarFrame.setDepthTest(True) self.fishStaminaBarFrame.setDepthWrite(True)
def createPirateNameBox(self, pirateName): self.pirateNameLabel = DirectLabel(relief = None, state = DGG.DISABLED, text = pirateName, text_align = TextNode.ACenter, text_scale = PiratesGuiGlobals.TextScaleMed, text_fg = PiratesGuiGlobals.TextFG1, text_wordwrap = 12, textMayChange = 0, sortOrder = 91) self.pirateNameLabel.setBin('fixed', 33) height = self.pirateNameLabel.getHeight() width = self.pirateNameLabel.getWidth() + 0.050000000000000003 pos = [ 0.0, 0.0, height / 2 - 0.035000000000000003] fs = [ -(width / 2 + 0.01), width / 2 + 0.01, -(height / 2 + 0.014999999999999999), height / 2 + 0.014999999999999999] self.pirateNameBox = BorderFrame(parent = self, state = DGG.DISABLED, frameSize = (fs[0], fs[1], fs[2], fs[3]), modelName = 'general_frame_f', pos = (0.0, 0.0, 0.0)) self.pirateNameLabel.reparentTo(self.pirateNameBox) self.pirateNameLabel.setPos(pos[0], pos[1], pos[2]) self.pirateNameBox.setClipPlaneOff() pos = self.pirateNameBox.getPos(aspect2d) x = min(pos[0], base.a2dRight - width) z = max(pos[2], base.a2dBottom - height) self.pirateNameBox.setPos(aspect2d, x, 0, z - 0.17499999999999999) self.pirateNameBox.flattenLight() self.pirateNameBox.setBin('fixed', 32) self.pirateNameBox.reparentTo(self)
def __init__(self): """Initialise the vehicle.""" # Draw a circle to represent this vehicle. d = Draw() d.drawXYCircle(pos = Vec3(0,0,0)) node = d.create() self.np = NodePath(node) self.np.reparentTo(render) # Add a text label above and to the side of this vehicle. self.label=DirectLabel( parent=self.np, text="Hello! :)", text_wordwrap=10, relief=None, text_scale=(0.5,0.5), text_frame=(0,0,0,0), text_bg=(0,0,0,0), color=(0.88,0,0.88,1)) self.label.setPos(2,4,2) # Offset text a little from vehicle. self.label.setBillboardAxis() # Compute a random direction for this vehicle to move in. self.direction = Vec3(random.random()-0.5,random.random()-0.5,0) self.direction.normalize() # Add a task to move this vehicle around. self.prevtime = 0 taskMgr.add(self.move,"moveTask")
def __init__(self, parent, leaderId, leaderName, shardName, category, memberIds, memberNames, **kw): self.leaderId = leaderId self.leaderName = leaderName self.shardName = shardName self.category = category self.memberIds = memberIds self.memberNames = memberNames self.playerCount = None if parent is None: parent = aspect2d text = TTLocalizer.GroupTrackerCategoryToText[self.category] optiondefs = ( ('text', text, None), ('text_fg', (0.0, 0.0, 0.0, 1.0), None), ('text_align', TextNode.ALeft, None), ('text_pos', (0.0, 0.0, 0.0), None), ('text_scale', 0.05, None), ('relief', None, None) ) self.defineoptions(kw, optiondefs) DirectButton.__init__(self, parent) self.initialiseoptions(GroupTrackerGroup) self.playerCount = DirectLabel(parent=self, pos=(0.6, 0, 0), relief=None, text='', text_align=TextNode.ARight, text_scale=0.05, text_fg=(0, 0, 0, 1)) self.updatePlayerCount()
def __init__(self): self.frameCharStatus = DirectFrame( # size of the frame frameSize = (0, .8, -.20, 0), # bg color Transparent frameColor = (0, 0, 0, 0)) self.frameCharStatus.reparentTo(base.a2dTopLeft) self.statusHealth = OnscreenImage( image = "HUD_Life100.png", scale = (0.1, 1, 0.1), pos = (0.085, 0, -0.085)) self.statusHealth.setTransparency(True) self.statusHealth.reparentTo(self.frameCharStatus) self.statusWeapon = OnscreenImage( image = "WeaponMG.png", scale = (0.1, 1, 0.1), pos = (0.285, 0, -0.085)) self.statusWeapon.setTransparency(True) self.statusWeapon.reparentTo(self.frameCharStatus) self.highscore = DirectLabel( text = "0", text_fg = (0,0,0,1), text_align = TextNode.ALeft, frameColor = (0,0,0,0), pos = (0.4,0,-0.12), scale = 0.15) self.highscore.setTransparency(True) self.highscore.reparentTo(self.frameCharStatus)
def _DistributedBanquetTable__enableControlInterface(self): gui = loader.loadModel("phase_3.5/models/gui/avatar_panel_gui") self.closeButton = DirectButton( image=( gui.find("**/CloseBtn_UP"), gui.find("**/CloseBtn_DN"), gui.find("**/CloseBtn_Rllvr"), gui.find("**/CloseBtn_UP"), ), relief=None, scale=2, text=TTLocalizer.BossbotPitcherLeave, text_scale=0.040000000000000001, text_pos=(0, -0.070000000000000007), text_fg=VBase4(1, 1, 1, 1), pos=(1.05, 0, -0.81999999999999995), command=self._DistributedBanquetTable__exitPitcher, ) self.accept("escape", self._DistributedBanquetTable__exitPitcher) self.accept("control", self._DistributedBanquetTable__controlPressed) self.accept("control-up", self._DistributedBanquetTable__controlReleased) self.accept("InputState-forward", self._DistributedBanquetTable__upArrow) self.accept("InputState-reverse", self._DistributedBanquetTable__downArrow) self.accept("InputState-turnLeft", self._DistributedBanquetTable__leftArrow) self.accept("InputState-turnRight", self._DistributedBanquetTable__rightArrow) self.accept("arrow_up", self._DistributedBanquetTable__upArrowKeyPressed) self.accept("arrow_down", self._DistributedBanquetTable__downArrowKeyPressed) taskMgr.add(self._DistributedBanquetTable__watchControls, self.watchControlsName) taskMgr.doMethodLater(5, self._DistributedBanquetTable__displayPitcherAdvice, self.pitcherAdviceName) self.arrowVert = 0 self.arrowHorz = 0 self.powerBar.show()
def __init__(self, doneEvent): self.doneEvent = doneEvent DirectFrame.__init__(self) self.reparentTo(aspect2d) self.setPos(0.0, 0.0, 0.16) self.stash() publicPartyGui = loader.loadModel( 'phase_4/models/parties/publicPartyGUI') self.frame = DirectFrame( parent=self, geom=publicPartyGui.find('**/activities_background'), geom_pos=(-0.8, 0.0, 0.2), geom_scale=2.0, relief=None) self.earnedLabel = DirectLabel( parent=self, relief=None, text=str(0), text_align=TextNode.ACenter, text_pos=(0.0, -0.07), text_scale=0.2, text_fg=(0.95, 0.95, 0.0, 1.0), text_font=ToontownGlobals.getSignFont(), textMayChange=True, image=DirectGuiGlobals.getDefaultDialogGeom(), image_scale=(0.33, 1.0, 0.33), pos=(-0.3, 0.0, 0.2), scale=0.9) purchaseModels = loader.loadModel('phase_4/models/gui/purchase_gui') jarImage = purchaseModels.find('**/Jar') self.jarLabel = DirectLabel( parent=self, relief=None, text=str(0), text_align=TextNode.ACenter, text_pos=(0.0, -0.07), text_scale=0.2, text_fg=JellybeanRewardGui.JarLabelTextColor, text_font=ToontownGlobals.getSignFont(), textMayChange=True, image=jarImage, scale=0.7, pos=(0.3, 0.0, 0.17)) purchaseModels.removeNode() del purchaseModels jarImage.removeNode() del jarImage self.messageLabel = DirectLabel(parent=self, relief=None, text='', text_align=TextNode.ALeft, text_wordwrap=16.0, text_scale=0.07, pos=(-0.52, 0.0, -0.1), textMayChange=True) self.doubledJellybeanLabel = DirectLabel( parent=self, relief=None, text=TTLocalizer.PartyRewardDoubledJellybean, text_align=TextNode.ACenter, text_wordwrap=12.0, text_scale=0.09, text_fg=(1.0, 0.125, 0.125, 1.0), pos=(0.0, 0.0, -0.465), textMayChange=False) self.doubledJellybeanLabel.hide() self.closeButton = DirectButton( parent=self, relief=None, text=TTLocalizer.PartyJellybeanRewardOK, text_align=TextNode.ACenter, text_scale=0.065, text_pos=(0.0, -0.625), geom=(publicPartyGui.find('**/startButton_up'), publicPartyGui.find('**/startButton_down'), publicPartyGui.find('**/startButton_rollover'), publicPartyGui.find('**/startButton_inactive')), geom_pos=(-0.39, 0.0, 0.125), command=self._close) publicPartyGui.removeNode() del publicPartyGui self.countSound = base.loader.loadSfx( 'phase_13/audio/sfx/tick_counter_short.ogg') self.overMaxSound = base.loader.loadSfx( 'phase_13/audio/sfx/tick_counter_overflow.ogg') return
class DistributedCinemaInterior(DistributedToonInterior.DistributedToonInterior ): notify = directNotify.newCategory("DistributedCinemaInterior") def __init__(self, cr): DistributedToonInterior.DistributedToonInterior.__init__(self, cr) self.fsm = ClassicFSM.ClassicFSM('DCinemaInterior', [ State.State('off', self.enterOff, self.exitOff), State.State('show', self.enterShow, self.exitShow), State.State('intermission', self.enterIntermission, self.exitIntermission) ], 'off', 'off') self.fsm.enterInitialState() self.state = None self.cinemaIndex = None self.movieTex = None self.movieCard = None self.movieSound = None self.movieTrack = None self.intermissionText = None def makeInterior(self): # Always use the same room for cinemas. DistributedToonInterior.DistributedToonInterior.makeInterior( self, roomIndex=0) def announceGenerate(self): DistributedToonInterior.DistributedToonInterior.announceGenerate(self) self.sendUpdate('requestStateAndTimestamp') def disable(self): self.fsm.requestFinalState() self.fsm = None self.state = None self.cinemaIndex = None self.movieTex = None self.movieCard = None self.movieSound = None self.movieTrack = None self.intermissionText = None self.cr.playGame.hood.loader.interiorMusic.stop() DistributedToonInterior.DistributedToonInterior.disable(self) def darkenInterior(self): darkenIval = self.interior.colorScaleInterval( 3.0, colorScale=(0.3, 0.3, 0.3, 1.0), startColorScale=(1.0, 1.0, 1.0, 1.0), blendType='easeInOut') darkenIval.start() def lightenInterior(self): lightenIval = self.interior.colorScaleInterval( 3.0, colorScale=(1, 1, 1, 1.0), startColorScale=(0.3, 0.3, 0.3, 1.0), blendType='easeInOut') lightenIval.start() def enterShow(self, ts=0): self.darkenInterior() self.cr.playGame.hood.loader.interiorMusic.stop() videoFile = CinemaGlobals.Cinemas[self.cinemaIndex][0] audioFile = CinemaGlobals.Cinemas[self.cinemaIndex][1] self.movieTex = MovieTexture(self.uniqueName("movieTex")) self.movieTex.read(videoFile) card = CardMaker(self.uniqueName('movieCard')) card.setFrame(-1.5, 1.5, -1, 1) self.movieCard = NodePath(card.generate()) self.movieCard.reparentTo(render) self.movieCard.setPos( self.interior.find('**/sign_origin;+s').getPos(render)) #self.movieCard.setX(self.movieCard, -0.05) self.movieCard.setHpr( self.interior.find('**/sign_origin;+s').getHpr(render)) self.movieCard.setDepthWrite(1, 1) self.movieCard.setTwoSided(True) self.movieCard.setTexture(self.movieTex) self.movieCard.setTexScale(TextureStage.getDefault(), self.movieTex.getTexScale()) self.movieCard.setScale(2.5) self.movieSound = base.loadSfx(audioFile) self.movieTex.synchronizeTo(self.movieSound) self.movieTrack = SoundInterval(self.movieSound, name=self.uniqueName('movieTrack')) self.movieTrack.setDoneEvent(self.movieTrack.getName()) self.acceptOnce(self.movieTrack.getDoneEvent(), self.fsm.request, ['off']) self.movieTrack.start(ts) def exitShow(self): self.ignore(self.movieTrack.getDoneEvent()) self.movieTrack.finish() self.movieTrack = None self.movieSound = None self.movieCard.removeNode() self.movieCard = None self.movieTex = None self.lightenInterior() self.cr.playGame.hood.loader.interiorMusic.play() def enterIntermission(self, ts=0): self.intermissionText = DirectLabel( relief=None, text_decal=True, text="", scale=0.7, parent=self.interior.find('**/sign_origin;+s'), text_font=CIGlobals.getMickeyFont(), text_fg=(1, 0.9, 0, 1)) self.movieTrack = Sequence(name=self.uniqueName('intermissionTrack')) for second in range(CinemaGlobals.IntermissionLength + 1): timeRemaining = CinemaGlobals.IntermissionLength - second self.movieTrack.append( Func(self.setIntermissionText, "Next show in:\n%d" % timeRemaining)) self.movieTrack.append(Wait(1.0)) self.movieTrack.setDoneEvent(self.movieTrack.getName()) self.acceptOnce(self.movieTrack.getDoneEvent(), self.fsm.request, ['off']) self.movieTrack.start(ts) def setIntermissionText(self, text): self.intermissionText['text'] = text def exitIntermission(self): self.ignore(self.movieTrack.getDoneEvent()) self.movieTrack.finish() self.movieTrack = None self.intermissionText.destroy() self.intermissionText = None def enterOff(self): pass def exitOff(self): pass def setCinemaIndex(self, index): self.cinemaIndex = index def getCinemaIndex(self): return self.cinemaIndex def setState(self, state, timestamp): ts = globalClockDelta.localElapsedTime(timestamp) self.state = state self.fsm.request(state, [ts]) def getState(self): return self.state
def __displayPitcherAdvice(self, task): if self.pitcherAdviceLabel == None: self.pitcherAdviceLabel = DirectLabel(text=TTLocalizer.BossbotPitcherAdvice, text_fg=VBase4(1, 1, 1, 1), text_align=TextNode.ACenter, relief=None, pos=(0, 0, 0.69), scale=0.1) return
def _show_char_desc(self): """Show detailed character description. Includes description of every character's trait and their current status. """ if self._char_desc_shown: self._fr["frameSize"] = (-0.31, 0.31, -0.1, 0.115) clear_wids(self._char_desc_wids) self._status_lab = None else: shift = 0.7 self._fr["frameSize"] = (-0.31, 0.31, -0.1, shift) shift -= 0.06 self._char_desc_wids.append( DirectLabel( parent=self._fr, # Traits text=base.labels.CHARACTERS[5], # noqa: F821, text_font=base.main_font, # noqa: F821, frameSize=(0.1, 0.1, 0.1, 0.1), text_scale=0.03, text_fg=RUST_COL, pos=(-0.225, 0, shift), ) ) if self.char.id in base.team.chars.keys(): # noqa: F821 traits_but = DirectButton( parent=self._fr, text="", frameSize=(-0.025, 0.025, -0.025, 0.025), frameTexture=GUI_PIC + "like.png", relief="flat", pos=(0.265, 0, shift + 0.013), command=base.traits_gui.show, # noqa: F821 ) traits_but.bind( DGG.ENTER, self._highlight_traits_but, extraArgs=[traits_but] ) traits_but.bind( DGG.EXIT, self._dehighlight_traits_but, extraArgs=[traits_but] ) self._char_desc_wids.append(traits_but) shift = self._fill_traits(shift) self._status_lab = DirectLabel( # Status parent=self._fr, # Status text=base.labels.CHARACTERS[4], # noqa: F821 text_font=base.main_font, # noqa: F821 frameSize=(0.1, 0.1, 0.1, 0.1), text_scale=0.03, text_fg=RUST_COL, pos=(-0.221, 0, shift), ) self._char_desc_wids.append(self._status_lab) self._fill_status(shift) self._char_desc_shown = not self._char_desc_shown
def __init__(self, numPlayers, avIdList, votes, directions, namesList, disconnectedList, directionToGo, directionReason, directionTotals, *args, **kwargs): opts = {'relief':None, 'geom':DGG.getDefaultDialogGeom(), 'geom_color':ToontownGlobals.GlobalDialogColor[:3]+(0.80,), 'geom_scale':(1.75,1,0.25), 'pos':(0,0,0.825) } opts.update(kwargs) DirectFrame.__init__(self,*args, **opts) self.initialiseoptions(VoteResultsTrolleyPanel) listMultiplier = 1 if TravelGameGlobals.SpoofFour: listMultiplier = 4 self.avIdList = avIdList * listMultiplier self.numPlayers = numPlayers * listMultiplier self.votes = votes * listMultiplier self.directions = directions * listMultiplier self.namesList = namesList * listMultiplier self.disconnectedList = disconnectedList * listMultiplier self.directionToGo = directionToGo self.directionReason = directionReason self.directionTotals = directionTotals self.entryList = [] self.rowFrame = [] self.upDownFrame = DirectFrame( parent=self, relief=None, pos = self.getRowPos(-1), ) self.upLabel = DirectLabel( parent = self, relief = None, pos = (-0.5, 0, 0.06), text = TTLocalizer.TravelGameDirections[0]+ ':', text_fg = (0.0, 0.0, 1.0, 1.0), text_scale = 0.05, text_align = TextNode.ARight ) self.downLabel = DirectLabel( parent = self, relief = None, pos = (0.5, 0, 0.06), text = TTLocalizer.TravelGameDirections[1]+':', text_fg = (1.0, 0.0, 0.0, 1.0), text_scale = 0.05, text_align = TextNode.ARight ) self.totalVotesUpLabel = DirectLabel( parent = self.upLabel, relief = None, pos = (0.2, 0, 0.0), text = '0', text_fg = (0.0, 0.0, 1.0, 1.0), text_scale = 0.05, text_align = TextNode.ARight ) self.totalVotesDownLabel = DirectLabel( parent = self.downLabel, relief = None, pos = (0.2, 0, 0.0), text = '0', text_fg = (1.0, 0.0, 0.0, 1.0), text_scale = 0.05, text_align = TextNode.ARight ) self.totalFrame = DirectFrame( parent=self, relief=None, pos = self.getRowPos(self.numPlayers), ) self.totalVotesLabels = [self.totalVotesUpLabel, self.totalVotesDownLabel] self.resultFrame = DirectFrame( parent=self, relief=None, #pos = self.getRowPos(self.numPlayers+1), pos = self.getRowPos(0.5), ) self.resultLabel = DirectLabel( parent = self.resultFrame, text = '', text_scale = 0.06, pos = (0.7, 0, 0.0), text_align = TextNode.ACenter ) self.setupResultLabel() for index in range(self.numPlayers): frame = DirectFrame( parent=self, relief=None, pos = self.getRowPos(index), ) self.rowFrame.append(frame) nameLabel = DirectFrame( parent = frame, relief = None, pos = (0.46,0.0,0.0), text = self.namesList[index], text_fg = (0.0, 0.0, 0.0, 1.0), text_scale = 0.05, text_align = TextNode.ACenter, text_font = DGG.getDefaultFont()#ToontownGlobals.getSignFont(), ) votesUpLabel = DirectLabel( parent = frame, relief = None, pos = (1.2,0.0,0.0), text = '', text_fg = (0,0,1,1), text_scale = 0.05, text_align = TextNode.ARight, text_font = DGG.getDefaultFont(), ) votesDownLabel = DirectLabel( parent = frame, relief = None, pos = (1.43,0.0,0.0), text = '', text_fg = (1,0,0,1), text_scale = 0.05, text_align = TextNode.ARight, text_font = DGG.getDefaultFont(), ) nameLabel.hide() self.entryList.append((nameLabel, votesUpLabel, votesDownLabel)) self.avVotesLabel = {} self.avArrows = {} matchingGameGui = loader.loadModel( 'phase_3.5/models/gui/matching_game_gui') minnieArrow = matchingGameGui.find("**/minnieArrow") from toontown.minigame.DistributedTravelGame import map3dToAspect2d for index in range(self.numPlayers): avId = self.avIdList[index] av = base.cr.doId2do.get(avId) if av: height = av.getHeight() avPos = av.getPos(render) avPos.setZ(av.getZ() + 5) # height) labelPos = map3dToAspect2d(render, avPos) if not labelPos: continue labelPos.setZ(labelPos.getZ() + 0.3) arrow = None if self.votes[index] > 0: arrow = aspect2d.attachNewNode('avArrow') minnieArrow.copyTo(arrow) arrow.setScale(1.1,1,1.15) arrow.setPos(labelPos) if self.directions[index] == 0: arrow.setR(-90) arrow.setColorScale(0,0,1,1) else: arrow.setR(90) arrow.setColorScale(1,0,0,1) arrow.wrtReparentTo(self.resultFrame) arrow.hide() self.avArrows[index] =arrow fgColor = Vec4(0,0,0,1) if self.votes[index] > 0: if self.directions[index] == 0: fgColor = Vec4(0,0,1,1) else : fgColor = Vec4(1,0,0,1) if self.votes[index] > 0: newLabel = DirectLabel( parent = aspect2d, #geom = DGG.getDefaultDialogGeom(), #geom_color =ToontownGlobals.GlobalDialogColor[:3]+(0.80,), #geom_scale = (0.1,1,0.1), relief = None, pos = labelPos, text = 'test', text_fg = (1,1,1,1), #fgColor, text_scale = 0.1, text_align = TextNode.ACenter, text_font = ToontownGlobals.getSignFont(), text_pos = (0,-0.01,0) ) else: newLabel = DirectLabel( parent = aspect2d, geom = DGG.getDefaultDialogGeom(), #geom_color =ToontownGlobals.GlobalDialogColor[:3]+(0.80,), geom_scale = (0.2,1,0.2), relief = None, pos = labelPos, text = 'test', text_fg = (0.5,0.5,0.5,1), #fgColor, text_scale = 0.1, text_align = TextNode.ACenter, text_font = ToontownGlobals.getSignFont(), text_pos = (0,-0.035,0) ) newLabel.wrtReparentTo(self.resultFrame) newLabel.hide() self.avVotesLabel[index] = newLabel matchingGameGui.removeNode() self.curArrowSfxIndex = 0 self.upArrowSfx = [] self.downArrowSfx = [] for i in range (5): self.upArrowSfx.append( base.loader.loadSfx("phase_4/audio/sfx/MG_sfx_travel_game_blue_arrow.mp3")) self.downArrowSfx.append( base.loader.loadSfx("phase_4/audio/sfx/MG_sfx_travel_game_red_arrow.mp3")) self.winVoteSfx = base.loader.loadSfx("phase_4/audio/sfx/MG_sfx_travel_game_win_vote.mp3") self.noVoteSfx = base.loader.loadSfx("phase_4/audio/sfx/MG_sfx_travel_game_square_no_vote_1.mp3") self.loseVoteSfx = base.loader.loadSfx("phase_4/audio/sfx/MG_sfx_travel_game_lose_vote.mp3") self.localAvatarWon = False self.localAvatarLost = False; localIndex = self.avIdList.index(base.localAvatar.doId) localDirection = self.directions[localIndex] localVotes = self.votes[localIndex] if localVotes: if localDirection == self.directionToGo: if not TravelGameGlobals.ReverseWin: self.localAvatarWon = True else: self.localAvatarLost = True else: if not TravelGameGlobals.ReverseWin: self.localAvatarLost = True else: self.localAvatarWon = True
def showExiting(self): if self.closeButton: self.closeButton.destroy() self.closeButton = DirectLabel(relief=None, text=TTLocalizer.BossbotPitcherLeaving, pos=(1.05, 0, -0.88), text_pos=(0, 0), text_scale=0.06, text_fg=VBase4(1, 1, 1, 1)) self.__cleanupPitcherAdvice() return
def load(self): self.notify.debug('load') DistributedMinigame.load(self) self.music = base.loader.loadMusic('phase_4/audio/bgm/MG_CogThief.ogg') self.initCogInfo() for barrelIndex in xrange(CTGG.NumBarrels): barrel = loader.loadModel( 'phase_4/models/minigames/cogthief_game_gagTank') barrel.setPos(CTGG.BarrelStartingPositions[barrelIndex]) barrel.setScale(self.BarrelScale) barrel.reparentTo(render) barrel.setTag('barrelIndex', str(barrelIndex)) collSphere = CollisionSphere(0, 0, 0, 4) collSphere.setTangible(0) name = 'BarrelSphere-%d' % barrelIndex collSphereName = self.uniqueName(name) collNode = CollisionNode(collSphereName) collNode.setFromCollideMask(CTGG.BarrelBitmask) collNode.addSolid(collSphere) colNp = barrel.attachNewNode(collNode) handler = CollisionHandlerEvent() handler.setInPattern('barrelHit-%fn') base.cTrav.addCollider(colNp, handler) self.accept('barrelHit-' + collSphereName, self.handleEnterBarrel) nodeToHide = '**/gagMoneyTen' if barrelIndex % 2: nodeToHide = '**/gagMoneyFive' iconToHide = barrel.find(nodeToHide) if not iconToHide.isEmpty(): iconToHide.hide() self.barrels.append(barrel) self.gameBoard = loader.loadModel( 'phase_4/models/minigames/cogthief_game') self.gameBoard.find('**/floor_TT').hide() self.gameBoard.find('**/floor_DD').hide() self.gameBoard.find('**/floor_DG').hide() self.gameBoard.find('**/floor_MM').hide() self.gameBoard.find('**/floor_BR').hide() self.gameBoard.find('**/floor_DL').hide() zone = self.getSafezoneId() if zone == ToontownGlobals.ToontownCentral: self.gameBoard.find('**/floor_TT').show() elif zone == ToontownGlobals.DonaldsDock: self.gameBoard.find('**/floor_DD').show() elif zone == ToontownGlobals.DaisyGardens: self.gameBoard.find('**/floor_DG').show() elif zone == ToontownGlobals.MinniesMelodyland: self.gameBoard.find('**/floor_MM').show() elif zone == ToontownGlobals.TheBrrrgh: self.gameBoard.find('**/floor_BR').show() elif zone == ToontownGlobals.DonaldsDreamland: self.gameBoard.find('**/floor_DL').show() else: self.gameBoard.find('**/floor_TT').show() self.gameBoard.setPosHpr(0, 0, 0, 0, 0, 0) self.gameBoard.setScale(1.0) self.toonSDs = {} avId = self.localAvId toonSD = CogThiefGameToonSD.CogThiefGameToonSD(avId, self) self.toonSDs[avId] = toonSD toonSD.load() self.loadCogs() self.toonHitTracks = {} self.toonPieTracks = {} self.sndOof = base.loader.loadSfx( 'phase_4/audio/sfx/MG_cannon_hit_dirt.ogg') self.sndRewardTick = base.loader.loadSfx( 'phase_3.5/audio/sfx/tick_counter.ogg') self.sndPerfect = base.loader.loadSfx( 'phase_4/audio/sfx/ring_perfect.ogg') self.timer = ToontownTimer.ToontownTimer() self.timer.posInTopRightCorner() self.timer.hide() purchaseModels = loader.loadModel('phase_4/models/gui/purchase_gui') self.jarImage = purchaseModels.find('**/Jar') self.jarImage.reparentTo(hidden) self.rewardPanel = DirectLabel(parent=hidden, relief=None, pos=(-0.173, 0.0, -0.55), scale=0.65, text='', text_scale=0.2, text_fg=(0.95, 0.95, 0, 1), text_pos=(0, -.13), text_font=ToontownGlobals.getSignFont(), image=self.jarImage) self.rewardPanelTitle = DirectLabel(parent=self.rewardPanel, relief=None, pos=(0, 0, 0.06), scale=0.08, text=TTLocalizer.CannonGameReward, text_fg=(0.95, 0.95, 0, 1), text_shadow=(0, 0, 0, 1)) return
class DistCogdoGame(DistCogdoGameBase, DistributedObject): notify = directNotify.newCategory('DistCogdoGame') 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') self.loadFSM.enterInitialState() self.fsm = ClassicFSM.ClassicFSM('DistCogdoGame', [ State.State('Visible', self.enterVisible, self.exitVisible, ['Intro']), State.State('Intro', self.enterIntro, self.exitIntro, ['WaitServerStart']), State.State('WaitServerStart', self.enterWaitServerStart, self.exitWaitServerStart, ['Game']), State.State('Game', self.enterGame, self.exitGame, ['Finish']), State.State('Finish', self.enterFinish, self.exitFinish, ['Off']), State.State('Off', self.enterOff, self.exitOff, ['Visible']) ], 'Off', 'Off') self.fsm.enterInitialState() self.difficultyOverride = None self.exteriorZoneOverride = None self._gotInterior = StateVar(False) self._toonsInEntranceElev = StateVar(False) self._wantStashElevator = StateVar(False) self._stashElevatorFC = FunctionCall(self._doStashElevator, self._toonsInEntranceElev, self._gotInterior, self._wantStashElevator) return def getTitle(self): pass def getInstructions(self): pass def setInteriorId(self, interiorId): self._interiorId = interiorId def setExteriorZone(self, exteriorZone): self.exteriorZone = exteriorZone def setDifficultyOverrides(self, difficultyOverride, exteriorZoneOverride): if difficultyOverride != CogdoGameConsts.NoDifficultyOverride: self.difficultyOverride = difficultyOverride / float( CogdoGameConsts.DifficultyOverrideMult) if exteriorZoneOverride != CogdoGameConsts.NoExteriorZoneOverride: self.exteriorZoneOverride = exteriorZoneOverride def getInterior(self): return self.cr.getDo(self._interiorId) def getEntranceElevator(self, callback): return self.getInterior().getEntranceElevator(callback) def getToonIds(self): interior = self.getInterior() if interior is not None: return interior.getToonIds() return [] return def getToon(self, toonId): if self.cr.doId2do.has_key(toonId): return self.cr.doId2do[toonId] return return def getNumPlayers(self): return len(self.getToonIds()) def isSinglePlayer(self): if self.getNumPlayers() == 1: return 1 return 0 def announceGenerate(self): DistributedObject.announceGenerate(self) self.loadFSM.request('Loaded') self._requestInterior() self.notify.info('difficulty: %s, safezoneId: %s' % (self.getDifficulty(), self.getSafezoneId())) def _requestInterior(self): self.cr.relatedObjectMgr.requestObjects( [self._interiorId], allCallback=self._handleGotInterior) def _handleGotInterior(self, objs): self._gotInterior.set(True) self.getEntranceElevator(self.placeEntranceElev) def stashEntranceElevator(self): self._wantStashElevator.set(True) def placeEntranceElev(self, elev): pass def _doStashElevator(self, toonsInEntranceElev, gotInterior, wantStashElevator): if gotInterior: interior = self.getInterior() if interior: if not toonsInEntranceElev and wantStashElevator: interior.stashElevatorIn() else: interior.stashElevatorIn(False) def disable(self): base.cogdoGame = None self.cr.cogdoGame = None self.fsm.requestFinalState() self.loadFSM.requestFinalState() self.fsm = None self.loadFSM = None DistributedObject.disable(self) return def delete(self): self._stashElevatorFC.destroy() self._wantStashElevator.destroy() self._toonsInEntranceElev.destroy() self._gotInterior.destroy() self._waitingStartLabel.destroy() self._waitingStartLabel = None DistributedObject.delete(self) return def getDifficulty(self): if self.difficultyOverride is not None: return self.difficultyOverride if hasattr(base, 'cogdoGameDifficulty'): return float(base.cogdoGameDifficulty) return CogdoGameConsts.getDifficulty(self.getSafezoneId()) def getSafezoneId(self): if self.exteriorZoneOverride is not None: return self.exteriorZoneOverride if hasattr(base, 'cogdoGameSafezoneId'): return CogdoGameConsts.getSafezoneId(base.cogdoGameSafezoneId) return CogdoGameConsts.getSafezoneId(self.exteriorZone) def enterNotLoaded(self): pass def exitNotLoaded(self): pass def enterLoaded(self): pass def exitLoaded(self): pass def enterOff(self): pass def exitOff(self): pass def setVisible(self): self.fsm.request('Visible') def setIntroStart(self): self.fsm.request('Intro') def enterVisible(self): self._toonsInEntranceElev.set(True) def exitVisible(self): pass def enterIntro(self, duration=MinigameGlobals.rulesDuration): base.cr.playGame.getPlace().fsm.request('Game') self._rulesDoneEvent = self.uniqueName('cogdoGameRulesDone') self.accept(self._rulesDoneEvent, self._handleRulesDone) self._rulesPanel = CogdoGameRulesPanel('CogdoGameRulesPanel', self.getTitle(), '', self._rulesDoneEvent, timeout=duration) self._rulesPanel.load() self._rulesPanel.enter() def exitIntro(self): self._toonsInEntranceElev.set(False) self.ignore(self._rulesDoneEvent) if self._rulesPanel: self._rulesPanel.exit() self._rulesPanel.unload() self._rulesPanel = None return def _handleRulesDone(self): self.ignore(self._rulesDoneEvent) self._rulesPanel.exit() self._rulesPanel.unload() self._rulesPanel = None self.fsm.request('WaitServerStart') self.d_setAvatarReady() return def d_setAvatarReady(self): self.sendUpdate('setAvatarReady', []) def enterWaitServerStart(self): numToons = 1 interior = self.getInterior() if interior: numToons = len(interior.getToonIds()) if numToons > 1: msg = TTL.MinigameWaitingForOtherPlayers else: msg = TTL.MinigamePleaseWait self._waitingStartLabel['text'] = msg self._waitingStartLabel.show() def exitWaitServerStart(self): self._waitingStartLabel.hide() def setGameStart(self, timestamp): self._startTime = globalClockDelta.networkToLocalTime(timestamp) self.fsm.request('Game') def getStartTime(self): return self._startTime def enterGame(self): if SCHELLGAMES_DEV: self.acceptOnce('escape', messenger.send, ['magicWord', ['~endMaze']]) def exitGame(self): if SCHELLGAMES_DEV: self.ignore('escape') def setGameFinish(self, timestamp): self._finishTime = globalClockDelta.networkToLocalTime(timestamp) self.fsm.request('Finish') def getFinishTime(self): return self._finishTime def enterFinish(self): pass def exitFinish(self): pass def setToonSad(self, toonId): pass def setToonDisconnect(self, toonId): pass
def windowDemo(): WindowSet = aspect2d.attachNewNode("Gui Set 1") #WindowSet = render2d.attachNewNode("Gui Set 1") # a first window window1 = DirectWindow( title='window1', pos=(-.8, .8), backgroundColor=(0.1, 0.1, 0.1, .6), borderColor=(0.5, 0.5, 0.5, .7), titleColor=(0.5, 0.5, 0.5, .6), titleSize=0.1, borderSize=0.06, windowParent=WindowSet, ) windowContent = DirectButton( text="Button1", scale=0.5, relief=DGG.FLAT, frameColor=(0, 1, 0, 1), ) windowContent2 = DirectButton( text="B2", scale=0.5, relief=DGG.FLAT, frameColor=(0, 1, 0, 1), ) window1.addVertical([windowContent, windowContent2]) # a second window window2 = DirectWindow( title='window2', pos=(-.4, .4), backgroundColor=(1, 0, 0, 0.5), windowParent=WindowSet, ) string1 = "Press tab to\ntoggle showing/hiding\nof all windows." windowContent = DirectLabel(text=string1, frameColor=(0, 1, 1, 1), scale=0.1) windowContent2 = DirectLabel(text='L2', frameColor=(0, 1, 1, 1), scale=0.8) window2.addHorizontal([windowContent, windowContent2]) # a third window with a close button featuring autoresize window3 = DirectWindow( title='window3', pos=(0, 0), closeButton=True, windowParent=WindowSet, ) windowContent = DirectButton( text="Press 1 to close me", relief=DGG.FLAT, frameColor=(0, 1, 1, 1), scale=0.05, ) window3.add([windowContent]) base.accept('1', window3.destroy) def toggleShow(): if WindowSet.isHidden(): WindowSet.show() else: WindowSet.hide() base.accept('tab', toggleShow)
def _initVisuals(self): RepairMincroGame._initVisuals(self) self.model = loader.loadModel('models/gui/pir_m_gui_srp_pumping_main') self.visual = self.attachNewNode('visual') self.visual.setPos(-0.25, 0.0, 0.075) goalTopLoc = self.model.find('**/locator_top') goalTopLoc.reparentTo(self.visual) goalBottomLoc = self.model.find('**/locator_bottom') goalBottomLoc.reparentTo(self.visual) self.goalPositions = (goalBottomLoc.getPos(self), goalTopLoc.getPos(self)) self.greatLabel = DirectLabel( text=PLocalizer.Minigame_Repair_Pumping_Great, text_fg=(0.2, 0.8, 0.3, 1.0), text_pos=(0.0, 0.6), text_align=TextNode.ACenter, text_font=PiratesGlobals.getPirateFont(), relief=None, text_shadow=(0.0, 0.0, 0.0, 1.0), scale=(0.08, 0.08, 0.08), pos=(-0.465, 0.0, 0.0), parent=self) self.failLabel = DirectLabel( text=PLocalizer.Minigame_Repair_Pumping_Fail, text_fg=(0.8, 0.2, 0.3, 1.0), text_pos=(0.0, 0.6), text_align=TextNode.ARight, text_font=PiratesGlobals.getPirateFont(), text_shadow=(0.0, 0.0, 0.0, 1.0), relief=None, scale=(0.08, 0.08, 0.08), pos=(-0.625, 0.0, 0.0), parent=self) self.shipBackground = self.model.find('**/static_ship_background') self.shipBackground.reparentTo(self.visual) self.waterMeter = self.model.find('**/sprite_waterBottom') self.waterMeter.reparentTo(self.visual) self.waterTop = self.model.find('**/sprite_waterTop') self.waterTop.reparentTo(self.visual) self.waterMeterTopLoc = self.waterMeter.find( '**/locator_topOfShipWater') self.pumpBackground = self.model.find('**/pumpBackground') self.pumpBackground.reparentTo(self.visual) self.pumpWaterTop = self.model.find('**/sprite_pumpWaterTop') self.pumpWaterTop.reparentTo(self.visual) self.pumpWaterBottom = self.model.find('**/sprite_pumpWaterBottom') self.pumpWaterBottom.reparentTo(self.visual) self.pumpWaterTopLoc = self.pumpWaterBottom.find( '**/locator_topOfPumpWater') self.pumpHandle = self.model.find('**/sprite_handle') self.pumpHandle.reparentTo(self.visual) self.pumpBar = self.model.find('**/static_pump') self.pumpBar.reparentTo(self.visual) self.goalBox = self.model.find('**/sprite_clickField') self.goalBox.reparentTo(self.visual) self.goalBox.setTransparency(1) self.enableGoalBox() self.pumpLine = self.model.find('**/sprite_bar') self.pumpLine.reparentTo(self.visual) self.ghostLine = self.visual.attachNewNode('ghostLine') self.pumpLine.getChild(0).copyTo(self.ghostLine) self.ghostLine.setScale(self.pumpLine.getScale()) self.ghostLine.setColor(1.0, 0.2, 0.2, 1.0) self.shipForground = self.model.find('**/static_ship_foreground') self.shipForground.reparentTo(self.visual) cm = CardMaker('cardMaker') cm.setFrame(-0.33, 0.33, 0.0, 1.0) self.goalBox.setZ(self.goalPositions[TOP].getZ()) self.goalBoxStartScale = self.goalBox.getSz() self.enableGoalBox() self.pumpWaterUpLerp = LerpFunc(self.setPumpWater, fromData=-0.1, toData=1.0, duration=0.5) self.pumpWaterDownLerp = LerpFunc(self.setPumpWater, fromData=1.0, toData=-0.1, duration=0.5) self.model.removeNode() del self.model return
class RepairPumpingGame(RepairMincroGame): __module__ = __name__ pumpDownSounds = None pumpUpSounds = None pumpGoodSounds = None pumpBadSounds = None def __init__(self, repairGame): self.config = RepairGlobals.Pumping RepairMincroGame.__init__(self, repairGame, 'pumping', PLocalizer.Minigame_Repair_Pumping_Start) def _initVars(self): RepairMincroGame._initVars(self) self.pumpRate = 0.0 self.remainingWater = 1.0 self.chainCount = 0 self.barDirection = UP self.goalIndex = TOP self.currentBarRate = self.config.barStartRange[0] self.hitRange = self.config.hitRange[0] self.barPercent = 0.0 self.failedPercentAndDirection = (-1.0, UP) def _initAudio(self): RepairMincroGame._initAudio(self) if not self.pumpDownSounds: RepairPumpingGame.pumpDownSounds = ( loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_DOWN01), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_DOWN02), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_DOWN03)) RepairPumpingGame.pumpUpSounds = ( loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_UP01), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_UP02), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_UP03)) RepairPumpingGame.pumpGoodSounds = ( loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_GOOD01), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_GOOD02), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_GOOD03), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_GOOD04), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_GOOD05), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_GOOD06)) RepairPumpingGame.pumpBadSounds = (loadSfx( SoundGlobals.SFX_MINIGAME_REPAIR_PUMP_BAD), ) def _initVisuals(self): RepairMincroGame._initVisuals(self) self.model = loader.loadModel('models/gui/pir_m_gui_srp_pumping_main') self.visual = self.attachNewNode('visual') self.visual.setPos(-0.25, 0.0, 0.075) goalTopLoc = self.model.find('**/locator_top') goalTopLoc.reparentTo(self.visual) goalBottomLoc = self.model.find('**/locator_bottom') goalBottomLoc.reparentTo(self.visual) self.goalPositions = (goalBottomLoc.getPos(self), goalTopLoc.getPos(self)) self.greatLabel = DirectLabel( text=PLocalizer.Minigame_Repair_Pumping_Great, text_fg=(0.2, 0.8, 0.3, 1.0), text_pos=(0.0, 0.6), text_align=TextNode.ACenter, text_font=PiratesGlobals.getPirateFont(), relief=None, text_shadow=(0.0, 0.0, 0.0, 1.0), scale=(0.08, 0.08, 0.08), pos=(-0.465, 0.0, 0.0), parent=self) self.failLabel = DirectLabel( text=PLocalizer.Minigame_Repair_Pumping_Fail, text_fg=(0.8, 0.2, 0.3, 1.0), text_pos=(0.0, 0.6), text_align=TextNode.ARight, text_font=PiratesGlobals.getPirateFont(), text_shadow=(0.0, 0.0, 0.0, 1.0), relief=None, scale=(0.08, 0.08, 0.08), pos=(-0.625, 0.0, 0.0), parent=self) self.shipBackground = self.model.find('**/static_ship_background') self.shipBackground.reparentTo(self.visual) self.waterMeter = self.model.find('**/sprite_waterBottom') self.waterMeter.reparentTo(self.visual) self.waterTop = self.model.find('**/sprite_waterTop') self.waterTop.reparentTo(self.visual) self.waterMeterTopLoc = self.waterMeter.find( '**/locator_topOfShipWater') self.pumpBackground = self.model.find('**/pumpBackground') self.pumpBackground.reparentTo(self.visual) self.pumpWaterTop = self.model.find('**/sprite_pumpWaterTop') self.pumpWaterTop.reparentTo(self.visual) self.pumpWaterBottom = self.model.find('**/sprite_pumpWaterBottom') self.pumpWaterBottom.reparentTo(self.visual) self.pumpWaterTopLoc = self.pumpWaterBottom.find( '**/locator_topOfPumpWater') self.pumpHandle = self.model.find('**/sprite_handle') self.pumpHandle.reparentTo(self.visual) self.pumpBar = self.model.find('**/static_pump') self.pumpBar.reparentTo(self.visual) self.goalBox = self.model.find('**/sprite_clickField') self.goalBox.reparentTo(self.visual) self.goalBox.setTransparency(1) self.enableGoalBox() self.pumpLine = self.model.find('**/sprite_bar') self.pumpLine.reparentTo(self.visual) self.ghostLine = self.visual.attachNewNode('ghostLine') self.pumpLine.getChild(0).copyTo(self.ghostLine) self.ghostLine.setScale(self.pumpLine.getScale()) self.ghostLine.setColor(1.0, 0.2, 0.2, 1.0) self.shipForground = self.model.find('**/static_ship_foreground') self.shipForground.reparentTo(self.visual) cm = CardMaker('cardMaker') cm.setFrame(-0.33, 0.33, 0.0, 1.0) self.goalBox.setZ(self.goalPositions[TOP].getZ()) self.goalBoxStartScale = self.goalBox.getSz() self.enableGoalBox() self.pumpWaterUpLerp = LerpFunc(self.setPumpWater, fromData=-0.1, toData=1.0, duration=0.5) self.pumpWaterDownLerp = LerpFunc(self.setPumpWater, fromData=1.0, toData=-0.1, duration=0.5) self.model.removeNode() del self.model return def destroy(self): del self.goalPositions self.pumpBar.removeNode() self.pumpLine.removeNode() self.goalBox.removeNode() self.pumpHandle.removeNode() self.waterMeter.removeNode() self.waterTop.removeNode() self.ghostLine.removeNode() self.shipBackground.removeNode() self.shipForground.removeNode() def reset(self): RepairMincroGame.reset(self) self.remainingWater = WATER_LEVEL_START self.chainCount = 0 self.barDirection = UP self.goalIndex = TOP self.barPercent = 0.0 self.failedPercentAndDirection = (-1.0, UP) actualZ = self.goalPositions[BOTTOM].getZ() actualZ -= self.visual.getZ() self.pumpLine.setZ(actualZ) self.setGoalIndex(TOP) self.pumpHandle.setR(ROTATION_MIN) self.waterMeter.setSz(WATER_LEVEL_START) self.waterTop.setZ(self.waterMeterTopLoc.getZ(self.visual)) self.ghostLine.stash() self.setPumpWater(1.0) self.failLabel.stash() self.greatLabel.stash() self.repairGame.gui.setTutorial(self.name) self.repairGame.gui.setTitle(self.name) def setDifficulty(self, difficulty): RepairMincroGame.setDifficulty(self, difficulty) percent = difficulty / self.repairGame.difficultyMax dif = self.config.pumpPowerRange[0] - self.config.pumpPowerRange[1] self.pumpRate = self.config.pumpPowerRange[0] - dif * percent dif = self.config.barStartRange[0] - self.config.barStartRange[1] self.currentBarRate = self.config.barStartRange[0] - dif * percent dif = self.config.hitRange[0] - self.config.hitRange[1] self.hitRange = self.config.hitRange[0] - dif * percent self.goalBox.setSz(self.hitRange / 0.18 * self.goalBoxStartScale) def setGoalIndex(self, goalIndex): self.goalIndex = goalIndex self.goalBox.setZ(self, self.goalPositions[goalIndex].getZ()) self.goalBox.setR(180 * (goalIndex - 1)) def resetFail(self): self.failedPercentAndDirection = (-1.0, UP) self.enableGoalBox() self.hideMarkers() def updateTask(self, task): dt = globalClock.getDt() percentTimeThisStep = dt / (self.currentBarRate + self.config.barSpeedMax) self.barPercent = self.barPercent + percentTimeThisStep * self.barDirection if self.failedPercentAndDirection[0] >= 0.0: if self.failedPercentAndDirection[1] != self.barDirection: if self.failedPercentAndDirection[ 0] * self.barDirection < self.barPercent * self.barDirection: self.resetFail() if self.barPercent >= 1.0: self.barPercent = 1.0 self.barDirection = DOWN if not self.isLineInBox(): self.chainCount = 0 if self.failedPercentAndDirection[0] < 0.5: self.resetFail() else: if self.barPercent <= 0.0: self.barPercent = 0.0 self.barDirection = UP if not self.isLineInBox(): self.chainCount = 0 if self.failedPercentAndDirection[0] > 0.5: self.resetFail() actualZ = self.goalPositions[0].getZ() + (self.goalPositions[1].getZ( ) - self.goalPositions[0].getZ()) * self.barPercent actualZ -= self.visual.getZ() self.pumpLine.setZ(actualZ) return Task.cont def enableGoalBox(self): self.goalBox.setColor(0.2, 1.0, 0.2, 0.6) self.goalBoxEnabled = 1 def disableGoalBox(self): self.goalBox.setColor(1.0, 0.2, 0.2, 0.3) self.goalBoxEnabled = 0 def isLineInBox(self): if self.goalIndex == TOP: return self.barPercent >= 1.0 - self.hitRange else: return self.barPercent <= self.hitRange def onMouseClick(self): if self.isLineInBox(): if self.goalBoxEnabled == 1: actualPumpAmount = self.pumpRate + self.config.chainMultiplier * self.chainCount * self.pumpRate actualPumpAmount *= WATER_LEVEL_START - WATER_LEVEL_DONE self.remainingWater -= actualPumpAmount self.remainingWater = max(0.0, self.remainingWater) self.waterMeter.setSz(self.remainingWater) self.waterTop.setZ( self.waterMeterTopLoc.getZ(self.visual) - 0.001) if self.barPercent > 0.5: self.pumpWaterDownLerp.duration = self.currentBarRate self.pumpWaterDownLerp.start() self.barDirection = DOWN self.pumpHandle.setR(ROTATION_MAX) random.choice(self.pumpDownSounds).play() else: self.pumpWaterUpLerp.duration = self.currentBarRate self.pumpWaterUpLerp.start() self.barDirection = UP self.pumpHandle.setR(ROTATION_MIN) random.choice(self.pumpUpSounds).play() self.barPercent > 0.5 and self.setGoalIndex(BOTTOM) else: self.setGoalIndex(TOP) self.currentBarRate /= self.config.barSpeedIncrease self.chainCount += 1 self.setSuccessMarker() if self.remainingWater <= WATER_LEVEL_DONE and self.barDirection == DOWN: self.remainingWater = 0.0 self.request('Outro') return totalRange = WATER_LEVEL_START - WATER_LEVEL_DONE current = WATER_LEVEL_START - self.remainingWater percent = min(100, int(current / totalRange * 100)) self.repairGame.d_reportMincroGameProgress( percent, max(0, min(5, self.chainCount) - 1)) else: self.disableGoalBox() self.currentBarRate /= self.config.barSpeedDecrease self.currentBarRate += ( 1 - self.config.barSpeedDecrease) * self.config.barSpeedMin self.currentBarRate = min(self.currentBarRate, self.config.barSpeedMin) self.setFailMarker() self.chainCount = 0 self.failedPercentAndDirection = (self.barPercent, self.barDirection) def setPumpWater(self, value): self.pumpWaterBottom.setSz(value) self.pumpWaterTop.setZ(self.pumpWaterTopLoc.getZ(self.visual)) def setSuccessMarker(self): self.greatLabel.setZ(self.pumpLine.getZ()) self.greatLabel.unstash() pumpSoundIndex = min(len(self.pumpGoodSounds) - 1, self.chainCount / 2) self.pumpGoodSounds[pumpSoundIndex].play() def setFailMarker(self): self.hideMarkers() self.ghostLine.setPos(self.pumpLine.getPos()) self.ghostLine.unstash() self.failLabel.setZ(self.pumpLine.getZ()) self.failLabel.unstash() random.choice(self.pumpBadSounds).play() def hideMarkers(self): self.ghostLine.stash() self.greatLabel.stash() self.failLabel.stash() def enterGame(self): RepairMincroGame.enterGame(self) taskMgr.add(self.updateTask, 'RepairPumpingGame.updateTask') self.accept('mouse1', self.onMouseClick) self.enableGoalBox() def exitGame(self): RepairMincroGame.exitGame(self) taskMgr.remove('RepairPumpingGame.updateTask') self.ignore('mouse1') def enterOutro(self): RepairMincroGame.enterOutro(self) self.repairGame.d_reportMincroGameScore(150)
class FileDialog(DirectObject): def __init__(self, title, initial_status, callback): self.frmLeft = -.7 self.frmBottom = -.12 self.frmRight = .7 self.frmTop = .12 self.frmWidth = self.frmRight - self.frmLeft self.frmHeight = self.frmTop - self.frmBottom self.title = title self.initial_status = initial_status self.callback = callback self.result = None self.done = 0 def activate(self): # create main dialog frame # Note: frame position references the CENTER of the frame self.frm = DirectFrame(pos=(0, 0, 0), frameSize=(self.frmLeft, self.frmRight, self.frmBottom, self.frmTop), relief=DGG.RIDGE, borderWidth=(0.01, 0.01), frameColor=(0.6, 0.6, 0.6, 1.0)) self.frm.reparentTo(base.aspect2d) # Note: wonderfully enough, label position on the other hand # references the CENTER of the LEFT border of the label! titleLabel = DirectLabel(text=self.title, scale=0.04, frameColor=(0.5, 0.5, 0.5, 1), relief=DGG.RIDGE, borderWidth=(0.01, 0.01), text_align=TextNode.ALeft) titleLabel.setPos(-self.frmWidth / 2 + .02, 0, self.frmHeight / 2 - .045) titleLabel.reparentTo(self.frm) sc = .04 self.dir_edit_field = DirectEntry( text='', # prompt text scale=sc, frameColor=(0.65, 0.65, 0.65, 1), command=self.setText, width=32, numLines=1, focus=1, focusInCommand=self.efFocusIn, ) self.dir_edit_field.setPos(-self.frmWidth / 2 + .02, 0, self.frmHeight / 2 - .13) self.dir_edit_field.reparentTo(self.frm) self.statusLabel = DirectLabel( text=self.initial_status, scale=0.04, frameColor=(0.6, 0.6, 0.6, 1), # relief = DGG.RIDGE, # borderWidth = (0.01, 0.01), text_align=TextNode.ALeft) self.statusLabel.setPos(-self.frmWidth / 2 + .02, 0, self.frmHeight / 2 - .2) self.statusLabel.reparentTo(self.frm) # call this if you need to run a form before your mainloop starts steppping the taskMgr def run(self): while self.done != 1: taskMgr.step() taskMgr.step( ) # once more to make the last output from the dialog visible # while we load a zone self.frm.removeNode() def end(self): self.frm.removeNode() # callback function to set text: called by the Panda3d taskMgr when the user # has entered something into the DirectEntry widget def setText(self, textEntered): print 'dir_edit_field::setText:', textEntered self.done = self.callback(textEntered) if self.done != 1: self.dir_edit_field['focus'] = 1 #clear the text def efFocusIn(self): print 'focus in' self.dir_edit_field.enterText('') def setStatus(self, status): self.statusLabel['text'] = status
def _initGUI(self): self.model = loader.loadModel('models/gui/pir_m_gui_srp_main') self.repairGamePicker = RepairGamePickerGUI( self, self.repairGame, self.model.find('**/group_picker')) self.staticElements = GUIFactory.generateStaticElements( self.model.getChild(0), self) self.textElements = {} self.textElements['title'] = DirectLabel( text='', text_fg=(1.0, 1.0, 1.0, 1.0), text_shadow=(0.0, 0.0, 0.0, 1.0), scale=(0.087499999999999994, 0.087499999999999994, 0.087499999999999994), pos=(0.0, 0.0, 0.91000000000000003), relief=None, textMayChange=1, text_font=PiratesGlobals.getPirateFont(), parent=self.staticElements['bg']) self.textElements['tutorial'] = DirectLabel( text='', text_fg=(1.0, 1.0, 1.0, 1.0), text_shadow=(0.0, 0.0, 0.0, 1.0), text_wordwrap=14, scale=(0.044999999999999998, 0.044999999999999998, 0.044999999999999998), pos=(0.0, 0.0, 0.79500000000000004), relief=None, textMayChange=1, text_font=PiratesGlobals.getPirateFont(), parent=self.staticElements['bg']) self.textElements['level'] = DirectLabel( text='', text_fg=(1.0, 1.0, 1.0, 1.0), scale=(0.052499999999999998, 0.052499999999999998, 0.052499999999999998), pos=(0.315, 0.0, 0.69999999999999996), relief=None, textMayChange=1, text_align=TextNode.ARight, text_font=PiratesGlobals.getPirateFont(), parent=self.staticElements['bg']) self.textElements['level'].stash() self.textElements['idleMessage'] = DirectLabel( text='', text_fg=(1.0, 1.0, 1.0, 1.0), text_shadow=(0.0, 0.0, 0.0, 1.0), text_wordwrap=15, scale=(0.087499999999999994, 0.087499999999999994, 0.087499999999999994), pos=(0.0, 0.0, 0.0), relief=None, textMayChange=1, text_font=PiratesGlobals.getPirateFont(), parent=self.staticElements['bg']) self.textElements['cycleCompleteMessage'] = DirectLabel( text='', text_fg=(1.0, 1.0, 1.0, 1.0), text_shadow=(0.0, 0.0, 0.0, 1.0), text_wordwrap=20, scale=(0.087499999999999994, 0.087499999999999994, 0.087499999999999994), pos=(0.0, 0.0, 0.0), relief=None, textMayChange=1, text_font=PiratesGlobals.getPirateFont(), parent=self.staticElements['bg']) self.closeButton = GuiButton( image=(self.model.find('**/esc_button/idle'), self.model.find('**/esc_button/over'), self.model.find('**/esc_button/over'), self.model.find('**/esc_button/idle')), image_scale=(0.75, 0.75, 0.75), image_pos=(0.074999999999999997, 0, 0.080000000000000002), hotkeys=['Escape'], hotkeyLabel=PLocalizer.Minigame_Repair_Leave_Game_Text, pos=(-0.40000000000000002, 0.0, 0.01), parent=base.a2dBottomRight, command=self.handleExitGame) self.closeButton.setBin('background', -90) self.model.removeNode() del self.model
def loadWeekNavButtons(self, pageFrame): if self.numIssues <= 1: return else: if self.myIssueIndex == self.numIssues - 1: weekStr = TTLocalizer.IssueFrameThisWeek elif self.myIssueIndex == self.numIssues - 2: weekStr = TTLocalizer.IssueFrameLastWeek else: weeksAgo = self.numIssues - self.myIssueIndex - 1 weekStr = TTLocalizer.IssueFrameWeeksAgo % weeksAgo prevImage = self.gui.find('**/tt_i_art_btn_ArchiveArrwLeftNormal') prevImageRo = self.gui.find('**/tt_i_art_btn_ArchiveArrwLeftRo') prevImageDisabled = self.gui.find( '**/tt_i_art_btn_ArchiveArrwLeftDisabled') actualY1 = 78.0 desiredY1 = 42.0 y1Scale = desiredY1 / actualY1 prevWeekBtn = DirectButton( relief=None, parent=pageFrame, image=[prevImage, prevImage, prevImageRo, prevImageDisabled], image_scale=y1Scale, command=self.changeWeek, extraArgs=(self.myIssueIndex - 1, ), pos=(0.806666, 0, 0.62)) if self.myIssueIndex == 0: prevWeekBtn['state'] = DGG.DISABLED nextImage = self.gui.find('**/tt_i_art_btn_ArchiveArrwRightNormal') nextImageRo = self.gui.find('**/tt_i_art_btn_ArchiveArrwRightRo') nextImageDisabled = self.gui.find( '**/tt_i_art_btn_ArchiveArrwRightDisabled') actualY2Scale = 63.0 desiredY2Scale = 34.0 y2Scale = desiredY2Scale / actualY2Scale nextWeekBtn = DirectButton( relief=None, parent=pageFrame, image=[nextImage, nextImage, nextImageRo, nextImageDisabled], image_scale=y2Scale, command=self.changeWeek, extraArgs=(self.myIssueIndex + 1, ), pos=(1.16, 0, 0.623333)) if self.myIssueIndex == self.numIssues - 1: nextWeekBtn['state'] = DGG.DISABLED actualX = 176.0 desiredX = 89.0 imageScale = desiredX / actualX midImage = self.gui.find('**/tt_i_art_btn_ArchiveMiddle') weekColor = (0.0 / 255.0, 23.0 / 255.0, 140.0 / 255.0, 1.0) weekLabel = DirectLabel(relief=None, image=midImage, image_scale=imageScale, parent=pageFrame, text=weekStr, text_font=ToontownGlobals.InterfaceFont, text_fg=weekColor, text_scale=0.043, text_pos=(0, -0.01, 0), pos=(0.983333, 0, 0.62)) return
class DistributedCogThiefGame(DistributedMinigame): notify = directNotify.newCategory('DistributedCogThiefGame') ToonSpeed = CTGG.ToonSpeed StageHalfWidth = 200.0 StageHalfHeight = 100.0 BarrelScale = 0.25 TOON_Z = 0 UPDATE_SUITS_TASK = 'CogThiefGameUpdateSuitsTask' REWARD_COUNTDOWN_TASK = 'cogThiefGameRewardCountdown' ControlKeyLimitTime = 1.0 def __init__(self, cr): DistributedMinigame.__init__(self, cr) self.gameFSM = ClassicFSM.ClassicFSM('DistributedCogThiefGame', [ State.State('off', self.enterOff, self.exitOff, ['play']), State.State('play', self.enterPlay, self.exitPlay, ['cleanup']), State.State('cleanup', self.enterCleanup, self.exitCleanup, []) ], 'off', 'cleanup') self.addChildGameFSM(self.gameFSM) self.cameraTopView = (0, 0, 55, 0, -90.0, 0) self.barrels = [] self.cogInfo = {} self.lastTimeControlPressed = 0 self.stolenBarrels = [] self.useOrthoWalk = base.config.GetBool('cog-thief-ortho', 1) self.resultIval = None self.gameIsEnding = False self.__textGen = TextNode('cogThiefGame') self.__textGen.setFont(ToontownGlobals.getSignFont()) self.__textGen.setAlign(TextNode.ACenter) return def getTitle(self): return TTLocalizer.CogThiefGameTitle def getInstructions(self): return TTLocalizer.CogThiefGameInstructions def getMaxDuration(self): return 0 def load(self): self.notify.debug('load') DistributedMinigame.load(self) self.music = base.loader.loadMusic('phase_4/audio/bgm/MG_CogThief.ogg') self.initCogInfo() for barrelIndex in xrange(CTGG.NumBarrels): barrel = loader.loadModel( 'phase_4/models/minigames/cogthief_game_gagTank') barrel.setPos(CTGG.BarrelStartingPositions[barrelIndex]) barrel.setScale(self.BarrelScale) barrel.reparentTo(render) barrel.setTag('barrelIndex', str(barrelIndex)) collSphere = CollisionSphere(0, 0, 0, 4) collSphere.setTangible(0) name = 'BarrelSphere-%d' % barrelIndex collSphereName = self.uniqueName(name) collNode = CollisionNode(collSphereName) collNode.setFromCollideMask(CTGG.BarrelBitmask) collNode.addSolid(collSphere) colNp = barrel.attachNewNode(collNode) handler = CollisionHandlerEvent() handler.setInPattern('barrelHit-%fn') base.cTrav.addCollider(colNp, handler) self.accept('barrelHit-' + collSphereName, self.handleEnterBarrel) nodeToHide = '**/gagMoneyTen' if barrelIndex % 2: nodeToHide = '**/gagMoneyFive' iconToHide = barrel.find(nodeToHide) if not iconToHide.isEmpty(): iconToHide.hide() self.barrels.append(barrel) self.gameBoard = loader.loadModel( 'phase_4/models/minigames/cogthief_game') self.gameBoard.find('**/floor_TT').hide() self.gameBoard.find('**/floor_DD').hide() self.gameBoard.find('**/floor_DG').hide() self.gameBoard.find('**/floor_MM').hide() self.gameBoard.find('**/floor_BR').hide() self.gameBoard.find('**/floor_DL').hide() zone = self.getSafezoneId() if zone == ToontownGlobals.ToontownCentral: self.gameBoard.find('**/floor_TT').show() elif zone == ToontownGlobals.DonaldsDock: self.gameBoard.find('**/floor_DD').show() elif zone == ToontownGlobals.DaisyGardens: self.gameBoard.find('**/floor_DG').show() elif zone == ToontownGlobals.MinniesMelodyland: self.gameBoard.find('**/floor_MM').show() elif zone == ToontownGlobals.TheBrrrgh: self.gameBoard.find('**/floor_BR').show() elif zone == ToontownGlobals.DonaldsDreamland: self.gameBoard.find('**/floor_DL').show() else: self.gameBoard.find('**/floor_TT').show() self.gameBoard.setPosHpr(0, 0, 0, 0, 0, 0) self.gameBoard.setScale(1.0) self.toonSDs = {} avId = self.localAvId toonSD = CogThiefGameToonSD.CogThiefGameToonSD(avId, self) self.toonSDs[avId] = toonSD toonSD.load() self.loadCogs() self.toonHitTracks = {} self.toonPieTracks = {} self.sndOof = base.loader.loadSfx( 'phase_4/audio/sfx/MG_cannon_hit_dirt.ogg') self.sndRewardTick = base.loader.loadSfx( 'phase_3.5/audio/sfx/tick_counter.ogg') self.sndPerfect = base.loader.loadSfx( 'phase_4/audio/sfx/ring_perfect.ogg') self.timer = ToontownTimer.ToontownTimer() self.timer.posInTopRightCorner() self.timer.hide() purchaseModels = loader.loadModel('phase_4/models/gui/purchase_gui') self.jarImage = purchaseModels.find('**/Jar') self.jarImage.reparentTo(hidden) self.rewardPanel = DirectLabel(parent=hidden, relief=None, pos=(-0.173, 0.0, -0.55), scale=0.65, text='', text_scale=0.2, text_fg=(0.95, 0.95, 0, 1), text_pos=(0, -.13), text_font=ToontownGlobals.getSignFont(), image=self.jarImage) self.rewardPanelTitle = DirectLabel(parent=self.rewardPanel, relief=None, pos=(0, 0, 0.06), scale=0.08, text=TTLocalizer.CannonGameReward, text_fg=(0.95, 0.95, 0, 1), text_shadow=(0, 0, 0, 1)) return def unload(self): self.notify.debug('unload') DistributedMinigame.unload(self) del self.music self.removeChildGameFSM(self.gameFSM) del self.gameFSM self.gameBoard.removeNode() del self.gameBoard for barrel in self.barrels: barrel.removeNode() del self.barrels for avId in self.toonSDs.keys(): toonSD = self.toonSDs[avId] toonSD.unload() del self.toonSDs self.timer.destroy() del self.timer self.rewardPanel.destroy() del self.rewardPanel self.jarImage.removeNode() del self.jarImage del self.sndRewardTick def onstage(self): self.notify.debug('onstage') DistributedMinigame.onstage(self) self.gameBoard.reparentTo(render) lt = base.localAvatar lt.reparentTo(render) self.__placeToon(self.localAvId) lt.setSpeed(0, 0) self.moveCameraToTop() toonSD = self.toonSDs[self.localAvId] toonSD.enter() toonSD.fsm.request('normal') self.stopGameWalk() for cogIndex in xrange(self.getNumCogs()): suit = self.cogInfo[cogIndex]['suit'].suit pos = self.cogInfo[cogIndex]['pos'] suit.reparentTo(self.gameBoard) suit.setPos(pos) suit.nametag3d.stash() suit.nametag.destroy() for avId in self.avIdList: self.toonHitTracks[avId] = Wait(0.1) self.toonRNGs = [] for i in xrange(self.numPlayers): self.toonRNGs.append(RandomNumGen.RandomNumGen(self.randomNumGen)) self.sndTable = { 'hitBySuit': [None] * self.numPlayers, 'falling': [None] * self.numPlayers } for i in xrange(self.numPlayers): self.sndTable['hitBySuit'][i] = base.loader.loadSfx( 'phase_4/audio/sfx/MG_Tag_C.ogg') self.sndTable['falling'][i] = base.loader.loadSfx( 'phase_4/audio/sfx/MG_cannon_whizz.ogg') base.playMusic(self.music, looping=1, volume=0.8) self.introTrack = self.getIntroTrack() self.introTrack.start() return def offstage(self): self.notify.debug('offstage') self.gameBoard.hide() self.music.stop() for barrel in self.barrels: barrel.hide() for avId in self.toonSDs.keys(): self.toonSDs[avId].exit() for avId in self.avIdList: av = self.getAvatar(avId) if av: av.resetLOD() self.timer.reparentTo(hidden) self.rewardPanel.reparentTo(hidden) if self.introTrack.isPlaying(): self.introTrack.finish() del self.introTrack DistributedMinigame.offstage(self) def handleDisabledAvatar(self, avId): self.notify.debug('handleDisabledAvatar') self.notify.debug('avatar ' + str(avId) + ' disabled') self.toonSDs[avId].exit(unexpectedExit=True) del self.toonSDs[avId] DistributedMinigame.handleDisabledAvatar(self, avId) def setGameReady(self): if not self.hasLocalToon: return self.notify.debug('setGameReady') if DistributedMinigame.setGameReady(self): return for avId in self.remoteAvIdList: toon = self.getAvatar(avId) if toon: toon.reparentTo(render) self.__placeToon(avId) toon.useLOD(1000) toonSD = CogThiefGameToonSD.CogThiefGameToonSD(avId, self) self.toonSDs[avId] = toonSD toonSD.load() toonSD.enter() toonSD.fsm.request('normal') toon.startSmooth() def setGameStart(self, timestamp): if not self.hasLocalToon: return self.notify.debug('setGameStart') DistributedMinigame.setGameStart(self, timestamp) if not base.config.GetBool('cog-thief-endless', 0): self.timer.show() self.timer.countdown(CTGG.GameTime, self.__gameTimerExpired) self.clockStopTime = None self.rewardPanel.reparentTo(base.a2dTopRight) self.scoreMult = MinigameGlobals.getScoreMult(self.cr.playGame.hood.id) self.__startRewardCountdown() if self.introTrack.isPlaying(): self.introTrack.finish() self.gameFSM.request('play') return def enterOff(self): self.notify.debug('enterOff') def exitOff(self): pass def enterPlay(self): self.notify.debug('enterPlay') self.startGameWalk() self.spawnUpdateSuitsTask() self.accept('control', self.controlKeyPressed) self.pieHandler = CollisionHandlerEvent() self.pieHandler.setInPattern('pieHit-%fn') def exitPlay(self): self.ignore('control') if self.resultIval and self.resultIval.isPlaying(): self.resultIval.finish() self.resultIval = None return def enterCleanup(self): self.__killRewardCountdown() if hasattr(self, 'jarIval'): self.jarIval.finish() del self.jarIval for key in self.toonHitTracks: ival = self.toonHitTracks[key] if ival.isPlaying(): ival.finish() self.toonHitTracks = {} for key in self.toonPieTracks: ival = self.toonPieTracks[key] if ival.isPlaying(): ival.finish() self.toonPieTracks = {} for key in self.cogInfo: cogThief = self.cogInfo[key]['suit'] cogThief.cleanup() self.removeUpdateSuitsTask() self.notify.debug('enterCleanup') def exitCleanup(self): pass def __placeToon(self, avId): toon = self.getAvatar(avId) if toon: index = self.avIdList.index(avId) toon.setPos(CTGG.ToonStartingPositions[index]) toon.setHpr(0, 0, 0) def moveCameraToTop(self): camera.reparentTo(render) p = self.cameraTopView camera.setPosHpr(p[0], p[1], p[2], p[3], p[4], p[5]) base.camLens.setMinFov(46 / (4. / 3.)) camera.setZ(camera.getZ() + base.config.GetFloat('cog-thief-z-camera-adjust', 0.0)) def destroyGameWalk(self): self.notify.debug('destroyOrthoWalk') if self.useOrthoWalk: self.gameWalk.destroy() del self.gameWalk else: self.notify.debug('TODO destroyGameWalk') def initGameWalk(self): self.notify.debug('startOrthoWalk') if self.useOrthoWalk: def doCollisions(oldPos, newPos, self=self): x = bound(newPos[0], CTGG.StageHalfWidth, -CTGG.StageHalfWidth) y = bound(newPos[1], CTGG.StageHalfHeight, -CTGG.StageHalfHeight) newPos.setX(x) newPos.setY(y) return newPos orthoDrive = OrthoDrive(self.ToonSpeed, customCollisionCallback=doCollisions, instantTurn=True) self.gameWalk = OrthoWalk(orthoDrive, broadcast=not self.isSinglePlayer()) else: self.gameWalk = CogThiefWalk.CogThiefWalk('walkDone') forwardSpeed = self.ToonSpeed / 2.0 base.mouseInterfaceNode.setForwardSpeed(forwardSpeed) multiplier = forwardSpeed / ToontownGlobals.ToonForwardSpeed base.mouseInterfaceNode.setRotateSpeed( ToontownGlobals.ToonRotateSpeed * 4) def initCogInfo(self): for cogIndex in xrange(self.getNumCogs()): self.cogInfo[cogIndex] = { 'pos': Point3(CTGG.CogStartingPositions[cogIndex]), 'goal': CTGG.NoGoal, 'goalId': CTGG.InvalidGoalId, 'suit': None } return def loadCogs(self): suitTypes = ['ds', 'ac', 'bc', 'ms'] for suitIndex in xrange(self.getNumCogs()): st = self.randomNumGen.choice(suitTypes) suit = CogThief.CogThief(suitIndex, st, self, self.getCogSpeed()) self.cogInfo[suitIndex]['suit'] = suit def handleEnterSphere(self, colEntry): if self.gameIsEnding: return intoName = colEntry.getIntoNodePath().getName() fromName = colEntry.getFromNodePath().getName() debugInto = intoName.split('/') debugFrom = fromName.split('/') self.notify.debug( 'handleEnterSphere gametime=%s %s into %s' % (self.getCurrentGameTime(), debugFrom[-1], debugInto[-1])) intoName = colEntry.getIntoNodePath().getName() if 'CogThiefSphere' in intoName: parts = intoName.split('-') suitNum = int(parts[1]) self.localToonHitBySuit(suitNum) def localToonHitBySuit(self, suitNum): self.notify.debug('localToonHitBySuit %d' % suitNum) timestamp = globalClockDelta.localToNetworkTime( globalClock.getFrameTime(), bits=32) pos = self.cogInfo[suitNum]['suit'].suit.getPos() self.sendUpdate( 'hitBySuit', [self.localAvId, timestamp, suitNum, pos[0], pos[1], pos[2]]) self.showToonHitBySuit(self.localAvId, timestamp) self.makeSuitRespondToToonHit(timestamp, suitNum) def hitBySuit(self, avId, timestamp, suitNum, x, y, z): if not self.hasLocalToon: return if self.gameFSM.getCurrentState().getName() not in ['play']: self.notify.warning('ignoring msg: av %s hit by suit' % avId) return if self.gameIsEnding: return self.notify.debug('avatar ' + ` avId ` + ' hit by a suit') if avId != self.localAvId: self.showToonHitBySuit(avId, timestamp) self.makeSuitRespondToToonHit(timestamp, suitNum) def showToonHitBySuit(self, avId, timestamp): toon = self.getAvatar(avId) if toon == None: return rng = self.toonRNGs[self.avIdList.index(avId)] curPos = toon.getPos(render) oldTrack = self.toonHitTracks[avId] if oldTrack.isPlaying(): oldTrack.finish() toon.setPos(curPos) toon.setZ(self.TOON_Z) parentNode = render.attachNewNode('mazeFlyToonParent-' + ` avId `) parentNode.setPos(toon.getPos()) toon.reparentTo(parentNode) toon.setPos(0, 0, 0) startPos = parentNode.getPos() dropShadow = toon.dropShadow.copyTo(parentNode) dropShadow.setScale(toon.dropShadow.getScale(render)) trajectory = Trajectory.Trajectory(0, Point3(0, 0, 0), Point3(0, 0, 50), gravMult=1.0) oldFlyDur = trajectory.calcTimeOfImpactOnPlane(0.0) trajectory = Trajectory.Trajectory(0, Point3(0, 0, 0), Point3(0, 0, 50), gravMult=0.55) flyDur = trajectory.calcTimeOfImpactOnPlane(0.0) avIndex = self.avIdList.index(avId) endPos = CTGG.ToonStartingPositions[avIndex] def flyFunc(t, trajectory, startPos=startPos, endPos=endPos, dur=flyDur, moveNode=parentNode, flyNode=toon): u = t / dur moveNode.setX(startPos[0] + u * (endPos[0] - startPos[0])) moveNode.setY(startPos[1] + u * (endPos[1] - startPos[1])) flyNode.setPos(trajectory.getPos(t)) flyTrack = Sequence(LerpFunctionInterval(flyFunc, fromData=0.0, toData=flyDur, duration=flyDur, extraArgs=[trajectory]), name=toon.uniqueName('hitBySuit-fly')) geomNode = toon.getGeomNode() startHpr = geomNode.getHpr() destHpr = Point3(startHpr) hRot = rng.randrange(1, 8) if rng.choice([0, 1]): hRot = -hRot destHpr.setX(destHpr[0] + hRot * 360) spinHTrack = Sequence(LerpHprInterval(geomNode, flyDur, destHpr, startHpr=startHpr), Func(geomNode.setHpr, startHpr), name=toon.uniqueName('hitBySuit-spinH')) parent = geomNode.getParent() rotNode = parent.attachNewNode('rotNode') geomNode.reparentTo(rotNode) rotNode.setZ(toon.getHeight() / 2.0) oldGeomNodeZ = geomNode.getZ() geomNode.setZ(-toon.getHeight() / 2.0) startHpr = rotNode.getHpr() destHpr = Point3(startHpr) pRot = rng.randrange(1, 3) if rng.choice([0, 1]): pRot = -pRot destHpr.setY(destHpr[1] + pRot * 360) spinPTrack = Sequence(LerpHprInterval(rotNode, flyDur, destHpr, startHpr=startHpr), Func(rotNode.setHpr, startHpr), name=toon.uniqueName('hitBySuit-spinP')) i = self.avIdList.index(avId) soundTrack = Sequence(Func(base.playSfx, self.sndTable['hitBySuit'][i]), Wait(flyDur * (2.0 / 3.0)), SoundInterval(self.sndTable['falling'][i], duration=flyDur * (1.0 / 3.0)), name=toon.uniqueName('hitBySuit-soundTrack')) def preFunc(self=self, avId=avId, toon=toon, dropShadow=dropShadow): forwardSpeed = toon.forwardSpeed rotateSpeed = toon.rotateSpeed if avId == self.localAvId: self.stopGameWalk() else: toon.stopSmooth() if forwardSpeed or rotateSpeed: toon.setSpeed(forwardSpeed, rotateSpeed) toon.dropShadow.hide() def postFunc(self=self, avId=avId, oldGeomNodeZ=oldGeomNodeZ, dropShadow=dropShadow, parentNode=parentNode): if avId == self.localAvId: base.localAvatar.setPos(endPos) if hasattr(self, 'gameWalk'): toon = base.localAvatar toon.setSpeed(0, 0) self.startGameWalk() dropShadow.removeNode() del dropShadow toon = self.getAvatar(avId) if toon: toon.dropShadow.show() geomNode = toon.getGeomNode() rotNode = geomNode.getParent() baseNode = rotNode.getParent() geomNode.reparentTo(baseNode) rotNode.removeNode() del rotNode geomNode.setZ(oldGeomNodeZ) if toon: toon.reparentTo(render) toon.setPos(endPos) parentNode.removeNode() del parentNode if avId != self.localAvId: if toon: toon.startSmooth() preFunc() slipBack = Parallel( Sequence(ActorInterval(toon, 'slip-backward', endFrame=24), Wait(CTGG.LyingDownDuration - (flyDur - oldFlyDur)), ActorInterval(toon, 'slip-backward', startFrame=24))) if toon.doId == self.localAvId: slipBack.append(SoundInterval(self.sndOof)) hitTrack = Sequence(Parallel(flyTrack, spinHTrack, spinPTrack, soundTrack), slipBack, Func(postFunc), name=toon.uniqueName('hitBySuit')) self.notify.debug('hitTrack duration = %s' % hitTrack.getDuration()) self.toonHitTracks[avId] = hitTrack hitTrack.start(globalClockDelta.localElapsedTime(timestamp)) return def updateSuitGoal(self, timestamp, inResponseToClientStamp, suitNum, goalType, goalId, x, y, z): if not self.hasLocalToon: return self.notify.debug( 'updateSuitGoal gameTime=%s timeStamp=%s cog=%s goal=%s goalId=%s (%.1f, %.1f,%.1f)' % (self.getCurrentGameTime(), timestamp, suitNum, CTGG.GoalStr[goalType], goalId, x, y, z)) cog = self.cogInfo[suitNum] cog['goal'] = goalType cog['goalId'] = goalId newPos = Point3(x, y, z) cog['pos'] = newPos suit = cog['suit'] suit.updateGoal(timestamp, inResponseToClientStamp, goalType, goalId, newPos) def spawnUpdateSuitsTask(self): self.notify.debug('spawnUpdateSuitsTask') for cogIndex in self.cogInfo: suit = self.cogInfo[cogIndex]['suit'] suit.gameStart(self.gameStartTime) taskMgr.remove(self.UPDATE_SUITS_TASK) taskMgr.add(self.updateSuitsTask, self.UPDATE_SUITS_TASK) def removeUpdateSuitsTask(self): taskMgr.remove(self.UPDATE_SUITS_TASK) def updateSuitsTask(self, task): if self.gameIsEnding: return task.done for cogIndex in self.cogInfo: suit = self.cogInfo[cogIndex]['suit'] suit.think() return task.cont def makeSuitRespondToToonHit(self, timestamp, suitNum): cog = self.cogInfo[suitNum]['suit'] cog.respondToToonHit(timestamp) def handleEnterBarrel(self, colEntry): if self.gameIsEnding: return intoName = colEntry.getIntoNodePath().getName() fromName = colEntry.getFromNodePath().getName() debugInto = intoName.split('/') debugFrom = fromName.split('/') self.notify.debug( 'handleEnterBarrel gameTime=%s %s into %s' % (self.getCurrentGameTime(), debugFrom[-1], debugInto[-1])) if 'CogThiefSphere' in intoName: parts = intoName.split('-') cogIndex = int(parts[1]) barrelName = colEntry.getFromNodePath().getName() barrelParts = barrelName.split('-') barrelIndex = int(barrelParts[1]) cog = self.cogInfo[cogIndex]['suit'] if cog.barrel == CTGG.NoBarrelCarried and barrelIndex not in self.stolenBarrels: timestamp = globalClockDelta.localToNetworkTime( globalClock.getFrameTime(), bits=32) if cog.suit: cogPos = cog.suit.getPos() collisionPos = colEntry.getContactPos(render) self.sendUpdate('cogHitBarrel', [ timestamp, cogIndex, barrelIndex, cogPos[0], cogPos[1], cogPos[2] ]) def makeCogCarryBarrel(self, timestamp, inResponseToClientStamp, cogIndex, barrelIndex, x, y, z): if not self.hasLocalToon: return if self.gameIsEnding: return self.notify.debug( 'makeCogCarryBarrel gameTime=%s timeStamp=%s cog=%s barrel=%s (%.1f, %.1f,%.1f)' % (self.getCurrentGameTime(), timestamp, cogIndex, barrelIndex, x, y, z)) barrel = self.barrels[barrelIndex] self.notify.debug('barrelPos= %s' % barrel.getPos()) cog = self.cogInfo[cogIndex]['suit'] cogPos = Point3(x, y, z) cog.makeCogCarryBarrel(timestamp, inResponseToClientStamp, barrel, barrelIndex, cogPos) def makeCogDropBarrel(self, timestamp, inResponseToClientStamp, cogIndex, barrelIndex, x, y, z): if not self.hasLocalToon: return self.notify.debug( 'makeCogDropBarrel gameTime=%s timeStamp=%s cog=%s barrel=%s (%.1f, %.1f,%.1f)' % (self.getCurrentGameTime(), timestamp, cogIndex, barrelIndex, x, y, z)) barrel = self.barrels[barrelIndex] self.notify.debug('barrelPos= %s' % barrel.getPos()) cog = self.cogInfo[cogIndex]['suit'] cogPos = Point3(x, y, z) cog.makeCogDropBarrel(timestamp, inResponseToClientStamp, barrel, barrelIndex, cogPos) def controlKeyPressed(self): if self.isToonPlayingHitTrack(self.localAvId): return if self.gameIsEnding: return if self.getCurrentGameTime( ) - self.lastTimeControlPressed > self.ControlKeyLimitTime: self.lastTimeControlPressed = self.getCurrentGameTime() self.notify.debug('controlKeyPressed') toonSD = self.toonSDs[self.localAvId] curState = toonSD.fsm.getCurrentState().getName() toon = self.getAvatar(self.localAvId) timestamp = globalClockDelta.localToNetworkTime( globalClock.getFrameTime(), bits=32) pos = toon.getPos() heading = toon.getH() self.sendUpdate( 'throwingPie', [self.localAvId, timestamp, heading, pos[0], pos[1], pos[2]]) self.showToonThrowingPie(self.localAvId, timestamp, heading, pos) def throwingPie(self, avId, timestamp, heading, x, y, z): if not self.hasLocalToon: return if self.gameFSM.getCurrentState().getName() not in ['play']: self.notify.warning('ignoring msg: av %s hit by suit' % avId) return self.notify.debug('avatar ' + ` avId ` + ' throwing pie') if avId != self.localAvId: pos = Point3(x, y, z) self.showToonThrowingPie(avId, timestamp, heading, pos) def showToonThrowingPie(self, avId, timestamp, heading, pos): toon = self.getAvatar(avId) if toon: tossTrack, pieTrack, flyPie = self.getTossPieInterval( toon, pos[0], pos[1], pos[2], heading, 0, 0, 0) def removePieFromTraverser(flyPie=flyPie): if base.cTrav: if flyPie: base.cTrav.removeCollider(flyPie) if avId == self.localAvId: flyPie.setTag('throwerId', str(avId)) collSphere = CollisionSphere(0, 0, 0, 0.5) collSphere.setTangible(0) name = 'PieSphere-%d' % avId collSphereName = self.uniqueName(name) collNode = CollisionNode(collSphereName) collNode.setFromCollideMask(ToontownGlobals.PieBitmask) collNode.addSolid(collSphere) colNp = flyPie.attachNewNode(collNode) colNp.show() base.cTrav.addCollider(colNp, self.pieHandler) self.accept('pieHit-' + collSphereName, self.handlePieHitting) def matchRunningAnim(toon=toon): toon.playingAnim = None toon.setSpeed(toon.forwardSpeed, toon.rotateSpeed) return newTossTrack = Sequence(tossTrack, Func(matchRunningAnim)) pieTrack = Parallel(newTossTrack, pieTrack) elapsedTime = globalClockDelta.localElapsedTime(timestamp) if elapsedTime < 16.0 / 24.0: elapsedTime = 16.0 / 24.0 pieTrack.start(elapsedTime) self.toonPieTracks[avId] = pieTrack def getTossPieInterval(self, toon, x, y, z, h, p, r, power, beginFlyIval=Sequence()): from toontown.toonbase import ToontownBattleGlobals from toontown.battle import BattleProps pie = toon.getPieModel() pie.setScale(0.9) flyPie = pie.copyTo(NodePath('a')) pieName = ToontownBattleGlobals.pieNames[toon.pieType] pieType = BattleProps.globalPropPool.getPropType(pieName) animPie = Sequence() if pieType == 'actor': animPie = ActorInterval(pie, pieName, startFrame=48) sound = loader.loadSfx('phase_3.5/audio/sfx/AA_pie_throw_only.ogg') t = power / 100.0 dist = 100 - 70 * t time = 1 + 0.5 * t proj = ProjectileInterval(None, startPos=Point3(0, 0, 0), endPos=Point3(0, dist, 0), duration=time) relVel = proj.startVel def getVelocity(toon=toon, relVel=relVel): return render.getRelativeVector(toon, relVel) * 0.6 toss = Track( (0, Sequence( Func(toon.setPosHpr, x, y, z, h, p, r), Func(pie.reparentTo, toon.rightHand), Func(pie.setPosHpr, 0, 0, 0, 0, 0, 0), Parallel( ActorInterval( toon, 'throw', startFrame=48, partName='torso'), animPie), Func(toon.loop, 'neutral'))), (16.0 / 24.0, Func(pie.detachNode))) fly = Track( (14.0 / 24.0, SoundInterval(sound, node=toon)), (16.0 / 24.0, Sequence( Func(flyPie.reparentTo, render), Func(flyPie.setPosHpr, toon, 0.52, 0.97, 2.24, 0, -45, 0), beginFlyIval, ProjectileInterval(flyPie, startVel=getVelocity, duration=6), Func(flyPie.detachNode)))) return (toss, fly, flyPie) def handlePieHitting(self, colEntry): if self.gameIsEnding: return into = colEntry.getIntoNodePath() intoName = into.getName() if 'CogThiefPieSphere' in intoName: timestamp = globalClockDelta.localToNetworkTime( globalClock.getFrameTime(), bits=32) parts = intoName.split('-') suitNum = int(parts[1]) pos = self.cogInfo[suitNum]['suit'].suit.getPos() if pos in CTGG.CogStartingPositions: self.notify.debug('Cog %d hit at starting pos %s, ignoring' % (suitNum, pos)) else: self.sendUpdate('pieHitSuit', [ self.localAvId, timestamp, suitNum, pos[0], pos[1], pos[2] ]) self.makeSuitRespondToPieHit(timestamp, suitNum) def pieHitSuit(self, avId, timestamp, suitNum, x, y, z): if not self.hasLocalToon: return if self.gameFSM.getCurrentState().getName() not in ['play']: self.notify.warning('ignoring msg: av %s hit by suit' % avId) return if self.gameIsEnding: return self.notify.debug('avatar ' + ` avId ` + ' hit by a suit') if avId != self.localAvId: self.makeSuitRespondToPieHit(timestamp, suitNum) def makeSuitRespondToPieHit(self, timestamp, suitNum): cog = self.cogInfo[suitNum]['suit'] cog.respondToPieHit(timestamp) def sendCogAtReturnPos(self, cogIndex, barrelIndex): timestamp = globalClockDelta.localToNetworkTime( globalClock.getFrameTime(), bits=32) self.sendUpdate('cogAtReturnPos', [timestamp, cogIndex, barrelIndex]) def markBarrelStolen(self, timestamp, inResponseToClientStamp, barrelIndex): if not self.hasLocalToon: return if barrelIndex not in self.stolenBarrels: self.stolenBarrels.append(barrelIndex) barrel = self.barrels[barrelIndex] barrel.hide() if base.config.GetBool('cog-thief-check-barrels', 1): if not base.config.GetBool('cog-thief-endless', 0): if len(self.stolenBarrels) == len(self.barrels): localStamp = globalClockDelta.networkToLocalTime(timestamp, bits=32) gameTime = self.local2GameTime(localStamp) self.clockStopTime = gameTime self.notify.debug('clockStopTime = %s' % gameTime) score = int(self.scoreMult * CTGG.calcScore(gameTime) + 0.5) self.rewardPanel['text'] = str(score) self.showResults() def __gameTimerExpired(self): self.notify.debug('game timer expired') self.showResults() def __startRewardCountdown(self): taskMgr.remove(self.REWARD_COUNTDOWN_TASK) taskMgr.add(self.__updateRewardCountdown, self.REWARD_COUNTDOWN_TASK) def __killRewardCountdown(self): taskMgr.remove(self.REWARD_COUNTDOWN_TASK) def __updateRewardCountdown(self, task): curTime = self.getCurrentGameTime() if self.clockStopTime is not None: if self.clockStopTime < curTime: self.notify.debug('self.clockStopTime < curTime %s %s' % (self.clockStopTime, curTime)) self.__killRewardCountdown() curTime = self.clockStopTime if curTime > CTGG.GameTime: curTime = CTGG.GameTime score = int(self.scoreMult * CTGG.calcScore(curTime) + 0.5) if not hasattr(task, 'curScore'): task.curScore = score result = Task.cont if hasattr(self, 'rewardPanel'): self.rewardPanel['text'] = str(score) if task.curScore != score: if hasattr(self, 'jarIval'): self.jarIval.finish() s = self.rewardPanel.getScale() self.jarIval = Parallel(Sequence( self.rewardPanel.scaleInterval(0.15, s * 3.0 / 4.0, blendType='easeOut'), self.rewardPanel.scaleInterval(0.15, s, blendType='easeIn')), SoundInterval(self.sndRewardTick), name='cogThiefGameRewardJarThrob') self.jarIval.start() task.curScore = score else: result = Task.done return result def startGameWalk(self): if self.useOrthoWalk: self.gameWalk.start() else: self.gameWalk.enter() self.gameWalk.fsm.request('walking') def stopGameWalk(self): if self.useOrthoWalk: self.gameWalk.stop() else: self.gameWalk.exit() def getCogThief(self, cogIndex): return self.cogInfo[cogIndex]['suit'] def isToonPlayingHitTrack(self, avId): if avId in self.toonHitTracks: track = self.toonHitTracks[avId] if track.isPlaying(): return True return False def getNumCogs(self): result = base.config.GetInt('cog-thief-num-cogs', 0) if not result: safezone = self.getSafezoneId() result = CTGG.calculateCogs(self.numPlayers, safezone) return result def getCogSpeed(self): result = 6.0 safezone = self.getSafezoneId() result = CTGG.calculateCogSpeed(self.numPlayers, safezone) return result def showResults(self): if not self.gameIsEnding: self.gameIsEnding = True for barrel in self.barrels: barrel.wrtReparentTo(render) for key in self.cogInfo: thief = self.cogInfo[key]['suit'] thief.suit.setPos(100, 0, 0) thief.suit.hide() self.__killRewardCountdown() self.stopGameWalk() numBarrelsSaved = len(self.barrels) - len(self.stolenBarrels) resultStr = '' if numBarrelsSaved == len(self.barrels): resultStr = TTLocalizer.CogThiefPerfect elif numBarrelsSaved > 1: resultStr = TTLocalizer.CogThiefBarrelsSaved % { 'num': numBarrelsSaved } elif numBarrelsSaved == 1: resultStr = TTLocalizer.CogThiefBarrelSaved % { 'num': numBarrelsSaved } else: resultStr = TTLocalizer.CogThiefNoBarrelsSaved perfectTextSubnode = hidden.attachNewNode( self.__genText(resultStr)) perfectText = hidden.attachNewNode('perfectText') perfectTextSubnode.reparentTo(perfectText) frame = self.__textGen.getCardActual() offsetY = -abs(frame[2] + frame[3]) / 2.0 perfectTextSubnode.setPos(0, 0, offsetY) perfectText.setColor(1, 0.1, 0.1, 1) def fadeFunc(t, text=perfectText): text.setColorScale(1, 1, 1, t) def destroyText(text=perfectText): text.removeNode() def safeGameOver(self=self): if not self.frameworkFSM.isInternalStateInFlux(): self.gameOver() textTrack = Sequence( Func(perfectText.reparentTo, aspect2d), Parallel( LerpScaleInterval(perfectText, duration=0.5, scale=0.3, startScale=0.0), LerpFunctionInterval(fadeFunc, fromData=0.0, toData=1.0, duration=0.5)), Wait(2.0), Parallel( LerpScaleInterval(perfectText, duration=0.5, scale=1.0), LerpFunctionInterval(fadeFunc, fromData=1.0, toData=0.0, duration=0.5, blendType='easeIn')), Func(destroyText), WaitInterval(0.5), Func(safeGameOver)) if numBarrelsSaved == len(self.barrels): soundTrack = SoundInterval(self.sndPerfect) else: soundTrack = Sequence() self.resultIval = Parallel(textTrack, soundTrack) self.resultIval.start() def __genText(self, text): self.__textGen.setText(text) return self.__textGen.generate() def getIntroTrack(self): base.camera.setPosHpr(0, -13.66, 13.59, 0, -51.6, 0) result = Sequence( Wait(2), LerpPosHprInterval(base.camera, 13, Point3(self.cameraTopView[0], self.cameraTopView[1], self.cameraTopView[2]), Point3(self.cameraTopView[3], self.cameraTopView[4], self.cameraTopView[5]), blendType='easeIn')) return result
class Menu: def __init__(self): self.frameMain = DirectFrame( image = "gui/MenuBackground.png", image_scale = (1.7778, 1, 1), frameSize = (base.a2dLeft, base.a2dRight, base.a2dTop, base.a2dBottom), frameColor = (0, 0, 0, 0)) self.frameMain.setTransparency(1) self.title = DirectLabel( scale = 0.15, text_align = TextNode.ALeft, pos = (base.a2dLeft + 0.2, 0, 0), frameColor = (0, 0, 0, 0), text = "Main Menu", text_fg = (1,1,1,1)) self.title.setTransparency(1) self.title.reparentTo(self.frameMain) self.btnStart = self.createButton( "Start", -.10, ["Menu-Start"]) self.btnStart = self.createButton( "Credits", -.25, ["Menu-Credits"]) self.btnExit = self.createButton( "Quit", -.40, ["Menu-Quit"]) self.hide() def createButton(self, text, verticalPos, eventArgs): maps = loader.loadModel("gui/button_map") btnGeom = (maps.find("**/btn_ready"), maps.find("**/btn_click"), maps.find("**/btn_rollover"), maps.find("**/btn_disabled")) btn = DirectButton( text = text, text_fg = (0,0,0,1), text_scale = 0.05, text_pos = (0.02, -0.015), text_align = TextNode.ALeft, scale = 2, pos = (base.a2dLeft + 0.2, 0, verticalPos), geom = btnGeom, relief = 0, frameColor = (0,0,0,0), command = base.messenger.send, extraArgs = eventArgs, pressEffect = False, rolloverSound = None, clickSound = None) btn.reparentTo(self.frameMain) def show(self): self.frameMain.show() def hide(self): self.frameMain.hide()
class PartyEditorGridElement(DirectButton): notify = directNotify.newCategory('PartyEditorGridElement') def __init__(self, partyEditor, id, isDecoration, checkSoldOutAndPaidStatusAndAffordability, **kw): self.partyEditor = partyEditor self.id = id self.isDecoration = isDecoration self.checkSoldOutAndPaidStatusAndAffordability = checkSoldOutAndPaidStatusAndAffordability if self.isDecoration: self._name = TTLocalizer.PartyDecorationNameDict[self.id]['editor'] colorList = ((1.0, 1.0, 1.0, 1.0), (0.0, 0.0, 1.0, 1.0), (0.0, 1.0, 1.0, 1.0), (0.5, 0.5, 0.5, 1.0)) self.geom = self.partyEditor.partyPlanner.gui.find( '**/%s' % PartyGlobals.DecorationInformationDict[self.id]['gridAsset']) else: self._name = TTLocalizer.PartyActivityNameDict[self.id]['editor'] colorList = ((1.0, 1.0, 1.0, 1.0), (0.0, 1.0, 0.0, 1.0), (1.0, 1.0, 0.0, 1.0), (0.5, 0.5, 0.5, 1.0)) self.geom = self.partyEditor.partyPlanner.gui.find( '**/%s' % PartyGlobals.ActivityInformationDict[self.id]['gridAsset']) optiondefs = (('geom', self.geom, None), ('geom_scale', 1.0, None), ('geom_color', colorList[0], None), ('geom1_color', colorList[0], None), ('geom2_color', colorList[0], None), ('geom3_color', colorList[0], None), ('relief', None, None)) self.defineoptions(kw, optiondefs) DirectButton.__init__(self, self.partyEditor.parent) self.initialiseoptions(PartyEditorGridElement) self.setName('%sGridElement' % self._name) self.bind(DirectGuiGlobals.B1PRESS, self.clicked) self.bind(DirectGuiGlobals.B1RELEASE, self.released) self.bind(DirectGuiGlobals.ENTER, self.mouseEnter) self.bind(DirectGuiGlobals.EXIT, self.mouseExit) self.uprightNodePath = NodePath('%sUpright' % self._name) self.uprightNodePath.reparentTo(self) rollOverZOffset = self.getGridSize()[1] / 30.0 self.rolloverTitle = DirectLabel(relief=None, parent=self.uprightNodePath, pos=Point3(0.0, 0.0, rollOverZOffset), text=self._name, text_fg=(1.0, 1.0, 1.0, 1.0), text_shadow=(0.0, 0.0, 0.0, 1.0), text_scale=0.075) self.rolloverTitle.stash() self.stash() self.overValidSquare = False self.lastValidPosition = None self.setColorScale(0.9, 0.9, 0.9, 0.7) self.setTransparency(True) self.mouseOverTrash = False self.centerGridSquare = None return def getCorrectRotation(self): r = self.getR() if r == 90.0: r = 270.0 else: if r == 270.0: r = 90.0 if self.id == PartyGlobals.ActivityIds.PartyCannon: return PartyUtils.convertDegreesToPartyGrid(r + 180.0) return PartyUtils.convertDegreesToPartyGrid(r) def getDecorationTuple(self, x, y): return (self.id, self.centerGridSquare.x, PartyGlobals.PartyEditorGridSize[1] - 1 - self.centerGridSquare.y, self.getCorrectRotation()) def getActivityTuple(self, x, y): return (self.id, self.centerGridSquare.x, PartyGlobals.PartyEditorGridSize[1] - 1 - self.centerGridSquare.y, self.getCorrectRotation()) def attach(self, mouseEvent): PartyEditorGridElement.notify.debug('attached grid element %s' % self._name) taskMgr.remove('gridElementDragTask%s' % self._name) vWidget2render2d = self.getPos(render2d) vMouse2render2d = Point3(mouseEvent.getMouse()[0], 0, mouseEvent.getMouse()[1]) taskMgr.add(self.elementDragTask, 'gridElementDragTask%s' % self._name) self.unstash() self.rolloverTitle.unstash() self.uprightNodePath.reparentTo(self) self.setPosHprToDefault() def elementDragTask(self, state): aspectRatio = base.camLens.getAspectRatio() if aspectRatio >= 1.6: bounds = PartyGlobals.PartyEditorGridBoundsWidescreen else: bounds = PartyGlobals.PartyEditorGridBounds mwn = base.mouseWatcherNode if mwn.hasMouse(): vMouse2render2d = Point3(mwn.getMouse()[0], 0, mwn.getMouse()[1]) newPos = vMouse2render2d if newPos[0] > bounds[0][0] and newPos[0] < bounds[1][0] and newPos[ 2] < bounds[0][1] and newPos[2] > bounds[1][1]: centerGridSquare = self.snapToGrid(newPos) if centerGridSquare is not None: self.centerGridSquare = centerGridSquare if not self.overValidSquare: self.setOverValidSquare(True) if self.mouseOverTrash: self.setOverTrash(False) return Task.cont if self.id != PartyGlobals.ActivityIds.PartyClock and self.id != PartyGlobals.DecorationIds.NormalSky and self.id != PartyGlobals.DecorationIds.Dreamland and self.id != PartyGlobals.DecorationIds.Melodyland and newPos[ 0] > PartyGlobals.PartyEditorTrashBounds[0][0] and newPos[ 0] < PartyGlobals.PartyEditorTrashBounds[1][ 0] and newPos[ 2] < PartyGlobals.PartyEditorTrashBounds[0][ 1] and newPos[ 2] > PartyGlobals.PartyEditorTrashBounds[ 1][1]: if not self.mouseOverTrash: self.setOverTrash(True) else: if self.mouseOverTrash: self.setOverTrash(False) self.setPos(render2d, newPos) if self.overValidSquare: self.setOverValidSquare(False) return Task.cont def setOverTrash(self, value): self.mouseOverTrash = value if value: self.partyEditor.trashCanButton[ 'state'] = DirectGuiGlobals.DISABLED self.setColorScale(1.0, 0.0, 0.0, 1.0) else: self.partyEditor.trashCanButton['state'] = DirectGuiGlobals.NORMAL self.setColorScale(0.9, 0.9, 0.9, 0.7) def setOverValidSquare(self, value): self.overValidSquare = value if value: self.setColorScale(1.0, 1.0, 1.0, 1.0) else: self.setColorScale(0.9, 0.9, 0.9, 0.7) def removeFromGrid(self): if self.centerGridSquare is not None: self.partyEditor.partyEditorGrid.removeElement( self.centerGridSquare, self.getGridSize()) self.setOverValidSquare(False) self.lastValidPosition = None self.stash() return def snapToGrid(self, newPos): gridSquare = self.getGridSquareFromPosition(newPos) if gridSquare == None: self.setPosHprToDefault() self.setPos(render2d, newPos) return if not self.partyEditor.partyEditorGrid.checkGridSquareForAvailability( gridSquare, self.getGridSize()): self.setPos(render2d, newPos) return self.setPosHprBasedOnGridSquare(gridSquare) return gridSquare def getGridSize(self): if self.isDecoration: return PartyGlobals.DecorationInformationDict[self.id]['gridsize'] return PartyGlobals.ActivityInformationDict[self.id]['gridsize'] def setPosHprToDefault(self): self.setR(0.0) self.uprightNodePath.setR(0.0) def setPosHprBasedOnGridSquare(self, gridSquare): aspectRatio = base.camLens.getAspectRatio() if aspectRatio >= 1.6: gridCenter = PartyGlobals.PartyEditorGridCenterWidescreen gridSquareSize = PartyGlobals.PartyEditorGridSquareSizeWidescreen else: gridCenter = PartyGlobals.PartyEditorGridCenter gridSquareSize = PartyGlobals.PartyEditorGridSquareSize gridPos = gridSquare.getPos() if self.getGridSize()[0] % 2 == 0: gridPos.setX(gridPos[0] + gridSquareSize[0] / 2.0) if self.getGridSize()[1] % 2 == 0: gridPos.setZ(gridPos[2] + gridSquareSize[1] / 2.0) if self.id != PartyGlobals.ActivityIds.PartyFireworks: if gridPos[0] > gridCenter[ 0] + PartyGlobals.PartyEditorGridRotateThreshold: self.setR(90.0) self.uprightNodePath.setR(-90.0) elif gridPos[0] < gridCenter[ 0] - PartyGlobals.PartyEditorGridRotateThreshold: self.setR(270.0) self.uprightNodePath.setR(-270.0) elif gridPos[2] < gridCenter[ 1] - PartyGlobals.PartyEditorGridRotateThreshold: self.setR(180.0) self.uprightNodePath.setR(-180.0) else: self.setR(0.0) self.uprightNodePath.setR(0.0) else: self.setR(270.0) self.uprightNodePath.setR(-270.0) self.setPos(render2d, gridPos) self.lastValidPosition = gridPos def getGridSquareFromPosition(self, newPos): aspectRatio = base.camLens.getAspectRatio() if aspectRatio >= 1.6: bounds = PartyGlobals.PartyEditorGridBoundsWidescreen gridSquareSize = PartyGlobals.PartyEditorGridSquareSizeWidescreen else: bounds = PartyGlobals.PartyEditorGridBounds gridSquareSize = PartyGlobals.PartyEditorGridSquareSize localX = newPos[0] - bounds[0][0] localY = newPos[2] - bounds[1][1] x = int(localX / gridSquareSize[0]) y = int(localY / gridSquareSize[1]) y = PartyGlobals.PartyEditorGridSize[1] - 1 - y return self.partyEditor.partyEditorGrid.getGridSquare(x, y) def detach(self, mouseEvent): taskMgr.remove('gridElementDragTask%s' % self._name) self.rolloverTitle.stash() if self.overValidSquare: self.partyEditor.partyEditorGrid.registerNewElement( self, self.centerGridSquare, self.getGridSize()) self.partyEditor.updateCostsAndBank() self.partyEditor.handleMutuallyExclusiveActivities() else: if self.lastValidPosition is not None: if self.mouseOverTrash: self.partyEditor.trashCanButton[ 'state'] = DirectGuiGlobals.NORMAL self.lastValidPosition = None self.partyEditor.updateCostsAndBank() self.stash() else: self.setPos(render2d, self.lastValidPosition) self.setOverValidSquare(True) self.partyEditor.partyEditorGrid.registerNewElement( self, self.centerGridSquare, self.getGridSize()) self.partyEditor.updateCostsAndBank() self.partyEditor.handleMutuallyExclusiveActivities() else: self.stash() self.checkSoldOutAndPaidStatusAndAffordability() return def placeInPartyGrounds(self, desiredXY=None): self.centerGridSquare = self.partyEditor.partyEditorGrid.getClearGridSquare( self.getGridSize(), desiredXY) if self.centerGridSquare is not None: self.setOverValidSquare(True) self.unstash() self.setPosHprBasedOnGridSquare(self.centerGridSquare) self.partyEditor.partyEditorGrid.registerNewElement( self, self.centerGridSquare, self.getGridSize()) self.partyEditor.updateCostsAndBank() self.partyEditor.partyPlanner.instructionLabel[ 'text'] = TTLocalizer.PartyPlannerEditorInstructionsPartyGrounds self.checkSoldOutAndPaidStatusAndAffordability() return True return False return def clicked(self, mouseEvent): PartyEditorGridElement.notify.debug('clicked grid element %s' % self._name) if self.centerGridSquare is not None: self.attach(mouseEvent) self.partyEditor.partyEditorGrid.removeElement( self.centerGridSquare, self.getGridSize()) return def released(self, mouseEvent): PartyEditorGridElement.notify.debug('released grid element %s' % self._name) self.detach(mouseEvent) def mouseEnter(self, mouseEvent): parent = self.getParent() self.reparentTo(parent) self.rolloverTitle.unstash() def mouseExit(self, mouseEvent): self.rolloverTitle.stash() def destroy(self): self.unbind(DirectGuiGlobals.B1PRESS) self.unbind(DirectGuiGlobals.B1RELEASE) self.unbind(DirectGuiGlobals.ENTER) self.unbind(DirectGuiGlobals.EXIT) DirectButton.destroy(self)
class RepairSawingGame(RepairMincroGame): __module__ = __name__ sawSounds = None boardComplet = None boardDestroyed = None def __init__(self, repairGame): self.config = RepairGlobals.Sawing notify = DirectNotifyGlobal.directNotify.newCategory( 'RepairSawingGame') RepairMincroGame.__init__(self, repairGame, 'sawing', PLocalizer.Minigame_Repair_Sawing_Start) def _initVars(self): RepairMincroGame._initVars(self) self.boardsPool = {} self.currentBoard = None self.currentBoardIndex = 0 self.onDeckBoard = None self.onDeckBoardIndex = 0 self.totalScore = 0.0 self.hitZone1Penalty = False self.hitZone2Penalty = False self.hitBoardPenalty = False self.moveDiffForSound = 0.0 self.startPositions = (Point3(0.0, 0.0, 0.0), ) self.currentStartIndex = 0 self.lastMousePos = None self.board_left = None self.board_right = None self.cut = None self.zone1_right = None self.zone1_left = None self.zone2_right = None self.zone2_left = None self.piece1 = None self.piece2 = None self.lastHitIndex = -1 self.sawWaypoints = [] return def _initAudio(self): RepairMincroGame._initAudio(self) if not self.sawSounds: RepairSawingGame.sawSounds = ( loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_INOUT01), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_INOUT02), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_INOUT03), loadSfx(SoundGlobals.SFX_MINIGAME_REPAIR_SAW_INOUT04)) RepairSawingGame.boardComplete = loadSfx( SoundGlobals.SFX_MINIGAME_REPAIR_SAW_COMPLETE) RepairSawingGame.boardDestroyed = loadSfx( SoundGlobals.SFX_MINIGAME_REPAIR_SAW_FAIL) def _initVisuals(self): RepairMincroGame._initVisuals(self) self.setBin('fixed', 36) self.model = loader.loadModel('models/gui/pir_m_gui_srp_sawing_main') sawModel = self.model.find('**/saw') sawModel.setR(193) sawModel.setPos(0.9, 0.0, -0.165) sawModel.setBin('gui-popup', 0) self.sawButton = RepairSaw(parent=self, clickDownCommand=self.sawAttachedToMouse, clickUpCommand=self.sawRemovedFromMouse, geom=sawModel, text_pos=(0.2, -0.3), text_fg=(1, 0, 0, 1), scale=(0.3, 0.3, 0.3), relief=None, pressEffect=0, frameSize=(-0.05, 1.05, -0.3, 0.05), rolloverSound=None, clickSound=None) self.sawingLine = RepairSawingLine(self, self.config.sawlineLineThickness, self.config.sawlineColor, self.config.sawlineLinespawnDist) self.progressDescriptionLabel = DirectLabel( text=PLocalizer.Minigame_Repair_Sawing_Description, text_fg=(1.0, 1.0, 1.0, 1.0), text_pos=(0.0, 0.0), text_shadow=(0.0, 0.0, 0.0, 1.0), text_font=PiratesGlobals.getPirateFont(), text_align=TextNode.ARight, relief=None, scale=(0.08, 0.08, 0.08), pos=(-0.2, 0.0, 0.5), parent=self) self.progressLabel = DirectLabel( text=PLocalizer.Minigame_Repair_Sawing_Thresholds[3], text_fg=(1.0, 1.0, 1.0, 1.0), text_pos=(0.0, 0.0), text_shadow=(0.0, 0.0, 0.0, 1.0), text_font=PiratesGlobals.getPirateFont(), text_align=TextNode.ALeft, relief=None, scale=(0.08, 0.08, 0.08), pos=(-0.18, 0.0, 0.5), parent=self) self.boardDestroyedLabel = DirectLabel( text=PLocalizer.Minigame_Repair_Sawing_Board_Destroyed, text_fg=(1.0, 0.0, 0.0, 1.0), text_pos=(0.0, 0.0), text_font=PiratesGlobals.getPirateFont(), text_shadow=(0.0, 0.0, 0.0, 1.0), relief=None, scale=(0.1, 0.1, 0.1), pos=(0.0, 0.0, 0.1), parent=self) self.boardDestroyedLabel.setBin('fixed', 38) self.boardDestroyedLabel.stash() return def _initIntervals(self): RepairMincroGame._initIntervals(self) self.newBoardSequence = Sequence( name='RepairSawingGame.newBoardSequence') self.splitBoardSequence = Sequence( name='RepairSawGame.splitBoardSequence') self.dropBoardSequence = Sequence( name='RepairSawGame.dropBoardSequence') def getNewBoard(self, boardIndex): board = self.model.find('**/wood%i' % boardIndex).copyTo( NodePath('board%i' % len(self.boardsPool))) board.reparentTo(self) piece1 = board.find('**/piece_1') piece1.setPythonTag('piece_1', self.piece1) piece1.setY(self.config.boardYDist) piece2 = board.find('**/piece_2') piece2.setPythonTag('piece_2', self.piece2) piece2.setY(self.config.boardYDist) pieceCut = board.find('**/piece_cut') pieceCut.setPythonTag('cut', self.cut) pieceCut.setColor(self.config.cutColor) pieceCut.setY(self.config.boardYDist) board_left = piece1.find('**/board') board_left.setPythonTag('left', self.board_left) board_right = piece2.find('**/board') board_right.setPythonTag('right', self.board_right) zone1_right = piece2.find('**/zone_1') zone1_right.setPythonTag('zone1_right', self.zone1_right) zone1_right.setColor(self.config.zone1Color) zone1_left = piece1.find('**/zone_1') zone1_left.setPythonTag('zone1_left', self.zone1_left) zone1_left.setColor(self.config.zone1Color) zone2_right = piece2.find('**/zone_2') zone2_right.setPythonTag('zone2_right', self.zone2_right) zone2_right.setColor(self.config.zone2Color) zone2_left = piece1.find('**/zone_2') zone2_left.setPythonTag('zone2_left', self.zone2_left) zone2_left.setColor(self.config.zone2Color) board.stash() return board def reset(self): for key in self.boardsPool.keys(): board = self.boardsPool[key] board.removeNode() self.boardsPool.clear() if self.currentBoard: self.currentBoard.removeNode() self.currentBoard = None if self.onDeckBoard: self.onDeckBoard.removeNode() self.onDeckBoard = None for boardIndex in self.currentDifficultySet: boardIndex -= 1 if 'copy1_%s' % boardIndex not in self.boardsPool: board = self.getNewBoard(boardIndex) self.boardsPool['copy1_%s' % boardIndex] = board if 'copy2_%s' % boardIndex not in self.boardsPool: board = self.getNewBoard(boardIndex) self.boardsPool['copy2_%s' % boardIndex] = board self.currentBoardIndex = 0 self.currentBoard = None self.moveNewBoardOnDeck() self.onDeckBoard.unstash() self.totalScore = 0 self.startPositions = (Point3(0.0, 0.0, 0.0), ) self.sawButton.stash() self.sawButton.reparentTo(self) self.lastHitIndex = -1 self.moveDiffForSound = 0.0 RepairMincroGame.reset(self) self.repairGame.gui.setTutorial(self.name) self.repairGame.gui.setTitle(self.name) return def destroy(self): RepairMincroGame.destroy(self) taskMgr.remove('SawingGame.updateSawTask') self.sawButton.destroy() self.sawButton.removeNode() del self.sawButton if self.currentBoard: self.currentBoard.removeNode() self.currentBoard = None if self.onDeckBoard: self.onDeckBoard.removeNode() self.onDeckBoard = None self.sawingLine = None self.progressDescriptionLabel.destroy() self.progressDescriptionLabel = None self.progressLabel.destroy() self.progressLabel = None self.boardDestroyedLabel.destroy() self.boardDestroyedLabel = None for key in self.boardsPool.keys(): board = self.boardsPool[key] if not board.isEmpty(): board.removeNode() self.boardsPool.clear() self.newBoardSequence.clearToInitial() del self.newBoardSequence self.splitBoardSequence.clearToInitial() del self.splitBoardSequence self.dropBoardSequence.clearToInitial() del self.dropBoardSequence return def setDifficulty(self, difficulty): RepairMincroGame.setDifficulty(self, difficulty) percent = difficulty / self.repairGame.difficultyMax difIndex = int( math.floor(percent * (len(self.config.difficultySets) - 1))) self.currentDifficultySet = self.config.difficultySets[difIndex] def splitBoard(self): self.sawingLine.reset() board = self.currentBoard boardIndex = self.currentBoardIndex if self.hitZone2Penalty: boardSplitAnim = Parallel( LerpPosInterval(self.board_left, duration=self.config.splitBoardAnimTime, pos=Point3(-2.0, 0.0, 0.0)), LerpPosInterval(self.board_right, duration=self.config.splitBoardAnimTime, pos=Point3(2.0, 0.0, 0.0)), LerpFunc(self.zone2_left.setSa, duration=self.config.splitBoardAnimTime / 2.0, fromData=1.0, toData=0.0), LerpFunc(self.zone2_right.setSa, duration=self.config.splitBoardAnimTime / 2.0, fromData=1.0, toData=0.0), LerpFunc(self.zone1_left.setSa, duration=self.config.splitBoardAnimTime / 2.0, fromData=1.0, toData=0.0), LerpFunc(self.zone1_right.setSa, duration=self.config.splitBoardAnimTime / 2.0, fromData=1.0, toData=0.0), LerpFunc(self.cut.setSa, duration=self.config.splitBoardAnimTime / 2.0, fromData=1.0, toData=0.0)) else: if self.hitZone1Penalty: boardSplitAnim = Parallel( LerpPosInterval(self.board_left, duration=self.config.splitBoardAnimTime, pos=Point3(-2.0, 0.0, 0.0)), LerpPosInterval(self.board_right, duration=self.config.splitBoardAnimTime, pos=Point3(2.0, 0.0, 0.0)), LerpPosInterval(self.zone2_left, duration=self.config.splitBoardAnimTime, pos=Point3(-2.0, 0.0, 0.0)), LerpPosInterval(self.zone2_right, duration=self.config.splitBoardAnimTime, pos=Point3(2.0, 0.0, 0.0)), LerpFunc(self.zone1_left.setSa, duration=self.config.splitBoardAnimTime / 2.0, fromData=1.0, toData=0.0), LerpFunc(self.zone1_right.setSa, duration=self.config.splitBoardAnimTime / 2.0, fromData=1.0, toData=0.0), LerpFunc(self.cut.setSa, duration=self.config.splitBoardAnimTime / 2.0, fromData=1.0, toData=0.0)) else: boardSplitAnim = Parallel( LerpPosInterval(self.piece1, duration=self.config.splitBoardAnimTime, pos=Point3(-2.0, self.config.boardYDist, 0.0)), LerpPosInterval(self.piece2, duration=self.config.splitBoardAnimTime, pos=Point3(2.0, self.config.boardYDist, 0.0)), LerpFunc(self.cut.setSa, duration=self.config.splitBoardAnimTime / 2.0, fromData=1.0, toData=0.0)) self.splitBoardSequence = Sequence( Func(self.updateScore), Func(self.boardComplete.play), boardSplitAnim, Func(board.stash), Func(self.piece1.setPos, self.piece1.getPos()), Func(self.piece2.setPos, self.piece2.getPos()), Func(self.board_right.setPos, self.board_right.getPos()), Func(self.board_left.setPos, self.board_left.getPos()), Func(self.zone2_right.setPos, self.zone2_right.getPos()), Func(self.zone2_left.setPos, self.zone2_left.getPos()), Func(self.zone1_right.setPos, self.zone1_right.getPos()), Func(self.zone1_left.setPos, self.zone1_left.getPos()), Func(self.cut.setSa, 1.0), Func(self.zone1_right.setSa, 1.0), Func(self.zone1_left.setSa, 1.0), Func(self.zone2_right.setSa, 1.0), Func(self.zone2_left.setSa, 1.0), Func(self.board_right.setSa, 1.0), Func(self.board_left.setSa, 1.0), Func(self.loadNewBoard), Func(self.addBoardBackToPool, board, boardIndex), name='RepairSawGame.splitBoardSequence') self.splitBoardSequence.start() def dropBoard(self): board = self.currentBoard boardIndex = self.currentBoardIndex self.dropBoardSequence = Sequence( Parallel( Sequence(Func(self.boardDestroyedLabel.unstash), Wait(1.5), Func(self.boardDestroyedLabel.stash)), Sequence( Wait(0.5), Func(self.boardDestroyed.play), Func(self.sawingLine.reset), LerpPosInterval(board, duration=self.config.splitBoardAnimTime, pos=Point3(0.0, 0.0, -2.0)), Func(board.stash), Wait(0.5), Func(self.loadNewBoard), Func(self.addBoardBackToPool, board, boardIndex))), name='RepairSawGame.dropBoardSequence') self.dropBoardSequence.start() def addBoardBackToPool(self, board, boardIndex): if 'copy1_%s' % boardIndex not in self.boardsPool: self.boardsPool['copy1_%s' % boardIndex] = board else: if 'copy2_%s' % boardIndex not in self.boardsPool: self.boardsPool['copy2_%s' % boardIndex] = board else: self.notify.error( 'Two copies of board type %i already in the boardsPool!' % boardIndex) def updateScoreText(self): self.progressLabel.unstash() self.progressDescriptionLabel.unstash() if self.hitBoardPenalty: self.progressLabel[ 'text'] = PLocalizer.Minigame_Repair_Sawing_Thresholds[0] self.progressLabel['text_fg'] = Vec4(1.0, 0.0, 0.0, 1.0) self.progressLabel.setText() else: if self.hitZone2Penalty: self.progressLabel[ 'text'] = PLocalizer.Minigame_Repair_Sawing_Thresholds[1] self.progressLabel['text_fg'] = Vec4(1.0, 0.5, 0.0, 1.0) self.progressLabel.setText() else: if self.hitZone1Penalty: self.progressLabel[ 'text'] = PLocalizer.Minigame_Repair_Sawing_Thresholds[ 2] self.progressLabel['text_fg'] = Vec4(1.0, 1.0, 0.0, 1.0) self.progressLabel.setText() else: self.progressLabel[ 'text'] = PLocalizer.Minigame_Repair_Sawing_Thresholds[ 3] self.progressLabel['text_fg'] = Vec4(0.0, 1.0, 0.0, 1.0) self.progressLabel.setText() def moveNewBoardOnDeck(self): boardIndex = random.randint(0, len(self.currentDifficultySet) - 1) boardType = self.currentDifficultySet[boardIndex] boardType -= 1 if 'copy1_%s' % boardType in self.boardsPool: self.onDeckBoard = self.boardsPool['copy1_%s' % boardType] del self.boardsPool['copy1_%s' % boardType] else: if 'copy2_%s' % boardType in self.boardsPool: self.onDeckBoard = self.boardsPool['copy2_%s' % boardType] del self.boardsPool['copy2_%s' % boardType] else: self.notify.error( 'No copies of board type %i in the boardsPool!' % boardType) self.onDeckBoardIndex = boardType self.onDeckBoard.setScale(0.25) self.onDeckBoard.setPos(0.5, -2.0, 0.56) self.onDeckBoard.unstash() def loadNewBoard(self): self.progressLabel.stash() self.progressDescriptionLabel.stash() if self.totalScore >= self.config.totalPoints: if self.onDeckBoard: self.onDeckBoard.stash() self.progressDescriptionLabel.stash() taskMgr.remove('SawingGame.updateSawTask') self.request('Outro') return self.currentBoard = self.onDeckBoard self.currentBoardIndex = self.onDeckBoardIndex self.piece1 = self.currentBoard.find('**/piece_1') self.piece1.setTransparency(1) self.piece2 = self.currentBoard.find('**/piece_2') self.piece2.setTransparency(1) self.cut = self.currentBoard.find('**/piece_cut') self.cut.setColor(self.config.cutColor) self.cut.setTransparency(1) self.board_left = self.piece1.find('**/board') self.board_left.setTransparency(1) self.zone1_left = self.piece1.find('**/zone_1') self.zone1_left.setTransparency(1) self.zone2_left = self.piece1.find('**/zone_2') self.zone2_left.setTransparency(1) self.board_right = self.piece2.find('**/board') self.board_right.setTransparency(1) self.zone1_right = self.piece2.find('**/zone_1') self.zone1_right.setTransparency(1) self.zone2_right = self.piece2.find('**/zone_2') self.zone2_right.setTransparency(1) self.board_left.setCollideMask(SAW_COLLIDE_MASK) self.board_right.setCollideMask(SAW_COLLIDE_MASK) self.cut.setCollideMask(SAW_COLLIDE_MASK) self.zone1_right.setCollideMask(SAW_COLLIDE_MASK) self.zone1_left.setCollideMask(SAW_COLLIDE_MASK) self.zone2_right.setCollideMask(SAW_COLLIDE_MASK) self.zone2_left.setCollideMask(SAW_COLLIDE_MASK) self.startPositions = ( self.currentBoard.find('**/locator_start_0').getPos() + Point3(*self.config.activeBoardPosition), self.currentBoard.find('**/locator_start_1').getPos() + Point3(*self.config.activeBoardPosition)) self.currentStartIndex = 0 for waypoint in self.sawWaypoints: waypoint.removeNode() self.sawWaypoints = [] locator = self.currentBoard.find('**/locator_0') index = 0 while not locator.isEmpty(): self.sawWaypoints.append( SawWaypoint(index, self.currentBoard, locator.getPos())) locator = self.currentBoard.find('**/locator_%i' % (index + 1)) index += 1 self.sawButton.deactivate() self.sawButton.setPos(self.startPositions[self.currentStartIndex]) self.hitBoardPenalty = False self.hitZone1Penalty = False self.hitZone2Penalty = False self.lastMousePos = None self.moveDiffForSound = self.config.playSawingSoundDelta + 0.1 self.newBoardSequence = Sequence( Parallel( self.currentBoard.posInterval( self.config.newBoardAnimTime, Point3(*self.config.activeBoardPosition)), self.currentBoard.scaleInterval(self.config.newBoardAnimTime, 1.0)), name='RepairSawingGame.newBoardSequence') if self.state in ['Game']: self.newBoardSequence.append(Func(self.sawButton.activate)) self.newBoardSequence.append(Wait(0.5)) self.newBoardSequence.append(Func(self.moveNewBoardOnDeck)) self.newBoardSequence.start() return def updateSawTask(self, task): if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() relative = Point3(mpos.getX(), 0.0, mpos.getY()) relative = self.getRelativePoint(render2d, relative) moveDiff = 0.0 if self.lastMousePos != None: moveDiff = (relative - self.lastMousePos).length() pickedObjects = self.repairGame.mousePicker.getCollisions( self.currentBoard, useIntoNodePaths=True) self.updateWaypoints() if len(pickedObjects) > 0: self.moveDiffForSound += moveDiff if self.moveDiffForSound > self.config.playSawingSoundDelta: sawSoundPlaying = False for sound in self.sawSounds: if sound.status() == 2: sawSoundPlaying = True break if sawSoundPlaying == False: sound = random.choice(self.sawSounds) sound.play() self.moveDiffForSound = 0.0 if self.board_right in pickedObjects or self.board_left in pickedObjects: for waypoint in self.sawWaypoints: waypoint.hit = False self.hitBoardPenalty = True self.dropBoard() self.sawButton.deactivate() else: if self.cut in pickedObjects: self.updateWaypoints() else: if self.zone1_right in pickedObjects or self.zone1_left in pickedObjects: self.updateWaypoints() if self.hitZone1Penalty == False: self.hitZone1Penalty = True else: if self.zone2_right in pickedObjects or self.zone2_left in pickedObjects: self.updateWaypoints() if self.hitZone2Penalty == False: self.hitZone2Penalty = True self.updateScoreText() else: boardComplete = True for waypoint in self.sawWaypoints: if not waypoint.hit: boardComplete = False break if boardComplete: self.splitBoard() self.sawButton.deactivate() self.lastMousePos = self.sawButton.getPos() return Task.cont def updateScore(self): if not self.hitBoardPenalty: currBoardScore = self.config.pointsPerBoard currBoardScore -= self.config.pointsLostForZone1 * ( self.hitZone1Penalty or self.hitZone2Penalty) currBoardScore -= self.config.pointsLostForZone2 * self.hitZone2Penalty rating = 4 - 1 * self.hitZone2Penalty - 3 * self.hitZone1Penalty self.totalScore += currBoardScore self.totalScore = min(self.totalScore, self.config.totalPoints) percent = int(self.totalScore / self.config.totalPoints * 100.0) self.repairGame.d_reportMincroGameProgress(percent, rating) def resetWaypoints(self): for waypoint in self.sawWaypoints: waypoint.hit = False def updateWaypoints(self): waypointList = self.getHitWaypoints() for waypointIndex in waypointList: self.lastHitIndex = waypointIndex self.sawWaypoints[waypointIndex].hit = True if waypointIndex == 0: self.currentStartIndex = not self.sawWaypoints[-1].hit and 0 elif waypointIndex == len(self.sawWaypoints) - 1: self.currentStartIndex = not self.sawWaypoints[0].hit and 1 def getHitWaypoints(self): waypointsHit = [] testDelta = self.config.testWaypointDelta for i in range(len(self.sawWaypoints)): waypointPos = self.sawWaypoints[i].getPos(self) closestDistance = 9999 if self.lastMousePos != None: currMousePos = self.sawButton.getPos() lastMousePos = self.lastMousePos totalLength = (currMousePos - lastMousePos).length() testLength = testDelta while testLength < totalLength: testPos = (currMousePos - lastMousePos) * ( testLength / totalLength) + lastMousePos self.updateSawLine(testPos) testDistance = (testPos - waypointPos).length() closestDistance = min(testDistance, closestDistance) testLength += testDelta self.updateSawLine(self.sawButton.getPos()) testDistance = (self.sawButton.getPos() - waypointPos).length() closestDistance = min(testDistance, closestDistance) if closestDistance < self.config.waypointRange[ self.currentBoardIndex]: waypointsHit.append(i) return waypointsHit def updateSawLine(self, pos): if pos.getX() < -0.633 or pos.getX() > 0.633: self.sawingLine.reset() return if pos.getZ() < -0.183 or pos.getZ() > 0.375: self.sawingLine.reset() return self.sawingLine.update(pos) def getClosestPosition(self, positions): closestIndex = -1 if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() relative = Point3(mpos.getX(), 0.0, mpos.getY()) relative = self.getRelativePoint(base.a2dBackground, relative) bestDistance = 99999.0 for i in range(len(positions)): dX = relative.getX() - positions[i].getX() dZ = relative.getZ() - positions[i].getZ() newDistance = dX * dX + dZ * dZ if newDistance < bestDistance: bestDistance = newDistance closestIndex = i return closestIndex def sawAttachedToMouse(self): self.lastHitIndex = -1 if not taskMgr.hasTaskNamed('SawingGame.updateSawTask'): taskMgr.add(self.updateSawTask, 'SawingGame.updateSawTask', priority=2) def sawRemovedFromMouse(self): if not self.sawButton.isStashed(): self.sawButton.setPos(self.startPositions[self.currentStartIndex]) self.lastHitIndex = -1 self.resetWaypoints() self.lastMousePos = None self.progressLabel.stash() self.progressDescriptionLabel.stash() self.sawingLine.reset() self.hitBoardPenalty = False self.hitZone1Penalty = False self.hitZone2Penalty = False taskMgr.remove('SawingGame.updateSawTask') return def enterIntro(self): RepairMincroGame.enterIntro(self) self.loadNewBoard() def enterGame(self): RepairMincroGame.enterGame(self) self.repairGame.mousePicker.setCollisionMask(SAW_COLLIDE_MASK) self.sawButton.activate() def exitGame(self): RepairMincroGame.exitGame(self) self.sawButton.deactivate() self.repairGame.mousePicker.clearCollisionMask() taskMgr.remove('SawingGame.updateSawTask') self.splitBoardSequence.clearToInitial() self.dropBoardSequence.clearToInitial() localAvatar.guiMgr._showCursor() def enterOutro(self): RepairMincroGame.enterOutro(self) self.repairGame.d_reportMincroGameScore(150)
def __makeItem(self, item): obj = DirectLabel( text = str(item.giveLoot()) + "x " + item.giveType(), text_scale = 0.5, text_pos = (0, -1, 0), image = ("item.png", "item_hover.png", "item.png"), #normal, hover, disabled scale = 0.16, numStates = 2, state = DGG.NORMAL, relief = DGG.GROOVE) obj.setTransparency(True) obj["activeState"] = 0 obj.reparentTo(self.itemFrame.getCanvas()) obj.bind(DGG.B1PRESS, self.dragStart, [obj]) obj.bind(DGG.B1RELEASE, self.dragStop) obj.bind(DGG.ENTER, self.inObject, [obj]) obj.bind(DGG.EXIT, self.outObject, [obj]) return obj
def adjustForUnreleased(self): if self.unreleased: textScale = self.comingSoonTextScale comingSoon = DirectLabel(parent=self, text=TTLocalizer.PartyPlannerComingSoon, text_scale=textScale, text_fg=(1.0, 0, 0, 1.0), text_shadow=(0, 0, 0, 1), relief=None) self['state'] = DirectGuiGlobals.DISABLED return
class VoteResultsTrolleyPanel(DirectFrame): """ Display the voting results, with even more show. Assumes the camera is pointed at the trolley, and the avatars can be seen Adapted from VoteResultsPanel and RaceEndPanels.py """ notify = DirectNotifyGlobal.directNotify.newCategory('VoteResultsTrolleyPanel') def __init__(self, numPlayers, avIdList, votes, directions, namesList, disconnectedList, directionToGo, directionReason, directionTotals, *args, **kwargs): opts = {'relief':None, 'geom':DGG.getDefaultDialogGeom(), 'geom_color':ToontownGlobals.GlobalDialogColor[:3]+(0.80,), 'geom_scale':(1.75,1,0.25), 'pos':(0,0,0.825) } opts.update(kwargs) DirectFrame.__init__(self,*args, **opts) self.initialiseoptions(VoteResultsTrolleyPanel) listMultiplier = 1 if TravelGameGlobals.SpoofFour: listMultiplier = 4 self.avIdList = avIdList * listMultiplier self.numPlayers = numPlayers * listMultiplier self.votes = votes * listMultiplier self.directions = directions * listMultiplier self.namesList = namesList * listMultiplier self.disconnectedList = disconnectedList * listMultiplier self.directionToGo = directionToGo self.directionReason = directionReason self.directionTotals = directionTotals self.entryList = [] self.rowFrame = [] self.upDownFrame = DirectFrame( parent=self, relief=None, pos = self.getRowPos(-1), ) self.upLabel = DirectLabel( parent = self, relief = None, pos = (-0.5, 0, 0.06), text = TTLocalizer.TravelGameDirections[0]+ ':', text_fg = (0.0, 0.0, 1.0, 1.0), text_scale = 0.05, text_align = TextNode.ARight ) self.downLabel = DirectLabel( parent = self, relief = None, pos = (0.5, 0, 0.06), text = TTLocalizer.TravelGameDirections[1]+':', text_fg = (1.0, 0.0, 0.0, 1.0), text_scale = 0.05, text_align = TextNode.ARight ) self.totalVotesUpLabel = DirectLabel( parent = self.upLabel, relief = None, pos = (0.2, 0, 0.0), text = '0', text_fg = (0.0, 0.0, 1.0, 1.0), text_scale = 0.05, text_align = TextNode.ARight ) self.totalVotesDownLabel = DirectLabel( parent = self.downLabel, relief = None, pos = (0.2, 0, 0.0), text = '0', text_fg = (1.0, 0.0, 0.0, 1.0), text_scale = 0.05, text_align = TextNode.ARight ) self.totalFrame = DirectFrame( parent=self, relief=None, pos = self.getRowPos(self.numPlayers), ) self.totalVotesLabels = [self.totalVotesUpLabel, self.totalVotesDownLabel] self.resultFrame = DirectFrame( parent=self, relief=None, #pos = self.getRowPos(self.numPlayers+1), pos = self.getRowPos(0.5), ) self.resultLabel = DirectLabel( parent = self.resultFrame, text = '', text_scale = 0.06, pos = (0.7, 0, 0.0), text_align = TextNode.ACenter ) self.setupResultLabel() for index in range(self.numPlayers): frame = DirectFrame( parent=self, relief=None, pos = self.getRowPos(index), ) self.rowFrame.append(frame) nameLabel = DirectFrame( parent = frame, relief = None, pos = (0.46,0.0,0.0), text = self.namesList[index], text_fg = (0.0, 0.0, 0.0, 1.0), text_scale = 0.05, text_align = TextNode.ACenter, text_font = DGG.getDefaultFont()#ToontownGlobals.getSignFont(), ) votesUpLabel = DirectLabel( parent = frame, relief = None, pos = (1.2,0.0,0.0), text = '', text_fg = (0,0,1,1), text_scale = 0.05, text_align = TextNode.ARight, text_font = DGG.getDefaultFont(), ) votesDownLabel = DirectLabel( parent = frame, relief = None, pos = (1.43,0.0,0.0), text = '', text_fg = (1,0,0,1), text_scale = 0.05, text_align = TextNode.ARight, text_font = DGG.getDefaultFont(), ) nameLabel.hide() self.entryList.append((nameLabel, votesUpLabel, votesDownLabel)) self.avVotesLabel = {} self.avArrows = {} matchingGameGui = loader.loadModel( 'phase_3.5/models/gui/matching_game_gui') minnieArrow = matchingGameGui.find("**/minnieArrow") from toontown.minigame.DistributedTravelGame import map3dToAspect2d for index in range(self.numPlayers): avId = self.avIdList[index] av = base.cr.doId2do.get(avId) if av: height = av.getHeight() avPos = av.getPos(render) avPos.setZ(av.getZ() + 5) # height) labelPos = map3dToAspect2d(render, avPos) if not labelPos: continue labelPos.setZ(labelPos.getZ() + 0.3) arrow = None if self.votes[index] > 0: arrow = aspect2d.attachNewNode('avArrow') minnieArrow.copyTo(arrow) arrow.setScale(1.1,1,1.15) arrow.setPos(labelPos) if self.directions[index] == 0: arrow.setR(-90) arrow.setColorScale(0,0,1,1) else: arrow.setR(90) arrow.setColorScale(1,0,0,1) arrow.wrtReparentTo(self.resultFrame) arrow.hide() self.avArrows[index] =arrow fgColor = Vec4(0,0,0,1) if self.votes[index] > 0: if self.directions[index] == 0: fgColor = Vec4(0,0,1,1) else : fgColor = Vec4(1,0,0,1) if self.votes[index] > 0: newLabel = DirectLabel( parent = aspect2d, #geom = DGG.getDefaultDialogGeom(), #geom_color =ToontownGlobals.GlobalDialogColor[:3]+(0.80,), #geom_scale = (0.1,1,0.1), relief = None, pos = labelPos, text = 'test', text_fg = (1,1,1,1), #fgColor, text_scale = 0.1, text_align = TextNode.ACenter, text_font = ToontownGlobals.getSignFont(), text_pos = (0,-0.01,0) ) else: newLabel = DirectLabel( parent = aspect2d, geom = DGG.getDefaultDialogGeom(), #geom_color =ToontownGlobals.GlobalDialogColor[:3]+(0.80,), geom_scale = (0.2,1,0.2), relief = None, pos = labelPos, text = 'test', text_fg = (0.5,0.5,0.5,1), #fgColor, text_scale = 0.1, text_align = TextNode.ACenter, text_font = ToontownGlobals.getSignFont(), text_pos = (0,-0.035,0) ) newLabel.wrtReparentTo(self.resultFrame) newLabel.hide() self.avVotesLabel[index] = newLabel matchingGameGui.removeNode() self.curArrowSfxIndex = 0 self.upArrowSfx = [] self.downArrowSfx = [] for i in range (5): self.upArrowSfx.append( base.loader.loadSfx("phase_4/audio/sfx/MG_sfx_travel_game_blue_arrow.mp3")) self.downArrowSfx.append( base.loader.loadSfx("phase_4/audio/sfx/MG_sfx_travel_game_red_arrow.mp3")) self.winVoteSfx = base.loader.loadSfx("phase_4/audio/sfx/MG_sfx_travel_game_win_vote.mp3") self.noVoteSfx = base.loader.loadSfx("phase_4/audio/sfx/MG_sfx_travel_game_square_no_vote_1.mp3") self.loseVoteSfx = base.loader.loadSfx("phase_4/audio/sfx/MG_sfx_travel_game_lose_vote.mp3") self.localAvatarWon = False self.localAvatarLost = False; localIndex = self.avIdList.index(base.localAvatar.doId) localDirection = self.directions[localIndex] localVotes = self.votes[localIndex] if localVotes: if localDirection == self.directionToGo: if not TravelGameGlobals.ReverseWin: self.localAvatarWon = True else: self.localAvatarLost = True else: if not TravelGameGlobals.ReverseWin: self.localAvatarLost = True else: self.localAvatarWon = True #""" #MG_sfx_travel_game_win_vote.mp3 MG_sfx_travel_game_turntble_rotate_1.mp3 \ #MG_sfx_travel_game_square_no_vote_2.mp3 MG_sfx_travel_game_red_arrow.mp3 \ #MG_sfx_travel_game_no_bonus.mp3 MG_sfx_travel_game_lose_vote.mp3 \ #MG_sfx_travel_game_bonus.mp3 MG_sfx_travel_game_blue_arrow.mp3 \ #MG_sfx_travel_game_bell_for_trolley.mp3 #""" def getRowPos(self, place): return Point3(-0.72,-0.01,0.0-place*0.1) def setupResultLabel(self): reasonStr = '' if self.directionReason == TravelGameGlobals.ReasonVote: if self.directionToGo == 0: losingDirection = 1 else: losingDirection = 0 diffVotes = self.directionTotals[self.directionToGo] - \ self.directionTotals[losingDirection] if diffVotes > 1: reasonStr = TTLocalizer.TravelGameReasonVotesPlural % { 'dir': TTLocalizer.TravelGameDirections[self.directionToGo], 'numVotes' : diffVotes,} else: reasonStr = TTLocalizer.TravelGameReasonVotesSingular % { 'dir': TTLocalizer.TravelGameDirections[self.directionToGo], 'numVotes' : diffVotes,} elif self.directionReason == TravelGameGlobals.ReasonRandom : reasonStr = TTLocalizer.TravelGameReasonRandom % { 'dir': TTLocalizer.TravelGameDirections[self.directionToGo], 'numVotes' : self.directionTotals[self.directionToGo],} elif self.directionReason == TravelGameGlobals.ReasonPlaceDecider: reasonStr = TravelGameReasonPlace % { 'name' : "TODO NAME", 'dir' : TTLocalizer.TravelGameDirections[self.directionToGo],} self.resultLabel['text'] = reasonStr self.resultLabel.hide() def createOnePlayerSequence(self, index, duration): """ create a sequence for one player """ numVotes = self.votes[index] direction = self.directions[index] def ticketTicker(t, label = self.entryList[index][direction+1], startVotes = 0, endVotes = numVotes): label['text'] = str( int(t*endVotes + startVotes)) track = Parallel() #track.append(Func(self.entryList[index][0].show, name='showName %d' % index)) #track.append(LerpFunc(ticketTicker,duration=duration, name='countVotes %d'% index)) # lets figure out the total before startVotes = 0 for prev in range(index): if self.directions[prev] == direction: startVotes += self.votes[prev] def totalTicker(t, label = self.totalVotesLabels[direction], startVotes = startVotes, additionalVotes = numVotes): label['text'] = str( int(t*additionalVotes + startVotes)) track.append(LerpFunc(totalTicker, duration=duration, name='countTotal %d' %index)) if index in self.avVotesLabel: def avVotesTicker(t, label = self.avVotesLabel[index], startVotes = 0, endVotes = numVotes, direction = direction): oldValue = label['text'] newValue = int(t*endVotes + startVotes) label['text'] = str(newValue) if not oldValue == label['text']: if newValue: if direction == 0: self.upArrowSfx[self.curArrowSfxIndex].play() else: self.downArrowSfx[self.curArrowSfxIndex].play() self.curArrowSfxIndex += 1 if self.curArrowSfxIndex >= len(self.upArrowSfx): self.curArrowSfxIndex = 0 label = self.avVotesLabel[index] track.append(Func(self.avVotesLabel[index].show, name='showName %d' % index)) if index in self.avArrows: track.append(Func(self.avArrows[index].show, name='showArrow %d' % index)) if direction == 0 and numVotes: #track.append(SoundInterval(self.upArrowSfx)) pass elif direction == 1 and numVotes: #track.append(SoundInterval(self.downArrowSfx)) pass else: track.append(SoundInterval(self.noVoteSfx)) track.append(LerpFunc(avVotesTicker,duration=duration, name='countAvVotes %d'% index)) return track def startMovie(self): self.movie = Sequence() for index in range(self.numPlayers): track = self.createOnePlayerSequence(index, 1.25) #track = self.createOnePlayerSequence(index, 5.25) self.movie.append(track) self.movie.append(Wait(0.75)) self.movie.append(Func(self.resultLabel.show)) soundAndWait = Parallel() soundAndWait.append( Wait(2.0)) if self.localAvatarWon: soundAndWait.append(SoundInterval(self.winVoteSfx)) elif self.localAvatarLost: soundAndWait.append(SoundInterval(self.loseVoteSfx, duration = 0.43)) self.movie.append(soundAndWait) self.movie.start() def destroy(self): self.movie.finish() del self.movie del self.winVoteSfx del self.noVoteSfx del self.upArrowSfx del self.loseVoteSfx del self.downArrowSfx DirectFrame.destroy(self)
class QuestMap(DirectFrame): def __init__(self, av, **kw): DirectFrame.__init__(self, relief=None, sortOrder=50) self.initialiseoptions(QuestMap) self.container = DirectFrame(parent=self, relief=None) self.marker = DirectFrame(parent=self.container, relief=None) self.cogInfoFrame = DirectFrame(parent=self.container, relief=None) cm = CardMaker('bg') cm.setFrame(-0.5, 0.5, -0.5, 0.5) bg = self.cogInfoFrame.attachNewNode(cm.generate()) bg.setTransparency(1) bg.setColor(0.5, 0.5, 0.5, 0.5) bg.setBin('fixed', 0) self.cogInfoFrame['geom'] = bg self.cogInfoFrame['geom_pos'] = (0, 0, 0) self.cogInfoFrame['geom_scale'] = (6, 1, 2) self.cogInfoFrame.setScale(0.05) self.cogInfoFrame.setPos(0, 0, 0.6) self.buildingMarkers = [] self.av = av self.wantToggle = False if base.config.GetBool('want-toggle-quest-map', True): self.wantToggle = True self.updateMarker = True self.cornerPosInfo = None self.hqPosInfo = None self.fishingSpotInfo = None self.load() self.setScale(1.5) bg.removeNode() self.hoodId = None self.zoneId = None self.suitPercentage = {} for currHoodInfo in SuitPlannerBase.SuitPlannerBase.SuitHoodInfo: tracks = currHoodInfo[ SuitPlannerBase.SuitPlannerBase.SUIT_HOOD_INFO_TRACK] self.suitPercentage[currHoodInfo[ SuitPlannerBase.SuitPlannerBase.SUIT_HOOD_INFO_ZONE]] = tracks return def load(self): gui = loader.loadModel('phase_4/models/questmap/questmap_gui') icon = gui.find('**/tt_t_gui_qst_arrow') iconNP = aspect2d.attachNewNode('iconNP') icon.reparentTo(iconNP) icon.setR(90) self.marker['geom'] = iconNP self.marker['image'] = iconNP self.marker.setScale(0.05) iconNP.removeNode() self.mapOpenButton = DirectButton( image=(gui.find('**/tt_t_gui_qst_mapClose'), gui.find('**/tt_t_gui_qst_mapClose'), gui.find('**/tt_t_gui_qst_mapTryToOpen')), relief=None, pos=(-0.08, 0, 0.37), parent=base.a2dBottomRight, scale=0.205, command=self.show) self.mapCloseButton = DirectButton( image=(gui.find('**/tt_t_gui_qst_mapOpen'), gui.find('**/tt_t_gui_qst_mapOpen'), gui.find('**/tt_t_gui_qst_mapTryToClose')), relief=None, pos=(-0.08, 0, 0.37), parent=base.a2dBottomRight, scale=0.205, command=self.hide) self.mapOpenButton.hide() self.mapCloseButton.hide() gui.removeNode() icons = loader.loadModel('phase_3/models/gui/cog_icons') cIcon = icons.find('**/CorpIcon') lIcon = icons.find('**/LegalIcon') mIcon = icons.find('**/MoneyIcon') sIcon = icons.find('**/SalesIcon') cogInfoTextColor = (0.2, 0.2, 0.2, 1) textPos = (1.2, -0.2) textScale = 0.8 self.cInfo = DirectLabel(parent=self.cogInfoFrame, text='', text_fg=cogInfoTextColor, text_pos=textPos, text_scale=textScale, geom=cIcon, geom_pos=(-0.2, 0, 0), geom_scale=0.8, relief=None) self.cInfo.setPos(-2.2, 0, 0.5) self.lInfo = DirectLabel(parent=self.cogInfoFrame, text_fg=cogInfoTextColor, text='', text_pos=textPos, text_scale=textScale, geom=lIcon, geom_pos=(-0.2, 0, 0), geom_scale=0.8, relief=None) self.lInfo.setPos(-2.2, 0, -0.5) self.mInfo = DirectLabel(parent=self.cogInfoFrame, text_fg=cogInfoTextColor, text='', text_pos=textPos, text_scale=textScale, geom=mIcon, geom_pos=(-0.2, 0, 0), geom_scale=0.8, relief=None) self.mInfo.setPos(0.8, 0, 0.5) self.sInfo = DirectLabel(parent=self.cogInfoFrame, text_fg=cogInfoTextColor, text='', text_pos=textPos, text_scale=textScale, geom=sIcon, geom_pos=(-0.2, 0, 0), geom_scale=0.8, relief=None) self.sInfo.setPos(0.8, 0, -0.5) icons.removeNode() return def updateCogInfo(self): currPercentage = self.suitPercentage.get(self.zoneId) if currPercentage is None: return self.cInfo['text'] = '%s%%' % currPercentage[0] self.lInfo['text'] = '%s%%' % currPercentage[1] self.mInfo['text'] = '%s%%' % currPercentage[2] self.sInfo['text'] = '%s%%' % currPercentage[3] return def destroy(self): self.ignore('questPageUpdated') self.mapOpenButton.destroy() self.mapCloseButton.destroy() del self.mapOpenButton del self.mapCloseButton DirectFrame.destroy(self) def putBuildingMarker(self, pos, hpr=(0, 0, 0), mapIndex=None): marker = DirectLabel(parent=self.container, text='', text_pos=(-0.05, -0.15), text_fg=(1, 1, 1, 1), relief=None) gui = loader.loadModel( 'phase_4/models/parties/schtickerbookHostingGUI') icon = gui.find('**/startPartyButton_inactive') iconNP = aspect2d.attachNewNode('iconNP') icon.reparentTo(iconNP) icon.setX(-12.0792 / 30.48) icon.setZ(-9.7404 / 30.48) marker['text'] = '%s' % mapIndex marker['text_scale'] = 0.7 marker['image'] = iconNP marker['image_color'] = (1, 0, 0, 1) marker['image_scale'] = 6 marker.setScale(0.05) relX, relY = self.transformAvPos(pos) marker.setPos(relX, 0, relY) self.buildingMarkers.append(marker) iconNP.removeNode() gui.removeNode() return def updateQuestInfo(self): for marker in self.buildingMarkers: marker.destroy() self.buildingMarkers = [] for (i, questDesc) in enumerate(self.av.quests): mapIndex = i + 1 quest = Quests.getQuest(questDesc[0]) toNpcId = questDesc[2] completed = quest.getCompletionStatus(self.av, questDesc) == Quests.COMPLETE if not completed: if quest.getType() == Quests.RecoverItemQuest: if quest.getHolder() == Quests.AnyFish: self.putBuildingMarker(self.fishingSpotInfo, mapIndex=mapIndex) continue elif quest.getType() not in (Quests.DeliverGagQuest, Quests.DeliverItemQuest, Quests.VisitQuest, Quests.TrackChoiceQuest): continue if toNpcId == Quests.ToonHQ: self.putBuildingMarker(self.hqPosInfo, mapIndex=mapIndex) continue npcZoneId = NPCToons.getNPCZone(toNpcId) hoodId = ZoneUtil.getCanonicalHoodId(npcZoneId) branchId = ZoneUtil.getCanonicalBranchZone(npcZoneId) if (self.hoodId != hoodId) or (self.zoneId != branchId): continue for blockIndex in xrange( base.cr.playGame.dnaStore.getNumBlockNumbers()): blockNumber = base.cr.playGame.dnaStore.getBlockNumberAt( blockIndex) zoneId = base.cr.playGame.dnaStore.getZoneFromBlockNumber( blockNumber) interiorZoneId = (zoneId - (zoneId % 100)) + 500 + blockNumber if npcZoneId == interiorZoneId: self.putBuildingMarker( base.cr.playGame.dnaStore.getDoorPosHprFromBlockNumber( blockNumber).getPos(), base.cr.playGame.dnaStore.getDoorPosHprFromBlockNumber( blockNumber).getHpr(), mapIndex=mapIndex) def transformAvPos(self, pos): if self.cornerPosInfo is None: return (0, 0) topRight = self.cornerPosInfo[0] bottomLeft = self.cornerPosInfo[1] relativeX = (pos.getX() - bottomLeft.getX()) / ( topRight.getX() - bottomLeft.getX()) - 0.5 relativeY = (pos.getY() - bottomLeft.getY()) / ( topRight.getY() - bottomLeft.getY()) - 0.5 return (relativeX, relativeY) def update(self, task): if self.av: if self.updateMarker: relX, relY = self.transformAvPos(self.av.getPos()) self.marker.setPos(relX, 0, relY) self.marker.setHpr(0, 0, -180 - self.av.getH()) i = 0 for buildingMarker in self.buildingMarkers: buildingMarker.setScale( (math.sin(task.time * 16.0 + i * math.pi / 3.0) + 1) * 0.005 + 0.04) i = i + 1 return Task.cont def updateMap(self): if self.av: hoodId = ZoneUtil.getCanonicalHoodId(self.av.getLocation()[1]) zoneId = ZoneUtil.getCanonicalBranchZone(self.av.getLocation()[1]) try: mapsGeom = loader.loadModel('phase_4/models/questmap/%s_maps' % ToontownGlobals.dnaMap[hoodId]) except: self.stop() return mapImage = mapsGeom.find('**/%s_%s_english' % (ToontownGlobals.dnaMap[hoodId], zoneId)) if not mapImage.isEmpty(): self.container['image'] = mapImage self.resetFrameSize() self.cornerPosInfo = QuestMapGlobals.CornerPosTable.get( '%s_%s_english' % (ToontownGlobals.dnaMap[hoodId], zoneId)) self.hqPosInfo = QuestMapGlobals.HQPosTable.get( '%s_%s_english' % (ToontownGlobals.dnaMap[hoodId], zoneId)) self.fishingSpotInfo = QuestMapGlobals.FishingSpotPosTable.get( '%s_%s_english' % (ToontownGlobals.dnaMap[hoodId], zoneId)) self.cogInfoPos = QuestMapGlobals.CogInfoPosTable.get( '%s_%s_english' % (ToontownGlobals.dnaMap[hoodId], zoneId)) self.cogInfoFrame.setPos(self.cogInfoPos) self.hide() self.hoodId = hoodId self.zoneId = zoneId self.updateQuestInfo() self.updateCogInfo() taskMgr.add(self.update, 'questMapUpdate') else: self.stop() mapsGeom.removeNode() def start(self): self.container.show() self.accept('questPageUpdated', self.updateMap) self.handleMarker() self.updateMap() def initMarker(self, task): if self.av: if not hasattr(base.cr.playGame.getPlace(), 'isInterior' ) or not base.cr.playGame.getPlace().isInterior: relX, relY = self.transformAvPos(self.av.getPos()) self.marker.setPos(relX, 0, relY) self.marker.setHpr(0, 0, -180 - self.av.getH()) self.marker['geom_scale'] = 1.4 * task.time % 0.5 * 10 + 1 self.marker['geom_color'] = (1, 1, 1, 0.8 - 1.4 * task.time % 0.5 * 2 / 0.8 + 0.2) if task.time < 1: return Task.cont else: self.marker['geom_color'] = (1, 1, 1, 0) return Task.done def show(self): taskMgr.add(self.initMarker, 'questMapInit') DirectFrame.show(self) self.mapOpenButton.hide() if self.container['image']: self.mapCloseButton.show() def hide(self): taskMgr.remove('questMapInit') DirectFrame.hide(self) if self.container['image']: self.mapOpenButton.show() self.mapCloseButton.hide() def toggle(self): if self.isHidden(): self.show() else: self.hide() def obscureButton(self): self.mapOpenButton.hide() self.mapCloseButton.hide() def stop(self): self.container['image'] = None for marker in self.buildingMarkers: marker.destroy() self.buildingMarkers = [] self.container.hide() self.hide() self.obscureButton() self.ignore('questPageUpdated') taskMgr.remove('questMapUpdate') return def handleMarker(self): if hasattr(base.cr.playGame.getPlace(), 'isInterior') and base.cr.playGame.getPlace().isInterior: self.updateMarker = False else: self.updateMarker = True def acceptOnscreenHooks(self): if self.wantToggle: self.accept(ToontownGlobals.MapHotkey, self.toggle) else: self.accept(ToontownGlobals.MapHotkeyOn, self.show) self.accept(ToontownGlobals.MapHotkeyOff, self.hide) self.updateMap() def ignoreOnscreenHooks(self): self.ignore(ToontownGlobals.MapHotkey) self.ignore(ToontownGlobals.MapHotkeyOn) self.ignore(ToontownGlobals.MapHotkeyOff) self.obscureButton()
class CharacterGUI: """Widget with the selected character info.""" def __init__(self): self.char = None # the chosen character self.rest_list_shown = False self._status_lab = None self._rest_buttons = {} self._char_desc_wids = [] self._char_desc_shown = False self._fr = DirectFrame( parent=base.a2dTopLeft, # noqa: F821 frameSize=(-0.31, 0.31, -0.1, 0.115), pos=(0.31, 0, -1.9), frameTexture=GUI_PIC + "metal1.png", state=DGG.NORMAL, ) self._fr.setTransparency(TransparencyAttrib.MAlpha) # a "?" button to open a detailed description of the character self._char_desc_but = DirectButton( parent=self._fr, pos=(0.27, 0, 0.0675), command=self._show_char_desc, clickSound=base.main_menu.click_snd, # noqa: F821 **ABOUT_BUT_PARAMS, ) DirectLabel( # Name: parent=self._fr, text=base.labels.CHARACTERS[0], # noqa: F821 text_font=base.main_font, # noqa: F821 frameSize=(0.1, 0.1, 0.1, 0.1), text_scale=0.03, text_fg=RUST_COL, pos=(-0.22, 0, 0.07), ) self._char_name = DirectLabel( parent=self._fr, text="", frameSize=(0.1, 0.1, 0.1, 0.1), text_scale=0.03, text_fg=SILVER_COL, pos=(-0.09, 0, 0.069), ) self._traits = DirectLabel( parent=self._fr, text="", frameSize=(0.1, 0.1, 0.1, 0.1), text_scale=(0.028, 0.028), text_fg=SILVER_COL, text_font=base.main_font, # noqa: F821 pos=(0, 0, 0.025), ) DirectLabel( # Class: parent=self._fr, text=base.labels.CHARACTERS[1], # noqa: F821 text_font=base.main_font, # noqa: F821 frameSize=(0.1, 0.1, 0.1, 0.1), text_scale=0.03, text_fg=RUST_COL, pos=(0.05, 0, 0.07), ) self._char_class = DirectLabel( parent=self._fr, text="", frameSize=(0.1, 0.1, 0.1, 0.1), text_scale=0.03, text_fg=SILVER_COL, pos=(0.17, 0, 0.068), ) DirectLabel( # Health parent=self._fr, text=base.labels.CHARACTERS[2], # noqa: F821 text_font=base.main_font, # noqa: F821 frameSize=(0.1, 0.1, 0.1, 0.1), text_scale=0.03, text_fg=RUST_COL, pos=(-0.22, 0, -0.015), ) self._char_health = DirectWaitBar( parent=self._fr, frameSize=(-0.17, 0.17, -0.002, 0.002), frameColor=(0.35, 0.35, 0.35, 1), value=0, barColor=(0.85, 0.2, 0.28, 1), pos=(0.07, 0, -0.008), ) DirectLabel( # Energy parent=self._fr, text=base.labels.CHARACTERS[3], # noqa: F821 text_font=base.main_font, # noqa: F821 frameSize=(0.1, 0.1, 0.1, 0.1), text_scale=0.03, text_fg=RUST_COL, pos=(-0.216, 0, -0.06), ) self._char_energy = DirectWaitBar( parent=self._fr, frameSize=(-0.17, 0.17, -0.002, 0.002), frameColor=(0.35, 0.35, 0.35, 1), value=0, barColor=(0.46, 0.61, 0.53, 1), pos=(0.07, 0, -0.053), ) self._tip = OnscreenText( parent=base.render2d, # noqa: F821 text="", font=base.main_font, # noqa: F821 scale=(0.021, 0.027), fg=SILVER_COL, bg=(0, 0, 0, 0.4), ) self._tip.hide() self._disease = DirectFrame( parent=self._fr, frameSize=(-0.02, 0.02, -0.02, 0.02), pos=(0.27, 0, -0.008), frameTexture=GUI_PIC + "disease.png", ) self._disease.setTransparency(TransparencyAttrib.MAlpha) self.clear_char_info() def _update_char_info(self, task): """Track the chosen character parameters in the GUI.""" if self.char.is_dead: self.clear_char_info() return task.done self._char_health["value"] = self.char.health self._char_energy["value"] = self.char.energy self._traits["text"] = ", ".join(self.char.traits) if self.char.is_diseased: self._disease.show() else: self._disease.hide() if self._char_desc_shown: self._update_desc() return task.again def _update_desc(self): """Update the chosen character description.""" to_del = [] for wid in self._char_desc_wids: if wid["text"] not in ( # Traits base.labels.CHARACTERS[5], # noqa: F821 # Status base.labels.CHARACTERS[4], # noqa: F821 "", ): wid.destroy() to_del.append(wid) for del_wid in to_del: self._char_desc_wids.remove(del_wid) self._fill_status(self._fill_traits(0.64)) def _fill_traits(self, shift): """Fill the chosen character traits. Args: shift (float): Z-coor for the new widgets. Returns: float: Z-coor including the new widgets shift. """ shift -= 0.03 for trait in self.char.traits + self.char.disabled_traits: self._char_desc_wids.append( DirectLabel( parent=self._fr, text=trait, frameSize=(0.1, 0.1, 0.1, 0.1), text_scale=0.03, text_font=base.main_font, # noqa: F821 text_fg=SILVER_COL if trait in self.char.traits else (0.3, 0.3, 0.3, 1), pos=(0, 0, shift), ) ) self._char_desc_wids.append( DirectLabel( parent=self._fr, text=base.labels.TRAIT_DESC[trait], # noqa: F821 text_font=base.main_font, # noqa: F821 frameSize=(0.1, 0.1, 0.1, 0.1), text_scale=0.029, text_fg=SILVER_COL if trait in self.char.traits else (0.3, 0.3, 0.3, 1), pos=(0, 0, shift - 0.045), ) ) shift -= 0.1 return shift def _fill_status(self, shift): """Fill the chosen character status. Args: shift (float): Z-coor for the new widgets. """ shift -= 0.04 for status in self.char.statuses: self._char_desc_wids.append( DirectLabel( parent=self._fr, text=status, text_font=base.main_font, # noqa: F821 frameSize=(0.1, 0.1, 0.1, 0.1), text_scale=0.029, text_fg=SILVER_COL, pos=(0, 0, shift), ) ) shift -= 0.045 def _show_char_desc(self): """Show detailed character description. Includes description of every character's trait and their current status. """ if self._char_desc_shown: self._fr["frameSize"] = (-0.31, 0.31, -0.1, 0.115) clear_wids(self._char_desc_wids) self._status_lab = None else: shift = 0.7 self._fr["frameSize"] = (-0.31, 0.31, -0.1, shift) shift -= 0.06 self._char_desc_wids.append( DirectLabel( parent=self._fr, # Traits text=base.labels.CHARACTERS[5], # noqa: F821, text_font=base.main_font, # noqa: F821, frameSize=(0.1, 0.1, 0.1, 0.1), text_scale=0.03, text_fg=RUST_COL, pos=(-0.225, 0, shift), ) ) if self.char.id in base.team.chars.keys(): # noqa: F821 traits_but = DirectButton( parent=self._fr, text="", frameSize=(-0.025, 0.025, -0.025, 0.025), frameTexture=GUI_PIC + "like.png", relief="flat", pos=(0.265, 0, shift + 0.013), command=base.traits_gui.show, # noqa: F821 ) traits_but.bind( DGG.ENTER, self._highlight_traits_but, extraArgs=[traits_but] ) traits_but.bind( DGG.EXIT, self._dehighlight_traits_but, extraArgs=[traits_but] ) self._char_desc_wids.append(traits_but) shift = self._fill_traits(shift) self._status_lab = DirectLabel( # Status parent=self._fr, # Status text=base.labels.CHARACTERS[4], # noqa: F821 text_font=base.main_font, # noqa: F821 frameSize=(0.1, 0.1, 0.1, 0.1), text_scale=0.03, text_fg=RUST_COL, pos=(-0.221, 0, shift), ) self._char_desc_wids.append(self._status_lab) self._fill_status(shift) self._char_desc_shown = not self._char_desc_shown def _dehighlight_traits_but(self, button, _): """Dehighlight traits tweaking button. Args: button (panda3d.gui.DirectGui.DirectButton): Button to dehighlight. """ button["frameTexture"] = GUI_PIC + "like.png" def _highlight_traits_but(self, button, _): """Hightlight traits tweaking button. Args: button (panda3d.gui.DirectGui.DirectButton): Button to highlight. """ button["frameTexture"] = GUI_PIC + "hover_like.png" def clear_char_info(self, clear_resting=True): """Clear the character GUI. Args: clear_resting (bool): Optional. A flag indicating if the list of the resting characters should also be closed. """ for wid in ( self._char_name, self._char_class, self._char_health, self._char_energy, self._traits, self._char_desc_but, self._disease, ): wid.hide() if self._char_desc_shown: self._show_char_desc() taskMgr.remove("track_char_info") # noqa: F821 self.char = None if clear_resting: for but in self._rest_buttons.values(): but.destroy() self.rest_list_shown = False def destroy_char_button(self, char_id): """Hide the given character button from the resting characters list. Args: char_id (str): Character id. """ if char_id in self._rest_buttons.keys(): self._rest_buttons[char_id].destroy() self._rest_buttons.pop(char_id) def hide_tip(self): """Hide the tooltip.""" self._tip.hide() def show_char_info(self, char): """Show the given character status. Args: char (units.crew.character.Character): The chosen character object. """ self._char_name["text"] = char.name self._char_class["text"] = char.class_.capitalize() self._traits["text"] = ", ".join(char.traits) self._char_health["range"] = char.class_data["health"] self._char_health["value"] = char.health self._char_energy["value"] = char.energy if char.is_diseased: self._disease.show() else: self._disease.hide() self.char = char self._char_name.show() self._char_class.show() self._char_health.show() self._char_energy.show() self._traits.show() self._char_desc_but.show() if self._char_desc_shown: self._show_char_desc() self._show_char_desc() taskMgr.doMethodLater( # noqa: F821 0.5, self._update_char_info, "track_char_info" ) def show_tooltip(self, text): """Show tooltip with the given text. Args: text (str): Text to show in the tooltip. """ if not base.mouseWatcherNode.hasMouse(): # noqa: F821 return if self.rest_list_shown and text == "Rest zone": return self._tip.setText(text) self._tip.setX(base.mouseWatcherNode.getMouseX()) # noqa: F821 self._tip.setY(base.mouseWatcherNode.getMouseY()) # noqa: F821 self._tip.show() def show_resting_chars(self, part): """Show a list of the characters resting in this part. Args: part (Train.RestPart): Rest part of the Train. """ if self.rest_list_shown: return self._tip.hide() self.rest_list_shown = True x = base.mouseWatcherNode.getMouseX() # noqa: F821 z = base.mouseWatcherNode.getMouseY() # noqa: F821 self._rest_buttons["title"] = DirectButton( pos=(x, 0, z), text=base.labels.TIPS[0], # noqa: F821 text_fg=RUST_COL, text_font=base.main_font, # noqa: F821 frameColor=(0, 0, 0, 0.6), scale=(0.04, 0, 0.03), ) shift = -0.039 for char in part.chars: if char.is_dead: continue self._rest_buttons[char.id] = DirectButton( pos=(x, 0, z + shift), text=char.name, text_fg=SILVER_COL, frameColor=(0, 0, 0, 0.6), command=base.common_ctrl.choose_char, # noqa: F821 extraArgs=[char.id], scale=(0.04, 0, 0.03), ) shift -= 0.033 def move_status_label(self, place): """Move the status label widget. Args: place (int): Place to shift the widget. """ if self._status_lab is not None: self._status_lab.setZ(self._status_lab.getZ() + place / 10) def update_resting_chars(self, part): """Update the list of the resting characters. Args: part (train.part.TrainPart): Rest train part. """ for key, but in self._rest_buttons.items(): if key != "title": but.destroy() self._rest_buttons[key] = None x, _, z = self._rest_buttons["title"].getPos() shift = -0.039 for char in part.chars: self._rest_buttons[char.id] = DirectButton( pos=(x, 0, z + shift), text=char.name, text_fg=SILVER_COL, frameColor=(0, 0, 0, 0.6), command=base.common_ctrl.choose_char, # noqa: F821 extraArgs=[char.id], scale=(0.04, 0, 0.03), ) shift -= 0.033
def load(self): gui = loader.loadModel('phase_4/models/questmap/questmap_gui') icon = gui.find('**/tt_t_gui_qst_arrow') iconNP = aspect2d.attachNewNode('iconNP') icon.reparentTo(iconNP) icon.setR(90) self.marker['geom'] = iconNP self.marker['image'] = iconNP self.marker.setScale(0.05) iconNP.removeNode() self.mapOpenButton = DirectButton( image=(gui.find('**/tt_t_gui_qst_mapClose'), gui.find('**/tt_t_gui_qst_mapClose'), gui.find('**/tt_t_gui_qst_mapTryToOpen')), relief=None, pos=(-0.08, 0, 0.37), parent=base.a2dBottomRight, scale=0.205, command=self.show) self.mapCloseButton = DirectButton( image=(gui.find('**/tt_t_gui_qst_mapOpen'), gui.find('**/tt_t_gui_qst_mapOpen'), gui.find('**/tt_t_gui_qst_mapTryToClose')), relief=None, pos=(-0.08, 0, 0.37), parent=base.a2dBottomRight, scale=0.205, command=self.hide) self.mapOpenButton.hide() self.mapCloseButton.hide() gui.removeNode() icons = loader.loadModel('phase_3/models/gui/cog_icons') cIcon = icons.find('**/CorpIcon') lIcon = icons.find('**/LegalIcon') mIcon = icons.find('**/MoneyIcon') sIcon = icons.find('**/SalesIcon') cogInfoTextColor = (0.2, 0.2, 0.2, 1) textPos = (1.2, -0.2) textScale = 0.8 self.cInfo = DirectLabel(parent=self.cogInfoFrame, text='', text_fg=cogInfoTextColor, text_pos=textPos, text_scale=textScale, geom=cIcon, geom_pos=(-0.2, 0, 0), geom_scale=0.8, relief=None) self.cInfo.setPos(-2.2, 0, 0.5) self.lInfo = DirectLabel(parent=self.cogInfoFrame, text_fg=cogInfoTextColor, text='', text_pos=textPos, text_scale=textScale, geom=lIcon, geom_pos=(-0.2, 0, 0), geom_scale=0.8, relief=None) self.lInfo.setPos(-2.2, 0, -0.5) self.mInfo = DirectLabel(parent=self.cogInfoFrame, text_fg=cogInfoTextColor, text='', text_pos=textPos, text_scale=textScale, geom=mIcon, geom_pos=(-0.2, 0, 0), geom_scale=0.8, relief=None) self.mInfo.setPos(0.8, 0, 0.5) self.sInfo = DirectLabel(parent=self.cogInfoFrame, text_fg=cogInfoTextColor, text='', text_pos=textPos, text_scale=textScale, geom=sIcon, geom_pos=(-0.2, 0, 0), geom_scale=0.8, relief=None) self.sInfo.setPos(0.8, 0, -0.5) icons.removeNode() return
class DistributedBanquetTable(DistributedObject.DistributedObject, FSM.FSM, BanquetTableBase.BanquetTableBase): notify = DirectNotifyGlobal.directNotify.newCategory('DistributedBanquetTable') rotationsPerSeatIndex = [90, 90, 0, 0, -90, -90, 180, 180] pitcherMinH = -360 pitcherMaxH = 360 rotateSpeed = 30 waterPowerSpeed = config.GetDouble('water-power-speed', 15) waterPowerExponent = config.GetDouble('water-power-exponent', 0.75) useNewAnimations = True TugOfWarControls = False OnlyUpArrow = True if OnlyUpArrow: BASELINE_KEY_RATE = 3 else: BASELINE_KEY_RATE = 6 UPDATE_KEY_PRESS_RATE_TASK = 'BanquetTableUpdateKeyPressRateTask' YELLOW_POWER_THRESHOLD = 0.75 RED_POWER_THRESHOLD = 0.97 def __init__(self, cr): DistributedObject.DistributedObject.__init__(self, cr) FSM.FSM.__init__(self, 'DistributedBanquetTable') self.boss = None self.index = -1 self.diners = {} self.dinerStatus = {} self.serviceLocs = {} self.chairLocators = {} self.sitLocators = {} self.activeIntervals = {} self.dinerStatusIndicators = {} self.preparedForPhaseFour = False self.avId = 0 self.toon = None self.pitcherSmoother = SmoothMover() self.pitcherSmoother.setSmoothMode(SmoothMover.SMOn) self.smoothStarted = 0 self.__broadcastPeriod = 0.2 self.changeSeq = 0 self.lastChangeSeq = 0 self.pitcherAdviceLabel = None self.fireLength = 250 self.fireTrack = None self.hitObject = None self.setupPowerBar() self.aimStart = None self.toonPitcherPosition = Point3(0, -2, 0) self.allowLocalRequestControl = True self.fadeTrack = None self.grabTrack = None self.gotHitByBoss = False self.keyTTL = [] self.keyRate = 0 self.buttons = [0, 1] self.lastPowerFired = 0 self.moveSound = None self.releaseTrack = None return def disable(self): DistributedObject.DistributedObject.disable(self) taskMgr.remove(self.triggerName) taskMgr.remove(self.smoothName) taskMgr.remove(self.watchControlsName) taskMgr.remove(self.pitcherAdviceName) taskMgr.remove(self.posHprBroadcastName) taskMgr.remove(self.waterPowerTaskName) if self.releaseTrack: self.releaseTrack.finish() self.releaseTrack = None if self.fireTrack: self.fireTrack.finish() self.fireTrack = None self.cleanupIntervals() return def delete(self): DistributedObject.DistributedObject.delete(self) self.boss = None self.ignoreAll() for indicator in self.dinerStatusIndicators.values(): indicator.delete() self.dinerStatusIndicators = {} for diner in self.diners.values(): diner.delete() self.diners = {} self.powerBar.destroy() self.powerBar = None self.pitcherMoveSfx.stop() return def announceGenerate(self): DistributedObject.DistributedObject.announceGenerate(self) self.loadAssets() self.smoothName = self.uniqueName('pitcherSmooth') self.pitcherAdviceName = self.uniqueName('pitcherAdvice') self.posHprBroadcastName = self.uniqueName('pitcherBroadcast') self.waterPowerTaskName = self.uniqueName('updateWaterPower') self.triggerName = self.uniqueName('trigger') self.watchControlsName = self.uniqueName('watchControls') def setBossCogId(self, bossCogId): self.bossCogId = bossCogId self.boss = base.cr.doId2do[bossCogId] self.boss.setTable(self, self.index) def setIndex(self, index): self.index = index def setState(self, state, avId, extraInfo): self.gotHitByBoss = extraInfo if state == 'F': self.demand('Off') elif state == 'N': self.demand('On') elif state == 'I': self.demand('Inactive') elif state == 'R': self.demand('Free') elif state == 'C': self.demand('Controlled', avId) elif state == 'L': self.demand('Flat', avId) else: self.notify.error('Invalid state from AI: %s' % state) def setNumDiners(self, numDiners): self.numDiners = numDiners def setDinerInfo(self, hungryDurations, eatingDurations, dinerLevels): self.dinerInfo = {} for i in xrange(len(hungryDurations)): hungryDur = hungryDurations[i] eatingDur = eatingDurations[i] dinerLevel = dinerLevels[i] self.dinerInfo[i] = (hungryDur, eatingDur, dinerLevel) def loadAssets(self): self.tableGroup = loader.loadModel('phase_12/models/bossbotHQ/BanquetTableChairs') tableLocator = self.boss.geom.find('**/TableLocator_%d' % (self.index + 1)) if tableLocator.isEmpty(): self.tableGroup.reparentTo(render) self.tableGroup.setPos(0, 75, 0) else: self.tableGroup.reparentTo(tableLocator) self.tableGeom = self.tableGroup.find('**/Geometry') self.setupDiners() self.setupChairCols() self.squirtSfx = loader.loadSfx('phase_4/audio/sfx/AA_squirt_seltzer_miss.ogg') self.hitBossSfx = loader.loadSfx('phase_5/audio/sfx/SA_watercooler_spray_only.ogg') self.hitBossSoundInterval = SoundInterval(self.hitBossSfx, node=self.boss, volume=1.0) self.serveFoodSfx = loader.loadSfx('phase_4/audio/sfx/MG_sfx_travel_game_bell_for_trolley.ogg') self.pitcherMoveSfx = base.loadSfx('phase_4/audio/sfx/MG_cannon_adjust.ogg') def setupDiners(self): for i in xrange(self.numDiners): newDiner = self.createDiner(i) self.diners[i] = newDiner self.dinerStatus[i] = self.HUNGRY def createDiner(self, i): diner = Suit.Suit() diner.dna = SuitDNA.SuitDNA() level = self.dinerInfo[i][2] level -= 4 diner.dna.newSuitRandom(level=level, dept='c') diner.setDNA(diner.dna) if self.useNewAnimations: diner.loop('sit', fromFrame=i) else: diner.pose('landing', 0) locator = self.tableGroup.find('**/chair_%d' % (i + 1)) locatorScale = locator.getNetTransform().getScale()[0] correctHeadingNp = locator.attachNewNode('correctHeading') self.chairLocators[i] = correctHeadingNp heading = self.rotationsPerSeatIndex[i] correctHeadingNp.setH(heading) sitLocator = correctHeadingNp.attachNewNode('sitLocator') base.sitLocator = sitLocator pos = correctHeadingNp.getPos(render) if SuitDNA.getSuitBodyType(diner.dna.name) == 'c': sitLocator.setPos(0.5, 3.65, -3.75) else: sitLocator.setZ(-2.4) sitLocator.setY(2.5) sitLocator.setX(0.5) self.sitLocators[i] = sitLocator diner.setScale(1.0 / locatorScale) diner.reparentTo(sitLocator) newLoc = NodePath('serviceLoc-%d-%d' % (self.index, i)) newLoc.reparentTo(correctHeadingNp) newLoc.setPos(0, 3.0, 1) self.serviceLocs[i] = newLoc base.serviceLoc = newLoc head = diner.find('**/joint_head') newIndicator = DinerStatusIndicator.DinerStatusIndicator(parent=head, pos=Point3(0, 0, 3.5), scale=5.0) newIndicator.wrtReparentTo(diner) self.dinerStatusIndicators[i] = newIndicator diner.nametag3d.stash() diner.nametag.destroy() return diner def setupChairCols(self): for i in xrange(self.numDiners): chairCol = self.tableGroup.find('**/collision_chair_%d' % (i + 1)) colName = 'ChairCol-%d-%d' % (self.index, i) chairCol.setTag('chairIndex', str(i)) chairCol.setName(colName) chairCol.setCollideMask(ToontownGlobals.WallBitmask) self.accept('enter' + colName, self.touchedChair) def touchedChair(self, colEntry): chairIndex = int(colEntry.getIntoNodePath().getTag('chairIndex')) if chairIndex in self.dinerStatus: status = self.dinerStatus[chairIndex] if status in (self.HUNGRY, self.ANGRY): self.boss.localToonTouchedChair(self.index, chairIndex) def serveFood(self, food, chairIndex): self.removeFoodModel(chairIndex) serviceLoc = self.serviceLocs.get(chairIndex) if not food or food.isEmpty(): foodModel = loader.loadModel('phase_12/models/bossbotHQ/canoffood') foodModel.setScale(ToontownGlobals.BossbotFoodModelScale) foodModel.reparentTo(serviceLoc) else: food.wrtReparentTo(serviceLoc) tray = food.find('**/tray') if not tray.isEmpty(): tray.hide() ivalDuration = 1.5 foodMoveIval = Parallel(SoundInterval(self.serveFoodSfx, node=food), ProjectileInterval(food, duration=ivalDuration, startPos=food.getPos(serviceLoc), endPos=serviceLoc.getPos(serviceLoc)), LerpHprInterval(food, ivalDuration, Point3(0, -360, 0))) intervalName = 'serveFood-%d-%d' % (self.index, chairIndex) foodMoveIval.start() self.activeIntervals[intervalName] = foodMoveIval def setDinerStatus(self, chairIndex, status): if chairIndex in self.dinerStatus: oldStatus = self.dinerStatus[chairIndex] self.dinerStatus[chairIndex] = status if oldStatus != status: if status == self.EATING: self.changeDinerToEating(chairIndex) elif status == self.HUNGRY: self.changeDinerToHungry(chairIndex) elif status == self.ANGRY: self.changeDinerToAngry(chairIndex) elif status == self.DEAD: self.changeDinerToDead(chairIndex) elif status == self.HIDDEN: self.changeDinerToHidden(chairIndex) def removeFoodModel(self, chairIndex): serviceLoc = self.serviceLocs.get(chairIndex) if serviceLoc: for i in xrange(serviceLoc.getNumChildren()): serviceLoc.getChild(0).removeNode() def changeDinerToEating(self, chairIndex): indicator = self.dinerStatusIndicators.get(chairIndex) eatingDuration = self.dinerInfo[chairIndex][1] if indicator: indicator.request('Eating', eatingDuration) diner = self.diners[chairIndex] intervalName = 'eating-%d-%d' % (self.index, chairIndex) eatInTime = 32.0 / 24.0 eatOutTime = 21.0 / 24.0 eatLoopTime = 19 / 24.0 rightHand = diner.getRightHand() waitTime = 5 loopDuration = eatingDuration - eatInTime - eatOutTime - waitTime serviceLoc = self.serviceLocs[chairIndex] def foodAttach(self = self, diner = diner): if not self.serviceLocs[chairIndex].getNumChildren(): return foodModel = self.serviceLocs[chairIndex].getChild(0) (foodModel.reparentTo(diner.getRightHand()),) (foodModel.setHpr(Point3(0, -94, 0)),) (foodModel.setPos(Point3(-0.15, -0.7, -0.4)),) scaleAdj = 1 if SuitDNA.getSuitBodyType(diner.dna.name) == 'c': scaleAdj = 0.6 (foodModel.setPos(Point3(0.1, -0.25, -0.31)),) else: scaleAdj = 0.8 (foodModel.setPos(Point3(-0.25, -0.85, -0.34)),) oldScale = foodModel.getScale() newScale = oldScale * scaleAdj foodModel.setScale(newScale) def foodDetach(self = self, diner = diner): if diner.getRightHand().getNumChildren() < 1: return foodModel = diner.getRightHand().getChild(0) (foodModel.reparentTo(serviceLoc),) (foodModel.setPosHpr(0, 0, 0, 0, 0, 0),) scaleAdj = 1 if SuitDNA.getSuitBodyType(diner.dna.name) == 'c': scaleAdj = 0.6 else: scakeAdj = 0.8 oldScale = foodModel.getScale() newScale = oldScale / scaleAdj foodModel.setScale(newScale) eatIval = Sequence(ActorInterval(diner, 'sit', duration=waitTime), ActorInterval(diner, 'sit-eat-in', startFrame=0, endFrame=6), Func(foodAttach), ActorInterval(diner, 'sit-eat-in', startFrame=6, endFrame=32), ActorInterval(diner, 'sit-eat-loop', duration=loopDuration, loop=1), ActorInterval(diner, 'sit-eat-out', startFrame=0, endFrame=12), Func(foodDetach), ActorInterval(diner, 'sit-eat-out', startFrame=12, endFrame=21)) eatIval.start() self.activeIntervals[intervalName] = eatIval def changeDinerToHungry(self, chairIndex): intervalName = 'eating-%d-%d' % (self.index, chairIndex) if intervalName in self.activeIntervals: self.activeIntervals[intervalName].finish() self.removeFoodModel(chairIndex) indicator = self.dinerStatusIndicators.get(chairIndex) if indicator: indicator.request('Hungry', self.dinerInfo[chairIndex][0]) diner = self.diners[chairIndex] if random.choice([0, 1]): diner.loop('sit-hungry-left') else: diner.loop('sit-hungry-right') def changeDinerToAngry(self, chairIndex): self.removeFoodModel(chairIndex) indicator = self.dinerStatusIndicators.get(chairIndex) if indicator: indicator.request('Angry') diner = self.diners[chairIndex] diner.loop('sit-angry') def changeDinerToDead(self, chairIndex): def removeDeathSuit(suit, deathSuit): if not deathSuit.isEmpty(): deathSuit.detachNode() suit.cleanupLoseActor() self.removeFoodModel(chairIndex) indicator = self.dinerStatusIndicators.get(chairIndex) if indicator: indicator.request('Dead') diner = self.diners[chairIndex] deathSuit = diner locator = self.tableGroup.find('**/chair_%d' % (chairIndex + 1)) deathSuit = diner.getLoseActor() ival = Sequence(Func(self.notify.debug, 'before actorinterval sit-lose'), ActorInterval(diner, 'sit-lose'), Func(self.notify.debug, 'before deathSuit.setHpr'), Func(deathSuit.setHpr, diner.getHpr()), Func(self.notify.debug, 'before diner.hide'), Func(diner.hide), Func(self.notify.debug, 'before deathSuit.reparentTo'), Func(deathSuit.reparentTo, self.chairLocators[chairIndex]), Func(self.notify.debug, 'befor ActorInterval lose'), ActorInterval(deathSuit, 'lose', duration=MovieUtil.SUIT_LOSE_DURATION), Func(self.notify.debug, 'before remove deathsuit'), Func(removeDeathSuit, diner, deathSuit, name='remove-death-suit-%d-%d' % (chairIndex, self.index)), Func(self.notify.debug, 'diner.stash'), Func(diner.stash)) spinningSound = base.loadSfx('phase_3.5/audio/sfx/Cog_Death.ogg') deathSound = base.loadSfx('phase_3.5/audio/sfx/ENC_cogfall_apart.ogg') deathSoundTrack = Sequence(Wait(0.8), SoundInterval(spinningSound, duration=1.2, startTime=1.5, volume=0.2, node=deathSuit), SoundInterval(spinningSound, duration=3.0, startTime=0.6, volume=0.8, node=deathSuit), SoundInterval(deathSound, volume=0.32, node=deathSuit)) intervalName = 'dinerDie-%d-%d' % (self.index, chairIndex) deathIval = Parallel(ival, deathSoundTrack) deathIval.start() self.activeIntervals[intervalName] = deathIval def changeDinerToHidden(self, chairIndex): self.removeFoodModel(chairIndex) indicator = self.dinerStatusIndicators.get(chairIndex) if indicator: indicator.request('Inactive') diner = self.diners[chairIndex] diner.hide() def setAllDinersToSitNeutral(self): startFrame = 0 for diner in self.diners.values(): if not diner.isHidden(): diner.loop('sit', fromFrame=startFrame) startFrame += 1 def cleanupIntervals(self): for interval in self.activeIntervals.values(): interval.finish() self.activeIntervals = {} def clearInterval(self, name, finish = 1): if self.activeIntervals.has_key(name): ival = self.activeIntervals[name] if finish: ival.finish() else: ival.pause() if self.activeIntervals.has_key(name): del self.activeIntervals[name] else: self.notify.debug('interval: %s already cleared' % name) def finishInterval(self, name): if self.activeIntervals.has_key(name): interval = self.activeIntervals[name] interval.finish() def getNotDeadInfo(self): notDeadList = [] for i in xrange(self.numDiners): if self.dinerStatus[i] != self.DEAD: notDeadList.append((self.index, i, 12)) return notDeadList def enterOn(self): pass def exitOn(self): pass def enterInactive(self): for chairIndex in xrange(self.numDiners): indicator = self.dinerStatusIndicators.get(chairIndex) if indicator: indicator.request('Inactive') self.removeFoodModel(chairIndex) def exitInactive(self): pass def enterFree(self): self.resetPowerBar() if self.fadeTrack: self.fadeTrack.finish() self.fadeTrack = None self.prepareForPhaseFour() if self.avId == localAvatar.doId: self.tableGroup.setAlphaScale(0.3) self.tableGroup.setTransparency(1) taskMgr.doMethodLater(5, self.__allowDetect, self.triggerName) self.fadeTrack = Sequence(Func(self.tableGroup.setTransparency, 1), self.tableGroup.colorScaleInterval(0.2, VBase4(1, 1, 1, 0.3))) self.fadeTrack.start() self.allowLocalRequestControl = False else: self.allowLocalRequestControl = True self.avId = 0 return def exitFree(self): pass def touchedTable(self, colEntry): tableIndex = int(colEntry.getIntoNodePath().getTag('tableIndex')) if self.state == 'Free' and self.avId == 0 and self.allowLocalRequestControl: self.d_requestControl() def prepareForPhaseFour(self): if not self.preparedForPhaseFour: for i in xrange(8): chair = self.tableGroup.find('**/chair_%d' % (i + 1)) if not chair.isEmpty(): chair.hide() colChairs = self.tableGroup.findAllMatches('**/ChairCol*') for i in xrange(colChairs.getNumPaths()): col = colChairs.getPath(i) col.stash() colChairs = self.tableGroup.findAllMatches('**/collision_chair*') for i in xrange(colChairs.getNumPaths()): col = colChairs.getPath(i) col.stash() tableCol = self.tableGroup.find('**/collision_table') colName = 'TableCol-%d' % self.index tableCol.setTag('tableIndex', str(self.index)) tableCol.setName(colName) tableCol.setCollideMask(ToontownGlobals.WallBitmask | ToontownGlobals.BanquetTableBitmask) self.accept('enter' + colName, self.touchedTable) self.preparedForPhaseFour = True self.waterPitcherModel = loader.loadModel('phase_12/models/bossbotHQ/tt_m_ara_bhq_seltzerBottle') lampNode = self.tableGroup.find('**/lamp_med_5') pos = lampNode.getPos(self.tableGroup) lampNode.hide() bottleLocator = self.tableGroup.find('**/bottle_locator') pos = bottleLocator.getPos(self.tableGroup) self.waterPitcherNode = self.tableGroup.attachNewNode('pitcherNode') self.waterPitcherNode.setPos(pos) self.waterPitcherModel.reparentTo(self.waterPitcherNode) self.waterPitcherModel.ls() self.nozzle = self.waterPitcherModel.find('**/nozzle_tip') self.handLocator = self.waterPitcherModel.find('**/hand_locator') self.handPos = self.handLocator.getPos() def d_requestControl(self): self.sendUpdate('requestControl') def d_requestFree(self, gotHitByBoss): self.sendUpdate('requestFree', [gotHitByBoss]) def enterControlled(self, avId): self.prepareForPhaseFour() self.avId = avId toon = base.cr.doId2do.get(avId) if not toon: return self.toon = toon self.grabTrack = self.makeToonGrabInterval(toon) self.notify.debug('grabTrack=%s' % self.grabTrack) self.pitcherCamPos = Point3(0, -50, 40) self.pitcherCamHpr = Point3(0, -21, 0) if avId == localAvatar.doId: self.boss.toMovieMode() self.__enableControlInterface() self.startPosHprBroadcast() self.grabTrack = Sequence(self.grabTrack, Func(camera.wrtReparentTo, localAvatar), LerpPosHprInterval(camera, 1, self.pitcherCamPos, self.pitcherCamHpr), Func(self.boss.toCraneMode)) if self.TugOfWarControls: self.__spawnUpdateKeyPressRateTask() self.accept('exitCrane', self.gotBossZapped) else: self.startSmooth() toon.stopSmooth() self.grabTrack.start() def exitControlled(self): self.ignore('exitCrane') if self.grabTrack: self.grabTrack.finish() self.grabTrack = None nextState = self.getCurrentOrNextState() self.notify.debug('nextState=%s' % nextState) if nextState == 'Flat': place = base.cr.playGame.getPlace() self.notify.debug('%s' % place.fsm) if self.avId == localAvatar.doId: self.__disableControlInterface() else: if self.toon and not self.toon.isDisabled(): self.toon.loop('neutral') self.toon.startSmooth() self.releaseTrack = self.makeToonReleaseInterval(self.toon) self.stopPosHprBroadcast() self.stopSmooth() if self.avId == localAvatar.doId: localAvatar.wrtReparentTo(render) self.__disableControlInterface() camera.reparentTo(base.localAvatar) camera.setPos(base.localAvatar.cameraPositions[0][0]) camera.setHpr(0, 0, 0) self.goToFinalBattle() self.safeBossToFinalBattleMode() else: toon = base.cr.doId2do.get(self.avId) if toon: toon.wrtReparentTo(render) self.releaseTrack.start() return def safeBossToFinalBattleMode(self): if self.boss: self.boss.toFinalBattleMode() def goToFinalBattle(self): if self.cr: place = self.cr.playGame.getPlace() if place and hasattr(place, 'fsm'): if place.fsm.getCurrentState().getName() == 'crane': place.setState('finalBattle') def makeToonGrabInterval(self, toon): toon.pose('leverNeutral', 0) toon.update() rightHandPos = toon.rightHand.getPos(toon) self.toonPitcherPosition = Point3(self.handPos[0] - rightHandPos[0], self.handPos[1] - rightHandPos[1], 0) destZScale = rightHandPos[2] / self.handPos[2] grabIval = Sequence(Func(toon.wrtReparentTo, self.waterPitcherNode), Func(toon.loop, 'neutral'), Parallel(ActorInterval(toon, 'jump'), Sequence(Wait(0.43), Parallel(ProjectileInterval(toon, duration=0.9, startPos=toon.getPos(self.waterPitcherNode), endPos=self.toonPitcherPosition), LerpHprInterval(toon, 0.9, Point3(0, 0, 0)), LerpScaleInterval(self.waterPitcherModel, 0.9, Point3(1, 1, destZScale))))), Func(toon.setPos, self.toonPitcherPosition), Func(toon.loop, 'leverNeutral')) return grabIval def makeToonReleaseInterval(self, toon): temp1 = self.waterPitcherNode.attachNewNode('temp1') temp1.setPos(self.toonPitcherPosition) temp2 = self.waterPitcherNode.attachNewNode('temp2') temp2.setPos(0, -10, -self.waterPitcherNode.getZ()) startPos = temp1.getPos(render) endPos = temp2.getPos(render) temp1.removeNode() temp2.removeNode() def getSlideToPos(toon = toon): return render.getRelativePoint(toon, Point3(0, -10, 0)) if self.gotHitByBoss: self.notify.debug('creating zap interval instead') grabIval = Sequence(Func(toon.loop, 'neutral'), Func(toon.wrtReparentTo, render), Parallel(ActorInterval(toon, 'slip-backward'), toon.posInterval(0.5, getSlideToPos, fluid=1))) else: grabIval = Sequence(Func(toon.loop, 'neutral'), Func(toon.wrtReparentTo, render), Parallel(ActorInterval(toon, 'jump'), Sequence(Wait(0.43), ProjectileInterval(toon, duration=0.9, startPos=startPos, endPos=endPos)))) return grabIval def b_clearSmoothing(self): self.d_clearSmoothing() self.clearSmoothing() def d_clearSmoothing(self): self.sendUpdate('clearSmoothing', [0]) def clearSmoothing(self, bogus = None): self.pitcherSmoother.clearPositions(1) def doSmoothTask(self, task): self.pitcherSmoother.computeAndApplySmoothHpr(self.waterPitcherNode) return Task.cont def startSmooth(self): if not self.smoothStarted: taskName = self.smoothName taskMgr.remove(taskName) self.reloadPosition() taskMgr.add(self.doSmoothTask, taskName) self.smoothStarted = 1 def stopSmooth(self): if self.smoothStarted: taskName = self.smoothName taskMgr.remove(taskName) self.forceToTruePosition() self.smoothStarted = 0 def __enableControlInterface(self): gui = loader.loadModel('phase_3.5/models/gui/avatar_panel_gui') self.closeButton = DirectButton(image=(gui.find('**/CloseBtn_UP'), gui.find('**/CloseBtn_DN'), gui.find('**/CloseBtn_Rllvr'), gui.find('**/CloseBtn_UP')), relief=None, scale=2, text=TTLocalizer.BossbotPitcherLeave, text_scale=0.04, text_pos=(0, -0.07), text_fg=VBase4(1, 1, 1, 1), pos=(1.05, 0, -0.82), command=self.__exitPitcher) self.accept('escape', self.__exitPitcher) self.accept('control', self.__controlPressed) self.accept('control-up', self.__controlReleased) self.accept('InputState-forward', self.__upArrow) self.accept('InputState-reverse', self.__downArrow) self.accept('InputState-turnLeft', self.__leftArrow) self.accept('InputState-turnRight', self.__rightArrow) self.accept('arrow_up', self.__upArrowKeyPressed) self.accept('arrow_down', self.__downArrowKeyPressed) taskMgr.add(self.__watchControls, self.watchControlsName) taskMgr.doMethodLater(5, self.__displayPitcherAdvice, self.pitcherAdviceName) self.arrowVert = 0 self.arrowHorz = 0 self.powerBar.show() return def __disableControlInterface(self): if self.closeButton: self.closeButton.destroy() self.closeButton = None self.__cleanupPitcherAdvice() self.ignore('escape') self.ignore('control') self.ignore('control-up') self.ignore('InputState-forward') self.ignore('InputState-reverse') self.ignore('InputState-turnLeft') self.ignore('InputState-turnRight') self.ignore('arrow_up') self.ignore('arrow_down') self.arrowVert = 0 self.arrowHorz = 0 taskMgr.remove(self.watchControlsName) taskMgr.remove(self.waterPowerTaskName) self.resetPowerBar() self.aimStart = None self.powerBar.hide() if self.TugOfWarControls: self.__killUpdateKeyPressRateTask() self.keyTTL = [] self.__setMoveSound(None) return def __displayPitcherAdvice(self, task): if self.pitcherAdviceLabel == None: self.pitcherAdviceLabel = DirectLabel(text=TTLocalizer.BossbotPitcherAdvice, text_fg=VBase4(1, 1, 1, 1), text_align=TextNode.ACenter, relief=None, pos=(0, 0, 0.69), scale=0.1) return def __cleanupPitcherAdvice(self): if self.pitcherAdviceLabel: self.pitcherAdviceLabel.destroy() self.pitcherAdviceLabel = None taskMgr.remove(self.pitcherAdviceName) return def showExiting(self): if self.closeButton: self.closeButton.destroy() self.closeButton = DirectLabel(relief=None, text=TTLocalizer.BossbotPitcherLeaving, pos=(1.05, 0, -0.88), text_pos=(0, 0), text_scale=0.06, text_fg=VBase4(1, 1, 1, 1)) self.__cleanupPitcherAdvice() return def __exitPitcher(self): self.showExiting() self.d_requestFree(False) def __controlPressed(self): self.__cleanupPitcherAdvice() if self.TugOfWarControls: if self.power: self.aimStart = 1 self.__endFireWater() elif self.state == 'Controlled': self.__beginFireWater() def __controlReleased(self): if self.TugOfWarControls: pass elif self.state == 'Controlled': self.__endFireWater() def __upArrow(self, pressed): self.__incrementChangeSeq() self.__cleanupPitcherAdvice() if pressed: self.arrowVert = 1 elif self.arrowVert > 0: self.arrowVert = 0 def __downArrow(self, pressed): self.__incrementChangeSeq() self.__cleanupPitcherAdvice() if pressed: self.arrowVert = -1 elif self.arrowVert < 0: self.arrowVert = 0 def __rightArrow(self, pressed): self.__incrementChangeSeq() self.__cleanupPitcherAdvice() if pressed: self.arrowHorz = 1 elif self.arrowHorz > 0: self.arrowHorz = 0 def __leftArrow(self, pressed): self.__incrementChangeSeq() self.__cleanupPitcherAdvice() if pressed: self.arrowHorz = -1 elif self.arrowHorz < 0: self.arrowHorz = 0 def __incrementChangeSeq(self): self.changeSeq = self.changeSeq + 1 & 255 def stopPosHprBroadcast(self): taskName = self.posHprBroadcastName taskMgr.remove(taskName) def startPosHprBroadcast(self): taskName = self.posHprBroadcastName self.b_clearSmoothing() self.d_sendPitcherPos() taskMgr.remove(taskName) taskMgr.doMethodLater(self.__broadcastPeriod, self.__posHprBroadcast, taskName) def __posHprBroadcast(self, task): self.d_sendPitcherPos() taskName = self.posHprBroadcastName taskMgr.doMethodLater(self.__broadcastPeriod, self.__posHprBroadcast, taskName) return Task.done def d_sendPitcherPos(self): timestamp = globalClockDelta.getFrameNetworkTime() self.sendUpdate('setPitcherPos', [self.changeSeq, self.waterPitcherNode.getH(), timestamp]) def setPitcherPos(self, changeSeq, h, timestamp): self.changeSeq = changeSeq if self.smoothStarted: now = globalClock.getFrameTime() local = globalClockDelta.networkToLocalTime(timestamp, now) self.pitcherSmoother.setH(h) self.pitcherSmoother.setTimestamp(local) self.pitcherSmoother.markPosition() else: self.waterPitcherNode.setH(h) def __watchControls(self, task): if self.arrowHorz: self.__movePitcher(self.arrowHorz) else: self.__setMoveSound(None) return Task.cont def __movePitcher(self, xd): dt = globalClock.getDt() h = self.waterPitcherNode.getH() - xd * self.rotateSpeed * dt h %= 360 self.notify.debug('rotSpeed=%.2f curH=%.2f xd =%.2f, dt = %.2f, h=%.2f' % (self.rotateSpeed, self.waterPitcherNode.getH(), xd, dt, h)) limitH = h self.waterPitcherNode.setH(limitH) if xd: self.__setMoveSound(self.pitcherMoveSfx) def reloadPosition(self): self.pitcherSmoother.clearPositions(0) self.pitcherSmoother.setHpr(self.waterPitcherNode.getHpr()) self.pitcherSmoother.setPhonyTimestamp() def forceToTruePosition(self): if self.pitcherSmoother.getLatestPosition(): self.pitcherSmoother.applySmoothHpr(self.waterPitcherNode) self.pitcherSmoother.clearPositions(1) def getSprayTrack(self, color, origin, target, dScaleUp, dHold, dScaleDown, horizScale = 1.0, vertScale = 1.0, parent = render): track = Sequence() SPRAY_LEN = 1.5 sprayProp = MovieUtil.globalPropPool.getProp('spray') sprayScale = hidden.attachNewNode('spray-parent') sprayRot = hidden.attachNewNode('spray-rotate') spray = sprayRot spray.setColor(color) if color[3] < 1.0: spray.setTransparency(1) def showSpray(sprayScale, sprayRot, sprayProp, origin, target, parent): if callable(origin): origin = origin() if callable(target): target = target() sprayRot.reparentTo(parent) sprayRot.clearMat() sprayScale.reparentTo(sprayRot) sprayScale.clearMat() sprayProp.reparentTo(sprayScale) sprayProp.clearMat() sprayRot.setPos(origin) sprayRot.lookAt(Point3(target)) track.append(Func(showSpray, sprayScale, sprayRot, sprayProp, origin, target, parent)) def calcTargetScale(target = target, origin = origin, horizScale = horizScale, vertScale = vertScale): if callable(target): target = target() if callable(origin): origin = origin() distance = Vec3(target - origin).length() yScale = distance / SPRAY_LEN targetScale = Point3(yScale * horizScale, yScale, yScale * vertScale) return targetScale track.append(LerpScaleInterval(sprayScale, dScaleUp, calcTargetScale, startScale=Point3(0.01, 0.01, 0.01))) track.append(Func(self.checkHitObject)) track.append(Wait(dHold)) def prepareToShrinkSpray(spray, sprayProp, origin, target): if callable(target): target = target() if callable(origin): origin = origin() sprayProp.setPos(Point3(0.0, -SPRAY_LEN, 0.0)) spray.setPos(target) track.append(Func(prepareToShrinkSpray, spray, sprayProp, origin, target)) track.append(LerpScaleInterval(sprayScale, dScaleDown, Point3(0.01, 0.01, 0.01))) def hideSpray(spray, sprayScale, sprayRot, sprayProp, propPool): sprayProp.detachNode() MovieUtil.removeProp(sprayProp) sprayRot.removeNode() sprayScale.removeNode() track.append(Func(hideSpray, spray, sprayScale, sprayRot, sprayProp, MovieUtil.globalPropPool)) return track def checkHitObject(self): if not self.hitObject: return if self.avId != base.localAvatar.doId: return tag = self.hitObject.getNetTag('pieCode') pieCode = int(tag) if pieCode == ToontownGlobals.PieCodeBossCog: self.hitBossSoundInterval.start() self.sendUpdate('waterHitBoss', [self.index]) if self.TugOfWarControls: damage = 1 if self.lastPowerFired < self.YELLOW_POWER_THRESHOLD: damage = 1 elif self.lastPowerFired < self.RED_POWER_THRESHOLD: damage = 2 else: damage = 3 self.boss.d_hitBoss(damage) else: damage = 1 if self.lastPowerFired < self.YELLOW_POWER_THRESHOLD: damage = 1 elif self.lastPowerFired < self.RED_POWER_THRESHOLD: damage = 2 else: damage = 3 self.boss.d_hitBoss(damage) def waterHitBoss(self, tableIndex): if self.index == tableIndex: self.hitBossSoundInterval.start() def setupPowerBar(self): self.powerBar = DirectWaitBar(pos=(0.0, 0, -0.94), relief=DGG.SUNKEN, frameSize=(-2.0, 2.0, -0.2, 0.2), borderWidth=(0.02, 0.02), scale=0.25, range=1, sortOrder=50, frameColor=(0.5, 0.5, 0.5, 0.5), barColor=(0.75, 0.75, 1.0, 0.8), text='', text_scale=0.26, text_fg=(1, 1, 1, 1), text_align=TextNode.ACenter, text_pos=(0, -0.05)) self.power = 0 self.powerBar['value'] = self.power self.powerBar.hide() def resetPowerBar(self): self.power = 0 self.powerBar['value'] = self.power self.powerBar['text'] = '' self.keyTTL = [] def __beginFireWater(self): if self.fireTrack and self.fireTrack.isPlaying(): return if self.aimStart != None: return if not self.state == 'Controlled': return if not self.avId == localAvatar.doId: return time = globalClock.getFrameTime() self.aimStart = time messenger.send('wakeup') taskMgr.add(self.__updateWaterPower, self.waterPowerTaskName) return def __endFireWater(self): if self.aimStart == None: return if not self.state == 'Controlled': return if not self.avId == localAvatar.doId: return taskMgr.remove(self.waterPowerTaskName) messenger.send('wakeup') self.aimStart = None origin = self.nozzle.getPos(render) target = self.boss.getPos(render) angle = deg2Rad(self.waterPitcherNode.getH() + 90) x = math.cos(angle) y = math.sin(angle) fireVector = Point3(x, y, 0) if self.power < 0.001: self.power = 0.001 self.lastPowerFired = self.power fireVector *= self.fireLength * self.power target = origin + fireVector segment = CollisionSegment(origin[0], origin[1], origin[2], target[0], target[1], target[2]) fromObject = render.attachNewNode(CollisionNode('pitcherColNode')) fromObject.node().addSolid(segment) fromObject.node().setFromCollideMask(ToontownGlobals.PieBitmask | ToontownGlobals.CameraBitmask | ToontownGlobals.FloorBitmask) fromObject.node().setIntoCollideMask(BitMask32.allOff()) queue = CollisionHandlerQueue() base.cTrav.addCollider(fromObject, queue) base.cTrav.traverse(render) queue.sortEntries() self.hitObject = None if queue.getNumEntries(): entry = queue.getEntry(0) target = entry.getSurfacePoint(render) self.hitObject = entry.getIntoNodePath() base.cTrav.removeCollider(fromObject) fromObject.removeNode() self.d_firingWater(origin, target) self.fireWater(origin, target) self.resetPowerBar() return def __updateWaterPower(self, task): if not self.powerBar: print '### no power bar!!!' return task.done newPower = self.__getWaterPower(globalClock.getFrameTime()) self.power = newPower self.powerBar['value'] = newPower if self.power < self.YELLOW_POWER_THRESHOLD: self.powerBar['barColor'] = VBase4(0.75, 0.75, 1.0, 0.8) elif self.power < self.RED_POWER_THRESHOLD: self.powerBar['barColor'] = VBase4(1.0, 1.0, 0.0, 0.8) else: self.powerBar['barColor'] = VBase4(1.0, 0.0, 0.0, 0.8) return task.cont def __getWaterPower(self, time): elapsed = max(time - self.aimStart, 0.0) t = elapsed / self.waterPowerSpeed exponent = self.waterPowerExponent if t > 1: t %= 1 power = 1 - math.pow(1 - t, exponent) if power > 1.0: power = 1.0 return power def d_firingWater(self, origin, target): self.sendUpdate('firingWater', [origin[0], origin[1], origin[2], target[0], target[1], target[2]]) def firingWater(self, startX, startY, startZ, endX, endY, endZ): origin = Point3(startX, startY, startZ) target = Point3(endX, endY, endZ) self.fireWater(origin, target) def fireWater(self, origin, target): color = VBase4(0.75, 0.75, 1, 0.8) dScaleUp = 0.1 dHold = 0.3 dScaleDown = 0.1 horizScale = 0.1 vertScale = 0.1 sprayTrack = self.getSprayTrack(color, origin, target, dScaleUp, dHold, dScaleDown, horizScale, vertScale) duration = self.squirtSfx.length() if sprayTrack.getDuration() < duration: duration = sprayTrack.getDuration() soundTrack = SoundInterval(self.squirtSfx, node=self.waterPitcherModel, duration=duration) self.fireTrack = Parallel(sprayTrack, soundTrack) self.fireTrack.start() def getPos(self, wrt = render): return self.tableGroup.getPos(wrt) def getLocator(self): return self.tableGroup def enterFlat(self, avId): self.prepareForPhaseFour() self.resetPowerBar() self.notify.debug('enterFlat %d' % self.index) if self.avId: toon = base.cr.doId2do.get(self.avId) if toon: toon.wrtReparentTo(render) toon.setZ(0) self.tableGroup.setScale(1, 1, 0.01) if self.avId and self.avId == localAvatar.doId: localAvatar.b_squish(ToontownGlobals.BossCogDamageLevels[ToontownGlobals.BossCogMoveAttack]) def exitFlat(self): self.tableGroup.setScale(1.0) if self.avId: toon = base.cr.doId2do.get(self.avId) if toon: if toon == localAvatar: self.boss.toCraneMode() toon.b_setAnimState('neutral') toon.setAnimState('neutral') toon.loop('leverNeutral') def __allowDetect(self, task): if self.fadeTrack: self.fadeTrack.finish() self.fadeTrack = Sequence(self.tableGroup.colorScaleInterval(0.2, VBase4(1, 1, 1, 1)), Func(self.tableGroup.clearColorScale), Func(self.tableGroup.clearTransparency)) self.fadeTrack.start() self.allowLocalRequestControl = True def gotBossZapped(self): self.showExiting() self.d_requestFree(True) def __upArrowKeyPressed(self): if self.TugOfWarControls: self.__pressHandler(0) def __downArrowKeyPressed(self): if self.TugOfWarControls: self.__pressHandler(1) def __pressHandler(self, index): if index == self.buttons[0]: self.keyTTL.insert(0, 1.0) if not self.OnlyUpArrow: self.buttons.reverse() def __spawnUpdateKeyPressRateTask(self): taskMgr.remove(self.taskName(self.UPDATE_KEY_PRESS_RATE_TASK)) taskMgr.doMethodLater(0.1, self.__updateKeyPressRateTask, self.taskName(self.UPDATE_KEY_PRESS_RATE_TASK)) def __killUpdateKeyPressRateTask(self): taskMgr.remove(self.taskName(self.UPDATE_KEY_PRESS_RATE_TASK)) def __updateKeyPressRateTask(self, task): if self.state not in 'Controlled': return Task.done for i in range(len(self.keyTTL)): self.keyTTL[i] -= 0.1 for i in range(len(self.keyTTL)): if self.keyTTL[i] <= 0: a = self.keyTTL[0:i] del self.keyTTL self.keyTTL = a break self.keyRate = len(self.keyTTL) keyRateDiff = self.keyRate - self.BASELINE_KEY_RATE diffPower = keyRateDiff / 300.0 if self.power < 1 and diffPower > 0: diffPower *= math.pow(1 - self.power, 1.25) newPower = self.power + diffPower if newPower > 1: newPower = 1 elif newPower < 0: newPower = 0 self.notify.debug('diffPower=%.2f keyRate = %d, newPower=%.2f' % (diffPower, self.keyRate, newPower)) self.power = newPower self.powerBar['value'] = newPower if self.power < self.YELLOW_POWER_THRESHOLD: self.powerBar['barColor'] = VBase4(0.75, 0.75, 1.0, 0.8) elif self.power < self.RED_POWER_THRESHOLD: self.powerBar['barColor'] = VBase4(1.0, 1.0, 0.0, 0.8) else: self.powerBar['barColor'] = VBase4(1.0, 0.0, 0.0, 0.8) self.__spawnUpdateKeyPressRateTask() return Task.done def __setMoveSound(self, sfx): if sfx != self.moveSound: if self.moveSound: self.moveSound.stop() self.moveSound = sfx if self.moveSound: base.playSfx(self.moveSound, looping=1, volume=0.5)
class DistributedBuilding(DistributedObject, Precacheable): notify = directNotify.newCategory('DistributedBuilding') SUIT_INIT_HEIGHT = 125 TAKEOVER_SFX_PREFIX = 'phase_5/audio/sfx/' # for precaching ELEVATOR_MDL = 'phase_4/models/modules/elevator.bam' ICONS_MDL = 'phase_3/models/gui/cog_icons.bam' SIGN_MDL = 'phase_5/models/modules/suit_sign.bam' def __init__(self, cr): DistributedObject.__init__(self, cr) self.suitDoorOrigin = None self.elevatorModel = None self.fsm = ClassicFSM.ClassicFSM('DistributedBuilding', [ State.State('off', self.enterOff, self.exitOff), State.State('waitForVictors', self.enterWaitForVictors, self.exitWaitForVictors), State.State('becomingToon', self.enterBecomingToon, self.exitBecomingToon), State.State('toon', self.enterToon, self.exitToon), State.State('becomingSuit', self.enterBecomingSuit, self.exitBecomingSuit), State.State('suit', self.enterSuit, self.exitSuit) ], 'off', 'off') self.fsm.enterInitialState() self.elevatorNodePath = None self.transitionTrack = None self.victorList = [0, 0, 0, 0] self.waitingMessage = None self.cogDropSound = None self.cogLandSound = None self.cogSettleSound = None self.cogWeakenSound = None self.toonGrowSound = None self.toonSettleSound = None self.leftDoor = None self.setLights = False @classmethod def doPrecache(cls): precacheModel(cls.ELEVATOR_MDL) precacheModel(cls.ICONS_MDL) precacheModel(cls.SIGN_MDL) def getDeptClassFromAbbr(self, abbr): if abbr == 's': return Dept.SALES elif abbr == 'l': return Dept.LAW elif abbr == 'c': return Dept.BOSS elif abbr == 'm': return Dept.CASH def generate(self): DistributedObject.generate(self) self.mode = 'toon' self.townTopLevel = self.cr.playGame.hood.loader.geom def disable(self): self.fsm.requestFinalState() del self.townTopLevel self.stopTransition() DistributedObject.disable(self) def delete(self): self.victorList = None if self.elevatorNodePath: base.disablePhysicsNodes(self.elevatorNodePath) self.elevatorNodePath.removeNode() del self.elevatorNodePath del self.elevatorModel if hasattr(self, 'cab'): del self.cab del self.leftDoor del self.rightDoor self.leftDoor = None del self.suitDoorOrigin self.cleanupSuitBuilding() self.unloadSfx() del self.fsm DistributedObject.delete(self) def setBlock(self, block, interiorZoneId): self.block = block self.interiorZoneId = interiorZoneId def setSuitData(self, suitDept, difficulty, numFloors): self.suitDept = suitDept self.difficulty = difficulty self.numFloors = numFloors def setState(self, state, timestamp): self.fsm.request(state, [globalClockDelta.localElapsedTime(timestamp)]) def getSuitElevatorNodePath(self): if self.mode != 'suit': self.setToSuit() return self.elevatorNodePath def getSuitDoorOrigin(self): if self.mode != 'suit': self.setToSuit() return self.suitDoorOrigin def setVictorList(self, victorList): self.victorList = victorList def enterOff(self): pass def exitOff(self): pass def enterWaitForVictors(self, ts): if self.mode != 'suit': self.setToSuit() victorCount = self.victorList.count(base.localAvatar.doId) if victorCount == 1: self.acceptOnce('insideVictorElevator', self.handleInsideVictorElevator) camera.reparentTo(render) camera.setPosHpr(self.elevatorNodePath, 0, -32.5, 9.4, 0, 348, 0) base.camLens.setMinFov(CIGlobals.DefaultCameraFov / (4. / 3.)) anyOthers = 0 for v in self.victorList: if v != 0 and v != base.localAvatar.doId: anyOthers = 1 if anyOthers: self.waitingMessage = DirectLabel( text="Waiting for other players...", text_fg=VBase4(1, 1, 1, 1), text_align=TextNode.ACenter, relief=None, pos=(0, 0, 0.35), scale=0.1, text_shadow=(0, 0, 0, 1)) elif victorCount == 0: pass else: self.error('localToon is on the victorList %d times' % victorCount) closeDoors(self.leftDoor, self.rightDoor) for light in self.floorIndicator: if light != None: light.setColor(LIGHT_OFF_COLOR) def handleInsideVictorElevator(self): self.sendUpdate('setVictorReady', []) def exitWaitForVictors(self): self.ignore('insideVictorElevator') if self.waitingMessage != None: self.waitingMessage.destroy() self.waitingMessage = None def enterBecomingToon(self, ts): self.animToToon(ts) def exitBecomingToon(self): pass def enterToon(self, ts): self.setToToon() def exitToon(self): pass def enterBecomingSuit(self, ts): self.animToSuit(ts) def exitBecomingSuit(self): pass def enterSuit(self, ts): self.setToSuit() def exitSuit(self): pass def getNodePaths(self): nodePath = [] npc = self.townTopLevel.findAllMatches('**/?b' + str(self.block) + ':*_DNARoot;+s') npc.addPathsFrom( self.townTopLevel.findAllMatches("**/toonBuildingsBlock" + str(self.block) + ";+s")) for i in xrange(npc.getNumPaths()): nodePath.append(npc.getPath(i)) return nodePath def getElevatorModel(self): return self.elevatorModel def loadElevator(self, newNP): self.floorIndicator = [None, None, None, None, None] self.elevatorNodePath = hidden.attachNewNode('elevatorNodePath') self.elevatorModel = loader.loadModel(self.ELEVATOR_MDL) npc = self.elevatorModel.findAllMatches('**/floor_light_?;+s') for i in xrange(npc.getNumPaths()): np = npc.getPath(i) floor = int(np.getName()[-1:]) - 1 self.floorIndicator[floor] = np if floor < self.numFloors: np.setColor(LIGHT_OFF_COLOR) else: np.hide() self.elevatorModel.reparentTo(self.elevatorNodePath) self.cab = self.elevatorModel.find('**/elevator') cogIcons = loader.loadModel(self.ICONS_MDL) dept = self.getDeptClassFromAbbr(self.suitDept) if dept == Dept.BOSS: corpIcon = cogIcons.find('**/CorpIcon').copyTo(self.cab) elif dept == Dept.SALES: corpIcon = cogIcons.find('**/SalesIcon').copyTo(self.cab) elif dept == Dept.LAW: corpIcon = cogIcons.find('**/LegalIcon').copyTo(self.cab) elif dept == Dept.CASH: corpIcon = cogIcons.find('**/MoneyIcon').copyTo(self.cab) corpIcon.setPos(0, 6.79, 6.8) corpIcon.setScale(3) corpIcon.setColor(dept.getMedallionColor()) cogIcons.removeNode() self.leftDoor = self.elevatorModel.find('**/left-door') if self.leftDoor.isEmpty(): self.leftDoor = self.elevatorModel.find('**/left_door') self.rightDoor = self.elevatorModel.find('**/right-door') if self.rightDoor.isEmpty(): self.rightDoor = self.elevatorModel.find('**/right_door') self.suitDoorOrigin = newNP.find('**/*_door_origin') self.elevatorNodePath.reparentTo(self.suitDoorOrigin) base.createPhysicsNodes(self.elevatorNodePath) base.enablePhysicsNodes(self.elevatorNodePath) #self.elevatorNodePath.flattenStrong() self.normalizeElevator() def loadAnimToSuitSfx(self): if self.cogDropSound is None: self.cogDropSound = base.loadSfx(self.TAKEOVER_SFX_PREFIX + 'cogbldg_drop.ogg') self.cogLandSound = base.loadSfx(self.TAKEOVER_SFX_PREFIX + 'cogbldg_land.ogg') self.cogSettleSound = base.loadSfx(self.TAKEOVER_SFX_PREFIX + 'cogbldg_settle.ogg') self.openSfx = base.loadSfx( 'phase_5/audio/sfx/elevator_door_open.ogg') def loadAnimToToonSfx(self): if self.cogWeakenSound is None: self.cogWeakenSound = base.loadSfx(self.TAKEOVER_SFX_PREFIX + 'cogbldg_weaken.ogg') self.toonGrowSound = base.loadSfx(self.TAKEOVER_SFX_PREFIX + 'toonbldg_grow.ogg') self.toonSettleSound = base.loadSfx(self.TAKEOVER_SFX_PREFIX + 'toonbldg_settle.ogg') self.openSfx = base.loadSfx( 'phase_5/audio/sfx/elevator_door_open.ogg') def unloadSfx(self): if self.cogDropSound != None: self.cogDropSound = None self.cogLandSound = None self.cogSettleSound = None self.openSfx = None if self.cogWeakenSound != None: self.cogWeakenSound = None self.toonGrowSound = None self.toonSettleSound = None self.openSfx = None def _deleteTransitionTrack(self): if self.transitionTrack: DelayDelete.cleanupDelayDeletes(self.transitionTrack) self.transitionTrack = None def animToSuit(self, timeStamp): self.stopTransition() if self.mode != 'toon': self.setToToon() self.loadAnimToSuitSfx() sideBldgNodes = self.getNodePaths() nodePath = hidden.find(self.getSbSearchString()) newNP = self.setupSuitBuilding(nodePath) if not self.leftDoor: return closeDoors(self.leftDoor, self.rightDoor) newNP.stash() sideBldgNodes.append(newNP) soundPlayed = 0 tracks = Parallel(name=self.taskName('toSuitTrack')) for i in sideBldgNodes: name = i.getName() timeForDrop = TO_SUIT_BLDG_TIME * 0.85 if name[0] == 's': showTrack = Sequence(name=self.taskName('ToSuitFlatsTrack') + '-' + str(sideBldgNodes.index(i))) initPos = Point3(0, 0, self.SUIT_INIT_HEIGHT) + i.getPos() showTrack.append(Func(i.setPos, initPos)) showTrack.append(Func(i.unstash)) showTrack.append(Func(base.enablePhysicsNodes, i)) if i == sideBldgNodes[len(sideBldgNodes) - 1]: showTrack.append(Func(self.normalizeElevator)) if not soundPlayed: showTrack.append( Func(base.playSfx, self.cogDropSound, 0, 1, None, 0.0)) showTrack.append( LerpPosInterval(i, timeForDrop, i.getPos(), name=self.taskName('ToSuitAnim') + '-' + str(sideBldgNodes.index(i)))) if not soundPlayed: showTrack.append( Func(base.playSfx, self.cogLandSound, 0, 1, None, 0.0)) showTrack.append( self.createBounceTrack(i, 2, 0.65, TO_SUIT_BLDG_TIME - timeForDrop, slowInitBounce=1.0)) if not soundPlayed: showTrack.append( Func(base.playSfx, self.cogSettleSound, 0, 1, None, 0.0)) tracks.append(showTrack) if not soundPlayed: soundPlayed = 1 elif name[0] == 't': hideTrack = Sequence( name=self.taskName('ToSuitToonFlatsTrack')) timeTillSquish = (self.SUIT_INIT_HEIGHT - 20.0) / self.SUIT_INIT_HEIGHT timeTillSquish *= timeForDrop hideTrack.append( LerpFunctionInterval(self.adjustColorScale, fromData=1, toData=0.25, duration=timeTillSquish, extraArgs=[i])) hideTrack.append( LerpScaleInterval(i, timeForDrop - timeTillSquish, Vec3(1, 1, 0.01))) hideTrack.append(Func(base.disablePhysicsNodes, i)) hideTrack.append(Func(i.stash)) hideTrack.append(Func(i.setScale, Vec3(1))) hideTrack.append(Func(i.clearColorScale)) tracks.append(hideTrack) self.stopTransition() self._deleteTransitionTrack() self.transitionTrack = tracks self.transitionTrack.start(timeStamp) def setupSuitBuilding(self, nodePath): if nodePath.isEmpty(): return dnaStore = self.cr.playGame.dnaStore level = int(self.difficulty / 2) + 1 suitNP = dnaStore.findNode( 'suit_landmark_' + self.getDeptClassFromAbbr(self.suitDept).getClothingPrefix() + str(level)) zoneId = dnaStore.getZoneFromBlockNumber(self.block) zoneId = ZoneUtil.getTrueZoneId(zoneId, self.interiorZoneId) newParentNP = base.cr.playGame.hood.loader.zoneDict[zoneId] suitBuildingNP = suitNP.copyTo(newParentNP) base.createPhysicsNodes(suitBuildingNP) buildingTitle = dnaStore.getTitleFromBlockNumber(self.block) if not buildingTitle: buildingTitle = "Cogs, Inc." else: buildingTitle += ", Inc." buildingTitle += "\n%s" % self.getDeptClassFromAbbr( self.suitDept).getName() textNode = TextNode('sign') textNode.setTextColor(1.0, 1.0, 1.0, 1.0) textNode.setFont(CIGlobals.getSuitFont()) textNode.setAlign(TextNode.ACenter) textNode.setWordwrap(17.0) textNode.setText(buildingTitle) textHeight = textNode.getHeight() zScale = (textHeight + 2) / 3.0 signOrigin = suitBuildingNP.find('**/sign_origin;+s') backgroundNP = loader.loadModel(self.SIGN_MDL) backgroundNP.reparentTo(signOrigin) backgroundNP.setPosHprScale(0.0, 0.0, textHeight * 0.8 / zScale, 0.0, 0.0, 0.0, 8.0, 8.0, 8.0 * zScale) #backgroundNP.node().setEffect(DecalEffect.make()) signTextNodePath = backgroundNP.attachNewNode(textNode.generate()) signTextNodePath.setPosHprScale(0.0, -0.02, -0.21 + textHeight * 0.1 / zScale, 0.0, 0.0, 0.0, 0.1, 0.1, 0.1 / zScale) signTextNodePath.setColor(1.0, 1.0, 1.0, 1.0) frontNP = suitBuildingNP.find('**/*_front/+GeomNode;+s') backgroundNP.wrtReparentTo(frontNP) frontNP.node().setEffect(DecalEffect.make()) suitBuildingNP.setName('sb' + str(self.block) + ':_landmark__DNARoot') suitBuildingNP.setPosHprScale(nodePath, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0) suitBuildingNP.flattenStrong() self.loadElevator(suitBuildingNP) #CIGlobals.replaceDecalEffectsWithDepthOffsetAttrib(suitBuildingNP) #CIGlobals.flattenModelNodes(suitBuildingNP) base.enablePhysicsNodes(suitBuildingNP) #suitBuildingNP.ls() return suitBuildingNP def cleanupSuitBuilding(self): if hasattr(self, 'floorIndicator'): del self.floorIndicator def adjustColorScale(self, scale, node): node.setColorScale(scale, scale, scale, 1) def animToToon(self, timeStamp): self.stopTransition() if self.mode != 'suit': self.setToSuit() self.loadAnimToToonSfx() suitSoundPlayed = 0 toonSoundPlayed = 0 bldgNodes = self.getNodePaths() tracks = Parallel() for i in bldgNodes: name = i.getName() if name[0] == 's': hideTrack = Sequence( name=self.taskName('ToToonSuitFlatsTrack')) landmark = name.find('_landmark_') != -1 if not suitSoundPlayed: hideTrack.append( Func(base.playSfx, self.cogWeakenSound, 0, 1, None, 0.0)) hideTrack.append( self.createBounceTrack(i, 3, 1.2, TO_TOON_BLDG_TIME * 0.05, slowInitBounce=0.0)) hideTrack.append( self.createBounceTrack(i, 5, 0.8, TO_TOON_BLDG_TIME * 0.1, slowInitBounce=0.0)) hideTrack.append( self.createBounceTrack(i, 7, 1.2, TO_TOON_BLDG_TIME * 0.17, slowInitBounce=0.0)) hideTrack.append( self.createBounceTrack(i, 9, 1.2, TO_TOON_BLDG_TIME * 0.18, slowInitBounce=0.0)) realScale = i.getScale() hideTrack.append( LerpScaleInterval(i, TO_TOON_BLDG_TIME * 0.1, Vec3(realScale[0], realScale[1], 0.01))) hideTrack.append(Func(base.disablePhysicsNodes, i)) if landmark: hideTrack.append(Func(i.removeNode)) else: hideTrack.append(Func(i.stash)) hideTrack.append(Func(i.setScale, Vec3(1))) if not suitSoundPlayed: suitSoundPlayed = 1 tracks.append(hideTrack) elif name[0] == 't': hideTrack = Sequence(name=self.taskName('ToToonFlatsTrack')) hideTrack.append(Wait(TO_TOON_BLDG_TIME * 0.5)) if not toonSoundPlayed: hideTrack.append( Func(base.playSfx, self.toonGrowSound, 0, 1, None, 0.0)) hideTrack.append(Func(i.unstash)) hideTrack.append(Func(base.enablePhysicsNodes, i)) hideTrack.append(Func(i.setScale, Vec3(1, 1, 0.01))) if not toonSoundPlayed: hideTrack.append( Func(base.playSfx, self.toonSettleSound, 0, 1, None, 0.0)) hideTrack.append( self.createBounceTrack(i, 11, 1.2, TO_TOON_BLDG_TIME * 0.5, slowInitBounce=4.0)) tracks.append(hideTrack) if not toonSoundPlayed: toonSoundPlayed = 1 self.stopTransition() bldgMTrack = tracks localToonIsVictor = self.localToonIsVictor() if localToonIsVictor: base.localAvatar.loop('neutral') camTrack = self.walkOutCameraTrack() victoryRunTrack, delayDeletes = self.getVictoryRunTrack() trackName = self.taskName('toToonTrack') self._deleteTransitionTrack() if localToonIsVictor: freedomTrack1 = Func(self.cr.playGame.getPlace().fsm.request, 'walk') freedomTrack2 = Func(base.localAvatar.d_setParent, CIGlobals.SPRender) freedomTrack3 = Func(messenger.send, BattleGlobals.BATTLE_COMPLETE_EVENT) self.transitionTrack = Parallel(camTrack, Sequence(victoryRunTrack, bldgMTrack, freedomTrack1, freedomTrack2, freedomTrack3), name=trackName) else: self.transitionTrack = Sequence(victoryRunTrack, bldgMTrack, name=trackName) self.transitionTrack.delayDeletes = delayDeletes if localToonIsVictor: self.transitionTrack.start(0) else: self.transitionTrack.start(timeStamp) def walkOutCameraTrack(self): track = Sequence( Func(camera.reparentTo, render), Func(camera.setPosHpr, self.elevatorNodePath, 0, -32.5, 9.4, 0, 348, 0), Func(base.camLens.setMinFov, CIGlobals.DefaultCameraFov / (4. / 3.)), Wait(VICTORY_RUN_TIME), Func(camera.setPosHpr, self.elevatorNodePath, 0, -32.5, 17, 0, 347, 0), Func(base.camLens.setMinFov, 75.0 / (4. / 3)), Wait(TO_TOON_BLDG_TIME), Func(base.camLens.setMinFov, CIGlobals.DefaultCameraFov / (4. / 3.))) return track def plantVictorsOutsideBldg(self): retVal = 0 for victor in self.victorList: if victor != 0 and victor in self.cr.doId2do: toon = self.cr.doId2do[victor] toon.setPosHpr(self.elevatorModel, 0, -10, 0, 0, 0, 0) toon.startSmooth() if victor == base.localAvatar.doId: retVal = 1 self.cr.playGame.getPlace().fsm.request('walk') return retVal def getVictoryRunTrack(self): origPosTrack = Sequence() delayDeletes = [] i = 0 for victor in self.victorList: if victor != 0 and victor in self.cr.doId2do: toon = self.cr.doId2do[victor] delayDeletes.append( DelayDelete.DelayDelete(toon, 'getVictoryRunTrack')) toon.stopSmooth() toon.setParent(CIGlobals.SPHidden) origPosTrack.append( Func(toon.setPosHpr, self.elevatorNodePath, apply(Point3, ElevatorPoints[i]), Point3(180, 0, 0))) origPosTrack.append(Func(toon.setParent, CIGlobals.SPRender)) i += 1 openDoors = getOpenInterval(self, self.leftDoor, self.rightDoor, self.openSfx, None) toonDoorPosHpr = self.cr.playGame.dnaStore.getDoorPosHprFromBlockNumber( self.block) useFarExitPoints = toonDoorPosHpr.getPos(render).getZ() > 1.0 runOutAll = Parallel() i = 0 for victor in self.victorList: if victor != 0 and victor in self.cr.doId2do: toon = self.cr.doId2do[victor] p0 = Point3(0, 0, 0) p1 = Point3(ElevatorPoints[i][0], ElevatorPoints[i][1] - 5.0, ElevatorPoints[i][2]) if useFarExitPoints: p2 = Point3(ElevatorOutPointsFar[i][0], ElevatorOutPointsFar[i][1], ElevatorOutPointsFar[i][2]) else: p2 = Point3(ElevatorOutPoints[i][0], ElevatorOutPoints[i][1], ElevatorOutPoints[i][2]) runOutSingle = Sequence( Func(toon.animFSM.request, 'run'), LerpPosInterval(toon, TOON_VICTORY_EXIT_TIME * 0.25, p1, other=self.elevatorNodePath), Func(toon.headsUp, self.elevatorNodePath, p2), LerpPosInterval(toon, TOON_VICTORY_EXIT_TIME * 0.5, p2, other=self.elevatorNodePath), LerpHprInterval(toon, TOON_VICTORY_EXIT_TIME * 0.25, Point3(0, 0, 0), other=self.elevatorNodePath), Func(toon.animFSM.request, 'neutral'), Func(toon.startSmooth)) runOutAll.append(runOutSingle) i += 1 victoryRunTrack = Sequence(origPosTrack, openDoors, runOutAll) return (victoryRunTrack, delayDeletes) def localToonIsVictor(self): retVal = 0 for victor in self.victorList: if victor == base.localAvatar.doId: retVal = 1 return retVal def createBounceTrack(self, nodeObj, numBounces, startScale, totalTime, slowInitBounce=0.0): if not nodeObj or numBounces < 1 or startScale == 0.0 or totalTime == 0: self.notify.warning( 'createBounceTrack called with invalid parameter(s)') return result = Sequence() numBounces += 1 if slowInitBounce: bounceTime = totalTime / (numBounces + slowInitBounce - 1.0) else: bounceTime = totalTime / float(numBounces) if slowInitBounce: currTime = bounceTime * float(slowInitBounce) else: currTime = bounceTime realScale = nodeObj.getScale() currScaleDiff = startScale - realScale[2] for currBounceScale in xrange(numBounces): if currBounceScale == numBounces - 1: currScale = realScale[2] elif currBounceScale % 2: currScale = realScale[2] - currScaleDiff else: currScale = realScale[2] + currScaleDiff result.append( LerpScaleInterval(nodeObj, currTime, Vec3(realScale[0], realScale[1], currScale), blendType='easeInOut')) currScaleDiff *= 0.5 currTime = bounceTime return result def stopTransition(self): if self.transitionTrack: self.transitionTrack.finish() self._deleteTransitionTrack() def setToSuit(self): self.stopTransition() if self.mode == 'suit': return self.mode = 'suit' nodes = self.getNodePaths() for i in nodes: name = i.getName() if name[0] == 's': if name.find('_landmark_') != -1: base.disablePhysicsNodes(i) i.removeNode() else: base.enablePhysicsNodes(i) i.unstash() elif name[0] == 't': for spl in i.findAllMatches("**/+Spotlight"): render.clearLight(spl) base.disablePhysicsNodes(i) i.stash() elif name[0] == 'c': base.disablePhysicsNodes(i) if name.find('_landmark_') != -1: i.removeNode() else: i.stash() if self.setLights and hasattr(self.cr.playGame.hood.loader, 'lampLights'): blockLamps = self.cr.playGame.hood.loader.lampLights.get( int(self.block), []) for lamp in blockLamps: render.clearLight(lamp) self.setLights = False npc = hidden.findAllMatches(self.getSbSearchString()) for i in xrange(npc.getNumPaths()): nodePath = npc.getPath(i) self.adjustSbNodepathScale(nodePath) self.setupSuitBuilding(nodePath) def setToToon(self): self.stopTransition() if not self.setLights and hasattr(self.cr.playGame.hood.loader, 'lampLights'): blockLamps = self.cr.playGame.hood.loader.lampLights.get( self.block, []) for lamp in blockLamps: render.setLight(lamp) self.setLights = True if self.mode == 'toon': return self.mode = 'toon' self.suitDoorOrigin = None nodes = self.getNodePaths() for i in nodes: i.clearColorScale() name = i.getName() if name[0] in ['s', 'c']: base.disablePhysicsNodes(i) if name.find('_landmark_') != -1: for spl in i.findAllMatches("**/+Spotlight"): render.clearLight(spl) i.removeNode() else: i.stash() elif name[0] == 't': for spl in i.findAllMatches("**/+Spotlight"): render.setLight(spl) base.enablePhysicsNodes(i) i.unstash() def normalizeElevator(self): self.elevatorNodePath.setScale(render, Vec3(1, 1, 1)) self.elevatorNodePath.setPosHpr(0, 0, 0, 0, 0, 0) def getSbSearchString(self): result = 'landmarkBlocks/sb' + str( self.block) + ':*_landmark_*_DNARoot' return result def adjustSbNodepathScale(self, nodePath): pass def getVisZoneId(self): exteriorZoneId = self.cr.playGame.dnaStore.getZoneFromBlockNumber( self.block) visZoneId = ZoneUtil.getTrueZoneId(exteriorZoneId, self.zoneId) return visZoneId
def load(self): gui = loader.loadModel('phase_3/models/gui/laff_o_meter') if self.isToon: hType = self.style.getType() if hType == 'dog': headModel = gui.find('**/doghead') elif hType == 'cat': headModel = gui.find('**/cathead') elif hType == 'mouse': headModel = gui.find('**/mousehead') elif hType == 'horse': headModel = gui.find('**/horsehead') elif hType == 'rabbit': headModel = gui.find('**/bunnyhead') elif hType == 'duck': headModel = gui.find('**/duckhead') elif hType == 'monkey': headModel = gui.find('**/monkeyhead') elif hType == 'bear': headModel = gui.find('**/bearhead') elif hType == 'pig': headModel = gui.find('**/pighead') elif hType == 'deer': headModel = gui.find('**/deerhead') else: raise StandardError('unknown toon species: ', hType) self.color = self.style.getHeadColor() self.container['image'] = headModel self.container['image_color'] = self.color self.resetFrameSize() self.setScale(0.1) self.frown = DirectFrame(parent=self.container, relief=None, image=gui.find('**/frown')) self.frown.setY(-0.1) self.smile = DirectFrame(parent=self.container, relief=None, image=gui.find('**/smile')) self.eyes = DirectFrame(parent=self.container, relief=None, image=gui.find('**/eyes')) self.eyes.setY(-0.1) self.openSmile = DirectFrame(parent=self.container, relief=None, image=gui.find('**/open_smile')) self.openSmile.setY(-0.1) self.tooth1 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_1')) self.tooth2 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_2')) self.tooth3 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_3')) self.tooth4 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_4')) self.tooth5 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_5')) self.tooth6 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_6')) self.maxLabel = DirectLabel( parent=self.eyes, relief=None, pos=(0.442, 0, 0.051), text='120', text_scale=0.4, text_font=ToontownGlobals.getInterfaceFont()) self.maxLabel.setY(-0.1) self.hpLabel = DirectLabel( parent=self.eyes, relief=None, pos=(-0.398, 0, 0.051), text='120', text_scale=0.4, text_font=ToontownGlobals.getInterfaceFont()) self.hpLabel.setY(-0.1) self.teeth = [ self.tooth6, self.tooth5, self.tooth4, self.tooth3, self.tooth2, self.tooth1 ] for tooth in self.teeth: tooth.setY(-0.1) self.fractions = [0.0, 0.166666, 0.333333, 0.5, 0.666666, 0.833333] gui.removeNode() return
class JellybeanRewardGui(DirectFrame): notify = directNotify.newCategory('JellybeanRewardGui') PreCountdownDelay = 1.0 CountDownRate = 0.2 JarLabelTextColor = (0.95, 0.95, 0.0, 1.0) JarLabelMaxedTextColor = (1.0, 0.0, 0.0, 1.0) def __init__(self, doneEvent): self.doneEvent = doneEvent DirectFrame.__init__(self) self.reparentTo(aspect2d) self.setPos(0.0, 0.0, 0.16) self.stash() publicPartyGui = loader.loadModel( 'phase_4/models/parties/publicPartyGUI') self.frame = DirectFrame( parent=self, geom=publicPartyGui.find('**/activities_background'), geom_pos=(-0.8, 0.0, 0.2), geom_scale=2.0, relief=None) self.earnedLabel = DirectLabel( parent=self, relief=None, text=str(0), text_align=TextNode.ACenter, text_pos=(0.0, -0.07), text_scale=0.2, text_fg=(0.95, 0.95, 0.0, 1.0), text_font=ToontownGlobals.getSignFont(), textMayChange=True, image=DirectGuiGlobals.getDefaultDialogGeom(), image_scale=(0.33, 1.0, 0.33), pos=(-0.3, 0.0, 0.2), scale=0.9) purchaseModels = loader.loadModel('phase_4/models/gui/purchase_gui') jarImage = purchaseModels.find('**/Jar') self.jarLabel = DirectLabel( parent=self, relief=None, text=str(0), text_align=TextNode.ACenter, text_pos=(0.0, -0.07), text_scale=0.2, text_fg=JellybeanRewardGui.JarLabelTextColor, text_font=ToontownGlobals.getSignFont(), textMayChange=True, image=jarImage, scale=0.7, pos=(0.3, 0.0, 0.17)) purchaseModels.removeNode() del purchaseModels jarImage.removeNode() del jarImage self.messageLabel = DirectLabel(parent=self, relief=None, text='', text_align=TextNode.ALeft, text_wordwrap=16.0, text_scale=0.07, pos=(-0.52, 0.0, -0.1), textMayChange=True) self.doubledJellybeanLabel = DirectLabel( parent=self, relief=None, text=TTLocalizer.PartyRewardDoubledJellybean, text_align=TextNode.ACenter, text_wordwrap=12.0, text_scale=0.09, text_fg=(1.0, 0.125, 0.125, 1.0), pos=(0.0, 0.0, -0.465), textMayChange=False) self.doubledJellybeanLabel.hide() self.closeButton = DirectButton( parent=self, relief=None, text=TTLocalizer.PartyJellybeanRewardOK, text_align=TextNode.ACenter, text_scale=0.065, text_pos=(0.0, -0.625), geom=(publicPartyGui.find('**/startButton_up'), publicPartyGui.find('**/startButton_down'), publicPartyGui.find('**/startButton_rollover'), publicPartyGui.find('**/startButton_inactive')), geom_pos=(-0.39, 0.0, 0.125), command=self._close) publicPartyGui.removeNode() del publicPartyGui self.countSound = base.loader.loadSfx( 'phase_13/audio/sfx/tick_counter_short.ogg') self.overMaxSound = base.loader.loadSfx( 'phase_13/audio/sfx/tick_counter_overflow.ogg') return def showReward(self, earnedAmount, jarAmount, message): JellybeanRewardGui.notify.debug( 'showReward( earnedAmount=%d, jarAmount=%d, ...)' % (earnedAmount, jarAmount)) self.earnedCount = earnedAmount self.earnedLabel['text'] = str(self.earnedCount) self.jarCount = jarAmount self.jarMax = base.localAvatar.getMaxMoney() self.jarLabel['text'] = str(self.jarCount) self.jarLabel['text_fg'] = JellybeanRewardGui.JarLabelTextColor self.messageLabel['text'] = message if base.cr.newsManager.isHolidayRunning( ToontownGlobals.JELLYBEAN_DAY ) or base.cr.newsManager.isHolidayRunning( ToontownGlobals.JELLYBEAN_PARTIES_HOLIDAY ) or base.cr.newsManager.isHolidayRunning( ToontownGlobals.JELLYBEAN_PARTIES_HOLIDAY_MONTH): self.doubledJellybeanLabel.show() else: self.doubledJellybeanLabel.hide() self.unstash() taskMgr.doMethodLater(JellybeanRewardGui.PreCountdownDelay, self.transferOneJellybean, 'JellybeanRewardGuiTransferOneJellybean', extraArgs=[]) def transferOneJellybean(self): if self.earnedCount == 0: return self.earnedCount -= 1 self.earnedLabel['text'] = str(self.earnedCount) self.jarCount += 1 if self.jarCount <= self.jarMax: self.jarLabel['text'] = str(self.jarCount) else: if self.jarCount > self.jarMax: self.jarLabel[ 'text_fg'] = JellybeanRewardGui.JarLabelMaxedTextColor if self.jarCount <= self.jarMax: base.playSfx(self.countSound) else: base.playSfx(self.overMaxSound) taskMgr.doMethodLater(JellybeanRewardGui.CountDownRate, self.transferOneJellybean, 'JellybeanRewardGuiTransferOneJellybean', extraArgs=[]) def _close(self): taskMgr.remove('JellybeanRewardGuiTransferOneJellybean') self.stash() messenger.send(self.doneEvent) def destroy(self): taskMgr.remove('JellybeanRewardGuiTransferOneJellybean') del self.countSound del self.overMaxSound self.frame.destroy() self.earnedLabel.destroy() self.jarLabel.destroy() self.messageLabel.destroy() self.closeButton.destroy() DirectFrame.destroy(self)
class DistributedMaze(DistributedNodePathEntity): notify = DirectNotifyGlobal.directNotify.newCategory('DistributedMaze') ScheduleTaskName = 'mazeScheduler' RemoveBlocksDict = { 2: ('HedgeBlock_0_1', ), 4: (('HedgeBlock_0_1', 'HedgeBlock_1_3', 'HedgeBlock_2_3'), ('HedgeBlock_0_2', 'HedgeBlock_2_3', 'HedgeBlock_1_3'), ('HedgeBlock_0_1', 'HedgeBlock_0_2', 'HedgeBlock_1_3', 'HedgeBlock_2_3')) } def __init__(self, cr): DistributedNodePathEntity.__init__(self, cr) self.numSections = 0 self.GameDuration = 35.0 + self.numSections * 15.0 self.timer = None self.frame2D = None self.gameLabel = None self.gameStarted = 0 self.finished = 0 self.timedOut = 0 self.toonFinishedText = TTLocalizer.toonFinishedHedgeMaze self.toonEnteredText = TTLocalizer.enterHedgeMaze def announceGenerate(self): DistributedNodePathEntity.announceGenerate(self) self.addHints(self.roomHold) self.loadGui() def disable(self): DistributedNodePathEntity.disable(self) self.unloadGui() self.cleanupTimer() self.ignoreAll() def delete(self): self.cleanupTimer() DistributedNodePathEntity.delete(self) def setRoomDoId(self, roomDoId): self.roomDoId = roomDoId room = self.cr.doId2do.get(roomDoId) if room: self.gotRoom([room]) else: self.roomRequest = self.cr.relatedObjectMgr.requestObjects( [roomDoId], allCallback=self.gotRoom, timeout=5) def gotRoom(self, rooms): self.roomRequest = None room = rooms[0] self.roomHold = room rotations = [0, 0, 90, 90, 180, 180, 270, 270] self.getRng().shuffle(rotations) self.numSections = 0 for i in xrange(0, 4): maze = room.getGeom().find('**/Maze_Inside_%d' % i) if not maze.isEmpty(): self.numSections += 1 if rotations: maze.setH(rotations.pop()) self.GameDuration = 35.0 + self.numSections * 15.0 self.removeHedgeBlocks(room) def addHints(self, room): self.focusPoint = self.attachNewNode('GolfGreenGameFrame') hintList = room.getGeom().findAllMatches('**/dead*') for hint in hintList: self.actSphere = CollisionSphere(0, 0, 0, 7.0) self.actSphereNode = CollisionNode( 'mazegame_hint-%s-%s' % (self.level.getLevelId(), self.entId)) self.actSphereNode.addSolid(self.actSphere) self.actSphereNodePath = hint.attachNewNode(self.actSphereNode) self.actSphereNode.setCollideMask(WallBitmask) self.actSphere.setTangible(0) self.enterEvent = 'enter' + self.actSphereNode.getName() self.accept(self.enterEvent, self.__handleToonEnterHint) self.exitEvent = 'exit' + self.actSphereNode.getName() self.accept(self.exitEvent, self.__handleToonExitHint) enterance = room.getGeom().find('**/ENTRANCE') self.enterSphere = CollisionSphere(0, 0, 0, 8.0) self.enterSphereNode = CollisionNode( 'mazegame_enter-%s-%s' % (self.level.getLevelId(), self.entId)) self.enterSphereNode.addSolid(self.enterSphere) self.enterSphereNodePath = enterance.attachNewNode( self.enterSphereNode) self.enterSphereNode.setCollideMask(WallBitmask) self.enterSphere.setTangible(0) self.enteranceEvent = 'enter' + self.enterSphereNode.getName() self.accept(self.enteranceEvent, self.__handleToonEnterance) finish = room.getGeom().find('**/finish') self.finishSphere = CollisionSphere(0, 0, 0, 15.0) self.finishSphereNode = CollisionNode( 'mazegame_finish-%s-%s' % (self.level.getLevelId(), self.entId)) self.finishSphereNode.addSolid(self.finishSphere) self.finishSphereNodePath = finish.attachNewNode(self.finishSphereNode) self.finishSphereNode.setCollideMask(WallBitmask) self.finishSphere.setTangible(0) self.finishEvent = 'enter' + self.finishSphereNode.getName() self.accept(self.finishEvent, self.__handleToonFinish) def __handleToonEnterance(self, collEntry): if not self.gameStarted: self.notify.debug('sending clientTriggered for %d' % self.doId) self.sendUpdate('setClientTriggered', []) self.level.countryClub.showInfoText(self.toonEnteredText) def __handleToonFinish(self, collEntry): self.sendUpdate('setFinishedMaze', []) self.finished = 1 def __handleToonEnterHint(self, collEntry): camHeight = base.localAvatar.getClampedAvatarHeight() heightScaleFactor = camHeight * 0.3333333333 defLookAt = Point3(0.0, 1.5, camHeight) cameraPoint = Point3(0.0, -22.0 * heightScaleFactor, camHeight + 54.0) base.localAvatar.stopUpdateSmartCamera() base.localAvatar.startUpdateSmartCamera(push=0) base.localAvatar.setIdealCameraPos(cameraPoint) def __handleToonExitHint(self, collEntry): base.localAvatar.stopUpdateSmartCamera() base.localAvatar.startUpdateSmartCamera() base.localAvatar.setCameraPositionByIndex(base.localAvatar.cameraIndex) self.cameraHold = None def getRng(self): return random.Random(self.entId * self.doId) def removeHedgeBlocks(self, room): if self.numSections in self.RemoveBlocksDict: blocksToRemove = self.getRng().choice( self.RemoveBlocksDict[self.numSections]) for blockName in blocksToRemove: block = room.getGeom().find('**/%s' % blockName) if not block.isEmpty(): block.removeNode() def setGameStart(self, timestamp): self.notify.debug('%d setGameStart: Starting game' % self.doId) self.gameStartTime = globalClockDelta.networkToLocalTime(timestamp) self.gameStarted = True curGameTime = self.getCurrentGameTime() timeLeft = self.GameDuration - curGameTime self.cleanupTimer() self.timer = ToontownTimer.ToontownTimer() self.timer.posBelowTopRightCorner() self.timer.setTime(timeLeft) self.timer.countdown(timeLeft, self.timerExpired) self.startScheduleTask() self.frame2D.show() def setGameOver(self): self.timedOut = 1 if not self.finished: self.sendUpdate('damageMe', []) roomNum = self.level.roomNum club = self.level.countryClub self.gameOverTrack = Sequence() self.gameOverTrack.append(localAvatar.getTeleportOutTrack()) self.gameOverTrack.append( Func(localAvatar.setPos, self.finishSphereNodePath.getPos(render))) self.gameOverTrack.append(Func(localAvatar.play, 'jump')) self.gameOverTrack.append( Func(self.level.countryClub.camEnterRoom, roomNum)) self.gameOverTrack.start() self.timerExpired() def local2GameTime(self, timestamp): return timestamp - self.gameStartTime def game2LocalTime(self, timestamp): return timestamp + self.gameStartTime def getCurrentGameTime(self): return self.local2GameTime(globalClock.getFrameTime()) def startScheduleTask(self): taskMgr.add(self.scheduleTask, self.ScheduleTaskName) def stopScheduleTask(self): taskMgr.remove(self.ScheduleTaskName) def scheduleTask(self, task): curTime = self.getCurrentGameTime() def cleanupTimer(self): if self.timer: self.timer.stop() self.timer.destroy() self.timer = None def timerExpired(self): self.cleanupTimer() self.unloadGui() def loadGui(self): self.frame2D = DirectFrame(scale=1.0, pos=(0.0, 0, 0.9), relief=DGG.FLAT, parent=aspect2d, frameSize=(-0.3, 0.3, -0.05, 0.05), frameColor=(0.737, 0.573, 0.345, 0.3)) self.frame2D.hide() self.gameLabel = DirectLabel(parent=self.frame2D, relief=None, pos=(0, 0, 0), scale=1.0, text=TTLocalizer.mazeLabel, text_font=ToontownGlobals.getSignFont(), text0_fg=(1, 1, 1, 1), text_scale=0.075, text_pos=(0, -0.02)) def unloadGui(self): if self.frame2D: self.frame2D.destroy() self.frame2D = None if self.gameLabel: self.gameLabel.destroy() self.gameLabel = None def toonFinished(self, avId, place, lastToon): toon = base.cr.doId2do.get(avId) if toon and not self.timedOut: self.level.countryClub.showInfoText( self.toonFinishedText % (toon.getName(), TTLocalizer.hedgeMazePlaces[place])) if lastToon: self.setGameOver()
class LaffMeter(DirectFrame): deathColor = Vec4(0.58039216, 0.80392157, 0.34117647, 1.0) def __init__(self, avdna, hp, maxHp): DirectFrame.__init__(self, relief=None, sortOrder=50) self.initialiseoptions(LaffMeter) self.container = DirectFrame(parent=self, relief=None) self.style = avdna self.av = None self.hp = hp self.maxHp = maxHp self.__obscured = 0 if self.style.type == 't': self.isToon = 1 else: self.isToon = 0 self.load() return def obscure(self, obscured): self.__obscured = obscured if self.__obscured: self.hide() def isObscured(self): return self.__obscured def load(self): gui = loader.loadModel('phase_3/models/gui/laff_o_meter') if self.isToon: hType = self.style.getType() if hType == 'dog': headModel = gui.find('**/doghead') elif hType == 'cat': headModel = gui.find('**/cathead') elif hType == 'mouse': headModel = gui.find('**/mousehead') elif hType == 'horse': headModel = gui.find('**/horsehead') elif hType == 'rabbit': headModel = gui.find('**/bunnyhead') elif hType == 'duck': headModel = gui.find('**/duckhead') elif hType == 'monkey': headModel = gui.find('**/monkeyhead') elif hType == 'bear': headModel = gui.find('**/bearhead') elif hType == 'pig': headModel = gui.find('**/pighead') elif hType == 'deer': headModel = gui.find('**/deerhead') else: raise StandardError('unknown toon species: ', hType) self.color = self.style.getHeadColor() self.container['image'] = headModel self.container['image_color'] = self.color self.resetFrameSize() self.setScale(0.1) self.frown = DirectFrame(parent=self.container, relief=None, image=gui.find('**/frown')) self.frown.setY(-0.1) self.smile = DirectFrame(parent=self.container, relief=None, image=gui.find('**/smile')) self.eyes = DirectFrame(parent=self.container, relief=None, image=gui.find('**/eyes')) self.eyes.setY(-0.1) self.openSmile = DirectFrame(parent=self.container, relief=None, image=gui.find('**/open_smile')) self.openSmile.setY(-0.1) self.tooth1 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_1')) self.tooth2 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_2')) self.tooth3 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_3')) self.tooth4 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_4')) self.tooth5 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_5')) self.tooth6 = DirectFrame(parent=self.openSmile, relief=None, image=gui.find('**/tooth_6')) self.maxLabel = DirectLabel( parent=self.eyes, relief=None, pos=(0.442, 0, 0.051), text='120', text_scale=0.4, text_font=ToontownGlobals.getInterfaceFont()) self.maxLabel.setY(-0.1) self.hpLabel = DirectLabel( parent=self.eyes, relief=None, pos=(-0.398, 0, 0.051), text='120', text_scale=0.4, text_font=ToontownGlobals.getInterfaceFont()) self.hpLabel.setY(-0.1) self.teeth = [ self.tooth6, self.tooth5, self.tooth4, self.tooth3, self.tooth2, self.tooth1 ] for tooth in self.teeth: tooth.setY(-0.1) self.fractions = [0.0, 0.166666, 0.333333, 0.5, 0.666666, 0.833333] gui.removeNode() return def destroy(self): if self.av: ToontownIntervals.cleanup( self.av.uniqueName('laffMeterBoing') + '-' + str(self.this)) ToontownIntervals.cleanup( self.av.uniqueName('laffMeterBoing') + '-' + str(self.this) + '-play') self.ignore(self.av.uniqueName('hpChange')) del self.style del self.av del self.hp del self.maxHp if self.isToon: del self.frown del self.smile del self.openSmile del self.tooth1 del self.tooth2 del self.tooth3 del self.tooth4 del self.tooth5 del self.tooth6 del self.teeth del self.fractions del self.maxLabel del self.hpLabel DirectFrame.destroy(self) def adjustTeeth(self): if self.isToon: for i in range(len(self.teeth)): if self.hp > self.maxHp * self.fractions[i]: self.teeth[i].show() else: self.teeth[i].hide() def adjustText(self): if self.isToon: if self.maxLabel['text'] != str( self.maxHp) or self.hpLabel['text'] != str(self.hp): self.maxLabel['text'] = str(self.maxHp) self.hpLabel['text'] = str(self.hp) def animatedEffect(self, delta): if delta == 0 or self.av == None: return name = self.av.uniqueName('laffMeterBoing') + '-' + str(self.this) ToontownIntervals.cleanup(name) if delta > 0: ToontownIntervals.start( ToontownIntervals.getPulseLargerIval(self.container, name)) else: ToontownIntervals.start( ToontownIntervals.getPulseSmallerIval(self.container, name)) return def adjustFace(self, hp, maxHp, quietly=0): if self.isToon and self.hp != None: self.frown.hide() self.smile.hide() self.openSmile.hide() self.eyes.hide() for tooth in self.teeth: tooth.hide() delta = hp - self.hp self.hp = hp self.maxHp = maxHp if self.hp < 1: self.frown.show() self.container['image_color'] = self.deathColor elif self.hp >= self.maxHp: self.smile.show() self.eyes.show() self.container['image_color'] = self.color else: self.openSmile.show() self.eyes.show() self.maxLabel.show() self.hpLabel.show() self.container['image_color'] = self.color self.adjustTeeth() self.adjustText() if not quietly: self.animatedEffect(delta) return def start(self): if self.av: self.hp = self.av.hp self.maxHp = self.av.maxHp if self.isToon: if not self.__obscured: self.show() self.adjustFace(self.hp, self.maxHp, 1) if self.av: self.accept(self.av.uniqueName('hpChange'), self.adjustFace) def stop(self): if self.isToon: self.hide() if self.av: self.ignore(self.av.uniqueName('hpChange')) def setAvatar(self, av): if self.av: self.ignore(self.av.uniqueName('hpChange')) self.av = av