def __init__(self):
InventoryPage.InventoryPage.__init__(self)
self.initialiseoptions(TitlesPage)
self.titles = []
self.selectedLandIndex = -1
self.selectedSeaIndex = -1
self.landButtons = []
self.seaButtons = []
self.forceInitLand = -1
self.forceInitSea = -1
self.loaded = 0
self.opened = 0
gui = loader.loadModel('models/gui/gui_main')
scale = 0.33500000000000002
self.background = self.attachNewNode('background')
self.background.setScale(scale)
self.background.setPos(0.53000000000000003, 0, 0.73999999999999999)
gui.find('**/gui_inv_red_general1').copyTo(self.background)
PiratesGlobals.flattenOrdered(self.background)
self.displayTitleFrame = DirectFrame(parent = self, relief = None, pos = (0.55000000000000004, 0, 1.175), text = PLocalizer.DisplayTitle, text_align = TextNode.ALeft, text_scale = 0.044999999999999998, text_pos = (-0.45000000000000001, 0.050000000000000003), text_fg = PiratesGuiGlobals.TextFG2, text_wordwrap = 20, text_shadow = (0, 0, 0, 1), textMayChange = 1, text_font = PiratesGlobals.getInterfaceFont())
self.displayTitleLandFrame = BorderFrame.BorderFrame(parent = self, relief = None, pos = (0.81000000000000005, 0, 1.02), frameSize = (-0.050000000000000003, 0.050000000000000003, -0.26000000000000001, -0.080000000000000002), modelName = 'pir_m_gui_frm_subframe', imageColorScale = VBase4(0.75, 0.75, 0.90000000000000002, 0.75), text = PLocalizer.DisplayTitleLand, text_align = TextNode.ACenter, text_scale = 0.032000000000000001, text_pos = (0, -0.01), text_fg = PiratesGuiGlobals.TextFG2, text_wordwrap = 15, text_shadow = (0, 0, 0, 1), textMayChange = 0, text_font = PiratesGlobals.getInterfaceFont())
self.displayTitleSeaFrame = BorderFrame.BorderFrame(parent = self, relief = None, pos = (0.96999999999999997, 0, 1.02), frameSize = (-0.050000000000000003, 0.050000000000000003, -0.26000000000000001, -0.080000000000000002), modelName = 'pir_m_gui_frm_subframe', imageColorScale = VBase4(0.75, 0.75, 0.90000000000000002, 0.75), text = PLocalizer.DisplayTitleSea, text_align = TextNode.ACenter, text_scale = 0.032000000000000001, text_pos = (0, -0.01), text_fg = PiratesGuiGlobals.TextFG2, text_wordwrap = 15, text_shadow = (0, 0, 0, 1), textMayChange = 0, text_font = PiratesGlobals.getInterfaceFont())
self.dummyFrame = DirectFrame(parent = self, relief = None, pos = (0.10000000000000001, 0, 0.89000000000000001))
self.accept('LocalAvatarInfamyUpdated', self.refresh)
self.accept('landBadgeSet', self.updateLandBadge)
self.accept('seaBadgeSet', self.updateSeaBadge)
def handleAvatarTeleportQuery(self, requesterId, requesterBandMgrId, requesterBandId, requesterGuildId, requesterShardId):
handle = self.cr.identifyAvatar(requesterId)
if not handle:
return None
if self.cr.identifyFriend(requesterId):
if requesterId in localAvatar.ignoreList or self.cr.avatarFriendsManager.checkIgnored(requesterId):
handle.sendTeleportResponse(PiratesGlobals.encodeTeleportFlag(PiratesGlobals.TFIgnore), 0, 0, 0, sendToId = requesterId)
return None
if localAvatar.ship and len(localAvatar.ship.crew) >= localAvatar.ship.getMaxCrew():
handle.sendTeleportResponse(PiratesGlobals.encodeTeleportFlag(PiratesGlobals.TFOnShip), 0, 0, 0, sendToId = requesterId)
return None
avName = handle.getName()
def confirmed(canTeleportTo, avId, failedFlag, avName = avName):
if canTeleportTo:
if self.cr.getActiveWorld() and self.cr.distributedDistrict and localAvatar.getParentObj():
handle.sendTeleportResponse(PiratesGlobals.TAAvailable, self.cr.distributedDistrict.doId, self.cr.getActiveWorld().doId, localAvatar.getParentObj().doId, sendToId = requesterId)
else:
handle.sendTeleportResponse(PiratesGlobals.encodeTeleportFlag(PiratesGlobals.TFUnavailable), 0, 0, 0, sendToId = requesterId)
elif localAvatar.failedTeleportMessageOk(requesterId):
localAvatar.setSystemMessage(requesterId, OTPLocalizer.WhisperFailedVisit % avName)
handle.sendTeleportResponse(PiratesGlobals.encodeTeleportFlag(failedFlag), 0, 0, 0, sendToId = requesterId)
confirmed = report(types = [
'args',
'deltaStamp'], dConfigParam = 'teleport')(confirmed)
localAvatar.confirmTeleportTo(confirmed, requesterId, avName, requesterBandMgrId, requesterBandId, requesterGuildId)
def setupBackground(self):
gui = loader.loadModel('models/gui/gui_main')
scale = 0.33500000000000002
self.background = self.attachNewNode('background')
self.background.setScale(scale)
self.background.setPos(0.41999999999999998, 0, 0.52000000000000002)
gui.find('**/gui_inv_red_general1').copyTo(self.background)
PiratesGlobals.flattenOrdered(self.background)
def confirmed(canTeleportTo, avId, failedFlag, avName = avName):
if canTeleportTo:
if self.cr.getActiveWorld() and self.cr.distributedDistrict and localAvatar.getParentObj():
handle.sendTeleportResponse(PiratesGlobals.TAAvailable, self.cr.distributedDistrict.doId, self.cr.getActiveWorld().doId, localAvatar.getParentObj().doId, sendToId = requesterId)
else:
handle.sendTeleportResponse(PiratesGlobals.encodeTeleportFlag(PiratesGlobals.TFUnavailable), 0, 0, 0, sendToId = requesterId)
elif localAvatar.failedTeleportMessageOk(requesterId):
localAvatar.setSystemMessage(requesterId, OTPLocalizer.WhisperFailedVisit % avName)
handle.sendTeleportResponse(PiratesGlobals.encodeTeleportFlag(failedFlag), 0, 0, 0, sendToId = requesterId)
def startWave(self, countdown, currWave, maxWave):
self.currWave = currWave
self.maxWave = maxWave
self.resetWavesUI()
if not self.flagshipUIBaseNode:
self.flagshipUIBaseNode = base.a2dTopLeft.attachNewNode('FlagshipUIBaseNode')
self.flagshipUIBaseNode.setPos(1.1499999999999999, 0, -0.41999999999999998)
self.flagshipUIBaseNode.setScale(0.75)
globalGui = loader.loadModel('models/gui/toplevel_gui')
if localAvatar.ship:
self.baseFrame = DirectFrame(parent = localAvatar.ship.flagshipUIBaseNode, relief = None, state = DGG.DISABLED, image = globalGui.find('**/generic_box'), image_scale = 0.12, image_pos = (0, 0, 0), pos = (0, 0, 0))
self.baseFrame.reparentTo(self.flagshipUIBaseNode)
self.baseFrame.setScale(16, 1, 8)
self.baseFrame.setPos(0.29999999999999999, 0, 0.074999999999999997)
if self.waveCount:
pass
1
self.waveCount = TextNode('BreakRemainingText')
self.waveCount.setFont(PiratesGlobals.getInterfaceFont())
self.waveCount.setTextColor(PiratesGuiGlobals.TextFG1)
self.waveCount.setAlign(TextNode.ACenter)
self.waveCount.setText(PLocalizer.FlagshipWaveCount % (str(currWave - 1), str(self.maxWave)))
self.waveCountNode = self.flagshipUIBaseNode.attachNewNode(self.waveCount)
self.waveCountNode.setPos(0.29999999999999999, 0, 0.10000000000000001)
self.waveCountNode.setScale(0.074999999999999997)
if currWave <= 1:
self.flagshipUIBaseNode.hide()
if self.counter:
pass
1
self.counter = TextNode('BreakRemainingText')
self.counter.setFont(PiratesGlobals.getInterfaceFont())
self.counter.setTextColor(PiratesGuiGlobals.TextFG1)
self.counter.setAlign(TextNode.ACenter)
self.counter.setText(str(countdown))
self.counterNode = self.flagshipUIBaseNode.attachNewNode(self.counter)
self.counterNode.setPos(0.45000000000000001, 0, 0)
self.counterNode.setScale(0.10000000000000001)
self.counterLabel = TextNode('BreakRemainingTextLabel')
self.counterLabel.setFont(PiratesGlobals.getInterfaceFont())
self.counterLabel.setTextColor(PiratesGuiGlobals.TextFG1)
self.counterLabel.setAlign(TextNode.ACenter)
self.counterLabel.setText(PLocalizer.FlagshipWaveCountdown)
self.counterLabelNode = self.flagshipUIBaseNode.attachNewNode(self.counterLabel)
self.counterLabelNode.setPos(0.25, 0, 0)
self.counterLabelNode.setScale(0.050000000000000003)
self.counterEndTime = globalClock.getRealTime() + countdown
if self.updateCounterTask:
taskMgr.remove(self.updateCounterTask)
self.updateCounterTask = taskMgr.add(self.updateCounter, 'updateCounterTask')
def createScoreboard(self, scoreboardPos):
invasionResults = self.getInvasionResults()
self.panel = Scoreboard.Scoreboard('', self.width, self.height - 0.71499999999999997, invasionResults, self.titleHeight)
self.panel.reparentTo(self)
self.panel.setPos(scoreboardPos)
for item in self.panel.list.items:
item.descText['text_font'] = PiratesGlobals.getPirateOutlineFont()
item.valueText['text_font'] = PiratesGlobals.getPirateOutlineFont()
lenItems = len(self.panel.list.items)
self.panel.list.items[0].descText.configure(text_fg = PiratesGuiGlobals.TextFG4)
self.panel.list.items[0].valueText.configure(text_fg = PiratesGuiGlobals.TextFG4)
def __init__(self, panelNumber, numOfPanels, **kw):
DirectFrame.__init__(self)
self.hide()
self.panelNumber = panelNumber
self.numOfPanels = numOfPanels
self.playerLbls = []
self.shipsSunkTotalslbl = []
self.damageTotalslbl = []
self.accuracyTotalslbl = []
self.shotsFiredTotalslbl = []
self.headingfont = PiratesGlobals.getPirateOutlineFont()
self.bodyfont = PiratesGlobals.getPirateFont()
self.highlightPlayerColor = PiratesGuiGlobals.TextFG4
def setupCellImage(self):
self.cellImage = NodePath("empty")
self.workingCellImage = NodePath("empty")
self.focusCellImage = NodePath("empty")
gui = loader.loadModel("models/gui/gui_icons_weapon")
self.gridBacking = NodePath("backing")
baseBacking = gui.find("**/pir_t_gui_frm_inventoryBox")
extraCell = gui.find("**/pir_t_gui_frm_inventoryBox_over")
extraCell.setScale(0.69999999999999996)
baseBacking.reparentTo(self.gridBacking)
extraCell.reparentTo(self.gridBacking)
PiratesGlobals.flattenOrdered(self.gridBacking)
self.imageScale = 1.0
self.imagePos = (0.0, 0.0, 0.0)
self.relief = DGG.FLAT
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,
)
if base.config.GetBool("want-hotkeys", False):
self.acceptHotkeys()
def handleAvatarTeleportResponse(self, avId, available, shardId, instanceDoId, areaDoId):
if not avId == self.teleportQueryId:
self.clearTeleportQueryId()
return None
self.clearTeleportQueryId()
handle = self.cr.identifyAvatar(avId)
if handle:
avName = handle.getName()
else:
return None
if available == PiratesGlobals.TAAvailable:
def teleportConfirmation(confirmed, shardId = shardId, instanceDoID = instanceDoId, avId = avId, avatarParentId = areaDoId):
if confirmed:
self.requestTeleportToAvatar(shardId, instanceDoId, avatarId = avId, avatarParentId = areaDoId)
teleportConfirmation = report(types = [
'args',
'deltaStamp'], dConfigParam = 'teleport')(teleportConfirmation)
localAvatar.setTeleportFlag(PiratesGlobals.TFSameArea, localAvatar.confirmNotSameAreaTeleportToPlayer, [
areaDoId])
localAvatar.confirmTeleport(teleportConfirmation, feedback = True)
localAvatar.clearTeleportFlag(PiratesGlobals.TFSameArea)
else:
flag = PiratesGlobals.decodeTeleportFlag(available)
if flag == PiratesGlobals.TAIgnore:
pass
1
if flag in PiratesGlobals.TFNoTeleportToReasons:
localAvatar.guiMgr.createWarning(PiratesGlobals.TFNoTeleportToReasons[flag] % avName, duration = 10)
def __init__(self, showMinutes = 0, mode = None, titleText = '', titleFg = None, infoText = '', cancelText = '', cancelCallback = None, alarmTime = 0):
self.showMinutes = showMinutes
self.mode = mode
OTPTimer.OTPTimer.__init__(self)
self['text_pos'] = (0, 0)
self['text_font'] = PiratesGlobals.getPirateOutlineFont()
self['text'] = ''
self.setFontColor(PiratesGuiGlobals.TextFG8)
self.initialiseoptions(PiratesTimer)
self.loadDials()
self.setScale(1)
self.alarmTime = alarmTime
self.dialInterval = None
self.alarmInterval = None
self.alarmStarted = None
if self.alarmTime > 0:
self.alarmSfx = loadSfx(SoundGlobals.SFX_GUI_ALARM)
self.outOfTimeSfx = loadSfx(SoundGlobals.SFX_GUI_OUT_OF_TIME)
if titleText or infoText:
self.createTimerText(titleText, titleFg, infoText)
if cancelCallback:
self.createCancelButton(cancelCallback, cancelText)
self.slide = False
self.end = False
def __init__(self, tabBar, name, **kw):
optiondefs = (
("modelName", "general_frame_c", None),
("frameSize", (0, 0.20499999999999999, 0.0, 0.10000000000000001), None),
("borderScale", 0.13500000000000001, None),
("bgBuffer", 0.14000000000000001, None),
("showBackground", True, None),
("bgColorScale", VBase4(0, 0, 0, 1), None),
("flatten", 0, None),
("label", "", None),
("textMayChange", 0, None),
("textpos", (0.10000000000000001, 0.025000000000000001, 0), None),
)
self.defineoptions(kw, optiondefs)
TopTab.__init__(self, tabBar, name)
self.initialiseoptions(ShipTab)
self.guiComponents["background"].setTransparency(0, 1)
self.label = DirectLabel(
parent=self,
relief=None,
state=DGG.DISABLED,
text=name,
text_pos=self["textpos"],
text_scale=0.050000000000000003,
text_align=TextNode.ACenter,
text_fg=PiratesGuiGlobals.TextFG1,
text_shadow=PiratesGuiGlobals.TextShadow,
text_font=PiratesGlobals.getInterfaceFont(),
textMayChange=1,
)
def createLevelUpAlert(self, duration, position, posChange):
textGenerator = TextNode('textGenerator')
textGenerator.setText(PLocalizer.LevelUp)
textGenerator.setFont(PiratesGlobals.getPirateOutlineFont())
textGenerator.clearShadow()
textGenerator.setAlign(TextNode.ACenter)
textGenerator.setTextColor(1.0, 1.0, 1.0, 1.0)
textScale = 0.074999999999999997
newTextNode = textGenerator.generate()
newTextDummy = render2d.attachNewNode(newTextNode)
newTextDummy.setPos(render2d, position)
newTextDummy.setHpr(render2d, 0.0, 0.0, 0.0)
newTextDummy.setScale(textScale)
newTextDummy.setBin('gui-popup', 0)
if hasattr(self, 'moveUpIval'):
self.moveUpIval.finish()
del self.moveUpIval
if hasattr(self, 'scaleDown'):
self.scaleDown.finish()
del self.scaleDown
if hasattr(self, 'fadeOut'):
self.fadeOut.finish()
del self.fadeOut
if hasattr(self, 'track'):
self.track.finish()
del self.track
self.moveUpIval = newTextDummy.posInterval(duration, position + posChange)
self.scaleDown = newTextDummy.scaleInterval(duration * 0.75, textScale * 0.69999999999999996, blendType = 'easeInOut')
self.fadeOut = newTextDummy.colorScaleInterval(duration * 0.25, Vec4(0, 0, 0, 0))
self.track = Sequence(Parallel(self.moveUpIval, Sequence(Wait(0.25), self.scaleDown), Sequence(Wait(0.75), self.fadeOut)), Func(self.removeExpAlert, newTextDummy))
self.track.start()
def addTextMessage(self, text, seconds = 7, priority = 0, color = (0, 0, 0, 1), icon = (), modelName = 'general_frame_b', name = None, avId = None, playerName = None):
if name and playerName:
t2 = text % (playerName, name)
elif name:
t2 = text % name
elif playerName:
t2 = text % playerName
else:
t2 = text
if self.lastMessage == t2:
return None
msg = StackMessage(parent = self, text = t2, text_wordwrap = 15.5, text_align = TextNode.ALeft, text_scale = 0.035000000000000003, text_fg = color, text_pos = (0.17000000000000001, -0.071999999999999995, 0), textMayChange = 1, time = seconds, priority = priority, icon = icon, modelName = modelName)
if name and playerName:
buttonText = text % playerName
else:
buttonText = text
if name or playerName:
msg['text_fg'] = (0, 0, 0, 0)
if name:
nameArray = ('\x01CPOrangeHEAD\x01' + name + '\x02', '\x01CPOrangeHEAD\x01' + name + '\x02', '\x01CPOrangeOVER\x01' + name + '\x02', '\x01CPOrangeHEAD\x01' + name + '\x02')
else:
nameArray = ('\x01CPOrangeHEAD\x01' + playerName + '\x02', '\x01CPOrangeHEAD\x01' + playerName + '\x02', '\x01CPOrangeOVER\x01' + playerName + '\x02', '\x01CPOrangeHEAD\x01' + playerName + '\x02')
if name:
nameButton = DirectButton(parent = NodePath(), relief = None, text = nameArray, text_align = TextNode.ALeft, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 0, command = self.handleAvatarTextPress, extraArgs = [
avId,
name])
else:
nameButton = DirectButton(parent = NodePath(), relief = None, text = nameArray, text_align = TextNode.ALeft, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 0, command = self.handlePlayerTextPress, extraArgs = [
avId,
playerName])
(left, right, bottom, top) = nameButton.getBounds()
nameGFX = TextGraphic(nameButton, left, right, 0, 1)
if name:
buttonName = '\x05' + name + '\x05'
else:
buttonName = '\x05' + playerName + '\x05'
buttonText = buttonText % buttonName
tpMgr = TextPropertiesManager.getGlobalPtr()
if name:
tpMgr.setGraphic(name, nameGFX)
else:
tpMgr.setGraphic(playerName, nameGFX)
del tpMgr
textRender = TextNode('textRender')
textRender.setFont(PiratesGlobals.getInterfaceFont())
textRender.setTextColor(PiratesGuiGlobals.TextFG14)
textRender.setShadowColor(PiratesGuiGlobals.TextShadow)
textRender.setWordwrap(15.5)
textRender.setTabWidth(1.0)
textRender.setShadow(0.080000000000000002, 0.080000000000000002)
textRender.setText(buttonText)
x = msg.attachNewNode(textRender.generate())
x.setScale(0.035000000000000003)
x.setPos(0.16700000000000001, 0, -0.072999999999999995)
self.addMessage(msg)
self.lastMessage = t2
return msg
def setupGui(self):
self.destroyGui()
if not self.guiSetup:
self.button = DialogButton(parent = self, buttonStyle = DialogButton.NO, pos = (0.25, 0, 0.080000000000000002), text = PLocalizer.lClose, helpPos = (-0.40000000000000002, 0, 0.029999999999999999), helpDelay = 0.29999999999999999, command = self['command'], extraArgs = self['extraArgs'])
self.background = BorderFrame(parent = self, pos = (0.050000000000000003, 0, 0.050000000000000003), frameSize = [
0.0,
0.40000000000000002,
0.10000000000000001,
0.59999999999999998], bgColorScale = VBase4(0, 0, 0, 0.75), bgTransparency = 1, flatten = 0)
if self['ownShip']:
state = DGG.NORMAL
else:
state = DGG.DISABLED
ship = localAvatar.getShip()
if ship:
friendState = ship.getAllowFriendState()
crewState = ship.getAllowCrewState()
guildState = ship.getAllowGuildState()
publicState = ship.getAllowPublicState()
else:
friendState = 0
crewState = 0
guildState = 0
publicState = 0
buttonOptions = {
'parent': self.background,
'state': state,
'relief': None,
'pos': (0.059999999999999998, 0, 0.53000000000000003),
'scale': 0.29999999999999999,
'text': PLocalizer.CrewBoardingAccessAllowFriends,
'value': friendState,
'text_pos': (0.16700000000000001, -0.059999999999999998, 0),
'text0_fg': PiratesGuiGlobals.TextFG1,
'text1_fg': PiratesGuiGlobals.TextFG1,
'text2_fg': PiratesGuiGlobals.TextFG1,
'text3_fg': PiratesGuiGlobals.TextFG9,
'text_font': PiratesGlobals.getInterfaceFont(),
'text_scale': 0.14999999999999999,
'text_shadow': (0, 0, 0, 1),
'text_align': TextNode.ALeft,
'command': self.allowFriends }
self.friendsButton = CheckButton(**None)
buttonOptions['text'] = PLocalizer.CrewBoardingAccessAllowCrew
buttonOptions['pos'] = (buttonOptions['pos'][0], buttonOptions['pos'][1], buttonOptions['pos'][2] - 0.12)
buttonOptions['command'] = self.allowCrew
buttonOptions['value'] = crewState
self.crewButton = CheckButton(**None)
buttonOptions['text'] = PLocalizer.CrewBoardingAccessAllowGuild
buttonOptions['pos'] = (buttonOptions['pos'][0], buttonOptions['pos'][1], buttonOptions['pos'][2] - 0.12)
buttonOptions['command'] = self.allowGuild
buttonOptions['value'] = guildState
self.guildButton = CheckButton(**None)
buttonOptions['text'] = PLocalizer.CrewBoardingAccessAllowPublic
buttonOptions['pos'] = (buttonOptions['pos'][0], buttonOptions['pos'][1], buttonOptions['pos'][2] - 0.12)
buttonOptions['command'] = self.allowPublic
buttonOptions['value'] = publicState
self.publicButton = CheckButton(**None)
self.guiSetup = True
def __init__(self, w, h, locationId = LocationIds.PORT_ROYAL_ISLAND):
GuiPanel.GuiPanel.__init__(self, '', w, h, True)
self.card = loader.loadModel('models/gui/pir_m_gui_fsh_legendaryScreen')
self.storyImageCard = loader.loadModel('models/minigames/pir_m_gam_fsh_legendaryGui')
self.UICompoments = { }
self.setPos(-1.1499999999999999, 0.0, -0.59999999999999998)
self['geom'] = self.card.find('**/background')
self['geom_pos'] = (0.57999999999999996, 0.0, 0.63)
self['geom_scale'] = (0.94999999999999996, 0.0, 0.84999999999999998)
self.coinImage = OnscreenImage(parent = self, image = self.card.find('**/coin'), scale = 0.90000000000000002, hpr = (0, 0, 0), pos = (0.84999999999999998, 0, 0.84999999999999998))
self.titleTextNode = TextNode('legendPanelTitle')
self.titleTextNode.setText(PLocalizer.LegendSelectionGui['panelTitle'])
self.titleTextNode.setFont(PiratesGlobals.getPirateFont())
self.titleTextNode.setTextColor(0.87, 0.81999999999999995, 0.54000000000000004, 0.90000000000000002)
self.titleTextNodePath = NodePath(self.titleTextNode)
self.titleTextNodePath.setPos(0.65000000000000002, 0.0, 1.2)
self.titleTextNodePath.setScale(0.070000000000000007)
self.titleTextNodePath.reparentTo(self)
self.introTextNode = TextNode('legendaryIntroTextNode')
self.introTextNode.setText(PLocalizer.LegendSelectionGui['legendIntro'])
self.introTextNode.setWordwrap(14.0)
self.introTextNode.setTextColor(0.90000000000000002, 0.80000000000000004, 0.46999999999999997, 0.90000000000000002)
self.introTextNodePath = NodePath(self.introTextNode)
self.introTextNodePath.setPos(0.59999999999999998, 0.0, 0.5)
self.introTextNodePath.setScale(0.042000000000000003)
self.introTextNodePath.reparentTo(self)
self.buttonRootNode = NodePath('button_RootNode')
self.buttonRootNode.reparentTo(self)
self.buttonRootNode.setPos(-0.080000000000000002, 0.0, 1.1499999999999999)
self.iconCard = loader.loadModel('models/gui/treasure_gui')
self.legendSelectionButtons = { }
btnGeom = (self.card.find('**/fishButton/idle'), self.card.find('**/fishButton/idle'), self.card.find('**/fishButton/over'))
for i in range(len(FishingGlobals.legendaryFishData)):
fishName = FishingGlobals.legendaryFishData[i]['name']
fishId = FishingGlobals.legendaryFishData[i]['id']
assetsKey = CollectionMap.Assets[fishId]
pos_x = 0.29999999999999999
pos_z = 0.0 - i * 0.25
button = GuiButton(parent = self.buttonRootNode, text = (fishName, fishName, fishName, fishName), text0_fg = (0.42999999999999999, 0.28999999999999998, 0.19, 1.0), text1_fg = (0.42999999999999999, 0.28999999999999998, 0.19, 1.0), text2_fg = (0.42999999999999999, 0.28999999999999998, 0.19, 1.0), text3_fg = (0.42999999999999999, 0.28999999999999998, 0.19, 1.0), text_scale = 0.035000000000000003, text_pos = (0.037999999999999999, -0.0050000000000000001), pos = (pos_x, 0, pos_z), hpr = (0, 0, 0), scale = 1.5, image = btnGeom, image_pos = (0, 0, 0), image_scale = 0.69999999999999996, sortOrder = 2, command = self.buttonClickHandle, extraArgs = [
fishId,
assetsKey,
locationId])
button.icon = OnscreenImage(parent = button, image = self.iconCard.find('**/%s*' % assetsKey), scale = 0.34999999999999998, hpr = (0, 0, 0), pos = (-0.123, 0, 0.0050000000000000001))
self.legendPanel = GuiPanel.GuiPanel('', 2.6000000000000001, 1.8999999999999999, True)
self.legendPanel.setPos(-1.3, 0.0, -0.94999999999999996)
self.legendPanel.background = OnscreenImage(parent = self.legendPanel, scale = (2.3999999999999999, 0, 1.8), image = self.storyImageCard.find('**/pir_t_gui_fsh_posterBackground'), hpr = (0, 0, 0), pos = (1.3, 0, 0.94999999999999996))
self.legendPanel.storyImage = OnscreenImage(parent = self.legendPanel, scale = 1, image = self.card.find('**/coin'), hpr = (0, 0, 0), pos = (1.8, 0, 1))
self.storyTextNode = TextNode('storyTextNode')
self.storyTextNode.setText('')
self.storyTextNode.setWordwrap(19.0)
self.storyTextNode.setTextColor(0.23000000000000001, 0.089999999999999997, 0.029999999999999999, 1.0)
self.storyTextNodePath = NodePath(self.storyTextNode)
self.storyTextNodePath.setPos(0.33000000000000002, 0.0, 1.6699999999999999)
self.storyTextNodePath.setScale(0.050000000000000003)
self.storyTextNodePath.reparentTo(self.legendPanel)
self.callBack = None
self.legendPanel.hide()
def createGui(self):
(item, quantity) = self.data
name = PLocalizer.InventoryTypeNames[item]
self.price = EconomyGlobals.getItemCost(item)
repId = InventoryType.SailingRep
itemTypeName = PLocalizer.InventoryTypeNames.get(repId)
self.itemType = itemTypeName
if self.sell:
self.price /= 2
card = loader.loadModel("models/textureCards/shipCatalog")
renderName = self.shipImageDict.get(item, "Catalog_War_Brig")
myTexCard = card.find("**/%s*" % renderName)
myTex = myTexCard.findAllTextures()[0]
card.removeNode()
del card
self.minLvl = EconomyGlobals.getItemMinLevel(item)
self.miscText = None
self.picture = DirectFrame(
parent=self,
relief=None,
state=DGG.DISABLED,
image=myTex,
image_scale=(0.070000000000000007, 1.0, 0.059999999999999998),
)
self.picture.setPos(0.10000000000000001, 0, 0.080000000000000002)
self.picture.setTransparency(1)
self.nameTag = DirectLabel(
parent=self,
state=DGG.DISABLED,
relief=None,
text=name,
text_scale=PiratesGuiGlobals.TextScaleMed * PLocalizer.getHeadingScale(2),
text_align=TextNode.ALeft,
text_fg=PiratesGuiGlobals.TextFG1,
text_shadow=PiratesGuiGlobals.TextShadow,
textMayChange=0,
)
self.nameTag.setPos(0.20000000000000001, 0, 0.10000000000000001)
self.costText = DirectLabel(
parent=self,
relief=None,
state=DGG.DISABLED,
geom=self.coinImage,
geom_scale=0.12,
geom_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),
text_font=PiratesGlobals.getInterfaceFont(),
)
self.costText.setPos(0.47999999999999998, 0, 0.040000000000000001)
def _CannonDefenseHelpPanel__createHeaderText(self, parent, text):
header = TextNode('Header')
header.setFont(PiratesGlobals.getInterfaceFont())
header.setTextColor(PiratesGuiGlobals.TextFG1)
header.setAlign(TextNode.ALeft)
header.setText(text)
headerNode = parent.attachNewNode(header)
headerNode.setScale(0.065000000000000002)
headerNode.setZ(0.0)
headerNode.setDepthTest(False)
def genTextEffect(targetObj, textGenerator, number, bonus, isNpc, cleanupCallback, startPos, destPos = None, scale = 1.0, modifiers = { }, effects = []):
textGenerator.setFont(PiratesGlobals.getPirateOutlineFont())
(text, baseVal, mods) = genText(number, bonus, MOD_TYPE_MULTIPLE, modifiers, effects)
duration = 2.0 + len(mods)
textGenerator.setText(text % str(baseVal))
textGenerator.clearShadow()
textGenerator.setAlign(TextNode.ACenter)
color = genColor(number, bonus, isNpc, effects)
newEffect = TextEffect(textGenerator, bonus, targetObj, scale, startPos, duration, text, baseVal, mods, cleanupCallback, destPos, color)
return newEffect
def __init__(self, manager, sizeX=1.0, sizeZ=1.0, countX=1, countZ=1, hotkeyList=[]):
InventoryUIContainer.InventoryUIContainer.__init__(
self, manager, sizeX, sizeZ, countX, countZ, cellInfo=hotkeyList
)
self.containerType = CONTAINER_BELT
gui = loader.loadModel("models/gui/gui_icons_weapon")
self.cellImage = gui.find("**/pir_t_gui_frm_inventoryBox")
self.initialiseoptions(InventoryUIBeltGrid)
self.rightClickAction = {
InventoryType.ItemTypeWeapon: (Locations.RANGE_WEAPONS, None, 0),
InventoryType.ItemTypeCharm: (Locations.RANGE_WEAPONS, None, 1),
}
self.freeWeaponInfo = DirectLabel(
parent=self,
relief=None,
textMayChange=0,
text=PLocalizer.FreeWeaponFromBlackSmith,
text_font=PiratesGlobals.getPirateBoldOutlineFont(),
text_fg=PiratesGuiGlobals.TextFG2,
text_scale=0.040000000000000001,
text_align=TextNode.ACenter,
text_shadow=PiratesGuiGlobals.TextShadow,
text_pos=(0, 0),
)
self.freeWeaponInfo.setPos(0.34999999999999998, 0, -0.10000000000000001)
self.freeWeaponInfo.show()
self.overflowInfo = DirectLabel(
parent=self,
relief=None,
textMayChange=0,
text=PLocalizer.OverflowHint,
text_font=PiratesGlobals.getPirateBoldOutlineFont(),
text_fg=PiratesGuiGlobals.TextFG2,
text_scale=0.040000000000000001,
text_align=TextNode.ACenter,
text_shadow=PiratesGuiGlobals.TextShadow,
text_pos=(0, 0),
)
self.overflowInfo.setPos(0.34999999999999998, 0, -0.10000000000000001)
self.overflowInfo.hide()
self.accept("overflowChanged", self.handleOverflow)
self.accept("newItemHeld", self.handleNewHeldItem)
self.accept("checkForWeapons", self.checkforNoWeapons)
def makeCell(self, cellImage = None, imageScale = None, imagePos = None):
returnCell = InventoryUIContainer.InventoryUIContainer.makeCell(self, cellImage, imageScale, imagePos)
textScale = 0.29999999999999999 * self.cellSizeX
returnCell.label['text_align'] = TextNode.ALeft
returnCell.label['text_scale'] = textScale
returnCell.label['text_font'] = PiratesGlobals.getInterfaceOutlineFont()
returnCell.label['text_pos'] = (0.55000000000000004 * self.cellSizeX - 0, 0.45000000000000001 * self.cellSizeZ - textScale)
returnCell.label['text_wordwrap'] = self.spaceSizeX / textScale
returnCell.hide()
return returnCell
def __init__(self, manager, sizeX = 1.0, sizeZ = 1.0, countX = 4, countZ = 4, minCountZ = 4, maxCountX = 5, itemList = None):
self.isReady = 0
InventoryUIStackContainer.InventoryUIStackContainer.__init__(self, manager, sizeX, sizeZ, minCountZ = minCountZ, maxCountX = maxCountX, itemList = itemList)
self.initialiseoptions(InventoryUICardContainer)
self.seperatorOn = 1
gui = loader.loadModel('models/gui/gui_main')
scale = 0.33500000000000002
self.background = self.attachNewNode('background')
self.background.setScale(scale)
self.background.setPos(0.34999999999999998, 0, 0.46000000000000002)
gui.find('**/gui_inv_cards').copyTo(self.background)
self.background.flattenStrong()
suitGui = loader.loadModel('models/gui/suit_icons')
cardImage = suitGui.find('**/pir_t_gui_frm_goldCircle')
if cardImage.isEmpty():
cardImage = None
i = 0
for suit in [
'h',
'd',
'c',
's']:
if suit in [
'h',
'd']:
suitColor = (0.69999999999999996, 0.69999999999999996, 0.69999999999999996, 1.0)
else:
suitColor = (1.0, 1.0, 1.0, 1.0)
suitFrame = DirectFrame(parent = self.background, relief = None, geom = suitGui.find('**/suit_icon_%s' % suit), geom_scale = 0.10000000000000001, geom_color = suitColor, image = cardImage, image_scale = 0.14999999999999999, pos = (i * 0.23400000000000001, 0, 0.90000000000000002))
i += 1
n = NodePath(suitFrame.node().getStateDef(0))
PiratesGlobals.flattenOrdered(n)
ng = n.getChild(0).copyTo(self.background)
ng.setPos(suitFrame.getPos())
n.getChild(0).hide()
PiratesGlobals.flattenOrdered(self.background)
self.cardDict = { }
self.updateList = []
self.cardGroup = self.attachNewNode('cardGroup')
self.cellSizeX = self.cellSizeX * 2.0
def _CannonDefenseHelpPanel__createBodyText(self, parent, text, wordWrap):
body = TextNode('Body')
body.setFont(PiratesGlobals.getInterfaceFont())
body.setTextColor(PiratesGuiGlobals.TextFG2)
body.setAlign(TextNode.ALeft)
body.setWordwrap(wordWrap)
body.setText(text)
bodyNode = parent.attachNewNode(body)
bodyNode.setScale(0.050000000000000003)
bodyNode.setZ(-0.070000000000000007)
bodyNode.setDepthTest(False)
def _CannonDefenseTimeRemainingUI__createWaveText(self, parent):
self.waveNumberTxt = TextNode('WaveNumber')
self.waveNumberTxt.setFont(PiratesGlobals.getInterfaceFont())
self.waveNumberTxt.setTextColor(PiratesGuiGlobals.TextFG1)
self.waveNumberTxt.setShadow(0.050000000000000003, 0.050000000000000003)
self.waveNumberTxt.setAlign(TextNode.ACenter)
waveTxtNode = parent.attachNewNode(self.waveNumberTxt)
waveTxtNode.setScale(0.12)
waveTxtNode.setPos(0, -0.20000000000000001, -0.080000000000000002)
waveTxtNode.setDepthTest(False)
waveTxtNode.setDepthWrite(False)
def _CannonDefenseGoldRemaingUI__createTextLabel(self, parent):
goldLabelTxt = TextNode("TreasureRemaining")
goldLabelTxt.setFont(PiratesGlobals.getInterfaceFont())
goldLabelTxt.setTextColor(PiratesGuiGlobals.TextFG1)
goldLabelTxt.setAlign(TextNode.ACenter)
goldLabelTxt.setText(PLocalizer.CannonDefense["TreasureRemaining"])
goldTxtNode = parent.attachNewNode(goldLabelTxt)
goldTxtNode.setScale(0.029999999999999999)
goldTxtNode.setX(0.035000000000000003)
goldTxtNode.setZ(0.0050000000000000001)
goldTxtNode.setDepthTest(False)
goldTxtNode.setDepthWrite(False)
def _CannonDefenseTimeRemainingUI__createWaveLabel(self, parent):
self.waveLabelTxt = TextNode('WaveLabel')
self.waveLabelTxt.setFont(PiratesGlobals.getInterfaceFont())
self.waveLabelTxt.setTextColor(PiratesGuiGlobals.TextFG1)
self.waveLabelTxt.setShadow(0.050000000000000003, 0.050000000000000003)
self.waveLabelTxt.setAlign(TextNode.ACenter)
self.waveLabelTxt.setText(PLocalizer.CannonDefense['WaveLabel'])
waveLblNode = parent.attachNewNode(self.waveLabelTxt)
waveLblNode.setScale(0.059999999999999998)
waveLblNode.setPos(0, -0.20000000000000001, 0.014999999999999999)
waveLblNode.setDepthTest(False)
waveLblNode.setDepthWrite(False)
def initLureHelpText(self):
self.helpTextNode = TextNode("fishBitingIcon")
self.helpTextNodePath = NodePath(self.helpTextNode)
self.helpTextNodePath.setPos(0.0, 0.0, 0.69999999999999996)
self.helpTextNode.setText(" ")
self.helpTextNode.setAlign(TextNode.ACenter)
self.helpTextNode.setFont(PiratesGlobals.getPirateFont())
self.helpTextNode.setTextColor(1.0, 1.0, 1.0, 1.0)
self.helpTextNodePath.reparentTo(self)
self.helpTextNodePath.setBillboardPointEye()
self.helpTextNodePath.setBin("fishingGame", 10)
self.helpTextNodePath.hide()
def makeCheckbox(self, pos, text, command, initialState, extraArgs, levelText):
charGui = loader.loadModel('models/gui/toplevel_gui')
buttonImage = (charGui.find('**/generic_button'), charGui.find('**/generic_button'), charGui.find('**/generic_button'), charGui.find('**/generic_button'))
geomCheck = [
charGui.find('**/generic_check'),
charGui.find('**/generic_check'),
charGui.find('**/generic_check'),
None]
c = DirectCheckButton(parent = self, relief = None, scale = 0.064000000000000001, boxBorder = 0.080000000000000002, boxRelief = None, boxImage = geomCheck, boxImageScale = 6, boxImageColor = VBase4(0, 1, 0, 1), pos = pos, text = text, text_fg = PiratesGuiGlobals.TextFG1, text_scale = 0.5, text_pos = (-2.3999999999999999, 0, -2.7999999999999998), text_align = TextNode.ALeft, text_font = PiratesGlobals.getInterfaceOutlineFont(), indicator_pos = (2.2000000000000002, 0, 0.14999999999999999), command = command, indicatorValue = initialState, extraArgs = extraArgs, text0_fg = PiratesGuiGlobals.TextFG1, text1_fg = PiratesGuiGlobals.TextFG1, text2_fg = PiratesGuiGlobals.TextFG1, text3_fg = PiratesGuiGlobals.TextFG1, text_shadow = PiratesGuiGlobals.TextShadow, image = buttonImage, image_pos = (0, 0, 0.14999999999999999), image_scale = (6, 1, 2.4500000000000002), state = DGG.DISABLED)
l = DirectLabel(parent = c, text = levelText, text_font = PiratesGlobals.getInterfaceFont(), text_scale = 0.5, text_align = TextNode.ALeft, frameColor = (0.80000000000000004, 0.69999999999999996, 0.5, 1), pos = (-0.29999999999999999, 0, 0))
c.setIndicatorValue()
del charGui
return c
def _createBankNoteText(self):
textPlaceHolder = self.panel.find('**/text')
self.bankNoteTxt = TextNode('BankNoteText')
self.bankNoteTxt.setFont(PiratesGlobals.getInterfaceFont())
self.bankNoteTxt.setTextColor(PiratesGuiGlobals.TextFG1)
self.bankNoteTxt.setShadow(0.050000000000000003, 0.050000000000000003)
self.bankNoteTxt.setAlign(TextNode.ALeft)
bankNoteTxtNode = textPlaceHolder.attachNewNode(self.bankNoteTxt)
bankNoteTxtNode.setScale(0.014999999999999999)
bankNoteTxtNode.setDepthTest(False)
bankNoteTxtNode.setDepthWrite(False)
bankNoteTxtNode.setPos(-0.02, 0, 0)
self.updateBankNoteText()
def announceGenerate(self):
DistributedGameTable.DistributedGameTable.announceGenerate(self)
self.timerLabel = DirectLabel(
relief=None,
text="",
text_fg=(1, 1, 1, 1),
text_shadow=(0, 0, 0, 1),
textMayChange=1,
text_font=PiratesGlobals.getPirateOutlineFont(),
)
self.timerLabel.setZ(5)
self.timerLabel.setBillboardPointEye()
self.timerLabel.reparentTo(self)
self.resultsFrame = ResultsFrame()
def createLevelUpAlert(self, duration, position, posChange):
textGenerator = TextNode('textGenerator')
textGenerator.setText(PLocalizer.LevelUp)
textGenerator.setFont(PiratesGlobals.getPirateOutlineFont())
textGenerator.clearShadow()
textGenerator.setAlign(TextNode.ACenter)
textGenerator.setTextColor(1.0, 1.0, 1.0, 1.0)
textScale = 0.074999999999999997
newTextNode = textGenerator.generate()
newTextDummy = render2d.attachNewNode(newTextNode)
newTextDummy.setPos(render2d, position)
newTextDummy.setHpr(render2d, 0.0, 0.0, 0.0)
newTextDummy.setScale(textScale)
newTextDummy.setBin('gui-popup', 0)
if hasattr(self, 'moveUpIval'):
self.moveUpIval.finish()
del self.moveUpIval
if hasattr(self, 'scaleDown'):
self.scaleDown.finish()
del self.scaleDown
if hasattr(self, 'fadeOut'):
self.fadeOut.finish()
del self.fadeOut
if hasattr(self, 'track'):
self.track.finish()
del self.track
self.moveUpIval = newTextDummy.posInterval(duration,
position + posChange)
self.scaleDown = newTextDummy.scaleInterval(duration * 0.75,
textScale *
0.69999999999999996,
blendType='easeInOut')
self.fadeOut = newTextDummy.colorScaleInterval(duration * 0.25,
Vec4(0, 0, 0, 0))
self.track = Sequence(
Parallel(self.moveUpIval, Sequence(Wait(0.25), self.scaleDown),
Sequence(Wait(0.75), self.fadeOut)),
Func(self.removeExpAlert, newTextDummy))
self.track.start()
def initializeNametag3d(self):
Avatar.Avatar.initializeNametag3d(self)
self.nametag3d.setFogOff()
self.nametag3d.setLightOff()
self.nametag3d.setColorScaleOff(100)
self.nametag3d.setH(self.getGeomNode().getH())
self.nametag.setFont(PiratesGlobals.getPirateBoldOutlineFont())
self.iconNodePath = self.nametag.getNameIcon()
if self.iconNodePath.isEmpty():
self.notify.warning('empty iconNodePath in initializeNametag3d')
return 0
if not self.nameText:
self.nameText = OnscreenText(fg = Vec4(1, 1, 1, 1), bg = Vec4(0, 0, 0, 0), scale = 1.1000000000000001, align = TextNode.ACenter, mayChange = 1, font = PiratesGlobals.getPirateBoldOutlineFont())
self.nameText.reparentTo(self.iconNodePath)
self.nameText.setTransparency(TransparencyAttrib.MDual, 2)
self.nameText.setColorScaleOff(100)
self.nameText.setLightOff()
self.nameText.setFogOff()
def updateBrigadeText(self):
if self.brigadeText and self.parentObj.minimapArea:
self.brigadeText.destroy()
self.brigadeText = None
elif not (self.brigadeText) and not (
self.parentObj.minimapArea) and self.parentObj.minimap:
self.brigadeText = DirectLabel(
parent=self.parentObj.minimap.getOverlayNode(),
relief=None,
text=PLocalizer.InvasionJollyRogerBrigadeUpdate %
(self.currentPhase, self.totalPhases - self.currentPhase),
text_align=TextNode.ALeft,
text_fg=PiratesGuiGlobals.TextFG2,
text_font=PiratesGlobals.getPirateOutlineFont(),
text_shadow=PiratesGuiGlobals.TextShadow,
textMayChange=1,
scale=60,
pos=(-800, -200, 0),
hpr=(0, -90, 0))
def handleAvatarTeleportResponse(self, avId, available, shardId,
instanceDoId, areaDoId):
if not avId == self.teleportQueryId:
self.clearTeleportQueryId()
return None
self.clearTeleportQueryId()
handle = self.cr.identifyAvatar(avId)
if handle:
avName = handle.getName()
else:
return None
if available == PiratesGlobals.TAAvailable:
def teleportConfirmation(confirmed,
shardId=shardId,
instanceDoID=instanceDoId,
avId=avId,
avatarParentId=areaDoId):
if confirmed:
self.requestTeleportToAvatar(shardId,
instanceDoId,
avatarId=avId,
avatarParentId=areaDoId)
teleportConfirmation = report(
types=['args', 'deltaStamp'],
dConfigParam='teleport')(teleportConfirmation)
localAvatar.setTeleportFlag(
PiratesGlobals.TFSameArea,
localAvatar.confirmNotSameAreaTeleportToPlayer, [areaDoId])
localAvatar.confirmTeleport(teleportConfirmation, feedback=True)
localAvatar.clearTeleportFlag(PiratesGlobals.TFSameArea)
else:
flag = PiratesGlobals.decodeTeleportFlag(available)
if flag == PiratesGlobals.TAIgnore:
pass
1
if flag in PiratesGlobals.TFNoTeleportToReasons:
localAvatar.guiMgr.createWarning(
PiratesGlobals.TFNoTeleportToReasons[flag] % avName,
duration=10)
def __init__(self, other=None):
Biped.Biped.__init__(self, other, HumanAnimationMixer)
self.model = None
self.zombie = False
self.crazyColorSkin = False
self.crazyColorSkinIndex = 0
self.flattenPending = None
if __dev__:
self.optimizeLOD = base.config.GetBool('optimize-avatar-lod', 1)
else:
self.optimizeLOD = 0
self.master = 0
self.loaded = 0
self.playingRate = None
self.shadowFileName = 'models/misc/drop_shadow'
self.setFont(PiratesGlobals.getInterfaceFont())
self.__blinkName = 'blink-' + str(self.this)
self.eyeLids = None
self.eyeBalls = None
self.eyeIris = None
self.reducedAnimList = None
self.headNode = None
self.extraNode = None
self.scaleNode = None
self.rootNode = None
self.floorOffsetZ = 0.0
self.headFudgeHpr = Vec3(0, 0, 0)
self.randGen = random.Random()
self.randGen.seed(random.random())
self.eyeFSM = ClassicFSM('eyeFSM', [
State('off', self.enterEyeFSMOff, self.exitEyeFSMOff,
['open', 'closed']),
State('open', self.enterEyeFSMOpen, self.exitEyeFSMOpen,
['closed', 'off']),
State('closed', self.enterEyeFSMClosed, self.exitEyeFSMClosed,
['open', 'off'])
], 'off', 'off')
self.eyeFSM.enterInitialState()
self.isPaid = True
if other != None:
self.copyHuman(other)
return
def __init__(self, avId, avName):
guiMain = loader.loadModel('models/gui/gui_main')
DirectFrame.__init__(self, relief = None, pos = (-0.59999999999999998, 0, 0.46999999999999997), image = guiMain.find('**/general_frame_e'), image_pos = (0.25, 0, 0.27500000000000002), image_scale = 0.25)
guiMain.removeNode()
self.initialiseoptions(CrewInvitee)
self.avId = avId
self.avName = avName
if base.cr.avatarFriendsManager.checkIgnored(self.avId):
self._CrewInvitee__handleNo()
return None
self.title = DirectLabel(parent = self, relief = None, text = PLocalizer.CrewInviteeTitle, text_scale = PiratesGuiGlobals.TextScaleExtraLarge, text_align = TextNode.ACenter, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_font = PiratesGlobals.getPirateOutlineFont(), pos = (0.25, 0, 0.41999999999999998), image = None, image_scale = 0.25)
nameArray = ('\x01CPOrangeHEAD\x01' + self.avName + '\x02', '\x01CPOrangeHEAD\x01' + self.avName + '\x02', '\x01CPOrangeOVER\x01' + self.avName + '\x02', '\x01CPOrangeHEAD\x01' + self.avName + '\x02')
nameButton = DirectButton(parent = NodePath(), relief = None, text = nameArray, text_align = TextNode.ALeft, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 0, command = self.handleAvatarPress, extraArgs = [
avId,
avName])
(left, right, bottom, top) = nameButton.getBounds()
nameGFX = TextGraphic(nameButton, left, right, 0, 1)
buttonName = '\x05' + self.avName + '\x05'
buttonText = PLocalizer.CrewInviteeInvitation % buttonName
tpMgr = TextPropertiesManager.getGlobalPtr()
tpMgr.setGraphic(self.avName, nameGFX)
del tpMgr
textRender = TextNode('textRender')
textRender.setFont(PiratesGlobals.getInterfaceFont())
textRender.setTextColor(PiratesGuiGlobals.TextFG2)
textRender.setAlign(TextNode.ACenter)
textRender.setShadowColor(PiratesGuiGlobals.TextShadow)
textRender.setWordwrap(11)
textRender.setTabWidth(1.0)
textRender.setShadow(0.080000000000000002, 0.080000000000000002)
textRender.setText(buttonText)
textNode = self.attachNewNode(textRender.generate())
textNode.setScale(PiratesGuiGlobals.TextScaleLarge)
textNode.setPos(0.25, 0, 0.32500000000000001)
self.bOk = CrewInviteeButton(text = PLocalizer.CrewInviteeOK, command = self._CrewInvitee__handleOk)
self.bOk.reparentTo(self)
self.bOk.setPos(0.10000000000000001, 0, 0.050000000000000003)
self.bNo = CrewInviteeButton(text = PLocalizer.CrewInviteeNo, command = self._CrewInvitee__handleNo)
self.bNo.reparentTo(self)
self.bNo.setPos(0.29999999999999999, 0, 0.050000000000000003)
self.accept('BandRequestCancel-%s' % (self.avId,), self._CrewInvitee__handleCancelFromAbove)
def enterWhisper(self, avatarName='John Sharkbait', whisperId=0):
self.whisperName = avatarName
self.whisperId = whisperId
self.chatTabs.stash()
self.whisperTabs.unstash()
if self.whisperNameLabel:
self.whisperNameLabel.destroy()
self.whisperNameLabel = DirectLabel(
parent=self.whisperTabs.getTab('Name'),
relief=None,
state=DGG.DISABLED,
text=avatarName,
text_scale=(self.myTextScale * self.iPercentage, self.myTextScale,
self.myTextScale),
text_align=TextNode.ALeft,
text_fg=PiratesGuiGlobals.TextFG2,
text_shadow=PiratesGuiGlobals.TextShadow,
text_pos=(0.21 * self.iPercentage, 0.04, 0),
text_font=PiratesGlobals.getInterfaceFont())
return
def __init__(self,
showMinutes=0,
mode=None,
titleText='',
titleFg=None,
infoText='',
cancelText='',
cancelCallback=None):
self.showMinutes = showMinutes
self.mode = mode
OTPTimer.OTPTimer.__init__(self)
self.initialiseoptions(PiratesTimerHourglass)
self['text_font'] = PiratesGlobals.getPirateOutlineFont()
self.setFontColor(Vec4(1, 1, 1, 1))
if titleText or infoText:
self.createTimerText(titleText, titleFg, infoText)
if cancelCallback:
self.createCancelButton(cancelCallback, cancelText)
self.getImage()
self.slide = False
def invArrived(inv):
if inv:
limit = localAvatar.getInventory().getStackLimit(
self.itemTuple[1])
if self.amount <= 1:
self['text'] = ' '
self['geom_color'] = (0.0, 0.0, 0.0, 0.0)
self['image_scale'] = 1.0
self.setPos(0.0, 0.0, 0.0)
elif self.showMax:
self['text'] = '%s/%s' % (self.amount, limit)
else:
self['text'] = 'x%s' % self.amount
self.configure(text_fg=PiratesGuiGlobals.TextFG0,
text_font=PiratesGlobals.getInterfaceFont(),
text_scale=PiratesGuiGlobals.TextScaleLarge,
text_pos=(0.050000000000000003,
0.042999999999999997))
self['image_scale'] = 1.5
self['geom_color'] = (1.0, 1.0, 1.0, 1.0)
def setTime(self, value):
if value < 0:
return None
number = TextNode('Number')
number.setFont(PiratesGlobals.getInterfaceFont())
number.setTextColor(PiratesGuiGlobals.TextFG1)
number.setAlign(TextNode.ACenter)
number.setShadow(0.050000000000000003, 0.050000000000000003)
number.setShadowColor(0, 0, 0, 1)
if value > 0:
number.setText(str(value))
else:
number.setText(PLocalizer.CannonDefenseHelp['BeginGame'])
numberNode = self.attachNewNode(number)
numberNode.setTransparency(1)
numberNode.setDepthTest(False)
numberNode.setDepthWrite(False)
seq = Sequence(Parallel(numberNode.scaleInterval(1, Vec3(0, 0, 0), Vec3(0.29999999999999999, 0.29999999999999999, 0.29999999999999999)), numberNode.colorScaleInterval(1, Vec4(1, 1, 1, 0), Vec4(1, 1, 1, 1))), Func(numberNode.removeNode))
seq.start()
def __init__(self, avId, avName):
guiMain = loader.loadModel('models/gui/gui_main')
DirectFrame.__init__(self,
relief=None,
pos=(-0.6, 0, 0.47),
image=guiMain.find('**/general_frame_e'),
image_pos=(0.25, 0, 0.275),
image_scale=0.25)
self.initialiseoptions(CrewBoot)
self.avId = avId
self.avName = avName
self.title = DirectLabel(
parent=self,
relief=None,
text=PLocalizer.CrewBootTitle,
text_scale=PiratesGuiGlobals.TextScaleExtraLarge,
text_align=TextNode.ACenter,
text_fg=PiratesGuiGlobals.TextFG2,
text_shadow=PiratesGuiGlobals.TextShadow,
text_font=PiratesGlobals.getPirateOutlineFont(),
pos=(0.25, 0, 0.42))
text = PLocalizer.CrewBootMessage % self.avName
self.message = DirectLabel(parent=self,
relief=None,
text=text,
text_scale=PiratesGuiGlobals.TextScaleLarge,
text_align=TextNode.ACenter,
text_fg=PiratesGuiGlobals.TextFG2,
text_shadow=PiratesGuiGlobals.TextShadow,
text_wordwrap=11,
pos=(0.25, 0, 0.325),
textMayChange=1)
self.bOk = CrewBootButton(text=PLocalizer.CrewBootOK,
command=self.__handleOk)
self.bOk.reparentTo(self)
self.bOk.setPos(0.1, 0, 0.05)
self.bNo = CrewBootButton(text=PLocalizer.CrewBootNo,
command=self.__handleNo)
self.bNo.reparentTo(self)
self.bNo.setPos(0.3, 0, 0.05)
return
def loadDials(self):
model = loader.loadModel('models/gui/gui_timer')
model.setScale(0.20000000000000001)
model.flattenLight()
PiratesTimer.ClockImage = model.find('**/timer_front')
PiratesTimer.BGImage = model.find('**/timer_back')
model.removeNode()
self.bgDial = DirectFrame(parent=self,
state=DGG.DISABLED,
relief=None,
image=self.BGImage)
self.fgLabel = DirectLabel(
parent=self,
state=DGG.DISABLED,
relief=None,
image=self.ClockImage,
image_pos=(-0.01, 0, 0.035000000000000003),
image_scale=(1.1000000000000001, 1, 0.80000000000000004),
text_scale=0.070000000000000007,
text_align=TextNode.ACenter,
text_font=PiratesGlobals.getPirateOutlineFont())
def __init__(self):
DirectObject.DirectObject.__init__(self)
self.event = None
self.sfx = None
self.text = DirectLabel(
parent=aspect2d,
relief=None,
text='',
text_align=TextNode.ACenter,
text_scale=0.059999999999999998,
text_fg=PiratesGuiGlobals.TextFG2,
text_shadow=PiratesGuiGlobals.TextShadow,
textMayChange=1,
pos=(0, 0, -0.90000000000000002),
text_font=PiratesGlobals.getPirateOutlineFont(),
sortOrder=80,
state=DGG.DISABLED)
self.text.hide()
self.fader = None
self.subtitleParent = render2d.attachNewNode(PGTop('subtitleParent'))
self.subtitleParent.node().setMouseWatcher(base.mouseWatcherNode)
def load(self, parent=None):
self.frame = BorderFrame(parent=parent,
frameSize=(-0.55000000000000004,
0.55000000000000004, -0.125,
0.125),
pos=(0, 0, -0.14999999999999999))
self.panelTitleText = DirectLabel(
parent=self.frame,
relief=None,
text=self.panelTitle,
text_scale=0.070000000000000007,
text_align=TextNode.ACenter,
text_font=PiratesGlobals.getPirateFont(),
text_fg=PiratesGuiGlobals.TextFG1,
text_shadow=(0, 0, 0, 1),
pos=(0, 0, 0.025000000000000001))
self.instructionsText = DirectLabel(parent=self.frame,
relief=None,
text=self.instructions,
text_scale=0.050000000000000003,
text_align=TextNode.ACenter,
text_wordwrap=40,
text_fg=(1, 1, 1, 1),
text_shadow=(0, 0, 0, 1),
pos=(0, 0, -0.029999999999999999))
self.frame.stash()
self.openSfx = loadSfx(SoundGlobals.SFX_GUI_SHOW_PANEL)
self.showPanelIval = Sequence(
Wait(2.0), Func(self.frame.unstash),
Func(base.playSfx, self.openSfx),
LerpPosInterval(self.frame,
0.5,
Point3(0, 0, -0.14999999999999999),
startPos=Point3(0, 0, 0.5),
blendType='easeOut'), Wait(self.duration),
LerpPosInterval(self.frame,
0.5,
Point3(0, 0, 0.5),
startPos=Point3(0, 0, -0.14999999999999999),
blendType='easeOut'), Func(self.frame.stash))
def __init__(self, avId, avName, crewType, openCrew):
guiMain = loader.loadModel('models/gui/gui_main')
DirectFrame.__init__(self, relief = None, pos = (-0.59999999999999998, 0, 0.46999999999999997), image = guiMain.find('**/general_frame_e'), image_pos = (0.25, 0, 0.27500000000000002), image_scale = 0.25)
self.initialiseoptions(CrewMatchNewMemberRequest)
self.avId = avId
self.avName = avName
self.crewType = crewType
self.openCrew = openCrew
self.title = DirectLabel(parent = self, relief = None, text = PLocalizer.CrewMatchNewMemberRequestTitle, text_scale = PiratesGuiGlobals.TextScaleExtraLarge, text_align = TextNode.ACenter, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_font = PiratesGlobals.getPirateOutlineFont(), pos = (0.25, 0, 0.41999999999999998))
nameArray = ('CPOrangeHEAD' + self.avName + '', 'CPOrangeHEAD' + self.avName + '', 'CPOrangeOVER' + self.avName + '', 'CPOrangeHEAD' + self.avName + '')
nameButton = DirectButton(parent = NodePath(), relief = None, text = nameArray, text_align = TextNode.ALeft, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 0, command = self.handleAvatarPress, extraArgs = [
avId,
avName])
(left, right, bottom, top) = nameButton.getBounds()
nameGFX = TextGraphic(nameButton, left, right, 0, 1)
buttonName = '' + self.avName + ''
buttonText = PLocalizer.CrewMatchNewMemberRequestMessage % buttonName
tpMgr = TextPropertiesManager.getGlobalPtr()
tpMgr.setGraphic(self.avName, nameGFX)
del tpMgr
textRender = TextNode('textRender')
textRender.setFont(PiratesGlobals.getInterfaceFont())
textRender.setTextColor(PiratesGuiGlobals.TextFG2)
textRender.setAlign(TextNode.ACenter)
textRender.setShadowColor(PiratesGuiGlobals.TextShadow)
textRender.setWordwrap(11)
textRender.setTabWidth(1.0)
textRender.setShadow(0.080000000000000002, 0.080000000000000002)
textRender.setText(buttonText)
textNode = self.attachNewNode(textRender.generate())
textNode.setScale(PiratesGuiGlobals.TextScaleLarge)
textNode.setPos(0.25, 0, 0.32500000000000001)
self.bOk = CrewMatchNewMemberRequestButton(text = PLocalizer.CrewMatchNewMemberRequestYes, command = self._CrewMatchNewMemberRequest__handleOk)
self.bOk.reparentTo(self)
self.bOk.setPos(0.10000000000000001, 0, 0.050000000000000003)
self.bNo = CrewMatchNewMemberRequestButton(text = PLocalizer.CrewMatchNewMemberRequestNo, command = self._CrewMatchNewMemberRequest__handleNo)
self.bNo.reparentTo(self)
self.bNo.setPos(0.29999999999999999, 0, 0.050000000000000003)
self.accept('clientLogout', self.destroy)
self.accept('destroyCrewMatchInvite', self.destroy)
def addModalTextMessage(self, text, buttonStyle = OTPDialog.CancelOnly, noCallback = None, yesCallback = None, cancelCallback = None, seconds = 120, priority = 0, color = (1, 1, 1, 1), icon = (), modelName = 'general_frame_f', name = None, avId = None):
if name:
t2 = text % name
else:
t2 = text
if self.lastMessage == text:
return None
msg = ModalStackMessage(parent = self, buttonStyle = buttonStyle, noCallback = noCallback, yesCallback = yesCallback, cancelCallback = cancelCallback, text = text, text_wordwrap = 15.5, text_align = TextNode.ALeft, text_scale = 0.035000000000000003, text_fg = color, text_pos = (0.17000000000000001, -0.071999999999999995, 0), textMayChange = 1, time = seconds, priority = priority, icon = icon, modelName = modelName)
if name:
msg['text_fg'] = (0, 0, 0, 0)
nameArray = ('\x1CPOrangeHEAD\x1' + name + '\x2', '\x1CPOrangeHEAD\x1' + name + '\x2', '\x1CPOrangeOVER\x1' + name + '\x2', '\x1CPOrangeHEAD\x1' + name + '\x2')
nameButton = DirectButton(parent = NodePath(), relief = None, text = nameArray, text_align = TextNode.ALeft, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 0, command = self.handleAvatarModalPress, extraArgs = [
avId,
name])
(left, right, bottom, top) = nameButton.getBounds()
nameGFX = TextGraphic(nameButton, left, right, 0, 1)
buttonName = '\x5' + name + '\x5'
buttonText = text % buttonName
tpMgr = TextPropertiesManager.getGlobalPtr()
tpMgr.setGraphic(name, nameGFX)
del tpMgr
textRender = TextNode('textRender')
textRender.setFont(PiratesGlobals.getInterfaceFont())
textRender.setTextColor(PiratesGuiGlobals.TextFG14)
textRender.setShadowColor(PiratesGuiGlobals.TextShadow)
textRender.setWordwrap(15.5)
textRender.setTabWidth(1.0)
textRender.setShadow(0.080000000000000002, 0.080000000000000002)
textRender.setText(buttonText)
x = msg.attachNewNode(textRender.generate())
x.setScale(0.034500000000000003, 1.0, 0.035000000000000003)
x.setPos(0.16700000000000001, 0, -0.072999999999999995)
self.addMessage(msg)
self.lastMessage = text
if icon and icon[0] == 'ship':
self.shipMessage = msg
return msg
def __init__(self, cell, manager):
self.sizeX = 0.80000000000000004
self.sizeZ = 0.59999999999999998
textScale = PiratesGuiGlobals.TextScaleTitleSmall
optiondefs = (('state', DGG.DISABLED, None),
('frameSize', (-0.0 * self.sizeX, 1.0 * self.sizeX,
-0.0 * self.sizeZ, 1.0 * self.sizeZ),
None), ('text', PLocalizer.InventorySplitterTitle,
None), ('text_align', TextNode.ACenter, None),
('text_font', PiratesGlobals.getPirateBoldOutlineFont(),
None), ('text_fg', (1, 1, 1, 1), None),
('text_shadow', PiratesGuiGlobals.TextShadow,
None), ('textMayChange', 1, None), ('text_scale',
textScale, None),
('text_pos', (self.sizeX * 0.5, self.sizeZ - textScale),
None))
self.defineoptions({}, optiondefs)
BorderFrame.__init__(self, parent=NodePath())
self.initialiseoptions(InventoryStackSplitter)
self.fromCell = cell
self.manager = manager
self.setup()
def genTextEffect(targetObj,
textGenerator,
number,
bonus,
isNpc,
cleanupCallback,
startPos,
destPos=None,
scale=1.0,
modifiers={},
effects=[]):
textGenerator.setFont(PiratesGlobals.getPirateOutlineFont())
text, baseVal, mods = genText(number, bonus, MOD_TYPE_MULTIPLE, modifiers,
effects)
duration = 2.0 + len(mods)
textGenerator.setText(text % str(baseVal))
textGenerator.clearShadow()
textGenerator.setAlign(TextNode.ACenter)
color = genColor(number, bonus, isNpc, effects)
newEffect = TextEffect(textGenerator, bonus, targetObj, scale, startPos,
duration, text, baseVal, mods, cleanupCallback,
destPos, color)
return newEffect
def __init__(self,
name,
nodePath,
offset,
text,
stencilId,
scale=0.025000000000000001,
*args,
**kwargs):
Billboard.__init__(self, name, nodePath, *args, **kwargs)
self.setBin('fixed', 110)
self.scale = scale
self.textNode = OnscreenText(text=text,
fg=Vec4(0, 0, 0, 1),
scale=scale,
shadow=Vec4(0, 0, 0, 0),
mayChange=True,
font=PiratesGlobals.getPirateFont())
self.textNode.detachNode()
sNode = self.attachNewNode('stencil')
sNode.setY(-offset)
self.textNode.instanceTo(sNode)
sNode.setDepthTest(False)
def __init__(self, badText='Error'):
self.sizeX = 0.80000000000000004
self.sizeZ = 0.59999999999999998
textScale = PiratesGuiGlobals.TextScaleTitleSmall
optiondefs = (('state', DGG.DISABLED, None),
('frameSize', (-0.0 * self.sizeX, 1.0 * self.sizeX,
-0.0 * self.sizeZ, 1.0 * self.sizeZ),
None), ('text', PLocalizer.ChatWarningTitle,
None), ('text_align', TextNode.ACenter, None),
('text_font', PiratesGlobals.getPirateBoldOutlineFont(),
None), ('text_fg', (1, 1, 1, 1), None),
('text_shadow', PiratesGuiGlobals.TextShadow,
None), ('textMayChange', 1, None), ('text_scale',
textScale, None),
('text_pos', (self.sizeX * 0.5,
self.sizeZ - textScale * 1.5), None))
self.defineoptions({}, optiondefs)
BorderFrame.__init__(self, parent=NodePath())
self.initialiseoptions(ChatWarningBox)
self.setX(self.sizeX * -0.5)
self.badText = badText
self.warningText = badText
self.setup()
def __init__(self, title, doneCallback, siegeTeam=0):
ShipSelectionPanel.__init__(
self,
title,
doneCallback,
pages=[self.OWN, self.FRIEND, self.CREW, self.GUILD, self.PUBLIC])
self.initialiseoptions(ShipDeployPanel)
self._siegeTeam = siegeTeam
if localAvatar.style.getTutorial() < PiratesGlobals.TUT_GOT_SHIP:
text = localAvatar.getCurrentIsland(
) != QuestConstants.LocationIds.PORT_ROYAL_ISLAND and PLocalizer.DinghyNeedFirstShip % PLocalizer.LocationNames[
QuestConstants.LocationIds.PORT_ROYAL_ISLAND]
else:
text = PLocalizer.DinghyNeedShip
self.noShipHint = DirectLabel(parent=self,
relief=None,
text=text,
text_font=PiratesGlobals.getPirateFont(),
text_scale=0.08,
text_fg=PiratesGuiGlobals.TextFG1,
text_wordwrap=10,
textMayChange=1,
pos=(0.55, 0, 0.8))
return
def initIndicatorIcons(self):
self.textureCard = loader.loadModel(
'models/textureCards/pir_m_gam_can_ship_icons')
if self.textureCard:
self.goldIcon = self.textureCard.find('**/pir_t_shp_can_gold*')
self.goldStolenlbl = DirectLabel(
parent=self.healthBar,
relief=None,
pos=(0, 0, 0.2),
text_align=TextNode.ACenter,
text_scale=0.5,
textMayChange=0,
text='!',
text_fg=PiratesGuiGlobals.TextFG23,
text_shadow=PiratesGuiGlobals.TextShadow,
text_font=PiratesGlobals.getPirateBoldOutlineFont(),
sortOrder=2)
self.goldStolenlbl.setTransparency(1)
self.goldStolenlbl.hide()
self.hasGoldlbl = DirectLabel(parent=self.healthBar,
relief=None,
pos=(0, 0, 0.35),
image=self.goldIcon,
image_scale=0.5,
image_pos=(0, 0, 0),
sortOrder=2)
self.hasGoldlbl.setTransparency(1)
self.hasGoldlbl.hide()
self.hasBNote = self.healthBar.attachNewNode('noteIndicator')
self.bnoteBack = loader.loadModel(
'models/textureCards/skillIcons').find(
'**/pir_t_gui_can_moneyIcon').copyTo(self.hasBNote)
self.hasBNote.setZ(0.35)
self.hasBNote.setScale(0.6)
self.hasBNote.hide()
return
def __init__(self, cell, parent):
self.sizeX = 0.64
self.sizeZ = 0.64
textScale = PiratesGuiGlobals.TextScaleTitleSmall
frameSize = (-0.0 * self.sizeX, 1.0 * self.sizeX, -0.0 * self.sizeZ,
1.0 * self.sizeZ)
modelName = 'pir_m_gui_frm_subframe'
imageColorScale = VBase4(0.75, 0.75, 0.9, 1.0)
optiondefs = (('state', DGG.DISABLED, None), ('frameSize', frameSize,
None),
('modelName', modelName, None), ('imageColorScale',
imageColorScale, None))
self.defineoptions({}, optiondefs)
BorderFrame.__init__(self, parent=NodePath())
self.initialiseoptions(InventoryStackSeller)
self.doubleFrame = BorderFrame(parent=self,
frameSize=frameSize,
modelName=modelName,
imageColorScale=imageColorScale)
self.tripleFrame = BorderFrame(
parent=self,
frameSize=frameSize,
modelName=modelName,
imageColorScale=imageColorScale,
text=PLocalizer.InventorySplitterTitle,
text_align=TextNode.ACenter,
text_font=PiratesGlobals.getPirateBoldOutlineFont(),
text_fg=VBase4(1, 1, 1, 1),
text_shadow=PiratesGuiGlobals.TextShadow,
text_scale=textScale,
text_pos=(self.sizeX * 0.5, self.sizeZ * 0.95 - textScale))
self.fromCell = cell
self.parent = parent
self.amount = self.fromCell.inventoryItem.getAmount()
self.setup()
return
def __init__(self, tabBar, name, text_xyz=None, **kw):
optiondefs = (('modelName', 'general_frame_c',
None), ('frameSize', (0, 0.22, 0.0, 0.1), None),
('borderScale', 0.135, None), ('bgBuffer', 0.14, None),
('label', '', None), ('textMayChange', 1, None))
self.defineoptions(kw, optiondefs)
TopTab.__init__(self, tabBar, name, **kw)
self.initialiseoptions(ChatTab)
text_pos = (0.117, 0.04, 0)
if text_xyz:
text_pos = text_xyz
self.myTextScale = PiratesGuiGlobals.TextScaleLarge * 1.1
self.myLabel = DirectLabel(parent=self,
relief=None,
state=DGG.DISABLED,
text=self['label'],
text_scale=self.myTextScale,
text_align=TextNode.ACenter,
text_fg=PiratesGuiGlobals.TextFG1,
text_shadow=PiratesGuiGlobals.TextShadow,
text_pos=text_pos,
text_font=PiratesGlobals.getInterfaceFont(),
textMayChange=1)
return
def __init__(self, faceId, *args, **kwargs):
DirectFrame.__init__(self, *args, **kwargs)
self.initialiseoptions(FaceSpot)
model = loader.loadModel('models/props/BH_images')
self.back = DirectFrame(parent=self,
relief=None,
geom=model.find('**/*bevel'))
self.dots = DirectFrame(parent=self,
relief=None,
geom=model.find('**/*dots'))
spot = model.find('**/*dot')
self.spots = [
DirectFrame(parent=self,
relief=None,
geom=spot,
hpr=(0.0, 0.0, 360.0 / 24.0 * x))
for x in range(self.NUMSTEPS)
]
self.face = DirectFrame(parent=self,
relief=None,
geom=model.find('**/*face_' + ` faceId `))
self.cross = DirectFrame(parent=self,
relief=None,
geom=model.find('**/*x'))
self.statusLabel = DirectLabel(
parent=self,
relief=None,
pos=(0, 0, 0.5),
text_scale=0.25,
text='0',
text_fg=(1, 1, 1, 1),
text_shadow=(0, 0, 0, 1),
textMayChange=1,
text_font=PiratesGlobals.getPirateOutlineFont())
self.disable()
return
def __init__(self, panelName, gameTitle, instructions):
BorderFrame.__init__(self,
parent=base.a2dBottomCenter,
frameSize=(-1, 1, 0, 0.29999999999999999),
pos=(0, 0, 0.5),
modelName='pir_m_gui_frm_subframe',
imageColorScale=VBase4(0.75, 0.75,
0.90000000000000002, 0.75))
self.initialiseoptions(PVPRulesPanel)
self.secondLayer = BorderFrame(
parent=self,
frameSize=(-1, 1, 0, 0.29999999999999999),
modelName='pir_m_gui_frm_subframe',
imageColorScale=VBase4(0.75, 0.75, 0.90000000000000002, 0.75))
self.gameTitle = gameTitle
self.instructions = instructions
self.gameTitleText = DirectLabel(
parent=self,
relief=None,
text=self.gameTitle,
text_scale=0.059999999999999998,
text_align=TextNode.ALeft,
text_font=PiratesGlobals.getPirateFont(),
text_fg=(1, 1, 1, 1),
text_shadow=(0, 0, 0, 1),
pos=(-0.95999999999999996, 0, 0.23000000000000001))
self.instructionsText = DirectLabel(parent=self,
relief=None,
text=self.instructions,
text_scale=0.050000000000000003,
text_align=TextNode.ALeft,
text_wordwrap=40,
text_fg=(1, 1, 1, 1),
text_shadow=(0, 0, 0, 1),
pos=(-0.95999999999999996, 0,
0.14000000000000001))
def createPortOfCall(self):
if self.portOfCallLabel:
self.portOfCallLabel.destroy()
if self.portOfCallButton:
self.portOfCallButton.destroy()
compassGui = loader.loadModel('models/gui/compass_gui')
topGui = loader.loadModel('models/gui/toplevel_gui')
teleportIcon = topGui.find('**/treasure_w_b_slot_empty').copyTo(
NodePath(''))
compassGui.find('**/compass_icon_objective_green').copyTo(teleportIcon)
teleportIcon.flattenStrong()
self.portOfCallLabel = DirectLabel(
parent=self,
text='',
text_align=TextNode.ALeft,
text_font=PiratesGlobals.getPirateOutlineFont(),
text_scale=0.044999999999999998,
text_fg=PiratesGuiGlobals.TextFG2,
textMayChange=1,
pos=(0.48999999999999999, 0, 0.072999999999999995))
self.portOfCallButton = GuiButton.GuiButton(
parent=self,
pos=(0.38, 0, 0.085000000000000006),
scale=0.84999999999999998,
text=PLocalizer.Return,
text_pos=(0.033000000000000002, -0.014),
text_scale=0.044999999999999998,
textMayChange=1,
image3_color=(0.80000000000000004, 0.80000000000000004,
0.80000000000000004, 1),
geom=teleportIcon,
geom_pos=(-0.065000000000000002, 0, 0),
geom_scale=0.20000000000000001,
command=self.handlePortOfCall)
def __init__(self, avId, avName):
SocialPage.SocialPage.__init__(self, 'TradeInviter')
self.initialiseoptions(TradeInviter)
self.avId = avId
self.avName = avName
self.avDisableName = 'disable-%s' % self.avId
self.fsm = ClassicFSM.ClassicFSM('TradeInviter', [
State.State('off', self.enterOff, self.exitOff),
State.State('getNewTrade', self.enterGetNewTrade, self.exitGetNewTrade),
State.State('begin', self.enterBegin, self.exitBegin),
State.State('notYet', self.enterNotYet, self.exitNotYet),
State.State('checkAvailability', self.enterCheckAvailability, self.exitCheckAvailability),
State.State('notAvailable', self.enterNotAvailable, self.exitNotAvailable),
State.State('notAcceptingTrades', self.enterNotAcceptingTrades, self.exitNotAcceptingTrades),
State.State('wentAway', self.enterWentAway, self.exitWentAway),
State.State('alreadyTrading', self.enterAlreadyTrading, self.exitAlreadyTrading),
State.State('alreadyInvited', self.enterAlreadyInvited, self.exitAlreadyInvited),
State.State('askingNPC', self.enterAskingNPC, self.exitAskingNPC),
State.State('endTrade', self.enterEndTrade, self.exitEndTrade),
State.State('tradeNoMore', self.enterTradeNoMore, self.exitTradeNoMore),
State.State('self', self.enterSelf, self.exitSelf),
State.State('ignored', self.enterIgnored, self.exitIgnored),
State.State('asking', self.enterAsking, self.exitAsking),
State.State('yes', self.enterYes, self.exitYes),
State.State('no', self.enterNo, self.exitNo),
State.State('maybe', self.enterMaybe, self.exitMaybe),
State.State('down', self.enterDown, self.exitDown),
State.State('cancel', self.enterCancel, self.exitCancel)], 'off', 'off')
guiMain = loader.loadModel('models/gui/gui_main')
self.box = OnscreenImage(parent=self, pos=(0.25, 0, 0.275), image=guiMain.find('**/general_frame_e'), scale=0.25)
self.title = DirectLabel(parent=self, relief=None, text=PLocalizer.TradeInviterTitle, text_scale=PiratesGuiGlobals.TextScaleExtraLarge, text_align=TextNode.ACenter, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, text_font=PiratesGlobals.getPirateOutlineFont(), pos=(0.25,
0,
0.42), image=None, image_scale=0.25)
self.message = DirectLabel(parent=self, relief=None, text='', text_scale=PiratesGuiGlobals.TextScaleLarge, text_align=TextNode.ACenter, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, text_wordwrap=11, pos=(0.25,
0,
0.325), textMayChange=1)
self.context = None
self.bOk = TradeInviterButton(text=PLocalizer.TradeInviterOK, command=self.__handleOk)
self.bOk.reparentTo(self)
self.bOk.setPos(0.2, 0, 0.05)
self.bOk.hide()
self.bCancel = TradeInviterButton(text=PLocalizer.TradeInviterCancel, command=self.__handleCancel)
self.bCancel.reparentTo(self)
self.bCancel.setPos(0.2, 0, 0.05)
self.bCancel.hide()
self.bStop = TradeInviterButton(text=PLocalizer.TradeInviterStopTrading, command=self.__handleStop)
self.bStop.reparentTo(self)
self.bStop.setPos(0.2, 0, 0.15)
self.bStop.hide()
self.bYes = TradeInviterButton(text=PLocalizer.TradeInviterYes, command=self.__handleYes)
self.bYes.reparentTo(self)
self.bYes.setPos(0.1, 0, 0.05)
self.bYes.hide()
self.bNo = TradeInviterButton(text=PLocalizer.TradeInviterNo, command=self.__handleNo)
self.bNo.reparentTo(self)
self.bNo.setPos(0.3, 0, 0.05)
self.bNo.hide()
self.fsm.enterInitialState()
if self.avId == None:
self.fsm.request('getNewTrade')
else:
self.fsm.request('begin')
return
def createGui(self):
itemId = self.data[0]
self.itemCount += 1
self.itemQuantity = self.quantity
self.itemCost = self.price
self.picture = DirectFrame(parent=self,
relief=None,
state=DGG.DISABLED,
pos=(0.035, 0, 0.025))
self.quantityLabel = DirectLabel(
parent=self,
relief=None,
state=DGG.DISABLED,
text=str(self.quantity),
text_fg=PiratesGuiGlobals.TextFG2,
text_scale=PiratesGuiGlobals.TextScaleSmall *
PLocalizer.getHeadingScale(2),
text_align=TextNode.ARight,
text_wordwrap=11,
pos=(0.1225, 0, 0.015))
if len(self.name) >= 39:
textScale = PiratesGuiGlobals.TextScaleMicro * PLocalizer.getHeadingScale(
2)
else:
if len(self.name) >= 35:
textScale = PiratesGuiGlobals.TextScaleTiny * PLocalizer.getHeadingScale(
2)
else:
textScale = PiratesGuiGlobals.TextScaleSmall * PLocalizer.getHeadingScale(
2)
self.nameTag = DirectLabel(parent=self,
relief=None,
state=DGG.DISABLED,
text=self.name,
text_fg=PiratesGuiGlobals.TextFG2,
text_scale=textScale,
text_align=TextNode.ALeft,
pos=(0.13, 0, 0.015))
self.costText = DirectLabel(
parent=self,
relief=None,
state=DGG.DISABLED,
image=InventoryListItem.coinImage,
image_scale=0.12,
image_pos=Vec3(-0.005, 0, 0.0125),
text=str(self.price),
text_fg=PiratesGuiGlobals.TextFG2,
text_scale=PiratesGuiGlobals.TextScaleSmall,
text_align=TextNode.ARight,
text_wordwrap=11,
text_pos=(-0.03, 0, 0),
pos=(self.width - 0.035, 0, 0.015),
text_font=PiratesGlobals.getInterfaceFont())
itemClass = EconomyGlobals.getItemCategory(itemId)
itemType = EconomyGlobals.getItemType(itemId)
if itemType == ItemType.FISHING_ROD or itemType == ItemType.FISHING_LURE:
asset = EconomyGlobals.getItemIcons(itemId)
if asset:
self.picture['geom'] = PurchaseListItem.fishingIcons.find(
'**/%s*' % asset)
self.picture['geom_scale'] = 0.04
self.picture['geom_pos'] = (0, 0, 0)
else:
if itemClass == ItemType.WEAPON or itemClass == ItemType.POUCH:
asset = EconomyGlobals.getItemIcons(itemId)
if asset:
self.picture['geom'] = InventoryListItem.weaponIcons.find(
'**/%s*' % asset)
self.picture['geom_scale'] = 0.04
self.picture['geom_pos'] = (0, 0, 0)
else:
if itemClass == ItemType.CONSUMABLE:
asset = EconomyGlobals.getItemIcons(itemId)
if asset:
self.picture[
'geom'] = InventoryListItem.skillIcons.find(
'**/%s*' % asset)
self.picture['geom_scale'] = 0.04
self.picture['geom_pos'] = (0, 0, 0)
if InventoryType.begin_WeaponCannonAmmo <= itemId and itemId <= InventoryType.end_WeaponCannonAmmo or InventoryType.begin_WeaponPistolAmmo <= itemId and itemId <= InventoryType.end_WeaponGrenadeAmmo or InventoryType.begin_WeaponDaggerAmmo <= itemId and itemId <= InventoryType.end_WeaponDaggerAmmo:
skillId = WeaponGlobals.getSkillIdForAmmoSkillId(itemId)
if skillId:
asset = WeaponGlobals.getSkillIcon(skillId)
if asset:
self.picture['geom'] = InventoryListItem.skillIcons.find(
'**/%s' % asset)
self.picture['geom_scale'] = 0.06
self.picture['geom_pos'] = (0, 0, 0)
else:
if InventoryType.SmallBottle <= itemId and itemId <= InventoryType.LargeBottle:
self.picture['geom'] = self.topGui.find(
'**/main_gui_ship_bottle')
self.picture['geom_scale'] = 0.1
self.picture['geom_pos'] = (0, 0, 0)
self.flattenStrong()
return
def __init__(self, chatManager, whiteListEntry):
optiondefs = (('relief', None, None), ('state', DGG.NORMAL,
self.setState),
('frameSize', (0, 0.9, 0, 0.6),
None), ('frameColor', (1, 0, 1, 0.2), None))
self.defineoptions({}, optiondefs)
DirectFrame.__init__(self, parent=NodePath())
self.initialiseoptions(ChatPanel)
FSM.__init__(self, 'ChatPanel')
base.chatPanel = self
self.chatManager = chatManager
self.index = 0
self.runningLineCount = 0
self.runningLineCountLastId = -1
self.lineCountList = [0]
self.wrappedText = []
self.chatFont = PiratesGlobals.getInterfaceFont()
self.nameFont = PiratesGlobals.getInterfaceFont()
self.shadowOffset = (0.09, 0.09)
self.shadowColor = (0.0, 0.0, 0.0, 1.0)
self.fontColorStyle = 1
if base.config.GetBool('want-random-chatStyle', 0):
self.chatFont = random.choice([
PiratesGlobals.getInterfaceFont(),
PiratesGlobals.getInterfaceOutlineFont()
])
self.nameFont = random.choice([
PiratesGlobals.getInterfaceFont(),
PiratesGlobals.getInterfaceOutlineFont()
])
self.shadowOffset = random.choice([(0.09, 0.09), (0.0, 0.0)])
self.fontColorStyle = random.choice([0, 1, 2])
self.lineDict = {}
self.renderedLineDict = {}
self.renderedLines = []
self.wordWrapper = TextNode('wrapper')
self.wordWrapper.setFont(self.chatFont)
self.wordWrapper.setWordwrap(self.WrapWidth)
self.wordWrapper.setTabWidth(1.0)
self.fadeIval = None
self.fadeTextIval = None
self.preferredMode = 'Short'
self.linesShown = True
self.holdLinesShown = None
self.wantSmallFont = 0
self.currentFontSize = self.TextScale
self.currentWordWrap = self.WrapWidth
self.resizeDelayTaskName = 'ChatPanel_Resize'
self.sCloseButton = None
self.tCloseButton = None
self.minButton = None
self.maxButton = None
self.setupGui()
self.chatBar = ChatBar(parent=self,
chatMgr=chatManager,
whiteListEntry=whiteListEntry)
self.setBoxWidth(base.options.chatbox_scale)
self.checkEmotes()
self.needSlider = 0
self.reparentTo(base.a2dBottomLeft)
self.accept('NewOpenMessage', self.__handleOpenMessage)
self.accept('SetChatBoxWidth', self.setBoxWidth)
self.accept('SetChatBoxStyle', self.setChatStyle)
self.accept('GUIHidden', self.__handleGlobalGuiHide)
self.accept('GUIShown', self.__handleGlobalGuiShow)
return
