def destroy(self):
if self.showTask:
taskMgr.remove(self.showTask)
self.showTask = None
self.snapShot = None
BorderFrame.destroy(self)
def __init__(self, parent, shipOV = None, shipName = '', shipClass = 0, mastInfo = [], hp = 0, maxHp = 0, sp = 0, maxSp = 0, cargo = 0, maxCargo = 0, crew = 0, maxCrew = 0, adventureTime = 0, **kw):
optiondefs = (('state', DGG.DISABLED, None), ('frameSize', (0.050000000000000003, 0.64000000000000001, 0.040000000000000001, 0.39000000000000001), None))
self.defineoptions(kw, optiondefs)
BorderFrame.__init__(self, parent, **None)
self.initialiseoptions(ShipStatFrame)
self.showTask = None
self.snapShot = ShipSnapshot(self, shipOV, shipName, shipClass, mastInfo, hp, maxHp, sp, maxSp, cargo, maxCargo, crew, maxCrew, adventureTime, pos = (0, 0, 0))
def destroy(self, autoDestroy = 1):
if self.ival:
self.ival.pause()
self.ival = None
if autoDestroy:
BorderFrame.destroy(self)
def setText(self):
BorderFrame.setText(self)
lines = self.component('text0').textNode.getHeight()
textSpace = (0.034799999999999998 * lines - 0.0276) * self['text_scale'][1] / 0.035000000000000003
if textSpace > 100:
textSpace = 0.0
self['frameSize'] = (0, 0.80000000000000004, -0.028000000000000001 - 0.043999999999999997 - 0.043999999999999997 - max(0.042000000000000003, textSpace), 0)
def __init__(self, panelName, gameTitle, instructions):
BorderFrame.__init__(self, parent = base.a2dBottomCenter, frameSize = (-1, 1, 0, 0.29999999999999999), pos = (0, 0, 0.5), modelName = 'pir_m_gui_frm_subframe', imageColorScale = VBase4(0.75, 0.75, 0.90000000000000002, 0.75))
self.initialiseoptions(PVPRulesPanel)
self.secondLayer = BorderFrame(parent = self, frameSize = (-1, 1, 0, 0.29999999999999999), modelName = 'pir_m_gui_frm_subframe', imageColorScale = VBase4(0.75, 0.75, 0.90000000000000002, 0.75))
self.gameTitle = gameTitle
self.instructions = instructions
self.gameTitleText = DirectLabel(parent = self, relief = None, text = self.gameTitle, text_scale = 0.059999999999999998, text_align = TextNode.ALeft, text_font = PiratesGlobals.getPirateFont(), text_fg = (1, 1, 1, 1), text_shadow = (0, 0, 0, 1), pos = (-0.95999999999999996, 0, 0.23000000000000001))
self.instructionsText = DirectLabel(parent = self, relief = None, text = self.instructions, text_scale = 0.050000000000000003, text_align = TextNode.ALeft, text_wordwrap = 40, text_fg = (1, 1, 1, 1), text_shadow = (0, 0, 0, 1), pos = (-0.95999999999999996, 0, 0.14000000000000001))
def __init__(self, tabBar, name, **kw):
optiondefs = (('state', DGG.DISABLED, None), ('command', None, self.setCommand), ('extraArgs', [], self.setExtraArgs), ('name', name, None), ('mouseEntered', None, None), ('mouseLeft', None, None), ('selected', False, self.setSelected), ('textMayChange', 1, None))
self.defineoptions(kw, optiondefs)
BorderFrame.__init__(self, parent = NodePath(), **kw)
self.initialiseoptions(Tab)
self.setName(str(name))
self.tabBar = tabBar
self.invisibleButton = DirectButton(parent = self, relief = 1, frameColor = (1.0, 0.0, 1.0, 0), frameSize = self.getInnerFrameSize(), rolloverSound = None, command = self['command'], extraArgs = self['extraArgs'], textMayChange = 1)
self.invisibleButton.bind(DGG.ENTER, self.mouseEntered)
self.invisibleButton.bind(DGG.EXIT, self.mouseLeft)
def __init__(self, cell, manager):
self.sizeX = 0.80000000000000004
self.sizeZ = 0.59999999999999998
textScale = PiratesGuiGlobals.TextScaleTitleSmall
optiondefs = (('state', DGG.DISABLED, None), ('frameSize', (-0.0 * self.sizeX, 1.0 * self.sizeX, -0.0 * self.sizeZ, 1.0 * self.sizeZ), None), ('text', PLocalizer.InventorySplitterTitle, None), ('text_align', TextNode.ACenter, None), ('text_font', PiratesGlobals.getPirateBoldOutlineFont(), None), ('text_fg', (1, 1, 1, 1), None), ('text_shadow', PiratesGuiGlobals.TextShadow, None), ('textMayChange', 1, None), ('text_scale', textScale, None), ('text_pos', (self.sizeX * 0.5, self.sizeZ - textScale), None))
self.defineoptions({ }, optiondefs)
BorderFrame.__init__(self, parent = NodePath())
self.initialiseoptions(InventoryStackSplitter)
self.fromCell = cell
self.manager = manager
self.setup()
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 __init__(self, badText = 'Error'):
self.sizeX = 0.80000000000000004
self.sizeZ = 0.59999999999999998
textScale = PiratesGuiGlobals.TextScaleTitleSmall
optiondefs = (('state', DGG.DISABLED, None), ('frameSize', (-0.0 * self.sizeX, 1.0 * self.sizeX, -0.0 * self.sizeZ, 1.0 * self.sizeZ), None), ('text', PLocalizer.ChatWarningTitle, None), ('text_align', TextNode.ACenter, None), ('text_font', PiratesGlobals.getPirateBoldOutlineFont(), None), ('text_fg', (1, 1, 1, 1), None), ('text_shadow', PiratesGuiGlobals.TextShadow, None), ('textMayChange', 1, None), ('text_scale', textScale, None), ('text_pos', (self.sizeX * 0.5, self.sizeZ - textScale * 1.5), None))
self.defineoptions({ }, optiondefs)
BorderFrame.__init__(self, parent = NodePath())
self.initialiseoptions(ChatWarningBox)
self.setX(self.sizeX * -0.5)
self.badText = badText
self.warningText = badText
self.setup()
def __init__(self, manager, callback, **kw):
self.sizeX = 0.80000000000000004
self.sizeZ = 0.80000000000000004
textScale = PiratesGuiGlobals.TextScaleTitleSmall
optiondefs = (('state', DGG.DISABLED, None), ('frameSize', (-0.0 * self.sizeX, 1.0 * self.sizeX, -0.0 * self.sizeZ, 1.0 * self.sizeZ), None), ('modelName', 'pir_m_gui_frm_main_blue', None), ('nameTag', PLocalizer.InventorySellTitle, None))
self.defineoptions(kw, optiondefs)
BorderFrame.__init__(self)
self.initialiseoptions(InventorySellConfirm)
self.accept('UpdateSellContainer', self.update)
self.manager = manager
self.callback = callback
self.confirmDialog = None
self.totalGoldValue = 0
self.setup()
class VitaeMeter(DirectFrame):
def __init__(self, parent, **kw):
DirectFrame.__init__(self, parent)
self.initialiseoptions(VitaeMeter)
toplevel_gui = loader.loadModel('models/gui/toplevel_gui')
self.vitaeDial = DialMeter(parent = self, meterColor = Vec4(0.80000000000000004, 0.20000000000000001, 0.20000000000000001, 1), baseColor = Vec4(0, 0, 0, 1), scale = 0.28000000000000003)
icon = toplevel_gui.find('**/morale_skull*')
self.vitaeIcon = DirectFrame(parent = self, state = DGG.NORMAL, relief = None, image = icon, image_scale = 0.625)
detailLabel = DirectLabel(relief = None, state = DGG.DISABLED, text = PLocalizer.VitaeDesc, text_align = TextNode.ALeft, text_scale = PiratesGuiGlobals.TextScaleExtraLarge, text_fg = PiratesGuiGlobals.TextFG1, text_wordwrap = 15, text_shadow = (0, 0, 0, 1), pos = (0.0, 0, -0.025000000000000001), textMayChange = 0, sortOrder = 91)
height = -(detailLabel.getHeight() + 0.01)
width = max(0.25, detailLabel.getWidth() + 0.040000000000000001)
self.helpBox = BorderFrame(parent = self, state = DGG.DISABLED, modelName = 'general_frame_f', frameSize = (-0.040000000000000001, width, height, 0.050000000000000003), pos = (0.050000000000000003, 0, -0.050000000000000003), sortOrder = 90)
detailLabel.reparentTo(self.helpBox)
self.helpBox.hide()
self.helpBox.setClipPlaneOff()
self.meterLabel = DirectLabel(parent = self.vitaeDial, relief = None, pos = (0, 0, -0.45000000000000001), text = PLocalizer.Vitae, text_scale = 0.20000000000000001, text_align = TextNode.ACenter, text_fg = PiratesGuiGlobals.TextFG1, text_shadow = PiratesGuiGlobals.TextShadow, text_font = PiratesGlobals.getPirateOutlineFont(), textMayChange = 1)
self.vitaeIcon.bind(DGG.WITHIN, self.showDetails)
self.vitaeIcon.bind(DGG.WITHOUT, self.hideDetails)
def showDetails(self, event):
self.helpBox.show()
def hideDetails(self, event):
self.helpBox.hide()
def update(self, level, range, val):
self.vitaeDial.hide()
Range = range * 1.0009999999999999
if level > 0:
self.vitaeDial.update(val, Range)
self.vitaeDial.show()
def createPirateNameBox(self, pirateName):
self.pirateNameLabel = DirectLabel(relief = None, state = DGG.DISABLED, text = pirateName, text_align = TextNode.ACenter, text_scale = PiratesGuiGlobals.TextScaleMed, text_fg = PiratesGuiGlobals.TextFG1, text_wordwrap = 12, textMayChange = 0, sortOrder = 91)
self.pirateNameLabel.setBin('fixed', 33)
height = self.pirateNameLabel.getHeight()
width = self.pirateNameLabel.getWidth() + 0.050000000000000003
pos = [
0.0,
0.0,
height / 2 - 0.035000000000000003]
fs = [
-(width / 2 + 0.01),
width / 2 + 0.01,
-(height / 2 + 0.014999999999999999),
height / 2 + 0.014999999999999999]
self.pirateNameBox = BorderFrame(parent = self, state = DGG.DISABLED, frameSize = (fs[0], fs[1], fs[2], fs[3]), modelName = 'general_frame_f', pos = (0.0, 0.0, 0.0))
self.pirateNameLabel.reparentTo(self.pirateNameBox)
self.pirateNameLabel.setPos(pos[0], pos[1], pos[2])
self.pirateNameBox.setClipPlaneOff()
pos = self.pirateNameBox.getPos(aspect2d)
x = min(pos[0], base.a2dRight - width)
z = max(pos[2], base.a2dBottom - height)
self.pirateNameBox.setPos(aspect2d, x, 0, z - 0.17499999999999999)
self.pirateNameBox.flattenLight()
self.pirateNameBox.setBin('fixed', 32)
self.pirateNameBox.reparentTo(self)
def 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 __init__(self, **kw):
self.sizeX = 0.80000000000000004
self.sizeZ = 0.90000000000000002
textScale = PiratesGuiGlobals.TextScaleTitleSmall
optiondefs = (('state', DGG.DISABLED, None), ('frameSize', (-0.0 * self.sizeX, 1.0 * self.sizeX, -0.0 * self.sizeZ, 1.0 * self.sizeZ), None), ('text', PLocalizer.BodyShapeUpdate, None), ('text_align', TextNode.ACenter, None), ('text_font', PiratesGlobals.getPirateBoldOutlineFont(), None), ('text_fg', (1, 1, 1, 1), None), ('text_shadow', PiratesGuiGlobals.TextShadow, None), ('textMayChange', 1, None), ('text_scale', textScale, None), ('text_pos', (self.sizeX * 0.5, self.sizeZ * 0.94999999999999996 - textScale), None))
self.defineoptions(kw, optiondefs)
BorderFrame.__init__(self)
self.initialiseoptions(BodyShapeChanger)
self.setPos(base.a2dRight - self.sizeX, 0, 0)
self.confirmDialog = None
self.isSetup = 0
self.doingRegen = 0
self.acceptOnce('localAV-enterHalt', self.setup)
localAvatar.gameFSM.request('Halt')
if not self.isSetup:
self.destroy()
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 makeDetails(self):
if self.detailFrame:
return None
normalScale = 0.97307200000000005
parent = self.getParent()
if parent:
for i in range(0, 2):
parent = parent.getParent()
if not parent:
break
continue
if parent:
parentScale = parent.getScale()[0]
else:
parentScale = normalScale
durationStr = str(int(self.maxDuration))
if self.effectId in buffTable:
text = buffTable[self.effectId][1] + PLocalizer.BuffDuration % durationStr
else:
text = buffTable[WeaponGlobals.C_UNKNOWN_EFFECT][1] + PLocalizer.BuffDuration % durationStr
self.detailBox = DirectLabel(state = DGG.DISABLED, relief = None, text = text, text_align = TextNode.ALeft, text_scale = PiratesGuiGlobals.TextScaleExtraLarge * normalScale / parentScale, text_fg = (1, 1, 1, 1), text_wordwrap = 15, text_shadow = (0, 0, 0, 1), textMayChange = 1)
height = -(self.detailBox.getHeight() + 0.01)
width = max(0.25, self.detailBox.getWidth() + 0.040000000000000001)
self.detailFrame = BorderFrame(parent = self.myIcon, state = DGG.DISABLED, frameSize = (-0.040000000000000001, width, height, 0.070000000000000007), pos = (0.050000000000000003, 0, -0.050000000000000003))
self.detailBox.reparentTo(self.detailFrame)
self.detailFrame.setBin('gui-popup', 0)
self.detailFrame.hide()
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 __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 createHelpBox(self):
if not self.helpBox:
self.helpLabel = DirectLabel(parent = aspect2d, relief = None, text = '', text_align = TextNode.ALeft, text_scale = PiratesGuiGlobals.TextScaleSmall, text_fg = PiratesGuiGlobals.TextFG2, text_wordwrap = 12, text_shadow = (0, 0, 0, 1), textMayChange = 1, sortOrder = 91)
height = -(self.helpLabel.getHeight() + 0.01)
width = max(0.25, self.helpLabel.getWidth() + 0.040000000000000001)
self.helpBox = BorderFrame(parent = aspect2d, state = DGG.DISABLED, frameSize = (-0.040000000000000001, width, height, 0.050000000000000003), pos = (0, 0, 0), sortOrder = 90)
self.helpLabel.reparentTo(self.helpBox)
self.helpBox.hide()
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 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 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)
def __init__(self, parent = None, **kwargs):
self.loadModels()
self.cornerGeom = None
self.text = None
self.circle = None
self.icon = None
self.icon2 = None
if not StackMessage.popupSfx:
StackMessage.popupSfx = loadSfx(SoundGlobals.SFX_GUI_STACK_POPUP)
StackMessage.lootSfx = loadSfx(SoundGlobals.SFX_GUI_LOOT)
StackMessage.lootSfx.setVolume(0.75)
optiondefs = (('relief', None, None), ('frameSize', (0, 0.80000000000000004, -0.17999999999999999, 0), None), ('state', DGG.DISABLED, None), ('time', 7, None), ('priority', 0, None), ('modelName', 'general_frame_b', None), ('borderScale', 0.69999999999999996, None), ('icon', (), self.setIcon), ('buttonStyle', None, None), ('noCallback', None, None), ('yesCallback', None, None), ('cancelCallback', None, None))
self.defineoptions(kwargs, optiondefs, dynamicGroups = ())
BorderFrame.__init__(self, parent, **kwargs)
self.initialiseoptions(StackMessage)
self.ival = None
self.cornerGeom = self.corner.copyTo(self)
self.cornerGeom.setScale(0.40000000000000002)
self.cornerGeom.setPos(0.068000000000000005, 0, -0.066000000000000003)
self.cornerGeom.setColorScale(*PiratesGuiGlobals.TextFG1)
self.setTransparency(True)
def __init__(self, title, w, h, showClose = True, titleSize = 0, modelName = 'general_frame_f', **kw):
self.width = w
self.height = h
BorderFrame.__init__(self, frameSize = (0, w, 0, h), modelName = modelName, sortOrder = 20, **kw)
self.initialiseoptions(GuiPanel)
titleFont = PiratesGuiGlobals.TextScaleMed
textColor = PiratesGuiGlobals.TextFG1
textShadow = PiratesGuiGlobals.TextShadow
wordwrap = 13
if titleSize == 0:
titleFont = PiratesGuiGlobals.TextScaleMed
textColor = PiratesGuiGlobals.TextFG1
textShadow = PiratesGuiGlobals.TextShadow
wordwrap = 13
elif titleSize == 1:
titleFont = PiratesGuiGlobals.TextScaleLarge
textColor = PiratesGuiGlobals.TextFG2
textShadow = None
wordwrap = 10
elif titleSize == 1.5:
titleFont = PiratesGuiGlobals.TextScaleExtraLarge
textColor = PiratesGuiGlobals.TextFG1
textShadow = None
wordwrap = 10
if title:
self.titleLabel = DirectLabel(parent = self, relief = None, pos = (0.050000000000000003, 0, h - PiratesGuiGlobals.TextScaleSmall * 2.5), text = title, text_align = TextNode.ALeft, text_scale = titleFont, text_pos = (0.014999999999999999, 0.014999999999999999), text_fg = textColor, text_shadow = textShadow, text_font = PiratesGlobals.getPirateOutlineFont(), textMayChange = 1, text_wordwrap = wordwrap, sortOrder = 21)
else:
self.titleLabel = None
if showClose:
lookoutUI = loader.loadModel('models/gui/lookout_gui')
self.closeButton = DirectButton(parent = self, relief = None, image = (lookoutUI.find('**/lookout_close_window'), lookoutUI.find('**/lookout_close_window_down'), lookoutUI.find('**/lookout_close_window_over'), lookoutUI.find('**/lookout_close_window_disabled')), pos = (w - 0.055, 0, h - 0.055), scale = 0.125, command = self.closePanel, sortOrder = 21)
lookoutUI.removeNode()
else:
self.closeButton = None
self.fadeLerp = None
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 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)
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'])
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
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
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
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 BuffIcon(DirectFrame):
Background = None
Card = None
def __init__(self, parent, effectId, duration, attackerId, **kw):
optiondefs = (('relief', None, None),)
self.defineoptions(kw, optiondefs)
DirectFrame.__init__(self, parent)
self.initialiseoptions(BuffIcon)
if not self.Background:
self.Background = loader.loadModel('models/gui/lookout_gui').find('**/lookout_submit')
self.Background.setScale(0.33000000000000002)
if not self.Card:
self.Card = loader.loadModel('models/textureCards/buff_icons')
self.myIcon = None
self.detailFrame = None
self.dial = None
self.iconScale = 0.070000000000000007
self.effectId = effectId
self.maxDuration = duration
self.timeLeft = duration
self.lastTimestamp = None
self.attackerId = attackerId
self.setDepthWrite(0)
self.setFogOff()
self.setLightOff()
self.setBin('gui-fixed', 0)
def makeIcons(self):
self.Background.copyTo(self)
self.dial = DialMeter(parent = self, meterColor = Vec4(0.29999999999999999, 0.0, 0.80000000000000004, 1), baseColor = Vec4(0, 0, 0, 1), scale = 0.17000000000000001, sortOrder = 0)
if self.effectId in buffTable:
info = buffTable.get(self.effectId)
else:
info = buffTable.get(WeaponGlobals.C_UNKNOWN_EFFECT)
self.myIcon = DirectButton(parent = self, relief = None, geom = self.Card.find('**/' + info[0]), geom_scale = self.iconScale, sortOrder = 1)
self.myIcon.bind(DGG.ENTER, self.showDetails)
self.myIcon.bind(DGG.EXIT, self.hideDetails)
self.updateIconInfo()
def makeDetails(self):
if self.detailFrame:
return None
normalScale = 0.97307200000000005
parent = self.getParent()
if parent:
for i in range(0, 2):
parent = parent.getParent()
if not parent:
break
continue
if parent:
parentScale = parent.getScale()[0]
else:
parentScale = normalScale
durationStr = str(int(self.maxDuration))
if self.effectId in buffTable:
text = buffTable[self.effectId][1] + PLocalizer.BuffDuration % durationStr
else:
text = buffTable[WeaponGlobals.C_UNKNOWN_EFFECT][1] + PLocalizer.BuffDuration % durationStr
self.detailBox = DirectLabel(state = DGG.DISABLED, relief = None, text = text, text_align = TextNode.ALeft, text_scale = PiratesGuiGlobals.TextScaleExtraLarge * normalScale / parentScale, text_fg = (1, 1, 1, 1), text_wordwrap = 15, text_shadow = (0, 0, 0, 1), textMayChange = 1)
height = -(self.detailBox.getHeight() + 0.01)
width = max(0.25, self.detailBox.getWidth() + 0.040000000000000001)
self.detailFrame = BorderFrame(parent = self.myIcon, state = DGG.DISABLED, frameSize = (-0.040000000000000001, width, height, 0.070000000000000007), pos = (0.050000000000000003, 0, -0.050000000000000003))
self.detailBox.reparentTo(self.detailFrame)
self.detailFrame.setBin('gui-popup', 0)
self.detailFrame.hide()
def showDetails(self, event):
self.makeDetails()
self.detailFrame.show()
self.updateIconInfo()
def hideDetails(self, event):
if self.detailFrame:
self.detailFrame.hide()
def updateIconInfo(self):
if self.lastTimestamp == None:
timeOffset = 0.0
else:
timeOffset = globalClockDelta.localElapsedTime(self.lastTimestamp)
duration = max(0.0, self.timeLeft - timeOffset)
self.dial.update(duration, self.maxDuration)
if self.detailFrame and not self.detailFrame.isHidden():
if duration > 0:
durationStr = PLocalizer.BuffDuration % str(int(duration) + 1)
else:
durationStr = ''
if self.effectId in buffTable:
text = buffTable[self.effectId][1] + durationStr
else:
text = buffTable[WeaponGlobals.C_UNKNOWN_EFFECT][1] + durationStr
self.detailBox['text'] = text
def destroy(self):
DirectFrame.destroy(self)
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 AmmoSkillButton(SkillButton.SkillButton):
__module__ = __name__
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.55
self.toolTipBox = None
self.slotId = slotId
self._initButtons()
self.updateSkillId(skillId)
return
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.4,
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
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
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.05),
scale=toolTipScale,
pos=(-(width * toolTipScale * 0.5), 0,
height * toolTipScale * 2.25),
state=DGG.DISABLED)
self.label.reparentTo(self.toolTipBox)
return
def showToolTip(self, event):
self.createToolTip()
def hideToolTip(self, event):
if self.toolTipBox:
self.toolTipBox.destroy()
self.toolTipBox = None
return
def onSellClick(self):
messenger.send('onSellClick', [self.skillId])
class LookoutRequestLVL2(DirectFrame, InventoryRequestGameType):
__module__ = __name__
def __init__(self,
name,
titleTextScale=None,
itemList=None,
parentPanel=None):
self.width = PiratesGuiGlobals.LookoutRequestLVL2Width
self.height = PiratesGuiGlobals.LookoutRequestLVL2Height
DirectFrame.__init__(self,
relief=None,
state=DGG.DISABLED,
frameColor=PiratesGuiGlobals.FrameColor,
borderWidth=PiratesGuiGlobals.BorderWidth,
frameSize=(0, self.width, 0, self.height))
self.initialiseoptions(LookoutRequestLVL2)
InventoryRequestGameType.__init__(self)
self.parentPanel = parentPanel
self.name = name
if itemList:
self.itemList = itemList
else:
self.notify.warning(
'no itemList provied, displaying default parlor game types')
self.itemList = [{
'Text':
GameTypeGlobals.getGameTypeString(
PiratesGlobals.GAME_STYLE_BLACKJACK, 'style'),
'Value':
PiratesGlobals.GAME_STYLE_BLACKJACK
}, {
'Text':
GameTypeGlobals.getGameTypeString(
PiratesGlobals.GAME_STYLE_POKER, 'style'),
'Value':
PiratesGlobals.GAME_STYLE_POKER
}]
self.activityListItems = ListFrame(0.8,
None,
'blah',
self,
frameColor=(0, 0, 0, 0))
self.activityListItems.setup()
if self.parentPanel.UI_VERSION == 0:
size = (0, 0.82, 0, 0.45)
pos = (0.15, 0, 0.55)
else:
size = (0, 0.82, 0, 0.75)
pos = (0.15, 0, 0.2)
self.activityList = DirectScrolledFrame(
parent=self,
frameSize=size,
relief=DGG.GROOVE,
state=DGG.NORMAL,
frameColor=(0, 0, 0, 0),
borderWidth=PiratesGuiGlobals.BorderWidth,
canvasSize=(0, 0.7, 0, self.activityListItems['frameSize'][3]),
verticalScroll_frameColor=PiratesGuiGlobals.ScrollbarColor,
verticalScroll_borderWidth=(0.0075, 0.0075),
verticalScroll_frameSize=(0, PiratesGuiGlobals.ScrollbarSize, 0,
self.height),
verticalScroll_thumb_frameColor=PiratesGuiGlobals.ButtonColor2,
verticalScroll_incButton_frameColor=PiratesGuiGlobals.ButtonColor2,
verticalScroll_decButton_frameColor=PiratesGuiGlobals.ButtonColor2,
sortOrder=5,
pos=pos)
if self.parentPanel.UI_VERSION == 0:
self.createListFrame(self.activityList)
self.activityListItems.reparentTo(self.activityList.getCanvas())
self.selectedItem = None
self.optionsPanel = None
self.optionsButton = None
self.rankingDisplay = DirectLabel(
parent=self.getParent(),
relief=None,
text='Ranking',
text_align=TextNode.ALeft,
text_scale=0.05,
text_fg=PiratesGuiGlobals.TextFG1,
text_shadow=PiratesGuiGlobals.TextShadow,
textMayChange=1,
pos=(0.29, 0, -0.55))
self.rankingDisplay.hide()
self.setParentPanel(parentPanel)
self.storedOptions = {}
self.customOptions = {}
return
def createListFrame(self, list, lookoutUI=None):
self.activityListBorderFrame = BorderFrame(parent=list,
pos=(0.4, 0, 0.25),
scale=(0.8, 1, 0.45))
self.activityListBorderFrame.setBackgroundVisible(False)
def createOptionsButton(self, lookoutUI=None, parentInfo=None):
if lookoutUI == None:
lookoutUI = loader.loadModel('models/gui/lookout_gui')
if parentInfo == None:
parent = self.parentPanel
buttonPos = (0.43, 0, 0.15)
buttonScale = 0.3
else:
parent = parentInfo.get('parent')
buttonPos = parentInfo.get('pos', (0.43, 0, 0.15))
buttonScale = parentInfo.get('scale', 0.3)
optionsButton, optionsButtonText = self.parentPanel.createButtonAndText(
imageInfo={
'parent': parent,
'textureCard': lookoutUI,
'imageName': 'lookout_option',
'buttonPos': buttonPos,
'buttonScale': buttonScale,
'clickCommand': lambda param=parent: self.optionsClick(param)
},
textInfo=PLocalizer.Options)
if parentInfo == None:
buttonParent = self
else:
buttonParent = parent
buttonParent.optionsButton = optionsButton
buttonParent.optionsButtonText = optionsButtonText
if self.parentPanel.submitButton:
self.parentPanel.submitButton['state'] = DGG.DISABLED
return
def setParentPanel(self, parentPanel):
self.parentPanel = parentPanel
def hide(self):
self.activityList.hide()
if self.optionsButton:
self.optionsButton.hide()
if self.rankingDisplay:
self.rankingDisplay.hide()
def show(self):
self.activityList.show()
def gotOptions(itemList):
if (itemList and len(itemList) > 0 and self).optionsButton:
self.optionsButton.hide()
itemList = self.determineLvl3ItemList(self.selectedItem, gotOptions)
def destroy(self):
self.selectedItem = None
self.parentPanel = None
if self.activityList:
self.activityList.destroy()
self.activityList = None
if self.activityListItems:
self.activityListItems.destroy()
self.activityListItems = None
if self.optionsButton:
self.optionsButton.destroy()
self.optionsButton = None
if self.optionsPanel:
self.optionsPanel.destroy()
self.optionsPanel = None
if self.rankingDisplay:
self.rankingDisplay.destroy()
DirectFrame.destroy(self)
self.cancelAllInventoryRequests()
return
def getItemChangeMsg(self):
return self.taskName('gameTypeChanged')
def getItemList(self):
return self.itemList
def createNewItem(self,
item,
parent,
itemType=None,
columnWidths=[],
color=None):
if self.parentPanel.UI_VERSION == 0:
newItem = ButtonListItem(item,
0.08,
0.75,
parent,
parentList=self,
txtColor=color,
pressEffect=False,
frameColor=(0, 0, 0, 0))
else:
newItem = LookoutListItem(item,
self.parentPanel.TOPLEVEL_GUI_FILE,
0.16,
0.75,
parent,
parentList=self,
txtColor=color,
pressEffect=False,
frameColor=(0, 0, 0, 0),
wantFrame=True)
if self.parentPanel.invited == None:
def gotOptions(itemList):
if itemList and len(itemList) > 0:
parentInfo = {
'parent': newItem,
'pos': (0.675, 0, 0.105),
'scale': 0.18
}
self.createOptionsButton(parentInfo=parentInfo)
self.determineLvl3ItemList(newItem, gotOptions)
newItem.setup()
if item['Value'] == PiratesGlobals.CREW_STYLE_FIND_A_CREW:
if localAvatar.guiMgr.crewHUD.crew or localAvatar.guiMgr.crewHUD.startACrewState or localAvatar.guiMgr.crewHUD.joinACrewStatusPVP:
newItem['state'] = DGG.DISABLED
newItem.title['text_fg'] = PiratesGuiGlobals.TextFG9
newItem.desc['text_fg'] = PiratesGuiGlobals.TextFG9
if item['Value'] == PiratesGlobals.CREW_STYLE_RECRUIT_MEMBERS:
if not localAvatar.guiMgr.crewHUD.crew or DistributedBandMember.DistributedBandMember.IsLocalAvatarHeadOfBand(
) == 0:
newItem['state'] = DGG.DISABLED
newItem.title['text_fg'] = PiratesGuiGlobals.TextFG9
newItem.desc['text_fg'] = PiratesGuiGlobals.TextFG9
if localAvatar.guiMgr.crewHUD.startACrewState:
newItem['state'] = DGG.NORMAL
newItem.title['text_fg'] = PiratesGuiGlobals.TextFG1
newItem.desc['text_fg'] = PiratesGuiGlobals.TextFG1
if item['Value'] == PiratesGlobals.CREW_STYLE_FIND_A_PVP_CREW:
if localAvatar.guiMgr.crewHUD.crew or localAvatar.guiMgr.crewHUD.startACrewState or localAvatar.guiMgr.crewHUD.joinACrewStatus:
newItem['state'] = DGG.DISABLED
newItem.title['text_fg'] = PiratesGuiGlobals.TextFG9
newItem.desc['text_fg'] = PiratesGuiGlobals.TextFG9
if item['Value'] == PiratesGlobals.GAME_STYLE_TM_BLACK_PEARL:
newItem.title['text_scale'] = PiratesGuiGlobals.TextScaleTitleSmall
return newItem
def determineLvl3ItemList(self, item, callback=None):
availItems = []
if item == None:
return availItems
gameType = self.parentPanel.getSelectedValue()
def optionsReceived(options):
if options:
optionKeys = options.keys()
for currOption in optionKeys:
if options[currOption][
0] == PiratesGuiGlobals.UIItemType_Hidden or options.get(
'execute'):
continue
availItems.append({
'Text':
GameTypeGlobals.getGameTypeString(
currOption, 'option'),
'Option':
currOption,
'Values':
options[currOption][1],
'Value':
options[currOption][1][0],
'ValueType':
options[currOption][0]
})
if callback:
callback(availItems)
self.getGameOptions(gameType, item.value, optionsReceived)
return availItems
def itemSelect(self, item):
if item.value == PiratesGlobals.CREW_STYLE_FIND_A_CREW or item.value == PiratesGlobals.CREW_STYLE_RECRUIT_MEMBERS or item.value == PiratesGlobals.CREW_STYLE_FIND_A_PVP_CREW:
self.toggleAICrewLookout(item.value)
return
for currItem in self.activityListItems.items:
currItem.setSelected(False)
item.setSelected(True)
self.selectedItem = item
categoryName = GameTypeGlobals.getGameTypeString(
self.selectedItem.value, 'style')
invCat = GameTypeGlobals.getGameTypeRanking(self.selectedItem.value)
inv = base.localAvatar.getInventory()
if inv:
playerRank = inv.getStackQuantity(invCat)
self.rankingDisplay['text'] = '%s : %d' % (categoryName,
playerRank)
self.rankingDisplay.show()
if self.parentPanel.submitButton == None:
self.parentPanel.submitRequest()
return
def optionsClick(self, selectedItem):
if self.optionsPanel:
self.optionsPanel.destroy()
self.optionsPanel = None
def gotOptions(itemList):
if itemList and len(itemList) > 0:
self.optionsPanel = LookoutRequestLVL3(
PLocalizer.LookoutOptionsTitle,
titleTextScale=0.05,
itemList=itemList,
optionsFor=selectedItem.value)
self.optionsPanel.reparentTo(self.parentPanel)
self.optionsPanel.setPos(0, 0, 0)
self.optionsPanel.setParentPanel(self)
gameTypeStr = GameTypeGlobals.getGameTypeString(
selectedItem.value, 'style')
self.optionsPanel.show(gameTypeStr, selectedItem)
if self.optionsButton:
self.optionsButton.hide()
self.parentPanel.updateMode(PiratesGuiGlobals.REQUEST_OPT_MODE)
self.determineLvl3ItemList(selectedItem, gotOptions)
return
def optionsClose(self):
self.parentPanel.updateMode(PiratesGuiGlobals.REQUEST_TYPE_MODE)
if self.parentPanel.deleteWhenClosed:
self.optionsPanel.destroy()
self.optionsPanel.removeNode()
self.optionsPanel = None
else:
self.optionsPanel.hide()
self.rankingDisplay.hide()
if self.optionsButton:
self.optionsButton.show()
return
def itemSelectByValue(self, itemValue=None):
itemToSelect = None
if itemValue == None:
if len(self.activityListItems.items) > 0:
itemToSelect = self.activityListItems.items[0]
for currItem in self.activityListItems.items:
print 'checking item with value %s' % currItem.value
if currItem.value == itemValue:
itemToSelect = currItem
break
if itemToSelect:
self.itemSelect(itemToSelect)
return
def addCustomOptions(self, gameType, optionPairs):
currOptions = self.customOptions.get(gameType)
if currOptions == None:
self.customOptions[gameType] = optionPairs
return
for currOptionPair in optionPairs:
for currOption in currOptions:
if currOption[0] == currOptionPair[0]:
currOption[1] = currOptionPair[1]
continue
currOptions.append(currOptionPair)
return
def getCustomOptions(self, gameType, clear=False):
options = self.customOptions.get(gameType, [])
if clear and len(options) > 0:
del self.customOptions[gameType]
return options
def getAllGameOptions(self, gameType, clear=False):
if self.optionsPanel:
options = self.optionsPanel.getGameOptions(gameType, clear)
else:
options = []
customOptions = self.getCustomOptions(gameType, clear)
return options + customOptions
def toggleAICrewLookout(self, itemType):
if itemType == PiratesGlobals.CREW_STYLE_FIND_A_CREW:
localAvatar.guiMgr.crewHUD.toggleAvatarLookout()
if itemType == PiratesGlobals.CREW_STYLE_RECRUIT_MEMBERS:
localAvatar.guiMgr.crewHUD.toggleCrewLookout()
if itemType == PiratesGlobals.CREW_STYLE_FIND_A_PVP_CREW:
localAvatar.guiMgr.crewHUD.toggleAvatarLookoutPVP()
localAvatar.guiMgr.lookoutPage.close()
def destroy(self):
self.parent = None
self.fromCell = None
self.doubleFrame.destroy()
self.tripleFrame.destroy()
BorderFrame.destroy(self)
def createListFrame(self, list, lookoutUI=None):
self.activityListBorderFrame = BorderFrame(parent=list,
pos=(0.4, 0, 0.25),
scale=(0.8, 1, 0.45))
self.activityListBorderFrame.setBackgroundVisible(False)