class RepairGameButton(GuiButton):
def __init__(self, parent, **kw):
optiondefs = (('nodePath', None, None), ('image_scale', (1.0, 1.0,
1.0), None))
self.defineoptions(kw, optiondefs)
GuiButton.__init__(self, parent)
self.initialiseoptions(RepairGameButton)
self.disabledStateNode = self.stateNodePath[3].getChild(0)
self.downStateNode = self.stateNodePath[1].getChild(0)
self.overStateNode = self.stateNodePath[2].getChild(0)
self.inProgress = False
self._initGUI()
def _initGUI(self):
self.setBin('fixed', 33)
mainGui = loader.loadModel('models/gui/gui_main')
gui = loader.loadModel('models/gui/toplevel_gui')
self.checkMark = gui.find('**/generic_check')
self.checkMark.reparentTo(self)
self.checkMark.stash()
self.checkMark.setScale(1.0)
self.checkMark.setColorScale(0.0, 1.0, 0.0, 1.0)
self.checkMark.setPos(0.02, 0.0, 0.02)
self.checkMark.setBin('fixed', 34)
self.skillRing = DialMeter(self,
wantCover=False,
dangerRatio=0.0,
meterColor=Vec4(0.90000000000000002,
0.90000000000000002,
0.10000000000000001, 1.0),
baseColor=Vec4(0.14999999999999999,
0.070000000000000007,
0.029999999999999999, 1.0),
completeColor=Vec4(0.10000000000000001,
0.90000000000000002,
0.10000000000000001,
1.0))
self.skillRing.reparentTo(self)
self.skillRing.setScale(0.28499999999999998, 0.29999999999999999,
0.26500000000000001)
self.skillRing.setBin('fixed', 32)
self.skillGlow = OnscreenImage(parent=self,
image=mainGui.find('**/icon_glow'),
scale=(1.0, 1.0, 1.0),
color=(1.0, 1.0, 0.59999999999999998,
1.0))
self.glow = OnscreenImage(parent=self,
image=mainGui.find('**/icon_glow'),
scale=(1.0, 1.0, 1.0),
color=(1.0, 1.0, 0.59999999999999998, 1.0))
self.skillGlow.reparentTo(self)
self.skillGlow.setBin('fixed', 31)
self.skillGlow.stash()
self.pirateNameBox = None
self.pirateNameLabel = None
def showGlow(self):
self.inProgress = False
if self.pirateNameLabel == None and self.checkMark.isStashed():
self.skillGlow.unstash()
def hideGlow(self):
self.inProgress = True
self.skillGlow.stash()
def setProgress(self, percent):
self.skillGlow.stash()
ratio = max(0.0, percent / 100.0)
if ratio >= 1.0:
if self.checkMark.isStashed():
self.checkMark.unstash()
elif not self.checkMark.isStashed():
self.checkMark.stash()
if self.pirateNameLabel == None and not (self.inProgress):
self.skillGlow.unstash()
self.skillRing.update(ratio, 1.0)
self.skillRing.wrtReparentTo(self.getParent())
self.reparentTo(self.getParent())
def updatePirateNameBox(self, pirateName):
if self.pirateNameLabel != None and self.pirateNameLabel[
'text'] != pirateName:
if self.pirateNameBox:
self.pirateNameBox.destroy()
if self.pirateNameLabel:
self.pirateNameLabel.destroy()
self.pirateNameBox = None
self.pirateNameLabel = None
if pirateName != '':
if self.pirateNameBox:
pass
if not (self.pirateNameLabel['text'] == pirateName):
self.createPirateNameBox(pirateName)
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)
class GuiButton(DirectButton):
notify = directNotify.newCategory('GuiButton')
genericButton = None
redGenericButton = None
blueGenericButton = None
def __init__(self, parent = None, hotkeys = (), hotkeyLabel = None, hotkeyLabelX = 0.091999999999999998, hotkeyArgs = True, helpText = '', helpPos = (0, 0, 0), helpDelay = PiratesGuiGlobals.HelpPopupTime, helpColorOff = False, helpLeftAlign = False, helpCenterAlign = False, **kw):
self.loadGui()
self.helpBox = None
self.helpWatcher = None
self.canRepositon = False
optiondefs = (('relief', None, None), ('pos', (0, 0, 0), None), ('image', GuiButton.genericButton, None), ('image_scale', (0.23999999999999999, 0.22, 0.22), None), ('image_pos', (0, 0, 0), None), ('pressEffect', 0, None), ('text', '', None), ('text_font', PiratesGlobals.getInterfaceFont(), None), ('text_scale', PiratesGuiGlobals.TextScaleLarge, None), ('text0_fg', PiratesGuiGlobals.TextFG2, None), ('text1_fg', PiratesGuiGlobals.TextFG2, None), ('text2_fg', PiratesGuiGlobals.TextFG2, None), ('text3_fg', PiratesGuiGlobals.TextFG3, None), ('text_shadow', PiratesGuiGlobals.TextShadow, None), ('text_pos', (0, -0.01), None), ('text_wordwrap', 8, None), ('text_align', TextNode.ACenter, None), ('textMayChange', 1, None), ('helpText', helpText, self.helpTextUpdated), ('helpPos', helpPos, self.setHelpPos), ('helpDelay', helpDelay, None), ('helpColorOff', helpColorOff, None), ('helpLeftAlign', helpLeftAlign, None), ('helpCenterAlign', helpCenterAlign, None), ('helpBin', 'gui-popup', None), ('helpBinSort', 0, None), ('helpOpaque', 0, None), ('canReposition', False, None), ('sortOrder', 100, None), ('baseImage', None, None), ('selected', False, None), ('selectedImage', GuiButton.genericButton, None), ('state', DGG.NORMAL, self.setState))
self.defineoptions(kw, optiondefs)
DirectButton.__init__(self, parent = NodePath())
self.initialiseoptions(GuiButton)
self.hotkeys = ()
self.setupHotkeys(hotkeys, hotkeyLabel, self['command'], self['extraArgs'], hotkeyLabelX, hotkeyArgs)
if not parent:
pass
self.reparentTo(aspect2d)
self.helpTaskName = None
def destroy(self):
self.hideDetails()
if self.helpWatcher:
self.helpWatcher.unbind(DGG.WITHIN)
self.helpWatcher.unbind(DGG.WITHOUT)
self.helpWatcher.destroy()
self.helpWatcher = None
self.unbind(DGG.ENTER)
self.unbind(DGG.EXIT)
self.ignoreAll()
DirectButton.destroy(self)
def loadGui(self):
if GuiButton.genericButton:
return None
gui = loader.loadModel('models/gui/toplevel_gui')
GuiButton.genericButton = (gui.find('**/generic_button'), gui.find('**/generic_button_down'), gui.find('**/generic_button_over'), gui.find('**/generic_button_disabled'))
GuiButton.redGenericButton = (gui.find('**/pir_t_gui_but_generic'), gui.find('**/pir_t_gui_but_generic_down'), gui.find('**/pir_t_gui_but_generic_over'), gui.find('**/pir_t_gui_but_generic_disabled'))
GuiButton.blueGenericButton = (gui.find('**/pir_t_gui_but_generic_blue'), gui.find('**/pir_t_gui_but_generic_blue_down'), gui.find('**/pir_t_gui_but_generic_blue_over'), gui.find('**/pir_t_gui_but_generic_blue_disabled'))
def setupHotkeys(self, hotkeys, hotkeyLabel, command, extraArgs, hotkeyLabelX = 0.091999999999999998, hotkeyArgs = True):
if self.hotkeys:
self.ignoreHotkeys()
self.hotkeyLabel.destroy()
self.hotkeys = hotkeys
self.command = command
self.extraArgs = extraArgs
self.hotkeyLabel = hotkeyLabel
self.hotkeyLabelX = hotkeyLabelX
self.hotkeyArgs = hotkeyArgs
if self.hotkeys:
self.hotkeyLabel = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = hotkeyLabel, text_font = PiratesGlobals.getPirateBoldOutlineFont(), text_scale = PiratesGuiGlobals.TextScaleMed, text_pos = (hotkeyLabelX, 0.01), text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 1)
self.acceptHotkeys()
def ignoreHotkeys(self):
if self.hotkeys:
for hotkey in self.hotkeys:
self.ignore(hotkey)
def acceptHotkeys(self):
if self.hotkeys:
for hotkey in self.hotkeys:
if self.hotkeyArgs:
self.accept(hotkey, self.command, self.extraArgs + [
hotkey])
continue
self.accept(hotkey, self.command, self.extraArgs)
def createHelpWatcher(self):
if self['helpOpaque']:
self.bind(DGG.ENTER, self.waitShowDetails)
self.bind(DGG.EXIT, self.hideDetails)
else:
w = self.getWidth()
h = self.getHeight()
pos = self._GuiButton__discoverHelpWatcherPos()
if not self['frameSize']:
pass
frameSize = self.getBounds()
self.helpWatcher = DirectFrame(parent = self, relief = base.config.GetBool('show-helpwatchers', 0), state = DGG.NORMAL, frameColor = (1, 1, 0, 0.5), frameSize = frameSize, sortOrder = self['sortOrder'] - 1)
self.helpWatcher.wrtReparentTo(self.getParent())
self.reparentTo(self.getParent())
self.helpWatcher.bind(DGG.WITHIN, self.waitShowDetails)
self.helpWatcher.bind(DGG.WITHOUT, self.hideDetails)
def _GuiButton__discoverHelpWatcherPos(self):
w = self.getWidth()
h = self.getHeight()
if not self['frameSize']:
pass
bounds = self.getBounds()
pos = Vec3(bounds[0] + w / 2, 0, bounds[2] + h / 2)
return pos
def resetHelpWatcher(self):
if self.helpWatcher:
self.helpWatcher.setPos(self, 0, 0, 0)
def createHelpBox(self):
if not self.helpWatcher:
self.createHelpWatcher()
helpLabel = DirectLabel(relief = None, state = DGG.DISABLED, text = self['helpText'], text_align = TextNode.ACenter, text_scale = PiratesGuiGlobals.TextScaleMed, text_fg = PiratesGuiGlobals.TextFG1, text_wordwrap = 12, text_shadow = (0, 0, 0, 1), textMayChange = 0, sortOrder = 91)
height = helpLabel.getHeight()
width = helpLabel.getWidth() + 0.050000000000000003
if self['helpLeftAlign']:
fs = [
0.0,
width,
-height,
0.044999999999999998]
pos = [
width / 2.0,
0,
-0.01]
elif self['helpCenterAlign']:
pos = [
0.0,
0.0,
-0.01]
fs = [
-(width / 2 + 0.01),
width / 2 + 0.01,
-(height / 2 + 0.014999999999999999),
height / 2 + 0.014999999999999999]
else:
fs = [
0.25 - width,
0.25,
-height,
0.044999999999999998]
pos = [
0.25 - width / 2.0,
0,
-0.01]
self.helpBox = BorderFrame(parent = self, state = DGG.DISABLED, frameSize = (fs[0], fs[1], fs[2], fs[3]), modelName = 'general_frame_f', pos = self['helpPos'], sortOrder = 90)
helpLabel.reparentTo(self.helpBox)
helpLabel.setPos(pos[0], pos[1], pos[2])
self.helpBox.hide()
self.helpBox.setClipPlaneOff()
pos = self.helpBox.getPos(aspect2d)
x = min(pos[0], base.a2dRight - width)
z = max(pos[2], base.a2dBottom - height)
self.helpBox.setPos(aspect2d, x, 0, z)
if self['helpColorOff']:
self.helpBox.setColorOff()
else:
self.helpBox.flattenLight()
if self['helpBin']:
self.helpBox.setBin(self['helpBin'], self['helpBinSort'])
def helpTextUpdated(self):
if self.helpBox and self.helpBox['text'] != self['helpText']:
self.helpBox.destroy()
self.createHelpBox()
elif self['helpText']:
self.createHelpBox()
def setHelpPos(self):
if self.helpBox:
self.helpTextUpdated()
def waitShowDetails(self, event):
try:
self['helpDelay']
except AttributeError:
return None
if not self.helpBox:
self.createHelpBox()
if self['helpDelay']:
self.hideDetails()
self.helpTaskName = 'helpInfoTask-%s' % self.getName()
taskMgr.doMethodLater(self['helpDelay'], self.helpBox.show, self.helpTaskName, extraArgs = [])
else:
self.helpBox.show()
def hideDetails(self, event = None):
if self.helpTaskName:
taskMgr.remove(self.helpTaskName)
if self.helpBox and not self.helpBox.isEmpty():
self.helpBox.hide()
def setImage(self):
DirectButton.setImage(self)
if not self['baseImage']:
self['baseImage'] = self['image']
def setSelected(self):
if self['selected']:
self['image'] = self['selectedImage']
else:
self['image'] = self['baseImage']
def setState(self):
DirectButton.setState(self)
if self.helpWatcher:
self.helpWatcher['state'] = self['state']
def removeNode(self):
DirectButton.removeNode(self)
if self.helpWatcher:
self.helpWatcher.removeNode()
def remove(self):
DirectButton.remove(self)
if self.helpWatcher:
self.helpWatcher.remove()
def detachNode(self):
DirectButton.detachNode(self)
if self.helpWatcher:
self.helpWatcher.detachNode()
def hide(self):
DirectButton.hide(self)
if self.helpWatcher:
self.helpWatcher.hide()
def show(self):
DirectButton.show(self)
if self.helpWatcher:
self.helpWatcher.show()
def stash(self):
DirectButton.stash(self)
if self.helpWatcher:
self.helpWatcher.stash()
def unstash(self):
DirectButton.unstash(self)
self.reparentTo(self.getParent(), sort = self['sortOrder'])
if self.helpWatcher:
self.helpWatcher.unstash()
self.helpWatcher.reparentTo(self.helpWatcher.getParent(), sort = self.helpWatcher['sortOrder'])
class GuiButton(DirectButton):
notify = directNotify.newCategory('GuiButton')
genericButton = None
redGenericButton = None
blueGenericButton = None
def __init__(self,
parent=None,
hotkeys=(),
hotkeyLabel=None,
hotkeyLabelX=0.091999999999999998,
hotkeyArgs=True,
helpText='',
helpPos=(0, 0, 0),
helpDelay=PiratesGuiGlobals.HelpPopupTime,
helpColorOff=False,
helpLeftAlign=False,
helpCenterAlign=False,
**kw):
self.loadGui()
self.helpBox = None
self.helpWatcher = None
self.canRepositon = False
optiondefs = (('relief', None, None), ('pos', (0, 0, 0), None),
('image', GuiButton.genericButton, None),
('image_scale', (0.23999999999999999, 0.22, 0.22),
None), ('image_pos', (0, 0, 0), None),
('pressEffect', 0, None), ('text', '', None),
('text_font', PiratesGlobals.getInterfaceFont(),
None), ('text_scale', PiratesGuiGlobals.TextScaleLarge,
None), ('text0_fg', PiratesGuiGlobals.TextFG2,
None),
('text1_fg', PiratesGuiGlobals.TextFG2,
None), ('text2_fg', PiratesGuiGlobals.TextFG2, None),
('text3_fg', PiratesGuiGlobals.TextFG3,
None), ('text_shadow', PiratesGuiGlobals.TextShadow,
None), ('text_pos', (0, -0.01),
None), ('text_wordwrap', 8, None),
('text_align', TextNode.ACenter,
None), ('textMayChange', 1,
None), ('helpText', helpText,
self.helpTextUpdated),
('helpPos', helpPos, self.setHelpPos), ('helpDelay',
helpDelay, None),
('helpColorOff', helpColorOff,
None), ('helpLeftAlign', helpLeftAlign,
None), ('helpCenterAlign', helpCenterAlign,
None), ('helpBin', 'gui-popup',
None), ('helpBinSort', 0, None),
('helpOpaque', 0, None), ('canReposition', False,
None), ('sortOrder', 100,
None), ('baseImage',
None, None),
('selected', False,
None), ('selectedImage', GuiButton.genericButton,
None), ('state', DGG.NORMAL, self.setState))
self.defineoptions(kw, optiondefs)
DirectButton.__init__(self, parent=NodePath(), **None)
self.initialiseoptions(GuiButton)
self.hotkeys = ()
self.setupHotkeys(hotkeys, hotkeyLabel, self['command'],
self['extraArgs'], hotkeyLabelX, hotkeyArgs)
if not parent:
pass
self.reparentTo(aspect2d)
self.helpTaskName = None
def destroy(self):
self.hideDetails()
self.command = None
if self.helpWatcher:
self.helpWatcher.command = None
self.helpWatcher.unbind(DGG.WITHIN)
self.helpWatcher.unbind(DGG.WITHOUT)
self.helpWatcher.destroy()
self.helpWatcher = None
self.unbind(DGG.ENTER)
self.unbind(DGG.EXIT)
self.ignoreAll()
DirectButton.destroy(self)
def loadGui(self):
if GuiButton.genericButton:
return None
gui = loader.loadModel('models/gui/toplevel_gui')
GuiButton.genericButton = (gui.find('**/generic_button'),
gui.find('**/generic_button_down'),
gui.find('**/generic_button_over'),
gui.find('**/generic_button_disabled'))
GuiButton.redGenericButton = (
gui.find('**/pir_t_gui_but_generic'),
gui.find('**/pir_t_gui_but_generic_down'),
gui.find('**/pir_t_gui_but_generic_over'),
gui.find('**/pir_t_gui_but_generic_disabled'))
GuiButton.blueGenericButton = (
gui.find('**/pir_t_gui_but_generic_blue'),
gui.find('**/pir_t_gui_but_generic_blue_down'),
gui.find('**/pir_t_gui_but_generic_blue_over'),
gui.find('**/pir_t_gui_but_generic_blue_disabled'))
def setupHotkeys(self,
hotkeys,
hotkeyLabel,
command,
extraArgs,
hotkeyLabelX=0.091999999999999998,
hotkeyArgs=True):
if self.hotkeys:
self.ignoreHotkeys()
self.hotkeyLabel.destroy()
self.hotkeys = hotkeys
self.command = command
self.extraArgs = extraArgs
self.hotkeyLabel = hotkeyLabel
self.hotkeyLabelX = hotkeyLabelX
self.hotkeyArgs = hotkeyArgs
if self.hotkeys:
self.hotkeyLabel = DirectLabel(
parent=self,
relief=None,
state=DGG.DISABLED,
text=hotkeyLabel,
text_font=PiratesGlobals.getPirateBoldOutlineFont(),
text_scale=PiratesGuiGlobals.TextScaleMed,
text_pos=(hotkeyLabelX, 0.01),
text_fg=PiratesGuiGlobals.TextFG2,
text_shadow=PiratesGuiGlobals.TextShadow,
textMayChange=1)
self.acceptHotkeys()
def ignoreHotkeys(self):
if self.hotkeys:
for hotkey in self.hotkeys:
self.ignore(hotkey)
def acceptHotkeys(self):
if self.hotkeys:
for hotkey in self.hotkeys:
if self.hotkeyArgs:
self.accept(hotkey, self.command,
self.extraArgs + [hotkey])
continue
self.accept(hotkey, self.command, self.extraArgs)
def createHelpWatcher(self):
if self['helpOpaque']:
self.bind(DGG.ENTER, self.waitShowDetails)
self.bind(DGG.EXIT, self.hideDetails)
else:
w = self.getWidth()
h = self.getHeight()
pos = self._GuiButton__discoverHelpWatcherPos()
if not self['frameSize']:
pass
frameSize = self.getBounds()
self.helpWatcher = DirectFrame(parent=self,
relief=base.config.GetBool(
'show-helpwatchers', 0),
state=DGG.NORMAL,
frameColor=(1, 1, 0, 0.5),
frameSize=frameSize,
sortOrder=self['sortOrder'] - 1)
self.helpWatcher.wrtReparentTo(self.getParent())
self.reparentTo(self.getParent())
self.helpWatcher.bind(DGG.WITHIN, self.waitShowDetails)
self.helpWatcher.bind(DGG.WITHOUT, self.hideDetails)
def _GuiButton__discoverHelpWatcherPos(self):
w = self.getWidth()
h = self.getHeight()
if not self['frameSize']:
pass
bounds = self.getBounds()
pos = Vec3(bounds[0] + w / 2, 0, bounds[2] + h / 2)
return pos
def resetHelpWatcher(self):
if self.helpWatcher:
self.helpWatcher.setPos(self, 0, 0, 0)
def createHelpBox(self):
if not self.helpWatcher:
self.createHelpWatcher()
helpLabel = DirectLabel(relief=None,
state=DGG.DISABLED,
text=self['helpText'],
text_align=TextNode.ACenter,
text_scale=PiratesGuiGlobals.TextScaleMed,
text_fg=PiratesGuiGlobals.TextFG1,
text_wordwrap=12,
text_shadow=(0, 0, 0, 1),
textMayChange=0,
sortOrder=91)
height = helpLabel.getHeight()
width = helpLabel.getWidth() + 0.050000000000000003
if self['helpLeftAlign']:
fs = [0.0, width, -height, 0.044999999999999998]
pos = [width / 2.0, 0, -0.01]
elif self['helpCenterAlign']:
pos = [0.0, 0.0, -0.01]
fs = [
-(width / 2 + 0.01), width / 2 + 0.01,
-(height / 2 + 0.014999999999999999),
height / 2 + 0.014999999999999999
]
else:
fs = [0.25 - width, 0.25, -height, 0.044999999999999998]
pos = [0.25 - width / 2.0, 0, -0.01]
self.helpBox = BorderFrame(parent=self,
state=DGG.DISABLED,
frameSize=(fs[0], fs[1], fs[2], fs[3]),
modelName='general_frame_f',
pos=self['helpPos'],
sortOrder=90)
helpLabel.reparentTo(self.helpBox)
helpLabel.setPos(pos[0], pos[1], pos[2])
self.helpBox.hide()
self.helpBox.setClipPlaneOff()
pos = self.helpBox.getPos(aspect2d)
x = min(pos[0], base.a2dRight - width)
z = max(pos[2], base.a2dBottom - height)
self.helpBox.setPos(aspect2d, x, 0, z)
if self['helpColorOff']:
self.helpBox.setColorOff()
else:
self.helpBox.flattenLight()
if self['helpBin']:
self.helpBox.setBin(self['helpBin'], self['helpBinSort'])
def helpTextUpdated(self):
if self.helpBox and self.helpBox['text'] != self['helpText']:
self.helpBox.destroy()
self.createHelpBox()
elif self['helpText']:
self.createHelpBox()
def setHelpPos(self):
if self.helpBox:
self.helpTextUpdated()
def waitShowDetails(self, event):
try:
self['helpDelay']
except AttributeError:
return None
if not self.helpBox:
self.createHelpBox()
if self['helpDelay']:
self.hideDetails()
self.helpTaskName = 'helpInfoTask-%s' % self.getName()
taskMgr.doMethodLater(self['helpDelay'],
self.helpBox.show,
self.helpTaskName,
extraArgs=[])
else:
self.helpBox.show()
def hideDetails(self, event=None):
if self.helpTaskName:
taskMgr.remove(self.helpTaskName)
if self.helpBox and not self.helpBox.isEmpty():
self.helpBox.hide()
def setImage(self):
DirectButton.setImage(self)
if not self['baseImage']:
self['baseImage'] = self['image']
def setSelected(self):
if self['selected']:
self['image'] = self['selectedImage']
else:
self['image'] = self['baseImage']
def setPos(self, *args, **kw):
DirectButton.setPos(self, *args, **args)
def setX(self, *args, **kw):
DirectButton.setX(self, *args, **args)
def setY(self, *args, **kw):
DirectButton.setY(self, *args, **args)
def setZ(self, *args, **kw):
DirectButton.setZ(self, *args, **args)
def setState(self):
DirectButton.setState(self)
if self.helpWatcher:
self.helpWatcher['state'] = self['state']
def removeNode(self):
DirectButton.removeNode(self)
if self.helpWatcher:
self.helpWatcher.removeNode()
def remove(self):
DirectButton.remove(self)
if self.helpWatcher:
self.helpWatcher.remove()
def detachNode(self):
DirectButton.detachNode(self)
if self.helpWatcher:
self.helpWatcher.detachNode()
def hide(self):
DirectButton.hide(self)
if self.helpWatcher:
self.helpWatcher.hide()
def show(self):
DirectButton.show(self)
if self.helpWatcher:
self.helpWatcher.show()
def stash(self):
DirectButton.stash(self)
if self.helpWatcher:
self.helpWatcher.stash()
def unstash(self):
DirectButton.unstash(self)
self.reparentTo(self.getParent(), sort=self['sortOrder'])
if self.helpWatcher:
self.helpWatcher.unstash()
self.helpWatcher.reparentTo(self.helpWatcher.getParent(),
sort=self.helpWatcher['sortOrder'])
class SkillButton(DirectFrame):
notify = directNotify.newCategory('SkillButton')
SkillIcons = None
Image = None
SkillRechargedSound = None
SubLock = None
def __init__(self,
skillId,
callback,
quantity=0,
skillRank=0,
showQuantity=False,
showHelp=False,
showRing=False,
hotkey=None,
name='',
showIcon=True,
showLock=False,
rechargeSkillId=False,
isWeaponSkill=False,
assocAmmo=[]):
DirectFrame.__init__(self, parent=NodePath(), relief=None)
self.initialiseoptions(SkillButton)
gui = loader.loadModel('models/gui/toplevel_gui')
if not SkillButton.SkillIcons:
print 'not SkillButton.SkillIcons:'
SkillButton.SkillIcons = loader.loadModel(
'models/textureCards/skillIcons')
SkillButton.Image = (SkillButton.SkillIcons.find('**/base'),
SkillButton.SkillIcons.find('**/base_down'),
SkillButton.SkillIcons.find('**/base_over'))
SkillButton.SkillRechargedSound = loadSfx(
SoundGlobals.SFX_SKILL_RECHARGED)
SkillButton.SubLock = gui.find('**/pir_t_gui_gen_key_subscriber')
SkillButton.SpecialIcons = []
for entry in SPECIAL_SKILL_ICONS:
if not entry:
SkillButton.SpecialIcons.append(None)
continue
specialImage = (SkillButton.SkillIcons.find('**/%s' % entry), )
SkillButton.SpecialIcons.append(specialImage)
model = loader.loadModel('models/effects/particleMaps')
toggleIcon = model.find('**/particleGlow')
toggleIcon.node().setAttrib(
ColorBlendAttrib.make(ColorBlendAttrib.MAdd))
self.toggleFrame = DirectFrame(relief=None,
state=DGG.DISABLED,
parent=self,
image=toggleIcon,
image_scale=0.34999999999999998,
image_pos=(0.0, 0.0, -0.01))
self.toggleFrame.hide()
self.glowRing = None
self.glowRing2 = None
self.assocAmmo = assocAmmo
self.skillId = skillId
self.quantity = quantity
self.showQuantity = showQuantity
self.skillRank = skillRank
self.skillRing = None
self.callback = callback
self.showUpgrade = False
self.showHelp = showHelp
self.showRing = showRing
self.showIcon = showIcon
self.showLock = showLock
self.isWeaponSkill = isWeaponSkill
self.lock = None
self.name = name
self.helpFrame = None
self.quantityLabel = None
self.skillButton = None
self.hotkeyLabel = None
self.hotkey = hotkey
self.greyOut = 0
self.tonicId = 0
self.skillRingIval = None
self.impulseIval = None
self.quickImpulseIval = None
self.isBreakAttackSkill = WeaponGlobals.getSkillTrack(
self.skillId) == WeaponGlobals.BREAK_ATTACK_SKILL_INDEX
self.isDefenseSkill = WeaponGlobals.getSkillTrack(
self.skillId) == WeaponGlobals.DEFENSE_SKILL_INDEX
self.rechargeFilled = 0
self.defenseAuraEffect = None
if self.isWeaponSkill:
self.weaponBackground = DirectLabel(
parent=self,
state=DGG.DISABLED,
image=SkillButton.SkillIcons.find('**/box_base'),
image_scale=(0.22, 0, 0.22),
image_pos=(0.0, 0.0, 0.0))
self.weaponBackground.flattenLight()
self.weaponBackground.setColor(0.20000000000000001,
0.20000000000000001,
0.20000000000000001,
0.20000000000000001)
self.weaponBackground.setTransparency(1)
if showRing:
if self.isBreakAttackSkill:
color = Vec4(1, 0, 0, 1)
elif self.isDefenseSkill:
color = Vec4(0, 1, 1, 1)
else:
color = Vec4(1, 0.80000000000000004, 0.5, 1)
self.skillRing = SkillRing(color, Vec4(0, 0, 0, 1.0))
gs = self.skillRing.meterFaceHalf2.node().getGeomState(0)
self.skillRing.meterFaceHalf2.node().setGeomState(
0, gs.removeAttrib(ColorAttrib.getClassType()))
self.skillRing.reparentTo(self, 0)
self.skillRing.setPos(0, 0, 0)
self.updateSkillId(skillId)
if showQuantity:
self.updateQuantity(quantity)
if hotkey:
self.createHotkey(hotkey)
if showLock:
self.createLock()
self.skillButton.bind(DGG.ENTER, self.showDetails)
self.skillButton.bind(DGG.EXIT, self.hideDetails)
if self.skillId >= InventoryType.begin_Consumables and self.skillId <= InventoryType.end_Consumables and not WeaponGlobals.getSkillEffectFlag(
skillId):
self.totalRechargeTime = base.cr.battleMgr.getModifiedRechargeTime(
localAvatar, InventoryType.UseItem)
self.tonicId = InventoryType.UseItem
else:
self.totalRechargeTime = base.cr.battleMgr.getModifiedRechargeTime(
localAvatar, self.skillId)
if showRing:
if not self.isBreakAttackSkill:
self.createSkillRingIval()
if self.tonicId:
timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging(
InventoryType.UseItem)
else:
timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging(
self.skillId)
if self.isBreakAttackSkill and timeSpentRecharging < self.totalRechargeTime:
self.updateRechargeRing()
elif not (self.isBreakAttackSkill):
if (self.totalRechargeTime or timeSpentRecharging
) and not (timeSpentRecharging > self.totalRechargeTime):
self.skillRingIval.start(startT=timeSpentRecharging)
not (timeSpentRecharging > self.totalRechargeTime)
self.skillRing.meterFaceHalf1.setR(0)
self.skillRing.meterFaceHalf2.setR(180)
self.skillRing.meterFaceHalf1.setColor(
self.skillRing.meterActiveColor, 100)
self.skillRing.meterFaceHalf2.setColor(
self.skillRing.meterActiveColor, 100)
self.skillRing.meterFaceHalf1.show()
self.skillRing.meterFaceHalf2.show()
if not self.isBreakAttackSkill:
self.checkAmount()
if self.isDefenseSkill:
self.startRecharge()
if self.isWeaponSkill:
self.weaponLabel = DirectLabel(
parent=self,
relief=None,
text=PLocalizer.WeaponAbility,
text_font=PiratesGlobals.getPirateBoldOutlineFont(),
text_align=TextNode.ACenter,
text_scale=PiratesGuiGlobals.TextScaleLarge,
text_fg=PiratesGuiGlobals.TextFG2,
text_shadow=PiratesGuiGlobals.TextShadow,
textMayChange=0,
pos=(0.0, 0, -0.12),
sortOrder=70,
state=DGG.DISABLED)
self.weaponLabel.flattenLight()
def loadGlowRing(self):
self.glowRing = loader.loadModel('models/effects/battleEffects').find(
'**/effectVoodooShockwave')
self.glowRing.node().setAttrib(
ColorBlendAttrib.make(ColorBlendAttrib.MAdd,
ColorBlendAttrib.OIncomingAlpha,
ColorBlendAttrib.OOne))
self.glowRing.reparentTo(self)
self.glowRing.setBin('transparent', 0)
self.glowRing.setScale(0.20000000000000001)
self.glowRing.hide()
self.glowRing2 = loader.loadModel('models/effects/particleMaps').find(
'**/particleGlow')
self.glowRing2.node().setAttrib(
ColorBlendAttrib.make(ColorBlendAttrib.MAdd,
ColorBlendAttrib.OOneMinusIncomingAlpha,
ColorBlendAttrib.OOne))
self.glowRing2.reparentTo(self)
self.glowRing2.setBin('transparent', 0)
self.glowRing2.setScale(0.20000000000000001)
self.glowRing2.setColor(0.80000000000000004, 1, 0.80000000000000004,
0.20000000000000001)
self.glowRing2.reparentTo(self)
self.glowRing2.hide()
def checkAmount(self):
if not (self.quantity) and self.showQuantity:
if self.showRing and not self.skillRingIval.isPlaying():
self.setGeomColor(0.5, 0.5, 0.5, 1.0)
self.setRingColor(Vec4(0.5, 0.5, 0.5, 1.0))
elif self.showRing and not self.skillRingIval.isPlaying():
self.setGeomColor(1.0, 1.0, 1.0, 1.0)
self.setRingColor(self.skillRing.meterActiveColor)
def toggleButton(self, state):
if state == True:
self.toggleFrame.show()
elif state == False:
self.toggleFrame.hide()
def createSkillRingIval(self):
if self.skillRingIval:
self.skillRingIval.pause()
self.skillRing.meterFaceHalf1.setR(0)
self.skillRing.meterFaceHalf2.setR(180)
self.skillRing.setScale(1.0)
self.skillRing.clearColorScale()
self.setGeomColor(1.0, 1.0, 1.0, 1.0)
self.checkAmount()
self.skillRingIval = None
if self.tonicId:
timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging(
InventoryType.UseItem)
else:
timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging(
self.skillId)
if self.isDefenseSkill:
localAvatar.setDefenceEffect(self.skillId)
if self.showRing:
self.skillRingIval = Sequence(
Func(localAvatar.setDefenceEffect, 0),
Func(self.setGeomColor, 0.5, 0.5, 0.5, 1.0),
Func(self.skillRing.meterFaceHalf1.setColor,
self.skillRing.meterActiveColor, 100),
Func(self.skillRing.meterFaceHalf2.setColor,
self.skillRing.meterColor, 100),
Func(self.skillRing.meterFaceHalf1.setR, 0),
Func(self.skillRing.meterFaceHalf2.setR, 0),
Func(self.skillRing.meterFaceHalf1.show),
Func(self.skillRing.meterFaceHalf2.show),
LerpFunc(self.skillRing.meterFaceHalf2.setR,
self.totalRechargeTime / 2, 0, -180),
Func(self.skillRing.meterFaceHalf2.setColor,
self.skillRing.meterActiveColor, 100),
Func(self.skillRing.meterFaceHalf2.setR, 0),
LerpFunc(self.skillRing.meterFaceHalf1.setR,
self.totalRechargeTime / 2, 0, -180),
Func(self.setGeomColor, 1.0, 1.0, 1.0, 1.0),
Func(base.playSfx, SkillButton.SkillRechargedSound,
volume=0.5),
Parallel(
LerpScaleInterval(self.skillRing, 0.10000000000000001,
Vec3(1.2, 1.2, 1.2)),
LerpColorScaleInterval(self.skillRing,
0.10000000000000001,
Vec4(0.0, 0.75, 0.0, 1.0),
Vec4(1.0, 1.0, 1.0, 1.0),
blendType='easeInOut')),
Func(localAvatar.setDefenceEffect, self.skillId),
LerpScaleInterval(
self.skillRing, 0.20000000000000001,
Vec3(0.90000000000000002, 0.90000000000000002,
0.90000000000000002)),
LerpScaleInterval(
self.skillRing, 0.029999999999999999,
Vec3(1.1000000000000001, 1.1000000000000001,
1.1000000000000001)),
Parallel(
LerpScaleInterval(self.skillRing, 0.029999999999999999,
Vec3(1.0, 1.0, 1.0)),
LerpColorScaleInterval(self.skillRing,
1,
Vec4(1.0, 1.0, 1.0, 1.0),
blendType='easeInOut')),
Func(self.skillRing.clearColorScale), Func(self.checkAmount))
def updateSkillRingIval(self):
if self.showRing:
playing = self.skillRingIval.isPlaying()
if self.tonicId:
timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging(
InventoryType.UseItem)
else:
timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging(
self.skillId)
if timeSpentRecharging:
skillRechargeProgress = timeSpentRecharging / self.totalRechargeTime
self.totalRechargeTime = base.cr.battleMgr.getModifiedRechargeTime(
localAvatar, self.skillId)
if not self.totalRechargeTime:
self.totalRechargeTime = base.cr.battleMgr.getModifiedRechargeTime(
localAvatar, InventoryType.UseItem)
if timeSpentRecharging:
timeSpentRecharging = skillRechargeProgress * self.totalRechargeTime
localAvatar.skillDiary.modifyTimeSpentRecharging(
self.skillId, timeSpentRecharging)
self.createSkillRingIval()
if playing and timeSpentRecharging:
self.skillRingIval.start(startT=timeSpentRecharging)
def quickGlowImpulse(self):
if not self.glowRing2:
self.loadGlowRing()
self.quickImpulseIval = Sequence(
Func(self.glowRing2.show),
LerpScaleInterval(
self.glowRing2, 0.20000000000000001,
Vec3(0.33000000000000002, 0.33000000000000002,
0.33000000000000002)),
LerpScaleInterval(
self.glowRing2, 0.25,
Vec3(0.20000000000000001, 0.20000000000000001,
0.20000000000000001)), Func(self.glowRing2.hide))
self.quickImpulseIval.start()
def startPowerImpulse(self):
if not self.glowRing:
self.loadGlowRing()
self.glowRing.show()
self.impulseIval = Sequence(
Parallel(
LerpScaleInterval(
self.glowRing, 0.10000000000000001,
Vec3(0.20300000000000001, 0.20300000000000001,
0.20300000000000001)),
LerpColorScaleInterval(self.glowRing,
0.10000000000000001,
Vec4(0.80000000000000004,
0.80000000000000004,
0.80000000000000004,
0.80000000000000004),
Vec4(1.0, 1.0, 1.0,
0.80000000000000004),
blendType='easeInOut')),
LerpScaleInterval(self.glowRing, 0.14999999999999999,
Vec3(0.19, 0.19, 0.19)),
LerpScaleInterval(
self.glowRing, 0.050000000000000003,
Vec3(0.20200000000000001, 0.20200000000000001,
0.20200000000000001)),
Parallel(
LerpScaleInterval(
self.glowRing, 0.029999999999999999,
Vec3(0.20000000000000001, 0.20000000000000001,
0.20000000000000001)),
LerpColorScaleInterval(self.glowRing,
0.40000000000000002,
Vec4(1.0, 1.0, 1.0, 1.0),
blendType='easeInOut')),
Func(self.glowRing.clearColorScale))
self.impulseIval.loop()
def stopPowerImpulse(self):
if self.glowRing:
self.glowRing.hide()
if self.impulseIval:
self.impulseIval.finish()
self.impulseIval = None
def updateRechargeRing(self):
timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging(
self.skillId)
self.totalRechargeTime = base.cr.battleMgr.getModifiedRechargeTime(
localAvatar, self.skillId)
if timeSpentRecharging >= self.totalRechargeTime and not (
self.rechargeFilled):
self.rechargeFilled = 1
if self.skillRingIval:
self.skillRingIval.pause()
self.skillRingIval = None
self.skillRing.meterFaceHalf1.setR(0)
self.skillRing.meterFaceHalf2.setR(180)
self.skillRing.setScale(1.0)
self.skillRing.clearColorScale()
self.setGeomColor(1.0, 1.0, 1.0, 1.0)
self.skillRingIval = Sequence(
Func(base.playSfx, SkillButton.SkillRechargedSound,
volume=0.5),
Parallel(
LerpScaleInterval(self.skillRing, 0.10000000000000001,
Vec3(1.2, 1.2, 1.2)),
LerpColorScaleInterval(self.skillRing,
0.10000000000000001,
Vec4(0.0, 0.75, 0.0, 1.0),
Vec4(1.0, 1.0, 1.0, 1.0),
blendType='easeInOut')),
Func(localAvatar.setDefenceEffect, self.skillId),
LerpScaleInterval(
self.skillRing, 0.20000000000000001,
Vec3(0.90000000000000002, 0.90000000000000002,
0.90000000000000002)),
LerpScaleInterval(
self.skillRing, 0.029999999999999999,
Vec3(1.1000000000000001, 1.1000000000000001,
1.1000000000000001)),
Parallel(
LerpScaleInterval(self.skillRing, 0.029999999999999999,
Vec3(1.0, 1.0, 1.0)),
LerpColorScaleInterval(self.skillRing,
1,
Vec4(1.0, 1.0, 1.0, 1.0),
blendType='easeInOut')),
Func(self.skillRing.clearColorScale))
self.skillRingIval.start()
elif timeSpentRecharging < self.totalRechargeTime:
self.rechargeFilled = 0
self.setGeomColor(0.5, 0.5, 0.5, 1.0)
self.skillRing.update(timeSpentRecharging, self.totalRechargeTime)
def updateSkillId(self, skillId):
self.skillId = skillId
if self.skillButton:
if self.quantityLabel:
self.quantityLabel.detachNode()
self.skillButton.destroy()
if self.showQuantity and not (self.quantity):
geomColor = Vec4(0.5, 0.5, 0.5, 1.0)
else:
geomColor = Vec4(1.0, 1.0, 1.0, 1.0)
if self.showIcon:
asset = WeaponGlobals.getSkillIcon(skillId)
if hasattr(self, '_skillIconName'):
asset = self._skillIconName
geom = SkillButton.SkillIcons.find('**/%s' % asset)
if geom.isEmpty():
geom = SkillButton.SkillIcons.find('**/base')
repId = WeaponGlobals.getSkillReputationCategoryId(self.skillId)
geom_scale = getGeomScale(repId, skillId)
image_color = (1, 1, 1, 1)
else:
geom = (None, )
geom_scale = 0.12
image_color = (0.5, 0.5, 0.5, 0.5)
specialIconId = 0
if self.isBreakAttackSkill:
specialIconId = 1
elif self.isDefenseSkill:
specialIconId = 2
elif skillId == ItemGlobals.getSpecialAttack(
localAvatar.currentWeaponId):
specialIconId = 3
if specialIconId:
something = SkillButton.SpecialIcons[specialIconId][0]
if self.skillRing:
self.skillRing.setupFace(something)
self['image'] = None
elif self.skillRing:
self.skillRing.setupFace()
if self.showRing:
image = None
else:
image = SkillButton.Image
self.skillButton = DirectButton(parent=self,
relief=None,
pos=(0, 0, 0),
text=('', '', self.name),
text_align=TextNode.ACenter,
text_shadow=Vec4(0, 0, 0, 1),
text_scale=0.040000000000000001,
text_fg=Vec4(1, 1, 1, 1),
text_pos=(0.0, 0.089999999999999997),
image=image,
image_scale=0.14999999999999999,
image_color=image_color,
geom=geom,
geom_scale=geom_scale,
geom_color=geomColor,
command=self.callback,
sortOrder=50,
extraArgs=[skillId])
self.skillButton.bind(DGG.ENTER, self.showDetails)
self.skillButton.bind(DGG.EXIT, self.hideDetails)
if self.quantityLabel and not self.quantityLabel.isEmpty():
self.quantityLabel.reparentTo(self.skillButton)
def createHotkey(self, hotkey):
self.hotkeyLabel = DirectLabel(
parent=self,
relief=None,
text=hotkey,
text_font=PiratesGlobals.getPirateBoldOutlineFont(),
text_align=TextNode.ARight,
text_scale=PiratesGuiGlobals.TextScaleLarge,
text_fg=PiratesGuiGlobals.TextFG2,
text_shadow=PiratesGuiGlobals.TextShadow,
textMayChange=0,
pos=(0.070000000000000007, 0, -0.059999999999999998),
sortOrder=70,
state=DGG.DISABLED)
self.hotkeyLabel.flattenLight()
def createLock(self):
if self.lock:
return None
self.lock = DirectFrame(parent=self,
relief=None,
image=SkillButton.SubLock,
image_scale=0.14000000000000001,
image_pos=(0.050000000000000003, 0,
-0.025000000000000001),
sortOrder=99)
if self.showIcon:
self.lock.setColorScale(0.90000000000000002, 0.90000000000000002,
0.90000000000000002, 1)
self.skillButton.setColorScale(0.40000000000000002,
0.40000000000000002,
0.40000000000000002, 1, 1)
else:
self.lock.setColorScale(0.59999999999999998, 0.59999999999999998,
0.59999999999999998, 1, 2)
self.skillButton.clearColorScale()
if self.showHelp:
self.lock.hide()
def createHelpFrame(self, args=None):
if self.helpFrame:
return None
inv = localAvatar.getInventory()
if not inv:
return None
baseRank = max(self.skillRank, 1)
lvlDamageMod = WeaponGlobals.getLevelDamageModifier(
localAvatar.getLevel())
buff = WeaponGlobals.getSkillEffectFlag(self.skillId)
dur = WeaponGlobals.getAttackDuration(self.skillId)
effect = dur + dur * (baseRank - 1) / 4.0
bonus = localAvatar.getSkillRankBonus(self.skillId)
upgradeAmt = WeaponGlobals.getAttackUpgrade(self.skillId)
rank = localAvatar.getSkillRank(self.skillId)
skillBoost = 0
if self.skillId in ItemGlobals.getLinkedSkills(
localAvatar.currentWeaponId):
linkedSkillId = WeaponGlobals.getLinkedSkillId(self.skillId)
skillBoost = ItemGlobals.getWeaponBoosts(
localAvatar.currentWeaponId, linkedSkillId)
skillBoost += ItemGlobals.getWeaponBoosts(
localAvatar.getCurrentCharm(), linkedSkillId)
else:
skillBoost = ItemGlobals.getWeaponBoosts(
localAvatar.currentWeaponId, self.skillId)
skillBoost += ItemGlobals.getWeaponBoosts(
localAvatar.getCurrentCharm(), self.skillId)
manaCost = 0
if WeaponGlobals.getSkillTrack(
self.skillId) != WeaponGlobals.PASSIVE_SKILL_INDEX:
manaCost = WeaponGlobals.getMojoCost(self.skillId)
if manaCost < 0:
amt = localAvatar.getSkillRankBonus(
InventoryType.StaffConservation)
manaCost = min(manaCost - manaCost * amt, 1.0)
damage = 0
loDamage = 0
mpDamage = 0
mpLoDamage = 0
if WeaponGlobals.getSkillTrack(
self.skillId) == WeaponGlobals.TONIC_SKILL_INDEX:
damage = WeaponGlobals.getAttackSelfHP(self.skillId)
elif WeaponGlobals.getSkillTrack(
self.skillId) != WeaponGlobals.PASSIVE_SKILL_INDEX:
mod = (1.0 + bonus) * lvlDamageMod
damage = int(WeaponGlobals.getAttackTargetHP(self.skillId) * mod)
loDamage = damage / 2
mpDamage = int(
WeaponGlobals.getAttackTargetMojo(self.skillId) * mod)
mpLoDamage = mpDamage / 2
try:
skillInfo = PLocalizer.SkillDescriptions.get(self.skillId)
skillTitle = PLocalizer.makeHeadingString(
PLocalizer.InventoryTypeNames.get(self.skillId), 2)
skillType = PLocalizer.makeHeadingString(skillInfo[0], 1)
except:
self.notify.error('Error getting skill info for skillId %s' %
self.skillId)
description = skillInfo[1]
if damage < 0:
description += ' ' + PLocalizer.DealsDamage
elif damage > 0:
if loDamage:
loDamage = 0
description += ' ' + PLocalizer.HealsDamageRange
else:
description += ' ' + PLocalizer.HealsDamage
if mpDamage < 0:
description += ' ' + PLocalizer.DealsMpDamage
effectId = WeaponGlobals.getSkillEffectFlag(self.skillId)
if effectId:
description += ' ' + SkillEffectDescriptions.get(effectId)[0]
if bonus:
if self.skillId == InventoryType.SailBroadsideLeft or self.skillId == InventoryType.SailBroadsideRight:
description += ' ' + PLocalizer.BroadsideDesc
if self.skillId == InventoryType.CannonShoot:
description += ' ' + PLocalizer.CannonShootDesc
if self.skillId == InventoryType.DollAttune:
description += ' ' + PLocalizer.MultiAttuneDesc
if WeaponGlobals.getSkillInterrupt(self.skillId):
description += ' ' + PLocalizer.InterruptDesc
if WeaponGlobals.getSkillUnattune(self.skillId):
description += ' ' + PLocalizer.UnattuneDesc
upgradeInfo = ''
if self.showUpgrade and rank < 5:
if rank > 0:
upgradeInfo = skillInfo[2]
if upgradeInfo == '':
if damage < 0:
upgradeInfo += PLocalizer.UpgradesDamage
elif damage > 0:
upgradeInfo += PLocalizer.UpgradesHealing
if mpDamage < 0:
upgradeInfo += ' ' + PLocalizer.UpgradesMpDamage
if effectId:
entry = SkillEffectDescriptions.get(effectId)
if len(entry) > 1:
if not damage:
upgradeInfo += PLocalizer.UpgradesDuration
else:
upgradeInfo += ' ' + PLocalizer.And
upgradeInfo += ' ' + entry[1]
upgradeInfo += '!'
elif len(upgradeInfo) >= 4:
upgradeInfo = skillInfo[3]
else:
upgradeInfo = PLocalizer.ClickToLearn
elif not self.showIcon:
unlockLevel = RepChart.getSkillUnlockLevel(self.skillId)
if unlockLevel > 0:
upgradeInfo = PLocalizer.UnlocksAtLevel % unlockLevel
if self.skillId in SkillComboReq and SkillComboReq[
self.skillId] and inv.getStackQuantity(self.skillId - 1) < 2:
color = 'red'
if rank == 0:
color = 'red'
upgradeInfo = ''
description += '\n' + color + SkillComboReq[self.skillId] + '.'
skillDesc = skillTitle + '\n' + skillType + '\n\n' + description + '\ngreen' + upgradeInfo
stats = []
if manaCost:
stats.append(abs(manaCost))
if damage and loDamage:
stats.append(abs(loDamage))
stats.append(abs(damage))
elif damage:
stats.append(abs(damage))
if mpDamage:
stats.append(abs(mpLoDamage))
stats.append(abs(mpDamage))
if buff == WeaponGlobals.C_CURSE:
stats.append(WeaponGlobals.CURSED_DAM_AMP * 100)
if buff == WeaponGlobals.C_WEAKEN:
stats.append(WeaponGlobals.WEAKEN_PENALTY * 100)
if effect > 0:
stats.append(effect)
if skillInfo[4]:
if bonus == 0 and upgradeAmt > 0:
if not self.skillId == InventoryType.SailBroadsideLeft and self.skillId == InventoryType.SailBroadsideRight:
pass
if not (self.skillId == InventoryType.CannonShoot):
bonus = upgradeAmt
if upgradeAmt < 1.0 and upgradeAmt > 0:
bonus *= 100
if self.skillId == InventoryType.SailTreasureSense:
bonus /= 2.0
elif self.skillId == InventoryType.CutlassParry:
bonus += WeaponGlobals.getSubtypeParryBonus(
localAvatar.currentWeaponId)
if bonus:
stats.append(abs(bonus))
if self.skillId == InventoryType.DollAttune:
stats.append(rank)
if self.skillRank:
rankText = DirectFrame(parent=self,
relief=None,
text=PLocalizer.makeHeadingString(
PLocalizer.Rank + ' %s' %
(self.skillRank + skillBoost), 2),
text_align=TextNode.ARight,
text_scale=PiratesGuiGlobals.TextScaleSmall,
text_fg=PiratesGuiGlobals.TextFG2,
text_wordwrap=15,
text_shadow=(0, 0, 0, 1),
pos=(0.45000000000000001, 0, 0),
textMayChange=1,
sortOrder=92,
state=DGG.DISABLED)
stats = [stat + 0.01 for stat in stats]
try:
pass
except TypeError:
self.notify.error('Error formatting skillDesc(%s): %s' %
(self.skillId, stats))
helpText = DirectFrame(parent=self,
relief=None,
text=skillDesc % stats,
text_align=TextNode.ALeft,
text_scale=PiratesGuiGlobals.TextScaleSmall,
text_fg=PiratesGuiGlobals.TextFG2,
text_wordwrap=17,
textMayChange=1,
state=DGG.DISABLED,
sortOrder=91)
height = -(helpText.getHeight() + 0.01)
if self.lock:
height = height - 0.040000000000000001
width = 0.55000000000000004
self.helpFrame = BorderFrame(parent=self,
state=DGG.DISABLED,
frameSize=(-0.040000000000000001, width,
height, 0.050000000000000003),
pos=(0, 0, -0.12),
sortOrder=90)
self.helpFrame.setBin('gui-popup', 0)
helpText.reparentTo(self.helpFrame)
if self.skillRank:
rankText.reparentTo(self.helpFrame)
if self.lock:
self.lockedFrame = DirectFrame(
parent=self.helpFrame,
relief=None,
pos=(0.087999999999999995, 0, height + 0.029999999999999999),
image=SkillButton.SubLock,
image_scale=0.13,
image_pos=(-0.055, 0, 0.012999999999999999),
text=PLocalizer.VR_AuthAccess,
text_scale=PiratesGuiGlobals.TextScaleSmall,
text_align=TextNode.ALeft,
text_fg=PiratesGuiGlobals.TextFG13)
self.notify.debug('locked!')
pos = self.helpFrame.getPos(aspect2d)
x = min(pos[0], base.a2dRight - width)
z = max(pos[2], base.a2dBottom - height)
self.helpFrame.setPos(aspect2d, x, 0, z)
def showDetails(self, event):
if self.showHelp:
self.createHelpFrame()
if self.showRing:
self.skillRing.rollover(True)
def hideDetails(self, event):
if self.helpFrame:
self.helpFrame.destroy()
self.helpFrame = None
if self.showRing:
self.skillRing.rollover(False)
def updateQuantity(self, quantity):
self.quantity = quantity
if not self.showQuantity:
return None
if quantity == WeaponGlobals.INF_QUANT:
text = ''
elif self.assocAmmo:
assocQuantity = 0
inv = localAvatar.getInventory()
if inv:
for ammoId in self.assocAmmo:
assocQuantity += inv.getItemQuantity(
self.getAmmoCat(), ammoId)
if quantity != assocQuantity:
text = '%s' % assocQuantity
else:
text = 'x%s' % quantity
else:
text = 'x%s' % quantity
if self.quantityLabel and not self.quantityLabel.isEmpty():
self.quantityLabel['text'] = text
else:
self.quantityLabel = DirectLabel(
parent=NodePath(),
relief=None,
state=DGG.DISABLED,
text=text,
frameColor=(0, 0, 0, 1),
frameSize=(-0.01, 0.02, -0.01, 0.025000000000000001),
text_scale=PiratesGuiGlobals.TextScaleLarge,
text_align=TextNode.ACenter,
text_fg=PiratesGuiGlobals.TextFG2,
text_shadow=PiratesGuiGlobals.TextShadow,
text_wordwrap=11,
pos=(0.029999999999999999, 0.0, 0.029999999999999999),
text_font=PiratesGlobals.getPirateBoldOutlineFont(),
sortOrder=60)
self.quantityLabel.flattenLight()
self.quantityLabel.reparentTo(self)
if self.skillButton and not self.skillButton.isEmpty():
self.quantityLabel.reparentTo(self.skillButton)
def getAmmoCat(self):
pass
def startRecharge(self):
if not self.showRing:
return None
if self.isBreakAttackSkill:
self.setGeomColor(0.5, 0.5, 0.5, 1.0)
self.updateRechargeRing()
return None
if self.skillRingIval.isPlaying():
self.createSkillRingIval()
self.skillRingIval.start()
def stopRecharge(self):
if self.showRing:
if self.isBreakAttackSkill:
self.setGeomColor(0.5, 0.5, 0.5, 1.0)
self.updateRechargeRing()
return None
if self.skillRingIval.isPlaying():
self.skillRingIval.pause()
def setGeomColor(self, r, g, b, a):
self.skillButton['geom_color'] = Vec4(r, g, b, a)
def setRingColor(self, color):
self.skillRing.meterFaceHalf1.setColor(color[0], color[1], color[2],
color[3], 100)
self.skillRing.meterFaceHalf2.setColor(color[0], color[1], color[2],
color[3], 100)
def setShowUpgrade(self, show):
if self.showUpgrade != show:
self.showUpgrade = show
if self.helpFrame:
self.helpFrame.destroy()
self.helpFrame = None
self.showDetails(None)
def setShowIcon(self, show):
if self.showIcon != show:
self.showIcon = show
self.updateSkillId(self.skillId)
if self.helpFrame:
self.helpFrame.destroy()
self.helpFrame = None
def setShowLock(self, show):
if self.showLock != show:
self.showLock = show
if show:
self.createLock()
elif self.lock:
self.lock.destroy()
self.lock = None
self.skillButton.clearColorScale()
def destroy(self):
self.callback = None
if self.skillRingIval:
self.skillRingIval.pause()
self.skillRingIval = None
if self.quantityLabel:
self.quantityLabel.destroy()
self.quantityLabel = None
if self.impulseIval:
self.impulseIval.pause()
self.impulseIval = None
if self.quickImpulseIval:
self.quickImpulseIval.pause()
self.quickImpulseIval = None
self.ignoreAll()
DirectFrame.destroy(self)
class RepairGameButton(GuiButton):
def __init__(self, parent, **kw):
optiondefs = (('nodePath', None, None), ('image_scale', (1.0, 1.0, 1.0), None))
self.defineoptions(kw, optiondefs)
GuiButton.__init__(self, parent)
self.initialiseoptions(RepairGameButton)
self.disabledStateNode = self.stateNodePath[3].getChild(0)
self.downStateNode = self.stateNodePath[1].getChild(0)
self.overStateNode = self.stateNodePath[2].getChild(0)
self.inProgress = False
self._initGUI()
def _initGUI(self):
self.setBin('fixed', 33)
mainGui = loader.loadModel('models/gui/gui_main')
gui = loader.loadModel('models/gui/toplevel_gui')
self.checkMark = gui.find('**/generic_check')
self.checkMark.reparentTo(self)
self.checkMark.stash()
self.checkMark.setScale(1.0)
self.checkMark.setColorScale(0.0, 1.0, 0.0, 1.0)
self.checkMark.setPos(0.02, 0.0, 0.02)
self.checkMark.setBin('fixed', 34)
self.skillRing = DialMeter(self, wantCover = False, dangerRatio = 0.0, meterColor = Vec4(0.90000000000000002, 0.90000000000000002, 0.10000000000000001, 1.0), baseColor = Vec4(0.14999999999999999, 0.070000000000000007, 0.029999999999999999, 1.0), completeColor = Vec4(0.10000000000000001, 0.90000000000000002, 0.10000000000000001, 1.0))
self.skillRing.reparentTo(self)
self.skillRing.setScale(0.28499999999999998, 0.29999999999999999, 0.26500000000000001)
self.skillRing.setBin('fixed', 32)
self.skillGlow = OnscreenImage(parent = self, image = mainGui.find('**/icon_glow'), scale = (1.0, 1.0, 1.0), color = (1.0, 1.0, 0.59999999999999998, 1.0))
self.glow = OnscreenImage(parent = self, image = mainGui.find('**/icon_glow'), scale = (1.0, 1.0, 1.0), color = (1.0, 1.0, 0.59999999999999998, 1.0))
self.skillGlow.reparentTo(self)
self.skillGlow.setBin('fixed', 31)
self.skillGlow.stash()
self.pirateNameBox = None
self.pirateNameLabel = None
def showGlow(self):
self.inProgress = False
if self.pirateNameLabel == None and self.checkMark.isStashed():
self.skillGlow.unstash()
def hideGlow(self):
self.inProgress = True
self.skillGlow.stash()
def setProgress(self, percent):
self.skillGlow.stash()
ratio = max(0.0, percent / 100.0)
if ratio >= 1.0:
if self.checkMark.isStashed():
self.checkMark.unstash()
elif not self.checkMark.isStashed():
self.checkMark.stash()
if self.pirateNameLabel == None and not (self.inProgress):
self.skillGlow.unstash()
self.skillRing.update(ratio, 1.0)
self.skillRing.wrtReparentTo(self.getParent())
self.reparentTo(self.getParent())
def updatePirateNameBox(self, pirateName):
if self.pirateNameLabel != None and self.pirateNameLabel['text'] != pirateName:
if self.pirateNameBox:
self.pirateNameBox.destroy()
if self.pirateNameLabel:
self.pirateNameLabel.destroy()
self.pirateNameBox = None
self.pirateNameLabel = None
if pirateName != '':
if self.pirateNameBox:
pass
if not (self.pirateNameLabel['text'] == pirateName):
self.createPirateNameBox(pirateName)
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)
class InventoryItemGui(InventoryListItem):
width = PiratesGuiGlobals.InventoryItemGuiWidth
height = PiratesGuiGlobals.InventoryItemGuiHeight
available = True
def __init__(self, data, trade = 0, buy = 0, sell = 0, use = 0, weapon = 0, isDisabled = 0, **kw):
if (trade and buy and sell and use or weapon) and not isDisabled:
buttonRelief = DGG.RAISED
buttonState = DGG.NORMAL
else:
buttonRelief = DGG.RIDGE
buttonState = DGG.DISABLED
self.loadGui()
optiondefs = (('relief', None, None), ('state', buttonState, None), ('frameSize', (0, self.width, 0, self.height), None), ('image', InventoryItemGui.genericButton, None), ('image_scale', (0.54000000000000004, 1, 0.41999999999999998), None), ('image_pos', (0.26000000000000001, 0, 0.080000000000000002), None), ('pressEffect', 0, None), ('command', self.sendEvents, None))
self.defineoptions(kw, optiondefs)
InventoryListItem.__init__(self, data, trade = trade, buy = buy, sell = sell, use = use, weapon = weapon, isDisabled = isDisabled, width = self.width, height = self.height)
self.initialiseoptions(InventoryItemGui)
self.createGui()
self.draggable = abs(self.buy) + abs(self.sell) + abs(self.use) + abs(self.trade) - 1
if self.draggable > 0:
self.bind(DGG.B1PRESS, self.dragStart)
self.bind(DGG.B1RELEASE, self.dragStop)
self.bind(DGG.B2PRESS, self.dragStart)
self.bind(DGG.B2RELEASE, self.dragStop)
self.bind(DGG.B3PRESS, self.dragStart)
self.bind(DGG.B3RELEASE, self.dragStop)
if self.weapon:
self.bind(DGG.B1PRESS, self.equipWeapon)
self.bind(DGG.B2PRESS, self.equipWeapon)
self.bind(DGG.B3PRESS, self.equipWeapon)
self.helpFrame = None
self.cm = CardMaker('itemCard')
self.cm.setFrame(-0.29999999999999999, 0.29999999999999999, -0.089999999999999997, 0.089999999999999997)
self.buffer = None
self.lens = PerspectiveLens()
self.lens.setNear(0.5)
self.lens.setAspectRatio(0.59999999999999998 / 0.17999999999999999)
self.realItem = None
self.itemCard = None
self.portraitSceneGraph = NodePath('PortraitSceneGraph')
detailGui = loader.loadModel('models/gui/gui_card_detail')
self.bg = detailGui.find('**/color')
self.bg.setScale(4)
self.bg.setPos(0, 17, -6.2999999999999998)
self.glow = detailGui.find('**/glow')
self.glow.setScale(3)
self.glow.setPos(0, 17, -6.2999999999999998)
self.glow.setColor(1, 1, 1, 0.80000000000000004)
self.setBin('gui-fixed', 1)
self.accept('open_main_window', self.createBuffer)
self.accept('aspectRatioChanged', self.createBuffer)
self.accept('close_main_window', self.destroyBuffer)
self.bind(DGG.ENTER, self.showDetails)
self.bind(DGG.EXIT, self.hideDetails)
def loadGui(self):
if InventoryItemGui.guiLoaded:
return None
InventoryListItem.loadGui(self)
InventoryItemGui.genericButton = (InventoryListItem.topGui.find('**/generic_button'), InventoryListItem.topGui.find('**/generic_button_down'), InventoryListItem.topGui.find('**/generic_button_over'), InventoryListItem.topGui.find('**/generic_button_disabled'))
def createGui(self):
itemId = self.data[0]
self.nameTag = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = self.name, text_scale = PiratesGuiGlobals.TextScaleSmall * PLocalizer.getHeadingScale(2), text_align = TextNode.ALeft, text_fg = PiratesGuiGlobals.TextFG1, text_shadow = PiratesGuiGlobals.TextShadow, pos = (0.16, 0, 0.105), text_font = PiratesGlobals.getInterfaceFont())
if itemId in range(InventoryType.begin_PistolPouches, InventoryType.end_PistolPouches):
self.itemTypeFormatted = PLocalizer.makeHeadingString(PLocalizer.InventoryItemClassNames.get(ItemType.PISTOL), 1)
elif itemId in range(InventoryType.begin_DaggerPouches, InventoryType.end_DaggerPouches):
self.itemTypeFormatted = PLocalizer.makeHeadingString(PLocalizer.InventoryItemClassNames.get(ItemType.DAGGER), 1)
elif itemId in range(InventoryType.begin_GrenadePouches, InventoryType.end_GrenadePouches):
self.itemTypeFormatted = PLocalizer.makeHeadingString(PLocalizer.GrenadeShort, 1)
elif itemId in range(InventoryType.begin_CannonPouches, InventoryType.end_CannonPouches):
self.itemTypeFormatted = PLocalizer.makeHeadingString(PLocalizer.ShipCannonShort, 1)
else:
self.itemTypeFormatted = PLocalizer.makeHeadingString(self.itemType, 1)
self.itemTypeName = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = self.itemTypeFormatted, text_scale = PiratesGuiGlobals.TextScaleSmall, text_align = TextNode.ALeft, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_font = PiratesGlobals.getInterfaceFont(), pos = (0.16, 0, 0.065000000000000002))
self.miscText = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = '', text_scale = PiratesGuiGlobals.TextScaleSmall, text_align = TextNode.ALeft, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_wordwrap = 11, pos = (0.16, 0, 0.025000000000000001))
if self.minLvl > 0:
repId = WeaponGlobals.getRepId(itemId)
if repId:
self.checkLevel(repId, self.minLvl)
self.checkFreebooter(itemId, base.localAvatar.getDoId())
trainingReq = EconomyGlobals.getItemTrainingReq(itemId)
if trainingReq:
self.checkTrainingReq(trainingReq)
if EconomyGlobals.getItemCategory(itemId) == ItemType.AMMO:
skillId = WeaponGlobals.getSkillIdForAmmoSkillId(itemId)
self.checkSkillReq(skillId)
self.checkInfamyReq(itemId)
if self.buy:
self.checkPlayerInventory(itemId)
self.costText = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, image = InventoryListItem.coinImage, image_scale = 0.12, image_pos = Vec3(-0.01, 0, 0.01), text = str(self.price), text_scale = PiratesGuiGlobals.TextScaleSmall, text_align = TextNode.ARight, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_wordwrap = 11, text_pos = (-0.029999999999999999, 0, 0), pos = (self.width - 0.035000000000000003, 0, 0.065000000000000002), text_font = PiratesGlobals.getInterfaceFont())
if self.quantity and self.quantity > 1:
self.quantityLabel = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = str(self.quantity), frameColor = (0, 0, 0, 1), frameSize = (-0.01, 0.02, -0.01, 0.025000000000000001), text_scale = 0.0275, text_align = TextNode.ACenter, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_wordwrap = 11, pos = (0.02, 0, 0.025000000000000001), text_font = PiratesGlobals.getPirateBoldOutlineFont())
geomParams = InventoryItemGui.getGeomParams(itemId)
self.picture = DirectFrame(parent = self, relief = None, state = DGG.DISABLED, geom = geomParams['geom'], geom_pos = geomParams['geom_pos'], geom_scale = geomParams['geom_scale'], pos = (0.01, 0, 0.01))
self.flattenStrong()
def getGeomParams(itemId):
geomParams = { }
itemType = EconomyGlobals.getItemType(itemId)
if itemType <= ItemType.WAND or itemType == ItemType.POTION:
if itemType == ItemType.POTION:
geomParams['geom'] = InventoryItemGui.skillIcons.find('**/%s' % ItemGlobals.getIcon(itemId))
else:
itemType = ItemGlobals.getType(itemId)
if ItemGlobals.getIcon(itemId):
geomParams['geom'] = InventoryItemGui.weaponIcons.find('**/%s' % ItemGlobals.getIcon(itemId))
geomParams['geom_scale'] = 0.11
geomParams['geom_pos'] = (0.080000000000000002, 0, 0.068000000000000005)
else:
itemClass = EconomyGlobals.getItemCategory(itemId)
itemType = EconomyGlobals.getItemType(itemId)
if itemType == ItemType.FISHING_ROD or itemType == ItemType.FISHING_LURE:
asset = EconomyGlobals.getItemIcons(itemId)
if asset:
geomParams['geom'] = InventoryItemGui.fishingIcons.find('**/%s*' % asset)
geomParams['geom_scale'] = 0.11
geomParams['geom_pos'] = (0.080000000000000002, 0, 0.068000000000000005)
elif itemClass == ItemType.WEAPON and itemClass == ItemType.POUCH or itemClass == ItemType.AMMO:
asset = EconomyGlobals.getItemIcons(itemId)
if asset:
geomParams['geom'] = InventoryItemGui.weaponIcons.find('**/%s*' % asset)
geomParams['geom_scale'] = 0.11
geomParams['geom_pos'] = (0.080000000000000002, 0, 0.068000000000000005)
elif itemClass == ItemType.CONSUMABLE:
asset = EconomyGlobals.getItemIcons(itemId)
if asset:
geomParams['geom'] = InventoryItemGui.skillIcons.find('**/%s*' % asset)
geomParams['geom_scale'] = 0.11
geomParams['geom_pos'] = (0.080000000000000002, 0, 0.068000000000000005)
if not InventoryType.begin_WeaponCannonAmmo <= itemId or itemId <= InventoryType.end_WeaponCannonAmmo:
if (InventoryType.begin_WeaponPistolAmmo <= itemId or itemId <= InventoryType.end_WeaponGrenadeAmmo or InventoryType.begin_WeaponDaggerAmmo <= itemId) and itemId <= InventoryType.end_WeaponDaggerAmmo:
skillId = WeaponGlobals.getSkillIdForAmmoSkillId(itemId)
if skillId:
asset = WeaponGlobals.getSkillIcon(skillId)
if asset:
geomParams['geom'] = InventoryListItem.skillIcons.find('**/%s' % asset)
geomParams['geom_scale'] = 0.14999999999999999
geomParams['geom_pos'] = (0.069000000000000006, 0, 0.069000000000000006)
elif InventoryType.SmallBottle <= itemId and itemId <= InventoryType.LargeBottle:
geomParams['geom'] = InventoryListItem.topGui.find('**/main_gui_ship_bottle')
geomParams['geom_scale'] = 0.10000000000000001
geomParams['geom_pos'] = (0.069000000000000006, 0, 0.069000000000000006)
return geomParams
getGeomParams = staticmethod(getGeomParams)
def checkFreebooter(self, itemId, avId):
if ItemGlobals.getRarity(itemId) == ItemGlobals.CRUDE:
return None
if not InventoryType.begin_WeaponCannonAmmo <= itemId or itemId <= InventoryType.end_WeaponCannonAmmo:
if (InventoryType.begin_WeaponPistolAmmo <= itemId or itemId <= InventoryType.end_WeaponGrenadeAmmo or InventoryType.begin_WeaponDaggerAmmo <= itemId) and itemId <= InventoryType.end_WeaponDaggerAmmo:
return None
if itemId in [
InventoryType.RegularLure]:
return None
if not Freebooter.getPaidStatus(avId):
self.highlightRed(PLocalizer.FreebooterDisallow)
def checkLevel(self, repId, minLvl):
inv = localAvatar.getInventory()
if inv:
repAmt = inv.getAccumulator(repId)
if minLvl > ReputationGlobals.getLevelFromTotalReputation(repId, repAmt)[0]:
self.highlightRed(PLocalizer.LevelRequirement % self.minLvl + ' ' + PLocalizer.InventoryItemClassNames.get(EconomyGlobals.getItemType(self.data[0])))
def checkTrainingReq(self, trainingReq):
inv = localAvatar.getInventory()
if inv:
amt = inv.getStackQuantity(trainingReq)
if not amt:
self.highlightRed(PLocalizer.TrainingRequirement)
def checkSkillReq(self, skillId):
if skillId in range(InventoryType.begin_FishingLures, InventoryType.end_FishingLures):
return None
if skillId:
if base.localAvatar.getSkillQuantity(skillId) < 2:
skillName = PLocalizer.getInventoryTypeName(skillId)
self.highlightRed(PLocalizer.SkillRequirement % skillName)
def checkInfamyReq(self, itemId):
landInfamyLevel = ItemGlobals.getLandInfamyRequirement(itemId)
seaInfamyLevel = ItemGlobals.getSeaInfamyRequirement(itemId)
if landInfamyLevel and TitleGlobals.getRank(TitleGlobals.LandPVPTitle, localAvatar.getInfamyLand()) < landInfamyLevel:
self.highlightRed(PLocalizer.LandInfamyRequirement % landInfamyLevel)
if seaInfamyLevel and TitleGlobals.getRank(TitleGlobals.ShipPVPTitle, localAvatar.getInfamySea()) < seaInfamyLevel:
self.highlightRed(PLocalizer.SeaInfamyRequirement % seaInfamyLevel)
def checkPlayerInventory(self, itemId, extraQty = 0):
if self.available:
itemCategory = EconomyGlobals.getItemCategory(itemId)
inventory = base.localAvatar.getInventory()
currStock = inventory.getStackQuantity(itemId)
currStockLimit = inventory.getStackLimit(itemId)
if itemCategory == ItemType.AMMO or itemCategory == ItemType.CONSUMABLE:
if currStock + extraQty >= currStockLimit and currStockLimit > 0:
self.highlightGreen(PLocalizer.InventoryFull % currStockLimit)
else:
self.highlightBox(PLocalizer.InventoryCurrent % (currStock + extraQty, currStockLimit), Vec4(1, 1, 1, 1), PiratesGuiGlobals.TextFG2)
elif itemCategory == ItemType.WEAPON:
if currStock >= 1:
self.highlightGreen(PLocalizer.InventoryOwned)
else:
inv = base.localAvatar.getInventory()
if inv is None:
return None
itemRep = WeaponGlobals.getRepId(itemId)
if itemRep == InventoryType.CutlassRep:
options = [
InventoryType.CutlassWeaponL1,
InventoryType.CutlassWeaponL2,
InventoryType.CutlassWeaponL3,
InventoryType.CutlassWeaponL4,
InventoryType.CutlassWeaponL5,
InventoryType.CutlassWeaponL6]
elif itemRep == InventoryType.PistolRep:
options = [
InventoryType.PistolWeaponL1,
InventoryType.PistolWeaponL2,
InventoryType.PistolWeaponL3,
InventoryType.PistolWeaponL4,
InventoryType.PistolWeaponL5,
InventoryType.PistolWeaponL6]
elif itemRep == InventoryType.DaggerRep:
options = [
InventoryType.DaggerWeaponL1,
InventoryType.DaggerWeaponL2,
InventoryType.DaggerWeaponL3,
InventoryType.DaggerWeaponL4,
InventoryType.DaggerWeaponL5,
InventoryType.DaggerWeaponL6]
elif itemRep == InventoryType.GrenadeRep:
options = [
InventoryType.GrenadeWeaponL1,
InventoryType.GrenadeWeaponL2,
InventoryType.GrenadeWeaponL3,
InventoryType.GrenadeWeaponL4,
InventoryType.GrenadeWeaponL5,
InventoryType.GrenadeWeaponL6]
elif itemRep == InventoryType.DollRep:
options = [
InventoryType.DollWeaponL1,
InventoryType.DollWeaponL2,
InventoryType.DollWeaponL3,
InventoryType.DollWeaponL4,
InventoryType.DollWeaponL5,
InventoryType.DollWeaponL6]
elif itemRep == InventoryType.WandRep:
options = [
InventoryType.WandWeaponL1,
InventoryType.WandWeaponL2,
InventoryType.WandWeaponL3,
InventoryType.WandWeaponL4,
InventoryType.WandWeaponL5,
InventoryType.WandWeaponL6]
else:
return None
for idx in range(len(options)):
optionId = options[idx]
if optionId == itemId:
currIdx = idx
for weaponId in options[currIdx:]:
if weaponId == itemId:
continue
stackAmt = inv.getStackQuantity(weaponId)
if stackAmt >= 1:
self.highlightRed(PLocalizer.InventoryLowLevel)
return None
continue
elif itemCategory == ItemType.POUCH:
inv = base.localAvatar.getInventory()
if currStock >= 1:
self.highlightGreen(PLocalizer.InventoryOwned)
else:
pistolPouches = [
InventoryType.PistolPouchL1,
InventoryType.PistolPouchL2,
InventoryType.PistolPouchL3]
daggerPouches = [
InventoryType.DaggerPouchL1,
InventoryType.DaggerPouchL2,
InventoryType.DaggerPouchL3]
grenadePouches = [
InventoryType.GrenadePouchL1,
InventoryType.GrenadePouchL2,
InventoryType.GrenadePouchL3]
cannonPouches = [
InventoryType.CannonPouchL1,
InventoryType.CannonPouchL2,
InventoryType.CannonPouchL3]
if itemId in pistolPouches:
pouchSet = pistolPouches
elif itemId in daggerPouches:
pouchSet = daggerPouches
elif itemId in grenadePouches:
pouchSet = grenadePouches
elif itemId in cannonPouches:
pouchSet = cannonPouches
else:
pouchSet = []
for pouchIdx in range(len(pouchSet)):
if pouchSet[pouchIdx] == itemId and pouchIdx + 1 < len(pouchSet):
for higherPouchIdx in range(pouchIdx + 1, len(pouchSet)):
stackAmt = inv.getStackQuantity(pouchSet[higherPouchIdx])
if stackAmt >= 1:
self.highlightRed(PLocalizer.InventoryLowLevel)
return None
continue
def highlightRed(self, text = ''):
self['state'] = DGG.DISABLED
self['image_color'] = Vec4(0.55000000000000004, 0.55000000000000004, 0.5, 1)
self.available = False
self.highlightBox(text, Vec4(0.75, 0.5, 0.5, 1), PiratesGuiGlobals.TextFG6)
def highlightGreen(self, text = ''):
self.highlightBox(text, Vec4(0.5, 0.75, 0.5, 1), PiratesGuiGlobals.TextFG4)
def highlightBox(self, text, image_color, text_fg):
self.miscText['text_fg'] = text_fg
if text != '':
self.miscText['text'] = text
def enable(self):
if self.available:
self['state'] = DGG.NORMAL
def disable(self):
if self.available:
self['state'] = DGG.DISABLED
def createHelpbox(self, args = None):
if self.helpFrame:
return None
itemType = EconomyGlobals.getItemType(self.data[0])
if itemType <= ItemType.WAND or itemType == ItemType.POTION:
itemId = self.data[0]
self.helpFrame = DirectFrame(parent = aspect2d, relief = None, state = DGG.DISABLED, sortOrder = 1)
detailGui = loader.loadModel('models/gui/gui_card_detail')
topGui = loader.loadModel('models/gui/toplevel_gui')
coinImage = topGui.find('**/treasure_w_coin*')
self.SkillIcons = loader.loadModel('models/textureCards/skillIcons')
self.BuffIcons = loader.loadModel('models/textureCards/buff_icons')
border = self.SkillIcons.find('**/base')
halfWidth = 0.29999999999999999
halfHeight = 0.20000000000000001
textScale = PiratesGuiGlobals.TextScaleMed
titleScale = PiratesGuiGlobals.TextScaleTitleSmall
titleNameScale = PiratesGuiGlobals.TextScaleExtraLarge
subtitleScale = PiratesGuiGlobals.TextScaleMed
iconScalar = 1.5
borderScaler = 0.25
splitHeight = 0.01
vMargin = 0.029999999999999999
runningVertPosition = 0.29999999999999999
runningSize = 0.0
labels = []
titleColor = PiratesGuiGlobals.TextFG6
itemColor = 'itemRed'
rarity = ItemGlobals.getRarity(itemId)
rarityText = PLocalizer.getItemRarityName(rarity)
subtypeText = PLocalizer.getItemSubtypeName(ItemGlobals.getSubtype(itemId))
if rarity == ItemGlobals.CRUDE:
titleColor = PiratesGuiGlobals.TextFG24
itemColor = 'itemBrown'
elif rarity == ItemGlobals.COMMON:
titleColor = PiratesGuiGlobals.TextFG13
itemColor = 'itemYellow'
elif rarity == ItemGlobals.RARE:
titleColor = PiratesGuiGlobals.TextFG4
itemColor = 'itemGreen'
elif rarity == ItemGlobals.FAMED:
titleColor = PiratesGuiGlobals.TextFG5
itemColor = 'itemBlue'
titleLabel = DirectLabel(parent = self, relief = None, text = PLocalizer.getItemName(itemId), text_scale = titleNameScale, text_fg = titleColor, text_shadow = PiratesGuiGlobals.TextShadow, text_align = TextNode.ACenter, pos = (0.0, 0.0, runningVertPosition), text_pos = (0.0, -textScale))
self.bg.setColor(titleColor)
tHeight = 0.070000000000000007
titleLabel.setZ(runningVertPosition)
runningVertPosition -= tHeight
runningSize += tHeight
labels.append(titleLabel)
subtitleLabel = DirectLabel(parent = self, relief = None, text = '\x01slant\x01%s %s\x02' % (rarityText, subtypeText), text_scale = subtitleScale, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_align = TextNode.ACenter, pos = (0.0, 0.0, runningVertPosition), text_pos = (0.0, -textScale))
subtHeight = 0.050000000000000003
subtitleLabel.setZ(subtHeight * 0.5 + runningVertPosition)
runningVertPosition -= subtHeight
runningSize += subtHeight
labels.append(subtitleLabel)
itemType = ItemGlobals.getType(itemId)
itemSubtype = ItemGlobals.getSubtype(itemId)
model = ItemGlobals.getModel(itemId)
if model:
if itemType == ItemGlobals.GRENADE:
self.realItem = loader.loadModel('models/ammunition/' + model)
elif itemType == ItemGlobals.POTION:
self.realItem = loader.loadModel('models/inventory/' + model)
else:
self.realItem = loader.loadModel('models/handheld/' + model)
if self.realItem:
spinBlur = self.realItem.find('**/motion_blur')
if spinBlur:
spinBlur.hide()
if itemSubtype == ItemGlobals.MUSKET:
bayonetPart = self.realItem.find('**/bayonet')
if bayonetPart:
bayonetPart.stash()
posHpr = ItemGlobals.getModelPosHpr(model)
if posHpr:
self.realItem.setPos(posHpr[0], posHpr[1], posHpr[2])
self.realItem.setHpr(posHpr[3], posHpr[4], posHpr[5])
elif itemType == ItemGlobals.SWORD:
self.realItem.setPos(-1.5, 3.0, -0.29999999999999999)
self.realItem.setHpr(90, 170, -90)
elif itemSubtype in (ItemGlobals.MUSKET, ItemGlobals.BAYONET):
self.realItem.setPos(-1.2, 3.0, -0.10000000000000001)
self.realItem.setHpr(0, 135, 10)
elif itemSubtype == ItemGlobals.BLUNDERBUSS:
self.realItem.setPos(-0.29999999999999999, 2.0, 0.0)
self.realItem.setHpr(0, 90, 0)
elif itemType == ItemGlobals.GUN:
self.realItem.setPos(-0.5, 2.0, -0.20000000000000001)
self.realItem.setHpr(0, 90, 0)
elif itemType == ItemGlobals.DOLL:
self.realItem.setPos(0.0, 1.8999999999999999, -0.10000000000000001)
self.realItem.setHpr(0, 90, 180)
elif itemType == ItemGlobals.DAGGER:
self.realItem.setPos(-1.0, 2.0, -0.29999999999999999)
self.realItem.setHpr(90, 170, -90)
elif itemType == ItemGlobals.GRENADE:
self.realItem.setPos(0.0, 3.5, -0.20000000000000001)
self.realItem.setHpr(0, 0, 0)
elif itemType == ItemGlobals.STAFF:
self.realItem.setPos(-0.40000000000000002, 3.0, -0.29999999999999999)
self.realItem.setHpr(-90, 15, -90)
elif itemSubtype == ItemGlobals.RAM:
self.realItem.setPos(-1.5, 1.5, -0.59999999999999998)
self.realItem.setHpr(70, 160, -90)
elif itemType == ItemGlobals.POTION:
self.realItem.setPos(0.0, 2.5, -0.40000000000000002)
self.realItem.setHpr(45, 0, 0)
else:
self.realItem.setPos(0.0, 1.5, -0.059999999999999998)
self.realItem.setHpr(0, 90, 0)
self.realItem.reparentTo(self.portraitSceneGraph)
iHeight = 0.17499999999999999
self.createBuffer()
self.itemCard.setZ(runningVertPosition - 0.059999999999999998)
runningVertPosition -= iHeight
runningSize += iHeight
labels.append(self.itemCard)
goldLabel = DirectLabel(parent = self, relief = None, image = coinImage, image_scale = 0.12, image_pos = Vec3(0.025000000000000001, 0, -0.02), text = str(int(ItemGlobals.getGoldCost(itemId) * ItemGlobals.GOLD_SALE_MULTIPLIER)), text_scale = subtitleScale, text_align = TextNode.ARight, text_fg = PiratesGuiGlobals.TextFG1, text_shadow = PiratesGuiGlobals.TextShadow, pos = (halfWidth - 0.050000000000000003, 0.0, runningVertPosition + 0.080000000000000002), text_pos = (0.0, -textScale))
labels.append(goldLabel)
infoText = PLocalizer.ItemAttackStrength % '\x01%s\x01%s\x02' % (itemColor, ItemGlobals.getPower(itemId))
if itemType == ItemGlobals.GUN:
infoText += ' %s' % PLocalizer.ItemBarrels % '\x01%s\x01%s\x02' % (itemColor, ItemGlobals.getBarrels(itemId))
infoText += ' %s' % PLocalizer.ItemRangeStrength % '\x01%s\x01%s\x02' % (itemColor, PLocalizer.getItemRangeName(WeaponGlobals.getRange(itemId)))
if itemType != ItemGlobals.POTION:
infoLabel = DirectLabel(parent = self, relief = None, text = infoText, text_scale = textScale, text_align = TextNode.ACenter, pos = (0.0, 0.0, runningVertPosition), text_pos = (0.0, -textScale))
iHeight = 0.080000000000000002
runningVertPosition -= iHeight
runningSize += iHeight
labels.append(infoLabel)
specialAttack = None
if itemType != ItemGlobals.POTION:
specialAttack = ItemGlobals.getSpecialAttack(itemId)
if specialAttack:
attackIcon = self.SkillIcons.find('**/%s' % WeaponGlobals.getSkillIcon(specialAttack))
specialAttackNameLabel = DirectLabel(parent = self, relief = None, image = border, image_scale = 0.10000000000000001, geom = attackIcon, geom_scale = 0.10000000000000001, image_pos = (-0.070000000000000007, 0.0, -0.050000000000000003), geom_pos = (-0.070000000000000007, 0.0, -0.050000000000000003), text = PLocalizer.getInventoryTypeName(specialAttack), text_scale = PiratesGuiGlobals.TextScaleLarge, text_wordwrap = halfWidth * 2.0 * (0.90000000000000002 / titleScale), text_align = TextNode.ALeft, text_fg = titleColor, text_font = PiratesGlobals.getInterfaceOutlineFont(), text_shadow = PiratesGuiGlobals.TextShadow, pos = (-halfWidth + 0.12 + textScale * 0.5, 0.0, runningVertPosition), text_pos = (0.0, -textScale))
specialAttackRankLabel = DirectLabel(parent = self, relief = None, text = PLocalizer.ItemRank % ItemGlobals.getSpecialAttackRank(itemId), text_scale = textScale, text_wordwrap = halfWidth * 2.0 * (0.90000000000000002 / titleScale), text_align = TextNode.ARight, pos = (halfWidth - textScale * 0.5, 0.0, runningVertPosition), text_pos = (0.0, -textScale))
specialAttackType = WeaponGlobals.getSkillTrack(specialAttack)
if specialAttackType == WeaponGlobals.BREAK_ATTACK_SKILL_INDEX:
specialAttackTypeText = PLocalizer.BreakAttackSkill
elif specialAttackType == WeaponGlobals.DEFENSE_SKILL_INDEX:
specialAttackTypeText = PLocalizer.DefenseSkill
else:
specialAttackTypeText = PLocalizer.WeaponSkill
specialAttackTypeLabel = DirectLabel(parent = self, relief = None, text = specialAttackTypeText, text_scale = 0.033500000000000002, text_wordwrap = halfWidth * 2.7999999999999998 * (0.90000000000000002 / titleScale), text_align = TextNode.ALeft, pos = (-halfWidth + 0.12 + textScale * 0.5, 0.0, runningVertPosition - PiratesGuiGlobals.TextScaleLarge), text_pos = (0.0, -textScale))
specialAttackInfo = PLocalizer.SkillDescriptions.get(specialAttack)
specialAttackDescriptionText = specialAttackInfo[1]
specialAttackDescriptionLabel = DirectLabel(parent = self, relief = None, text = specialAttackDescriptionText, text_scale = textScale, text_wordwrap = halfWidth * 2.7999999999999998 * (0.90000000000000002 / titleScale), text_align = TextNode.ALeft, pos = (-halfWidth + 0.12 + textScale * 0.5, 0.0, runningVertPosition - specialAttackNameLabel.getHeight() + specialAttackTypeLabel.getHeight() - 0.059999999999999998), text_pos = (0.0, -textScale))
saHeight = specialAttackNameLabel.getHeight() + specialAttackTypeLabel.getHeight() + specialAttackDescriptionLabel.getHeight() - 0.040000000000000001
runningVertPosition -= saHeight
runningSize += saHeight
labels.append(specialAttackNameLabel)
labels.append(specialAttackRankLabel)
labels.append(specialAttackTypeLabel)
labels.append(specialAttackDescriptionLabel)
attributes = ItemGlobals.getAttributes(itemId)
for i in range(0, len(attributes)):
attributeIcon = self.SkillIcons.find('**/%s' % ItemGlobals.getAttributeIcon(attributes[i][0]))
if not attributeIcon:
attributeIcon = self.BuffIcons.find('**/%s' % ItemGlobals.getAttributeIcon(attributes[i][0]))
attributeNameLabel = DirectLabel(parent = self, relief = None, image = border, image_scale = 0.050000000000000003, geom = attributeIcon, geom_scale = 0.050000000000000003, image_pos = (-0.070000000000000007, 0.0, -0.029999999999999999), geom_pos = (-0.070000000000000007, 0.0, -0.029999999999999999), text = PLocalizer.getItemAttributeName(attributes[i][0]), text_scale = PiratesGuiGlobals.TextScaleLarge, text_wordwrap = halfWidth * 2.0 * (0.90000000000000002 / titleScale), text_align = TextNode.ALeft, text_fg = titleColor, text_font = PiratesGlobals.getInterfaceOutlineFont(), text_shadow = PiratesGuiGlobals.TextShadow, pos = (-halfWidth + 0.12 + textScale * 0.5, 0.0, runningVertPosition), text_pos = (0.0, -textScale))
attributeRankLabel = DirectLabel(parent = self, relief = None, text = PLocalizer.ItemRank % attributes[i][1], text_scale = textScale, text_wordwrap = halfWidth * 2.0 * (0.90000000000000002 / titleScale), text_align = TextNode.ARight, pos = (halfWidth - textScale * 0.5, 0.0, runningVertPosition), text_pos = (0.0, -textScale))
if attributeNameLabel.getHeight() > 0.074999999999999997:
attributeNameSpace = 0.080000000000000002
else:
attributeNameSpace = PiratesGuiGlobals.TextScaleLarge
attributeDescriptionLabel = DirectLabel(parent = self, relief = None, text = PLocalizer.getItemAttributeDescription(attributes[i][0]), text_scale = textScale, text_wordwrap = halfWidth * 2.7999999999999998 * (0.90000000000000002 / titleScale), text_align = TextNode.ALeft, pos = (-halfWidth + 0.12 + textScale * 0.5, 0.0, runningVertPosition - attributeNameSpace), text_pos = (0.0, -textScale))
aHeight = attributeNameLabel.getHeight() + attributeDescriptionLabel.getHeight()
runningVertPosition -= aHeight + splitHeight
runningSize += aHeight + splitHeight
labels.append(attributeNameLabel)
labels.append(attributeRankLabel)
labels.append(attributeDescriptionLabel)
skillBoosts = ItemGlobals.getSkillBoosts(itemId)
for i in range(0, len(skillBoosts)):
boostIcon = self.SkillIcons.find('**/%s' % WeaponGlobals.getSkillIcon(skillBoosts[i][0]))
boostNameLabel = DirectLabel(parent = self, relief = None, image = border, image_scale = 0.050000000000000003, geom = boostIcon, geom_scale = 0.050000000000000003, image_pos = (-0.070000000000000007, 0.0, -0.029999999999999999), geom_pos = (-0.070000000000000007, 0.0, -0.029999999999999999), text = PLocalizer.ItemBoost % PLocalizer.getInventoryTypeName(skillBoosts[i][0]), text_scale = textScale, text_wordwrap = halfWidth * 2.0 * (0.90000000000000002 / titleScale), text_align = TextNode.ALeft, pos = (-halfWidth + 0.12 + textScale * 0.5, 0.0, runningVertPosition), text_pos = (0.0, -textScale))
boostRankLabel = DirectLabel(parent = self, relief = None, text = '+%s' % str(skillBoosts[i][1]), text_scale = textScale, text_wordwrap = halfWidth * 2.0 * (0.90000000000000002 / titleScale), text_align = TextNode.ARight, pos = (halfWidth - textScale * 0.5, 0.0, runningVertPosition), text_pos = (0.0, -textScale))
bHeight = boostNameLabel.getHeight()
runningVertPosition -= bHeight + splitHeight
runningSize += bHeight + splitHeight
labels.append(boostNameLabel)
labels.append(boostRankLabel)
description = PLocalizer.getItemFlavorText(itemId)
if description != '':
descriptionLabel = DirectLabel(parent = self, relief = None, text = description, text_scale = textScale, text_wordwrap = halfWidth * 2.0 * (0.94999999999999996 / textScale), text_align = TextNode.ALeft, pos = (-halfWidth + textScale * 0.5, 0.0, runningVertPosition), text_pos = (0.0, -textScale))
dHeight = descriptionLabel.getHeight() + 0.02
runningVertPosition -= dHeight
runningSize += dHeight
labels.append(descriptionLabel)
inv = localAvatar.getInventory()
weaponLevel = 0
weaponRepId = WeaponGlobals.getRepId(itemId)
weaponRep = inv.getReputation(weaponRepId)
weaponReq = ItemGlobals.getWeaponRequirement(itemId)
weaponText = None
trainingToken = EconomyGlobals.getItemTrainingReq(itemId)
trainingAmt = inv.getItemQuantity(trainingToken)
if weaponReq:
weaponLevel = ReputationGlobals.getLevelFromTotalReputation(weaponRepId, weaponRep)[0]
if weaponLevel < weaponReq:
weaponColor = PiratesGuiGlobals.TextFG6
else:
weaponColor = (0.40000000000000002, 0.40000000000000002, 0.40000000000000002, 1.0)
weaponText = PLocalizer.ItemLevelRequirement % (weaponReq, PLocalizer.getItemTypeName(itemType))
elif trainingAmt == 0:
weaponColor = PiratesGuiGlobals.TextFG6
weaponText = PLocalizer.ItemTrainingRequirement % PLocalizer.getItemTypeName(itemType)
if trainingAmt == 0:
if itemType == ItemGlobals.GUN:
base.localAvatar.sendRequestContext(InventoryType.GunTrainingRequired)
elif itemType == ItemGlobals.DOLL:
base.localAvatar.sendRequestContext(InventoryType.DollTrainingRequired)
elif itemType == ItemGlobals.DAGGER:
base.localAvatar.sendRequestContext(InventoryType.DaggerTrainingRequired)
elif itemType == ItemGlobals.STAFF:
base.localAvatar.sendRequestContext(InventoryType.StaffTrainingRequired)
if weaponText:
weaponReqLabel = DirectLabel(parent = self, relief = None, text = weaponText, text_scale = textScale, text_wordwrap = halfWidth * 2.0 * (1.5 / titleScale), text_fg = weaponColor, text_shadow = PiratesGuiGlobals.TextShadow, text_align = TextNode.ACenter, pos = (0.0, 0.0, runningVertPosition), text_pos = (0.0, -textScale))
wHeight = weaponReqLabel.getHeight()
runningVertPosition -= wHeight
runningSize += wHeight
labels.append(weaponReqLabel)
if not Freebooter.getPaidStatus(localAvatar.getDoId()):
if rarity != ItemGlobals.CRUDE:
unlimitedLabel = DirectLabel(parent = self, relief = None, text = PLocalizer.UnlimitedAccessRequirement, text_scale = textScale, text_wordwrap = halfWidth * 2.0 * (1.5 / titleScale), text_fg = PiratesGuiGlobals.TextFG6, text_shadow = PiratesGuiGlobals.TextShadow, text_align = TextNode.ACenter, pos = (0.0, 0.0, runningVertPosition), text_pos = (0.0, -textScale))
uHeight = unlimitedLabel.getHeight()
runningVertPosition -= uHeight
runningSize += uHeight
labels.append(unlimitedLabel)
runningVertPosition -= 0.02
runningSize += 0.02
panels = self.helpFrame.attachNewNode('panels')
topPanel = panels.attachNewNode('middlePanel')
detailGui.find('**/top_panel').copyTo(topPanel)
topPanel.setScale(0.080000000000000002)
topPanel.reparentTo(self.helpFrame)
middlePanel = panels.attachNewNode('middlePanel')
detailGui.find('**/middle_panel').copyTo(middlePanel)
middlePanel.setScale(0.080000000000000002)
middlePanel.reparentTo(self.helpFrame)
placement = 0
i = 0
heightMax = -0.080000000000000002
currentHeight = runningVertPosition
while currentHeight < heightMax:
middlePanel = panels.attachNewNode('middlePanel%s' % 1)
detailGui.find('**/middle_panel').copyTo(middlePanel)
middlePanel.setScale(0.080000000000000002)
middlePanel.reparentTo(self.helpFrame)
if currentHeight + 0.20000000000000001 >= heightMax:
difference = heightMax - currentHeight
placement += (0.16800000000000001 / 0.20000000000000001) * difference
currentHeight += difference
else:
placement += 0.16800000000000001
currentHeight += 0.20000000000000001
middlePanel.setZ(-placement)
i += 1
bottomPanel = panels.attachNewNode('bottomPanel')
detailGui.find('**/bottom_panel').copyTo(bottomPanel)
bottomPanel.setScale(0.080000000000000002)
bottomPanel.setZ(-placement)
bottomPanel.reparentTo(self.helpFrame)
colorPanel = panels.attachNewNode('colorPanel')
detailGui.find('**/color').copyTo(colorPanel)
colorPanel.setScale(0.080000000000000002)
colorPanel.setColor(titleColor)
colorPanel.reparentTo(self.helpFrame)
lineBreakTopPanel = panels.attachNewNode('lineBreakTopPanel')
detailGui.find('**/line_break_top').copyTo(lineBreakTopPanel)
lineBreakTopPanel.setScale(0.080000000000000002, 0.080000000000000002, 0.070000000000000007)
lineBreakTopPanel.setZ(0.0080000000000000002)
lineBreakTopPanel.reparentTo(self.helpFrame)
if itemType != ItemGlobals.POTION:
lineBreakBottomPanel = panels.attachNewNode('lineBreakBottomPanel')
detailGui.find('**/line_break_bottom').copyTo(lineBreakBottomPanel)
lineBreakBottomPanel.setScale(0.080000000000000002, 0.080000000000000002, 0.070000000000000007)
lineBreakBottomPanel.setZ(-0.014999999999999999)
lineBreakBottomPanel.reparentTo(self.helpFrame)
panels.flattenStrong()
self.helpFrame['frameSize'] = (-halfWidth, halfWidth, -(runningSize + vMargin), vMargin)
totalHeight = self.helpFrame.getHeight() - 0.10000000000000001
for label in labels:
label.reparentTo(self.helpFrame)
self.helpFrame.setBin('gui-popup', 0)
self.helpFrame.setPos(self, 0.55000000000000004, 0, -0.29999999999999999)
zOffset = -0.5 - self.helpFrame.getPos(aspect2d)[2]
if zOffset >= 0.0:
self.helpFrame.setPos(self, 0.55000000000000004, 0, zOffset - 0.29999999999999999)
else:
weaponInfo = PLocalizer.WeaponDescriptions.get(self.data[0])
weaponDesc = weaponInfo
self.helpText = DirectFrame(parent = self, relief = None, text = weaponDesc, state = DGG.DISABLED, text_align = TextNode.ALeft, text_scale = PiratesGuiGlobals.TextScaleSmall, text_fg = PiratesGuiGlobals.TextFG2, text_wordwrap = 13, textMayChange = 0, sortOrder = 91)
height = -self.helpText.getHeight()
self.helpFrame = BorderFrame(parent = aspect2d, state = DGG.DISABLED, frameSize = (-0.029999999999999999, 0.42999999999999999, height, 0.050000000000000003), sortOrder = 90, borderScale = 0.20000000000000001)
self.helpText.reparentTo(self.helpFrame)
self.helpFrame.setBin('gui-popup', 0)
self.helpFrame.setPos(self, 0.25, 0, -0.035000000000000003)
def destroy(self):
taskMgr.remove('helpInfoTask')
taskMgr.remove(self.taskName('dragTask'))
self.destroyBuffer()
if self.itemCard:
self.itemCard.removeNode()
if self.realItem:
self.realItem.removeNode()
if self.helpFrame:
self.helpFrame.destroy()
self.helpFrame = None
del self.picture
if self.weapon:
taskMgr.remove(DGG.B1PRESS)
taskMgr.remove(DGG.B2PRESS)
taskMgr.remove(DGG.B3PRESS)
InventoryListItem.destroy(self)
def setDraggable(self, d):
self.draggable = d
def dragStart(self, event):
self.origionalPos = self.getPos(render2d)
self.origionalParent = self.getParent()
self.bringToFront()
self.setColorScale(1, 1, 1, 0.5)
if self.draggable:
self.wrtReparentTo(aspect2d)
taskMgr.remove(self.taskName('dragTask'))
vWidget2render2d = self.getPos(render2d)
vMouse2render2d = Point3(event.getMouse()[0], 0, event.getMouse()[1])
editVec = Vec3(vWidget2render2d - vMouse2render2d)
task = taskMgr.add(self.dragTask, self.taskName('dragTask'))
task.editVec = editVec
def dragTask(self, task):
if task.time < PiratesGuiGlobals.DragStartDelayTime:
return Task.cont
else:
mwn = base.mouseWatcherNode
if mwn.hasMouse():
vMouse2render2d = Point3(mwn.getMouse()[0], 0, mwn.getMouse()[1])
newPos = vMouse2render2d + task.editVec
self.setPos(render2d, newPos)
newPos = self.getPos(aspect2d)
x = newPos[0]
z = newPos[2]
x = x - x % 0.050000000000000003
z = z - z % 0.050000000000000003
x = min(1.3 - self.width, max(-1.3, x))
z = min(1 - self.height, max(-1, z))
self.setPos(aspect2d, x, 0.0, z)
return Task.cont
def dragStop(self, event):
self.clearColorScale()
self.wrtReparentTo(self.origionalParent)
self.setPos(render2d, self.origionalPos)
if self.draggable:
taskMgr.remove(self.taskName('dragTask'))
def showDetails(self, event):
taskMgr.doMethodLater(PiratesGuiGlobals.HelpPopupTime, self.createHelpbox, 'helpInfoTask')
self.createHelpbox()
def hideDetails(self, event):
taskMgr.remove('helpInfoTask')
if self.helpFrame:
self.helpFrame.destroy()
self.helpFrame = None
def createBuffer(self):
self.destroyBuffer()
self.buffer = base.win.makeTextureBuffer('par', 256, 256)
self.buffer.setOneShot(True)
self.cam = base.makeCamera(win = self.buffer, scene = self.portraitSceneGraph, clearColor = Vec4(1), lens = self.lens)
self.cam.node().getDisplayRegion(0).setIncompleteRender(False)
self.cam.reparentTo(self.portraitSceneGraph)
self.bg.reparentTo(self.cam)
self.glow.reparentTo(self.cam)
if self.itemCard:
self.itemCard.removeNode()
tex = self.buffer.getTexture()
self.itemCard = NodePath(self.cm.generate())
self.itemCard.setTexture(tex, 1)
if self.helpFrame:
self.itemCard.reparentTo(self.helpFrame)
def destroyBuffer(self):
if self.buffer:
base.graphicsEngine.removeWindow(self.buffer)
self.buffer = None
self.bg.detachNode()
self.glow.detachNode()
self.cam.removeNode()
self.cam = None
class SkillButton(DirectFrame):
notify = directNotify.newCategory('SkillButton')
SkillIcons = None
Image = None
SkillRechargedSound = None
SubLock = None
def __init__(self, skillId, callback, quantity = 0, skillRank = 0, showQuantity = False, showHelp = False, showRing = False, hotkey = None, name = '', showIcon = True, showLock = False, rechargeSkillId = False, isWeaponSkill = False, assocAmmo = []):
DirectFrame.__init__(self, parent = NodePath(), relief = None)
self.initialiseoptions(SkillButton)
gui = loader.loadModel('models/gui/toplevel_gui')
if not SkillButton.SkillIcons:
print 'not SkillButton.SkillIcons:'
SkillButton.SkillIcons = loader.loadModel('models/textureCards/skillIcons')
SkillButton.Image = (SkillButton.SkillIcons.find('**/base'), SkillButton.SkillIcons.find('**/base_down'), SkillButton.SkillIcons.find('**/base_over'))
SkillButton.SkillRechargedSound = loadSfx(SoundGlobals.SFX_SKILL_RECHARGED)
SkillButton.SubLock = gui.find('**/pir_t_gui_gen_key_subscriber')
SkillButton.SpecialIcons = []
for entry in SPECIAL_SKILL_ICONS:
if not entry:
SkillButton.SpecialIcons.append(None)
continue
specialImage = (SkillButton.SkillIcons.find('**/%s' % entry),)
SkillButton.SpecialIcons.append(specialImage)
model = loader.loadModel('models/effects/particleMaps')
toggleIcon = model.find('**/particleGlow')
toggleIcon.node().setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd))
self.toggleFrame = DirectFrame(relief = None, state = DGG.DISABLED, parent = self, image = toggleIcon, image_scale = 0.34999999999999998, image_pos = (0.0, 0.0, -0.01))
self.toggleFrame.hide()
self.glowRing = None
self.glowRing2 = None
self.assocAmmo = assocAmmo
self.skillId = skillId
self.quantity = quantity
self.showQuantity = showQuantity
self.skillRank = skillRank
self.skillRing = None
self.callback = callback
self.showUpgrade = False
self.showHelp = showHelp
self.showRing = showRing
self.showIcon = showIcon
self.showLock = showLock
self.isWeaponSkill = isWeaponSkill
self.lock = None
self.name = name
self.helpFrame = None
self.quantityLabel = None
self.skillButton = None
self.hotkeyLabel = None
self.hotkey = hotkey
self.greyOut = 0
self.tonicId = 0
self.skillRingIval = None
self.impulseIval = None
self.quickImpulseIval = None
self.isBreakAttackSkill = WeaponGlobals.getSkillTrack(self.skillId) == WeaponGlobals.BREAK_ATTACK_SKILL_INDEX
self.isDefenseSkill = WeaponGlobals.getSkillTrack(self.skillId) == WeaponGlobals.DEFENSE_SKILL_INDEX
self.rechargeFilled = 0
self.defenseAuraEffect = None
if self.isWeaponSkill:
self.weaponBackground = DirectLabel(parent = self, state = DGG.DISABLED, image = SkillButton.SkillIcons.find('**/box_base'), image_scale = (0.22, 0, 0.22), image_pos = (0.0, 0.0, 0.0))
self.weaponBackground.flattenLight()
self.weaponBackground.setColor(0.20000000000000001, 0.20000000000000001, 0.20000000000000001, 0.20000000000000001)
self.weaponBackground.setTransparency(1)
if showRing:
if self.isBreakAttackSkill:
color = Vec4(1, 0, 0, 1)
elif self.isDefenseSkill:
color = Vec4(0, 1, 1, 1)
else:
color = Vec4(1, 0.80000000000000004, 0.5, 1)
self.skillRing = SkillRing(color, Vec4(0, 0, 0, 1.0))
gs = self.skillRing.meterFaceHalf2.node().getGeomState(0)
self.skillRing.meterFaceHalf2.node().setGeomState(0, gs.removeAttrib(ColorAttrib.getClassType()))
self.skillRing.reparentTo(self, 0)
self.skillRing.setPos(0, 0, 0)
self.updateSkillId(skillId)
if showQuantity:
self.updateQuantity(quantity)
if hotkey:
self.createHotkey(hotkey)
if showLock:
self.createLock()
self.skillButton.bind(DGG.ENTER, self.showDetails)
self.skillButton.bind(DGG.EXIT, self.hideDetails)
if self.skillId >= InventoryType.begin_Consumables and self.skillId <= InventoryType.end_Consumables and not WeaponGlobals.getSkillEffectFlag(skillId):
self.totalRechargeTime = base.cr.battleMgr.getModifiedRechargeTime(localAvatar, InventoryType.UseItem)
self.tonicId = InventoryType.UseItem
else:
self.totalRechargeTime = base.cr.battleMgr.getModifiedRechargeTime(localAvatar, self.skillId)
if showRing:
if not self.isBreakAttackSkill:
self.createSkillRingIval()
if self.tonicId:
timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging(InventoryType.UseItem)
else:
timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging(self.skillId)
if self.isBreakAttackSkill and timeSpentRecharging < self.totalRechargeTime:
self.updateRechargeRing()
elif not (self.isBreakAttackSkill):
if (self.totalRechargeTime or timeSpentRecharging) and not (timeSpentRecharging > self.totalRechargeTime):
self.skillRingIval.start(startT = timeSpentRecharging)
not (timeSpentRecharging > self.totalRechargeTime)
self.skillRing.meterFaceHalf1.setR(0)
self.skillRing.meterFaceHalf2.setR(180)
self.skillRing.meterFaceHalf1.setColor(self.skillRing.meterActiveColor, 100)
self.skillRing.meterFaceHalf2.setColor(self.skillRing.meterActiveColor, 100)
self.skillRing.meterFaceHalf1.show()
self.skillRing.meterFaceHalf2.show()
if not self.isBreakAttackSkill:
self.checkAmount()
if self.isDefenseSkill:
self.startRecharge()
if self.isWeaponSkill:
self.weaponLabel = DirectLabel(parent = self, relief = None, text = PLocalizer.WeaponAbility, text_font = PiratesGlobals.getPirateBoldOutlineFont(), text_align = TextNode.ACenter, text_scale = PiratesGuiGlobals.TextScaleLarge, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 0, pos = (0.0, 0, -0.12), sortOrder = 70, state = DGG.DISABLED)
self.weaponLabel.flattenLight()
def loadGlowRing(self):
self.glowRing = loader.loadModel('models/effects/battleEffects').find('**/effectVoodooShockwave')
self.glowRing.node().setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOne))
self.glowRing.reparentTo(self)
self.glowRing.setBin('transparent', 0)
self.glowRing.setScale(0.20000000000000001)
self.glowRing.hide()
self.glowRing2 = loader.loadModel('models/effects/particleMaps').find('**/particleGlow')
self.glowRing2.node().setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OOneMinusIncomingAlpha, ColorBlendAttrib.OOne))
self.glowRing2.reparentTo(self)
self.glowRing2.setBin('transparent', 0)
self.glowRing2.setScale(0.20000000000000001)
self.glowRing2.setColor(0.80000000000000004, 1, 0.80000000000000004, 0.20000000000000001)
self.glowRing2.reparentTo(self)
self.glowRing2.hide()
def checkAmount(self):
if not (self.quantity) and self.showQuantity:
if self.showRing and not self.skillRingIval.isPlaying():
self.setGeomColor(0.5, 0.5, 0.5, 1.0)
self.setRingColor(Vec4(0.5, 0.5, 0.5, 1.0))
elif self.showRing and not self.skillRingIval.isPlaying():
self.setGeomColor(1.0, 1.0, 1.0, 1.0)
self.setRingColor(self.skillRing.meterActiveColor)
def toggleButton(self, state):
if state == True:
self.toggleFrame.show()
elif state == False:
self.toggleFrame.hide()
def createSkillRingIval(self):
if self.skillRingIval:
self.skillRingIval.pause()
self.skillRing.meterFaceHalf1.setR(0)
self.skillRing.meterFaceHalf2.setR(180)
self.skillRing.setScale(1.0)
self.skillRing.clearColorScale()
self.setGeomColor(1.0, 1.0, 1.0, 1.0)
self.checkAmount()
self.skillRingIval = None
if self.tonicId:
timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging(InventoryType.UseItem)
else:
timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging(self.skillId)
if self.isDefenseSkill:
localAvatar.setDefenceEffect(self.skillId)
if self.showRing:
self.skillRingIval = Sequence(Func(localAvatar.setDefenceEffect, 0), Func(self.setGeomColor, 0.5, 0.5, 0.5, 1.0), Func(self.skillRing.meterFaceHalf1.setColor, self.skillRing.meterActiveColor, 100), Func(self.skillRing.meterFaceHalf2.setColor, self.skillRing.meterColor, 100), Func(self.skillRing.meterFaceHalf1.setR, 0), Func(self.skillRing.meterFaceHalf2.setR, 0), Func(self.skillRing.meterFaceHalf1.show), Func(self.skillRing.meterFaceHalf2.show), LerpFunc(self.skillRing.meterFaceHalf2.setR, self.totalRechargeTime / 2, 0, -180), Func(self.skillRing.meterFaceHalf2.setColor, self.skillRing.meterActiveColor, 100), Func(self.skillRing.meterFaceHalf2.setR, 0), LerpFunc(self.skillRing.meterFaceHalf1.setR, self.totalRechargeTime / 2, 0, -180), Func(self.setGeomColor, 1.0, 1.0, 1.0, 1.0), Func(base.playSfx, SkillButton.SkillRechargedSound, volume = 0.5), Parallel(LerpScaleInterval(self.skillRing, 0.10000000000000001, Vec3(1.2, 1.2, 1.2)), LerpColorScaleInterval(self.skillRing, 0.10000000000000001, Vec4(0.0, 0.75, 0.0, 1.0), Vec4(1.0, 1.0, 1.0, 1.0), blendType = 'easeInOut')), Func(localAvatar.setDefenceEffect, self.skillId), LerpScaleInterval(self.skillRing, 0.20000000000000001, Vec3(0.90000000000000002, 0.90000000000000002, 0.90000000000000002)), LerpScaleInterval(self.skillRing, 0.029999999999999999, Vec3(1.1000000000000001, 1.1000000000000001, 1.1000000000000001)), Parallel(LerpScaleInterval(self.skillRing, 0.029999999999999999, Vec3(1.0, 1.0, 1.0)), LerpColorScaleInterval(self.skillRing, 1, Vec4(1.0, 1.0, 1.0, 1.0), blendType = 'easeInOut')), Func(self.skillRing.clearColorScale), Func(self.checkAmount))
def updateSkillRingIval(self):
if self.showRing:
playing = self.skillRingIval.isPlaying()
if self.tonicId:
timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging(InventoryType.UseItem)
else:
timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging(self.skillId)
if timeSpentRecharging:
skillRechargeProgress = timeSpentRecharging / self.totalRechargeTime
self.totalRechargeTime = base.cr.battleMgr.getModifiedRechargeTime(localAvatar, self.skillId)
if not self.totalRechargeTime:
self.totalRechargeTime = base.cr.battleMgr.getModifiedRechargeTime(localAvatar, InventoryType.UseItem)
if timeSpentRecharging:
timeSpentRecharging = skillRechargeProgress * self.totalRechargeTime
localAvatar.skillDiary.modifyTimeSpentRecharging(self.skillId, timeSpentRecharging)
self.createSkillRingIval()
if playing and timeSpentRecharging:
self.skillRingIval.start(startT = timeSpentRecharging)
def quickGlowImpulse(self):
if not self.glowRing2:
self.loadGlowRing()
self.quickImpulseIval = Sequence(Func(self.glowRing2.show), LerpScaleInterval(self.glowRing2, 0.20000000000000001, Vec3(0.33000000000000002, 0.33000000000000002, 0.33000000000000002)), LerpScaleInterval(self.glowRing2, 0.25, Vec3(0.20000000000000001, 0.20000000000000001, 0.20000000000000001)), Func(self.glowRing2.hide))
self.quickImpulseIval.start()
def startPowerImpulse(self):
if not self.glowRing:
self.loadGlowRing()
self.glowRing.show()
self.impulseIval = Sequence(Parallel(LerpScaleInterval(self.glowRing, 0.10000000000000001, Vec3(0.20300000000000001, 0.20300000000000001, 0.20300000000000001)), LerpColorScaleInterval(self.glowRing, 0.10000000000000001, Vec4(0.80000000000000004, 0.80000000000000004, 0.80000000000000004, 0.80000000000000004), Vec4(1.0, 1.0, 1.0, 0.80000000000000004), blendType = 'easeInOut')), LerpScaleInterval(self.glowRing, 0.14999999999999999, Vec3(0.19, 0.19, 0.19)), LerpScaleInterval(self.glowRing, 0.050000000000000003, Vec3(0.20200000000000001, 0.20200000000000001, 0.20200000000000001)), Parallel(LerpScaleInterval(self.glowRing, 0.029999999999999999, Vec3(0.20000000000000001, 0.20000000000000001, 0.20000000000000001)), LerpColorScaleInterval(self.glowRing, 0.40000000000000002, Vec4(1.0, 1.0, 1.0, 1.0), blendType = 'easeInOut')), Func(self.glowRing.clearColorScale))
self.impulseIval.loop()
def stopPowerImpulse(self):
if self.glowRing:
self.glowRing.hide()
if self.impulseIval:
self.impulseIval.finish()
self.impulseIval = None
def updateRechargeRing(self):
timeSpentRecharging = localAvatar.skillDiary.getTimeSpentRecharging(self.skillId)
self.totalRechargeTime = base.cr.battleMgr.getModifiedRechargeTime(localAvatar, self.skillId)
if timeSpentRecharging >= self.totalRechargeTime and not (self.rechargeFilled):
self.rechargeFilled = 1
if self.skillRingIval:
self.skillRingIval.pause()
self.skillRingIval = None
self.skillRing.meterFaceHalf1.setR(0)
self.skillRing.meterFaceHalf2.setR(180)
self.skillRing.setScale(1.0)
self.skillRing.clearColorScale()
self.setGeomColor(1.0, 1.0, 1.0, 1.0)
self.skillRingIval = Sequence(Func(base.playSfx, SkillButton.SkillRechargedSound, volume = 0.5), Parallel(LerpScaleInterval(self.skillRing, 0.10000000000000001, Vec3(1.2, 1.2, 1.2)), LerpColorScaleInterval(self.skillRing, 0.10000000000000001, Vec4(0.0, 0.75, 0.0, 1.0), Vec4(1.0, 1.0, 1.0, 1.0), blendType = 'easeInOut')), Func(localAvatar.setDefenceEffect, self.skillId), LerpScaleInterval(self.skillRing, 0.20000000000000001, Vec3(0.90000000000000002, 0.90000000000000002, 0.90000000000000002)), LerpScaleInterval(self.skillRing, 0.029999999999999999, Vec3(1.1000000000000001, 1.1000000000000001, 1.1000000000000001)), Parallel(LerpScaleInterval(self.skillRing, 0.029999999999999999, Vec3(1.0, 1.0, 1.0)), LerpColorScaleInterval(self.skillRing, 1, Vec4(1.0, 1.0, 1.0, 1.0), blendType = 'easeInOut')), Func(self.skillRing.clearColorScale))
self.skillRingIval.start()
elif timeSpentRecharging < self.totalRechargeTime:
self.rechargeFilled = 0
self.setGeomColor(0.5, 0.5, 0.5, 1.0)
self.skillRing.update(timeSpentRecharging, self.totalRechargeTime)
def updateSkillId(self, skillId):
self.skillId = skillId
if self.skillButton:
if self.quantityLabel:
self.quantityLabel.detachNode()
self.skillButton.destroy()
if self.showQuantity and not (self.quantity):
geomColor = Vec4(0.5, 0.5, 0.5, 1.0)
else:
geomColor = Vec4(1.0, 1.0, 1.0, 1.0)
if self.showIcon:
asset = WeaponGlobals.getSkillIcon(skillId)
if hasattr(self, '_skillIconName'):
asset = self._skillIconName
geom = SkillButton.SkillIcons.find('**/%s' % asset)
if geom.isEmpty():
geom = SkillButton.SkillIcons.find('**/base')
repId = WeaponGlobals.getSkillReputationCategoryId(self.skillId)
geom_scale = getGeomScale(repId, skillId)
image_color = (1, 1, 1, 1)
else:
geom = (None,)
geom_scale = 0.12
image_color = (0.5, 0.5, 0.5, 0.5)
specialIconId = 0
if self.isBreakAttackSkill:
specialIconId = 1
elif self.isDefenseSkill:
specialIconId = 2
elif skillId == ItemGlobals.getSpecialAttack(localAvatar.currentWeaponId):
specialIconId = 3
if specialIconId:
something = SkillButton.SpecialIcons[specialIconId][0]
if self.skillRing:
self.skillRing.setupFace(something)
self['image'] = None
elif self.skillRing:
self.skillRing.setupFace()
if self.showRing:
image = None
else:
image = SkillButton.Image
self.skillButton = DirectButton(parent = self, relief = None, pos = (0, 0, 0), text = ('', '', self.name), text_align = TextNode.ACenter, text_shadow = Vec4(0, 0, 0, 1), text_scale = 0.040000000000000001, text_fg = Vec4(1, 1, 1, 1), text_pos = (0.0, 0.089999999999999997), image = image, image_scale = 0.14999999999999999, image_color = image_color, geom = geom, geom_scale = geom_scale, geom_color = geomColor, command = self.callback, sortOrder = 50, extraArgs = [
skillId])
self.skillButton.bind(DGG.ENTER, self.showDetails)
self.skillButton.bind(DGG.EXIT, self.hideDetails)
if self.quantityLabel and not self.quantityLabel.isEmpty():
self.quantityLabel.reparentTo(self.skillButton)
def createHotkey(self, hotkey):
self.hotkeyLabel = DirectLabel(parent = self, relief = None, text = hotkey, text_font = PiratesGlobals.getPirateBoldOutlineFont(), text_align = TextNode.ARight, text_scale = PiratesGuiGlobals.TextScaleLarge, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 0, pos = (0.070000000000000007, 0, -0.059999999999999998), sortOrder = 70, state = DGG.DISABLED)
self.hotkeyLabel.flattenLight()
def createLock(self):
if self.lock:
return None
self.lock = DirectFrame(parent = self, relief = None, image = SkillButton.SubLock, image_scale = 0.14000000000000001, image_pos = (0.050000000000000003, 0, -0.025000000000000001), sortOrder = 99)
if self.showIcon:
self.lock.setColorScale(0.90000000000000002, 0.90000000000000002, 0.90000000000000002, 1)
self.skillButton.setColorScale(0.40000000000000002, 0.40000000000000002, 0.40000000000000002, 1, 1)
else:
self.lock.setColorScale(0.59999999999999998, 0.59999999999999998, 0.59999999999999998, 1, 2)
self.skillButton.clearColorScale()
if self.showHelp:
self.lock.hide()
def createHelpFrame(self, args = None):
if self.helpFrame:
return None
inv = localAvatar.getInventory()
if not inv:
return None
baseRank = max(self.skillRank, 1)
lvlDamageMod = WeaponGlobals.getLevelDamageModifier(localAvatar.getLevel())
buff = WeaponGlobals.getSkillEffectFlag(self.skillId)
dur = WeaponGlobals.getAttackDuration(self.skillId)
effect = dur + dur * (baseRank - 1) / 4.0
bonus = localAvatar.getSkillRankBonus(self.skillId)
upgradeAmt = WeaponGlobals.getAttackUpgrade(self.skillId)
rank = localAvatar.getSkillRank(self.skillId)
skillBoost = 0
if self.skillId in ItemGlobals.getLinkedSkills(localAvatar.currentWeaponId):
linkedSkillId = WeaponGlobals.getLinkedSkillId(self.skillId)
skillBoost = ItemGlobals.getWeaponBoosts(localAvatar.currentWeaponId, linkedSkillId)
skillBoost += ItemGlobals.getWeaponBoosts(localAvatar.getCurrentCharm(), linkedSkillId)
else:
skillBoost = ItemGlobals.getWeaponBoosts(localAvatar.currentWeaponId, self.skillId)
skillBoost += ItemGlobals.getWeaponBoosts(localAvatar.getCurrentCharm(), self.skillId)
manaCost = 0
if WeaponGlobals.getSkillTrack(self.skillId) != WeaponGlobals.PASSIVE_SKILL_INDEX:
manaCost = WeaponGlobals.getMojoCost(self.skillId)
if manaCost < 0:
amt = localAvatar.getSkillRankBonus(InventoryType.StaffConservation)
manaCost = min(manaCost - manaCost * amt, 1.0)
damage = 0
loDamage = 0
mpDamage = 0
mpLoDamage = 0
if WeaponGlobals.getSkillTrack(self.skillId) == WeaponGlobals.TONIC_SKILL_INDEX:
damage = WeaponGlobals.getAttackSelfHP(self.skillId)
elif WeaponGlobals.getSkillTrack(self.skillId) != WeaponGlobals.PASSIVE_SKILL_INDEX:
mod = (1.0 + bonus) * lvlDamageMod
damage = int(WeaponGlobals.getAttackTargetHP(self.skillId) * mod)
loDamage = damage / 2
mpDamage = int(WeaponGlobals.getAttackTargetMojo(self.skillId) * mod)
mpLoDamage = mpDamage / 2
try:
skillInfo = PLocalizer.SkillDescriptions.get(self.skillId)
skillTitle = PLocalizer.makeHeadingString(PLocalizer.InventoryTypeNames.get(self.skillId), 2)
skillType = PLocalizer.makeHeadingString(skillInfo[0], 1)
except:
self.notify.error('Error getting skill info for skillId %s' % self.skillId)
description = skillInfo[1]
if damage < 0:
description += ' ' + PLocalizer.DealsDamage
elif damage > 0:
if loDamage:
loDamage = 0
description += ' ' + PLocalizer.HealsDamageRange
else:
description += ' ' + PLocalizer.HealsDamage
if mpDamage < 0:
description += ' ' + PLocalizer.DealsMpDamage
effectId = WeaponGlobals.getSkillEffectFlag(self.skillId)
if effectId:
description += ' ' + SkillEffectDescriptions.get(effectId)[0]
if bonus:
if self.skillId == InventoryType.SailBroadsideLeft or self.skillId == InventoryType.SailBroadsideRight:
description += ' ' + PLocalizer.BroadsideDesc
if self.skillId == InventoryType.CannonShoot:
description += ' ' + PLocalizer.CannonShootDesc
if self.skillId == InventoryType.DollAttune:
description += ' ' + PLocalizer.MultiAttuneDesc
if WeaponGlobals.getSkillInterrupt(self.skillId):
description += ' ' + PLocalizer.InterruptDesc
if WeaponGlobals.getSkillUnattune(self.skillId):
description += ' ' + PLocalizer.UnattuneDesc
upgradeInfo = ''
if self.showUpgrade and rank < 5:
if rank > 0:
upgradeInfo = skillInfo[2]
if upgradeInfo == '':
if damage < 0:
upgradeInfo += PLocalizer.UpgradesDamage
elif damage > 0:
upgradeInfo += PLocalizer.UpgradesHealing
if mpDamage < 0:
upgradeInfo += ' ' + PLocalizer.UpgradesMpDamage
if effectId:
entry = SkillEffectDescriptions.get(effectId)
if len(entry) > 1:
if not damage:
upgradeInfo += PLocalizer.UpgradesDuration
else:
upgradeInfo += ' ' + PLocalizer.And
upgradeInfo += ' ' + entry[1]
upgradeInfo += '!'
elif len(upgradeInfo) >= 4:
upgradeInfo = skillInfo[3]
else:
upgradeInfo = PLocalizer.ClickToLearn
elif not self.showIcon:
unlockLevel = RepChart.getSkillUnlockLevel(self.skillId)
if unlockLevel > 0:
upgradeInfo = PLocalizer.UnlocksAtLevel % unlockLevel
if self.skillId in SkillComboReq and SkillComboReq[self.skillId] and inv.getStackQuantity(self.skillId - 1) < 2:
color = 'red'
if rank == 0:
color = 'red'
upgradeInfo = ''
description += '\n' + color + SkillComboReq[self.skillId] + '.'
skillDesc = skillTitle + '\n' + skillType + '\n\n' + description + '\ngreen' + upgradeInfo
stats = []
if manaCost:
stats.append(abs(manaCost))
if damage and loDamage:
stats.append(abs(loDamage))
stats.append(abs(damage))
elif damage:
stats.append(abs(damage))
if mpDamage:
stats.append(abs(mpLoDamage))
stats.append(abs(mpDamage))
if buff == WeaponGlobals.C_CURSE:
stats.append(WeaponGlobals.CURSED_DAM_AMP * 100)
if buff == WeaponGlobals.C_WEAKEN:
stats.append(WeaponGlobals.WEAKEN_PENALTY * 100)
if effect > 0:
stats.append(effect)
if skillInfo[4]:
if bonus == 0 and upgradeAmt > 0:
if not self.skillId == InventoryType.SailBroadsideLeft and self.skillId == InventoryType.SailBroadsideRight:
pass
if not (self.skillId == InventoryType.CannonShoot):
bonus = upgradeAmt
if upgradeAmt < 1.0 and upgradeAmt > 0:
bonus *= 100
if self.skillId == InventoryType.SailTreasureSense:
bonus /= 2.0
elif self.skillId == InventoryType.CutlassParry:
bonus += WeaponGlobals.getSubtypeParryBonus(localAvatar.currentWeaponId)
if bonus:
stats.append(abs(bonus))
if self.skillId == InventoryType.DollAttune:
stats.append(rank)
if self.skillRank:
rankText = DirectFrame(parent = self, relief = None, text = PLocalizer.makeHeadingString(PLocalizer.Rank + ' %s' % (self.skillRank + skillBoost), 2), text_align = TextNode.ARight, text_scale = PiratesGuiGlobals.TextScaleSmall, text_fg = PiratesGuiGlobals.TextFG2, text_wordwrap = 15, text_shadow = (0, 0, 0, 1), pos = (0.45000000000000001, 0, 0), textMayChange = 1, sortOrder = 92, state = DGG.DISABLED)
stats = [stat + 0.01 for stat in stats]
try:
pass
except TypeError:
self.notify.error('Error formatting skillDesc(%s): %s' % (self.skillId, stats))
helpText = DirectFrame(parent = self, relief = None, text = skillDesc % stats, text_align = TextNode.ALeft, text_scale = PiratesGuiGlobals.TextScaleSmall, text_fg = PiratesGuiGlobals.TextFG2, text_wordwrap = 17, textMayChange = 1, state = DGG.DISABLED, sortOrder = 91)
height = -(helpText.getHeight() + 0.01)
if self.lock:
height = height - 0.040000000000000001
width = 0.55000000000000004
self.helpFrame = BorderFrame(parent = self, state = DGG.DISABLED, frameSize = (-0.040000000000000001, width, height, 0.050000000000000003), pos = (0, 0, -0.12), sortOrder = 90)
self.helpFrame.setBin('gui-popup', 0)
helpText.reparentTo(self.helpFrame)
if self.skillRank:
rankText.reparentTo(self.helpFrame)
if self.lock:
self.lockedFrame = DirectFrame(parent = self.helpFrame, relief = None, pos = (0.087999999999999995, 0, height + 0.029999999999999999), image = SkillButton.SubLock, image_scale = 0.13, image_pos = (-0.055, 0, 0.012999999999999999), text = PLocalizer.VR_AuthAccess, text_scale = PiratesGuiGlobals.TextScaleSmall, text_align = TextNode.ALeft, text_fg = PiratesGuiGlobals.TextFG13)
self.notify.debug('locked!')
pos = self.helpFrame.getPos(aspect2d)
x = min(pos[0], base.a2dRight - width)
z = max(pos[2], base.a2dBottom - height)
self.helpFrame.setPos(aspect2d, x, 0, z)
def showDetails(self, event):
if self.showHelp:
self.createHelpFrame()
if self.showRing:
self.skillRing.rollover(True)
def hideDetails(self, event):
if self.helpFrame:
self.helpFrame.destroy()
self.helpFrame = None
if self.showRing:
self.skillRing.rollover(False)
def updateQuantity(self, quantity):
self.quantity = quantity
if not self.showQuantity:
return None
if quantity == WeaponGlobals.INF_QUANT:
text = ''
elif self.assocAmmo:
assocQuantity = 0
inv = localAvatar.getInventory()
if inv:
for ammoId in self.assocAmmo:
assocQuantity += inv.getItemQuantity(self.getAmmoCat(), ammoId)
if quantity != assocQuantity:
text = '%s' % assocQuantity
else:
text = 'x%s' % quantity
else:
text = 'x%s' % quantity
if self.quantityLabel and not self.quantityLabel.isEmpty():
self.quantityLabel['text'] = text
else:
self.quantityLabel = DirectLabel(parent = NodePath(), relief = None, state = DGG.DISABLED, text = text, frameColor = (0, 0, 0, 1), frameSize = (-0.01, 0.02, -0.01, 0.025000000000000001), text_scale = PiratesGuiGlobals.TextScaleLarge, text_align = TextNode.ACenter, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_wordwrap = 11, pos = (0.029999999999999999, 0.0, 0.029999999999999999), text_font = PiratesGlobals.getPirateBoldOutlineFont(), sortOrder = 60)
self.quantityLabel.flattenLight()
self.quantityLabel.reparentTo(self)
if self.skillButton and not self.skillButton.isEmpty():
self.quantityLabel.reparentTo(self.skillButton)
def getAmmoCat(self):
pass
def startRecharge(self):
if not self.showRing:
return None
if self.isBreakAttackSkill:
self.setGeomColor(0.5, 0.5, 0.5, 1.0)
self.updateRechargeRing()
return None
if self.skillRingIval.isPlaying():
self.createSkillRingIval()
self.skillRingIval.start()
def stopRecharge(self):
if self.showRing:
if self.isBreakAttackSkill:
self.setGeomColor(0.5, 0.5, 0.5, 1.0)
self.updateRechargeRing()
return None
if self.skillRingIval.isPlaying():
self.skillRingIval.pause()
def setGeomColor(self, r, g, b, a):
self.skillButton['geom_color'] = Vec4(r, g, b, a)
def setRingColor(self, color):
self.skillRing.meterFaceHalf1.setColor(color[0], color[1], color[2], color[3], 100)
self.skillRing.meterFaceHalf2.setColor(color[0], color[1], color[2], color[3], 100)
def setShowUpgrade(self, show):
if self.showUpgrade != show:
self.showUpgrade = show
if self.helpFrame:
self.helpFrame.destroy()
self.helpFrame = None
self.showDetails(None)
def setShowIcon(self, show):
if self.showIcon != show:
self.showIcon = show
self.updateSkillId(self.skillId)
if self.helpFrame:
self.helpFrame.destroy()
self.helpFrame = None
def setShowLock(self, show):
if self.showLock != show:
self.showLock = show
if show:
self.createLock()
elif self.lock:
self.lock.destroy()
self.lock = None
self.skillButton.clearColorScale()
def destroy(self):
self.callback = None
if self.skillRingIval:
self.skillRingIval.pause()
self.skillRingIval = None
if self.quantityLabel:
self.quantityLabel.destroy()
self.quantityLabel = None
if self.impulseIval:
self.impulseIval.pause()
self.impulseIval = None
if self.quickImpulseIval:
self.quickImpulseIval.pause()
self.quickImpulseIval = None
self.ignoreAll()
DirectFrame.destroy(self)
