def destroy(self, autoDestroy = 1): if self.ival: self.ival.pause() self.ival = None if autoDestroy: BorderFrame.destroy(self)
def destroy(self): if self.showTask: taskMgr.remove(self.showTask) self.showTask = None self.snapShot = None BorderFrame.destroy(self)
def destroy(self): self.parent = None self.fromCell = None self.doubleFrame.destroy() self.tripleFrame.destroy() BorderFrame.destroy(self) return
def destroy(self, autoDestroy = 1): if self.ival: self.ival.pause() self.ival = None if autoDestroy: BorderFrame.destroy(self)
def destroy(self): if self.showTask: taskMgr.remove(self.showTask) self.showTask = None self.snapShot = None BorderFrame.destroy(self)
def destroy(self): base.localAvatar.guiMgr.setIgnoreMainMenuHotKey(True) base.localAvatar.guiMgr.setIgnoreAllKeys(False) base.localAvatar.guiMgr.hideSeaChest() base.localAvatar.guiMgr.setIgnoreMainMenuHotKey(False) self.ignoreAll() BorderFrame.destroy(self) if self.confirmDialog: self.confirmDialog.destroy() localAvatar.gameFSM.request('LandRoam')
def destroy(self): self.borderTwoSecondLayer.destroy() self.borderTwoSecondLayer = None self.borderTwo.destroy() self.borderTwo = None self.two.destroy() self.two = None self.secondLayer.destroy() self.secondLater = None self.game = None BorderFrame.destroy(self)
def destroy(self): base.localAvatar.guiMgr.setIgnoreMainMenuHotKey(True) base.localAvatar.guiMgr.setIgnoreAllKeys(False) base.localAvatar.guiMgr.hideSeaChest() base.localAvatar.guiMgr.setIgnoreMainMenuHotKey(False) self.ignoreAll() BorderFrame.destroy(self) if self.confirmDialog: self.confirmDialog.destroy() localAvatar.gameFSM.request('LandRoam')
def destroy(self): self.borderTwoSecondLayer.destroy() self.borderTwoSecondLayer = None self.borderTwo.destroy() self.borderTwo = None self.two.destroy() self.two = None self.secondLayer.destroy() self.secondLater = None self.game = None BorderFrame.destroy(self)
class TreasureMapRulesPanel: __module__ = __name__ def __init__(self, panelTitle, instructions, parent=base.a2dTopCenter, duration=8.0): self.panelTitle = panelTitle self.instructions = instructions self.showPanelIval = None self.duration = duration self.load(parent) return def load(self, parent=None): self.frame = BorderFrame(parent=parent, frameSize=(-0.55, 0.55, -0.125, 0.125), pos=(0, 0, -0.15)) self.panelTitleText = DirectLabel(parent=self.frame, relief=None, text=self.panelTitle, text_scale=0.07, text_align=TextNode.ACenter, text_font=PiratesGlobals.getPirateFont(), text_fg=PiratesGuiGlobals.TextFG1, text_shadow=(0, 0, 0, 1), pos=(0, 0, 0.025)) self.instructionsText = DirectLabel(parent=self.frame, relief=None, text=self.instructions, text_scale=0.05, text_align=TextNode.ACenter, text_wordwrap=40, text_fg=(1, 1, 1, 1), text_shadow=(0, 0, 0, 1), pos=(0, 0, -0.03)) self.frame.stash() self.openSfx = loadSfx(SoundGlobals.SFX_GUI_SHOW_PANEL) self.showPanelIval = Sequence(Wait(2.0), Func(self.frame.unstash), Func(base.playSfx, self.openSfx), LerpPosInterval(self.frame, 0.5, Point3(0, 0, -0.15), startPos=Point3(0, 0, 0.5), blendType='easeOut'), Wait(self.duration), LerpPosInterval(self.frame, 0.5, Point3(0, 0, 0.5), startPos=Point3(0, 0, -0.15), blendType='easeOut'), Func(self.frame.stash)) return def destroy(self): self.frame.destroy() taskMgr.remove('hideTMRulesTask') if self.showPanelIval: self.showPanelIval.pause() self.showPanelIval = None del self.openSfx del self.frame del self.panelTitleText del self.instructionsText return def setInstructions(self, instructions): self.instructionsText['text'] = instructions def show(self): self.frame.show() if self.showPanelIval.isPlaying(): self.showPanelIval.finish() self.showPanelIval.start() def hide(self, task=None): self.frame.stash()
class TreasureMapRulesPanel: def __init__(self, panelTitle, instructions, parent = base.a2dTopCenter, duration = 8.0): self.panelTitle = panelTitle self.instructions = instructions self.showPanelIval = None self.duration = duration self.load(parent) def load(self, parent = None): self.frame = BorderFrame(parent = parent, frameSize = (-0.55000000000000004, 0.55000000000000004, -0.125, 0.125), pos = (0, 0, -0.14999999999999999)) self.panelTitleText = DirectLabel(parent = self.frame, relief = None, text = self.panelTitle, text_scale = 0.070000000000000007, text_align = TextNode.ACenter, text_font = PiratesGlobals.getPirateFont(), text_fg = PiratesGuiGlobals.TextFG1, text_shadow = (0, 0, 0, 1), pos = (0, 0, 0.025000000000000001)) self.instructionsText = DirectLabel(parent = self.frame, relief = None, text = self.instructions, text_scale = 0.050000000000000003, text_align = TextNode.ACenter, text_wordwrap = 40, text_fg = (1, 1, 1, 1), text_shadow = (0, 0, 0, 1), pos = (0, 0, -0.029999999999999999)) self.frame.stash() self.openSfx = loadSfx(SoundGlobals.SFX_GUI_SHOW_PANEL) self.showPanelIval = Sequence(Wait(2.0), Func(self.frame.unstash), Func(base.playSfx, self.openSfx), LerpPosInterval(self.frame, 0.5, Point3(0, 0, -0.14999999999999999), startPos = Point3(0, 0, 0.5), blendType = 'easeOut'), Wait(self.duration), LerpPosInterval(self.frame, 0.5, Point3(0, 0, 0.5), startPos = Point3(0, 0, -0.14999999999999999), blendType = 'easeOut'), Func(self.frame.stash)) def destroy(self): self.frame.destroy() taskMgr.remove('hideTMRulesTask') if self.showPanelIval: self.showPanelIval.pause() self.showPanelIval = None del self.openSfx del self.frame del self.panelTitleText del self.instructionsText def setInstructions(self, instructions): self.instructionsText['text'] = instructions def show(self): self.frame.show() if self.showPanelIval.isPlaying(): self.showPanelIval.finish() self.showPanelIval.start() def hide(self, task = None): self.frame.stash()
def destroy(self): self.ignore('UpdateSellContainer') base.localAvatar.guiMgr.setIgnoreMainMenuHotKey(True) base.localAvatar.guiMgr.setIgnoreAllKeys(False) base.localAvatar.guiMgr.hideSeaChest() base.localAvatar.guiMgr.setIgnoreMainMenuHotKey(False) self.manager.releaseFromSale() if self.inventoryPanelSell: self.inventoryPanelSell.clearSale() if self.stackSeller: self.stackSeller.destroy() self.stackSeller = None if self.confirmDialog: self.confirmDialog.destroy() self.confirmDialog = None self.ignoreAll() localAvatar.enableLootUI() BorderFrame.destroy(self) return
def destroy(self): self.ignore("UpdateSellContainer") base.localAvatar.guiMgr.setIgnoreMainMenuHotKey(True) base.localAvatar.guiMgr.setIgnoreAllKeys(False) base.localAvatar.guiMgr.hideSeaChest() base.localAvatar.guiMgr.setIgnoreMainMenuHotKey(False) self.manager.releaseFromSale() if self.inventoryPanelSell: self.inventoryPanelSell.clearSale() if self.stackSeller: self.stackSeller.destroy() self.stackSeller = None if self.confirmDialog: self.confirmDialog.destroy() self.confirmDialog = None self.ignoreAll() localAvatar.enableLootUI() BorderFrame.destroy(self)
class PVPCompletePanel(BorderFrame): SUMMARY_PAGE = 1 DETAILS_PAGE = 2 def __init__(self, name, pvp): self.width = PiratesGuiGlobals.PVPCompletePanelWidth self.height = PiratesGuiGlobals.PVPCompletePanelHeight BorderFrame.__init__(self, frameSize = (self.width * 0.14999999999999999, self.width * 0.84999999999999998, self.height * 0.81999999999999995, self.height), modelName = 'pir_m_gui_frm_subframe', imageColorScale = VBase4(0.75, 0.75, 0.94999999999999996, 0.75)) self.secondLayer = BorderFrame(parent = self, relief = None, frameSize = (self.width * 0.14999999999999999, self.width * 0.84999999999999998, self.height * 0.81999999999999995, self.height), modelName = 'pir_m_gui_frm_subframe', imageColorScale = VBase4(0.75, 0.75, 0.90000000000000002, 0.75)) self.initialiseoptions(PVPCompletePanel) self.endButton = GuiButton(parent = self, text = PLocalizer.PVPExit, command = pvp.requestPVPLeave, pos = (1.25, 0, 0.10000000000000001), image = GuiButton.redGenericButton, image_scale = 0.59999999999999998) self.endButton.setBin('gui-popup', 0) self.name = name self.title = DirectLabel(parent = self, relief = None, text = name, text_align = TextNode.ACenter, text_scale = 0.070000000000000007, text_fg = PiratesGuiGlobals.TextFG1, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 1, pos = (1.25, 0, 1.6200000000000001)) if pvp.hasTeams(): team1Score = '0' team2Score = '0' for stat in pvp.scoreboardHolder.getItemList(): if stat['Team'] == 1: team1Score = stat['Score'] continue if stat['Team'] == 2: team2Score = stat['Score'] continue self.team1ScoreLabel = DirectLabel(parent = self, relief = None, text = PLocalizer.PVPTeamScore % (1, team1Score), text_align = TextNode.ACenter, text_scale = 0.040000000000000001, text_fg = PVPGlobals.getTeamColor(1), text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 1, pos = (1.05, 0, 1.55)) self.team2ScoreLabel = DirectLabel(parent = self, relief = None, text = PLocalizer.PVPTeamScore % (2, team2Score), text_align = TextNode.ACenter, text_scale = 0.040000000000000001, text_fg = PVPGlobals.getTeamColor(2), text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 1, pos = (1.45, 0, 1.55)) self.outcome = DirectLabel(parent = self, relief = None, text = '', text_align = TextNode.ACenter, text_scale = 0.059999999999999998, text_fg = PiratesGuiGlobals.TextFG1, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 1, pos = (1.25, 0, 1.45)) if pvp.hasTeams(): if team1Score > team2Score: self.outcome['text_fg'] = PVPGlobals.getTeamColor(1) elif team2Score > team1Score: self.outcome['text_fg'] = PVPGlobals.getTeamColor(2) self.borderTwo = BorderFrame(parent = self, relief = None, frameSize = (self.width * 0.14999999999999999, self.width * 0.84999999999999998, 0, self.height * 0.80000000000000004), modelName = 'pir_m_gui_frm_subframe', imageColorScale = VBase4(0.75, 0.75, 0.90000000000000002, 0.75)) self.borderTwoSecondLayer = BorderFrame(parent = self.borderTwo, relief = None, frameSize = (self.width * 0.14999999999999999, self.width * 0.84999999999999998, 0, self.height * 0.80000000000000004), modelName = 'pir_m_gui_frm_subframe', imageColorScale = VBase4(0.75, 0.75, 0.90000000000000002, 0.75)) self.two = ScoreFrame(PiratesGuiGlobals.PVPCompletePageWidth - 1.0, PiratesGuiGlobals.PVPCompletePageHeight, pvp.statsHolder, 0, sortOrder = 2) self.two.reparentTo(self.borderTwo) self.two.setPos(0.45000000000000001, 0, -0.14999999999999999) self.two.setup() self.game = pvp def setOutcome(self, outcome): self.outcome['text'] = outcome def destroy(self): self.borderTwoSecondLayer.destroy() self.borderTwoSecondLayer = None self.borderTwo.destroy() self.borderTwo = None self.two.destroy() self.two = None self.secondLayer.destroy() self.secondLater = None self.game = None BorderFrame.destroy(self)
class InventoryStackSeller(BorderFrame): def __init__(self, cell, parent): self.sizeX = 0.64000000000000001 self.sizeZ = 0.64000000000000001 textScale = PiratesGuiGlobals.TextScaleTitleSmall frameSize = (-0.0 * self.sizeX, 1.0 * self.sizeX, -0.0 * self.sizeZ, 1.0 * self.sizeZ) modelName = 'pir_m_gui_frm_subframe' imageColorScale = VBase4(0.75, 0.75, 0.90000000000000002, 1.0) optiondefs = (('state', DGG.DISABLED, None), ('frameSize', frameSize, None), ('modelName', modelName, None), ('imageColorScale', imageColorScale, None)) self.defineoptions({ }, optiondefs) BorderFrame.__init__(self, parent = NodePath()) self.initialiseoptions(InventoryStackSeller) self.doubleFrame = BorderFrame(parent = self, frameSize = frameSize, modelName = modelName, imageColorScale = imageColorScale) self.tripleFrame = BorderFrame(parent = self, frameSize = frameSize, modelName = modelName, imageColorScale = imageColorScale, text = PLocalizer.InventorySplitterTitle, text_align = TextNode.ACenter, text_font = PiratesGlobals.getPirateBoldOutlineFont(), text_fg = VBase4(1, 1, 1, 1), text_shadow = PiratesGuiGlobals.TextShadow, text_scale = textScale, text_pos = (self.sizeX * 0.5, self.sizeZ * 0.94999999999999996 - textScale)) self.fromCell = cell self.parent = parent self.amount = self.fromCell.inventoryItem.getAmount() self.setup() def setup(self): self.setBin('gui-fixed', 1) self.itemLabel = DirectLabel(parent = self, relief = None, text = '%s' % self.fromCell.inventoryItem.getName(), text_font = PiratesGlobals.getPirateBoldOutlineFont(), text_align = TextNode.ACenter, text_scale = PiratesGuiGlobals.TextScaleLarge, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, image = self.fromCell.inventoryItem['image'], image_scale = self.fromCell.inventoryItem['image_scale'], text_pos = (0.0, 0.066000000000000003), pos = (self.sizeX * 0.5, 0.0, self.sizeZ * 0.59999999999999998)) self.amountEntry = DirectEntry(parent = self, relief = DGG.GROOVE, scale = PiratesGuiGlobals.TextScaleExtraLarge, initialText = '%s' % self.amount, width = 1.5, numLines = 1, focus = 1, cursorKeys = 1, frameColor = (1.0, 1.0, 1.0, 0.20000000000000001), entryFont = PiratesGlobals.getPirateBoldOutlineFont(), text_fg = (1.0, 1.0, 1.0, 1.0), pos = (self.sizeX * 0.32500000000000001, 0.0, self.sizeZ * 0.35499999999999998), suppressKeys = 1, suppressMouse = 1, autoCapitalize = 0, command = self.selectStackAmount) self.amountLabel = DirectLabel(parent = self, relief = None, text = PLocalizer.InventorySellAmount % self.amount, text_font = PiratesGlobals.getPirateBoldOutlineFont(), text_align = TextNode.ACenter, text_scale = PiratesGuiGlobals.TextScaleExtraLarge, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_pos = (0.0, 0.066000000000000003), pos = (self.sizeX * 0.55000000000000004, 0.0, self.sizeZ * 0.25)) self.confirmButton = GuiButton.GuiButton(parent = self, text = PLocalizer.lOk, text_fg = PiratesGuiGlobals.TextFG2, text_pos = (0.0, -0.014), text_scale = PiratesGuiGlobals.TextScaleLarge, text_align = TextNode.ACenter, text_shadow = PiratesGuiGlobals.TextShadow, image = GuiButton.GuiButton.blueGenericButton, image_scale = (0.59999999999999998, 0.59999999999999998, 0.59999999999999998), pos = (self.sizeX * 0.25, 0, 0.10000000000000001), relief = None, command = self.selectStackAmount) self.cancelButton = GuiButton.GuiButton(parent = self, text = PLocalizer.lCancel, text_fg = PiratesGuiGlobals.TextFG2, text_pos = (0.0, -0.014), text_scale = PiratesGuiGlobals.TextScaleLarge, text_align = TextNode.ACenter, text_shadow = PiratesGuiGlobals.TextShadow, image = GuiButton.GuiButton.blueGenericButton, image_scale = (0.59999999999999998, 0.59999999999999998, 0.59999999999999998), pos = (self.sizeX * 0.75, 0, 0.10000000000000001), relief = None, command = self.cancelItem) def destroy(self): self.parent = None self.fromCell = None self.doubleFrame.destroy() self.tripleFrame.destroy() BorderFrame.destroy(self) def selectStackAmount(self, amount = None): if not amount: amount = self.amountEntry.get() if not amount or len(amount) == 0: base.localAvatar.guiMgr.createWarning(PLocalizer.InventorySellWarning, PiratesGuiGlobals.TextFG6) return None try: amount = int(amount) except: base.localAvatar.guiMgr.createWarning(PLocalizer.InventorySellWarning, PiratesGuiGlobals.TextFG6) return None if amount < 0 or amount > self.amount: base.localAvatar.guiMgr.createWarning(PLocalizer.InventorySellWarning, PiratesGuiGlobals.TextFG6) return None if amount == 0: self.cancelItem() return None else: self.parent.setStackAmount(self.fromCell, amount) self.destroy() def cancelItem(self): self.parent.cancelItem() self.destroy()
class PVPCompletePanel(BorderFrame): SUMMARY_PAGE = 1 DETAILS_PAGE = 2 def __init__(self, name, pvp): self.width = PiratesGuiGlobals.PVPCompletePanelWidth self.height = PiratesGuiGlobals.PVPCompletePanelHeight BorderFrame.__init__(self, frameSize=(self.width * 0.14999999999999999, self.width * 0.84999999999999998, self.height * 0.81999999999999995, self.height), modelName='pir_m_gui_frm_subframe', imageColorScale=VBase4(0.75, 0.75, 0.94999999999999996, 0.75)) self.secondLayer = BorderFrame( parent=self, relief=None, frameSize=(self.width * 0.14999999999999999, self.width * 0.84999999999999998, self.height * 0.81999999999999995, self.height), modelName='pir_m_gui_frm_subframe', imageColorScale=VBase4(0.75, 0.75, 0.90000000000000002, 0.75)) self.initialiseoptions(PVPCompletePanel) self.endButton = GuiButton(parent=self, text=PLocalizer.PVPExit, command=pvp.requestPVPLeave, pos=(1.25, 0, 0.10000000000000001), image=GuiButton.redGenericButton, image_scale=0.59999999999999998) self.endButton.setBin('gui-popup', 0) self.name = name self.title = DirectLabel(parent=self, relief=None, text=name, text_align=TextNode.ACenter, text_scale=0.070000000000000007, text_fg=PiratesGuiGlobals.TextFG1, text_shadow=PiratesGuiGlobals.TextShadow, textMayChange=1, pos=(1.25, 0, 1.6200000000000001)) if pvp.hasTeams(): team1Score = '0' team2Score = '0' for stat in pvp.scoreboardHolder.getItemList(): if stat['Team'] == 1: team1Score = stat['Score'] continue if stat['Team'] == 2: team2Score = stat['Score'] continue self.team1ScoreLabel = DirectLabel( parent=self, relief=None, text=PLocalizer.PVPTeamScore % (1, team1Score), text_align=TextNode.ACenter, text_scale=0.040000000000000001, text_fg=PVPGlobals.getTeamColor(1), text_shadow=PiratesGuiGlobals.TextShadow, textMayChange=1, pos=(1.05, 0, 1.55)) self.team2ScoreLabel = DirectLabel( parent=self, relief=None, text=PLocalizer.PVPTeamScore % (2, team2Score), text_align=TextNode.ACenter, text_scale=0.040000000000000001, text_fg=PVPGlobals.getTeamColor(2), text_shadow=PiratesGuiGlobals.TextShadow, textMayChange=1, pos=(1.45, 0, 1.55)) self.outcome = DirectLabel(parent=self, relief=None, text='', text_align=TextNode.ACenter, text_scale=0.059999999999999998, text_fg=PiratesGuiGlobals.TextFG1, text_shadow=PiratesGuiGlobals.TextShadow, textMayChange=1, pos=(1.25, 0, 1.45)) if pvp.hasTeams(): if team1Score > team2Score: self.outcome['text_fg'] = PVPGlobals.getTeamColor(1) elif team2Score > team1Score: self.outcome['text_fg'] = PVPGlobals.getTeamColor(2) self.borderTwo = BorderFrame( parent=self, relief=None, frameSize=(self.width * 0.14999999999999999, self.width * 0.84999999999999998, 0, self.height * 0.80000000000000004), modelName='pir_m_gui_frm_subframe', imageColorScale=VBase4(0.75, 0.75, 0.90000000000000002, 0.75)) self.borderTwoSecondLayer = BorderFrame( parent=self.borderTwo, relief=None, frameSize=(self.width * 0.14999999999999999, self.width * 0.84999999999999998, 0, self.height * 0.80000000000000004), modelName='pir_m_gui_frm_subframe', imageColorScale=VBase4(0.75, 0.75, 0.90000000000000002, 0.75)) self.two = ScoreFrame(PiratesGuiGlobals.PVPCompletePageWidth - 1.0, PiratesGuiGlobals.PVPCompletePageHeight, pvp.statsHolder, 0, sortOrder=2) self.two.reparentTo(self.borderTwo) self.two.setPos(0.45000000000000001, 0, -0.14999999999999999) self.two.setup() self.game = pvp def setOutcome(self, outcome): self.outcome['text'] = outcome def destroy(self): self.borderTwoSecondLayer.destroy() self.borderTwoSecondLayer = None self.borderTwo.destroy() self.borderTwo = None self.two.destroy() self.two = None self.secondLayer.destroy() self.secondLater = None self.game = None BorderFrame.destroy(self)
class AmmoSkillButton(SkillButton.SkillButton): def __init__(self, skillId, slotId, callback, quantity = 0, skillRank = 0, showQuantity = False, showHelp = False, showRing = False, hotkey = None, name = '', showIcon = True, showLock = False, rechargeSkillId = False, assocAmmo = []): if skillId in [ InventoryType.DefenseCannonRoundShot, InventoryType.DefenseCannonEmpty]: showQuantity = False if not Freebooter.getPaidStatus(base.localAvatar.doId) and slotId >= CannonDefenseGlobals.FREEBOOTER_MAX_AMMO_SLOTS: showLock = True SkillButton.SkillButton.__init__(self, skillId, callback, quantity, skillRank, showQuantity, showHelp, showRing, hotkey, name, showIcon, showLock, rechargeSkillId, assocAmmo) self.toggleFrame['image_scale'] = 0.55000000000000004 self.toolTipBox = None self.slotId = slotId self._initButtons() self.updateSkillId(skillId) def _initButtons(self): self.sellButtonModel = loader.loadModel('models/gui/pir_m_gui_can_buttonSell') self.sellButton = GuiButton(parent = self, image = (self.sellButtonModel.find('**/idle'), self.sellButtonModel.find('**/idle'), self.sellButtonModel.find('**/over')), image_scale = 1, scale = 0.40000000000000002, sortOrder = 100, pos = (0, 0, -0.125), command = self.onSellClick) self.sellButton.bind(DGG.ENTER, self.showToolTip) self.sellButton.bind(DGG.EXIT, self.hideToolTip) def updateSkillId(self, skillId): SkillButton.SkillButton.updateSkillId(self, skillId) if not hasattr(self, 'sellButton'): return None if skillId == InventoryType.DefenseCannonEmpty: self.sellButton['state'] = DGG.DISABLED self.sellButton.hide() if skillId == InventoryType.DefenseCannonEmpty: self.setShowIcon(False) else: self.sellButton['state'] = DGG.NORMAL self.sellButton.show() self.setShowIcon(True) def createToolTip(self): if self.toolTipBox: return None self.label = DirectLabel(parent = None, relief = None, text = PLocalizer.SellButton, text_align = TextNode.ALeft, text_scale = PiratesGuiGlobals.TextScaleLarge, text_fg = PiratesGuiGlobals.TextFG2, text_wordwrap = 12) height = -self.label.getHeight() width = self.label.getWidth() toolTipScale = 2.5 self.toolTipBox = None self.toolTipBox = BorderFrame(parent = self.sellButton, frameSize = (-0.01, width, height, 0.050000000000000003), scale = toolTipScale, pos = (-(width * toolTipScale * 0.5), 0, height * toolTipScale * 2.25), state = DGG.DISABLED) self.label.reparentTo(self.toolTipBox) def showToolTip(self, event): self.createToolTip() def hideToolTip(self, event): if self.toolTipBox: self.toolTipBox.destroy() self.toolTipBox = None def onSellClick(self): messenger.send('onSellClick', [ self.skillId])
class SongItemGui(SongListItem): width = PiratesGuiGlobals.InventoryItemGuiWidth height = PiratesGuiGlobals.InventoryItemGuiHeight available = True def __init__(self, data, trade = 0, buy = 0, sell = 0, use = 0, weapon = 0, isDisabled = 0, **kw): if (trade and buy and sell and use or weapon) and not isDisabled: buttonRelief = DGG.RAISED buttonState = DGG.NORMAL else: buttonRelief = DGG.RIDGE buttonState = DGG.DISABLED self.loadGui() optiondefs = (('relief', None, None), ('state', buttonState, None), ('frameSize', (0, self.width, 0, self.height), None), ('image', SongItemGui.genericButton, None), ('image_scale', (0.54000000000000004, 1, 0.41999999999999998), None), ('image_pos', (0.26000000000000001, 0, 0.080000000000000002), None), ('pressEffect', 0, None), ('command', self.sendEvents, None)) self.defineoptions(kw, optiondefs) SongListItem.__init__(self, data, trade = trade, buy = buy, sell = sell, use = use, weapon = weapon, isDisabled = isDisabled, width = self.width, height = self.height) self.initialiseoptions(SongItemGui) self.createGui() self.helpBox = None def loadGui(self): if SongItemGui.guiLoaded: return None SongListItem.loadGui(self) SongItemGui.genericButton = (SongListItem.topGui.find('**/generic_button'), SongListItem.topGui.find('**/generic_button_down'), SongListItem.topGui.find('**/generic_button_over'), SongListItem.topGui.find('**/generic_button_disabled')) def createGui(self): itemId = self.data[0] self.picture = DirectFrame(parent = self, relief = None, state = DGG.DISABLED, pos = (0.01, 0, 0.01)) self.nameTag = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = self.name, text_scale = PiratesGuiGlobals.TextScaleSmall * PLocalizer.getHeadingScale(2), text_align = TextNode.ALeft, text_fg = PiratesGuiGlobals.TextFG1, text_shadow = PiratesGuiGlobals.TextShadow, pos = (0.050000000000000003, 0, 0.105), text_font = PiratesGlobals.getInterfaceFont()) itemTypeFormatted = '' self.itemTypeName = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = itemTypeFormatted, text_scale = PiratesGuiGlobals.TextScaleSmall, text_align = TextNode.ALeft, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_font = PiratesGlobals.getInterfaceFont(), pos = (0.050000000000000003, 0, 0.065000000000000002)) self.miscText = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = '', text_scale = PiratesGuiGlobals.TextScaleSmall, text_align = TextNode.ALeft, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_wordwrap = 11, pos = (0.050000000000000003, 0, 0.025000000000000001)) if self.minLvl > 0: repId = WeaponGlobals.getRepId(itemId) if repId: self.checkLevel(repId, self.minLvl) trainingReq = EconomyGlobals.getItemTrainingReq(itemId) if trainingReq: self.checkTrainingReq(trainingReq) if EconomyGlobals.getItemCategory(itemId) == ItemType.AMMO: skillId = WeaponGlobals.getSkillIdForAmmoSkillId(itemId) self.checkSkillReq(skillId) if self.buy: self.checkPlayerInventory(itemId) self.costText = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, image = SongListItem.coinImage, image_scale = 0.12, image_pos = Vec3(-0.01, 0, 0.01), text = str(self.price), text_scale = PiratesGuiGlobals.TextScaleSmall, text_align = TextNode.ARight, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_wordwrap = 11, text_pos = (-0.029999999999999999, 0, 0), pos = (self.width - 0.035000000000000003, 0, 0.105), text_font = PiratesGlobals.getInterfaceFont()) if self.quantity and self.quantity > 1: self.quantityLabel = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = str(self.quantity), frameColor = (0, 0, 0, 1), frameSize = (-0.01, 0.02, -0.01, 0.025000000000000001), text_scale = 0.0275, text_align = TextNode.ACenter, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_wordwrap = 11, pos = (0.02, 0, 0.025000000000000001), text_font = PiratesGlobals.getPirateBoldOutlineFont()) itemClass = EconomyGlobals.getItemCategory(itemId) if itemClass == ItemType.WEAPON or itemClass == ItemType.POUCH: asset = EconomyGlobals.getItemIcons(itemId) if asset: self.picture['geom'] = SongItemGui.weaponIcons.find('**/%s*' % asset) self.picture['geom_scale'] = 0.11 self.picture['geom_pos'] = (0.080000000000000002, 0, 0.068000000000000005) elif itemClass == ItemType.CONSUMABLE: asset = EconomyGlobals.getItemIcons(itemId) if asset: self.picture['geom'] = SongItemGui.skillIcons.find('**/%s*' % asset) self.picture['geom_scale'] = 0.11 self.picture['geom_pos'] = (0.080000000000000002, 0, 0.068000000000000005) if not InventoryType.begin_WeaponCannonAmmo <= itemId or itemId <= InventoryType.end_WeaponCannonAmmo: if (InventoryType.begin_WeaponPistolAmmo <= itemId or itemId <= InventoryType.end_WeaponGrenadeAmmo or InventoryType.begin_WeaponDaggerAmmo <= itemId) and itemId <= InventoryType.end_WeaponDaggerAmmo: skillId = WeaponGlobals.getSkillIdForAmmoSkillId(itemId) if skillId: asset = WeaponGlobals.getSkillIcon(skillId) if asset: self.picture['geom'] = SongListItem.skillIcons.find('**/%s' % asset) self.picture['geom_scale'] = 0.14999999999999999 self.picture['geom_pos'] = (0.069000000000000006, 0, 0.069000000000000006) elif InventoryType.SmallBottle <= itemId and itemId <= InventoryType.LargeBottle: self.picture['geom'] = SongListItem.topGui.find('**/main_gui_ship_bottle') self.picture['geom_scale'] = 0.10000000000000001 self.picture['geom_pos'] = (0.069000000000000006, 0, 0.069000000000000006) self.flattenStrong() def checkLevel(self, repId, minLvl): inv = localAvatar.getInventory() if inv: repAmt = inv.getAccumulator(repId) if minLvl > ReputationGlobals.getLevelFromTotalReputation(repId, repAmt)[0]: self.highlightRed(PLocalizer.LevelRequirement % self.minLvl) def checkTrainingReq(self, trainingReq): inv = localAvatar.getInventory() if inv: amt = inv.getStackQuantity(trainingReq) if not amt: self.highlightRed(PLocalizer.TrainingRequirement) def checkSkillReq(self, skillId): if skillId: if base.localAvatar.getSkillQuantity(skillId) < 2: skillName = PLocalizer.getInventoryTypeName(skillId) self.highlightRed(PLocalizer.SkillRequirement % skillName) def checkPlayerInventory(self, itemId, extraQty = 0): if self.available: inventory = base.localAvatar.getInventory() currStock = inventory.getStackQuantity(itemId) currStockLimit = inventory.getStackLimit(itemId) if currStock == 0: if base.cr.newsManager.getHoliday(21): pass if not (itemId in InventoryType.WinterHolidaySongs): self.name = PLocalizer.makeHeadingString(PLocalizer.SongTitleUnknown, 2) self.nameTag['text'] = PLocalizer.makeHeadingString(PLocalizer.SongTitleUnknown, 2) self.itemTypeName['text'] = PLocalizer.makeHeadingString(PLocalizer.SongComingSoon, 1) self.disable() not (itemId in InventoryType.WinterHolidaySongs) def highlightRed(self, text = ''): self['state'] = DGG.DISABLED self['image_color'] = Vec4(0.55000000000000004, 0.55000000000000004, 0.5, 1) self.available = False self.highlightBox(text, Vec4(0.75, 0.5, 0.5, 1), PiratesGuiGlobals.TextFG6) def highlightGreen(self, text = ''): self.highlightBox(text, Vec4(0.5, 0.75, 0.5, 1), PiratesGuiGlobals.TextFG4) def highlightBox(self, text, image_color, text_fg): self.miscText['text_fg'] = text_fg if text != '': self.miscText['text'] = text def enable(self): if self.available: self['state'] = DGG.NORMAL def disable(self): if self.available: self['state'] = DGG.DISABLED def createHelpbox(self, args = None): if self.helpBox: return None weaponInfo = PLocalizer.WeaponDescriptions.get(self.data[0]) weaponDesc = weaponInfo self.helpText = DirectFrame(parent = self, relief = None, text = weaponDesc, state = DGG.DISABLED, text_align = TextNode.ALeft, text_scale = PiratesGuiGlobals.TextScaleSmall, text_fg = PiratesGuiGlobals.TextFG2, text_wordwrap = 13, textMayChange = 0, sortOrder = 91) height = -self.helpText.getHeight() self.helpBox = BorderFrame(parent = aspect2d, state = DGG.DISABLED, frameSize = (-0.029999999999999999, 0.42999999999999999, height, 0.050000000000000003), sortOrder = 90, borderScale = 0.20000000000000001) self.helpText.reparentTo(self.helpBox) self.helpBox.setBin('gui-popup', 0) self.helpBox.setPos(self, 0.25, 0, -0.035000000000000003) def destroy(self): taskMgr.remove('helpInfoTask') taskMgr.remove(self.taskName('dragTask')) if self.helpBox: self.helpBox.destroy() self.helpBox = None del self.picture if self.weapon: taskMgr.remove(DGG.B1PRESS) taskMgr.remove(DGG.B2PRESS) taskMgr.remove(DGG.B3PRESS) SongListItem.destroy(self) def setDraggable(self, d): self.draggable = d def dragStart(self, event): self.origionalPos = self.getPos(render2d) self.origionalParent = self.getParent() self.bringToFront() self.setColorScale(1, 1, 1, 0.5) if self.draggable: self.wrtReparentTo(aspect2d) taskMgr.remove(self.taskName('dragTask')) vWidget2render2d = self.getPos(render2d) vMouse2render2d = Point3(event.getMouse()[0], 0, event.getMouse()[1]) editVec = Vec3(vWidget2render2d - vMouse2render2d) task = taskMgr.add(self.dragTask, self.taskName('dragTask')) task.editVec = editVec def dragTask(self, task): if task.time < PiratesGuiGlobals.DragStartDelayTime: return Task.cont else: mwn = base.mouseWatcherNode if mwn.hasMouse(): vMouse2render2d = Point3(mwn.getMouse()[0], 0, mwn.getMouse()[1]) newPos = vMouse2render2d + task.editVec self.setPos(render2d, newPos) newPos = self.getPos(aspect2d) x = newPos[0] z = newPos[2] x = x - x % 0.050000000000000003 z = z - z % 0.050000000000000003 x = min(1.3 - self.width, max(-1.3, x)) z = min(1 - self.height, max(-1, z)) self.setPos(aspect2d, x, 0.0, z) return Task.cont def dragStop(self, event): self.clearColorScale() self.wrtReparentTo(self.origionalParent) self.setPos(render2d, self.origionalPos) if self.draggable: taskMgr.remove(self.taskName('dragTask')) def showDetails(self, event): taskMgr.doMethodLater(PiratesGuiGlobals.HelpPopupTime, self.createHelpbox, 'helpInfoTask') self.createHelpbox() def hideDetails(self, event): taskMgr.remove('helpInfoTask') if self.helpBox: self.helpBox.destroy() self.helpBox = None
class InventoryItemGui(InventoryListItem): width = PiratesGuiGlobals.InventoryItemGuiWidth height = PiratesGuiGlobals.InventoryItemGuiHeight available = True def __init__(self, data, trade = 0, buy = 0, sell = 0, use = 0, weapon = 0, isDisabled = 0, **kw): if (trade and buy and sell and use or weapon) and not isDisabled: buttonRelief = DGG.RAISED buttonState = DGG.NORMAL else: buttonRelief = DGG.RIDGE buttonState = DGG.DISABLED self.loadGui() optiondefs = (('relief', None, None), ('state', buttonState, None), ('frameSize', (0, self.width, 0, self.height), None), ('image', InventoryItemGui.genericButton, None), ('image_scale', (0.54000000000000004, 1, 0.41999999999999998), None), ('image_pos', (0.26000000000000001, 0, 0.080000000000000002), None), ('pressEffect', 0, None), ('command', self.sendEvents, None)) self.defineoptions(kw, optiondefs) InventoryListItem.__init__(self, data, trade = trade, buy = buy, sell = sell, use = use, weapon = weapon, isDisabled = isDisabled, width = self.width, height = self.height) self.initialiseoptions(InventoryItemGui) self.createGui() self.draggable = abs(self.buy) + abs(self.sell) + abs(self.use) + abs(self.trade) - 1 if self.draggable > 0: self.bind(DGG.B1PRESS, self.dragStart) self.bind(DGG.B1RELEASE, self.dragStop) self.bind(DGG.B2PRESS, self.dragStart) self.bind(DGG.B2RELEASE, self.dragStop) self.bind(DGG.B3PRESS, self.dragStart) self.bind(DGG.B3RELEASE, self.dragStop) if self.weapon: self.bind(DGG.B1PRESS, self.equipWeapon) self.bind(DGG.B2PRESS, self.equipWeapon) self.bind(DGG.B3PRESS, self.equipWeapon) self.helpFrame = None self.cm = CardMaker('itemCard') self.cm.setFrame(-0.29999999999999999, 0.29999999999999999, -0.089999999999999997, 0.089999999999999997) self.buffer = None self.lens = PerspectiveLens() self.lens.setNear(0.5) self.lens.setAspectRatio(0.59999999999999998 / 0.17999999999999999) self.realItem = None self.itemCard = None self.portraitSceneGraph = NodePath('PortraitSceneGraph') detailGui = loader.loadModel('models/gui/gui_card_detail') self.bg = detailGui.find('**/color') self.bg.setScale(4) self.bg.setPos(0, 17, -6.2999999999999998) self.glow = detailGui.find('**/glow') self.glow.setScale(3) self.glow.setPos(0, 17, -6.2999999999999998) self.glow.setColor(1, 1, 1, 0.80000000000000004) self.setBin('gui-fixed', 1) self.accept('open_main_window', self.createBuffer) self.accept('aspectRatioChanged', self.createBuffer) self.accept('close_main_window', self.destroyBuffer) self.bind(DGG.ENTER, self.showDetails) self.bind(DGG.EXIT, self.hideDetails) def loadGui(self): if InventoryItemGui.guiLoaded: return None InventoryListItem.loadGui(self) InventoryItemGui.genericButton = (InventoryListItem.topGui.find('**/generic_button'), InventoryListItem.topGui.find('**/generic_button_down'), InventoryListItem.topGui.find('**/generic_button_over'), InventoryListItem.topGui.find('**/generic_button_disabled')) def createGui(self): itemId = self.data[0] self.nameTag = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = self.name, text_scale = PiratesGuiGlobals.TextScaleSmall * PLocalizer.getHeadingScale(2), text_align = TextNode.ALeft, text_fg = PiratesGuiGlobals.TextFG1, text_shadow = PiratesGuiGlobals.TextShadow, pos = (0.16, 0, 0.105), text_font = PiratesGlobals.getInterfaceFont()) if itemId in range(InventoryType.begin_PistolPouches, InventoryType.end_PistolPouches): self.itemTypeFormatted = PLocalizer.makeHeadingString(PLocalizer.InventoryItemClassNames.get(ItemType.PISTOL), 1) elif itemId in range(InventoryType.begin_DaggerPouches, InventoryType.end_DaggerPouches): self.itemTypeFormatted = PLocalizer.makeHeadingString(PLocalizer.InventoryItemClassNames.get(ItemType.DAGGER), 1) elif itemId in range(InventoryType.begin_GrenadePouches, InventoryType.end_GrenadePouches): self.itemTypeFormatted = PLocalizer.makeHeadingString(PLocalizer.GrenadeShort, 1) elif itemId in range(InventoryType.begin_CannonPouches, InventoryType.end_CannonPouches): self.itemTypeFormatted = PLocalizer.makeHeadingString(PLocalizer.ShipCannonShort, 1) else: self.itemTypeFormatted = PLocalizer.makeHeadingString(self.itemType, 1) self.itemTypeName = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = self.itemTypeFormatted, text_scale = PiratesGuiGlobals.TextScaleSmall, text_align = TextNode.ALeft, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_font = PiratesGlobals.getInterfaceFont(), pos = (0.16, 0, 0.065000000000000002)) self.miscText = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = '', text_scale = PiratesGuiGlobals.TextScaleSmall, text_align = TextNode.ALeft, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_wordwrap = 11, pos = (0.16, 0, 0.025000000000000001)) if self.minLvl > 0: repId = WeaponGlobals.getRepId(itemId) if repId: self.checkLevel(repId, self.minLvl) self.checkFreebooter(itemId, base.localAvatar.getDoId()) trainingReq = EconomyGlobals.getItemTrainingReq(itemId) if trainingReq: self.checkTrainingReq(trainingReq) if EconomyGlobals.getItemCategory(itemId) == ItemType.AMMO: skillId = WeaponGlobals.getSkillIdForAmmoSkillId(itemId) self.checkSkillReq(skillId) self.checkInfamyReq(itemId) if self.buy: self.checkPlayerInventory(itemId) self.costText = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, image = InventoryListItem.coinImage, image_scale = 0.12, image_pos = Vec3(-0.01, 0, 0.01), text = str(self.price), text_scale = PiratesGuiGlobals.TextScaleSmall, text_align = TextNode.ARight, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_wordwrap = 11, text_pos = (-0.029999999999999999, 0, 0), pos = (self.width - 0.035000000000000003, 0, 0.065000000000000002), text_font = PiratesGlobals.getInterfaceFont()) if self.quantity and self.quantity > 1: self.quantityLabel = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = str(self.quantity), frameColor = (0, 0, 0, 1), frameSize = (-0.01, 0.02, -0.01, 0.025000000000000001), text_scale = 0.0275, text_align = TextNode.ACenter, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_wordwrap = 11, pos = (0.02, 0, 0.025000000000000001), text_font = PiratesGlobals.getPirateBoldOutlineFont()) geomParams = InventoryItemGui.getGeomParams(itemId) self.picture = DirectFrame(parent = self, relief = None, state = DGG.DISABLED, geom = geomParams['geom'], geom_pos = geomParams['geom_pos'], geom_scale = geomParams['geom_scale'], pos = (0.01, 0, 0.01)) self.flattenStrong() def getGeomParams(itemId): geomParams = { } itemType = EconomyGlobals.getItemType(itemId) if itemType <= ItemType.WAND or itemType == ItemType.POTION: if itemType == ItemType.POTION: geomParams['geom'] = InventoryItemGui.skillIcons.find('**/%s' % ItemGlobals.getIcon(itemId)) else: itemType = ItemGlobals.getType(itemId) if ItemGlobals.getIcon(itemId): geomParams['geom'] = InventoryItemGui.weaponIcons.find('**/%s' % ItemGlobals.getIcon(itemId)) geomParams['geom_scale'] = 0.11 geomParams['geom_pos'] = (0.080000000000000002, 0, 0.068000000000000005) else: itemClass = EconomyGlobals.getItemCategory(itemId) itemType = EconomyGlobals.getItemType(itemId) if itemType == ItemType.FISHING_ROD or itemType == ItemType.FISHING_LURE: asset = EconomyGlobals.getItemIcons(itemId) if asset: geomParams['geom'] = InventoryItemGui.fishingIcons.find('**/%s*' % asset) geomParams['geom_scale'] = 0.11 geomParams['geom_pos'] = (0.080000000000000002, 0, 0.068000000000000005) elif itemClass == ItemType.WEAPON and itemClass == ItemType.POUCH or itemClass == ItemType.AMMO: asset = EconomyGlobals.getItemIcons(itemId) if asset: geomParams['geom'] = InventoryItemGui.weaponIcons.find('**/%s*' % asset) geomParams['geom_scale'] = 0.11 geomParams['geom_pos'] = (0.080000000000000002, 0, 0.068000000000000005) elif itemClass == ItemType.CONSUMABLE: asset = EconomyGlobals.getItemIcons(itemId) if asset: geomParams['geom'] = InventoryItemGui.skillIcons.find('**/%s*' % asset) geomParams['geom_scale'] = 0.11 geomParams['geom_pos'] = (0.080000000000000002, 0, 0.068000000000000005) if not InventoryType.begin_WeaponCannonAmmo <= itemId or itemId <= InventoryType.end_WeaponCannonAmmo: if (InventoryType.begin_WeaponPistolAmmo <= itemId or itemId <= InventoryType.end_WeaponGrenadeAmmo or InventoryType.begin_WeaponDaggerAmmo <= itemId) and itemId <= InventoryType.end_WeaponDaggerAmmo: skillId = WeaponGlobals.getSkillIdForAmmoSkillId(itemId) if skillId: asset = WeaponGlobals.getSkillIcon(skillId) if asset: geomParams['geom'] = InventoryListItem.skillIcons.find('**/%s' % asset) geomParams['geom_scale'] = 0.14999999999999999 geomParams['geom_pos'] = (0.069000000000000006, 0, 0.069000000000000006) elif InventoryType.SmallBottle <= itemId and itemId <= InventoryType.LargeBottle: geomParams['geom'] = InventoryListItem.topGui.find('**/main_gui_ship_bottle') geomParams['geom_scale'] = 0.10000000000000001 geomParams['geom_pos'] = (0.069000000000000006, 0, 0.069000000000000006) return geomParams getGeomParams = staticmethod(getGeomParams) def checkFreebooter(self, itemId, avId): if ItemGlobals.getRarity(itemId) == ItemGlobals.CRUDE: return None if not InventoryType.begin_WeaponCannonAmmo <= itemId or itemId <= InventoryType.end_WeaponCannonAmmo: if (InventoryType.begin_WeaponPistolAmmo <= itemId or itemId <= InventoryType.end_WeaponGrenadeAmmo or InventoryType.begin_WeaponDaggerAmmo <= itemId) and itemId <= InventoryType.end_WeaponDaggerAmmo: return None if itemId in [ InventoryType.RegularLure]: return None if not Freebooter.getPaidStatus(avId): self.highlightRed(PLocalizer.FreebooterDisallow) def checkLevel(self, repId, minLvl): inv = localAvatar.getInventory() if inv: repAmt = inv.getAccumulator(repId) if minLvl > ReputationGlobals.getLevelFromTotalReputation(repId, repAmt)[0]: self.highlightRed(PLocalizer.LevelRequirement % self.minLvl + ' ' + PLocalizer.InventoryItemClassNames.get(EconomyGlobals.getItemType(self.data[0]))) def checkTrainingReq(self, trainingReq): inv = localAvatar.getInventory() if inv: amt = inv.getStackQuantity(trainingReq) if not amt: self.highlightRed(PLocalizer.TrainingRequirement) def checkSkillReq(self, skillId): if skillId in range(InventoryType.begin_FishingLures, InventoryType.end_FishingLures): return None if skillId: if base.localAvatar.getSkillQuantity(skillId) < 2: skillName = PLocalizer.getInventoryTypeName(skillId) self.highlightRed(PLocalizer.SkillRequirement % skillName) def checkInfamyReq(self, itemId): landInfamyLevel = ItemGlobals.getLandInfamyRequirement(itemId) seaInfamyLevel = ItemGlobals.getSeaInfamyRequirement(itemId) if landInfamyLevel and TitleGlobals.getRank(TitleGlobals.LandPVPTitle, localAvatar.getInfamyLand()) < landInfamyLevel: self.highlightRed(PLocalizer.LandInfamyRequirement % landInfamyLevel) if seaInfamyLevel and TitleGlobals.getRank(TitleGlobals.ShipPVPTitle, localAvatar.getInfamySea()) < seaInfamyLevel: self.highlightRed(PLocalizer.SeaInfamyRequirement % seaInfamyLevel) def checkPlayerInventory(self, itemId, extraQty = 0): if self.available: itemCategory = EconomyGlobals.getItemCategory(itemId) inventory = base.localAvatar.getInventory() currStock = inventory.getStackQuantity(itemId) currStockLimit = inventory.getStackLimit(itemId) if itemCategory == ItemType.AMMO or itemCategory == ItemType.CONSUMABLE: if currStock + extraQty >= currStockLimit and currStockLimit > 0: self.highlightGreen(PLocalizer.InventoryFull % currStockLimit) else: self.highlightBox(PLocalizer.InventoryCurrent % (currStock + extraQty, currStockLimit), Vec4(1, 1, 1, 1), PiratesGuiGlobals.TextFG2) elif itemCategory == ItemType.WEAPON: if currStock >= 1: self.highlightGreen(PLocalizer.InventoryOwned) else: inv = base.localAvatar.getInventory() if inv is None: return None itemRep = WeaponGlobals.getRepId(itemId) if itemRep == InventoryType.CutlassRep: options = [ InventoryType.CutlassWeaponL1, InventoryType.CutlassWeaponL2, InventoryType.CutlassWeaponL3, InventoryType.CutlassWeaponL4, InventoryType.CutlassWeaponL5, InventoryType.CutlassWeaponL6] elif itemRep == InventoryType.PistolRep: options = [ InventoryType.PistolWeaponL1, InventoryType.PistolWeaponL2, InventoryType.PistolWeaponL3, InventoryType.PistolWeaponL4, InventoryType.PistolWeaponL5, InventoryType.PistolWeaponL6] elif itemRep == InventoryType.DaggerRep: options = [ InventoryType.DaggerWeaponL1, InventoryType.DaggerWeaponL2, InventoryType.DaggerWeaponL3, InventoryType.DaggerWeaponL4, InventoryType.DaggerWeaponL5, InventoryType.DaggerWeaponL6] elif itemRep == InventoryType.GrenadeRep: options = [ InventoryType.GrenadeWeaponL1, InventoryType.GrenadeWeaponL2, InventoryType.GrenadeWeaponL3, InventoryType.GrenadeWeaponL4, InventoryType.GrenadeWeaponL5, InventoryType.GrenadeWeaponL6] elif itemRep == InventoryType.DollRep: options = [ InventoryType.DollWeaponL1, InventoryType.DollWeaponL2, InventoryType.DollWeaponL3, InventoryType.DollWeaponL4, InventoryType.DollWeaponL5, InventoryType.DollWeaponL6] elif itemRep == InventoryType.WandRep: options = [ InventoryType.WandWeaponL1, InventoryType.WandWeaponL2, InventoryType.WandWeaponL3, InventoryType.WandWeaponL4, InventoryType.WandWeaponL5, InventoryType.WandWeaponL6] else: return None for idx in range(len(options)): optionId = options[idx] if optionId == itemId: currIdx = idx for weaponId in options[currIdx:]: if weaponId == itemId: continue stackAmt = inv.getStackQuantity(weaponId) if stackAmt >= 1: self.highlightRed(PLocalizer.InventoryLowLevel) return None continue elif itemCategory == ItemType.POUCH: inv = base.localAvatar.getInventory() if currStock >= 1: self.highlightGreen(PLocalizer.InventoryOwned) else: pistolPouches = [ InventoryType.PistolPouchL1, InventoryType.PistolPouchL2, InventoryType.PistolPouchL3] daggerPouches = [ InventoryType.DaggerPouchL1, InventoryType.DaggerPouchL2, InventoryType.DaggerPouchL3] grenadePouches = [ InventoryType.GrenadePouchL1, InventoryType.GrenadePouchL2, InventoryType.GrenadePouchL3] cannonPouches = [ InventoryType.CannonPouchL1, InventoryType.CannonPouchL2, InventoryType.CannonPouchL3] if itemId in pistolPouches: pouchSet = pistolPouches elif itemId in daggerPouches: pouchSet = daggerPouches elif itemId in grenadePouches: pouchSet = grenadePouches elif itemId in cannonPouches: pouchSet = cannonPouches else: pouchSet = [] for pouchIdx in range(len(pouchSet)): if pouchSet[pouchIdx] == itemId and pouchIdx + 1 < len(pouchSet): for higherPouchIdx in range(pouchIdx + 1, len(pouchSet)): stackAmt = inv.getStackQuantity(pouchSet[higherPouchIdx]) if stackAmt >= 1: self.highlightRed(PLocalizer.InventoryLowLevel) return None continue def highlightRed(self, text = ''): self['state'] = DGG.DISABLED self['image_color'] = Vec4(0.55000000000000004, 0.55000000000000004, 0.5, 1) self.available = False self.highlightBox(text, Vec4(0.75, 0.5, 0.5, 1), PiratesGuiGlobals.TextFG6) def highlightGreen(self, text = ''): self.highlightBox(text, Vec4(0.5, 0.75, 0.5, 1), PiratesGuiGlobals.TextFG4) def highlightBox(self, text, image_color, text_fg): self.miscText['text_fg'] = text_fg if text != '': self.miscText['text'] = text def enable(self): if self.available: self['state'] = DGG.NORMAL def disable(self): if self.available: self['state'] = DGG.DISABLED def createHelpbox(self, args = None): if self.helpFrame: return None itemType = EconomyGlobals.getItemType(self.data[0]) if itemType <= ItemType.WAND or itemType == ItemType.POTION: itemId = self.data[0] self.helpFrame = DirectFrame(parent = aspect2d, relief = None, state = DGG.DISABLED, sortOrder = 1) detailGui = loader.loadModel('models/gui/gui_card_detail') topGui = loader.loadModel('models/gui/toplevel_gui') coinImage = topGui.find('**/treasure_w_coin*') self.SkillIcons = loader.loadModel('models/textureCards/skillIcons') self.BuffIcons = loader.loadModel('models/textureCards/buff_icons') border = self.SkillIcons.find('**/base') halfWidth = 0.29999999999999999 halfHeight = 0.20000000000000001 textScale = PiratesGuiGlobals.TextScaleMed titleScale = PiratesGuiGlobals.TextScaleTitleSmall titleNameScale = PiratesGuiGlobals.TextScaleExtraLarge subtitleScale = PiratesGuiGlobals.TextScaleMed iconScalar = 1.5 borderScaler = 0.25 splitHeight = 0.01 vMargin = 0.029999999999999999 runningVertPosition = 0.29999999999999999 runningSize = 0.0 labels = [] titleColor = PiratesGuiGlobals.TextFG6 itemColor = 'itemRed' rarity = ItemGlobals.getRarity(itemId) rarityText = PLocalizer.getItemRarityName(rarity) subtypeText = PLocalizer.getItemSubtypeName(ItemGlobals.getSubtype(itemId)) if rarity == ItemGlobals.CRUDE: titleColor = PiratesGuiGlobals.TextFG24 itemColor = 'itemBrown' elif rarity == ItemGlobals.COMMON: titleColor = PiratesGuiGlobals.TextFG13 itemColor = 'itemYellow' elif rarity == ItemGlobals.RARE: titleColor = PiratesGuiGlobals.TextFG4 itemColor = 'itemGreen' elif rarity == ItemGlobals.FAMED: titleColor = PiratesGuiGlobals.TextFG5 itemColor = 'itemBlue' titleLabel = DirectLabel(parent = self, relief = None, text = PLocalizer.getItemName(itemId), text_scale = titleNameScale, text_fg = titleColor, text_shadow = PiratesGuiGlobals.TextShadow, text_align = TextNode.ACenter, pos = (0.0, 0.0, runningVertPosition), text_pos = (0.0, -textScale)) self.bg.setColor(titleColor) tHeight = 0.070000000000000007 titleLabel.setZ(runningVertPosition) runningVertPosition -= tHeight runningSize += tHeight labels.append(titleLabel) subtitleLabel = DirectLabel(parent = self, relief = None, text = '\x01slant\x01%s %s\x02' % (rarityText, subtypeText), text_scale = subtitleScale, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_align = TextNode.ACenter, pos = (0.0, 0.0, runningVertPosition), text_pos = (0.0, -textScale)) subtHeight = 0.050000000000000003 subtitleLabel.setZ(subtHeight * 0.5 + runningVertPosition) runningVertPosition -= subtHeight runningSize += subtHeight labels.append(subtitleLabel) itemType = ItemGlobals.getType(itemId) itemSubtype = ItemGlobals.getSubtype(itemId) model = ItemGlobals.getModel(itemId) if model: if itemType == ItemGlobals.GRENADE: self.realItem = loader.loadModel('models/ammunition/' + model) elif itemType == ItemGlobals.POTION: self.realItem = loader.loadModel('models/inventory/' + model) else: self.realItem = loader.loadModel('models/handheld/' + model) if self.realItem: spinBlur = self.realItem.find('**/motion_blur') if spinBlur: spinBlur.hide() if itemSubtype == ItemGlobals.MUSKET: bayonetPart = self.realItem.find('**/bayonet') if bayonetPart: bayonetPart.stash() posHpr = ItemGlobals.getModelPosHpr(model) if posHpr: self.realItem.setPos(posHpr[0], posHpr[1], posHpr[2]) self.realItem.setHpr(posHpr[3], posHpr[4], posHpr[5]) elif itemType == ItemGlobals.SWORD: self.realItem.setPos(-1.5, 3.0, -0.29999999999999999) self.realItem.setHpr(90, 170, -90) elif itemSubtype in (ItemGlobals.MUSKET, ItemGlobals.BAYONET): self.realItem.setPos(-1.2, 3.0, -0.10000000000000001) self.realItem.setHpr(0, 135, 10) elif itemSubtype == ItemGlobals.BLUNDERBUSS: self.realItem.setPos(-0.29999999999999999, 2.0, 0.0) self.realItem.setHpr(0, 90, 0) elif itemType == ItemGlobals.GUN: self.realItem.setPos(-0.5, 2.0, -0.20000000000000001) self.realItem.setHpr(0, 90, 0) elif itemType == ItemGlobals.DOLL: self.realItem.setPos(0.0, 1.8999999999999999, -0.10000000000000001) self.realItem.setHpr(0, 90, 180) elif itemType == ItemGlobals.DAGGER: self.realItem.setPos(-1.0, 2.0, -0.29999999999999999) self.realItem.setHpr(90, 170, -90) elif itemType == ItemGlobals.GRENADE: self.realItem.setPos(0.0, 3.5, -0.20000000000000001) self.realItem.setHpr(0, 0, 0) elif itemType == ItemGlobals.STAFF: self.realItem.setPos(-0.40000000000000002, 3.0, -0.29999999999999999) self.realItem.setHpr(-90, 15, -90) elif itemSubtype == ItemGlobals.RAM: self.realItem.setPos(-1.5, 1.5, -0.59999999999999998) self.realItem.setHpr(70, 160, -90) elif itemType == ItemGlobals.POTION: self.realItem.setPos(0.0, 2.5, -0.40000000000000002) self.realItem.setHpr(45, 0, 0) else: self.realItem.setPos(0.0, 1.5, -0.059999999999999998) self.realItem.setHpr(0, 90, 0) self.realItem.reparentTo(self.portraitSceneGraph) iHeight = 0.17499999999999999 self.createBuffer() self.itemCard.setZ(runningVertPosition - 0.059999999999999998) runningVertPosition -= iHeight runningSize += iHeight labels.append(self.itemCard) goldLabel = DirectLabel(parent = self, relief = None, image = coinImage, image_scale = 0.12, image_pos = Vec3(0.025000000000000001, 0, -0.02), text = str(int(ItemGlobals.getGoldCost(itemId) * ItemGlobals.GOLD_SALE_MULTIPLIER)), text_scale = subtitleScale, text_align = TextNode.ARight, text_fg = PiratesGuiGlobals.TextFG1, text_shadow = PiratesGuiGlobals.TextShadow, pos = (halfWidth - 0.050000000000000003, 0.0, runningVertPosition + 0.080000000000000002), text_pos = (0.0, -textScale)) labels.append(goldLabel) infoText = PLocalizer.ItemAttackStrength % '\x01%s\x01%s\x02' % (itemColor, ItemGlobals.getPower(itemId)) if itemType == ItemGlobals.GUN: infoText += ' %s' % PLocalizer.ItemBarrels % '\x01%s\x01%s\x02' % (itemColor, ItemGlobals.getBarrels(itemId)) infoText += ' %s' % PLocalizer.ItemRangeStrength % '\x01%s\x01%s\x02' % (itemColor, PLocalizer.getItemRangeName(WeaponGlobals.getRange(itemId))) if itemType != ItemGlobals.POTION: infoLabel = DirectLabel(parent = self, relief = None, text = infoText, text_scale = textScale, text_align = TextNode.ACenter, pos = (0.0, 0.0, runningVertPosition), text_pos = (0.0, -textScale)) iHeight = 0.080000000000000002 runningVertPosition -= iHeight runningSize += iHeight labels.append(infoLabel) specialAttack = None if itemType != ItemGlobals.POTION: specialAttack = ItemGlobals.getSpecialAttack(itemId) if specialAttack: attackIcon = self.SkillIcons.find('**/%s' % WeaponGlobals.getSkillIcon(specialAttack)) specialAttackNameLabel = DirectLabel(parent = self, relief = None, image = border, image_scale = 0.10000000000000001, geom = attackIcon, geom_scale = 0.10000000000000001, image_pos = (-0.070000000000000007, 0.0, -0.050000000000000003), geom_pos = (-0.070000000000000007, 0.0, -0.050000000000000003), text = PLocalizer.getInventoryTypeName(specialAttack), text_scale = PiratesGuiGlobals.TextScaleLarge, text_wordwrap = halfWidth * 2.0 * (0.90000000000000002 / titleScale), text_align = TextNode.ALeft, text_fg = titleColor, text_font = PiratesGlobals.getInterfaceOutlineFont(), text_shadow = PiratesGuiGlobals.TextShadow, pos = (-halfWidth + 0.12 + textScale * 0.5, 0.0, runningVertPosition), text_pos = (0.0, -textScale)) specialAttackRankLabel = DirectLabel(parent = self, relief = None, text = PLocalizer.ItemRank % ItemGlobals.getSpecialAttackRank(itemId), text_scale = textScale, text_wordwrap = halfWidth * 2.0 * (0.90000000000000002 / titleScale), text_align = TextNode.ARight, pos = (halfWidth - textScale * 0.5, 0.0, runningVertPosition), text_pos = (0.0, -textScale)) specialAttackType = WeaponGlobals.getSkillTrack(specialAttack) if specialAttackType == WeaponGlobals.BREAK_ATTACK_SKILL_INDEX: specialAttackTypeText = PLocalizer.BreakAttackSkill elif specialAttackType == WeaponGlobals.DEFENSE_SKILL_INDEX: specialAttackTypeText = PLocalizer.DefenseSkill else: specialAttackTypeText = PLocalizer.WeaponSkill specialAttackTypeLabel = DirectLabel(parent = self, relief = None, text = specialAttackTypeText, text_scale = 0.033500000000000002, text_wordwrap = halfWidth * 2.7999999999999998 * (0.90000000000000002 / titleScale), text_align = TextNode.ALeft, pos = (-halfWidth + 0.12 + textScale * 0.5, 0.0, runningVertPosition - PiratesGuiGlobals.TextScaleLarge), text_pos = (0.0, -textScale)) specialAttackInfo = PLocalizer.SkillDescriptions.get(specialAttack) specialAttackDescriptionText = specialAttackInfo[1] specialAttackDescriptionLabel = DirectLabel(parent = self, relief = None, text = specialAttackDescriptionText, text_scale = textScale, text_wordwrap = halfWidth * 2.7999999999999998 * (0.90000000000000002 / titleScale), text_align = TextNode.ALeft, pos = (-halfWidth + 0.12 + textScale * 0.5, 0.0, runningVertPosition - specialAttackNameLabel.getHeight() + specialAttackTypeLabel.getHeight() - 0.059999999999999998), text_pos = (0.0, -textScale)) saHeight = specialAttackNameLabel.getHeight() + specialAttackTypeLabel.getHeight() + specialAttackDescriptionLabel.getHeight() - 0.040000000000000001 runningVertPosition -= saHeight runningSize += saHeight labels.append(specialAttackNameLabel) labels.append(specialAttackRankLabel) labels.append(specialAttackTypeLabel) labels.append(specialAttackDescriptionLabel) attributes = ItemGlobals.getAttributes(itemId) for i in range(0, len(attributes)): attributeIcon = self.SkillIcons.find('**/%s' % ItemGlobals.getAttributeIcon(attributes[i][0])) if not attributeIcon: attributeIcon = self.BuffIcons.find('**/%s' % ItemGlobals.getAttributeIcon(attributes[i][0])) attributeNameLabel = DirectLabel(parent = self, relief = None, image = border, image_scale = 0.050000000000000003, geom = attributeIcon, geom_scale = 0.050000000000000003, image_pos = (-0.070000000000000007, 0.0, -0.029999999999999999), geom_pos = (-0.070000000000000007, 0.0, -0.029999999999999999), text = PLocalizer.getItemAttributeName(attributes[i][0]), text_scale = PiratesGuiGlobals.TextScaleLarge, text_wordwrap = halfWidth * 2.0 * (0.90000000000000002 / titleScale), text_align = TextNode.ALeft, text_fg = titleColor, text_font = PiratesGlobals.getInterfaceOutlineFont(), text_shadow = PiratesGuiGlobals.TextShadow, pos = (-halfWidth + 0.12 + textScale * 0.5, 0.0, runningVertPosition), text_pos = (0.0, -textScale)) attributeRankLabel = DirectLabel(parent = self, relief = None, text = PLocalizer.ItemRank % attributes[i][1], text_scale = textScale, text_wordwrap = halfWidth * 2.0 * (0.90000000000000002 / titleScale), text_align = TextNode.ARight, pos = (halfWidth - textScale * 0.5, 0.0, runningVertPosition), text_pos = (0.0, -textScale)) if attributeNameLabel.getHeight() > 0.074999999999999997: attributeNameSpace = 0.080000000000000002 else: attributeNameSpace = PiratesGuiGlobals.TextScaleLarge attributeDescriptionLabel = DirectLabel(parent = self, relief = None, text = PLocalizer.getItemAttributeDescription(attributes[i][0]), text_scale = textScale, text_wordwrap = halfWidth * 2.7999999999999998 * (0.90000000000000002 / titleScale), text_align = TextNode.ALeft, pos = (-halfWidth + 0.12 + textScale * 0.5, 0.0, runningVertPosition - attributeNameSpace), text_pos = (0.0, -textScale)) aHeight = attributeNameLabel.getHeight() + attributeDescriptionLabel.getHeight() runningVertPosition -= aHeight + splitHeight runningSize += aHeight + splitHeight labels.append(attributeNameLabel) labels.append(attributeRankLabel) labels.append(attributeDescriptionLabel) skillBoosts = ItemGlobals.getSkillBoosts(itemId) for i in range(0, len(skillBoosts)): boostIcon = self.SkillIcons.find('**/%s' % WeaponGlobals.getSkillIcon(skillBoosts[i][0])) boostNameLabel = DirectLabel(parent = self, relief = None, image = border, image_scale = 0.050000000000000003, geom = boostIcon, geom_scale = 0.050000000000000003, image_pos = (-0.070000000000000007, 0.0, -0.029999999999999999), geom_pos = (-0.070000000000000007, 0.0, -0.029999999999999999), text = PLocalizer.ItemBoost % PLocalizer.getInventoryTypeName(skillBoosts[i][0]), text_scale = textScale, text_wordwrap = halfWidth * 2.0 * (0.90000000000000002 / titleScale), text_align = TextNode.ALeft, pos = (-halfWidth + 0.12 + textScale * 0.5, 0.0, runningVertPosition), text_pos = (0.0, -textScale)) boostRankLabel = DirectLabel(parent = self, relief = None, text = '+%s' % str(skillBoosts[i][1]), text_scale = textScale, text_wordwrap = halfWidth * 2.0 * (0.90000000000000002 / titleScale), text_align = TextNode.ARight, pos = (halfWidth - textScale * 0.5, 0.0, runningVertPosition), text_pos = (0.0, -textScale)) bHeight = boostNameLabel.getHeight() runningVertPosition -= bHeight + splitHeight runningSize += bHeight + splitHeight labels.append(boostNameLabel) labels.append(boostRankLabel) description = PLocalizer.getItemFlavorText(itemId) if description != '': descriptionLabel = DirectLabel(parent = self, relief = None, text = description, text_scale = textScale, text_wordwrap = halfWidth * 2.0 * (0.94999999999999996 / textScale), text_align = TextNode.ALeft, pos = (-halfWidth + textScale * 0.5, 0.0, runningVertPosition), text_pos = (0.0, -textScale)) dHeight = descriptionLabel.getHeight() + 0.02 runningVertPosition -= dHeight runningSize += dHeight labels.append(descriptionLabel) inv = localAvatar.getInventory() weaponLevel = 0 weaponRepId = WeaponGlobals.getRepId(itemId) weaponRep = inv.getReputation(weaponRepId) weaponReq = ItemGlobals.getWeaponRequirement(itemId) weaponText = None trainingToken = EconomyGlobals.getItemTrainingReq(itemId) trainingAmt = inv.getItemQuantity(trainingToken) if weaponReq: weaponLevel = ReputationGlobals.getLevelFromTotalReputation(weaponRepId, weaponRep)[0] if weaponLevel < weaponReq: weaponColor = PiratesGuiGlobals.TextFG6 else: weaponColor = (0.40000000000000002, 0.40000000000000002, 0.40000000000000002, 1.0) weaponText = PLocalizer.ItemLevelRequirement % (weaponReq, PLocalizer.getItemTypeName(itemType)) elif trainingAmt == 0: weaponColor = PiratesGuiGlobals.TextFG6 weaponText = PLocalizer.ItemTrainingRequirement % PLocalizer.getItemTypeName(itemType) if trainingAmt == 0: if itemType == ItemGlobals.GUN: base.localAvatar.sendRequestContext(InventoryType.GunTrainingRequired) elif itemType == ItemGlobals.DOLL: base.localAvatar.sendRequestContext(InventoryType.DollTrainingRequired) elif itemType == ItemGlobals.DAGGER: base.localAvatar.sendRequestContext(InventoryType.DaggerTrainingRequired) elif itemType == ItemGlobals.STAFF: base.localAvatar.sendRequestContext(InventoryType.StaffTrainingRequired) if weaponText: weaponReqLabel = DirectLabel(parent = self, relief = None, text = weaponText, text_scale = textScale, text_wordwrap = halfWidth * 2.0 * (1.5 / titleScale), text_fg = weaponColor, text_shadow = PiratesGuiGlobals.TextShadow, text_align = TextNode.ACenter, pos = (0.0, 0.0, runningVertPosition), text_pos = (0.0, -textScale)) wHeight = weaponReqLabel.getHeight() runningVertPosition -= wHeight runningSize += wHeight labels.append(weaponReqLabel) if not Freebooter.getPaidStatus(localAvatar.getDoId()): if rarity != ItemGlobals.CRUDE: unlimitedLabel = DirectLabel(parent = self, relief = None, text = PLocalizer.UnlimitedAccessRequirement, text_scale = textScale, text_wordwrap = halfWidth * 2.0 * (1.5 / titleScale), text_fg = PiratesGuiGlobals.TextFG6, text_shadow = PiratesGuiGlobals.TextShadow, text_align = TextNode.ACenter, pos = (0.0, 0.0, runningVertPosition), text_pos = (0.0, -textScale)) uHeight = unlimitedLabel.getHeight() runningVertPosition -= uHeight runningSize += uHeight labels.append(unlimitedLabel) runningVertPosition -= 0.02 runningSize += 0.02 panels = self.helpFrame.attachNewNode('panels') topPanel = panels.attachNewNode('middlePanel') detailGui.find('**/top_panel').copyTo(topPanel) topPanel.setScale(0.080000000000000002) topPanel.reparentTo(self.helpFrame) middlePanel = panels.attachNewNode('middlePanel') detailGui.find('**/middle_panel').copyTo(middlePanel) middlePanel.setScale(0.080000000000000002) middlePanel.reparentTo(self.helpFrame) placement = 0 i = 0 heightMax = -0.080000000000000002 currentHeight = runningVertPosition while currentHeight < heightMax: middlePanel = panels.attachNewNode('middlePanel%s' % 1) detailGui.find('**/middle_panel').copyTo(middlePanel) middlePanel.setScale(0.080000000000000002) middlePanel.reparentTo(self.helpFrame) if currentHeight + 0.20000000000000001 >= heightMax: difference = heightMax - currentHeight placement += (0.16800000000000001 / 0.20000000000000001) * difference currentHeight += difference else: placement += 0.16800000000000001 currentHeight += 0.20000000000000001 middlePanel.setZ(-placement) i += 1 bottomPanel = panels.attachNewNode('bottomPanel') detailGui.find('**/bottom_panel').copyTo(bottomPanel) bottomPanel.setScale(0.080000000000000002) bottomPanel.setZ(-placement) bottomPanel.reparentTo(self.helpFrame) colorPanel = panels.attachNewNode('colorPanel') detailGui.find('**/color').copyTo(colorPanel) colorPanel.setScale(0.080000000000000002) colorPanel.setColor(titleColor) colorPanel.reparentTo(self.helpFrame) lineBreakTopPanel = panels.attachNewNode('lineBreakTopPanel') detailGui.find('**/line_break_top').copyTo(lineBreakTopPanel) lineBreakTopPanel.setScale(0.080000000000000002, 0.080000000000000002, 0.070000000000000007) lineBreakTopPanel.setZ(0.0080000000000000002) lineBreakTopPanel.reparentTo(self.helpFrame) if itemType != ItemGlobals.POTION: lineBreakBottomPanel = panels.attachNewNode('lineBreakBottomPanel') detailGui.find('**/line_break_bottom').copyTo(lineBreakBottomPanel) lineBreakBottomPanel.setScale(0.080000000000000002, 0.080000000000000002, 0.070000000000000007) lineBreakBottomPanel.setZ(-0.014999999999999999) lineBreakBottomPanel.reparentTo(self.helpFrame) panels.flattenStrong() self.helpFrame['frameSize'] = (-halfWidth, halfWidth, -(runningSize + vMargin), vMargin) totalHeight = self.helpFrame.getHeight() - 0.10000000000000001 for label in labels: label.reparentTo(self.helpFrame) self.helpFrame.setBin('gui-popup', 0) self.helpFrame.setPos(self, 0.55000000000000004, 0, -0.29999999999999999) zOffset = -0.5 - self.helpFrame.getPos(aspect2d)[2] if zOffset >= 0.0: self.helpFrame.setPos(self, 0.55000000000000004, 0, zOffset - 0.29999999999999999) else: weaponInfo = PLocalizer.WeaponDescriptions.get(self.data[0]) weaponDesc = weaponInfo self.helpText = DirectFrame(parent = self, relief = None, text = weaponDesc, state = DGG.DISABLED, text_align = TextNode.ALeft, text_scale = PiratesGuiGlobals.TextScaleSmall, text_fg = PiratesGuiGlobals.TextFG2, text_wordwrap = 13, textMayChange = 0, sortOrder = 91) height = -self.helpText.getHeight() self.helpFrame = BorderFrame(parent = aspect2d, state = DGG.DISABLED, frameSize = (-0.029999999999999999, 0.42999999999999999, height, 0.050000000000000003), sortOrder = 90, borderScale = 0.20000000000000001) self.helpText.reparentTo(self.helpFrame) self.helpFrame.setBin('gui-popup', 0) self.helpFrame.setPos(self, 0.25, 0, -0.035000000000000003) def destroy(self): taskMgr.remove('helpInfoTask') taskMgr.remove(self.taskName('dragTask')) self.destroyBuffer() if self.itemCard: self.itemCard.removeNode() if self.realItem: self.realItem.removeNode() if self.helpFrame: self.helpFrame.destroy() self.helpFrame = None del self.picture if self.weapon: taskMgr.remove(DGG.B1PRESS) taskMgr.remove(DGG.B2PRESS) taskMgr.remove(DGG.B3PRESS) InventoryListItem.destroy(self) def setDraggable(self, d): self.draggable = d def dragStart(self, event): self.origionalPos = self.getPos(render2d) self.origionalParent = self.getParent() self.bringToFront() self.setColorScale(1, 1, 1, 0.5) if self.draggable: self.wrtReparentTo(aspect2d) taskMgr.remove(self.taskName('dragTask')) vWidget2render2d = self.getPos(render2d) vMouse2render2d = Point3(event.getMouse()[0], 0, event.getMouse()[1]) editVec = Vec3(vWidget2render2d - vMouse2render2d) task = taskMgr.add(self.dragTask, self.taskName('dragTask')) task.editVec = editVec def dragTask(self, task): if task.time < PiratesGuiGlobals.DragStartDelayTime: return Task.cont else: mwn = base.mouseWatcherNode if mwn.hasMouse(): vMouse2render2d = Point3(mwn.getMouse()[0], 0, mwn.getMouse()[1]) newPos = vMouse2render2d + task.editVec self.setPos(render2d, newPos) newPos = self.getPos(aspect2d) x = newPos[0] z = newPos[2] x = x - x % 0.050000000000000003 z = z - z % 0.050000000000000003 x = min(1.3 - self.width, max(-1.3, x)) z = min(1 - self.height, max(-1, z)) self.setPos(aspect2d, x, 0.0, z) return Task.cont def dragStop(self, event): self.clearColorScale() self.wrtReparentTo(self.origionalParent) self.setPos(render2d, self.origionalPos) if self.draggable: taskMgr.remove(self.taskName('dragTask')) def showDetails(self, event): taskMgr.doMethodLater(PiratesGuiGlobals.HelpPopupTime, self.createHelpbox, 'helpInfoTask') self.createHelpbox() def hideDetails(self, event): taskMgr.remove('helpInfoTask') if self.helpFrame: self.helpFrame.destroy() self.helpFrame = None def createBuffer(self): self.destroyBuffer() self.buffer = base.win.makeTextureBuffer('par', 256, 256) self.buffer.setOneShot(True) self.cam = base.makeCamera(win = self.buffer, scene = self.portraitSceneGraph, clearColor = Vec4(1), lens = self.lens) self.cam.node().getDisplayRegion(0).setIncompleteRender(False) self.cam.reparentTo(self.portraitSceneGraph) self.bg.reparentTo(self.cam) self.glow.reparentTo(self.cam) if self.itemCard: self.itemCard.removeNode() tex = self.buffer.getTexture() self.itemCard = NodePath(self.cm.generate()) self.itemCard.setTexture(tex, 1) if self.helpFrame: self.itemCard.reparentTo(self.helpFrame) def destroyBuffer(self): if self.buffer: base.graphicsEngine.removeWindow(self.buffer) self.buffer = None self.bg.detachNode() self.glow.detachNode() self.cam.removeNode() self.cam = None
def destroy(self): self.ignoreAll() BorderFrame.destroy(self)
class InventoryStackSeller(BorderFrame): def __init__(self, cell, parent): self.sizeX = 0.64000000000000001 self.sizeZ = 0.64000000000000001 textScale = PiratesGuiGlobals.TextScaleTitleSmall frameSize = (-0.0 * self.sizeX, 1.0 * self.sizeX, -0.0 * self.sizeZ, 1.0 * self.sizeZ) modelName = 'pir_m_gui_frm_subframe' imageColorScale = VBase4(0.75, 0.75, 0.90000000000000002, 1.0) optiondefs = (('state', DGG.DISABLED, None), ('frameSize', frameSize, None), ('modelName', modelName, None), ('imageColorScale', imageColorScale, None)) self.defineoptions({ }, optiondefs) BorderFrame.__init__(self, parent = NodePath()) self.initialiseoptions(InventoryStackSeller) self.doubleFrame = BorderFrame(parent = self, frameSize = frameSize, modelName = modelName, imageColorScale = imageColorScale) self.tripleFrame = BorderFrame(parent = self, frameSize = frameSize, modelName = modelName, imageColorScale = imageColorScale, text = PLocalizer.InventorySplitterTitle, text_align = TextNode.ACenter, text_font = PiratesGlobals.getPirateBoldOutlineFont(), text_fg = VBase4(1, 1, 1, 1), text_shadow = PiratesGuiGlobals.TextShadow, text_scale = textScale, text_pos = (self.sizeX * 0.5, self.sizeZ * 0.94999999999999996 - textScale)) self.fromCell = cell self.parent = parent self.amount = self.fromCell.inventoryItem.getAmount() self.setup() def setup(self): self.setBin('gui-fixed', 1) self.itemLabel = DirectLabel(parent = self, relief = None, text = '%s' % self.fromCell.inventoryItem.getName(), text_font = PiratesGlobals.getPirateBoldOutlineFont(), text_align = TextNode.ACenter, text_scale = PiratesGuiGlobals.TextScaleLarge, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, image = self.fromCell.inventoryItem['image'], image_scale = self.fromCell.inventoryItem['image_scale'], text_pos = (0.0, 0.066000000000000003), pos = (self.sizeX * 0.5, 0.0, self.sizeZ * 0.59999999999999998)) self.amountEntry = DirectEntry(parent = self, relief = DGG.GROOVE, scale = PiratesGuiGlobals.TextScaleExtraLarge, initialText = '%s' % self.amount, width = 1.5, numLines = 1, focus = 1, cursorKeys = 1, frameColor = (1.0, 1.0, 1.0, 0.20000000000000001), entryFont = PiratesGlobals.getPirateBoldOutlineFont(), text_fg = (1.0, 1.0, 1.0, 1.0), pos = (self.sizeX * 0.32500000000000001, 0.0, self.sizeZ * 0.35499999999999998), suppressKeys = 1, suppressMouse = 1, autoCapitalize = 0, command = self.selectStackAmount) self.amountLabel = DirectLabel(parent = self, relief = None, text = PLocalizer.InventorySellAmount % self.amount, text_font = PiratesGlobals.getPirateBoldOutlineFont(), text_align = TextNode.ACenter, text_scale = PiratesGuiGlobals.TextScaleExtraLarge, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_pos = (0.0, 0.066000000000000003), pos = (self.sizeX * 0.55000000000000004, 0.0, self.sizeZ * 0.25)) self.confirmButton = GuiButton.GuiButton(parent = self, text = PLocalizer.lOk, text_fg = PiratesGuiGlobals.TextFG2, text_pos = (0.0, -0.014), text_scale = PiratesGuiGlobals.TextScaleLarge, text_align = TextNode.ACenter, text_shadow = PiratesGuiGlobals.TextShadow, image = GuiButton.GuiButton.blueGenericButton, image_scale = (0.59999999999999998, 0.59999999999999998, 0.59999999999999998), pos = (self.sizeX * 0.25, 0, 0.10000000000000001), relief = None, command = self.selectStackAmount) self.cancelButton = GuiButton.GuiButton(parent = self, text = PLocalizer.lCancel, text_fg = PiratesGuiGlobals.TextFG2, text_pos = (0.0, -0.014), text_scale = PiratesGuiGlobals.TextScaleLarge, text_align = TextNode.ACenter, text_shadow = PiratesGuiGlobals.TextShadow, image = GuiButton.GuiButton.blueGenericButton, image_scale = (0.59999999999999998, 0.59999999999999998, 0.59999999999999998), pos = (self.sizeX * 0.75, 0, 0.10000000000000001), relief = None, command = self.cancelItem) def destroy(self): self.parent = None self.fromCell = None self.doubleFrame.destroy() self.tripleFrame.destroy() BorderFrame.destroy(self) def selectStackAmount(self, amount = None): if not amount: amount = self.amountEntry.get() if not amount or len(amount) == 0: base.localAvatar.guiMgr.createWarning(PLocalizer.InventorySellWarning, PiratesGuiGlobals.TextFG6) return None try: amount = int(amount) except: base.localAvatar.guiMgr.createWarning(PLocalizer.InventorySellWarning, PiratesGuiGlobals.TextFG6) return None if amount < 0 or amount > self.amount: base.localAvatar.guiMgr.createWarning(PLocalizer.InventorySellWarning, PiratesGuiGlobals.TextFG6) return None if amount == 0: self.cancelItem() return None else: self.parent.setStackAmount(self.fromCell, amount) self.destroy() def cancelItem(self): self.parent.cancelItem() self.destroy()
class BlackjackTableGUI(DirectFrame, TableGUI, SplitBase): HandPos = (Vec3(0, 0, 0.4), Vec3(0.38, 0, 0.33), Vec3(0.65, 0, 0.1), Vec3(0.45, 0, -0.26), Vec3(0, 0, -0.3), Vec3(-0.45, 0, -0.26), Vec3(-0.65, 0, 0.1), Vec3(-0.38, 0, 0.33)) LocalAvatarGuiIndex = 4 def sliderValueToBid(self, value): bid = int(value * self.table.betMultiplier * 50) bid = bid / 5 bid = bid * 5 if bid < 2: bid = 2 return bid def x_to_gui_coordinate(self, x): return x * self.width def y_to_gui_coordinate(self, y): return self.height - y * self.height def create_slider(self, update_function, default_value, x, y, resolution, label, parent): slider_x = self.x_to_gui_coordinate(x) slider_y = self.y_to_gui_coordinate(y) def update_slider(slider, update_function): string = slider.label + ' (%d)' % self.sliderValueToBid( slider['value']) slider['text'] = string update_function(slider['value']) charGui = loader.loadModel('models/gui/char_gui') slider = DirectSlider( parent=parent, relief=None, command=update_slider, image=charGui.find('**/chargui_slider_small'), image_scale=(2.15, 2.15, 1.5), thumb_relief=None, thumb_image=(charGui.find('**/chargui_slider_node'), charGui.find('**/chargui_slider_node_down'), charGui.find('**/chargui_slider_node_over')), pos=(slider_x, 0.0, slider_y), text_align=TextNode.ACenter, text_scale=(0.1, 0.1), text_pos=(0.0, 0.1), text_fg=PiratesGuiGlobals.TextFG1, scale=0.43, pageSize=resolution, text='default', value=default_value) charGui.removeNode() slider.label = label slider['extraArgs'] = [slider, update_function] return slider def __init__(self, table): DirectFrame.__init__(self, relief=None) self.initialiseoptions(BlackjackTableGUI) self.table = table self.destroyed = False self.maxHandCards = 14 self.playerStatusPanels = [] for i in range(self.table.NumSeats + 1): statusPanel = BlackjackStatusPanel(self.maxHandCards) statusPanel.setName('playerHand-%s' % i) pos = self.HandPos[i] statusPanel.setPos(pos) self.playerStatusPanels.append(statusPanel) self.localStatusPanel = self.playerStatusPanels[ self.LocalAvatarGuiIndex] width = 1.0 height = 0.25 self.menu = BorderFrame(parent=base.a2dBottomCenter, frameSize=(-width / 2.0, width / 2.0, 0, height), pos=(0, 0, 0)) self.width = width self.height = height self.initializeTableInterface() x = -0.36 y = 0.1775 x_increment = 0.24 helpText = PLocalizer.TableCardsHelp helpPos = (0.0, 0.0, 0.24) text = PLocalizer.BlackjackCardSwap button = GuiButton(parent=self.menu, command=self.playerAction, helpText=helpText, helpPos=helpPos, pos=(x, 0, y), canReposition=True) self.setButtonSettings2Lines(button, (x, 0, y), text, [PlayingCardGlobals.CardSwap]) button.show() self.cardSwapButton = button self.buttonArray = self.buttonArray + [button] x += x_increment text = PLocalizer.BlackjackDoubleDown button = GuiButton(parent=self.menu, command=self.playerAction, canReposition=True) self.setButtonSettings2Lines(button, (x, 0, y), text, [PlayingCardGlobals.DoubleDown]) button.show() self.doubleDownButton = button self.buttonArray = self.buttonArray + [button] x += x_increment text = PLocalizer.BlackjackStay button = GuiButton(parent=self.menu, command=self.playerAction, canReposition=True) self.setButtonSettings(button, (x, 0, y), text, [PlayingCardGlobals.Stay]) button.show() self.stayButton = button self.buttonArray = self.buttonArray + [button] x += x_increment text = PLocalizer.BlackjackHit button = GuiButton(parent=self.menu, command=self.playerAction, canReposition=True) self.setButtonSettings(button, (x, 0, y), text, [PlayingCardGlobals.Hit]) button.show() self.hitButton = button self.buttonArray = self.buttonArray + [button] x += x_increment x = -0.36 y = 0.07 x_increment = 0.24 x += x_increment x += x_increment text = PLocalizer.BlackjackSplit button = GuiButton(parent=self.menu, command=self.playerAction, canReposition=True) self.setButtonSettings(button, (x, 0, y), text, [PlayingCardGlobals.Split]) button.show() self.splitButton = button self.buttonArray = self.buttonArray + [button] x += x_increment bid = self.table.getTableBidAmount() text = PLocalizer.BlackjackBid + ' ' + bid.__repr__() button = GuiButton(parent=self.menu, command=self.playerAction, canReposition=True) self.setButtonSettings(button, (x, 0, y), text, [PlayingCardGlobals.Bid]) button.show() self.bidButton = button self.buttonArray = self.buttonArray + [button] x += x_increment def bid_update_function(value): bid = self.sliderValueToBid(value) text = PLocalizer.BlackjackBid + ' ' + bid.__repr__() self.bidButton['text'] = text self.bidAmount = bid self.bidAmount = 2 default_value = 0.0 x = 0.0 y = -0.25 label = PLocalizer.BlackjackBid resolution = 1.0 self.bidSlider = self.create_slider(bid_update_function, default_value, x, y, resolution, label, self.menu) x = -0.36 y = 0.1775 x_increment = 0.24 text = PLocalizer.PokerCheat1 button = GuiButton(parent=self.menu, command=self.cardSwapButtonSelection, canReposition=True) self.setButtonSettings2Lines(button, (x, 0, y), text, [PlayingCardGlobals.Cheat1]) self.cheat1Button = button self.buttonArray = self.buttonArray + [button] x = x + x_increment text = PLocalizer.PokerCheat2 button = GuiButton(parent=self.menu, command=self.cardSwapButtonSelection, canReposition=True) self.setButtonSettings2Lines(button, (x, 0, y), text, [PlayingCardGlobals.Cheat2]) self.cheat2Button = button self.buttonArray = self.buttonArray + [button] x = x + x_increment self.hideCheatButtons() self.disableAllPlayButtons() gui = loader.loadModel('models/gui/toplevel_gui') goldCoin = gui.find('**/treasure_w_coin*') scale = 0.32 currentMoney = localAvatar.getInventory().getGoldInPocket() self.moneyDisplay = DirectLabel( parent=self.menu, relief=None, pos=(-0.3 + x_increment / 2.0, 0, 0.075), geom=goldCoin, geom_scale=(scale, scale, scale), geom_pos=(0, 0, 0), text='%s' % currentMoney, text_align=TextNode.ALeft, text_scale=0.035, text_pos=(0.045, -0.01), text_fg=PiratesGuiGlobals.TextFG1, text_shadow=PiratesGuiGlobals.TextShadow, textMayChange=1, scale=1.1) self.accept( InventoryGlobals.getCategoryQuantChangeMsg( localAvatar.getInventoryId(), InventoryType.ItemTypeMoney), self.setMoney) this = self identifier = 0 this.sfxArray = [] this.hitIdentifier = identifier this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_HIT) ] identifier = identifier + 1 self.hands = [] self.splitCardsArray = [] self.canSplit = False self.canDoubleDown = False self.bid = False return def cardSwapButtonSelection(self, card): self.cheat1Button.hide() self.cheat2Button.hide() self.cardIndexSelection(card) def startCardIndexSelection(self): self.cheat1Button.show() self.cheat2Button.show() self.cancelButton.show() self.hideActionButtons() def playerAction(self, action): base.localAvatar.delayAFK() if action == PlayingCardGlobals.CardSwap: self.startCardIndexSelection() else: self.table.guiCallback(action) self.endTimer() self.disableAllPlayButtons() if action == PlayingCardGlobals.Split: length = len(self.hands) if length > 0 and self.table.localAvatarSeat > 0 and self.table.localAvatarSeat < length: hand = self.hands[self.table.localAvatarSeat] if hand and len(hand) == 2: self.splitCardsArray.append(hand[1]) def setMoney(self, money): self.moneyDisplay['text'] = '%s' % money self.table.displayStacks(self.table.localAvatarSeat, money) def showArrow(self, seatIndex): self.hideArrow() guiIndex = self.getGuiIndex(seatIndex) self.playerStatusPanels[guiIndex].arrow.show() self.playerStatusPanels[guiIndex].actionLabel.hide() def hideArrow(self): map(lambda panel: panel.arrow.hide(), self.playerStatusPanels) def getGuiIndex(self, seatIndex): return (self.LocalAvatarGuiIndex - self.table.localAvatarSeat + seatIndex) % (self.table.NumSeats + 1) def setTableState(self, hands, allHands): for panel in self.playerStatusPanels: for card in panel.hand: card.hide() panel.handNameLabel.hide() panel.splitLabel.hide() panel.handsLabel.hide() self.hands = hands for i in range(len(hands)): newHand = hands[i] guiIndex = self.getGuiIndex(i) panel = self.playerStatusPanels[guiIndex] hand = panel.hand handNameLabel = panel.handNameLabel splitLabel = panel.splitLabel handsLabel = panel.handsLabel for card, newValue in zip(hand, newHand): card.show() card.setValue(newValue) if newValue == PlayingCardGlobals.Unknown: card.turnDown() else: card.turnUp() self.centerCards(panel, newHand) if newHand and PlayingCardGlobals.Unknown not in newHand: handValue = PlayingCardGlobals.getBlackjackHandValue(newHand) if handValue == 21 and len(newHand) == 2: handArray = allHands[i] total_hands = len(handArray) if total_hands <= 1: handNameLabel['text'] = PLocalizer.BlackjackHand else: handNameLabel['text'] = str(handValue) elif handValue > 21: handNameLabel[ 'text'] = PLocalizer.BlackjackBusted % handValue else: handNameLabel['text'] = str(handValue) handNameLabel.show() if i == self.table.localAvatarSeat: handArray = allHands[i] total_hands = len(handArray) if total_hands > 1: current_hand_index = self.table.getCurrentHandIndex( i, allHands) splitLabel['text'] = PLocalizer.BlackjackHandofHand % ( current_hand_index + 1, total_hands) splitLabel.show() hands_text = '' for h in range(current_hand_index): hands_text = hands_text + str( PlayingCardGlobals.getBlackjackHandValue( handArray[h])) + ' ' handsLabel.show() self.createSplitDisplay(i, allHands, handsLabel) self.canSplit = False self.canDoubleDown = False if newHand[0] in self.splitCardsArray: self.splitCardsArray.remove(newHand[0]) if handValue >= 21: self.disableAllPlayButtons() else: self.updateSplitAndDoubleDown(newHand) def updateSplitAndDoubleDown(self, hand): self.canSplit = False self.canDoubleDown = False length = len(hand) if length == 2: if self.table.getPlayerChips() >= self.bidAmount: self.canDoubleDown = True if self.splitableHand(hand[0], hand[1]): self.canSplit = True def updatePlayButtions(self): self.disableAllPlayButtons() if self.canDoubleDown: self.normalButton(self.doubleDownButton) self.normalButton(self.stayButton) self.normalButton(self.hitButton) if self.canSplit: self.normalButton(self.splitButton) have_cheat_card = False if self.swapCard == False: for card_id in range(52): if self.table.getPlayerInventoryCardCount(card_id) > 0: have_cheat_card = True break if have_cheat_card: self.normalButton(self.cardSwapButton) else: self.disableButton(self.cardSwapButton) def setEvent(self, seatIndex, action): guiIndex = self.getGuiIndex(seatIndex) panel = self.playerStatusPanels[guiIndex] actionText = PlayingCardGlobals.getBlackjackActionText(action) if len(action) >= 2: if action[0] == PlayingCardGlobals.Bid and action[1] == 0: actionText = ' ' if seatIndex == self.table.localAvatarSeat: if action[0] == PlayingCardGlobals.Bid: if action[1] == 0: self.bid = False else: self.bid = True panel.displayAction(actionText, self.table, seatIndex) if seatIndex == self.table.localAvatarSeat: time = 0.0 if action[0] == PlayingCardGlobals.AskForBid: time = PlayingCardGlobals.BidTimeout self.disableAllPlayButtons() self.normalButton(self.bidButton) self.bidSlider.show() self.splitCardsArray = [] self.swapCard = False self.bid = False if action[0] == PlayingCardGlobals.AskCard: time = PlayingCardGlobals.AskCardTimeout self.updatePlayButtions() if action[0] == PlayingCardGlobals.Stay: self.disableAllPlayButtons() if action[0] == PlayingCardGlobals.DoubleDown: self.disableAllPlayButtons() if action[0] == PlayingCardGlobals.Split: time = PlayingCardGlobals.AskCardTimeout self.disableAllPlayButtons() if time > 0.0: self.startTimer(time) def disableAllPlayButtons(self): self.disableButton(self.splitButton) self.disableButton(self.doubleDownButton) self.disableButton(self.stayButton) self.disableButton(self.hitButton) self.disableButton(self.bidButton) self.bidSlider.hide() self.disableButton(self.cardSwapButton) def destroy(self): self.endTimer() self.deleteTableGUI() del self.bidSlider self.menu.destroy() del self.menu for panel in self.playerStatusPanels: panel.destroy() del self.playerStatusPanels del self.localStatusPanel self.destroyed = True del self.table DirectFrame.destroy(self) this = self if this.sfxArray: length = len(this.sfxArray) for i in range(length): sfx = this.sfxArray[i] this.sfxArray[i] = None if sfx: loader.unloadSfx(sfx) return def leaveAction(self, action): self.deleteLeaveDialog() self.leaveDialog = PDialog.PDialog( text=PLocalizer.PokerLeaveConfirmMessage, style=OTPDialog.YesNo, giveMouse=False, command=self.leaveCallback) self.table.setDialogBin(self.leaveDialog) def timerExpiredCallback(self): self.disableAllPlayButtons() self.showActionButtons() self.hideCheatButtons() self.leaveButton.show() self.cheat1Button.hide() self.cheat2Button.hide() self.endTimer() self.deleteSwapDialog() def splitableHand(self, card1, card2): state = False rank1 = card1 % 13 rank2 = card2 % 13 if rank1 == rank2: state = True elif rank1 >= 8 and rank1 <= 11 and rank2 >= 8 and rank2 <= 11: state = True return state def showActionButtons(self): self.splitButton.show() self.doubleDownButton.show() self.stayButton.show() self.hitButton.show() self.bidButton.show() if self.cardSwapButton: self.cardSwapButton.show() self.leaveButton.show() self.moneyDisplay.show() def hideActionButtons(self): self.splitButton.hide() self.doubleDownButton.hide() self.stayButton.hide() self.hitButton.hide() self.bidButton.hide() self.bidSlider.hide() if self.cardSwapButton: self.cardSwapButton.hide() self.leaveButton.hide() self.moneyDisplay.show() def cancelSelection(self, value=None): self.hideButtonArray(self.suitButtonArray) self.hideButtonArray(self.rankButtonArray) self.cancelButton.hide() self.showActionButtons() self.cheat1Button.hide() self.cheat2Button.hide() def createSplitDisplay(self, seat, allHands, parent): self.deleteSplitDisplay(parent) handArray = allHands[seat] total_hands = len(handArray) if total_hands > 1: current_hand_index = self.table.getCurrentHandIndex(seat, allHands) x_increment = 0.24 x_size = (total_hands - 1) * x_increment x = -x_size * 0.5 y = -0.16 card_y = -0.05 for h in range(total_hands): hand = handArray[h] value = PlayingCardGlobals.getBlackjackHandValue(hand) scale = 0.375 length = len(hand) card_x_increment = 0.06 left = card_x_increment * scale * length * -0.5 for i in range(length): card = PlayingCard.PlayingCardNodePath( 'standard', PlayingCardGlobals.Unknown) card.reparentTo(parent) card.setPos(x + left + i * (card_x_increment * scale), 0, card_y) card.setScale(scale) card.setValue(hand[i]) card.turnUp() card.show() parent.cardArray.append(card) if h == current_hand_index: color = 1.0 card.setColor(color, color, color, 1.0) else: color = 0.6 card.setColor(color, color, color, 1.0) label = DirectLabel(parent=parent, relief=None, text='', text_align=TextNode.ACenter, text_scale=0.04, pos=(x, 0.0, y), text_fg=(1, 1, 1, 1), text_shadow=(0, 0, 0, 1)) label['text'] = str(value) label.show() parent.labelArray.append(label) x += x_increment return def centerCards(self, panel, hand): x_increment = 0.06 length = len(hand) left = x_increment * length * -0.5 for i in range(length): card = panel.hand[i] card.setPos(left + i * x_increment, 0, 0)
class PokerTableGUI(DirectFrame, TableGUI): __module__ = __name__ HandPos = (Vec3(0, 0, 0.4), Vec3(0.38, 0, 0.33), Vec3(0.65, 0, 0.1), Vec3(0.45, 0, -0.26), Vec3(0, 0, -0.3), Vec3(-0.45, 0, -0.26), Vec3(-0.65, 0, 0.1), Vec3(-0.38, 0, 0.33)) LocalAvatarGuiIndex = 4 def __init__(self, table, maxCommunityCards, maxHandCards): DirectFrame.__init__(self, parent=base.a2dBackground, relief=None) self.initialiseoptions(PokerTableGUI) self.maxCommunityCards = maxCommunityCards self.maxHandCards = maxHandCards self.maxBet = 0 self.numberOfTimeouts = 0 self.table = table self.destroyed = False self.playerActions = [] width = 1.0 self.menu = BorderFrame(parent=base.a2dBottomCenter, frameSize=(-width / 2.0, width / 2.0, 0, 0.25), pos=(0, 0, 0)) self.disableReason = DirectLabel( parent=self.menu, text='', text_align=TextNode.ACenter, text_scale=0.04, pos=(0, 0, 0.175), text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, textMayChange=1) self.disableReason.hide() self.initializeTableInterface() x = -0.36 y = 0.1775 x_increment = 0.24 helpText = PLocalizer.TableCardsHelp helpPos = (0.0, 0.0, 0.24) text = PLocalizer.PokerCheat1 button = GuiButton(parent=self.menu, command=self.cardIndexSelection, helpText=helpText, helpPos=helpPos, pos=(x, 0, y), canReposition=True) self.setButtonSettings2Lines(button, (x, 0, y), text, [PlayingCardGlobals.Cheat1]) self.cheat1Button = button self.buttonArray = self.buttonArray + [button] x = x + x_increment text = PLocalizer.PokerCheat2 button = GuiButton(parent=self.menu, command=self.cardIndexSelection, helpText=helpText, helpPos=helpPos, pos=(x, 0, y), canReposition=True) self.setButtonSettings2Lines(button, (x, 0, y), text, [PlayingCardGlobals.Cheat2]) self.cheat2Button = button self.buttonArray = self.buttonArray + [button] x = x + x_increment text = PLocalizer.PokerCheck button = GuiButton(parent=self.menu, command=self.playerAction, canReposition=True) self.setButtonSettings(button, (x, 0, y), text, [PlayingCardGlobals.CheckCall]) self.passButton = button self.buttonArray = self.buttonArray + [button] x = x + x_increment text = PLocalizer.PokerBet button = GuiButton(parent=self.menu, command=self.playerAction, canReposition=True) self.setButtonSettings(button, (x, 0, y), text, [PlayingCardGlobals.BetRaise]) self.betButton = button self.buttonArray = self.buttonArray + [button] x = x + x_increment x = -0.36 y = 0.07 x_increment = 0.24 x = x + x_increment x = x + x_increment x = x + x_increment text = PLocalizer.PokerFold button = GuiButton(parent=self.menu, command=self.playerAction, canReposition=True) self.setButtonSettings(button, (x, 0, y), text, [PlayingCardGlobals.Fold]) self.foldButton = button self.buttonArray = self.buttonArray + [button] x = x + x_increment self.potSizeLabel = DirectLabel(parent=self, relief=None, text='', text_align=TextNode.ACenter, text_scale=0.05, pos=(-0.15, 0.0, 0.17), text_fg=(1, 0.9, 0.6, 1), text_shadow=(0, 0, 0, 1)) if table.wantMeter == 1: cardMaker = CardMaker('tellMeter') cardMaker.setFrame(-1, 1, -1, 1) self.meterMax = 0.2 self.meterBorder = NodePath(cardMaker.generate()) self.meterBorder.setColor(1, 1, 0, 1) self.meterBorder.setScale(0.2, 1, 0.02) self.meterBorder.reparentTo(aspect2d) self.meter = NodePath(cardMaker.generate()) self.meter.setColor(1, 0, 0, 1) self.meter.setScale(0.2, 1, 0.05) self.meter.reparentTo(aspect2d) if table.wantMeter == 2: cardMaker = CardMaker('tellMeter') cardMaker.setFrame(-1, 1, -1, 1) self.balance = NodePath('Balance') self.balance.reparentTo(aspect2d) self.balanceL = NodePath(cardMaker.generate()) self.balanceL.setColor(1, 0, 0, 1) self.balanceL.setScale(0.125, 1, 0.01) self.balanceL.setPos(-0.125, 0, 0) self.balanceL.reparentTo(self.balance) self.balanceR = NodePath(cardMaker.generate()) self.balanceR.setColor(0, 1, 0, 1) self.balanceR.setScale(0.125, 1, 0.01) self.balanceR.setPos(0.125, 0, 0) self.balanceR.reparentTo(self.balance) self.fulcrum = loader.loadModel('models/props/winebottle_B') self.fulcrum.setScale(0.2) self.fulcrum.setZ(-0.21) self.fulcrum.reparentTo(aspect2d) self.weightR = NodePath(cardMaker.generate()) self.weightR.setColor(0, 0, 1, 1) self.weightR.setScale(0.03, 1, 0.05) self.weightR.setPos(0.22, 0, 0.06) self.weightR.reparentTo(self.balance) self.weightL = NodePath(cardMaker.generate()) self.weightL.setColor(0, 0, 1, 1) self.weightL.setScale(0.03, 1, 0.05) self.weightL.setPos(-0.22, 0, 0.06) self.weightL.reparentTo(self.balance) self.balance.hide() self.fulcrum.hide() self.communityCardNode = NodePath('communityCards') self.communityCardNode.reparentTo(self) self.communityCardNode.setScale(0.5) self.communityCardNode.setPos(0, 0, 0.04) self.communityCards = [] for i in range(self.maxCommunityCards): card = PlayingCard.PlayingCardNodePath('standard', PlayingCardGlobals.Unknown) card.reparentTo(self.communityCardNode) card.setPos(i * 0.3 - 0.6, 0, 0) card.hide() self.communityCards.append(card) self.playerStatusPanels = [] for i in range(self.table.NumSeats + 1): statusPanel = PokerStatusPanel(self.maxHandCards) statusPanel.setName('playerHand-%s' % i) pos = self.HandPos[i] statusPanel.setPos(pos) self.playerStatusPanels.append(statusPanel) self.localStatusPanel = self.playerStatusPanels[ self.LocalAvatarGuiIndex] gui = loader.loadModel('models/gui/toplevel_gui') goldCoin = gui.find('**/treasure_w_coin*') scale = 0.32 currentMoney = self.table.getPlayerChips() x_increment = 0.24 self.moneyDisplay = DirectLabel( parent=self.menu, relief=None, pos=(-0.3 + x_increment, 0, 0.075), geom=goldCoin, geom_scale=(scale, scale, scale), geom_pos=(0, 0, 0), text='%s' % currentMoney, text_align=TextNode.ALeft, text_scale=0.04, text_pos=(0.05, -0.01), text_fg=PiratesGuiGlobals.TextFG1, text_shadow=PiratesGuiGlobals.TextShadow, textMayChange=1, scale=1.1) self.accept( InventoryGlobals.getCategoryQuantChangeMsg( localAvatar.getInventoryId(), InventoryType.ItemTypeMoney), self.setMoney) this = self identifier = 0 this.sfxArray = [] this.shuffleIdentifier = identifier this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_SHUFFLE) ] identifier += 1 this.startDealIdentifier = identifier this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_01) ] identifier += 1 this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_02) ] identifier += 1 this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_03) ] identifier += 1 this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_04) ] identifier += 1 this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_05) ] identifier += 1 this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_06) ] identifier += 1 this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_07) ] identifier += 1 this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_08) ] identifier += 1 this.totalDealIdentifiers = identifier - this.startDealIdentifier this.foldIdentifier = identifier this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_FOLD) ] identifier += 1 this.flipIdentifier = identifier this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_FLIP) ] identifier += 1 this.pickupIdentifier = identifier this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_PICKUP) ] identifier += 1 this.checkIdentifier = identifier check = loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_CHECK) check.setVolume(0.5) this.sfxArray = this.sfxArray + [check] identifier += 1 this.betIdentifier = identifier this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_CHIPS_BET) ] identifier += 1 this.collectIdentifier = identifier this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_CHIPS_COLLECT) ] identifier += 1 this.allInIdentifier = identifier this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_CHIPS_ALL) ] identifier += 1 return def showActionButtons(self): self.cheat1Button.show() self.cheat2Button.show() self.passButton.show() self.betButton.show() self.foldButton.show() self.leaveButton.show() self.moneyDisplay.show() self.disableReason.hide() def hideActionButtons(self): self.cheat1Button.hide() self.cheat2Button.hide() self.passButton.hide() self.betButton.hide() self.foldButton.hide() self.leaveButton.hide() def playerAction(self, action, allin_amount=0): self.numberOfTimeouts = 0 base.localAvatar.delayAFK() self.table.guiCallback(action, allin_amount) def leaveAction(self, action, allin_amount=0): self.deleteLeaveDialog() def showLeaveDialog(displayText=None): self.leaveDialog = PDialog.PDialog( text=displayText or PLocalizer.PokerLeaveConfirmMessage, style=OTPDialog.YesNo, giveMouse=False, command=self.leaveCallback) self.table.setDialogBin(self.leaveDialog) if self.table.gameVariation == PiratesGlobals.PARLORGAME_VARIATION_UNDEAD: def gotInventory(inventory): text = None try: for currQuest in inventory.getQuestList(): for currQuestTask, currQuestTaskState in zip( currQuest.getTasks(), currQuest.getTaskStates()): if isinstance(currQuestTask, SkeletonPokerTaskDNA): if currQuestTaskState.isComplete(): if currQuestTaskState.isComplete( bonus=True): lostProgress = 0 else: lostProgress = currQuestTaskState.getBonusProgress( ) else: lostProgress = currQuestTaskState.getProgress( ) loseAmt = min( PiratesGlobals.PARLORGAME_UNDEAD_EXIT_LOSS, lostProgress) if loseAmt > 0: text = PLocalizer.PokerUndeadLeaveConfirmMessage % str( loseAmt) raise NameError('doneSearch') except NameError: pass showLeaveDialog(text) return invReq = DistributedInventoryBase.getInventory( localAvatar.inventoryId, gotInventory) else: showLeaveDialog() return def timeoutAction(self, action): self.table.guiCallback(action) def setMoney(self, money): self.moneyDisplay['text'] = ('%s' % money, ) self.table.displayStacks(self.table.localAvatarSeat, money) def showArrow(self, seatIndex): self.hideArrow() guiIndex = self.getGuiIndex(seatIndex) self.playerStatusPanels[guiIndex].arrow.show() self.playerStatusPanels[guiIndex].actionLabel.hide() def hideArrow(self): map(lambda panel: panel.arrow.hide(), self.playerStatusPanels) def setPlayerActions(self, maxBet, playerActions): oldActions = self.playerActions self.playerActions = playerActions oldMaxBet = self.maxBet self.maxBet = maxBet for i, oldAction, newAction in zip(range(len(playerActions)), oldActions, playerActions): if oldAction != newAction: action, amount = newAction panel = self.playerStatusPanels[self.getGuiIndex(i)] hand = panel.hand label = panel.actionLabel if action == PlayingCardGlobals.CheckCall: if amount: actionText = PLocalizer.PokerCall else: actionText = PLocalizer.PokerCheck else: if action == PlayingCardGlobals.BetRaise: if oldMaxBet == 0: actionText = PLocalizer.PokerBetAmount % amount else: actionText = PLocalizer.PokerRaiseAmount % amount else: if action == PlayingCardGlobals.Fold: actionText = PLocalizer.PokerFold for card in hand: card.hide() panel.handNameLabel.hide() panel.arrow.hide() else: if action == PlayingCardGlobals.NoAction: actionText = '' panel.actionLabel.hide() else: if action == PlayingCardGlobals.SmallBlind: amount = self.table.anteList[1] actionText = PLocalizer.PokerSmallBlindAmount % amount else: if action == PlayingCardGlobals.BigBlind: amount = self.table.anteList[2] actionText = PLocalizer.PokerBigBlindAmount % amount else: if action == PlayingCardGlobals.Check: actionText = PLocalizer.PokerCheck else: if action == PlayingCardGlobals.AllIn: actionText = PLocalizer.PokerAllIn else: self.notify.error( 'Unknown action: %s' % action) panel.displayAction(actionText, self.table, i) def getGuiIndex(self, seatIndex): return (self.LocalAvatarGuiIndex - self.table.localAvatarSeat + seatIndex) % (self.table.NumSeats + 1) def clearTable(self): for panel in self.playerStatusPanels: for card in panel.hand: card.hide() panel.handNameLabel.hide() panel.actionLabel.hide() panel.dealerButton.hide() panel.anteLabel.hide() for i in range(len(self.communityCards)): card = self.communityCards[i] card.hide() def setTableState(self, round, buttonSeat, communityCardValues, playerHandValues, totalWinningsArray): self.clearTable() self.playerStatusPanels[self.getGuiIndex(buttonSeat)].anteLabel.show() self.playerStatusPanels[self.getGuiIndex( buttonSeat)].dealerButton.show() for i in range(len(self.communityCards)): card = self.communityCards[i] if i < len(communityCardValues): newValue = communityCardValues[i] card.show() card.setValue(newValue) if newValue != PlayingCardGlobals.Unknown: card.turnUp() else: card.hide() card.setValue(PlayingCardGlobals.Unknown) for i in range(len(playerHandValues)): newHand = playerHandValues[i] guiIndex = self.getGuiIndex(i) panel = self.playerStatusPanels[guiIndex] hand = panel.hand handNameLabel = panel.handNameLabel allUnknown = 1 for card, newValue in zip(hand, newHand): card.show() card.setValue(newValue) if newValue == PlayingCardGlobals.Unknown: card.turnDown() else: allUnknown = 0 card.turnUp() if allUnknown: panel.cardScaler.setScale(0.4) else: panel.cardScaler.setScale(0.5) if newHand: if PlayingCardGlobals.Unknown not in newHand: if self.table.handIdArray: seat = i handId = self.table.handIdArray[seat] sortedHand = handId > PlayingCardGlobals.Nothing and self.table.sortedCardsArray[ seat] handName = PLocalizer.getHandNameFull( self.table.handIdToHandCode(handId), sortedHand) handNameLabel['text'] = handName handNameLabel.show() end = False length = len(totalWinningsArray) for i in range(length): if totalWinningsArray[i] != 0: end = True break if (end and self).table.endOfHand: for i in range(length): if totalWinningsArray[i] > 0: actor = self.table.actors[i] if actor: name = actor.getName() win = totalWinningsArray[i] message = PLocalizer.PokerChatWinGoldMessage % (name, win) base.talkAssistant.receiveGameMessage(message) if totalWinningsArray[ i] == PlayingCardGlobals.PlayerCaughtCheating: actor = self.table.actors[i] if actor: name = actor.getName() message = PLocalizer.PokerChatCaughtCheatingMessage % name base.talkAssistant.receiveGameMessage(message) def setLocalAvatarHand(self, cardValues): map(lambda card: card.hide(), self.localStatusPanel.hand) self.localStatusPanel.cardScaler.setScale(0.5) for card, newValue in zip(self.localStatusPanel.hand, cardValues): card.show() card.setValue(newValue) if newValue != PlayingCardGlobals.Unknown: card.turnUp() handNameLabel = self.localStatusPanel.handNameLabel communityCardValues = map(lambda card: card.getValue(), self.communityCards) if cardValues: if PlayingCardGlobals.Unknown not in cardValues: (self.handId == PlayingCardGlobals.Nothing or self.sortedCards == None) and handNameLabel.hide() else: handName = PLocalizer.getHandNameFull( self.table.handIdToHandCode(self.handId), self.sortedCards) handNameLabel['text'] = handName handNameLabel.show() else: handNameLabel.hide() return def setPotSize(self, potSize): if potSize: self.potSizeLabel['text'] = PLocalizer.PokerPotAmount % potSize else: self.potSizeLabel['text'] = '' def enableActionCallback(self): pass def enableAction(self): chips = self.table.getPlayerChips() minimum = self.table.getMinimumBetAmount() if chips <= 0: self.table.allIn() else: self.cheat1Button.show() self.cheat2Button.show() self.passButton.show() self.betButton.show() self.foldButton.show() self.disableReason.hide() if self.table.checkCondition(): self.passButton['text'] = PLocalizer.PokerCheck self.passButton['extraArgs'] = [PlayingCardGlobals.Check] if chips > minimum: self.betButton[ 'text'] = PLocalizer.PokerBetAmount % minimum self.betButton['extraArgs'] = [PlayingCardGlobals.BetRaise] else: self.betButton[ 'text'] = PLocalizer.PokerAllInAmount % chips self.betButton['extraArgs'] = [ PlayingCardGlobals.AllIn, chips ] else: callAmount = self.table.getCallAmount() raiseAmount = self.table.maxBet + minimum if chips > callAmount: if callAmount == 0: self.passButton['text'] = PLocalizer.PokerCheck self.passButton['extraArgs'] = [ PlayingCardGlobals.Check ] else: self.passButton[ 'text'] = PLocalizer.PokerCallAmount % callAmount self.passButton['extraArgs'] = [ PlayingCardGlobals.CheckCall ] else: self.passButton[ 'text'] = PLocalizer.PokerAllInAmount % chips self.passButton['extraArgs'] = [ PlayingCardGlobals.AllIn, chips ] self.betButton.hide() if chips > callAmount + minimum: self.betButton[ 'text'] = PLocalizer.PokerRaiseAmount % raiseAmount self.betButton['extraArgs'] = [PlayingCardGlobals.BetRaise] else: self.betButton['text'] = PLocalizer.PokerAllInAmount % ( callAmount + chips) self.betButton['extraArgs'] = [ PlayingCardGlobals.AllIn, chips ] self.startTimer(PlayingCardGlobals.SecondsPerHand) def timeoutFold(self): self.hideActionButtons() self.hideCheatButtons() self.timeoutAction(PlayingCardGlobals.Fold) self.leaveButton.show() self.timeout = True self.deleteSwapDialog() def timeoutLeave(self): self.hideActionButtons() self.hideCheatButtons() self.timeoutAction(PlayingCardGlobals.Leave) self.timeout = True self.deleteSwapDialog() def timerExpiredCallback(self): self.numberOfTimeouts = self.numberOfTimeouts + 1 if self.numberOfTimeouts >= PlayingCardGlobals.MaximumTimeouts: self.timeoutLeave() else: self.timeoutFold() self.endTimer() def enableCheat(self): have_cheat_card = False for card_id in range(52): if self.table.getPlayerInventoryCardCount(card_id) > 0: have_cheat_card = True break if have_cheat_card: self.normalButton(self.cheat1Button) self.normalButton(self.cheat2Button) else: self.disableCheat() def disableCheat(self): self.disableButton(self.cheat1Button) self.disableButton(self.cheat2Button) def disableAction(self, reason=None): self.cheat1Button.hide() self.cheat2Button.hide() self.passButton.hide() self.betButton.hide() self.foldButton.hide() if reason: self.disableReason['text'] = reason self.disableReason.show() else: self.disableReason.hide() self.endTimer() def destroy(self): self.endTimer() self.deleteTableGUI() self.potSizeLabel.destroy() self.menu.destroy() del self.menu self.communityCardNode.removeNode() del self.communityCardNode for card in self.communityCards: card.removeNode() del self.communityCards for panel in self.playerStatusPanels: panel.destroy() del self.playerStatusPanels del self.localStatusPanel if self.table.wantMeter == 1: self.meter.removeNode() del self.meter self.meterBorder.removeNode() del self.meterBorder if self.table.wantMeter == 2: self.fulcrum.removeNode() del self.fulcrum self.balance.removeNode() del self.balance this = self if this.sfxArray: length = len(this.sfxArray) for i in range(length): sfx = this.sfxArray[i] this.sfxArray[i] = None if sfx: loader.unloadSfx(sfx) self.destroyed = True del self.table DirectFrame.destroy(self) return def getMeterPercent(self): return self.meter.getScale()[0] / self.meterMax * 100.0 def setMeterPercent(self, percent): curScale = self.meter.getScale() self.meter.setScale(self.meterMax * (percent / 100.0), curScale[1], curScale[2]) def getBalanceAngle(self): return self.balance.getR() def setBalanceAngle(self, angle): self.balance.setR(angle)
def destroy(self): self.parent = None self.fromCell = None self.doubleFrame.destroy() self.tripleFrame.destroy() BorderFrame.destroy(self)
class AmmoPanelButton(DirectButton): SkillIcons = None def __init__(self, callback, skillId, skillRank): if not AmmoPanelButton.SkillIcons: AmmoPanelButton.SkillIcons = loader.loadModel('models/textureCards/skillIcons') AmmoPanelButton.Image = (AmmoPanelButton.SkillIcons.find('**/base'), AmmoPanelButton.SkillIcons.find('**/base_down'), AmmoPanelButton.SkillIcons.find('**/base_over')) self.locked = True self.purchaseable = True self.cost = CannonDefenseGlobals.getDefenseCannonAmmoCost(skillId) self.amount = CannonDefenseGlobals.getDefenseCannonAmmoAmount(skillId) if self.amount == -1: self.amount = PLocalizer.Unlimited self.skillId = skillId self.skillRank = skillRank self.infoBox = None self.flashIval = None asset = RadialMenu.getSkillIconName(skillId, 0) geom = AmmoPanelButton.SkillIcons.find('**/%s' % asset) self.geom = geom if self.locked: asset = None geom = None DirectButton.__init__(self, relief = None, pos = (0, 0, 0), text = '?', text_scale = 0.10000000000000001, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_pos = (0.0050000000000000001, -0.035000000000000003), text_align = TextNode.ACenter, image = AmmoPanelButton.Image, image_scale = 0.12, geom = geom, geom_scale = 0.12, command = callback, textMayChange = 1, sortOrder = 70, extraArgs = [ skillId]) self.initialiseoptions(AmmoPanelButton) gui = loader.loadModel('models/gui/toplevel_gui') self.lockIcon = gui.find('**/pir_t_gui_gen_key_subscriber') if not Freebooter.getPaidStatus(base.localAvatar.doId) and skillId > CannonDefenseGlobals.FREEBOOTER_LAST_AMMO_AVAILABLE: self.lock = DirectFrame(parent = self, relief = None, image = self.lockIcon, image_scale = 0.14000000000000001, image_pos = (0.050000000000000003, 0, -0.025000000000000001), sortOrder = 99) self.bind(DGG.ENTER, self.showDetails) self.bind(DGG.EXIT, self.hideDetails) def createTextBox(self): if self.infoBox: return None globalPos = self.getPos(base.a2dLeftCenter) self.infoBox = None self.infoBox = BorderFrame(parent = base.a2dLeftCenter, frameSize = (-0.040000000000000001, 0.5, -0.25, 0.050000000000000003), pos = (globalPos.getX() + 0.12, 0, globalPos.getZ()), state = DGG.DISABLED) self.label = DirectLabel(parent = self.infoBox, relief = None, text = PLocalizer.CannonDefenseAmmoDesc % (PLocalizer.makeHeadingString(PLocalizer.InventoryTypeNames[self.skillId], 2), self.cost, self.amount, PLocalizer.CannonDefenseAmmoTypeDesc[self.skillId]), text_align = TextNode.ALeft, text_scale = PiratesGuiGlobals.TextScaleLarge, text_fg = PiratesGuiGlobals.TextFG2, text_wordwrap = 12, textMayChange = 1) if self.locked: memberText = '' if self.skillId > CannonDefenseGlobals.FREEBOOTER_LAST_AMMO_AVAILABLE: memberText = PLocalizer.VR_AuthAccess self.label['text'] = PLocalizer.CannonDefenseAmmoUnlockedAt % (CannonDefenseGlobals.getLevelUnlockedAt(self.skillId), memberText) self.infoBox.setBin('gui-cannonDefense', 4) def showDetails(self, event): self.createTextBox() def hideDetails(self, event): if self.infoBox: self.infoBox.destroy() self.infoBox = None def isLocked(self): return self.locked def unlock(self): if self.locked: self['text'] = '' self['geom'] = self.geom self['geom_scale'] = 0.12 self.locked = False def canPurchase(self, bankNotes): if not self.purchaseable: return False return bankNotes >= self.cost def enablePurchase(self): self.purchaseable = True self.setAlphaScale(1.0) def disablePurchase(self): self.purchaseable = False self.setAlphaScale(0.40000000000000002) def flash(self): if self.flashIval: self.flashIval.pause() self.flashIval = Sequence(LerpColorInterval(self, 0.25, color = VBase4(0.69999999999999996, 0.10000000000000001, 0.10000000000000001, 1.0), blendType = 'easeOut'), LerpColorInterval(self, 0.25, color = VBase4(1.0, 1.0, 1.0, 1.0), blendType = 'easeOut')) self.flashIval.start()
class SkillButton(DirectFrame): notify = directNotify.newCategory('SkillButton') SkillIcons = None Image = None SkillRechargedSound = None SubLock = None def __init__(self, skillId, callback, quantity=0, skillRank=0, showQuantity=False, showHelp=False, showRing=False, hotkey=None, name='', showIcon=True, showLock=False, rechargeSkillId=False, isWeaponSkill=False, assocAmmo=[]): DirectFrame.__init__(self, parent=NodePath(), relief=None) self.initialiseoptions(SkillButton) gui = loader.loadModel('models/gui/toplevel_gui') if not SkillButton.SkillIcons: print 'not SkillButton.SkillIcons:' SkillButton.SkillIcons = loader.loadModel( 'models/textureCards/skillIcons') SkillButton.Image = (SkillButton.SkillIcons.find('**/base'), SkillButton.SkillIcons.find('**/base_down'), SkillButton.SkillIcons.find('**/base_over')) SkillButton.SkillRechargedSound = loadSfx( SoundGlobals.SFX_SKILL_RECHARGED) SkillButton.SubLock = gui.find('**/pir_t_gui_gen_key_subscriber') SkillButton.SpecialIcons = [] for entry in SPECIAL_SKILL_ICONS: if not entry: SkillButton.SpecialIcons.append(None) continue specialImage = (SkillButton.SkillIcons.find('**/%s' % entry), ) SkillButton.SpecialIcons.append(specialImage) model = loader.loadModel('models/effects/particleMaps') toggleIcon = model.find('**/particleGlow') toggleIcon.node().setAttrib( ColorBlendAttrib.make(ColorBlendAttrib.MAdd)) self.toggleFrame = DirectFrame(relief=None, state=DGG.DISABLED, parent=self, image=toggleIcon, image_scale=0.34999999999999998, image_pos=(0.0, 0.0, -0.01)) self.toggleFrame.hide() self.glowRing = None self.glowRing2 = None self.assocAmmo = assocAmmo self.skillId = skillId self.quantity = quantity self.showQuantity = showQuantity self.skillRank = skillRank self.skillRing = None self.callback = callback self.showUpgrade = False self.showHelp = showHelp self.showRing = showRing self.showIcon = showIcon self.showLock = showLock self.isWeaponSkill = isWeaponSkill self.lock = None self.name = name self.helpFrame = None self.quantityLabel = None self.skillButton = None self.hotkeyLabel = None self.hotkey = hotkey self.greyOut = 0 self.tonicId = 0 self.skillRingIval = None self.impulseIval = None self.quickImpulseIval = None self.isBreakAttackSkill = WeaponGlobals.getSkillTrack( self.skillId) == WeaponGlobals.BREAK_ATTACK_SKILL_INDEX self.isDefenseSkill = WeaponGlobals.getSkillTrack( self.skillId) == WeaponGlobals.DEFENSE_SKILL_INDEX self.rechargeFilled = 0 self.defenseAuraEffect = None if self.isWeaponSkill: self.weaponBackground = DirectLabel( parent=self, state=DGG.DISABLED, image=SkillButton.SkillIcons.find('**/box_base'), image_scale=(0.22, 0, 0.22), image_pos=(0.0, 0.0, 0.0)) self.weaponBackground.flattenLight() self.weaponBackground.setColor(0.20000000000000001, 0.20000000000000001, 0.20000000000000001, 0.20000000000000001) self.weaponBackground.setTransparency(1) if showRing: if self.isBreakAttackSkill: color = Vec4(1, 0, 0, 1) elif self.isDefenseSkill: color = Vec4(0, 1, 1, 1) else: color = Vec4(1, 0.80000000000000004, 0.5, 1) self.skillRing = SkillRing(color, Vec4(0, 0, 0, 1.0)) gs = self.skillRing.meterFaceHalf2.node().getGeomState(0) self.skillRing.meterFaceHalf2.node().setGeomState( 0, gs.removeAttrib(ColorAttrib.getClassType())) self.skillRing.reparentTo(self, 0) self.skillRing.setPos(0, 0, 0) self.updateSkillId(skillId) if showQuantity: self.updateQuantity(quantity) if hotkey: self.createHotkey(hotkey) if showLock: self.createLock() self.skillButton.bind(DGG.ENTER, self.showDetails) self.skillButton.bind(DGG.EXIT, self.hideDetails) if self.skillId >= InventoryType.begin_Consumables and self.skillId <= InventoryType.end_Consumables and not WeaponGlobals.getSkillEffectFlag( skillId): self.totalRechargeTime = base.cr.battleMgr.getModifiedRechargeTime( localAvatar, InventoryType.UseItem) self.tonicId = InventoryType.UseItem else: self.totalRechargeTime = base.cr.battleMgr.getModifiedRechargeTime( localAvatar, self.skillId) if showRing: if not self.isBreakAttackSkill: self.createSkillRingIval() if self.tonicId: timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging( InventoryType.UseItem) else: timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging( self.skillId) if self.isBreakAttackSkill and timeSpentRecharging < self.totalRechargeTime: self.updateRechargeRing() elif not (self.isBreakAttackSkill): if (self.totalRechargeTime or timeSpentRecharging ) and not (timeSpentRecharging > self.totalRechargeTime): self.skillRingIval.start(startT=timeSpentRecharging) not (timeSpentRecharging > self.totalRechargeTime) self.skillRing.meterFaceHalf1.setR(0) self.skillRing.meterFaceHalf2.setR(180) self.skillRing.meterFaceHalf1.setColor( self.skillRing.meterActiveColor, 100) self.skillRing.meterFaceHalf2.setColor( self.skillRing.meterActiveColor, 100) self.skillRing.meterFaceHalf1.show() self.skillRing.meterFaceHalf2.show() if not self.isBreakAttackSkill: self.checkAmount() if self.isDefenseSkill: self.startRecharge() if self.isWeaponSkill: self.weaponLabel = DirectLabel( parent=self, relief=None, text=PLocalizer.WeaponAbility, text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_align=TextNode.ACenter, text_scale=PiratesGuiGlobals.TextScaleLarge, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, textMayChange=0, pos=(0.0, 0, -0.12), sortOrder=70, state=DGG.DISABLED) self.weaponLabel.flattenLight() def loadGlowRing(self): self.glowRing = loader.loadModel('models/effects/battleEffects').find( '**/effectVoodooShockwave') self.glowRing.node().setAttrib( ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOne)) self.glowRing.reparentTo(self) self.glowRing.setBin('transparent', 0) self.glowRing.setScale(0.20000000000000001) self.glowRing.hide() self.glowRing2 = loader.loadModel('models/effects/particleMaps').find( '**/particleGlow') self.glowRing2.node().setAttrib( ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OOneMinusIncomingAlpha, ColorBlendAttrib.OOne)) self.glowRing2.reparentTo(self) self.glowRing2.setBin('transparent', 0) self.glowRing2.setScale(0.20000000000000001) self.glowRing2.setColor(0.80000000000000004, 1, 0.80000000000000004, 0.20000000000000001) self.glowRing2.reparentTo(self) self.glowRing2.hide() def checkAmount(self): if not (self.quantity) and self.showQuantity: if self.showRing and not self.skillRingIval.isPlaying(): self.setGeomColor(0.5, 0.5, 0.5, 1.0) self.setRingColor(Vec4(0.5, 0.5, 0.5, 1.0)) elif self.showRing and not self.skillRingIval.isPlaying(): self.setGeomColor(1.0, 1.0, 1.0, 1.0) self.setRingColor(self.skillRing.meterActiveColor) def toggleButton(self, state): if state == True: self.toggleFrame.show() elif state == False: self.toggleFrame.hide() def createSkillRingIval(self): if self.skillRingIval: self.skillRingIval.pause() self.skillRing.meterFaceHalf1.setR(0) self.skillRing.meterFaceHalf2.setR(180) self.skillRing.setScale(1.0) self.skillRing.clearColorScale() self.setGeomColor(1.0, 1.0, 1.0, 1.0) self.checkAmount() self.skillRingIval = None if self.tonicId: timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging( InventoryType.UseItem) else: timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging( self.skillId) if self.isDefenseSkill: localAvatar.setDefenceEffect(self.skillId) if self.showRing: self.skillRingIval = Sequence( Func(localAvatar.setDefenceEffect, 0), Func(self.setGeomColor, 0.5, 0.5, 0.5, 1.0), Func(self.skillRing.meterFaceHalf1.setColor, self.skillRing.meterActiveColor, 100), Func(self.skillRing.meterFaceHalf2.setColor, self.skillRing.meterColor, 100), Func(self.skillRing.meterFaceHalf1.setR, 0), Func(self.skillRing.meterFaceHalf2.setR, 0), Func(self.skillRing.meterFaceHalf1.show), Func(self.skillRing.meterFaceHalf2.show), LerpFunc(self.skillRing.meterFaceHalf2.setR, self.totalRechargeTime / 2, 0, -180), Func(self.skillRing.meterFaceHalf2.setColor, self.skillRing.meterActiveColor, 100), Func(self.skillRing.meterFaceHalf2.setR, 0), LerpFunc(self.skillRing.meterFaceHalf1.setR, self.totalRechargeTime / 2, 0, -180), Func(self.setGeomColor, 1.0, 1.0, 1.0, 1.0), Func(base.playSfx, SkillButton.SkillRechargedSound, volume=0.5), Parallel( LerpScaleInterval(self.skillRing, 0.10000000000000001, Vec3(1.2, 1.2, 1.2)), LerpColorScaleInterval(self.skillRing, 0.10000000000000001, Vec4(0.0, 0.75, 0.0, 1.0), Vec4(1.0, 1.0, 1.0, 1.0), blendType='easeInOut')), Func(localAvatar.setDefenceEffect, self.skillId), LerpScaleInterval( self.skillRing, 0.20000000000000001, Vec3(0.90000000000000002, 0.90000000000000002, 0.90000000000000002)), LerpScaleInterval( self.skillRing, 0.029999999999999999, Vec3(1.1000000000000001, 1.1000000000000001, 1.1000000000000001)), Parallel( LerpScaleInterval(self.skillRing, 0.029999999999999999, Vec3(1.0, 1.0, 1.0)), LerpColorScaleInterval(self.skillRing, 1, Vec4(1.0, 1.0, 1.0, 1.0), blendType='easeInOut')), Func(self.skillRing.clearColorScale), Func(self.checkAmount)) def updateSkillRingIval(self): if self.showRing: playing = self.skillRingIval.isPlaying() if self.tonicId: timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging( InventoryType.UseItem) else: timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging( self.skillId) if timeSpentRecharging: skillRechargeProgress = timeSpentRecharging / self.totalRechargeTime self.totalRechargeTime = base.cr.battleMgr.getModifiedRechargeTime( localAvatar, self.skillId) if not self.totalRechargeTime: self.totalRechargeTime = base.cr.battleMgr.getModifiedRechargeTime( localAvatar, InventoryType.UseItem) if timeSpentRecharging: timeSpentRecharging = skillRechargeProgress * self.totalRechargeTime localAvatar.skillDiary.modifyTimeSpentRecharging( self.skillId, timeSpentRecharging) self.createSkillRingIval() if playing and timeSpentRecharging: self.skillRingIval.start(startT=timeSpentRecharging) def quickGlowImpulse(self): if not self.glowRing2: self.loadGlowRing() self.quickImpulseIval = Sequence( Func(self.glowRing2.show), LerpScaleInterval( self.glowRing2, 0.20000000000000001, Vec3(0.33000000000000002, 0.33000000000000002, 0.33000000000000002)), LerpScaleInterval( self.glowRing2, 0.25, Vec3(0.20000000000000001, 0.20000000000000001, 0.20000000000000001)), Func(self.glowRing2.hide)) self.quickImpulseIval.start() def startPowerImpulse(self): if not self.glowRing: self.loadGlowRing() self.glowRing.show() self.impulseIval = Sequence( Parallel( LerpScaleInterval( self.glowRing, 0.10000000000000001, Vec3(0.20300000000000001, 0.20300000000000001, 0.20300000000000001)), LerpColorScaleInterval(self.glowRing, 0.10000000000000001, Vec4(0.80000000000000004, 0.80000000000000004, 0.80000000000000004, 0.80000000000000004), Vec4(1.0, 1.0, 1.0, 0.80000000000000004), blendType='easeInOut')), LerpScaleInterval(self.glowRing, 0.14999999999999999, Vec3(0.19, 0.19, 0.19)), LerpScaleInterval( self.glowRing, 0.050000000000000003, Vec3(0.20200000000000001, 0.20200000000000001, 0.20200000000000001)), Parallel( LerpScaleInterval( self.glowRing, 0.029999999999999999, Vec3(0.20000000000000001, 0.20000000000000001, 0.20000000000000001)), LerpColorScaleInterval(self.glowRing, 0.40000000000000002, Vec4(1.0, 1.0, 1.0, 1.0), blendType='easeInOut')), Func(self.glowRing.clearColorScale)) self.impulseIval.loop() def stopPowerImpulse(self): if self.glowRing: self.glowRing.hide() if self.impulseIval: self.impulseIval.finish() self.impulseIval = None def updateRechargeRing(self): timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging( self.skillId) self.totalRechargeTime = base.cr.battleMgr.getModifiedRechargeTime( localAvatar, self.skillId) if timeSpentRecharging >= self.totalRechargeTime and not ( self.rechargeFilled): self.rechargeFilled = 1 if self.skillRingIval: self.skillRingIval.pause() self.skillRingIval = None self.skillRing.meterFaceHalf1.setR(0) self.skillRing.meterFaceHalf2.setR(180) self.skillRing.setScale(1.0) self.skillRing.clearColorScale() self.setGeomColor(1.0, 1.0, 1.0, 1.0) self.skillRingIval = Sequence( Func(base.playSfx, SkillButton.SkillRechargedSound, volume=0.5), Parallel( LerpScaleInterval(self.skillRing, 0.10000000000000001, Vec3(1.2, 1.2, 1.2)), LerpColorScaleInterval(self.skillRing, 0.10000000000000001, Vec4(0.0, 0.75, 0.0, 1.0), Vec4(1.0, 1.0, 1.0, 1.0), blendType='easeInOut')), Func(localAvatar.setDefenceEffect, self.skillId), LerpScaleInterval( self.skillRing, 0.20000000000000001, Vec3(0.90000000000000002, 0.90000000000000002, 0.90000000000000002)), LerpScaleInterval( self.skillRing, 0.029999999999999999, Vec3(1.1000000000000001, 1.1000000000000001, 1.1000000000000001)), Parallel( LerpScaleInterval(self.skillRing, 0.029999999999999999, Vec3(1.0, 1.0, 1.0)), LerpColorScaleInterval(self.skillRing, 1, Vec4(1.0, 1.0, 1.0, 1.0), blendType='easeInOut')), Func(self.skillRing.clearColorScale)) self.skillRingIval.start() elif timeSpentRecharging < self.totalRechargeTime: self.rechargeFilled = 0 self.setGeomColor(0.5, 0.5, 0.5, 1.0) self.skillRing.update(timeSpentRecharging, self.totalRechargeTime) def updateSkillId(self, skillId): self.skillId = skillId if self.skillButton: if self.quantityLabel: self.quantityLabel.detachNode() self.skillButton.destroy() if self.showQuantity and not (self.quantity): geomColor = Vec4(0.5, 0.5, 0.5, 1.0) else: geomColor = Vec4(1.0, 1.0, 1.0, 1.0) if self.showIcon: asset = WeaponGlobals.getSkillIcon(skillId) if hasattr(self, '_skillIconName'): asset = self._skillIconName geom = SkillButton.SkillIcons.find('**/%s' % asset) if geom.isEmpty(): geom = SkillButton.SkillIcons.find('**/base') repId = WeaponGlobals.getSkillReputationCategoryId(self.skillId) geom_scale = getGeomScale(repId, skillId) image_color = (1, 1, 1, 1) else: geom = (None, ) geom_scale = 0.12 image_color = (0.5, 0.5, 0.5, 0.5) specialIconId = 0 if self.isBreakAttackSkill: specialIconId = 1 elif self.isDefenseSkill: specialIconId = 2 elif skillId == ItemGlobals.getSpecialAttack( localAvatar.currentWeaponId): specialIconId = 3 if specialIconId: something = SkillButton.SpecialIcons[specialIconId][0] if self.skillRing: self.skillRing.setupFace(something) self['image'] = None elif self.skillRing: self.skillRing.setupFace() if self.showRing: image = None else: image = SkillButton.Image self.skillButton = DirectButton(parent=self, relief=None, pos=(0, 0, 0), text=('', '', self.name), text_align=TextNode.ACenter, text_shadow=Vec4(0, 0, 0, 1), text_scale=0.040000000000000001, text_fg=Vec4(1, 1, 1, 1), text_pos=(0.0, 0.089999999999999997), image=image, image_scale=0.14999999999999999, image_color=image_color, geom=geom, geom_scale=geom_scale, geom_color=geomColor, command=self.callback, sortOrder=50, extraArgs=[skillId]) self.skillButton.bind(DGG.ENTER, self.showDetails) self.skillButton.bind(DGG.EXIT, self.hideDetails) if self.quantityLabel and not self.quantityLabel.isEmpty(): self.quantityLabel.reparentTo(self.skillButton) def createHotkey(self, hotkey): self.hotkeyLabel = DirectLabel( parent=self, relief=None, text=hotkey, text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_align=TextNode.ARight, text_scale=PiratesGuiGlobals.TextScaleLarge, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, textMayChange=0, pos=(0.070000000000000007, 0, -0.059999999999999998), sortOrder=70, state=DGG.DISABLED) self.hotkeyLabel.flattenLight() def createLock(self): if self.lock: return None self.lock = DirectFrame(parent=self, relief=None, image=SkillButton.SubLock, image_scale=0.14000000000000001, image_pos=(0.050000000000000003, 0, -0.025000000000000001), sortOrder=99) if self.showIcon: self.lock.setColorScale(0.90000000000000002, 0.90000000000000002, 0.90000000000000002, 1) self.skillButton.setColorScale(0.40000000000000002, 0.40000000000000002, 0.40000000000000002, 1, 1) else: self.lock.setColorScale(0.59999999999999998, 0.59999999999999998, 0.59999999999999998, 1, 2) self.skillButton.clearColorScale() if self.showHelp: self.lock.hide() def createHelpFrame(self, args=None): if self.helpFrame: return None inv = localAvatar.getInventory() if not inv: return None baseRank = max(self.skillRank, 1) lvlDamageMod = WeaponGlobals.getLevelDamageModifier( localAvatar.getLevel()) buff = WeaponGlobals.getSkillEffectFlag(self.skillId) dur = WeaponGlobals.getAttackDuration(self.skillId) effect = dur + dur * (baseRank - 1) / 4.0 bonus = localAvatar.getSkillRankBonus(self.skillId) upgradeAmt = WeaponGlobals.getAttackUpgrade(self.skillId) rank = localAvatar.getSkillRank(self.skillId) skillBoost = 0 if self.skillId in ItemGlobals.getLinkedSkills( localAvatar.currentWeaponId): linkedSkillId = WeaponGlobals.getLinkedSkillId(self.skillId) skillBoost = ItemGlobals.getWeaponBoosts( localAvatar.currentWeaponId, linkedSkillId) skillBoost += ItemGlobals.getWeaponBoosts( localAvatar.getCurrentCharm(), linkedSkillId) else: skillBoost = ItemGlobals.getWeaponBoosts( localAvatar.currentWeaponId, self.skillId) skillBoost += ItemGlobals.getWeaponBoosts( localAvatar.getCurrentCharm(), self.skillId) manaCost = 0 if WeaponGlobals.getSkillTrack( self.skillId) != WeaponGlobals.PASSIVE_SKILL_INDEX: manaCost = WeaponGlobals.getMojoCost(self.skillId) if manaCost < 0: amt = localAvatar.getSkillRankBonus( InventoryType.StaffConservation) manaCost = min(manaCost - manaCost * amt, 1.0) damage = 0 loDamage = 0 mpDamage = 0 mpLoDamage = 0 if WeaponGlobals.getSkillTrack( self.skillId) == WeaponGlobals.TONIC_SKILL_INDEX: damage = WeaponGlobals.getAttackSelfHP(self.skillId) elif WeaponGlobals.getSkillTrack( self.skillId) != WeaponGlobals.PASSIVE_SKILL_INDEX: mod = (1.0 + bonus) * lvlDamageMod damage = int(WeaponGlobals.getAttackTargetHP(self.skillId) * mod) loDamage = damage / 2 mpDamage = int( WeaponGlobals.getAttackTargetMojo(self.skillId) * mod) mpLoDamage = mpDamage / 2 try: skillInfo = PLocalizer.SkillDescriptions.get(self.skillId) skillTitle = PLocalizer.makeHeadingString( PLocalizer.InventoryTypeNames.get(self.skillId), 2) skillType = PLocalizer.makeHeadingString(skillInfo[0], 1) except: self.notify.error('Error getting skill info for skillId %s' % self.skillId) description = skillInfo[1] if damage < 0: description += ' ' + PLocalizer.DealsDamage elif damage > 0: if loDamage: loDamage = 0 description += ' ' + PLocalizer.HealsDamageRange else: description += ' ' + PLocalizer.HealsDamage if mpDamage < 0: description += ' ' + PLocalizer.DealsMpDamage effectId = WeaponGlobals.getSkillEffectFlag(self.skillId) if effectId: description += ' ' + SkillEffectDescriptions.get(effectId)[0] if bonus: if self.skillId == InventoryType.SailBroadsideLeft or self.skillId == InventoryType.SailBroadsideRight: description += ' ' + PLocalizer.BroadsideDesc if self.skillId == InventoryType.CannonShoot: description += ' ' + PLocalizer.CannonShootDesc if self.skillId == InventoryType.DollAttune: description += ' ' + PLocalizer.MultiAttuneDesc if WeaponGlobals.getSkillInterrupt(self.skillId): description += ' ' + PLocalizer.InterruptDesc if WeaponGlobals.getSkillUnattune(self.skillId): description += ' ' + PLocalizer.UnattuneDesc upgradeInfo = '' if self.showUpgrade and rank < 5: if rank > 0: upgradeInfo = skillInfo[2] if upgradeInfo == '': if damage < 0: upgradeInfo += PLocalizer.UpgradesDamage elif damage > 0: upgradeInfo += PLocalizer.UpgradesHealing if mpDamage < 0: upgradeInfo += ' ' + PLocalizer.UpgradesMpDamage if effectId: entry = SkillEffectDescriptions.get(effectId) if len(entry) > 1: if not damage: upgradeInfo += PLocalizer.UpgradesDuration else: upgradeInfo += ' ' + PLocalizer.And upgradeInfo += ' ' + entry[1] upgradeInfo += '!' elif len(upgradeInfo) >= 4: upgradeInfo = skillInfo[3] else: upgradeInfo = PLocalizer.ClickToLearn elif not self.showIcon: unlockLevel = RepChart.getSkillUnlockLevel(self.skillId) if unlockLevel > 0: upgradeInfo = PLocalizer.UnlocksAtLevel % unlockLevel if self.skillId in SkillComboReq and SkillComboReq[ self.skillId] and inv.getStackQuantity(self.skillId - 1) < 2: color = 'red' if rank == 0: color = 'red' upgradeInfo = '' description += '\n' + color + SkillComboReq[self.skillId] + '.' skillDesc = skillTitle + '\n' + skillType + '\n\n' + description + '\ngreen' + upgradeInfo stats = [] if manaCost: stats.append(abs(manaCost)) if damage and loDamage: stats.append(abs(loDamage)) stats.append(abs(damage)) elif damage: stats.append(abs(damage)) if mpDamage: stats.append(abs(mpLoDamage)) stats.append(abs(mpDamage)) if buff == WeaponGlobals.C_CURSE: stats.append(WeaponGlobals.CURSED_DAM_AMP * 100) if buff == WeaponGlobals.C_WEAKEN: stats.append(WeaponGlobals.WEAKEN_PENALTY * 100) if effect > 0: stats.append(effect) if skillInfo[4]: if bonus == 0 and upgradeAmt > 0: if not self.skillId == InventoryType.SailBroadsideLeft and self.skillId == InventoryType.SailBroadsideRight: pass if not (self.skillId == InventoryType.CannonShoot): bonus = upgradeAmt if upgradeAmt < 1.0 and upgradeAmt > 0: bonus *= 100 if self.skillId == InventoryType.SailTreasureSense: bonus /= 2.0 elif self.skillId == InventoryType.CutlassParry: bonus += WeaponGlobals.getSubtypeParryBonus( localAvatar.currentWeaponId) if bonus: stats.append(abs(bonus)) if self.skillId == InventoryType.DollAttune: stats.append(rank) if self.skillRank: rankText = DirectFrame(parent=self, relief=None, text=PLocalizer.makeHeadingString( PLocalizer.Rank + ' %s' % (self.skillRank + skillBoost), 2), text_align=TextNode.ARight, text_scale=PiratesGuiGlobals.TextScaleSmall, text_fg=PiratesGuiGlobals.TextFG2, text_wordwrap=15, text_shadow=(0, 0, 0, 1), pos=(0.45000000000000001, 0, 0), textMayChange=1, sortOrder=92, state=DGG.DISABLED) stats = [stat + 0.01 for stat in stats] try: pass except TypeError: self.notify.error('Error formatting skillDesc(%s): %s' % (self.skillId, stats)) helpText = DirectFrame(parent=self, relief=None, text=skillDesc % stats, text_align=TextNode.ALeft, text_scale=PiratesGuiGlobals.TextScaleSmall, text_fg=PiratesGuiGlobals.TextFG2, text_wordwrap=17, textMayChange=1, state=DGG.DISABLED, sortOrder=91) height = -(helpText.getHeight() + 0.01) if self.lock: height = height - 0.040000000000000001 width = 0.55000000000000004 self.helpFrame = BorderFrame(parent=self, state=DGG.DISABLED, frameSize=(-0.040000000000000001, width, height, 0.050000000000000003), pos=(0, 0, -0.12), sortOrder=90) self.helpFrame.setBin('gui-popup', 0) helpText.reparentTo(self.helpFrame) if self.skillRank: rankText.reparentTo(self.helpFrame) if self.lock: self.lockedFrame = DirectFrame( parent=self.helpFrame, relief=None, pos=(0.087999999999999995, 0, height + 0.029999999999999999), image=SkillButton.SubLock, image_scale=0.13, image_pos=(-0.055, 0, 0.012999999999999999), text=PLocalizer.VR_AuthAccess, text_scale=PiratesGuiGlobals.TextScaleSmall, text_align=TextNode.ALeft, text_fg=PiratesGuiGlobals.TextFG13) self.notify.debug('locked!') pos = self.helpFrame.getPos(aspect2d) x = min(pos[0], base.a2dRight - width) z = max(pos[2], base.a2dBottom - height) self.helpFrame.setPos(aspect2d, x, 0, z) def showDetails(self, event): if self.showHelp: self.createHelpFrame() if self.showRing: self.skillRing.rollover(True) def hideDetails(self, event): if self.helpFrame: self.helpFrame.destroy() self.helpFrame = None if self.showRing: self.skillRing.rollover(False) def updateQuantity(self, quantity): self.quantity = quantity if not self.showQuantity: return None if quantity == WeaponGlobals.INF_QUANT: text = '' elif self.assocAmmo: assocQuantity = 0 inv = localAvatar.getInventory() if inv: for ammoId in self.assocAmmo: assocQuantity += inv.getItemQuantity( self.getAmmoCat(), ammoId) if quantity != assocQuantity: text = '%s' % assocQuantity else: text = 'x%s' % quantity else: text = 'x%s' % quantity if self.quantityLabel and not self.quantityLabel.isEmpty(): self.quantityLabel['text'] = text else: self.quantityLabel = DirectLabel( parent=NodePath(), relief=None, state=DGG.DISABLED, text=text, frameColor=(0, 0, 0, 1), frameSize=(-0.01, 0.02, -0.01, 0.025000000000000001), text_scale=PiratesGuiGlobals.TextScaleLarge, text_align=TextNode.ACenter, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, text_wordwrap=11, pos=(0.029999999999999999, 0.0, 0.029999999999999999), text_font=PiratesGlobals.getPirateBoldOutlineFont(), sortOrder=60) self.quantityLabel.flattenLight() self.quantityLabel.reparentTo(self) if self.skillButton and not self.skillButton.isEmpty(): self.quantityLabel.reparentTo(self.skillButton) def getAmmoCat(self): pass def startRecharge(self): if not self.showRing: return None if self.isBreakAttackSkill: self.setGeomColor(0.5, 0.5, 0.5, 1.0) self.updateRechargeRing() return None if self.skillRingIval.isPlaying(): self.createSkillRingIval() self.skillRingIval.start() def stopRecharge(self): if self.showRing: if self.isBreakAttackSkill: self.setGeomColor(0.5, 0.5, 0.5, 1.0) self.updateRechargeRing() return None if self.skillRingIval.isPlaying(): self.skillRingIval.pause() def setGeomColor(self, r, g, b, a): self.skillButton['geom_color'] = Vec4(r, g, b, a) def setRingColor(self, color): self.skillRing.meterFaceHalf1.setColor(color[0], color[1], color[2], color[3], 100) self.skillRing.meterFaceHalf2.setColor(color[0], color[1], color[2], color[3], 100) def setShowUpgrade(self, show): if self.showUpgrade != show: self.showUpgrade = show if self.helpFrame: self.helpFrame.destroy() self.helpFrame = None self.showDetails(None) def setShowIcon(self, show): if self.showIcon != show: self.showIcon = show self.updateSkillId(self.skillId) if self.helpFrame: self.helpFrame.destroy() self.helpFrame = None def setShowLock(self, show): if self.showLock != show: self.showLock = show if show: self.createLock() elif self.lock: self.lock.destroy() self.lock = None self.skillButton.clearColorScale() def destroy(self): self.callback = None if self.skillRingIval: self.skillRingIval.pause() self.skillRingIval = None if self.quantityLabel: self.quantityLabel.destroy() self.quantityLabel = None if self.impulseIval: self.impulseIval.pause() self.impulseIval = None if self.quickImpulseIval: self.quickImpulseIval.pause() self.quickImpulseIval = None self.ignoreAll() DirectFrame.destroy(self)
class BoardingPermissionPanel(GuiPanel): def __init__(self, parent, *args, **kw): self.guiSetup = False optiondefs = (('parent', parent, None), ('pos', (-0.57999999999999996, 0, -0.089999999999999997), None), ('command', None, None), ('extraArgs', [], None), ('ownShip', 0, None)) self.defineoptions(kw, optiondefs) GuiPanel.__init__(self, title = PLocalizer.BoardPermTitle, h = 0.80000000000000004, w = 0.5, titleSize = 1.5, showClose = False) self.initialiseoptions(BoardingPermissionPanel) self.titleLabel['text_align'] = TextNode.ACenter self.titleLabel.setPos(0.23000000000000001, 0, 0.71999999999999997) self.setupGui() def destroy(self): self.button = None self.background = None self.friendsButton = None self.crewButton = None self.guildButton = None self.publicButton = None GuiPanel.destroy(self) def setupGui(self): self.destroyGui() if not self.guiSetup: self.button = DialogButton(parent = self, buttonStyle = DialogButton.NO, pos = (0.25, 0, 0.080000000000000002), text = PLocalizer.lClose, helpPos = (-0.40000000000000002, 0, 0.029999999999999999), helpDelay = 0.29999999999999999, command = self['command'], extraArgs = self['extraArgs']) self.background = BorderFrame(parent = self, pos = (0.050000000000000003, 0, 0.050000000000000003), frameSize = [ 0.0, 0.40000000000000002, 0.10000000000000001, 0.59999999999999998], bgColorScale = VBase4(0, 0, 0, 0.75), bgTransparency = 1, flatten = 0) if self['ownShip']: state = DGG.NORMAL else: state = DGG.DISABLED ship = localAvatar.getShip() if ship: friendState = ship.getAllowFriendState() crewState = ship.getAllowCrewState() guildState = ship.getAllowGuildState() publicState = ship.getAllowPublicState() else: friendState = 0 crewState = 0 guildState = 0 publicState = 0 buttonOptions = { 'parent': self.background, 'state': state, 'relief': None, 'pos': (0.059999999999999998, 0, 0.53000000000000003), 'scale': 0.29999999999999999, 'text': PLocalizer.CrewBoardingAccessAllowFriends, 'value': friendState, 'text_pos': (0.16700000000000001, -0.059999999999999998, 0), 'text0_fg': PiratesGuiGlobals.TextFG1, 'text1_fg': PiratesGuiGlobals.TextFG1, 'text2_fg': PiratesGuiGlobals.TextFG1, 'text3_fg': PiratesGuiGlobals.TextFG9, 'text_font': PiratesGlobals.getInterfaceFont(), 'text_scale': 0.14999999999999999, 'text_shadow': (0, 0, 0, 1), 'text_align': TextNode.ALeft, 'command': self.allowFriends } self.friendsButton = CheckButton(**None) buttonOptions['text'] = PLocalizer.CrewBoardingAccessAllowCrew buttonOptions['pos'] = (buttonOptions['pos'][0], buttonOptions['pos'][1], buttonOptions['pos'][2] - 0.12) buttonOptions['command'] = self.allowCrew buttonOptions['value'] = crewState self.crewButton = CheckButton(**None) buttonOptions['text'] = PLocalizer.CrewBoardingAccessAllowGuild buttonOptions['pos'] = (buttonOptions['pos'][0], buttonOptions['pos'][1], buttonOptions['pos'][2] - 0.12) buttonOptions['command'] = self.allowGuild buttonOptions['value'] = guildState self.guildButton = CheckButton(**None) buttonOptions['text'] = PLocalizer.CrewBoardingAccessAllowPublic buttonOptions['pos'] = (buttonOptions['pos'][0], buttonOptions['pos'][1], buttonOptions['pos'][2] - 0.12) buttonOptions['command'] = self.allowPublic buttonOptions['value'] = publicState self.publicButton = CheckButton(**None) self.guiSetup = True def destroyGui(self): if self.guiSetup: self.background.destroy() self.background = None self.friendsButton.destroy() self.friendsButton = None self.crewButton.destroy() self.crewButton = None self.guildButton.destroy() self.guildButton = None self.publicButton.destroy() self.publicButton = None self.button.destroy() self.button = None self.guiSetup = False def allowFriends(self, allow): if self['ownShip']: ship = localAvatar.getShip() if ship: ship.b_setAllowFriendState(allow) def allowCrew(self, allow): if self['ownShip']: ship = localAvatar.getShip() if ship: ship.b_setAllowCrewState(allow) def allowGuild(self, allow): if self['ownShip']: ship = localAvatar.getShip() if ship: ship.b_setAllowGuildState(allow) def allowPublic(self, allow): if self['ownShip']: ship = localAvatar.getShip() if ship: ship.b_setAllowPublicState(allow) def setAllowFriends(self, allow): self.friendsButton['value'] = allow def setAllowCrew(self, allow): self.crewButton['value'] = allow def setAllowGuild(self, allow): self.guildButton['value'] = allow def setAllowPublic(self, allow): self.publicButton['value'] = allow
class SkillpageGuiButton(DirectButton): SkillIcons = None def __init__(self, callback, skillId, skillRank): if not SkillpageGuiButton.SkillIcons: SkillpageGuiButton.SkillIcons = loader.loadModel('models/textureCards/skillIcons') SkillpageGuiButton.Image = (SkillpageGuiButton.SkillIcons.find('**/base'), SkillpageGuiButton.SkillIcons.find('**/base_down'), SkillpageGuiButton.SkillIcons.find('**/base_over')) asset = RadialMenu.getSkillIconName(skillId, 0) geom = SkillpageGuiButton.SkillIcons.find('**/%s' % asset) DirectButton.__init__(self, relief = None, pos = (0, 0, 0), image = SkillpageGuiButton.Image, image_scale = 0.12, geom = geom, geom_scale = 0.12, command = callback, textMayChange = 1, sortOrder = 70, extraArgs = [ skillId]) self.initialiseoptions(SkillpageGuiButton) self.skillId = skillId self.skillRank = skillRank self.showUpgrade = 0 self.helpBox = None self.quantity = None self.bind(DGG.ENTER, self.showDetails) self.bind(DGG.EXIT, self.hideDetails) def createHelpbox(self, args = None): if self.helpBox: return None baseRank = max(self.skillRank, 1) lvlDamageMod = WeaponGlobals.getLevelDamageModifier(localAvatar.getLevel()) buff = WeaponGlobals.getSkillEffectFlag(self.skillId) dur = WeaponGlobals.getAttackDuration(self.skillId) effect = dur + dur * (baseRank - 1) / 4 dodge = WeaponGlobals.getAttackDodge(self.skillId) * baseRank accuracy = 0 damageMod = 0 reduceDamMod = 0 rechargeMod = 0 shipTurningMod = 0 shipSpeedMod = 0 rangeMod = 0 treasureSenseMod = 0 manaCost = WeaponGlobals.getMojoCost(self.skillId) damage = 0 loDamage = 0 mpDamage = 0 chargeMod = 0 if self.skillId == InventoryType.SailBroadsideLeft or self.skillId == InventoryType.SailBroadsideRight: damageMod = WeaponGlobals.getAttackTargetHP(self.skillId) * (baseRank - 1) * 100 elif self.skillId == InventoryType.CannonShoot: rechargeMod = WeaponGlobals.CANNON_SHOOT_RATE_REDUCTION * (baseRank - 1) * 100 elif WeaponGlobals.getSkillTrack(self.skillId) == WeaponGlobals.TONIC_SKILL_INDEX: damage = WeaponGlobals.getAttackSelfHP(self.skillId) elif WeaponGlobals.getSkillTrack(self.skillId) != WeaponGlobals.PASSIVE_SKILL_INDEX: damage = int(WeaponGlobals.getAttackTargetHP(self.skillId) * (1.0 + WeaponGlobals.LEVELUP_DAMAGE_MULTIPLIER * (baseRank - 1))) * lvlDamageMod loDamage = damage / 2 mpDamage = int(WeaponGlobals.getAttackTargetMojo(self.skillId) * (1.0 + WeaponGlobals.LEVELUP_DAMAGE_MULTIPLIER * (baseRank - 1))) * lvlDamageMod mpLoDamage = mpDamage / 2 else: accuracy = WeaponGlobals.getAttackAccuracy(self.skillId) * baseRank damageMod = WeaponGlobals.getAttackTargetHP(self.skillId) * baseRank * 100 reduceDamMod = WeaponGlobals.getAttackSelfHP(self.skillId) * baseRank if reduceDamMod < 1: reduceDamMod *= 100 if effect < 1: effect *= 100 rechargeMod = WeaponGlobals.getAttackRechargeTime(self.skillId) * baseRank * 100 shipTurningMod = WeaponGlobals.getShipTurnRate(self.skillId) * baseRank * 100 shipSpeedMod = WeaponGlobals.getShipMaxSpeed(self.skillId) * baseRank * 100 treasureSenseMod = (WeaponGlobals.TREASURE_SENSE_BONUS / 2) * baseRank rangeMod = WeaponGlobals.getAttackRange(self.skillId) * baseRank manaCost *= baseRank chargeMod = WeaponGlobals.getAttackMaxCharge(self.skillId) * baseRank * 100 if self.skillId == InventoryType.StaffSpiritLore: import pdb as pdb pdb.set_trace() skillInfo = PLocalizer.SkillDescriptions.get(self.skillId) skillTitle = PLocalizer.InventoryTypeNames.get(self.skillId) skillType = 'slant' + skillInfo[0] + '\n\n' description = skillInfo[1] if damage < 0: description += ' ' + PLocalizer.DealsDamage elif damage > 0: if loDamage: description += ' ' + PLocalizer.HealsDamageRange else: description += ' ' + PLocalizer.HealsDamage if mpDamage < 0: description += ' ' + PLocalizer.DealsMpDamage effectId = WeaponGlobals.getSkillEffectFlag(self.skillId) if effectId: description += ' ' + SkillEffectDescriptions.get(effectId)[0] if (self.skillId == InventoryType.SailBroadsideLeft or self.skillId == InventoryType.SailBroadsideRight) and damageMod > 0: description += ' ' + PLocalizer.BroadsideDesc if self.skillId == InventoryType.CannonShoot and rechargeMod: description += ' ' + PLocalizer.CannonShootDesc if self.skillId == InventoryType.DollAttune: description += ' ' + PLocalizer.MultiAttuneDesc if WeaponGlobals.getSkillInterrupt(self.skillId): description += ' ' + PLocalizer.InterruptDesc if WeaponGlobals.getSkillUnattune(self.skillId): description += ' ' + PLocalizer.UnattuneDesc upgradeInfo = '' if self.showUpgrade and self.skillRank < 5: if self.skillRank > 0: upgradeInfo = skillInfo[2] if upgradeInfo == '': if damage < 0: upgradeInfo += PLocalizer.UpgradesDamage elif damage > 0: upgradeInfo += PLocalizer.UpgradesHealing if mpDamage < 0: upgradeInfo += ' ' + PLocalizer.UpgradesMpDamage if effectId: entry = SkillEffectDescriptions.get(effectId) if len(entry) > 1: if not damage: upgradeInfo += PLocalizer.UpgradesDuration else: upgradeInfo += ' ' + PLocalizer.And upgradeInfo += ' ' + entry[1] upgradeInfo += '!' elif len(upgradeInfo) >= 4: upgradeInfo = skillInfo[3] else: upgradeInfo = PLocalizer.ClickToLearn if self.skillId in SkillComboReq and SkillComboReq[self.skillId] and self.skillRank <= 1: description += ' ' + SkillComboReq[self.skillId] skillDesc = 'goldsmallCaps' + skillTitle + '\n' + skillType + description + '\ngreen' + upgradeInfo + '' stats = [] if manaCost: stats.append(abs(manaCost)) if damage and loDamage: stats.append(abs(loDamage)) stats.append(abs(damage)) elif damage: stats.append(abs(damage)) if mpDamage: stats.append(abs(mpLoDamage)) stats.append(abs(mpDamage)) if buff == WeaponGlobals.C_CURSE: stats.append(WeaponGlobals.CURSED_DAM_AMP * 100) if buff == WeaponGlobals.C_ATTUNE and baseRank > 1: stats.append(baseRank) if buff == WeaponGlobals.C_WEAKEN: stats.append(WeaponGlobals.WEAKEN_PENALTY * 100) if effect > 0: stats.append(effect) if dodge: stats.append(abs(dodge)) if accuracy: stats.append(abs(accuracy)) if damageMod: stats.append(abs(damageMod)) if reduceDamMod: stats.append(abs(reduceDamMod)) if rechargeMod: stats.append(abs(rechargeMod)) if shipTurningMod: stats.append(abs(shipTurningMod)) if shipSpeedMod: stats.append(abs(shipSpeedMod)) if chargeMod: stats.append(abs(chargeMod)) if rangeMod: stats.append(abs(rangeMod)) if self.skillId == InventoryType.SailTreasureSense: stats.append(abs(treasureSenseMod)) stats = tuple(stats) if self.skillRank: self.rankText = DirectFrame(parent = self, relief = None, text = ('goldsmallCaps' + PLocalizer.Rank + ' %d' + '') % self.skillRank, text_align = TextNode.ARight, text_scale = PiratesGuiGlobals.TextScaleSmall, text_fg = PiratesGuiGlobals.TextFG2, text_wordwrap = 15, text_shadow = (0, 0, 0, 1), pos = (0.45000000000000001, 0, 0), textMayChange = 1, sortOrder = 92, state = DGG.DISABLED) self.helpText = DirectFrame(parent = self, relief = None, text = skillDesc % stats, text_align = TextNode.ALeft, text_scale = PiratesGuiGlobals.TextScaleSmall, text_fg = PiratesGuiGlobals.TextFG2, text_wordwrap = 15, text_shadow = (0, 0, 0, 1), textMayChange = 1, sortOrder = 91, state = DGG.DISABLED) height = -(self.helpText.getHeight() + 0.01) self.helpBox = BorderFrame(parent = self, frameSize = (-0.040000000000000001, 0.5, height, 0.050000000000000003), pos = (0, 0, -0.12), sortOrder = 90, state = DGG.DISABLED) self.helpBox.setBin('gui-popup', 0) self.helpText.reparentTo(self.helpBox) if self.skillRank: self.rankText.reparentTo(self.helpBox) def destroy(self): if self.quantity: self.quantity.destroy() self.quantity = None self.ignoreAll() DirectButton.destroy(self) def showDetails(self, event): self.createHelpbox() def hideDetails(self, event): if self.helpBox: self.helpBox.destroy() self.helpBox = None def attachQuantity(self, quantity): if self.quantity: self.quantity['text'] = 'x%s' % quantity else: self.quantity = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = 'x%s' % quantity, frameColor = (0, 0, 0, 1), frameSize = (-0.01, 0.02, -0.01, 0.025000000000000001), text_scale = 0.0275, text_align = TextNode.ACenter, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_wordwrap = 11, pos = (0.029999999999999999, 0.0, 0.029999999999999999), text_font = PiratesGlobals.getPirateBoldOutlineFont())
class SongItemGui(SongListItem): width = PiratesGuiGlobals.InventoryItemGuiWidth height = PiratesGuiGlobals.InventoryItemGuiHeight available = True def __init__(self, data, trade=0, buy=0, sell=0, use=0, weapon=0, isDisabled=0, **kw): if (trade and buy and sell and use or weapon) and not isDisabled: buttonRelief = DGG.RAISED buttonState = DGG.NORMAL else: buttonRelief = DGG.RIDGE buttonState = DGG.DISABLED self.loadGui() optiondefs = (('relief', None, None), ('state', buttonState, None), ('frameSize', (0, self.width, 0, self.height), None), ('image', SongItemGui.genericButton, None), ('image_scale', (0.54000000000000004, 1, 0.41999999999999998), None), ('image_pos', (0.26000000000000001, 0, 0.080000000000000002), None), ('pressEffect', 0, None), ('command', self.sendEvents, None)) self.defineoptions(kw, optiondefs) SongListItem.__init__(self, data, trade=trade, buy=buy, sell=sell, use=use, weapon=weapon, isDisabled=isDisabled, width=self.width, height=self.height) self.initialiseoptions(SongItemGui) self.createGui() self.helpBox = None def loadGui(self): if SongItemGui.guiLoaded: return None SongListItem.loadGui(self) SongItemGui.genericButton = ( SongListItem.topGui.find('**/generic_button'), SongListItem.topGui.find('**/generic_button_down'), SongListItem.topGui.find('**/generic_button_over'), SongListItem.topGui.find('**/generic_button_disabled')) def createGui(self): itemId = self.data[0] self.picture = DirectFrame(parent=self, relief=None, state=DGG.DISABLED, pos=(0.01, 0, 0.01)) self.nameTag = DirectLabel( parent=self, relief=None, state=DGG.DISABLED, text=self.name, text_scale=PiratesGuiGlobals.TextScaleSmall * PLocalizer.getHeadingScale(2), text_align=TextNode.ALeft, text_fg=PiratesGuiGlobals.TextFG1, text_shadow=PiratesGuiGlobals.TextShadow, pos=(0.050000000000000003, 0, 0.105), text_font=PiratesGlobals.getInterfaceFont()) itemTypeFormatted = '' self.itemTypeName = DirectLabel( parent=self, relief=None, state=DGG.DISABLED, text=itemTypeFormatted, text_scale=PiratesGuiGlobals.TextScaleSmall, text_align=TextNode.ALeft, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, text_font=PiratesGlobals.getInterfaceFont(), pos=(0.050000000000000003, 0, 0.065000000000000002)) self.miscText = DirectLabel( parent=self, relief=None, state=DGG.DISABLED, text='', text_scale=PiratesGuiGlobals.TextScaleSmall, text_align=TextNode.ALeft, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, text_wordwrap=11, pos=(0.050000000000000003, 0, 0.025000000000000001)) if self.minLvl > 0: repId = WeaponGlobals.getRepId(itemId) if repId: self.checkLevel(repId, self.minLvl) trainingReq = EconomyGlobals.getItemTrainingReq(itemId) if trainingReq: self.checkTrainingReq(trainingReq) if EconomyGlobals.getItemCategory(itemId) == ItemType.AMMO: skillId = WeaponGlobals.getSkillIdForAmmoSkillId(itemId) self.checkSkillReq(skillId) if self.buy: self.checkPlayerInventory(itemId) self.costText = DirectLabel( parent=self, relief=None, state=DGG.DISABLED, image=SongListItem.coinImage, image_scale=0.12, image_pos=Vec3(-0.01, 0, 0.01), text=str(self.price), text_scale=PiratesGuiGlobals.TextScaleSmall, text_align=TextNode.ARight, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, text_wordwrap=11, text_pos=(-0.029999999999999999, 0, 0), pos=(self.width - 0.035000000000000003, 0, 0.105), text_font=PiratesGlobals.getInterfaceFont()) if self.quantity and self.quantity > 1: self.quantityLabel = DirectLabel( parent=self, relief=None, state=DGG.DISABLED, text=str(self.quantity), frameColor=(0, 0, 0, 1), frameSize=(-0.01, 0.02, -0.01, 0.025000000000000001), text_scale=0.0275, text_align=TextNode.ACenter, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, text_wordwrap=11, pos=(0.02, 0, 0.025000000000000001), text_font=PiratesGlobals.getPirateBoldOutlineFont()) itemClass = EconomyGlobals.getItemCategory(itemId) if itemClass == ItemType.WEAPON or itemClass == ItemType.POUCH: asset = EconomyGlobals.getItemIcons(itemId) if asset: self.picture['geom'] = SongItemGui.weaponIcons.find('**/%s*' % asset) self.picture['geom_scale'] = 0.11 self.picture['geom_pos'] = (0.080000000000000002, 0, 0.068000000000000005) elif itemClass == ItemType.CONSUMABLE: asset = EconomyGlobals.getItemIcons(itemId) if asset: self.picture['geom'] = SongItemGui.skillIcons.find('**/%s*' % asset) self.picture['geom_scale'] = 0.11 self.picture['geom_pos'] = (0.080000000000000002, 0, 0.068000000000000005) if not InventoryType.begin_WeaponCannonAmmo <= itemId or itemId <= InventoryType.end_WeaponCannonAmmo: if (InventoryType.begin_WeaponPistolAmmo <= itemId or itemId <= InventoryType.end_WeaponGrenadeAmmo or InventoryType.begin_WeaponDaggerAmmo <= itemId ) and itemId <= InventoryType.end_WeaponDaggerAmmo: skillId = WeaponGlobals.getSkillIdForAmmoSkillId(itemId) if skillId: asset = WeaponGlobals.getSkillIcon(skillId) if asset: self.picture['geom'] = SongListItem.skillIcons.find( '**/%s' % asset) self.picture['geom_scale'] = 0.14999999999999999 self.picture['geom_pos'] = (0.069000000000000006, 0, 0.069000000000000006) elif InventoryType.SmallBottle <= itemId and itemId <= InventoryType.LargeBottle: self.picture['geom'] = SongListItem.topGui.find( '**/main_gui_ship_bottle') self.picture['geom_scale'] = 0.10000000000000001 self.picture['geom_pos'] = (0.069000000000000006, 0, 0.069000000000000006) self.flattenStrong() def checkLevel(self, repId, minLvl): inv = localAvatar.getInventory() if inv: repAmt = inv.getAccumulator(repId) if minLvl > ReputationGlobals.getLevelFromTotalReputation( repId, repAmt)[0]: self.highlightRed(PLocalizer.LevelRequirement % self.minLvl) def checkTrainingReq(self, trainingReq): inv = localAvatar.getInventory() if inv: amt = inv.getStackQuantity(trainingReq) if not amt: self.highlightRed(PLocalizer.TrainingRequirement) def checkSkillReq(self, skillId): if skillId: if base.localAvatar.getSkillQuantity(skillId) < 2: skillName = PLocalizer.getInventoryTypeName(skillId) self.highlightRed(PLocalizer.SkillRequirement % skillName) def checkPlayerInventory(self, itemId, extraQty=0): if self.available: inventory = base.localAvatar.getInventory() currStock = inventory.getStackQuantity(itemId) currStockLimit = inventory.getStackLimit(itemId) if currStock == 0: if base.cr.newsManager.getHoliday(21): pass if not (itemId in InventoryType.WinterHolidaySongs): self.name = PLocalizer.makeHeadingString( PLocalizer.SongTitleUnknown, 2) self.nameTag['text'] = PLocalizer.makeHeadingString( PLocalizer.SongTitleUnknown, 2) self.itemTypeName['text'] = PLocalizer.makeHeadingString( PLocalizer.SongComingSoon, 1) self.disable() not (itemId in InventoryType.WinterHolidaySongs) def highlightRed(self, text=''): self['state'] = DGG.DISABLED self['image_color'] = Vec4(0.55000000000000004, 0.55000000000000004, 0.5, 1) self.available = False self.highlightBox(text, Vec4(0.75, 0.5, 0.5, 1), PiratesGuiGlobals.TextFG6) def highlightGreen(self, text=''): self.highlightBox(text, Vec4(0.5, 0.75, 0.5, 1), PiratesGuiGlobals.TextFG4) def highlightBox(self, text, image_color, text_fg): self.miscText['text_fg'] = text_fg if text != '': self.miscText['text'] = text def enable(self): if self.available: self['state'] = DGG.NORMAL def disable(self): if self.available: self['state'] = DGG.DISABLED def createHelpbox(self, args=None): if self.helpBox: return None weaponInfo = PLocalizer.WeaponDescriptions.get(self.data[0]) weaponDesc = weaponInfo self.helpText = DirectFrame( parent=self, relief=None, text=weaponDesc, state=DGG.DISABLED, text_align=TextNode.ALeft, text_scale=PiratesGuiGlobals.TextScaleSmall, text_fg=PiratesGuiGlobals.TextFG2, text_wordwrap=13, textMayChange=0, sortOrder=91) height = -self.helpText.getHeight() self.helpBox = BorderFrame(parent=aspect2d, state=DGG.DISABLED, frameSize=(-0.029999999999999999, 0.42999999999999999, height, 0.050000000000000003), sortOrder=90, borderScale=0.20000000000000001) self.helpText.reparentTo(self.helpBox) self.helpBox.setBin('gui-popup', 0) self.helpBox.setPos(self, 0.25, 0, -0.035000000000000003) def destroy(self): taskMgr.remove('helpInfoTask') taskMgr.remove(self.taskName('dragTask')) if self.helpBox: self.helpBox.destroy() self.helpBox = None del self.picture if self.weapon: taskMgr.remove(DGG.B1PRESS) taskMgr.remove(DGG.B2PRESS) taskMgr.remove(DGG.B3PRESS) SongListItem.destroy(self) def setDraggable(self, d): self.draggable = d def dragStart(self, event): self.origionalPos = self.getPos(render2d) self.origionalParent = self.getParent() self.bringToFront() self.setColorScale(1, 1, 1, 0.5) if self.draggable: self.wrtReparentTo(aspect2d) taskMgr.remove(self.taskName('dragTask')) vWidget2render2d = self.getPos(render2d) vMouse2render2d = Point3(event.getMouse()[0], 0, event.getMouse()[1]) editVec = Vec3(vWidget2render2d - vMouse2render2d) task = taskMgr.add(self.dragTask, self.taskName('dragTask')) task.editVec = editVec def dragTask(self, task): if task.time < PiratesGuiGlobals.DragStartDelayTime: return Task.cont else: mwn = base.mouseWatcherNode if mwn.hasMouse(): vMouse2render2d = Point3(mwn.getMouse()[0], 0, mwn.getMouse()[1]) newPos = vMouse2render2d + task.editVec self.setPos(render2d, newPos) newPos = self.getPos(aspect2d) x = newPos[0] z = newPos[2] x = x - x % 0.050000000000000003 z = z - z % 0.050000000000000003 x = min(1.3 - self.width, max(-1.3, x)) z = min(1 - self.height, max(-1, z)) self.setPos(aspect2d, x, 0.0, z) return Task.cont def dragStop(self, event): self.clearColorScale() self.wrtReparentTo(self.origionalParent) self.setPos(render2d, self.origionalPos) if self.draggable: taskMgr.remove(self.taskName('dragTask')) def showDetails(self, event): taskMgr.doMethodLater(PiratesGuiGlobals.HelpPopupTime, self.createHelpbox, 'helpInfoTask') self.createHelpbox() def hideDetails(self, event): taskMgr.remove('helpInfoTask') if self.helpBox: self.helpBox.destroy() self.helpBox = None
class AmmoSkillButton(SkillButton.SkillButton): def __init__(self, skillId, slotId, callback, quantity=0, skillRank=0, showQuantity=False, showHelp=False, showRing=False, hotkey=None, name='', showIcon=True, showLock=False, rechargeSkillId=False, assocAmmo=[]): if skillId in [ InventoryType.DefenseCannonRoundShot, InventoryType.DefenseCannonEmpty ]: showQuantity = False if not Freebooter.getPaidStatus( base.localAvatar.doId ) and slotId >= CannonDefenseGlobals.FREEBOOTER_MAX_AMMO_SLOTS: showLock = True SkillButton.SkillButton.__init__(self, skillId, callback, quantity, skillRank, showQuantity, showHelp, showRing, hotkey, name, showIcon, showLock, rechargeSkillId, assocAmmo) self.toggleFrame['image_scale'] = 0.55000000000000004 self.toolTipBox = None self.slotId = slotId self._initButtons() self.updateSkillId(skillId) def _initButtons(self): self.sellButtonModel = loader.loadModel( 'models/gui/pir_m_gui_can_buttonSell') self.sellButton = GuiButton( parent=self, image=(self.sellButtonModel.find('**/idle'), self.sellButtonModel.find('**/idle'), self.sellButtonModel.find('**/over')), image_scale=1, scale=0.40000000000000002, sortOrder=100, pos=(0, 0, -0.125), command=self.onSellClick) self.sellButton.bind(DGG.ENTER, self.showToolTip) self.sellButton.bind(DGG.EXIT, self.hideToolTip) def updateSkillId(self, skillId): SkillButton.SkillButton.updateSkillId(self, skillId) if not hasattr(self, 'sellButton'): return None if skillId == InventoryType.DefenseCannonEmpty: self.sellButton['state'] = DGG.DISABLED self.sellButton.hide() if skillId == InventoryType.DefenseCannonEmpty: self.setShowIcon(False) else: self.sellButton['state'] = DGG.NORMAL self.sellButton.show() self.setShowIcon(True) def createToolTip(self): if self.toolTipBox: return None self.label = DirectLabel(parent=None, relief=None, text=PLocalizer.SellButton, text_align=TextNode.ALeft, text_scale=PiratesGuiGlobals.TextScaleLarge, text_fg=PiratesGuiGlobals.TextFG2, text_wordwrap=12) height = -self.label.getHeight() width = self.label.getWidth() toolTipScale = 2.5 self.toolTipBox = None self.toolTipBox = BorderFrame(parent=self.sellButton, frameSize=(-0.01, width, height, 0.050000000000000003), scale=toolTipScale, pos=(-(width * toolTipScale * 0.5), 0, height * toolTipScale * 2.25), state=DGG.DISABLED) self.label.reparentTo(self.toolTipBox) def showToolTip(self, event): self.createToolTip() def hideToolTip(self, event): if self.toolTipBox: self.toolTipBox.destroy() self.toolTipBox = None def onSellClick(self): messenger.send('onSellClick', [self.skillId])
class AmmoPanelButton(DirectButton): SkillIcons = None def __init__(self, callback, skillId, skillRank): if not AmmoPanelButton.SkillIcons: AmmoPanelButton.SkillIcons = loader.loadModel( 'models/textureCards/skillIcons') AmmoPanelButton.Image = ( AmmoPanelButton.SkillIcons.find('**/base'), AmmoPanelButton.SkillIcons.find('**/base_down'), AmmoPanelButton.SkillIcons.find('**/base_over')) self.locked = True self.purchaseable = True self.cost = CannonDefenseGlobals.getDefenseCannonAmmoCost(skillId) self.amount = CannonDefenseGlobals.getDefenseCannonAmmoAmount(skillId) if self.amount == -1: self.amount = PLocalizer.Unlimited self.skillId = skillId self.skillRank = skillRank self.infoBox = None self.flashIval = None asset = RadialMenu.getSkillIconName(skillId, 0) geom = AmmoPanelButton.SkillIcons.find('**/%s' % asset) self.geom = geom if self.locked: asset = None geom = None DirectButton.__init__(self, relief=None, pos=(0, 0, 0), text='?', text_scale=0.10000000000000001, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, text_pos=(0.0050000000000000001, -0.035000000000000003), text_align=TextNode.ACenter, image=AmmoPanelButton.Image, image_scale=0.12, geom=geom, geom_scale=0.12, command=callback, textMayChange=1, sortOrder=70, extraArgs=[skillId]) self.initialiseoptions(AmmoPanelButton) gui = loader.loadModel('models/gui/toplevel_gui') self.lockIcon = gui.find('**/pir_t_gui_gen_key_subscriber') if not Freebooter.getPaidStatus( base.localAvatar.doId ) and skillId > CannonDefenseGlobals.FREEBOOTER_LAST_AMMO_AVAILABLE: self.lock = DirectFrame(parent=self, relief=None, image=self.lockIcon, image_scale=0.14000000000000001, image_pos=(0.050000000000000003, 0, -0.025000000000000001), sortOrder=99) self.bind(DGG.ENTER, self.showDetails) self.bind(DGG.EXIT, self.hideDetails) def createTextBox(self): if self.infoBox: return None globalPos = self.getPos(base.a2dLeftCenter) self.infoBox = None self.infoBox = BorderFrame(parent=base.a2dLeftCenter, frameSize=(-0.040000000000000001, 0.5, -0.25, 0.050000000000000003), pos=(globalPos.getX() + 0.12, 0, globalPos.getZ()), state=DGG.DISABLED) self.label = DirectLabel( parent=self.infoBox, relief=None, text=PLocalizer.CannonDefenseAmmoDesc % (PLocalizer.makeHeadingString( PLocalizer.InventoryTypeNames[self.skillId], 2), self.cost, self.amount, PLocalizer.CannonDefenseAmmoTypeDesc[self.skillId]), text_align=TextNode.ALeft, text_scale=PiratesGuiGlobals.TextScaleLarge, text_fg=PiratesGuiGlobals.TextFG2, text_wordwrap=12, textMayChange=1) if self.locked: memberText = '' if self.skillId > CannonDefenseGlobals.FREEBOOTER_LAST_AMMO_AVAILABLE: memberText = PLocalizer.VR_AuthAccess self.label['text'] = PLocalizer.CannonDefenseAmmoUnlockedAt % ( CannonDefenseGlobals.getLevelUnlockedAt( self.skillId), memberText) self.infoBox.setBin('gui-cannonDefense', 4) def showDetails(self, event): self.createTextBox() def hideDetails(self, event): if self.infoBox: self.infoBox.destroy() self.infoBox = None def isLocked(self): return self.locked def unlock(self): if self.locked: self['text'] = '' self['geom'] = self.geom self['geom_scale'] = 0.12 self.locked = False def canPurchase(self, bankNotes): if not self.purchaseable: return False return bankNotes >= self.cost def enablePurchase(self): self.purchaseable = True self.setAlphaScale(1.0) def disablePurchase(self): self.purchaseable = False self.setAlphaScale(0.40000000000000002) def flash(self): if self.flashIval: self.flashIval.pause() self.flashIval = Sequence( LerpColorInterval(self, 0.25, color=VBase4(0.69999999999999996, 0.10000000000000001, 0.10000000000000001, 1.0), blendType='easeOut'), LerpColorInterval(self, 0.25, color=VBase4(1.0, 1.0, 1.0, 1.0), blendType='easeOut')) self.flashIval.start()
def destroy(self): self.tabBar = None self.invisibleButton = None BorderFrame.destroy(self)
def destroy(self): self.ignoreAll() BorderFrame.destroy(self)
class GuiButton(DirectButton): notify = directNotify.newCategory('GuiButton') genericButton = None redGenericButton = None blueGenericButton = None def __init__(self, parent = None, hotkeys = (), hotkeyLabel = None, hotkeyLabelX = 0.091999999999999998, hotkeyArgs = True, helpText = '', helpPos = (0, 0, 0), helpDelay = PiratesGuiGlobals.HelpPopupTime, helpColorOff = False, helpLeftAlign = False, helpCenterAlign = False, **kw): self.loadGui() self.helpBox = None self.helpWatcher = None self.canRepositon = False optiondefs = (('relief', None, None), ('pos', (0, 0, 0), None), ('image', GuiButton.genericButton, None), ('image_scale', (0.23999999999999999, 0.22, 0.22), None), ('image_pos', (0, 0, 0), None), ('pressEffect', 0, None), ('text', '', None), ('text_font', PiratesGlobals.getInterfaceFont(), None), ('text_scale', PiratesGuiGlobals.TextScaleLarge, None), ('text0_fg', PiratesGuiGlobals.TextFG2, None), ('text1_fg', PiratesGuiGlobals.TextFG2, None), ('text2_fg', PiratesGuiGlobals.TextFG2, None), ('text3_fg', PiratesGuiGlobals.TextFG3, None), ('text_shadow', PiratesGuiGlobals.TextShadow, None), ('text_pos', (0, -0.01), None), ('text_wordwrap', 8, None), ('text_align', TextNode.ACenter, None), ('textMayChange', 1, None), ('helpText', helpText, self.helpTextUpdated), ('helpPos', helpPos, self.setHelpPos), ('helpDelay', helpDelay, None), ('helpColorOff', helpColorOff, None), ('helpLeftAlign', helpLeftAlign, None), ('helpCenterAlign', helpCenterAlign, None), ('helpBin', 'gui-popup', None), ('helpBinSort', 0, None), ('helpOpaque', 0, None), ('canReposition', False, None), ('sortOrder', 100, None), ('baseImage', None, None), ('selected', False, None), ('selectedImage', GuiButton.genericButton, None), ('state', DGG.NORMAL, self.setState)) self.defineoptions(kw, optiondefs) DirectButton.__init__(self, parent = NodePath()) self.initialiseoptions(GuiButton) self.hotkeys = () self.setupHotkeys(hotkeys, hotkeyLabel, self['command'], self['extraArgs'], hotkeyLabelX, hotkeyArgs) if not parent: pass self.reparentTo(aspect2d) self.helpTaskName = None def destroy(self): self.hideDetails() if self.helpWatcher: self.helpWatcher.unbind(DGG.WITHIN) self.helpWatcher.unbind(DGG.WITHOUT) self.helpWatcher.destroy() self.helpWatcher = None self.unbind(DGG.ENTER) self.unbind(DGG.EXIT) self.ignoreAll() DirectButton.destroy(self) def loadGui(self): if GuiButton.genericButton: return None gui = loader.loadModel('models/gui/toplevel_gui') GuiButton.genericButton = (gui.find('**/generic_button'), gui.find('**/generic_button_down'), gui.find('**/generic_button_over'), gui.find('**/generic_button_disabled')) GuiButton.redGenericButton = (gui.find('**/pir_t_gui_but_generic'), gui.find('**/pir_t_gui_but_generic_down'), gui.find('**/pir_t_gui_but_generic_over'), gui.find('**/pir_t_gui_but_generic_disabled')) GuiButton.blueGenericButton = (gui.find('**/pir_t_gui_but_generic_blue'), gui.find('**/pir_t_gui_but_generic_blue_down'), gui.find('**/pir_t_gui_but_generic_blue_over'), gui.find('**/pir_t_gui_but_generic_blue_disabled')) def setupHotkeys(self, hotkeys, hotkeyLabel, command, extraArgs, hotkeyLabelX = 0.091999999999999998, hotkeyArgs = True): if self.hotkeys: self.ignoreHotkeys() self.hotkeyLabel.destroy() self.hotkeys = hotkeys self.command = command self.extraArgs = extraArgs self.hotkeyLabel = hotkeyLabel self.hotkeyLabelX = hotkeyLabelX self.hotkeyArgs = hotkeyArgs if self.hotkeys: self.hotkeyLabel = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = hotkeyLabel, text_font = PiratesGlobals.getPirateBoldOutlineFont(), text_scale = PiratesGuiGlobals.TextScaleMed, text_pos = (hotkeyLabelX, 0.01), text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 1) self.acceptHotkeys() def ignoreHotkeys(self): if self.hotkeys: for hotkey in self.hotkeys: self.ignore(hotkey) def acceptHotkeys(self): if self.hotkeys: for hotkey in self.hotkeys: if self.hotkeyArgs: self.accept(hotkey, self.command, self.extraArgs + [ hotkey]) continue self.accept(hotkey, self.command, self.extraArgs) def createHelpWatcher(self): if self['helpOpaque']: self.bind(DGG.ENTER, self.waitShowDetails) self.bind(DGG.EXIT, self.hideDetails) else: w = self.getWidth() h = self.getHeight() pos = self._GuiButton__discoverHelpWatcherPos() if not self['frameSize']: pass frameSize = self.getBounds() self.helpWatcher = DirectFrame(parent = self, relief = base.config.GetBool('show-helpwatchers', 0), state = DGG.NORMAL, frameColor = (1, 1, 0, 0.5), frameSize = frameSize, sortOrder = self['sortOrder'] - 1) self.helpWatcher.wrtReparentTo(self.getParent()) self.reparentTo(self.getParent()) self.helpWatcher.bind(DGG.WITHIN, self.waitShowDetails) self.helpWatcher.bind(DGG.WITHOUT, self.hideDetails) def _GuiButton__discoverHelpWatcherPos(self): w = self.getWidth() h = self.getHeight() if not self['frameSize']: pass bounds = self.getBounds() pos = Vec3(bounds[0] + w / 2, 0, bounds[2] + h / 2) return pos def resetHelpWatcher(self): if self.helpWatcher: self.helpWatcher.setPos(self, 0, 0, 0) def createHelpBox(self): if not self.helpWatcher: self.createHelpWatcher() helpLabel = DirectLabel(relief = None, state = DGG.DISABLED, text = self['helpText'], text_align = TextNode.ACenter, text_scale = PiratesGuiGlobals.TextScaleMed, text_fg = PiratesGuiGlobals.TextFG1, text_wordwrap = 12, text_shadow = (0, 0, 0, 1), textMayChange = 0, sortOrder = 91) height = helpLabel.getHeight() width = helpLabel.getWidth() + 0.050000000000000003 if self['helpLeftAlign']: fs = [ 0.0, width, -height, 0.044999999999999998] pos = [ width / 2.0, 0, -0.01] elif self['helpCenterAlign']: pos = [ 0.0, 0.0, -0.01] fs = [ -(width / 2 + 0.01), width / 2 + 0.01, -(height / 2 + 0.014999999999999999), height / 2 + 0.014999999999999999] else: fs = [ 0.25 - width, 0.25, -height, 0.044999999999999998] pos = [ 0.25 - width / 2.0, 0, -0.01] self.helpBox = BorderFrame(parent = self, state = DGG.DISABLED, frameSize = (fs[0], fs[1], fs[2], fs[3]), modelName = 'general_frame_f', pos = self['helpPos'], sortOrder = 90) helpLabel.reparentTo(self.helpBox) helpLabel.setPos(pos[0], pos[1], pos[2]) self.helpBox.hide() self.helpBox.setClipPlaneOff() pos = self.helpBox.getPos(aspect2d) x = min(pos[0], base.a2dRight - width) z = max(pos[2], base.a2dBottom - height) self.helpBox.setPos(aspect2d, x, 0, z) if self['helpColorOff']: self.helpBox.setColorOff() else: self.helpBox.flattenLight() if self['helpBin']: self.helpBox.setBin(self['helpBin'], self['helpBinSort']) def helpTextUpdated(self): if self.helpBox and self.helpBox['text'] != self['helpText']: self.helpBox.destroy() self.createHelpBox() elif self['helpText']: self.createHelpBox() def setHelpPos(self): if self.helpBox: self.helpTextUpdated() def waitShowDetails(self, event): try: self['helpDelay'] except AttributeError: return None if not self.helpBox: self.createHelpBox() if self['helpDelay']: self.hideDetails() self.helpTaskName = 'helpInfoTask-%s' % self.getName() taskMgr.doMethodLater(self['helpDelay'], self.helpBox.show, self.helpTaskName, extraArgs = []) else: self.helpBox.show() def hideDetails(self, event = None): if self.helpTaskName: taskMgr.remove(self.helpTaskName) if self.helpBox and not self.helpBox.isEmpty(): self.helpBox.hide() def setImage(self): DirectButton.setImage(self) if not self['baseImage']: self['baseImage'] = self['image'] def setSelected(self): if self['selected']: self['image'] = self['selectedImage'] else: self['image'] = self['baseImage'] def setState(self): DirectButton.setState(self) if self.helpWatcher: self.helpWatcher['state'] = self['state'] def removeNode(self): DirectButton.removeNode(self) if self.helpWatcher: self.helpWatcher.removeNode() def remove(self): DirectButton.remove(self) if self.helpWatcher: self.helpWatcher.remove() def detachNode(self): DirectButton.detachNode(self) if self.helpWatcher: self.helpWatcher.detachNode() def hide(self): DirectButton.hide(self) if self.helpWatcher: self.helpWatcher.hide() def show(self): DirectButton.show(self) if self.helpWatcher: self.helpWatcher.show() def stash(self): DirectButton.stash(self) if self.helpWatcher: self.helpWatcher.stash() def unstash(self): DirectButton.unstash(self) self.reparentTo(self.getParent(), sort = self['sortOrder']) if self.helpWatcher: self.helpWatcher.unstash() self.helpWatcher.reparentTo(self.helpWatcher.getParent(), sort = self.helpWatcher['sortOrder'])
class GuiButton(DirectButton): notify = directNotify.newCategory('GuiButton') genericButton = None redGenericButton = None blueGenericButton = None def __init__(self, parent=None, hotkeys=(), hotkeyLabel=None, hotkeyLabelX=0.091999999999999998, hotkeyArgs=True, helpText='', helpPos=(0, 0, 0), helpDelay=PiratesGuiGlobals.HelpPopupTime, helpColorOff=False, helpLeftAlign=False, helpCenterAlign=False, **kw): self.loadGui() self.helpBox = None self.helpWatcher = None self.canRepositon = False optiondefs = (('relief', None, None), ('pos', (0, 0, 0), None), ('image', GuiButton.genericButton, None), ('image_scale', (0.23999999999999999, 0.22, 0.22), None), ('image_pos', (0, 0, 0), None), ('pressEffect', 0, None), ('text', '', None), ('text_font', PiratesGlobals.getInterfaceFont(), None), ('text_scale', PiratesGuiGlobals.TextScaleLarge, None), ('text0_fg', PiratesGuiGlobals.TextFG2, None), ('text1_fg', PiratesGuiGlobals.TextFG2, None), ('text2_fg', PiratesGuiGlobals.TextFG2, None), ('text3_fg', PiratesGuiGlobals.TextFG3, None), ('text_shadow', PiratesGuiGlobals.TextShadow, None), ('text_pos', (0, -0.01), None), ('text_wordwrap', 8, None), ('text_align', TextNode.ACenter, None), ('textMayChange', 1, None), ('helpText', helpText, self.helpTextUpdated), ('helpPos', helpPos, self.setHelpPos), ('helpDelay', helpDelay, None), ('helpColorOff', helpColorOff, None), ('helpLeftAlign', helpLeftAlign, None), ('helpCenterAlign', helpCenterAlign, None), ('helpBin', 'gui-popup', None), ('helpBinSort', 0, None), ('helpOpaque', 0, None), ('canReposition', False, None), ('sortOrder', 100, None), ('baseImage', None, None), ('selected', False, None), ('selectedImage', GuiButton.genericButton, None), ('state', DGG.NORMAL, self.setState)) self.defineoptions(kw, optiondefs) DirectButton.__init__(self, parent=NodePath(), **None) self.initialiseoptions(GuiButton) self.hotkeys = () self.setupHotkeys(hotkeys, hotkeyLabel, self['command'], self['extraArgs'], hotkeyLabelX, hotkeyArgs) if not parent: pass self.reparentTo(aspect2d) self.helpTaskName = None def destroy(self): self.hideDetails() self.command = None if self.helpWatcher: self.helpWatcher.command = None self.helpWatcher.unbind(DGG.WITHIN) self.helpWatcher.unbind(DGG.WITHOUT) self.helpWatcher.destroy() self.helpWatcher = None self.unbind(DGG.ENTER) self.unbind(DGG.EXIT) self.ignoreAll() DirectButton.destroy(self) def loadGui(self): if GuiButton.genericButton: return None gui = loader.loadModel('models/gui/toplevel_gui') GuiButton.genericButton = (gui.find('**/generic_button'), gui.find('**/generic_button_down'), gui.find('**/generic_button_over'), gui.find('**/generic_button_disabled')) GuiButton.redGenericButton = ( gui.find('**/pir_t_gui_but_generic'), gui.find('**/pir_t_gui_but_generic_down'), gui.find('**/pir_t_gui_but_generic_over'), gui.find('**/pir_t_gui_but_generic_disabled')) GuiButton.blueGenericButton = ( gui.find('**/pir_t_gui_but_generic_blue'), gui.find('**/pir_t_gui_but_generic_blue_down'), gui.find('**/pir_t_gui_but_generic_blue_over'), gui.find('**/pir_t_gui_but_generic_blue_disabled')) def setupHotkeys(self, hotkeys, hotkeyLabel, command, extraArgs, hotkeyLabelX=0.091999999999999998, hotkeyArgs=True): if self.hotkeys: self.ignoreHotkeys() self.hotkeyLabel.destroy() self.hotkeys = hotkeys self.command = command self.extraArgs = extraArgs self.hotkeyLabel = hotkeyLabel self.hotkeyLabelX = hotkeyLabelX self.hotkeyArgs = hotkeyArgs if self.hotkeys: self.hotkeyLabel = DirectLabel( parent=self, relief=None, state=DGG.DISABLED, text=hotkeyLabel, text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_scale=PiratesGuiGlobals.TextScaleMed, text_pos=(hotkeyLabelX, 0.01), text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, textMayChange=1) self.acceptHotkeys() def ignoreHotkeys(self): if self.hotkeys: for hotkey in self.hotkeys: self.ignore(hotkey) def acceptHotkeys(self): if self.hotkeys: for hotkey in self.hotkeys: if self.hotkeyArgs: self.accept(hotkey, self.command, self.extraArgs + [hotkey]) continue self.accept(hotkey, self.command, self.extraArgs) def createHelpWatcher(self): if self['helpOpaque']: self.bind(DGG.ENTER, self.waitShowDetails) self.bind(DGG.EXIT, self.hideDetails) else: w = self.getWidth() h = self.getHeight() pos = self._GuiButton__discoverHelpWatcherPos() if not self['frameSize']: pass frameSize = self.getBounds() self.helpWatcher = DirectFrame(parent=self, relief=base.config.GetBool( 'show-helpwatchers', 0), state=DGG.NORMAL, frameColor=(1, 1, 0, 0.5), frameSize=frameSize, sortOrder=self['sortOrder'] - 1) self.helpWatcher.wrtReparentTo(self.getParent()) self.reparentTo(self.getParent()) self.helpWatcher.bind(DGG.WITHIN, self.waitShowDetails) self.helpWatcher.bind(DGG.WITHOUT, self.hideDetails) def _GuiButton__discoverHelpWatcherPos(self): w = self.getWidth() h = self.getHeight() if not self['frameSize']: pass bounds = self.getBounds() pos = Vec3(bounds[0] + w / 2, 0, bounds[2] + h / 2) return pos def resetHelpWatcher(self): if self.helpWatcher: self.helpWatcher.setPos(self, 0, 0, 0) def createHelpBox(self): if not self.helpWatcher: self.createHelpWatcher() helpLabel = DirectLabel(relief=None, state=DGG.DISABLED, text=self['helpText'], text_align=TextNode.ACenter, text_scale=PiratesGuiGlobals.TextScaleMed, text_fg=PiratesGuiGlobals.TextFG1, text_wordwrap=12, text_shadow=(0, 0, 0, 1), textMayChange=0, sortOrder=91) height = helpLabel.getHeight() width = helpLabel.getWidth() + 0.050000000000000003 if self['helpLeftAlign']: fs = [0.0, width, -height, 0.044999999999999998] pos = [width / 2.0, 0, -0.01] elif self['helpCenterAlign']: pos = [0.0, 0.0, -0.01] fs = [ -(width / 2 + 0.01), width / 2 + 0.01, -(height / 2 + 0.014999999999999999), height / 2 + 0.014999999999999999 ] else: fs = [0.25 - width, 0.25, -height, 0.044999999999999998] pos = [0.25 - width / 2.0, 0, -0.01] self.helpBox = BorderFrame(parent=self, state=DGG.DISABLED, frameSize=(fs[0], fs[1], fs[2], fs[3]), modelName='general_frame_f', pos=self['helpPos'], sortOrder=90) helpLabel.reparentTo(self.helpBox) helpLabel.setPos(pos[0], pos[1], pos[2]) self.helpBox.hide() self.helpBox.setClipPlaneOff() pos = self.helpBox.getPos(aspect2d) x = min(pos[0], base.a2dRight - width) z = max(pos[2], base.a2dBottom - height) self.helpBox.setPos(aspect2d, x, 0, z) if self['helpColorOff']: self.helpBox.setColorOff() else: self.helpBox.flattenLight() if self['helpBin']: self.helpBox.setBin(self['helpBin'], self['helpBinSort']) def helpTextUpdated(self): if self.helpBox and self.helpBox['text'] != self['helpText']: self.helpBox.destroy() self.createHelpBox() elif self['helpText']: self.createHelpBox() def setHelpPos(self): if self.helpBox: self.helpTextUpdated() def waitShowDetails(self, event): try: self['helpDelay'] except AttributeError: return None if not self.helpBox: self.createHelpBox() if self['helpDelay']: self.hideDetails() self.helpTaskName = 'helpInfoTask-%s' % self.getName() taskMgr.doMethodLater(self['helpDelay'], self.helpBox.show, self.helpTaskName, extraArgs=[]) else: self.helpBox.show() def hideDetails(self, event=None): if self.helpTaskName: taskMgr.remove(self.helpTaskName) if self.helpBox and not self.helpBox.isEmpty(): self.helpBox.hide() def setImage(self): DirectButton.setImage(self) if not self['baseImage']: self['baseImage'] = self['image'] def setSelected(self): if self['selected']: self['image'] = self['selectedImage'] else: self['image'] = self['baseImage'] def setPos(self, *args, **kw): DirectButton.setPos(self, *args, **args) def setX(self, *args, **kw): DirectButton.setX(self, *args, **args) def setY(self, *args, **kw): DirectButton.setY(self, *args, **args) def setZ(self, *args, **kw): DirectButton.setZ(self, *args, **args) def setState(self): DirectButton.setState(self) if self.helpWatcher: self.helpWatcher['state'] = self['state'] def removeNode(self): DirectButton.removeNode(self) if self.helpWatcher: self.helpWatcher.removeNode() def remove(self): DirectButton.remove(self) if self.helpWatcher: self.helpWatcher.remove() def detachNode(self): DirectButton.detachNode(self) if self.helpWatcher: self.helpWatcher.detachNode() def hide(self): DirectButton.hide(self) if self.helpWatcher: self.helpWatcher.hide() def show(self): DirectButton.show(self) if self.helpWatcher: self.helpWatcher.show() def stash(self): DirectButton.stash(self) if self.helpWatcher: self.helpWatcher.stash() def unstash(self): DirectButton.unstash(self) self.reparentTo(self.getParent(), sort=self['sortOrder']) if self.helpWatcher: self.helpWatcher.unstash() self.helpWatcher.reparentTo(self.helpWatcher.getParent(), sort=self.helpWatcher['sortOrder'])
def destroy(self): self.tabBar = None self.invisibleButton = None BorderFrame.destroy(self)
class BoardingPermissionPanel(GuiPanel): def __init__(self, parent, *args, **kw): self.guiSetup = False optiondefs = (('parent', parent, None), ('pos', (-0.58, 0, -0.09), None), ('command', None, None), ('extraArgs', [], None), ('ownShip', 0, None)) self.defineoptions(kw, optiondefs) GuiPanel.__init__(self, title=PLocalizer.BoardPermTitle, h=0.8, w=0.5, titleSize=1.5, showClose=False, **kw) self.initialiseoptions(BoardingPermissionPanel) self.titleLabel['text_align'] = TextNode.ACenter self.titleLabel.setPos(0.23, 0, 0.72) self.setupGui() return def destroy(self): self.button = None self.background = None self.friendsButton = None self.crewButton = None self.guildButton = None self.publicButton = None GuiPanel.destroy(self) return def setupGui(self): self.destroyGui() if not self.guiSetup: self.button = DialogButton(parent=self, buttonStyle=DialogButton.NO, pos=(0.25, 0, 0.08), text=PLocalizer.lClose, helpPos=(-0.4, 0, 0.03), helpDelay=0.3, command=self['command'], extraArgs=self['extraArgs']) self.background = BorderFrame(parent=self, pos=(0.05, 0, 0.05), frameSize=[0.0, 0.4, 0.1, 0.6], bgColorScale=VBase4(0, 0, 0, 0.75), bgTransparency=1, flatten=0) if self['ownShip']: state = DGG.NORMAL else: state = DGG.DISABLED ship = localAvatar.getShip() if ship: friendState = ship.getAllowFriendState() crewState = ship.getAllowCrewState() guildState = ship.getAllowGuildState() publicState = ship.getAllowPublicState() else: friendState = 0 crewState = 0 guildState = 0 publicState = 0 buttonOptions = { 'parent': self.background, 'state': state, 'relief': None, 'pos': (0.06, 0, 0.53), 'scale': 0.3, 'text': PLocalizer.CrewBoardingAccessAllowFriends, 'value': friendState, 'text_pos': (0.167, -0.06, 0), 'text0_fg': PiratesGuiGlobals.TextFG1, 'text1_fg': PiratesGuiGlobals.TextFG1, 'text2_fg': PiratesGuiGlobals.TextFG1, 'text3_fg': PiratesGuiGlobals.TextFG9, 'text_font': PiratesGlobals.getInterfaceFont(), 'text_scale': 0.15, 'text_shadow': (0, 0, 0, 1), 'text_align': TextNode.ALeft, 'command': self.allowFriends } self.friendsButton = CheckButton(**buttonOptions) buttonOptions['text'] = PLocalizer.CrewBoardingAccessAllowCrew buttonOptions['pos'] = (buttonOptions['pos'][0], buttonOptions['pos'][1], buttonOptions['pos'][2] - 0.12) buttonOptions['command'] = self.allowCrew buttonOptions['value'] = crewState self.crewButton = CheckButton(**buttonOptions) buttonOptions['text'] = PLocalizer.CrewBoardingAccessAllowGuild buttonOptions['pos'] = (buttonOptions['pos'][0], buttonOptions['pos'][1], buttonOptions['pos'][2] - 0.12) buttonOptions['command'] = self.allowGuild buttonOptions['value'] = guildState self.guildButton = CheckButton(**buttonOptions) buttonOptions['text'] = PLocalizer.CrewBoardingAccessAllowPublic buttonOptions['pos'] = (buttonOptions['pos'][0], buttonOptions['pos'][1], buttonOptions['pos'][2] - 0.12) buttonOptions['command'] = self.allowPublic buttonOptions['value'] = publicState self.publicButton = CheckButton(**buttonOptions) self.guiSetup = True return def destroyGui(self): if self.guiSetup: self.background.destroy() self.background = None self.friendsButton.destroy() self.friendsButton = None self.crewButton.destroy() self.crewButton = None self.guildButton.destroy() self.guildButton = None self.publicButton.destroy() self.publicButton = None self.button.destroy() self.button = None self.guiSetup = False return def allowFriends(self, allow): if self['ownShip']: ship = localAvatar.getShip() if ship: ship.b_setAllowFriendState(allow) def allowCrew(self, allow): if self['ownShip']: ship = localAvatar.getShip() if ship: ship.b_setAllowCrewState(allow) def allowGuild(self, allow): if self['ownShip']: ship = localAvatar.getShip() if ship: ship.b_setAllowGuildState(allow) def allowPublic(self, allow): if self['ownShip']: ship = localAvatar.getShip() if ship: ship.b_setAllowPublicState(allow) def setAllowFriends(self, allow): self.friendsButton['value'] = allow def setAllowCrew(self, allow): self.crewButton['value'] = allow def setAllowGuild(self, allow): self.guildButton['value'] = allow def setAllowPublic(self, allow): self.publicButton['value'] = allow
class SkillpageGuiButton(DirectButton): SkillIcons = None def __init__(self, callback, skillId, skillRank): if not SkillpageGuiButton.SkillIcons: SkillpageGuiButton.SkillIcons = loader.loadModel( 'models/textureCards/skillIcons') SkillpageGuiButton.Image = ( SkillpageGuiButton.SkillIcons.find('**/base'), SkillpageGuiButton.SkillIcons.find('**/base_down'), SkillpageGuiButton.SkillIcons.find('**/base_over')) asset = RadialMenu.getSkillIconName(skillId, 0) geom = SkillpageGuiButton.SkillIcons.find('**/%s' % asset) DirectButton.__init__(self, relief=None, pos=(0, 0, 0), image=SkillpageGuiButton.Image, image_scale=0.12, geom=geom, geom_scale=0.12, command=callback, textMayChange=1, sortOrder=70, extraArgs=[skillId]) self.initialiseoptions(SkillpageGuiButton) self.skillId = skillId self.skillRank = skillRank self.showUpgrade = 0 self.helpBox = None self.quantity = None self.bind(DGG.ENTER, self.showDetails) self.bind(DGG.EXIT, self.hideDetails) return def createHelpbox(self, args=None): if self.helpBox: return baseRank = max(self.skillRank, 1) lvlDamageMod = WeaponGlobals.getLevelDamageModifier( localAvatar.getLevel()) buff = WeaponGlobals.getSkillEffectFlag(self.skillId) dur = WeaponGlobals.getAttackDuration(self.skillId) effect = dur + dur * (baseRank - 1) / 4 dodge = WeaponGlobals.getAttackDodge(self.skillId) * baseRank accuracy = 0 damageMod = 0 reduceDamMod = 0 rechargeMod = 0 shipTurningMod = 0 shipSpeedMod = 0 rangeMod = 0 treasureSenseMod = 0 manaCost = WeaponGlobals.getMojoCost(self.skillId) damage = 0 loDamage = 0 mpDamage = 0 chargeMod = 0 if self.skillId == InventoryType.SailBroadsideLeft or self.skillId == InventoryType.SailBroadsideRight: damageMod = WeaponGlobals.getAttackTargetHP( self.skillId) * (baseRank - 1) * 100 else: if self.skillId == InventoryType.CannonShoot: rechargeMod = WeaponGlobals.CANNON_SHOOT_RATE_REDUCTION * ( baseRank - 1) * 100 else: if WeaponGlobals.getSkillTrack( self.skillId) == WeaponGlobals.TONIC_SKILL_INDEX: damage = WeaponGlobals.getAttackSelfHP(self.skillId) else: if WeaponGlobals.getSkillTrack( self.skillId) != WeaponGlobals.PASSIVE_SKILL_INDEX: damage = int( WeaponGlobals.getAttackTargetHP(self.skillId) * (1.0 + WeaponGlobals.LEVELUP_DAMAGE_MULTIPLIER * (baseRank - 1))) * lvlDamageMod loDamage = damage / 2 mpDamage = int( WeaponGlobals.getAttackTargetMojo(self.skillId) * (1.0 + WeaponGlobals.LEVELUP_DAMAGE_MULTIPLIER * (baseRank - 1))) * lvlDamageMod mpLoDamage = mpDamage / 2 else: accuracy = WeaponGlobals.getAttackAccuracy( self.skillId) * baseRank damageMod = WeaponGlobals.getAttackTargetHP( self.skillId) * baseRank * 100 reduceDamMod = WeaponGlobals.getAttackSelfHP( self.skillId) * baseRank if reduceDamMod < 1: reduceDamMod *= 100 if effect < 1: effect *= 100 rechargeMod = WeaponGlobals.getAttackRechargeTime( self.skillId) * baseRank * 100 shipTurningMod = WeaponGlobals.getShipTurnRate( self.skillId) * baseRank * 100 shipSpeedMod = WeaponGlobals.getShipMaxSpeed( self.skillId) * baseRank * 100 treasureSenseMod = WeaponGlobals.TREASURE_SENSE_BONUS / 2 * baseRank rangeMod = WeaponGlobals.getAttackRange( self.skillId) * baseRank manaCost *= baseRank chargeMod = WeaponGlobals.getAttackMaxCharge( self.skillId) * baseRank * 100 if self.skillId == InventoryType.StaffSpiritLore: import pdb pdb.set_trace() skillInfo = PLocalizer.SkillDescriptions.get(self.skillId) skillTitle = PLocalizer.InventoryTypeNames.get( self.skillId) skillType = '\x01slant\x01' + skillInfo[0] + '\x02\n\n' description = skillInfo[1] if damage < 0: description += ' ' + PLocalizer.DealsDamage elif damage > 0: if loDamage: description += ' ' + PLocalizer.HealsDamageRange else: description += ' ' + PLocalizer.HealsDamage if mpDamage < 0: description += ' ' + PLocalizer.DealsMpDamage effectId = WeaponGlobals.getSkillEffectFlag(self.skillId) if effectId: description += ' ' + SkillEffectDescriptions.get( effectId)[0] if self.skillId == InventoryType.SailBroadsideLeft or self.skillId == InventoryType.SailBroadsideRight: if damageMod > 0: description += ' ' + PLocalizer.BroadsideDesc if self.skillId == InventoryType.CannonShoot and rechargeMod: description += ' ' + PLocalizer.CannonShootDesc if self.skillId == InventoryType.DollAttune: description += ' ' + PLocalizer.MultiAttuneDesc if WeaponGlobals.getSkillInterrupt(self.skillId): description += ' ' + PLocalizer.InterruptDesc if WeaponGlobals.getSkillUnattune(self.skillId): description += ' ' + PLocalizer.UnattuneDesc upgradeInfo = '' if self.showUpgrade and self.skillRank < 5: if self.skillRank > 0: upgradeInfo = skillInfo[2] if upgradeInfo == '': if damage < 0: upgradeInfo += PLocalizer.UpgradesDamage elif damage > 0: upgradeInfo += PLocalizer.UpgradesHealing if mpDamage < 0: upgradeInfo += ' ' + PLocalizer.UpgradesMpDamage if effectId: entry = SkillEffectDescriptions.get( effectId) if len(entry) > 1: val = damage or upgradeInfo val += PLocalizer.UpgradesDuration else: upgradeInfo += ' ' + PLocalizer.And upgradeInfo += ' ' + entry[1] upgradeInfo += '!' elif len(upgradeInfo) >= 4: upgradeInfo = skillInfo[3] else: upgradeInfo = PLocalizer.ClickToLearn if self.skillId in SkillComboReq and SkillComboReq[ self.skillId] and self.skillRank <= 1: description += ' ' + SkillComboReq[self.skillId] skillDesc = '\x01gold\x01\x01smallCaps\x01' + skillTitle + '\x02\x02\n' + skillType + description + '\n\x01green\x01' + upgradeInfo + '\x02' stats = [] if manaCost: stats.append(abs(manaCost)) if damage and loDamage: stats.append(abs(loDamage)) stats.append(abs(damage)) elif damage: stats.append(abs(damage)) if mpDamage: stats.append(abs(mpLoDamage)) stats.append(abs(mpDamage)) if buff == WeaponGlobals.C_CURSE: stats.append(WeaponGlobals.CURSED_DAM_AMP * 100) if buff == WeaponGlobals.C_ATTUNE and baseRank > 1: stats.append(baseRank) if buff == WeaponGlobals.C_WEAKEN: stats.append(WeaponGlobals.WEAKEN_PENALTY * 100) if effect > 0: stats.append(effect) if dodge: stats.append(abs(dodge)) if accuracy: stats.append(abs(accuracy)) if damageMod: stats.append(abs(damageMod)) if reduceDamMod: stats.append(abs(reduceDamMod)) if rechargeMod: stats.append(abs(rechargeMod)) if shipTurningMod: stats.append(abs(shipTurningMod)) if shipSpeedMod: stats.append(abs(shipSpeedMod)) if chargeMod: stats.append(abs(chargeMod)) if rangeMod: stats.append(abs(rangeMod)) if self.skillId == InventoryType.SailTreasureSense: stats.append(abs(treasureSenseMod)) stats = tuple(stats) if self.skillRank: self.rankText = DirectFrame( parent=self, relief=None, text=('\x01gold\x01\x01smallCaps\x01' + PLocalizer.Rank + ' %d' + '\x02\x02') % self.skillRank, text_align=TextNode.ARight, text_scale=PiratesGuiGlobals.TextScaleSmall, text_fg=PiratesGuiGlobals.TextFG2, text_wordwrap=15, text_shadow=(0, 0, 0, 1), pos=(0.45, 0, 0), textMayChange=1, sortOrder=92, state=DGG.DISABLED) self.helpText = DirectFrame( parent=self, relief=None, text=skillDesc % stats, text_align=TextNode.ALeft, text_scale=PiratesGuiGlobals.TextScaleSmall, text_fg=PiratesGuiGlobals.TextFG2, text_wordwrap=15, text_shadow=(0, 0, 0, 1), textMayChange=1, sortOrder=91, state=DGG.DISABLED) height = -(self.helpText.getHeight() + 0.01) self.helpBox = BorderFrame(parent=self, frameSize=(-0.04, 0.5, height, 0.05), pos=(0, 0, -0.12), sortOrder=90, state=DGG.DISABLED) self.helpBox.setBin('gui-popup', 0) self.helpText.reparentTo(self.helpBox) if self.skillRank: self.rankText.reparentTo(self.helpBox) return def destroy(self): if self.quantity: self.quantity.destroy() self.quantity = None self.ignoreAll() DirectButton.destroy(self) return def showDetails(self, event): self.createHelpbox() def hideDetails(self, event): if self.helpBox: self.helpBox.destroy() self.helpBox = None return def attachQuantity(self, quantity): if self.quantity: self.quantity['text'] = 'x%s' % quantity else: self.quantity = DirectLabel( parent=self, relief=None, state=DGG.DISABLED, text='x%s' % quantity, frameColor=(0, 0, 0, 1), frameSize=(-0.01, 0.02, -0.01, 0.025), text_scale=0.0275, text_align=TextNode.ACenter, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, text_wordwrap=11, pos=(0.03, 0.0, 0.03), text_font=PiratesGlobals.getPirateBoldOutlineFont()) return
class PokerTableGUI(DirectFrame, TableGUI): HandPos = (Vec3(0, 0, 0.40000000000000002), Vec3(0.38, 0, 0.33000000000000002), Vec3(0.65000000000000002, 0, 0.10000000000000001), Vec3(0.45000000000000001, 0, -0.26000000000000001), Vec3(0, 0, -0.29999999999999999), Vec3(-0.45000000000000001, 0, -0.26000000000000001), Vec3(-0.65000000000000002, 0, 0.10000000000000001), Vec3(-0.38, 0, 0.33000000000000002)) LocalAvatarGuiIndex = 4 def __init__(self, table, maxCommunityCards, maxHandCards): DirectFrame.__init__(self, parent = base.a2dBackground, relief = None) self.initialiseoptions(PokerTableGUI) self.maxCommunityCards = maxCommunityCards self.maxHandCards = maxHandCards self.maxBet = 0 self.numberOfTimeouts = 0 self.table = table self.destroyed = False self.playerActions = [] width = 1.0 self.menu = BorderFrame(parent = base.a2dBottomCenter, frameSize = (-width / 2.0, width / 2.0, 0, 0.25), pos = (0, 0, 0)) self.disableReason = DirectLabel(parent = self.menu, text = '', text_align = TextNode.ACenter, text_scale = 0.040000000000000001, pos = (0, 0, 0.17499999999999999), text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 1) self.disableReason.hide() self.initializeTableInterface() x = -0.35999999999999999 y = 0.17749999999999999 x_increment = 0.23999999999999999 helpText = PLocalizer.TableCardsHelp helpPos = (0.0, 0.0, 0.23999999999999999) text = PLocalizer.PokerCheat1 button = GuiButton(parent = self.menu, command = self.cardIndexSelection, helpText = helpText, helpPos = helpPos, pos = (x, 0, y), canReposition = True) self.setButtonSettings2Lines(button, (x, 0, y), text, [ PlayingCardGlobals.Cheat1]) self.cheat1Button = button self.buttonArray = self.buttonArray + [ button] x = x + x_increment text = PLocalizer.PokerCheat2 button = GuiButton(parent = self.menu, command = self.cardIndexSelection, helpText = helpText, helpPos = helpPos, pos = (x, 0, y), canReposition = True) self.setButtonSettings2Lines(button, (x, 0, y), text, [ PlayingCardGlobals.Cheat2]) self.cheat2Button = button self.buttonArray = self.buttonArray + [ button] x = x + x_increment text = PLocalizer.PokerCheck button = GuiButton(parent = self.menu, command = self.playerAction, canReposition = True) self.setButtonSettings(button, (x, 0, y), text, [ PlayingCardGlobals.CheckCall]) self.passButton = button self.buttonArray = self.buttonArray + [ button] x = x + x_increment text = PLocalizer.PokerBet button = GuiButton(parent = self.menu, command = self.playerAction, canReposition = True) self.setButtonSettings(button, (x, 0, y), text, [ PlayingCardGlobals.BetRaise]) self.betButton = button self.buttonArray = self.buttonArray + [ button] x = x + x_increment x = -0.35999999999999999 y = 0.070000000000000007 x_increment = 0.23999999999999999 x = x + x_increment x = x + x_increment x = x + x_increment text = PLocalizer.PokerFold button = GuiButton(parent = self.menu, command = self.playerAction, canReposition = True) self.setButtonSettings(button, (x, 0, y), text, [ PlayingCardGlobals.Fold]) self.foldButton = button self.buttonArray = self.buttonArray + [ button] x = x + x_increment self.potSizeLabel = DirectLabel(parent = self, relief = None, text = '', text_align = TextNode.ACenter, text_scale = 0.050000000000000003, pos = (-0.14999999999999999, 0.0, 0.17000000000000001), text_fg = (1, 0.90000000000000002, 0.59999999999999998, 1), text_shadow = (0, 0, 0, 1)) if table.wantMeter == 1: cardMaker = CardMaker('tellMeter') cardMaker.setFrame(-1, 1, -1, 1) self.meterMax = 0.20000000000000001 self.meterBorder = NodePath(cardMaker.generate()) self.meterBorder.setColor(1, 1, 0, 1) self.meterBorder.setScale(0.20000000000000001, 1, 0.02) self.meterBorder.reparentTo(aspect2d) self.meter = NodePath(cardMaker.generate()) self.meter.setColor(1, 0, 0, 1) self.meter.setScale(0.20000000000000001, 1, 0.050000000000000003) self.meter.reparentTo(aspect2d) if table.wantMeter == 2: cardMaker = CardMaker('tellMeter') cardMaker.setFrame(-1, 1, -1, 1) self.balance = NodePath('Balance') self.balance.reparentTo(aspect2d) self.balanceL = NodePath(cardMaker.generate()) self.balanceL.setColor(1, 0, 0, 1) self.balanceL.setScale(0.125, 1, 0.01) self.balanceL.setPos(-0.125, 0, 0) self.balanceL.reparentTo(self.balance) self.balanceR = NodePath(cardMaker.generate()) self.balanceR.setColor(0, 1, 0, 1) self.balanceR.setScale(0.125, 1, 0.01) self.balanceR.setPos(0.125, 0, 0) self.balanceR.reparentTo(self.balance) self.fulcrum = loader.loadModel('models/props/winebottle_B') self.fulcrum.setScale(0.20000000000000001) self.fulcrum.setZ(-0.20999999999999999) self.fulcrum.reparentTo(aspect2d) self.weightR = NodePath(cardMaker.generate()) self.weightR.setColor(0, 0, 1, 1) self.weightR.setScale(0.029999999999999999, 1, 0.050000000000000003) self.weightR.setPos(0.22, 0, 0.059999999999999998) self.weightR.reparentTo(self.balance) self.weightL = NodePath(cardMaker.generate()) self.weightL.setColor(0, 0, 1, 1) self.weightL.setScale(0.029999999999999999, 1, 0.050000000000000003) self.weightL.setPos(-0.22, 0, 0.059999999999999998) self.weightL.reparentTo(self.balance) self.balance.hide() self.fulcrum.hide() self.communityCardNode = NodePath('communityCards') self.communityCardNode.reparentTo(self) self.communityCardNode.setScale(0.5) self.communityCardNode.setPos(0, 0, 0.040000000000000001) self.communityCards = [] for i in range(self.maxCommunityCards): card = PlayingCard.PlayingCardNodePath('standard', PlayingCardGlobals.Unknown) card.reparentTo(self.communityCardNode) card.setPos(i * 0.29999999999999999 - 0.59999999999999998, 0, 0) card.hide() self.communityCards.append(card) self.playerStatusPanels = [] for i in range(self.table.NumSeats + 1): statusPanel = PokerStatusPanel(self.maxHandCards) statusPanel.setName('playerHand-%s' % i) pos = self.HandPos[i] statusPanel.setPos(pos) self.playerStatusPanels.append(statusPanel) self.localStatusPanel = self.playerStatusPanels[self.LocalAvatarGuiIndex] gui = loader.loadModel('models/gui/toplevel_gui') goldCoin = gui.find('**/treasure_w_coin*') scale = 0.32000000000000001 currentMoney = self.table.getPlayerChips() x_increment = 0.23999999999999999 self.moneyDisplay = DirectLabel(parent = self.menu, relief = None, pos = (-0.29999999999999999 + x_increment, 0, 0.074999999999999997), geom = goldCoin, geom_scale = (scale, scale, scale), geom_pos = (0, 0, 0), text = '%s' % currentMoney, text_align = TextNode.ALeft, text_scale = 0.040000000000000001, text_pos = (0.050000000000000003, -0.01), text_fg = PiratesGuiGlobals.TextFG1, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 1, scale = 1.1000000000000001) self.accept(InventoryGlobals.getCategoryQuantChangeMsg(localAvatar.getInventoryId(), InventoryType.ItemTypeMoney), self.setMoney) this = self identifier = 0 this.sfxArray = [] this.shuffleIdentifier = identifier this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_SHUFFLE)] identifier += 1 this.startDealIdentifier = identifier this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_01)] identifier += 1 this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_02)] identifier += 1 this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_03)] identifier += 1 this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_04)] identifier += 1 this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_05)] identifier += 1 this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_06)] identifier += 1 this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_07)] identifier += 1 this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_08)] identifier += 1 this.totalDealIdentifiers = identifier - this.startDealIdentifier this.foldIdentifier = identifier this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_FOLD)] identifier += 1 this.flipIdentifier = identifier this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_FLIP)] identifier += 1 this.pickupIdentifier = identifier this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_PICKUP)] identifier += 1 this.checkIdentifier = identifier check = loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_CHECK) check.setVolume(0.5) this.sfxArray = this.sfxArray + [ check] identifier += 1 this.betIdentifier = identifier this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_CHIPS_BET)] identifier += 1 this.collectIdentifier = identifier this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_CHIPS_COLLECT)] identifier += 1 this.allInIdentifier = identifier this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_CHIPS_ALL)] identifier += 1 def showActionButtons(self): self.cheat1Button.show() self.cheat2Button.show() self.passButton.show() self.betButton.show() self.foldButton.show() self.leaveButton.show() self.moneyDisplay.show() self.disableReason.hide() def hideActionButtons(self): self.cheat1Button.hide() self.cheat2Button.hide() self.passButton.hide() self.betButton.hide() self.foldButton.hide() self.leaveButton.hide() def playerAction(self, action, allin_amount = 0): self.numberOfTimeouts = 0 base.localAvatar.delayAFK() self.table.guiCallback(action, allin_amount) def leaveAction(self, action, allin_amount = 0): self.deleteLeaveDialog() def showLeaveDialog(displayText = None): if not displayText: pass self.leaveDialog = PDialog.PDialog(text = PLocalizer.PokerLeaveConfirmMessage, style = OTPDialog.YesNo, giveMouse = False, command = self.leaveCallback) self.table.setDialogBin(self.leaveDialog) if self.table.gameVariation == PiratesGlobals.PARLORGAME_VARIATION_UNDEAD: def gotInventory(inventory): text = None try: for currQuest in inventory.getQuestList(): for (currQuestTask, currQuestTaskState) in zip(currQuest.getTasks(), currQuest.getTaskStates()): if isinstance(currQuestTask, SkeletonPokerTaskDNA): if currQuestTaskState.isComplete(): if currQuestTaskState.isComplete(bonus = True): lostProgress = 0 else: lostProgress = currQuestTaskState.getBonusProgress() else: lostProgress = currQuestTaskState.getProgress() loseAmt = min(PiratesGlobals.PARLORGAME_UNDEAD_EXIT_LOSS, lostProgress) if loseAmt > 0: text = PLocalizer.PokerUndeadLeaveConfirmMessage % str(loseAmt) raise NameError('doneSearch') loseAmt > 0 except NameError: pass showLeaveDialog(text) invReq = DistributedInventoryBase.getInventory(localAvatar.inventoryId, gotInventory) else: showLeaveDialog() def timeoutAction(self, action): self.table.guiCallback(action) def setMoney(self, money): self.moneyDisplay['text'] = ('%s' % money,) self.table.displayStacks(self.table.localAvatarSeat, money) def showArrow(self, seatIndex): self.hideArrow() guiIndex = self.getGuiIndex(seatIndex) self.playerStatusPanels[guiIndex].arrow.show() self.playerStatusPanels[guiIndex].actionLabel.hide() def hideArrow(self): map(lambda panel: panel.arrow.hide(), self.playerStatusPanels) def setPlayerActions(self, maxBet, playerActions): oldActions = self.playerActions self.playerActions = playerActions oldMaxBet = self.maxBet self.maxBet = maxBet for (i, oldAction, newAction) in zip(range(len(playerActions)), oldActions, playerActions): if oldAction != newAction: (action, amount) = newAction panel = self.playerStatusPanels[self.getGuiIndex(i)] hand = panel.hand label = panel.actionLabel if action == PlayingCardGlobals.CheckCall: if amount: actionText = PLocalizer.PokerCall else: actionText = PLocalizer.PokerCheck elif action == PlayingCardGlobals.BetRaise: if oldMaxBet == 0: actionText = PLocalizer.PokerBetAmount % amount else: actionText = PLocalizer.PokerRaiseAmount % amount elif action == PlayingCardGlobals.Fold: actionText = PLocalizer.PokerFold for card in hand: card.hide() panel.handNameLabel.hide() panel.arrow.hide() elif action == PlayingCardGlobals.NoAction: actionText = '' panel.actionLabel.hide() elif action == PlayingCardGlobals.SmallBlind: amount = self.table.anteList[1] actionText = PLocalizer.PokerSmallBlindAmount % amount elif action == PlayingCardGlobals.BigBlind: amount = self.table.anteList[2] actionText = PLocalizer.PokerBigBlindAmount % amount elif action == PlayingCardGlobals.Check: actionText = PLocalizer.PokerCheck elif action == PlayingCardGlobals.AllIn: actionText = PLocalizer.PokerAllIn else: self.notify.error('Unknown action: %s' % action) panel.displayAction(actionText, self.table, i) continue def getGuiIndex(self, seatIndex): return ((self.LocalAvatarGuiIndex - self.table.localAvatarSeat) + seatIndex) % (self.table.NumSeats + 1) def clearTable(self): for panel in self.playerStatusPanels: for card in panel.hand: card.hide() panel.handNameLabel.hide() panel.actionLabel.hide() panel.dealerButton.hide() panel.anteLabel.hide() for i in range(len(self.communityCards)): card = self.communityCards[i] card.hide() def setTableState(self, round, buttonSeat, communityCardValues, playerHandValues, totalWinningsArray): self.clearTable() self.playerStatusPanels[self.getGuiIndex(buttonSeat)].anteLabel.show() self.playerStatusPanels[self.getGuiIndex(buttonSeat)].dealerButton.show() for i in range(len(self.communityCards)): card = self.communityCards[i] if i < len(communityCardValues): newValue = communityCardValues[i] card.show() card.setValue(newValue) if newValue != PlayingCardGlobals.Unknown: card.turnUp() newValue != PlayingCardGlobals.Unknown card.hide() card.setValue(PlayingCardGlobals.Unknown) for i in range(len(playerHandValues)): newHand = playerHandValues[i] guiIndex = self.getGuiIndex(i) panel = self.playerStatusPanels[guiIndex] hand = panel.hand handNameLabel = panel.handNameLabel allUnknown = 1 for (card, newValue) in zip(hand, newHand): card.show() card.setValue(newValue) if newValue == PlayingCardGlobals.Unknown: card.turnDown() continue allUnknown = 0 card.turnUp() if allUnknown: panel.cardScaler.setScale(0.40000000000000002) else: panel.cardScaler.setScale(0.5) if newHand and PlayingCardGlobals.Unknown not in newHand: if self.table.handIdArray: seat = i handId = self.table.handIdArray[seat] if handId > PlayingCardGlobals.Nothing: sortedHand = self.table.sortedCardsArray[seat] handName = PLocalizer.getHandNameFull(self.table.handIdToHandCode(handId), sortedHand) handNameLabel['text'] = handName handNameLabel.show() end = False length = len(totalWinningsArray) for i in range(length): if totalWinningsArray[i] != 0: end = True break continue if end and self.table.endOfHand: for i in range(length): if totalWinningsArray[i] > 0: actor = self.table.actors[i] if actor: name = actor.getName() win = totalWinningsArray[i] message = PLocalizer.PokerChatWinGoldMessage % (name, win) base.talkAssistant.receiveGameMessage(message) if totalWinningsArray[i] == PlayingCardGlobals.PlayerCaughtCheating: actor = self.table.actors[i] if actor: name = actor.getName() message = PLocalizer.PokerChatCaughtCheatingMessage % name base.talkAssistant.receiveGameMessage(message) def setLocalAvatarHand(self, cardValues): map(lambda card: card.hide(), self.localStatusPanel.hand) self.localStatusPanel.cardScaler.setScale(0.5) for (card, newValue) in zip(self.localStatusPanel.hand, cardValues): card.show() card.setValue(newValue) if newValue != PlayingCardGlobals.Unknown: card.turnUp() continue handNameLabel = self.localStatusPanel.handNameLabel communityCardValues = map(lambda card: card.getValue(), self.communityCards) if cardValues and PlayingCardGlobals.Unknown not in cardValues: if self.handId == PlayingCardGlobals.Nothing or self.sortedCards == None: handNameLabel.hide() else: handName = PLocalizer.getHandNameFull(self.table.handIdToHandCode(self.handId), self.sortedCards) handNameLabel['text'] = handName handNameLabel.show() else: handNameLabel.hide() def setPotSize(self, potSize): if potSize: self.potSizeLabel['text'] = PLocalizer.PokerPotAmount % potSize else: self.potSizeLabel['text'] = '' def enableActionCallback(self): pass def enableAction(self): chips = self.table.getPlayerChips() minimum = self.table.getMinimumBetAmount() if chips <= 0: self.table.allIn() else: self.cheat1Button.show() self.cheat2Button.show() self.passButton.show() self.betButton.show() self.foldButton.show() self.disableReason.hide() if self.table.checkCondition(): self.passButton['text'] = PLocalizer.PokerCheck self.passButton['extraArgs'] = [ PlayingCardGlobals.Check] if chips > minimum: self.betButton['text'] = PLocalizer.PokerBetAmount % minimum self.betButton['extraArgs'] = [ PlayingCardGlobals.BetRaise] else: self.betButton['text'] = PLocalizer.PokerAllInAmount % chips self.betButton['extraArgs'] = [ PlayingCardGlobals.AllIn, chips] else: callAmount = self.table.getCallAmount() raiseAmount = self.table.maxBet + minimum if chips > callAmount: if callAmount == 0: self.passButton['text'] = PLocalizer.PokerCheck self.passButton['extraArgs'] = [ PlayingCardGlobals.Check] else: self.passButton['text'] = PLocalizer.PokerCallAmount % callAmount self.passButton['extraArgs'] = [ PlayingCardGlobals.CheckCall] else: self.passButton['text'] = PLocalizer.PokerAllInAmount % chips self.passButton['extraArgs'] = [ PlayingCardGlobals.AllIn, chips] self.betButton.hide() if chips > callAmount + minimum: self.betButton['text'] = PLocalizer.PokerRaiseAmount % raiseAmount self.betButton['extraArgs'] = [ PlayingCardGlobals.BetRaise] else: self.betButton['text'] = PLocalizer.PokerAllInAmount % (callAmount + chips) self.betButton['extraArgs'] = [ PlayingCardGlobals.AllIn, chips] self.startTimer(PlayingCardGlobals.SecondsPerHand) def timeoutFold(self): self.hideActionButtons() self.hideCheatButtons() self.timeoutAction(PlayingCardGlobals.Fold) self.leaveButton.show() self.timeout = True self.deleteSwapDialog() def timeoutLeave(self): self.hideActionButtons() self.hideCheatButtons() self.timeoutAction(PlayingCardGlobals.Leave) self.timeout = True self.deleteSwapDialog() def timerExpiredCallback(self): self.numberOfTimeouts = self.numberOfTimeouts + 1 if self.numberOfTimeouts >= PlayingCardGlobals.MaximumTimeouts: self.timeoutLeave() else: self.timeoutFold() self.endTimer() def enableCheat(self): have_cheat_card = False for card_id in range(52): if self.table.getPlayerInventoryCardCount(card_id) > 0: have_cheat_card = True break continue if have_cheat_card: self.normalButton(self.cheat1Button) self.normalButton(self.cheat2Button) else: self.disableCheat() def disableCheat(self): self.disableButton(self.cheat1Button) self.disableButton(self.cheat2Button) def disableAction(self, reason = None): self.cheat1Button.hide() self.cheat2Button.hide() self.passButton.hide() self.betButton.hide() self.foldButton.hide() if reason: self.disableReason['text'] = reason self.disableReason.show() else: self.disableReason.hide() self.endTimer() def destroy(self): self.endTimer() self.deleteTableGUI() self.potSizeLabel.destroy() self.menu.destroy() del self.menu self.communityCardNode.removeNode() del self.communityCardNode for card in self.communityCards: card.removeNode() del self.communityCards for panel in self.playerStatusPanels: panel.destroy() del self.playerStatusPanels del self.localStatusPanel if self.table.wantMeter == 1: self.meter.removeNode() del self.meter self.meterBorder.removeNode() del self.meterBorder if self.table.wantMeter == 2: self.fulcrum.removeNode() del self.fulcrum self.balance.removeNode() del self.balance this = self if this.sfxArray: length = len(this.sfxArray) for i in range(length): sfx = this.sfxArray[i] this.sfxArray[i] = None if sfx: loader.unloadSfx(sfx) continue self.destroyed = True del self.table DirectFrame.destroy(self) def getMeterPercent(self): return (self.meter.getScale()[0] / self.meterMax) * 100.0 def setMeterPercent(self, percent): curScale = self.meter.getScale() self.meter.setScale(self.meterMax * (percent / 100.0), curScale[1], curScale[2]) def getBalanceAngle(self): return self.balance.getR() def setBalanceAngle(self, angle): self.balance.setR(angle)
class BlackjackTableGUI(DirectFrame, TableGUI, SplitBase): HandPos = (Vec3(0, 0, 0.40000000000000002), Vec3(0.38, 0, 0.33000000000000002), Vec3(0.65000000000000002, 0, 0.10000000000000001), Vec3(0.45000000000000001, 0, -0.26000000000000001), Vec3(0, 0, -0.29999999999999999), Vec3(-0.45000000000000001, 0, -0.26000000000000001), Vec3(-0.65000000000000002, 0, 0.10000000000000001), Vec3(-0.38, 0, 0.33000000000000002)) LocalAvatarGuiIndex = 4 def sliderValueToBid(self, value): bid = int(value * self.table.betMultiplier * 50) bid = bid / 5 bid = bid * 5 if bid < 2: bid = 2 return bid def x_to_gui_coordinate(self, x): return x * self.width def y_to_gui_coordinate(self, y): return self.height - y * self.height def create_slider(self, update_function, default_value, x, y, resolution, label, parent): slider_x = self.x_to_gui_coordinate(x) slider_y = self.y_to_gui_coordinate(y) def update_slider(slider, update_function): string = slider.label + ' (%d)' % self.sliderValueToBid(slider['value']) slider['text'] = string update_function(slider['value']) charGui = loader.loadModel('models/gui/char_gui') slider = DirectSlider(parent = parent, relief = None, command = update_slider, image = charGui.find('**/chargui_slider_small'), image_scale = (2.1499999999999999, 2.1499999999999999, 1.5), thumb_relief = None, thumb_image = (charGui.find('**/chargui_slider_node'), charGui.find('**/chargui_slider_node_down'), charGui.find('**/chargui_slider_node_over')), pos = (slider_x, 0.0, slider_y), text_align = TextNode.ACenter, text_scale = (0.10000000000000001, 0.10000000000000001), text_pos = (0.0, 0.10000000000000001), text_fg = PiratesGuiGlobals.TextFG1, scale = 0.42999999999999999, pageSize = resolution, text = 'default', value = default_value) charGui.removeNode() slider.label = label slider['extraArgs'] = [ slider, update_function] return slider def __init__(self, table): DirectFrame.__init__(self, relief = None) self.initialiseoptions(BlackjackTableGUI) self.table = table self.destroyed = False self.maxHandCards = 14 self.playerStatusPanels = [] for i in range(self.table.NumSeats + 1): statusPanel = BlackjackStatusPanel(self.maxHandCards) statusPanel.setName('playerHand-%s' % i) pos = self.HandPos[i] statusPanel.setPos(pos) self.playerStatusPanels.append(statusPanel) self.localStatusPanel = self.playerStatusPanels[self.LocalAvatarGuiIndex] width = 1.0 height = 0.25 self.menu = BorderFrame(parent = base.a2dBottomCenter, frameSize = (-width / 2.0, width / 2.0, 0, height), pos = (0, 0, 0)) self.width = width self.height = height self.initializeTableInterface() x = -0.35999999999999999 y = 0.17749999999999999 x_increment = 0.23999999999999999 helpText = PLocalizer.TableCardsHelp helpPos = (0.0, 0.0, 0.23999999999999999) text = PLocalizer.BlackjackCardSwap button = GuiButton(parent = self.menu, command = self.playerAction, helpText = helpText, helpPos = helpPos, pos = (x, 0, y), canReposition = True) self.setButtonSettings2Lines(button, (x, 0, y), text, [ PlayingCardGlobals.CardSwap]) button.show() self.cardSwapButton = button self.buttonArray = self.buttonArray + [ button] x += x_increment text = PLocalizer.BlackjackDoubleDown button = GuiButton(parent = self.menu, command = self.playerAction, canReposition = True) self.setButtonSettings2Lines(button, (x, 0, y), text, [ PlayingCardGlobals.DoubleDown]) button.show() self.doubleDownButton = button self.buttonArray = self.buttonArray + [ button] x += x_increment text = PLocalizer.BlackjackStay button = GuiButton(parent = self.menu, command = self.playerAction, canReposition = True) self.setButtonSettings(button, (x, 0, y), text, [ PlayingCardGlobals.Stay]) button.show() self.stayButton = button self.buttonArray = self.buttonArray + [ button] x += x_increment text = PLocalizer.BlackjackHit button = GuiButton(parent = self.menu, command = self.playerAction, canReposition = True) self.setButtonSettings(button, (x, 0, y), text, [ PlayingCardGlobals.Hit]) button.show() self.hitButton = button self.buttonArray = self.buttonArray + [ button] x += x_increment x = -0.35999999999999999 y = 0.070000000000000007 x_increment = 0.23999999999999999 x += x_increment x += x_increment text = PLocalizer.BlackjackSplit button = GuiButton(parent = self.menu, command = self.playerAction, canReposition = True) self.setButtonSettings(button, (x, 0, y), text, [ PlayingCardGlobals.Split]) button.show() self.splitButton = button self.buttonArray = self.buttonArray + [ button] x += x_increment bid = self.table.getTableBidAmount() text = PLocalizer.BlackjackBid + ' ' + bid.__repr__() button = GuiButton(parent = self.menu, command = self.playerAction, canReposition = True) self.setButtonSettings(button, (x, 0, y), text, [ PlayingCardGlobals.Bid]) button.show() self.bidButton = button self.buttonArray = self.buttonArray + [ button] x += x_increment def bid_update_function(value): bid = self.sliderValueToBid(value) text = PLocalizer.BlackjackBid + ' ' + bid.__repr__() self.bidButton['text'] = text self.bidAmount = bid self.bidAmount = 2 default_value = 0.0 x = 0.0 y = -0.25 label = PLocalizer.BlackjackBid resolution = 1.0 self.bidSlider = self.create_slider(bid_update_function, default_value, x, y, resolution, label, self.menu) x = -0.35999999999999999 y = 0.17749999999999999 x_increment = 0.23999999999999999 text = PLocalizer.PokerCheat1 button = GuiButton(parent = self.menu, command = self.cardSwapButtonSelection, canReposition = True) self.setButtonSettings2Lines(button, (x, 0, y), text, [ PlayingCardGlobals.Cheat1]) self.cheat1Button = button self.buttonArray = self.buttonArray + [ button] x = x + x_increment text = PLocalizer.PokerCheat2 button = GuiButton(parent = self.menu, command = self.cardSwapButtonSelection, canReposition = True) self.setButtonSettings2Lines(button, (x, 0, y), text, [ PlayingCardGlobals.Cheat2]) self.cheat2Button = button self.buttonArray = self.buttonArray + [ button] x = x + x_increment self.hideCheatButtons() self.disableAllPlayButtons() gui = loader.loadModel('models/gui/toplevel_gui') goldCoin = gui.find('**/treasure_w_coin*') scale = 0.32000000000000001 currentMoney = localAvatar.getInventory().getGoldInPocket() self.moneyDisplay = DirectLabel(parent = self.menu, relief = None, pos = (-0.29999999999999999 + x_increment / 2.0, 0, 0.074999999999999997), geom = goldCoin, geom_scale = (scale, scale, scale), geom_pos = (0, 0, 0), text = '%s' % currentMoney, text_align = TextNode.ALeft, text_scale = 0.035000000000000003, text_pos = (0.044999999999999998, -0.01), text_fg = PiratesGuiGlobals.TextFG1, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 1, scale = 1.1000000000000001) self.accept(InventoryGlobals.getCategoryQuantChangeMsg(localAvatar.getInventoryId(), InventoryType.ItemTypeMoney), self.setMoney) this = self identifier = 0 this.sfxArray = [] this.hitIdentifier = identifier this.sfxArray = this.sfxArray + [ loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_HIT)] identifier = identifier + 1 self.hands = [] self.splitCardsArray = [] self.canSplit = False self.canDoubleDown = False self.bid = False def cardSwapButtonSelection(self, card): self.cheat1Button.hide() self.cheat2Button.hide() self.cardIndexSelection(card) def startCardIndexSelection(self): self.cheat1Button.show() self.cheat2Button.show() self.cancelButton.show() self.hideActionButtons() def playerAction(self, action): base.localAvatar.delayAFK() if action == PlayingCardGlobals.CardSwap: self.startCardIndexSelection() else: self.table.guiCallback(action) self.endTimer() self.disableAllPlayButtons() if action == PlayingCardGlobals.Split: length = len(self.hands) if length > 0 and self.table.localAvatarSeat > 0 and self.table.localAvatarSeat < length: hand = self.hands[self.table.localAvatarSeat] if hand and len(hand) == 2: self.splitCardsArray.append(hand[1]) def setMoney(self, money): self.moneyDisplay['text'] = '%s' % money self.table.displayStacks(self.table.localAvatarSeat, money) def showArrow(self, seatIndex): self.hideArrow() guiIndex = self.getGuiIndex(seatIndex) self.playerStatusPanels[guiIndex].arrow.show() self.playerStatusPanels[guiIndex].actionLabel.hide() def hideArrow(self): map(lambda panel: panel.arrow.hide(), self.playerStatusPanels) def getGuiIndex(self, seatIndex): return ((self.LocalAvatarGuiIndex - self.table.localAvatarSeat) + seatIndex) % (self.table.NumSeats + 1) def setTableState(self, hands, allHands): for panel in self.playerStatusPanels: for card in panel.hand: card.hide() panel.handNameLabel.hide() panel.splitLabel.hide() panel.handsLabel.hide() self.hands = hands for i in range(len(hands)): newHand = hands[i] guiIndex = self.getGuiIndex(i) panel = self.playerStatusPanels[guiIndex] hand = panel.hand handNameLabel = panel.handNameLabel splitLabel = panel.splitLabel handsLabel = panel.handsLabel for (card, newValue) in zip(hand, newHand): card.show() card.setValue(newValue) if newValue == PlayingCardGlobals.Unknown: card.turnDown() continue card.turnUp() self.centerCards(panel, newHand) if newHand and PlayingCardGlobals.Unknown not in newHand: handValue = PlayingCardGlobals.getBlackjackHandValue(newHand) if handValue == 21 and len(newHand) == 2: handArray = allHands[i] total_hands = len(handArray) if total_hands <= 1: handNameLabel['text'] = PLocalizer.BlackjackHand else: handNameLabel['text'] = str(handValue) elif handValue > 21: handNameLabel['text'] = PLocalizer.BlackjackBusted % handValue else: handNameLabel['text'] = str(handValue) handNameLabel.show() if i == self.table.localAvatarSeat: handArray = allHands[i] total_hands = len(handArray) if total_hands > 1: current_hand_index = self.table.getCurrentHandIndex(i, allHands) splitLabel['text'] = PLocalizer.BlackjackHandofHand % (current_hand_index + 1, total_hands) splitLabel.show() hands_text = '' for h in range(current_hand_index): hands_text = hands_text + str(PlayingCardGlobals.getBlackjackHandValue(handArray[h])) + ' ' handsLabel.show() self.createSplitDisplay(i, allHands, handsLabel) self.canSplit = False self.canDoubleDown = False if newHand[0] in self.splitCardsArray: self.splitCardsArray.remove(newHand[0]) if handValue >= 21: self.disableAllPlayButtons() else: self.updateSplitAndDoubleDown(newHand) i == self.table.localAvatarSeat def updateSplitAndDoubleDown(self, hand): self.canSplit = False self.canDoubleDown = False length = len(hand) if length == 2: if self.table.getPlayerChips() >= self.bidAmount: self.canDoubleDown = True if self.splitableHand(hand[0], hand[1]): self.canSplit = True def updatePlayButtions(self): self.disableAllPlayButtons() if self.canDoubleDown: self.normalButton(self.doubleDownButton) self.normalButton(self.stayButton) self.normalButton(self.hitButton) if self.canSplit: self.normalButton(self.splitButton) have_cheat_card = False if self.swapCard == False: for card_id in range(52): if self.table.getPlayerInventoryCardCount(card_id) > 0: have_cheat_card = True break continue if have_cheat_card: self.normalButton(self.cardSwapButton) else: self.disableButton(self.cardSwapButton) def setEvent(self, seatIndex, action): guiIndex = self.getGuiIndex(seatIndex) panel = self.playerStatusPanels[guiIndex] actionText = PlayingCardGlobals.getBlackjackActionText(action) if len(action) >= 2: if action[0] == PlayingCardGlobals.Bid and action[1] == 0: actionText = ' ' if seatIndex == self.table.localAvatarSeat: if action[0] == PlayingCardGlobals.Bid: if action[1] == 0: self.bid = False else: self.bid = True panel.displayAction(actionText, self.table, seatIndex) if seatIndex == self.table.localAvatarSeat: time = 0.0 if action[0] == PlayingCardGlobals.AskForBid: time = PlayingCardGlobals.BidTimeout self.disableAllPlayButtons() self.normalButton(self.bidButton) self.bidSlider.show() self.splitCardsArray = [] self.swapCard = False self.bid = False if action[0] == PlayingCardGlobals.AskCard: time = PlayingCardGlobals.AskCardTimeout self.updatePlayButtions() if action[0] == PlayingCardGlobals.Stay: self.disableAllPlayButtons() if action[0] == PlayingCardGlobals.DoubleDown: self.disableAllPlayButtons() if action[0] == PlayingCardGlobals.Split: time = PlayingCardGlobals.AskCardTimeout self.disableAllPlayButtons() if time > 0.0: self.startTimer(time) def disableAllPlayButtons(self): self.disableButton(self.splitButton) self.disableButton(self.doubleDownButton) self.disableButton(self.stayButton) self.disableButton(self.hitButton) self.disableButton(self.bidButton) self.bidSlider.hide() self.disableButton(self.cardSwapButton) def destroy(self): self.endTimer() self.deleteTableGUI() del self.bidSlider self.menu.destroy() del self.menu for panel in self.playerStatusPanels: panel.destroy() del self.playerStatusPanels del self.localStatusPanel self.destroyed = True del self.table DirectFrame.destroy(self) this = self if this.sfxArray: length = len(this.sfxArray) for i in range(length): sfx = this.sfxArray[i] this.sfxArray[i] = None if sfx: loader.unloadSfx(sfx) continue def leaveAction(self, action): self.deleteLeaveDialog() self.leaveDialog = PDialog.PDialog(text = PLocalizer.PokerLeaveConfirmMessage, style = OTPDialog.YesNo, giveMouse = False, command = self.leaveCallback) self.table.setDialogBin(self.leaveDialog) def timerExpiredCallback(self): self.disableAllPlayButtons() self.showActionButtons() self.hideCheatButtons() self.leaveButton.show() self.cheat1Button.hide() self.cheat2Button.hide() self.endTimer() self.deleteSwapDialog() def splitableHand(self, card1, card2): state = False rank1 = card1 % 13 rank2 = card2 % 13 if rank1 == rank2: state = True elif rank1 >= 8 and rank1 <= 11 and rank2 >= 8 and rank2 <= 11: state = True return state def showActionButtons(self): self.splitButton.show() self.doubleDownButton.show() self.stayButton.show() self.hitButton.show() self.bidButton.show() if self.cardSwapButton: self.cardSwapButton.show() self.leaveButton.show() self.moneyDisplay.show() def hideActionButtons(self): self.splitButton.hide() self.doubleDownButton.hide() self.stayButton.hide() self.hitButton.hide() self.bidButton.hide() self.bidSlider.hide() if self.cardSwapButton: self.cardSwapButton.hide() self.leaveButton.hide() self.moneyDisplay.show() def cancelSelection(self, value = None): self.hideButtonArray(self.suitButtonArray) self.hideButtonArray(self.rankButtonArray) self.cancelButton.hide() self.showActionButtons() self.cheat1Button.hide() self.cheat2Button.hide() def createSplitDisplay(self, seat, allHands, parent): self.deleteSplitDisplay(parent) handArray = allHands[seat] total_hands = len(handArray) if total_hands > 1: current_hand_index = self.table.getCurrentHandIndex(seat, allHands) x_increment = 0.23999999999999999 x_size = (total_hands - 1) * x_increment x = -x_size * 0.5 y = -0.16 card_y = -0.050000000000000003 for h in range(total_hands): hand = handArray[h] value = PlayingCardGlobals.getBlackjackHandValue(hand) scale = 0.375 length = len(hand) card_x_increment = 0.059999999999999998 left = card_x_increment * scale * length * -0.5 for i in range(length): card = PlayingCard.PlayingCardNodePath('standard', PlayingCardGlobals.Unknown) card.reparentTo(parent) card.setPos(x + left + i * card_x_increment * scale, 0, card_y) card.setScale(scale) card.setValue(hand[i]) card.turnUp() card.show() parent.cardArray.append(card) if h == current_hand_index: color = 1.0 card.setColor(color, color, color, 1.0) continue color = 0.59999999999999998 card.setColor(color, color, color, 1.0) label = DirectLabel(parent = parent, relief = None, text = '', text_align = TextNode.ACenter, text_scale = 0.040000000000000001, pos = (x, 0.0, y), text_fg = (1, 1, 1, 1), text_shadow = (0, 0, 0, 1)) label['text'] = str(value) label.show() parent.labelArray.append(label) x += x_increment def centerCards(self, panel, hand): x_increment = 0.059999999999999998 length = len(hand) left = x_increment * length * -0.5 for i in range(length): card = panel.hand[i] card.setPos(left + i * x_increment, 0, 0)
class SkillButton(DirectFrame): notify = directNotify.newCategory('SkillButton') SkillIcons = None Image = None SkillRechargedSound = None SubLock = None def __init__(self, skillId, callback, quantity = 0, skillRank = 0, showQuantity = False, showHelp = False, showRing = False, hotkey = None, name = '', showIcon = True, showLock = False, rechargeSkillId = False, isWeaponSkill = False, assocAmmo = []): DirectFrame.__init__(self, parent = NodePath(), relief = None) self.initialiseoptions(SkillButton) gui = loader.loadModel('models/gui/toplevel_gui') if not SkillButton.SkillIcons: print 'not SkillButton.SkillIcons:' SkillButton.SkillIcons = loader.loadModel('models/textureCards/skillIcons') SkillButton.Image = (SkillButton.SkillIcons.find('**/base'), SkillButton.SkillIcons.find('**/base_down'), SkillButton.SkillIcons.find('**/base_over')) SkillButton.SkillRechargedSound = loadSfx(SoundGlobals.SFX_SKILL_RECHARGED) SkillButton.SubLock = gui.find('**/pir_t_gui_gen_key_subscriber') SkillButton.SpecialIcons = [] for entry in SPECIAL_SKILL_ICONS: if not entry: SkillButton.SpecialIcons.append(None) continue specialImage = (SkillButton.SkillIcons.find('**/%s' % entry),) SkillButton.SpecialIcons.append(specialImage) model = loader.loadModel('models/effects/particleMaps') toggleIcon = model.find('**/particleGlow') toggleIcon.node().setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd)) self.toggleFrame = DirectFrame(relief = None, state = DGG.DISABLED, parent = self, image = toggleIcon, image_scale = 0.34999999999999998, image_pos = (0.0, 0.0, -0.01)) self.toggleFrame.hide() self.glowRing = None self.glowRing2 = None self.assocAmmo = assocAmmo self.skillId = skillId self.quantity = quantity self.showQuantity = showQuantity self.skillRank = skillRank self.skillRing = None self.callback = callback self.showUpgrade = False self.showHelp = showHelp self.showRing = showRing self.showIcon = showIcon self.showLock = showLock self.isWeaponSkill = isWeaponSkill self.lock = None self.name = name self.helpFrame = None self.quantityLabel = None self.skillButton = None self.hotkeyLabel = None self.hotkey = hotkey self.greyOut = 0 self.tonicId = 0 self.skillRingIval = None self.impulseIval = None self.quickImpulseIval = None self.isBreakAttackSkill = WeaponGlobals.getSkillTrack(self.skillId) == WeaponGlobals.BREAK_ATTACK_SKILL_INDEX self.isDefenseSkill = WeaponGlobals.getSkillTrack(self.skillId) == WeaponGlobals.DEFENSE_SKILL_INDEX self.rechargeFilled = 0 self.defenseAuraEffect = None if self.isWeaponSkill: self.weaponBackground = DirectLabel(parent = self, state = DGG.DISABLED, image = SkillButton.SkillIcons.find('**/box_base'), image_scale = (0.22, 0, 0.22), image_pos = (0.0, 0.0, 0.0)) self.weaponBackground.flattenLight() self.weaponBackground.setColor(0.20000000000000001, 0.20000000000000001, 0.20000000000000001, 0.20000000000000001) self.weaponBackground.setTransparency(1) if showRing: if self.isBreakAttackSkill: color = Vec4(1, 0, 0, 1) elif self.isDefenseSkill: color = Vec4(0, 1, 1, 1) else: color = Vec4(1, 0.80000000000000004, 0.5, 1) self.skillRing = SkillRing(color, Vec4(0, 0, 0, 1.0)) gs = self.skillRing.meterFaceHalf2.node().getGeomState(0) self.skillRing.meterFaceHalf2.node().setGeomState(0, gs.removeAttrib(ColorAttrib.getClassType())) self.skillRing.reparentTo(self, 0) self.skillRing.setPos(0, 0, 0) self.updateSkillId(skillId) if showQuantity: self.updateQuantity(quantity) if hotkey: self.createHotkey(hotkey) if showLock: self.createLock() self.skillButton.bind(DGG.ENTER, self.showDetails) self.skillButton.bind(DGG.EXIT, self.hideDetails) if self.skillId >= InventoryType.begin_Consumables and self.skillId <= InventoryType.end_Consumables and not WeaponGlobals.getSkillEffectFlag(skillId): self.totalRechargeTime = base.cr.battleMgr.getModifiedRechargeTime(localAvatar, InventoryType.UseItem) self.tonicId = InventoryType.UseItem else: self.totalRechargeTime = base.cr.battleMgr.getModifiedRechargeTime(localAvatar, self.skillId) if showRing: if not self.isBreakAttackSkill: self.createSkillRingIval() if self.tonicId: timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging(InventoryType.UseItem) else: timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging(self.skillId) if self.isBreakAttackSkill and timeSpentRecharging < self.totalRechargeTime: self.updateRechargeRing() elif not (self.isBreakAttackSkill): if (self.totalRechargeTime or timeSpentRecharging) and not (timeSpentRecharging > self.totalRechargeTime): self.skillRingIval.start(startT = timeSpentRecharging) not (timeSpentRecharging > self.totalRechargeTime) self.skillRing.meterFaceHalf1.setR(0) self.skillRing.meterFaceHalf2.setR(180) self.skillRing.meterFaceHalf1.setColor(self.skillRing.meterActiveColor, 100) self.skillRing.meterFaceHalf2.setColor(self.skillRing.meterActiveColor, 100) self.skillRing.meterFaceHalf1.show() self.skillRing.meterFaceHalf2.show() if not self.isBreakAttackSkill: self.checkAmount() if self.isDefenseSkill: self.startRecharge() if self.isWeaponSkill: self.weaponLabel = DirectLabel(parent = self, relief = None, text = PLocalizer.WeaponAbility, text_font = PiratesGlobals.getPirateBoldOutlineFont(), text_align = TextNode.ACenter, text_scale = PiratesGuiGlobals.TextScaleLarge, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 0, pos = (0.0, 0, -0.12), sortOrder = 70, state = DGG.DISABLED) self.weaponLabel.flattenLight() def loadGlowRing(self): self.glowRing = loader.loadModel('models/effects/battleEffects').find('**/effectVoodooShockwave') self.glowRing.node().setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOne)) self.glowRing.reparentTo(self) self.glowRing.setBin('transparent', 0) self.glowRing.setScale(0.20000000000000001) self.glowRing.hide() self.glowRing2 = loader.loadModel('models/effects/particleMaps').find('**/particleGlow') self.glowRing2.node().setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OOneMinusIncomingAlpha, ColorBlendAttrib.OOne)) self.glowRing2.reparentTo(self) self.glowRing2.setBin('transparent', 0) self.glowRing2.setScale(0.20000000000000001) self.glowRing2.setColor(0.80000000000000004, 1, 0.80000000000000004, 0.20000000000000001) self.glowRing2.reparentTo(self) self.glowRing2.hide() def checkAmount(self): if not (self.quantity) and self.showQuantity: if self.showRing and not self.skillRingIval.isPlaying(): self.setGeomColor(0.5, 0.5, 0.5, 1.0) self.setRingColor(Vec4(0.5, 0.5, 0.5, 1.0)) elif self.showRing and not self.skillRingIval.isPlaying(): self.setGeomColor(1.0, 1.0, 1.0, 1.0) self.setRingColor(self.skillRing.meterActiveColor) def toggleButton(self, state): if state == True: self.toggleFrame.show() elif state == False: self.toggleFrame.hide() def createSkillRingIval(self): if self.skillRingIval: self.skillRingIval.pause() self.skillRing.meterFaceHalf1.setR(0) self.skillRing.meterFaceHalf2.setR(180) self.skillRing.setScale(1.0) self.skillRing.clearColorScale() self.setGeomColor(1.0, 1.0, 1.0, 1.0) self.checkAmount() self.skillRingIval = None if self.tonicId: timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging(InventoryType.UseItem) else: timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging(self.skillId) if self.isDefenseSkill: localAvatar.setDefenceEffect(self.skillId) if self.showRing: self.skillRingIval = Sequence(Func(localAvatar.setDefenceEffect, 0), Func(self.setGeomColor, 0.5, 0.5, 0.5, 1.0), Func(self.skillRing.meterFaceHalf1.setColor, self.skillRing.meterActiveColor, 100), Func(self.skillRing.meterFaceHalf2.setColor, self.skillRing.meterColor, 100), Func(self.skillRing.meterFaceHalf1.setR, 0), Func(self.skillRing.meterFaceHalf2.setR, 0), Func(self.skillRing.meterFaceHalf1.show), Func(self.skillRing.meterFaceHalf2.show), LerpFunc(self.skillRing.meterFaceHalf2.setR, self.totalRechargeTime / 2, 0, -180), Func(self.skillRing.meterFaceHalf2.setColor, self.skillRing.meterActiveColor, 100), Func(self.skillRing.meterFaceHalf2.setR, 0), LerpFunc(self.skillRing.meterFaceHalf1.setR, self.totalRechargeTime / 2, 0, -180), Func(self.setGeomColor, 1.0, 1.0, 1.0, 1.0), Func(base.playSfx, SkillButton.SkillRechargedSound, volume = 0.5), Parallel(LerpScaleInterval(self.skillRing, 0.10000000000000001, Vec3(1.2, 1.2, 1.2)), LerpColorScaleInterval(self.skillRing, 0.10000000000000001, Vec4(0.0, 0.75, 0.0, 1.0), Vec4(1.0, 1.0, 1.0, 1.0), blendType = 'easeInOut')), Func(localAvatar.setDefenceEffect, self.skillId), LerpScaleInterval(self.skillRing, 0.20000000000000001, Vec3(0.90000000000000002, 0.90000000000000002, 0.90000000000000002)), LerpScaleInterval(self.skillRing, 0.029999999999999999, Vec3(1.1000000000000001, 1.1000000000000001, 1.1000000000000001)), Parallel(LerpScaleInterval(self.skillRing, 0.029999999999999999, Vec3(1.0, 1.0, 1.0)), LerpColorScaleInterval(self.skillRing, 1, Vec4(1.0, 1.0, 1.0, 1.0), blendType = 'easeInOut')), Func(self.skillRing.clearColorScale), Func(self.checkAmount)) def updateSkillRingIval(self): if self.showRing: playing = self.skillRingIval.isPlaying() if self.tonicId: timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging(InventoryType.UseItem) else: timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging(self.skillId) if timeSpentRecharging: skillRechargeProgress = timeSpentRecharging / self.totalRechargeTime self.totalRechargeTime = base.cr.battleMgr.getModifiedRechargeTime(localAvatar, self.skillId) if not self.totalRechargeTime: self.totalRechargeTime = base.cr.battleMgr.getModifiedRechargeTime(localAvatar, InventoryType.UseItem) if timeSpentRecharging: timeSpentRecharging = skillRechargeProgress * self.totalRechargeTime localAvatar.skillDiary.modifyTimeSpentRecharging(self.skillId, timeSpentRecharging) self.createSkillRingIval() if playing and timeSpentRecharging: self.skillRingIval.start(startT = timeSpentRecharging) def quickGlowImpulse(self): if not self.glowRing2: self.loadGlowRing() self.quickImpulseIval = Sequence(Func(self.glowRing2.show), LerpScaleInterval(self.glowRing2, 0.20000000000000001, Vec3(0.33000000000000002, 0.33000000000000002, 0.33000000000000002)), LerpScaleInterval(self.glowRing2, 0.25, Vec3(0.20000000000000001, 0.20000000000000001, 0.20000000000000001)), Func(self.glowRing2.hide)) self.quickImpulseIval.start() def startPowerImpulse(self): if not self.glowRing: self.loadGlowRing() self.glowRing.show() self.impulseIval = Sequence(Parallel(LerpScaleInterval(self.glowRing, 0.10000000000000001, Vec3(0.20300000000000001, 0.20300000000000001, 0.20300000000000001)), LerpColorScaleInterval(self.glowRing, 0.10000000000000001, Vec4(0.80000000000000004, 0.80000000000000004, 0.80000000000000004, 0.80000000000000004), Vec4(1.0, 1.0, 1.0, 0.80000000000000004), blendType = 'easeInOut')), LerpScaleInterval(self.glowRing, 0.14999999999999999, Vec3(0.19, 0.19, 0.19)), LerpScaleInterval(self.glowRing, 0.050000000000000003, Vec3(0.20200000000000001, 0.20200000000000001, 0.20200000000000001)), Parallel(LerpScaleInterval(self.glowRing, 0.029999999999999999, Vec3(0.20000000000000001, 0.20000000000000001, 0.20000000000000001)), LerpColorScaleInterval(self.glowRing, 0.40000000000000002, Vec4(1.0, 1.0, 1.0, 1.0), blendType = 'easeInOut')), Func(self.glowRing.clearColorScale)) self.impulseIval.loop() def stopPowerImpulse(self): if self.glowRing: self.glowRing.hide() if self.impulseIval: self.impulseIval.finish() self.impulseIval = None def updateRechargeRing(self): timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging(self.skillId) self.totalRechargeTime = base.cr.battleMgr.getModifiedRechargeTime(localAvatar, self.skillId) if timeSpentRecharging >= self.totalRechargeTime and not (self.rechargeFilled): self.rechargeFilled = 1 if self.skillRingIval: self.skillRingIval.pause() self.skillRingIval = None self.skillRing.meterFaceHalf1.setR(0) self.skillRing.meterFaceHalf2.setR(180) self.skillRing.setScale(1.0) self.skillRing.clearColorScale() self.setGeomColor(1.0, 1.0, 1.0, 1.0) self.skillRingIval = Sequence(Func(base.playSfx, SkillButton.SkillRechargedSound, volume = 0.5), Parallel(LerpScaleInterval(self.skillRing, 0.10000000000000001, Vec3(1.2, 1.2, 1.2)), LerpColorScaleInterval(self.skillRing, 0.10000000000000001, Vec4(0.0, 0.75, 0.0, 1.0), Vec4(1.0, 1.0, 1.0, 1.0), blendType = 'easeInOut')), Func(localAvatar.setDefenceEffect, self.skillId), LerpScaleInterval(self.skillRing, 0.20000000000000001, Vec3(0.90000000000000002, 0.90000000000000002, 0.90000000000000002)), LerpScaleInterval(self.skillRing, 0.029999999999999999, Vec3(1.1000000000000001, 1.1000000000000001, 1.1000000000000001)), Parallel(LerpScaleInterval(self.skillRing, 0.029999999999999999, Vec3(1.0, 1.0, 1.0)), LerpColorScaleInterval(self.skillRing, 1, Vec4(1.0, 1.0, 1.0, 1.0), blendType = 'easeInOut')), Func(self.skillRing.clearColorScale)) self.skillRingIval.start() elif timeSpentRecharging < self.totalRechargeTime: self.rechargeFilled = 0 self.setGeomColor(0.5, 0.5, 0.5, 1.0) self.skillRing.update(timeSpentRecharging, self.totalRechargeTime) def updateSkillId(self, skillId): self.skillId = skillId if self.skillButton: if self.quantityLabel: self.quantityLabel.detachNode() self.skillButton.destroy() if self.showQuantity and not (self.quantity): geomColor = Vec4(0.5, 0.5, 0.5, 1.0) else: geomColor = Vec4(1.0, 1.0, 1.0, 1.0) if self.showIcon: asset = WeaponGlobals.getSkillIcon(skillId) if hasattr(self, '_skillIconName'): asset = self._skillIconName geom = SkillButton.SkillIcons.find('**/%s' % asset) if geom.isEmpty(): geom = SkillButton.SkillIcons.find('**/base') repId = WeaponGlobals.getSkillReputationCategoryId(self.skillId) geom_scale = getGeomScale(repId, skillId) image_color = (1, 1, 1, 1) else: geom = (None,) geom_scale = 0.12 image_color = (0.5, 0.5, 0.5, 0.5) specialIconId = 0 if self.isBreakAttackSkill: specialIconId = 1 elif self.isDefenseSkill: specialIconId = 2 elif skillId == ItemGlobals.getSpecialAttack(localAvatar.currentWeaponId): specialIconId = 3 if specialIconId: something = SkillButton.SpecialIcons[specialIconId][0] if self.skillRing: self.skillRing.setupFace(something) self['image'] = None elif self.skillRing: self.skillRing.setupFace() if self.showRing: image = None else: image = SkillButton.Image self.skillButton = DirectButton(parent = self, relief = None, pos = (0, 0, 0), text = ('', '', self.name), text_align = TextNode.ACenter, text_shadow = Vec4(0, 0, 0, 1), text_scale = 0.040000000000000001, text_fg = Vec4(1, 1, 1, 1), text_pos = (0.0, 0.089999999999999997), image = image, image_scale = 0.14999999999999999, image_color = image_color, geom = geom, geom_scale = geom_scale, geom_color = geomColor, command = self.callback, sortOrder = 50, extraArgs = [ skillId]) self.skillButton.bind(DGG.ENTER, self.showDetails) self.skillButton.bind(DGG.EXIT, self.hideDetails) if self.quantityLabel and not self.quantityLabel.isEmpty(): self.quantityLabel.reparentTo(self.skillButton) def createHotkey(self, hotkey): self.hotkeyLabel = DirectLabel(parent = self, relief = None, text = hotkey, text_font = PiratesGlobals.getPirateBoldOutlineFont(), text_align = TextNode.ARight, text_scale = PiratesGuiGlobals.TextScaleLarge, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 0, pos = (0.070000000000000007, 0, -0.059999999999999998), sortOrder = 70, state = DGG.DISABLED) self.hotkeyLabel.flattenLight() def createLock(self): if self.lock: return None self.lock = DirectFrame(parent = self, relief = None, image = SkillButton.SubLock, image_scale = 0.14000000000000001, image_pos = (0.050000000000000003, 0, -0.025000000000000001), sortOrder = 99) if self.showIcon: self.lock.setColorScale(0.90000000000000002, 0.90000000000000002, 0.90000000000000002, 1) self.skillButton.setColorScale(0.40000000000000002, 0.40000000000000002, 0.40000000000000002, 1, 1) else: self.lock.setColorScale(0.59999999999999998, 0.59999999999999998, 0.59999999999999998, 1, 2) self.skillButton.clearColorScale() if self.showHelp: self.lock.hide() def createHelpFrame(self, args = None): if self.helpFrame: return None inv = localAvatar.getInventory() if not inv: return None baseRank = max(self.skillRank, 1) lvlDamageMod = WeaponGlobals.getLevelDamageModifier(localAvatar.getLevel()) buff = WeaponGlobals.getSkillEffectFlag(self.skillId) dur = WeaponGlobals.getAttackDuration(self.skillId) effect = dur + dur * (baseRank - 1) / 4.0 bonus = localAvatar.getSkillRankBonus(self.skillId) upgradeAmt = WeaponGlobals.getAttackUpgrade(self.skillId) rank = localAvatar.getSkillRank(self.skillId) skillBoost = 0 if self.skillId in ItemGlobals.getLinkedSkills(localAvatar.currentWeaponId): linkedSkillId = WeaponGlobals.getLinkedSkillId(self.skillId) skillBoost = ItemGlobals.getWeaponBoosts(localAvatar.currentWeaponId, linkedSkillId) skillBoost += ItemGlobals.getWeaponBoosts(localAvatar.getCurrentCharm(), linkedSkillId) else: skillBoost = ItemGlobals.getWeaponBoosts(localAvatar.currentWeaponId, self.skillId) skillBoost += ItemGlobals.getWeaponBoosts(localAvatar.getCurrentCharm(), self.skillId) manaCost = 0 if WeaponGlobals.getSkillTrack(self.skillId) != WeaponGlobals.PASSIVE_SKILL_INDEX: manaCost = WeaponGlobals.getMojoCost(self.skillId) if manaCost < 0: amt = localAvatar.getSkillRankBonus(InventoryType.StaffConservation) manaCost = min(manaCost - manaCost * amt, 1.0) damage = 0 loDamage = 0 mpDamage = 0 mpLoDamage = 0 if WeaponGlobals.getSkillTrack(self.skillId) == WeaponGlobals.TONIC_SKILL_INDEX: damage = WeaponGlobals.getAttackSelfHP(self.skillId) elif WeaponGlobals.getSkillTrack(self.skillId) != WeaponGlobals.PASSIVE_SKILL_INDEX: mod = (1.0 + bonus) * lvlDamageMod damage = int(WeaponGlobals.getAttackTargetHP(self.skillId) * mod) loDamage = damage / 2 mpDamage = int(WeaponGlobals.getAttackTargetMojo(self.skillId) * mod) mpLoDamage = mpDamage / 2 try: skillInfo = PLocalizer.SkillDescriptions.get(self.skillId) skillTitle = PLocalizer.makeHeadingString(PLocalizer.InventoryTypeNames.get(self.skillId), 2) skillType = PLocalizer.makeHeadingString(skillInfo[0], 1) except: self.notify.error('Error getting skill info for skillId %s' % self.skillId) description = skillInfo[1] if damage < 0: description += ' ' + PLocalizer.DealsDamage elif damage > 0: if loDamage: loDamage = 0 description += ' ' + PLocalizer.HealsDamageRange else: description += ' ' + PLocalizer.HealsDamage if mpDamage < 0: description += ' ' + PLocalizer.DealsMpDamage effectId = WeaponGlobals.getSkillEffectFlag(self.skillId) if effectId: description += ' ' + SkillEffectDescriptions.get(effectId)[0] if bonus: if self.skillId == InventoryType.SailBroadsideLeft or self.skillId == InventoryType.SailBroadsideRight: description += ' ' + PLocalizer.BroadsideDesc if self.skillId == InventoryType.CannonShoot: description += ' ' + PLocalizer.CannonShootDesc if self.skillId == InventoryType.DollAttune: description += ' ' + PLocalizer.MultiAttuneDesc if WeaponGlobals.getSkillInterrupt(self.skillId): description += ' ' + PLocalizer.InterruptDesc if WeaponGlobals.getSkillUnattune(self.skillId): description += ' ' + PLocalizer.UnattuneDesc upgradeInfo = '' if self.showUpgrade and rank < 5: if rank > 0: upgradeInfo = skillInfo[2] if upgradeInfo == '': if damage < 0: upgradeInfo += PLocalizer.UpgradesDamage elif damage > 0: upgradeInfo += PLocalizer.UpgradesHealing if mpDamage < 0: upgradeInfo += ' ' + PLocalizer.UpgradesMpDamage if effectId: entry = SkillEffectDescriptions.get(effectId) if len(entry) > 1: if not damage: upgradeInfo += PLocalizer.UpgradesDuration else: upgradeInfo += ' ' + PLocalizer.And upgradeInfo += ' ' + entry[1] upgradeInfo += '!' elif len(upgradeInfo) >= 4: upgradeInfo = skillInfo[3] else: upgradeInfo = PLocalizer.ClickToLearn elif not self.showIcon: unlockLevel = RepChart.getSkillUnlockLevel(self.skillId) if unlockLevel > 0: upgradeInfo = PLocalizer.UnlocksAtLevel % unlockLevel if self.skillId in SkillComboReq and SkillComboReq[self.skillId] and inv.getStackQuantity(self.skillId - 1) < 2: color = 'red' if rank == 0: color = 'red' upgradeInfo = '' description += '\n' + color + SkillComboReq[self.skillId] + '.' skillDesc = skillTitle + '\n' + skillType + '\n\n' + description + '\ngreen' + upgradeInfo stats = [] if manaCost: stats.append(abs(manaCost)) if damage and loDamage: stats.append(abs(loDamage)) stats.append(abs(damage)) elif damage: stats.append(abs(damage)) if mpDamage: stats.append(abs(mpLoDamage)) stats.append(abs(mpDamage)) if buff == WeaponGlobals.C_CURSE: stats.append(WeaponGlobals.CURSED_DAM_AMP * 100) if buff == WeaponGlobals.C_WEAKEN: stats.append(WeaponGlobals.WEAKEN_PENALTY * 100) if effect > 0: stats.append(effect) if skillInfo[4]: if bonus == 0 and upgradeAmt > 0: if not self.skillId == InventoryType.SailBroadsideLeft and self.skillId == InventoryType.SailBroadsideRight: pass if not (self.skillId == InventoryType.CannonShoot): bonus = upgradeAmt if upgradeAmt < 1.0 and upgradeAmt > 0: bonus *= 100 if self.skillId == InventoryType.SailTreasureSense: bonus /= 2.0 elif self.skillId == InventoryType.CutlassParry: bonus += WeaponGlobals.getSubtypeParryBonus(localAvatar.currentWeaponId) if bonus: stats.append(abs(bonus)) if self.skillId == InventoryType.DollAttune: stats.append(rank) if self.skillRank: rankText = DirectFrame(parent = self, relief = None, text = PLocalizer.makeHeadingString(PLocalizer.Rank + ' %s' % (self.skillRank + skillBoost), 2), text_align = TextNode.ARight, text_scale = PiratesGuiGlobals.TextScaleSmall, text_fg = PiratesGuiGlobals.TextFG2, text_wordwrap = 15, text_shadow = (0, 0, 0, 1), pos = (0.45000000000000001, 0, 0), textMayChange = 1, sortOrder = 92, state = DGG.DISABLED) stats = [stat + 0.01 for stat in stats] try: pass except TypeError: self.notify.error('Error formatting skillDesc(%s): %s' % (self.skillId, stats)) helpText = DirectFrame(parent = self, relief = None, text = skillDesc % stats, text_align = TextNode.ALeft, text_scale = PiratesGuiGlobals.TextScaleSmall, text_fg = PiratesGuiGlobals.TextFG2, text_wordwrap = 17, textMayChange = 1, state = DGG.DISABLED, sortOrder = 91) height = -(helpText.getHeight() + 0.01) if self.lock: height = height - 0.040000000000000001 width = 0.55000000000000004 self.helpFrame = BorderFrame(parent = self, state = DGG.DISABLED, frameSize = (-0.040000000000000001, width, height, 0.050000000000000003), pos = (0, 0, -0.12), sortOrder = 90) self.helpFrame.setBin('gui-popup', 0) helpText.reparentTo(self.helpFrame) if self.skillRank: rankText.reparentTo(self.helpFrame) if self.lock: self.lockedFrame = DirectFrame(parent = self.helpFrame, relief = None, pos = (0.087999999999999995, 0, height + 0.029999999999999999), image = SkillButton.SubLock, image_scale = 0.13, image_pos = (-0.055, 0, 0.012999999999999999), text = PLocalizer.VR_AuthAccess, text_scale = PiratesGuiGlobals.TextScaleSmall, text_align = TextNode.ALeft, text_fg = PiratesGuiGlobals.TextFG13) self.notify.debug('locked!') pos = self.helpFrame.getPos(aspect2d) x = min(pos[0], base.a2dRight - width) z = max(pos[2], base.a2dBottom - height) self.helpFrame.setPos(aspect2d, x, 0, z) def showDetails(self, event): if self.showHelp: self.createHelpFrame() if self.showRing: self.skillRing.rollover(True) def hideDetails(self, event): if self.helpFrame: self.helpFrame.destroy() self.helpFrame = None if self.showRing: self.skillRing.rollover(False) def updateQuantity(self, quantity): self.quantity = quantity if not self.showQuantity: return None if quantity == WeaponGlobals.INF_QUANT: text = '' elif self.assocAmmo: assocQuantity = 0 inv = localAvatar.getInventory() if inv: for ammoId in self.assocAmmo: assocQuantity += inv.getItemQuantity(self.getAmmoCat(), ammoId) if quantity != assocQuantity: text = '%s' % assocQuantity else: text = 'x%s' % quantity else: text = 'x%s' % quantity if self.quantityLabel and not self.quantityLabel.isEmpty(): self.quantityLabel['text'] = text else: self.quantityLabel = DirectLabel(parent = NodePath(), relief = None, state = DGG.DISABLED, text = text, frameColor = (0, 0, 0, 1), frameSize = (-0.01, 0.02, -0.01, 0.025000000000000001), text_scale = PiratesGuiGlobals.TextScaleLarge, text_align = TextNode.ACenter, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_wordwrap = 11, pos = (0.029999999999999999, 0.0, 0.029999999999999999), text_font = PiratesGlobals.getPirateBoldOutlineFont(), sortOrder = 60) self.quantityLabel.flattenLight() self.quantityLabel.reparentTo(self) if self.skillButton and not self.skillButton.isEmpty(): self.quantityLabel.reparentTo(self.skillButton) def getAmmoCat(self): pass def startRecharge(self): if not self.showRing: return None if self.isBreakAttackSkill: self.setGeomColor(0.5, 0.5, 0.5, 1.0) self.updateRechargeRing() return None if self.skillRingIval.isPlaying(): self.createSkillRingIval() self.skillRingIval.start() def stopRecharge(self): if self.showRing: if self.isBreakAttackSkill: self.setGeomColor(0.5, 0.5, 0.5, 1.0) self.updateRechargeRing() return None if self.skillRingIval.isPlaying(): self.skillRingIval.pause() def setGeomColor(self, r, g, b, a): self.skillButton['geom_color'] = Vec4(r, g, b, a) def setRingColor(self, color): self.skillRing.meterFaceHalf1.setColor(color[0], color[1], color[2], color[3], 100) self.skillRing.meterFaceHalf2.setColor(color[0], color[1], color[2], color[3], 100) def setShowUpgrade(self, show): if self.showUpgrade != show: self.showUpgrade = show if self.helpFrame: self.helpFrame.destroy() self.helpFrame = None self.showDetails(None) def setShowIcon(self, show): if self.showIcon != show: self.showIcon = show self.updateSkillId(self.skillId) if self.helpFrame: self.helpFrame.destroy() self.helpFrame = None def setShowLock(self, show): if self.showLock != show: self.showLock = show if show: self.createLock() elif self.lock: self.lock.destroy() self.lock = None self.skillButton.clearColorScale() def destroy(self): self.callback = None if self.skillRingIval: self.skillRingIval.pause() self.skillRingIval = None if self.quantityLabel: self.quantityLabel.destroy() self.quantityLabel = None if self.impulseIval: self.impulseIval.pause() self.impulseIval = None if self.quickImpulseIval: self.quickImpulseIval.pause() self.quickImpulseIval = None self.ignoreAll() DirectFrame.destroy(self)