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)
