def __init__(self, panelName, gameTitle, instructions):
BorderFrame.__init__(self,
parent=base.a2dBottomCenter,
frameSize=(-1, 1, 0, 0.3),
pos=(0, 0, 0.5),
modelName='pir_m_gui_frm_subframe',
imageColorScale=VBase4(0.75, 0.75, 0.9, 0.75))
self.initialiseoptions(PVPRulesPanel)
self.secondLayer = BorderFrame(parent=self,
frameSize=(-1, 1, 0, 0.3),
modelName='pir_m_gui_frm_subframe',
imageColorScale=VBase4(
0.75, 0.75, 0.9, 0.75))
self.gameTitle = gameTitle
self.instructions = instructions
self.gameTitleText = DirectLabel(
parent=self,
relief=None,
text=self.gameTitle,
text_scale=0.06,
text_align=TextNode.ALeft,
text_font=PiratesGlobals.getPirateFont(),
text_fg=(1, 1, 1, 1),
text_shadow=(0, 0, 0, 1),
pos=(-0.96, 0, 0.23))
self.instructionsText = DirectLabel(parent=self,
relief=None,
text=self.instructions,
text_scale=0.05,
text_align=TextNode.ALeft,
text_wordwrap=40,
text_fg=(1, 1, 1, 1),
text_shadow=(0, 0, 0, 1),
pos=(-0.96, 0, 0.14))
return
def createTextBox(self):
if self.infoBox:
return None
globalPos = self.getPos(base.a2dLeftCenter)
self.infoBox = None
self.infoBox = BorderFrame(parent=base.a2dLeftCenter,
frameSize=(-0.040000000000000001, 0.5,
-0.25, 0.050000000000000003),
pos=(globalPos.getX() + 0.12, 0,
globalPos.getZ()),
state=DGG.DISABLED)
self.label = DirectLabel(
parent=self.infoBox,
relief=None,
text=PLocalizer.CannonDefenseAmmoDesc %
(PLocalizer.makeHeadingString(
PLocalizer.InventoryTypeNames[self.skillId], 2), self.cost,
self.amount, PLocalizer.CannonDefenseAmmoTypeDesc[self.skillId]),
text_align=TextNode.ALeft,
text_scale=PiratesGuiGlobals.TextScaleLarge,
text_fg=PiratesGuiGlobals.TextFG2,
text_wordwrap=12,
textMayChange=1)
if self.locked:
memberText = ''
if self.skillId > CannonDefenseGlobals.FREEBOOTER_LAST_AMMO_AVAILABLE:
memberText = PLocalizer.VR_AuthAccess
self.label['text'] = PLocalizer.CannonDefenseAmmoUnlockedAt % (
CannonDefenseGlobals.getLevelUnlockedAt(
self.skillId), memberText)
self.infoBox.setBin('gui-cannonDefense', 4)
def createListFrame(self):
self.clearListFrame()
self.activityListBorderFrame = BorderFrame(parent=self, pos=(0.375, 0, 0.082), scale=(0.75,
1,
0.165), borderScale=0.2)
self.activityListBorderFrame.setBackgroundVisible(False)
self.activityListBorderFrame.setColorScale(0.4, 0.4, 0.4, 1)
def createGui(self):
self.destroyGui()
box = loader.loadModel('models/gui/gui_title_box').find('**/gui_title_box_top')
box.setPos(0.54000000000000004, 0, 1.3600000000000001)
box.setScale(0.25)
box.reparentTo(self)
box.flattenStrong()
if not self.charGui:
self.charGui = loader.loadModel('models/gui/char_gui')
self.title = DirectLabel(parent = self, relief = None, text = self.titleText, text_fg = PiratesGuiGlobals.TextFG1, text_font = PiratesGlobals.getPirateFont(), text_scale = PiratesGuiGlobals.TextScaleTitleSmall, text_shadow = PiratesGuiGlobals.TextShadow, pos = (self.width * 0.5, 0, 1.343))
self.tabBackParent = self.attachNewNode('tabBackParent')
self.tabBackParent.setZ(1.1100000000000001)
self.scrollFrame = DirectScrolledFrame(parent = self, relief = None, state = DGG.NORMAL, manageScrollBars = 0, autoHideScrollBars = 1, frameSize = (0.050000000000000003, self.width - 0.10000000000000001, 0.14000000000000001, self.height - 0.25), canvasSize = (0.050000000000000003, self.width - 0.10000000000000001, 0.14000000000000001, self.height - 0.25), verticalScroll_relief = None, verticalScroll_image = self.charGui.find('**/chargui_slider_small'), verticalScroll_frameSize = (0.0, PiratesGuiGlobals.ScrollbarSize, 0.14199999999999999, self.height - 0.26000000000000001), verticalScroll_image_scale = (self.height - 0.29999999999999999, 1, 0.75), verticalScroll_image_hpr = (0, 0, 90), verticalScroll_image_pos = (self.width - PiratesGuiGlobals.ScrollbarSize * 0.5 - 0.059999999999999998, 0, self.height * 0.46000000000000002), verticalScroll_image_color = (0.60999999999999999, 0.59999999999999998, 0.59999999999999998, 1), verticalScroll_thumb_image = (self.charGui.find('**/chargui_slider_node'), self.charGui.find('**/chargui_slider_node_down'), self.charGui.find('**/chargui_slider_node_over')), verticalScroll_thumb_relief = None, verticalScroll_thumb_image_scale = 0.40000000000000002, verticalScroll_thumb_image_pos = (-0.0050000000000000001, 0, 0), verticalScroll_resizeThumb = 0, horizontalScroll_relief = None)
self.scrollFrame.verticalScroll.incButton.destroy()
self.scrollFrame.verticalScroll.decButton.destroy()
self.scrollFrame.horizontalScroll.incButton.destroy()
self.scrollFrame.horizontalScroll.decButton.destroy()
self.scrollFrame.horizontalScroll.hide()
self.accept('press-wheel_up-%s' % self.scrollFrame.guiId, self.mouseWheelUp)
self.accept('press-wheel_down-%s' % self.scrollFrame.guiId, self.mouseWheelDown)
self.tabFrontParent = self.attachNewNode('tabFrontParent')
self.tabFrontParent.setZ(1.1100000000000001)
frameSize = (self.scrollFrame['frameSize'][0] + 0.01, self.scrollFrame['frameSize'][1] + 0.040000000000000001, self.scrollFrame['frameSize'][2] - 0.01, self.scrollFrame['frameSize'][3])
self.repackScrollFrame()
self.border = BorderFrame(parent = self.scrollFrame, state = DGG.DISABLED, modelName = 'general_frame_f', frameSize = frameSize, borderScale = 0.14999999999999999, showBackground = True, bgColorScale = VBase4(0, 0, 0, 1), sortOrder = -1)
gui = loader.loadModel('models/gui/toplevel_gui')
geomX = gui.find('**/generic_x')
self.closeButton = GuiButton.GuiButton(parent = self, pos = (self.width / 2.0, 0, 0.070000000000000007), text = PLocalizer.TableLeave, text_scale = PiratesGuiGlobals.TextScaleLarge, text_pos = (0.035000000000000003, -0.014), textMayChange = 0, geom = (geomX,) * 4, geom_pos = (-0.059999999999999998, 0, 0), geom_scale = 0.5, geom0_color = PiratesGuiGlobals.ButtonColor3[0], geom1_color = PiratesGuiGlobals.ButtonColor3[1], geom2_color = PiratesGuiGlobals.ButtonColor3[2], geom3_color = PiratesGuiGlobals.ButtonColor3[3], image3_color = (0.80000000000000004, 0.80000000000000004, 0.80000000000000004, 1), command = self.closePanel)
self.shipBar = ShipTabBar(self.tabBackParent, self.tabFrontParent, parent = self)
for t in self.pages:
self.addTab(t)
self.refreshTabStates()
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 createFrame(self):
self.removeFrame()
self.borderFrame = BorderFrame(parent=self,
pos=(0.5, 0, 0.14999999999999999),
scale=(0.56999999999999995, 1,
0.33000000000000002))
self.borderFrame.setBackgroundVisible(False)
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 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, headerTxt, bodyTxt, wordWrap, width, height):
NodePath.__init__(self, 'Panel')
self.setTransparency(TransparencyAttrib.MAlpha)
self.background = BorderFrame(parent = self, frameSize = (-0.02, width, 0, height), pos = (0, 0, -height + 0.059999999999999998), state = DGG.DISABLED, frameColor = (0, 0, 0, 0), bgTransparency = 1)
self._CannonDefenseHelpPanel__createHeaderText(self, headerTxt)
self._CannonDefenseHelpPanel__createArrow()
if bodyTxt:
self._CannonDefenseHelpPanel__createBodyText(self, bodyTxt, wordWrap)
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 __init__(self, parent, **kw):
DirectFrame.__init__(self, parent, **None)
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 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 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.04)
self.helpBox = BorderFrame(parent=aspect2d, state=DGG.DISABLED, frameSize=(-0.04, width, height, 0.05), pos=(0,
0,
0), sortOrder=90)
self.helpLabel.reparentTo(self.helpBox)
self.helpBox.hide()
return
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 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 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 createHelpbox(self, args=None):
if self.helpBox:
return
baseRank = max(self.skillRank, 1)
lvlDamageMod = WeaponGlobals.getLevelDamageModifier(
localAvatar.getLevel())
buff = WeaponGlobals.getSkillEffectFlag(self.skillId)
dur = WeaponGlobals.getAttackDuration(self.skillId)
effect = dur + dur * (baseRank - 1) / 4
dodge = WeaponGlobals.getAttackDodge(self.skillId) * baseRank
accuracy = 0
damageMod = 0
reduceDamMod = 0
rechargeMod = 0
shipTurningMod = 0
shipSpeedMod = 0
rangeMod = 0
treasureSenseMod = 0
manaCost = WeaponGlobals.getMojoCost(self.skillId)
damage = 0
loDamage = 0
mpDamage = 0
chargeMod = 0
if self.skillId == InventoryType.SailBroadsideLeft or self.skillId == InventoryType.SailBroadsideRight:
damageMod = WeaponGlobals.getAttackTargetHP(
self.skillId) * (baseRank - 1) * 100
else:
if self.skillId == InventoryType.CannonShoot:
rechargeMod = WeaponGlobals.CANNON_SHOOT_RATE_REDUCTION * (
baseRank - 1) * 100
else:
if WeaponGlobals.getSkillTrack(
self.skillId) == WeaponGlobals.TONIC_SKILL_INDEX:
damage = WeaponGlobals.getAttackSelfHP(self.skillId)
else:
if WeaponGlobals.getSkillTrack(
self.skillId) != WeaponGlobals.PASSIVE_SKILL_INDEX:
damage = int(
WeaponGlobals.getAttackTargetHP(self.skillId) *
(1.0 + WeaponGlobals.LEVELUP_DAMAGE_MULTIPLIER *
(baseRank - 1))) * lvlDamageMod
loDamage = damage / 2
mpDamage = int(
WeaponGlobals.getAttackTargetMojo(self.skillId) *
(1.0 + WeaponGlobals.LEVELUP_DAMAGE_MULTIPLIER *
(baseRank - 1))) * lvlDamageMod
mpLoDamage = mpDamage / 2
else:
accuracy = WeaponGlobals.getAttackAccuracy(
self.skillId) * baseRank
damageMod = WeaponGlobals.getAttackTargetHP(
self.skillId) * baseRank * 100
reduceDamMod = WeaponGlobals.getAttackSelfHP(
self.skillId) * baseRank
if reduceDamMod < 1:
reduceDamMod *= 100
if effect < 1:
effect *= 100
rechargeMod = WeaponGlobals.getAttackRechargeTime(
self.skillId) * baseRank * 100
shipTurningMod = WeaponGlobals.getShipTurnRate(
self.skillId) * baseRank * 100
shipSpeedMod = WeaponGlobals.getShipMaxSpeed(
self.skillId) * baseRank * 100
treasureSenseMod = WeaponGlobals.TREASURE_SENSE_BONUS / 2 * baseRank
rangeMod = WeaponGlobals.getAttackRange(
self.skillId) * baseRank
manaCost *= baseRank
chargeMod = WeaponGlobals.getAttackMaxCharge(
self.skillId) * baseRank * 100
if self.skillId == InventoryType.StaffSpiritLore:
import pdb
pdb.set_trace()
skillInfo = PLocalizer.SkillDescriptions.get(self.skillId)
skillTitle = PLocalizer.InventoryTypeNames.get(
self.skillId)
skillType = '\x01slant\x01' + skillInfo[0] + '\x02\n\n'
description = skillInfo[1]
if damage < 0:
description += ' ' + PLocalizer.DealsDamage
elif damage > 0:
if loDamage:
description += ' ' + PLocalizer.HealsDamageRange
else:
description += ' ' + PLocalizer.HealsDamage
if mpDamage < 0:
description += ' ' + PLocalizer.DealsMpDamage
effectId = WeaponGlobals.getSkillEffectFlag(self.skillId)
if effectId:
description += ' ' + SkillEffectDescriptions.get(
effectId)[0]
if self.skillId == InventoryType.SailBroadsideLeft or self.skillId == InventoryType.SailBroadsideRight:
if damageMod > 0:
description += ' ' + PLocalizer.BroadsideDesc
if self.skillId == InventoryType.CannonShoot and rechargeMod:
description += ' ' + PLocalizer.CannonShootDesc
if self.skillId == InventoryType.DollAttune:
description += ' ' + PLocalizer.MultiAttuneDesc
if WeaponGlobals.getSkillInterrupt(self.skillId):
description += ' ' + PLocalizer.InterruptDesc
if WeaponGlobals.getSkillUnattune(self.skillId):
description += ' ' + PLocalizer.UnattuneDesc
upgradeInfo = ''
if self.showUpgrade and self.skillRank < 5:
if self.skillRank > 0:
upgradeInfo = skillInfo[2]
if upgradeInfo == '':
if damage < 0:
upgradeInfo += PLocalizer.UpgradesDamage
elif damage > 0:
upgradeInfo += PLocalizer.UpgradesHealing
if mpDamage < 0:
upgradeInfo += ' ' + PLocalizer.UpgradesMpDamage
if effectId:
entry = SkillEffectDescriptions.get(
effectId)
if len(entry) > 1:
val = damage or upgradeInfo
val += PLocalizer.UpgradesDuration
else:
upgradeInfo += ' ' + PLocalizer.And
upgradeInfo += ' ' + entry[1]
upgradeInfo += '!'
elif len(upgradeInfo) >= 4:
upgradeInfo = skillInfo[3]
else:
upgradeInfo = PLocalizer.ClickToLearn
if self.skillId in SkillComboReq and SkillComboReq[
self.skillId] and self.skillRank <= 1:
description += ' ' + SkillComboReq[self.skillId]
skillDesc = '\x01gold\x01\x01smallCaps\x01' + skillTitle + '\x02\x02\n' + skillType + description + '\n\x01green\x01' + upgradeInfo + '\x02'
stats = []
if manaCost:
stats.append(abs(manaCost))
if damage and loDamage:
stats.append(abs(loDamage))
stats.append(abs(damage))
elif damage:
stats.append(abs(damage))
if mpDamage:
stats.append(abs(mpLoDamage))
stats.append(abs(mpDamage))
if buff == WeaponGlobals.C_CURSE:
stats.append(WeaponGlobals.CURSED_DAM_AMP * 100)
if buff == WeaponGlobals.C_ATTUNE and baseRank > 1:
stats.append(baseRank)
if buff == WeaponGlobals.C_WEAKEN:
stats.append(WeaponGlobals.WEAKEN_PENALTY * 100)
if effect > 0:
stats.append(effect)
if dodge:
stats.append(abs(dodge))
if accuracy:
stats.append(abs(accuracy))
if damageMod:
stats.append(abs(damageMod))
if reduceDamMod:
stats.append(abs(reduceDamMod))
if rechargeMod:
stats.append(abs(rechargeMod))
if shipTurningMod:
stats.append(abs(shipTurningMod))
if shipSpeedMod:
stats.append(abs(shipSpeedMod))
if chargeMod:
stats.append(abs(chargeMod))
if rangeMod:
stats.append(abs(rangeMod))
if self.skillId == InventoryType.SailTreasureSense:
stats.append(abs(treasureSenseMod))
stats = tuple(stats)
if self.skillRank:
self.rankText = DirectFrame(
parent=self,
relief=None,
text=('\x01gold\x01\x01smallCaps\x01' +
PLocalizer.Rank + ' %d' + '\x02\x02') %
self.skillRank,
text_align=TextNode.ARight,
text_scale=PiratesGuiGlobals.TextScaleSmall,
text_fg=PiratesGuiGlobals.TextFG2,
text_wordwrap=15,
text_shadow=(0, 0, 0, 1),
pos=(0.45, 0, 0),
textMayChange=1,
sortOrder=92,
state=DGG.DISABLED)
self.helpText = DirectFrame(
parent=self,
relief=None,
text=skillDesc % stats,
text_align=TextNode.ALeft,
text_scale=PiratesGuiGlobals.TextScaleSmall,
text_fg=PiratesGuiGlobals.TextFG2,
text_wordwrap=15,
text_shadow=(0, 0, 0, 1),
textMayChange=1,
sortOrder=91,
state=DGG.DISABLED)
height = -(self.helpText.getHeight() + 0.01)
self.helpBox = BorderFrame(parent=self,
frameSize=(-0.04, 0.5, height, 0.05),
pos=(0, 0, -0.12),
sortOrder=90,
state=DGG.DISABLED)
self.helpBox.setBin('gui-popup', 0)
self.helpText.reparentTo(self.helpBox)
if self.skillRank:
self.rankText.reparentTo(self.helpBox)
return
def __init__(self, table):
DirectFrame.__init__(self, relief=None)
self.initialiseoptions(BlackjackTableGUI)
self.table = table
self.destroyed = False
self.maxHandCards = 14
self.playerStatusPanels = []
for i in range(self.table.NumSeats + 1):
statusPanel = BlackjackStatusPanel(self.maxHandCards)
statusPanel.setName('playerHand-%s' % i)
pos = self.HandPos[i]
statusPanel.setPos(pos)
self.playerStatusPanels.append(statusPanel)
self.localStatusPanel = self.playerStatusPanels[
self.LocalAvatarGuiIndex]
width = 1.0
height = 0.25
self.menu = BorderFrame(parent=base.a2dBottomCenter,
frameSize=(-width / 2.0, width / 2.0, 0,
height),
pos=(0, 0, 0))
self.width = width
self.height = height
self.initializeTableInterface()
x = -0.36
y = 0.1775
x_increment = 0.24
helpText = PLocalizer.TableCardsHelp
helpPos = (0.0, 0.0, 0.24)
text = PLocalizer.BlackjackCardSwap
button = GuiButton(parent=self.menu,
command=self.playerAction,
helpText=helpText,
helpPos=helpPos,
pos=(x, 0, y),
canReposition=True)
self.setButtonSettings2Lines(button, (x, 0, y), text,
[PlayingCardGlobals.CardSwap])
button.show()
self.cardSwapButton = button
self.buttonArray = self.buttonArray + [button]
x += x_increment
text = PLocalizer.BlackjackDoubleDown
button = GuiButton(parent=self.menu,
command=self.playerAction,
canReposition=True)
self.setButtonSettings2Lines(button, (x, 0, y), text,
[PlayingCardGlobals.DoubleDown])
button.show()
self.doubleDownButton = button
self.buttonArray = self.buttonArray + [button]
x += x_increment
text = PLocalizer.BlackjackStay
button = GuiButton(parent=self.menu,
command=self.playerAction,
canReposition=True)
self.setButtonSettings(button, (x, 0, y), text,
[PlayingCardGlobals.Stay])
button.show()
self.stayButton = button
self.buttonArray = self.buttonArray + [button]
x += x_increment
text = PLocalizer.BlackjackHit
button = GuiButton(parent=self.menu,
command=self.playerAction,
canReposition=True)
self.setButtonSettings(button, (x, 0, y), text,
[PlayingCardGlobals.Hit])
button.show()
self.hitButton = button
self.buttonArray = self.buttonArray + [button]
x += x_increment
x = -0.36
y = 0.07
x_increment = 0.24
x += x_increment
x += x_increment
text = PLocalizer.BlackjackSplit
button = GuiButton(parent=self.menu,
command=self.playerAction,
canReposition=True)
self.setButtonSettings(button, (x, 0, y), text,
[PlayingCardGlobals.Split])
button.show()
self.splitButton = button
self.buttonArray = self.buttonArray + [button]
x += x_increment
bid = self.table.getTableBidAmount()
text = PLocalizer.BlackjackBid + ' ' + bid.__repr__()
button = GuiButton(parent=self.menu,
command=self.playerAction,
canReposition=True)
self.setButtonSettings(button, (x, 0, y), text,
[PlayingCardGlobals.Bid])
button.show()
self.bidButton = button
self.buttonArray = self.buttonArray + [button]
x += x_increment
def bid_update_function(value):
bid = self.sliderValueToBid(value)
text = PLocalizer.BlackjackBid + ' ' + bid.__repr__()
self.bidButton['text'] = text
self.bidAmount = bid
self.bidAmount = 2
default_value = 0.0
x = 0.0
y = -0.25
label = PLocalizer.BlackjackBid
resolution = 1.0
self.bidSlider = self.create_slider(bid_update_function, default_value,
x, y, resolution, label, self.menu)
x = -0.36
y = 0.1775
x_increment = 0.24
text = PLocalizer.PokerCheat1
button = GuiButton(parent=self.menu,
command=self.cardSwapButtonSelection,
canReposition=True)
self.setButtonSettings2Lines(button, (x, 0, y), text,
[PlayingCardGlobals.Cheat1])
self.cheat1Button = button
self.buttonArray = self.buttonArray + [button]
x = x + x_increment
text = PLocalizer.PokerCheat2
button = GuiButton(parent=self.menu,
command=self.cardSwapButtonSelection,
canReposition=True)
self.setButtonSettings2Lines(button, (x, 0, y), text,
[PlayingCardGlobals.Cheat2])
self.cheat2Button = button
self.buttonArray = self.buttonArray + [button]
x = x + x_increment
self.hideCheatButtons()
self.disableAllPlayButtons()
gui = loader.loadModel('models/gui/toplevel_gui')
goldCoin = gui.find('**/treasure_w_coin*')
scale = 0.32
currentMoney = localAvatar.getInventory().getGoldInPocket()
self.moneyDisplay = DirectLabel(
parent=self.menu,
relief=None,
pos=(-0.3 + x_increment / 2.0, 0, 0.075),
geom=goldCoin,
geom_scale=(scale, scale, scale),
geom_pos=(0, 0, 0),
text='%s' % currentMoney,
text_align=TextNode.ALeft,
text_scale=0.035,
text_pos=(0.045, -0.01),
text_fg=PiratesGuiGlobals.TextFG1,
text_shadow=PiratesGuiGlobals.TextShadow,
textMayChange=1,
scale=1.1)
self.accept(
InventoryGlobals.getCategoryQuantChangeMsg(
localAvatar.getInventoryId(), InventoryType.ItemTypeMoney),
self.setMoney)
this = self
identifier = 0
this.sfxArray = []
this.hitIdentifier = identifier
this.sfxArray = this.sfxArray + [
loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_HIT)
]
identifier = identifier + 1
self.hands = []
self.splitCardsArray = []
self.canSplit = False
self.canDoubleDown = False
self.bid = False
return
def createListFrame(self, list, lookoutUI = None):
self.activityListBorderFrame = BorderFrame(parent = list, pos = (0.40000000000000002, 0, 0.25), scale = (0.80000000000000004, 1, 0.45000000000000001))
self.activityListBorderFrame.setBackgroundVisible(False)
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 __init__(self, table, maxCommunityCards, maxHandCards):
DirectFrame.__init__(self, parent=base.a2dBackground, relief=None)
self.initialiseoptions(PokerTableGUI)
self.maxCommunityCards = maxCommunityCards
self.maxHandCards = maxHandCards
self.maxBet = 0
self.numberOfTimeouts = 0
self.table = table
self.destroyed = False
self.playerActions = []
width = 1.0
self.menu = BorderFrame(parent=base.a2dBottomCenter,
frameSize=(-width / 2.0, width / 2.0, 0, 0.25),
pos=(0, 0, 0))
self.disableReason = DirectLabel(
parent=self.menu,
text='',
text_align=TextNode.ACenter,
text_scale=0.04,
pos=(0, 0, 0.175),
text_fg=PiratesGuiGlobals.TextFG2,
text_shadow=PiratesGuiGlobals.TextShadow,
textMayChange=1)
self.disableReason.hide()
self.initializeTableInterface()
x = -0.36
y = 0.1775
x_increment = 0.24
helpText = PLocalizer.TableCardsHelp
helpPos = (0.0, 0.0, 0.24)
text = PLocalizer.PokerCheat1
button = GuiButton(parent=self.menu,
command=self.cardIndexSelection,
helpText=helpText,
helpPos=helpPos,
pos=(x, 0, y),
canReposition=True)
self.setButtonSettings2Lines(button, (x, 0, y), text,
[PlayingCardGlobals.Cheat1])
self.cheat1Button = button
self.buttonArray = self.buttonArray + [button]
x = x + x_increment
text = PLocalizer.PokerCheat2
button = GuiButton(parent=self.menu,
command=self.cardIndexSelection,
helpText=helpText,
helpPos=helpPos,
pos=(x, 0, y),
canReposition=True)
self.setButtonSettings2Lines(button, (x, 0, y), text,
[PlayingCardGlobals.Cheat2])
self.cheat2Button = button
self.buttonArray = self.buttonArray + [button]
x = x + x_increment
text = PLocalizer.PokerCheck
button = GuiButton(parent=self.menu,
command=self.playerAction,
canReposition=True)
self.setButtonSettings(button, (x, 0, y), text,
[PlayingCardGlobals.CheckCall])
self.passButton = button
self.buttonArray = self.buttonArray + [button]
x = x + x_increment
text = PLocalizer.PokerBet
button = GuiButton(parent=self.menu,
command=self.playerAction,
canReposition=True)
self.setButtonSettings(button, (x, 0, y), text,
[PlayingCardGlobals.BetRaise])
self.betButton = button
self.buttonArray = self.buttonArray + [button]
x = x + x_increment
x = -0.36
y = 0.07
x_increment = 0.24
x = x + x_increment
x = x + x_increment
x = x + x_increment
text = PLocalizer.PokerFold
button = GuiButton(parent=self.menu,
command=self.playerAction,
canReposition=True)
self.setButtonSettings(button, (x, 0, y), text,
[PlayingCardGlobals.Fold])
self.foldButton = button
self.buttonArray = self.buttonArray + [button]
x = x + x_increment
self.potSizeLabel = DirectLabel(parent=self,
relief=None,
text='',
text_align=TextNode.ACenter,
text_scale=0.05,
pos=(-0.15, 0.0, 0.17),
text_fg=(1, 0.9, 0.6, 1),
text_shadow=(0, 0, 0, 1))
if table.wantMeter == 1:
cardMaker = CardMaker('tellMeter')
cardMaker.setFrame(-1, 1, -1, 1)
self.meterMax = 0.2
self.meterBorder = NodePath(cardMaker.generate())
self.meterBorder.setColor(1, 1, 0, 1)
self.meterBorder.setScale(0.2, 1, 0.02)
self.meterBorder.reparentTo(aspect2d)
self.meter = NodePath(cardMaker.generate())
self.meter.setColor(1, 0, 0, 1)
self.meter.setScale(0.2, 1, 0.05)
self.meter.reparentTo(aspect2d)
if table.wantMeter == 2:
cardMaker = CardMaker('tellMeter')
cardMaker.setFrame(-1, 1, -1, 1)
self.balance = NodePath('Balance')
self.balance.reparentTo(aspect2d)
self.balanceL = NodePath(cardMaker.generate())
self.balanceL.setColor(1, 0, 0, 1)
self.balanceL.setScale(0.125, 1, 0.01)
self.balanceL.setPos(-0.125, 0, 0)
self.balanceL.reparentTo(self.balance)
self.balanceR = NodePath(cardMaker.generate())
self.balanceR.setColor(0, 1, 0, 1)
self.balanceR.setScale(0.125, 1, 0.01)
self.balanceR.setPos(0.125, 0, 0)
self.balanceR.reparentTo(self.balance)
self.fulcrum = loader.loadModel('models/props/winebottle_B')
self.fulcrum.setScale(0.2)
self.fulcrum.setZ(-0.21)
self.fulcrum.reparentTo(aspect2d)
self.weightR = NodePath(cardMaker.generate())
self.weightR.setColor(0, 0, 1, 1)
self.weightR.setScale(0.03, 1, 0.05)
self.weightR.setPos(0.22, 0, 0.06)
self.weightR.reparentTo(self.balance)
self.weightL = NodePath(cardMaker.generate())
self.weightL.setColor(0, 0, 1, 1)
self.weightL.setScale(0.03, 1, 0.05)
self.weightL.setPos(-0.22, 0, 0.06)
self.weightL.reparentTo(self.balance)
self.balance.hide()
self.fulcrum.hide()
self.communityCardNode = NodePath('communityCards')
self.communityCardNode.reparentTo(self)
self.communityCardNode.setScale(0.5)
self.communityCardNode.setPos(0, 0, 0.04)
self.communityCards = []
for i in range(self.maxCommunityCards):
card = PlayingCard.PlayingCardNodePath('standard',
PlayingCardGlobals.Unknown)
card.reparentTo(self.communityCardNode)
card.setPos(i * 0.3 - 0.6, 0, 0)
card.hide()
self.communityCards.append(card)
self.playerStatusPanels = []
for i in range(self.table.NumSeats + 1):
statusPanel = PokerStatusPanel(self.maxHandCards)
statusPanel.setName('playerHand-%s' % i)
pos = self.HandPos[i]
statusPanel.setPos(pos)
self.playerStatusPanels.append(statusPanel)
self.localStatusPanel = self.playerStatusPanels[
self.LocalAvatarGuiIndex]
gui = loader.loadModel('models/gui/toplevel_gui')
goldCoin = gui.find('**/treasure_w_coin*')
scale = 0.32
currentMoney = self.table.getPlayerChips()
x_increment = 0.24
self.moneyDisplay = DirectLabel(
parent=self.menu,
relief=None,
pos=(-0.3 + x_increment, 0, 0.075),
geom=goldCoin,
geom_scale=(scale, scale, scale),
geom_pos=(0, 0, 0),
text='%s' % currentMoney,
text_align=TextNode.ALeft,
text_scale=0.04,
text_pos=(0.05, -0.01),
text_fg=PiratesGuiGlobals.TextFG1,
text_shadow=PiratesGuiGlobals.TextShadow,
textMayChange=1,
scale=1.1)
self.accept(
InventoryGlobals.getCategoryQuantChangeMsg(
localAvatar.getInventoryId(), InventoryType.ItemTypeMoney),
self.setMoney)
this = self
identifier = 0
this.sfxArray = []
this.shuffleIdentifier = identifier
this.sfxArray = this.sfxArray + [
loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_SHUFFLE)
]
identifier += 1
this.startDealIdentifier = identifier
this.sfxArray = this.sfxArray + [
loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_01)
]
identifier += 1
this.sfxArray = this.sfxArray + [
loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_02)
]
identifier += 1
this.sfxArray = this.sfxArray + [
loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_03)
]
identifier += 1
this.sfxArray = this.sfxArray + [
loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_04)
]
identifier += 1
this.sfxArray = this.sfxArray + [
loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_05)
]
identifier += 1
this.sfxArray = this.sfxArray + [
loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_06)
]
identifier += 1
this.sfxArray = this.sfxArray + [
loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_07)
]
identifier += 1
this.sfxArray = this.sfxArray + [
loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_DEAL_08)
]
identifier += 1
this.totalDealIdentifiers = identifier - this.startDealIdentifier
this.foldIdentifier = identifier
this.sfxArray = this.sfxArray + [
loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_FOLD)
]
identifier += 1
this.flipIdentifier = identifier
this.sfxArray = this.sfxArray + [
loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_FLIP)
]
identifier += 1
this.pickupIdentifier = identifier
this.sfxArray = this.sfxArray + [
loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_PICKUP)
]
identifier += 1
this.checkIdentifier = identifier
check = loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_CHECK)
check.setVolume(0.5)
this.sfxArray = this.sfxArray + [check]
identifier += 1
this.betIdentifier = identifier
this.sfxArray = this.sfxArray + [
loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_CHIPS_BET)
]
identifier += 1
this.collectIdentifier = identifier
this.sfxArray = this.sfxArray + [
loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_CHIPS_COLLECT)
]
identifier += 1
this.allInIdentifier = identifier
this.sfxArray = this.sfxArray + [
loadSfx(SoundGlobals.SFX_MINIGAME_CARDS_CHIPS_ALL)
]
identifier += 1
return
def createHelpFrame(self, args=None):
if self.helpFrame:
return None
inv = localAvatar.getInventory()
if not inv:
return None
baseRank = max(self.skillRank, 1)
lvlDamageMod = WeaponGlobals.getLevelDamageModifier(
localAvatar.getLevel())
buff = WeaponGlobals.getSkillEffectFlag(self.skillId)
dur = WeaponGlobals.getAttackDuration(self.skillId)
effect = dur + dur * (baseRank - 1) / 4.0
bonus = localAvatar.getSkillRankBonus(self.skillId)
upgradeAmt = WeaponGlobals.getAttackUpgrade(self.skillId)
rank = localAvatar.getSkillRank(self.skillId)
skillBoost = 0
if self.skillId in ItemGlobals.getLinkedSkills(
localAvatar.currentWeaponId):
linkedSkillId = WeaponGlobals.getLinkedSkillId(self.skillId)
skillBoost = ItemGlobals.getWeaponBoosts(
localAvatar.currentWeaponId, linkedSkillId)
skillBoost += ItemGlobals.getWeaponBoosts(
localAvatar.getCurrentCharm(), linkedSkillId)
else:
skillBoost = ItemGlobals.getWeaponBoosts(
localAvatar.currentWeaponId, self.skillId)
skillBoost += ItemGlobals.getWeaponBoosts(
localAvatar.getCurrentCharm(), self.skillId)
manaCost = 0
if WeaponGlobals.getSkillTrack(
self.skillId) != WeaponGlobals.PASSIVE_SKILL_INDEX:
manaCost = WeaponGlobals.getMojoCost(self.skillId)
if manaCost < 0:
amt = localAvatar.getSkillRankBonus(
InventoryType.StaffConservation)
manaCost = min(manaCost - manaCost * amt, 1.0)
damage = 0
loDamage = 0
mpDamage = 0
mpLoDamage = 0
if WeaponGlobals.getSkillTrack(
self.skillId) == WeaponGlobals.TONIC_SKILL_INDEX:
damage = WeaponGlobals.getAttackSelfHP(self.skillId)
elif WeaponGlobals.getSkillTrack(
self.skillId) != WeaponGlobals.PASSIVE_SKILL_INDEX:
mod = (1.0 + bonus) * lvlDamageMod
damage = int(WeaponGlobals.getAttackTargetHP(self.skillId) * mod)
loDamage = damage / 2
mpDamage = int(
WeaponGlobals.getAttackTargetMojo(self.skillId) * mod)
mpLoDamage = mpDamage / 2
try:
skillInfo = PLocalizer.SkillDescriptions.get(self.skillId)
skillTitle = PLocalizer.makeHeadingString(
PLocalizer.InventoryTypeNames.get(self.skillId), 2)
skillType = PLocalizer.makeHeadingString(skillInfo[0], 1)
except:
self.notify.error('Error getting skill info for skillId %s' %
self.skillId)
description = skillInfo[1]
if damage < 0:
description += ' ' + PLocalizer.DealsDamage
elif damage > 0:
if loDamage:
loDamage = 0
description += ' ' + PLocalizer.HealsDamageRange
else:
description += ' ' + PLocalizer.HealsDamage
if mpDamage < 0:
description += ' ' + PLocalizer.DealsMpDamage
effectId = WeaponGlobals.getSkillEffectFlag(self.skillId)
if effectId:
description += ' ' + SkillEffectDescriptions.get(effectId)[0]
if bonus:
if self.skillId == InventoryType.SailBroadsideLeft or self.skillId == InventoryType.SailBroadsideRight:
description += ' ' + PLocalizer.BroadsideDesc
if self.skillId == InventoryType.CannonShoot:
description += ' ' + PLocalizer.CannonShootDesc
if self.skillId == InventoryType.DollAttune:
description += ' ' + PLocalizer.MultiAttuneDesc
if WeaponGlobals.getSkillInterrupt(self.skillId):
description += ' ' + PLocalizer.InterruptDesc
if WeaponGlobals.getSkillUnattune(self.skillId):
description += ' ' + PLocalizer.UnattuneDesc
upgradeInfo = ''
if self.showUpgrade and rank < 5:
if rank > 0:
upgradeInfo = skillInfo[2]
if upgradeInfo == '':
if damage < 0:
upgradeInfo += PLocalizer.UpgradesDamage
elif damage > 0:
upgradeInfo += PLocalizer.UpgradesHealing
if mpDamage < 0:
upgradeInfo += ' ' + PLocalizer.UpgradesMpDamage
if effectId:
entry = SkillEffectDescriptions.get(effectId)
if len(entry) > 1:
if not damage:
upgradeInfo += PLocalizer.UpgradesDuration
else:
upgradeInfo += ' ' + PLocalizer.And
upgradeInfo += ' ' + entry[1]
upgradeInfo += '!'
elif len(upgradeInfo) >= 4:
upgradeInfo = skillInfo[3]
else:
upgradeInfo = PLocalizer.ClickToLearn
elif not self.showIcon:
unlockLevel = RepChart.getSkillUnlockLevel(self.skillId)
if unlockLevel > 0:
upgradeInfo = PLocalizer.UnlocksAtLevel % unlockLevel
if self.skillId in SkillComboReq and SkillComboReq[
self.skillId] and inv.getStackQuantity(self.skillId - 1) < 2:
color = 'red'
if rank == 0:
color = 'red'
upgradeInfo = ''
description += '\n' + color + SkillComboReq[self.skillId] + '.'
skillDesc = skillTitle + '\n' + skillType + '\n\n' + description + '\ngreen' + upgradeInfo
stats = []
if manaCost:
stats.append(abs(manaCost))
if damage and loDamage:
stats.append(abs(loDamage))
stats.append(abs(damage))
elif damage:
stats.append(abs(damage))
if mpDamage:
stats.append(abs(mpLoDamage))
stats.append(abs(mpDamage))
if buff == WeaponGlobals.C_CURSE:
stats.append(WeaponGlobals.CURSED_DAM_AMP * 100)
if buff == WeaponGlobals.C_WEAKEN:
stats.append(WeaponGlobals.WEAKEN_PENALTY * 100)
if effect > 0:
stats.append(effect)
if skillInfo[4]:
if bonus == 0 and upgradeAmt > 0:
if not self.skillId == InventoryType.SailBroadsideLeft and self.skillId == InventoryType.SailBroadsideRight:
pass
if not (self.skillId == InventoryType.CannonShoot):
bonus = upgradeAmt
if upgradeAmt < 1.0 and upgradeAmt > 0:
bonus *= 100
if self.skillId == InventoryType.SailTreasureSense:
bonus /= 2.0
elif self.skillId == InventoryType.CutlassParry:
bonus += WeaponGlobals.getSubtypeParryBonus(
localAvatar.currentWeaponId)
if bonus:
stats.append(abs(bonus))
if self.skillId == InventoryType.DollAttune:
stats.append(rank)
if self.skillRank:
rankText = DirectFrame(parent=self,
relief=None,
text=PLocalizer.makeHeadingString(
PLocalizer.Rank + ' %s' %
(self.skillRank + skillBoost), 2),
text_align=TextNode.ARight,
text_scale=PiratesGuiGlobals.TextScaleSmall,
text_fg=PiratesGuiGlobals.TextFG2,
text_wordwrap=15,
text_shadow=(0, 0, 0, 1),
pos=(0.45000000000000001, 0, 0),
textMayChange=1,
sortOrder=92,
state=DGG.DISABLED)
stats = [stat + 0.01 for stat in stats]
try:
pass
except TypeError:
self.notify.error('Error formatting skillDesc(%s): %s' %
(self.skillId, stats))
helpText = DirectFrame(parent=self,
relief=None,
text=skillDesc % stats,
text_align=TextNode.ALeft,
text_scale=PiratesGuiGlobals.TextScaleSmall,
text_fg=PiratesGuiGlobals.TextFG2,
text_wordwrap=17,
textMayChange=1,
state=DGG.DISABLED,
sortOrder=91)
height = -(helpText.getHeight() + 0.01)
if self.lock:
height = height - 0.040000000000000001
width = 0.55000000000000004
self.helpFrame = BorderFrame(parent=self,
state=DGG.DISABLED,
frameSize=(-0.040000000000000001, width,
height, 0.050000000000000003),
pos=(0, 0, -0.12),
sortOrder=90)
self.helpFrame.setBin('gui-popup', 0)
helpText.reparentTo(self.helpFrame)
if self.skillRank:
rankText.reparentTo(self.helpFrame)
if self.lock:
self.lockedFrame = DirectFrame(
parent=self.helpFrame,
relief=None,
pos=(0.087999999999999995, 0, height + 0.029999999999999999),
image=SkillButton.SubLock,
image_scale=0.13,
image_pos=(-0.055, 0, 0.012999999999999999),
text=PLocalizer.VR_AuthAccess,
text_scale=PiratesGuiGlobals.TextScaleSmall,
text_align=TextNode.ALeft,
text_fg=PiratesGuiGlobals.TextFG13)
self.notify.debug('locked!')
pos = self.helpFrame.getPos(aspect2d)
x = min(pos[0], base.a2dRight - width)
z = max(pos[2], base.a2dBottom - height)
self.helpFrame.setPos(aspect2d, x, 0, z)
