def loadWeaponButtons(self): for hotkey in self.hotkeys: hotkey.destroy() self.hotkeys = [] for icon in self.icons: icon.destroy() self.icons = [] for repMeter in self.repMeters: repMeter.destroy() self.repMeters = [] self['frameSize'] = (0, self.ICON_WIDTH * len(self.items) + 0.040000000000000001, 0, self.HEIGHT) self.setX(-((self.ICON_WIDTH * len(self.items) + 0.040000000000000001) / 2.0)) topGui = loader.loadModel('models/gui/toplevel_gui') kbButton = topGui.find('**/keyboard_button') for i in range(len(self.items)): if self.items[i]: category = WeaponGlobals.getRepId(self.items[i][0]) icon = DirectFrame(parent = self, state = DGG.DISABLED, relief = None, frameSize = (0, 0.080000000000000002, 0, 0.080000000000000002), pos = (self.ICON_WIDTH * i + 0.080000000000000002, 0, 0.082000000000000003)) icon.setTransparency(1) hotkeyText = 'F%s' % self.items[i][1] hotkey = DirectFrame(parent = icon, state = DGG.DISABLED, relief = None, text = hotkeyText, text_align = TextNode.ACenter, text_scale = 0.044999999999999998, text_pos = (0, 0), text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, image = kbButton, image_scale = 0.059999999999999998, image_pos = (0, 0, 0.01), image_color = (0.5, 0.5, 0.34999999999999998, 1), pos = (0, 0, 0.080000000000000002)) self.hotkeys.append(hotkey) category = WeaponGlobals.getRepId(self.items[i][0]) if Freebooter.getPaidStatus(base.localAvatar.getDoId()) or Freebooter.allowedFreebooterWeapon(category): asset = ItemGlobals.getIcon(self.items[i][0]) if asset: texCard = self.card.find('**/%s' % asset) icon['geom'] = texCard icon['geom_scale'] = 0.080000000000000002 icon.resetFrameSize() self.icons.append(icon) else: texCard = topGui.find('**/pir_t_gui_gen_key_subscriber*') icon['geom'] = texCard icon['geom_scale'] = 0.20000000000000001 icon.resetFrameSize() self.icons.append(icon) repMeter = DirectWaitBar(parent = icon, relief = DGG.SUNKEN, state = DGG.DISABLED, borderWidth = (0.002, 0.002), range = 0, value = 0, frameColor = (0.23999999999999999, 0.23999999999999999, 0.20999999999999999, 1), barColor = (0.80000000000000004, 0.80000000000000004, 0.69999999999999996, 1), pos = (-0.050000000000000003, 0, -0.052499999999999998), hpr = (0, 0, 0), frameSize = (0.0050000000000000001, 0.095000000000000001, 0, 0.012500000000000001)) self.repMeters.append(repMeter) inv = base.localAvatar.getInventory() if inv: repValue = inv.getReputation(category) (level, leftoverValue) = ReputationGlobals.getLevelFromTotalReputation(category, repValue) max = ReputationGlobals.getReputationNeededToLevel(category, level) repMeter['range'] = max repMeter['value'] = leftoverValue
def addTab(self, itemGroup, item): newTab = self.tabBar.addTab(itemGroup, command = self.setPage, extraArgs = [ itemGroup]) repId = WeaponGlobals.getRepId(item) if repId: iconName = ReputationGlobals.RepIcons.get(repId) if repId == InventoryType.FishingRep: icon = StoreGUI.FishingIcons.find('**/%s' % iconName) else: icon = StoreGUI.WeaponIcons.find('**/%s' % iconName) elif InventoryType.begin_Consumables <= item: pass elif repId or ItemGlobals.getClass(item) == InventoryType.ItemTypeConsumable: iconName = EconomyGlobals.getItemIcons(item) icon = StoreGUI.SkillIcons.find('**/%s' % iconName) elif InventoryType.begin_WeaponCannonAmmo <= item: pass elif ItemGlobals.getClass(item) == InventoryType.ItemTypeConsumable: iconName = EconomyGlobals.getItemIcons(InventoryType.CannonL1) icon = StoreGUI.WeaponIcons.find('**/%s' % iconName) elif InventoryType.begin_WeaponGrenadeAmmo <= item: pass elif ItemGlobals.getClass(item) == InventoryType.ItemTypeConsumable: itemId = InventoryType.GrenadeWeaponL1 iconName = EconomyGlobals.getItemIcons(itemId) icon = StoreGUI.WeaponIcons.find('**/%s' % iconName) elif InventoryType.begin_FishingLures <= item: pass elif ItemGlobals.getClass(item) == InventoryType.ItemTypeConsumable: icon = StoreGUI.FishingIcons.find('**/pir_t_gui_gen_fish_lure') else: icon = None newTab.nameTag = DirectLabel(parent = newTab, relief = None, state = DGG.DISABLED, image = icon, image_scale = 0.40000000000000002, image_pos = (0, 0, 0.040000000000000001), pos = (0.059999999999999998, 0, -0.035000000000000003)) self.pageNames.append(itemGroup)
def selectPrev(self): if len(self.items) < 1: return None self.show() if len(self.items) > 1: keepTrying = True else: keepTrying = False while keepTrying: keepTrying = False self.choice = self.choice - 1 if self.choice < 0 or self.choice > len(self.items) - 1: self.choice = len(self.items) - 1 if not Freebooter.getPaidStatus(base.localAvatar.getDoId()): if self.items[self.choice]: category = WeaponGlobals.getRepId(self.items[self.choice][0]) if not Freebooter.allowedFreebooterWeapon(category): keepTrying = True else: keepTrying = True self.items[self.choice] self.cursor.setPos(self.ICON_WIDTH * self.choice + 0.080000000000000002, 0, 0.071999999999999995) taskMgr.remove('BarSelectHideTask' + str(self.getParent())) self.hideTask = taskMgr.doMethodLater(self.SelectionDelay, self.confirmSelection, 'BarSelectHideTask' + str(self.getParent()), extraArgs = [])
def addTab(self, itemGroup, item): newTab = self.tabBar.addTab(itemGroup, command=self.setPage, extraArgs=[itemGroup]) repId = WeaponGlobals.getRepId(item) if repId: iconName = ReputationGlobals.RepIcons.get(repId) if repId == InventoryType.FishingRep: icon = StoreGUI.FishingIcons.find('**/%s' % iconName) else: icon = StoreGUI.WeaponIcons.find('**/%s' % iconName) elif InventoryType.begin_Consumables <= item < InventoryType.end_Consumables or ItemGlobals.getClass( item) == InventoryType.ItemTypeConsumable: iconName = EconomyGlobals.getItemIcons(item) icon = StoreGUI.SkillIcons.find('**/%s' % iconName) elif InventoryType.begin_WeaponCannonAmmo <= item < InventoryType.end_WeaponCannonAmmo: iconName = EconomyGlobals.getItemIcons(InventoryType.CannonL1) icon = StoreGUI.WeaponIcons.find('**/%s' % iconName) elif InventoryType.begin_WeaponGrenadeAmmo <= item < InventoryType.end_WeaponGrenadeAmmo: itemId = InventoryType.GrenadeWeaponL1 iconName = EconomyGlobals.getItemIcons(itemId) icon = StoreGUI.WeaponIcons.find('**/%s' % iconName) elif InventoryType.begin_FishingLures <= item < InventoryType.end_FishingLures: icon = StoreGUI.FishingIcons.find('**/pir_t_gui_gen_fish_lure') else: icon = None newTab.nameTag = DirectLabel(parent=newTab, relief=None, state=DGG.DISABLED, image=icon, image_scale=0.4, image_pos=(0, 0, 0.04), pos=(0.06, 0, -0.035)) self.pageNames.append(itemGroup) return
def selectNext(self): if len(self.items) < 1: return None self.show() if len(self.items) > 1: keepTrying = True else: keepTrying = False while keepTrying: keepTrying = False self.choice = self.choice + 1 if self.choice > len(self.items) - 1: self.choice = 0 if not Freebooter.getPaidStatus(base.localAvatar.getDoId()): category = WeaponGlobals.getRepId(self.items[self.choice][0]) if not Freebooter.allowedFreebooterWeapon(category): keepTrying = True Freebooter.allowedFreebooterWeapon(category) self.cursor.setPos( self.ICON_WIDTH * self.choice + 0.080000000000000002, 0, 0.071999999999999995) taskMgr.remove('BarSelectHideTask' + str(self.getParent())) self.hideTask = taskMgr.doMethodLater(self.SelectionDelay, self.confirmSelection, 'BarSelectHideTask' + str(self.getParent()), extraArgs=[])
def updateRep(self, category, value): for i in range(len(self.items)): repId = WeaponGlobals.getRepId(self.items[i][0]) if repId == category: level, leftoverValue = ReputationGlobals.getLevelFromTotalReputation( category, value) max = ReputationGlobals.getReputationNeededToLevel( category, level) if len(self.repMeters) - 1 >= i: self.repMeters[i]['range'] = max self.repMeters[i]['value'] = leftoverValue
def updateRep(self, category, value): for i in range(len(self.items)): repId = WeaponGlobals.getRepId(self.items[i][0]) if repId == category: (level, leftoverValue) = ReputationGlobals.getLevelFromTotalReputation(category, value) max = ReputationGlobals.getReputationNeededToLevel(category, level) if len(self.repMeters) - 1 >= i: self.repMeters[i]['range'] = max self.repMeters[i]['value'] = leftoverValue len(self.repMeters) - 1 >= i
def checkComboExpired(self, avId, weaponId, skillId, skillResult): barTime = 3.0 curTime = globalClock.getFrameTime() for attackerId in self.timers: comboLength = len(self.timers[attackerId]) lastEntry = self.timers[attackerId][comboLength - 1] lastSkillId = lastEntry[self.SKILLID_INDEX] timestamp = lastEntry[self.TIMESTAMP_INDEX] if (barTime + timestamp - curTime) + self.TOLERANCE > 0: if attackerId != avId: return 0 subtypeId = ItemGlobals.getSubtype(weaponId) if not subtypeId: return 0 repId = WeaponGlobals.getSkillReputationCategoryId(skillId) if not repId: return 0 if repId != WeaponGlobals.getRepId(weaponId): return 0 comboChain = self.COMBO_ORDER.get(subtypeId) if comboChain: if not self.SPECIAL_SKILLS.get(repId, []): self.notify.warning('No special skills for weapon %s with skill %s, subtype %s, rep %s' % (weaponId, skillId, subtypeId, repId)) if skillId in self.SPECIAL_SKILLS.get(repId, []): if lastSkillId not in self.SPECIAL_SKILLS.get(repId, []): return 0 elif skillId in comboChain: index = comboChain.index(skillId) if index > 0: requisiteAttack = comboChain[index - 1] if lastSkillId == requisiteAttack: return 0 elif not comboLength: return 0 return 1
def checkComboExpired(self, avId, weaponId, skillId, skillResult): barTime = 3.0 curTime = globalClock.getFrameTime() for attackerId in self.timers: comboLength = len(self.timers[attackerId]) lastEntry = self.timers[attackerId][comboLength - 1] lastSkillId = lastEntry[self.SKILLID_INDEX] timestamp = lastEntry[self.TIMESTAMP_INDEX] if (barTime + timestamp - curTime) + self.TOLERANCE > 0: if attackerId != avId: return 0 subtypeId = ItemGlobals.getSubtype(weaponId) if not subtypeId: return 0 repId = WeaponGlobals.getSkillReputationCategoryId(skillId) if not repId: return 0 if repId != WeaponGlobals.getRepId(weaponId): return 0 comboChain = self.COMBO_ORDER.get(subtypeId) if comboChain: if not self.SPECIAL_SKILLS.get(repId, []): self.notify.warning( 'No special skills for weapon %s with skill %s, subtype %s, rep %s' % (weaponId, skillId, subtypeId, repId)) if skillId in self.SPECIAL_SKILLS.get(repId, []): if lastSkillId not in self.SPECIAL_SKILLS.get( repId, []): return 0 elif skillId in comboChain: index = comboChain.index(skillId) if index > 0: requisiteAttack = comboChain[index - 1] if lastSkillId == requisiteAttack: return 0 elif not comboLength: return 0 return 1
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 aimOverTargetTask(self, task): if base.localAvatar.hasStickyTargets(): if isinstance(base.localAvatar.currentWeapon, Doll.Doll): target = base.localAvatar.currentTarget if target: pt = self.getNearProjectionPoint(target) (pt, distance) = self.getTargetScreenXY(target) self.reticleHolder.setPos(pt) self.reticle.setScale(self.reticleScale / distance) else: self.reticleHolder.setPos(self.RETICLE_POS) self.reticle.setScale(self.reticleScale) return Task.cont (target, dist) = self.takeAim(base.localAvatar) if target: monstrous = target.hasNetPythonTag('MonstrousObject') else: monstrous = False dt = globalClock.getDt() dt = min(1.0, 8 * dt) if self.wantAimAssist and target and not monstrous: pt = self.getNearProjectionPoint(target) (pt, distance) = self.getTargetScreenXY(target) rPos = self.reticleHolder.getPos() if not rPos.almostEqual(pt, 0.001): nPos = Vec3(rPos) nPos += (pt - rPos) * dt self.reticleHolder.setPos(nPos) rScale = self.reticle.getScale() if not rScale.almostEqual(Vec3(self.reticleScale), 0.001): nScale = Vec3(rScale) f = self.reticleScale / distance nScale += (Vec3(f, f, f) - rScale) * dt nScale.setX(max(self.reticleScale / 1.25, nScale[0])) nScale.setY(max(self.reticleScale / 1.25, nScale[1])) nScale.setZ(max(self.reticleScale / 1.25, nScale[2])) self.reticle.setScale(nScale) else: rPos = self.reticleHolder.getPos() if not rPos.almostEqual(self.RETICLE_POS, 0.001): nPos = Vec3(rPos) nPos += (self.RETICLE_POS - rPos) * dt self.reticleHolder.setPos(nPos) self.reticle.setScale(self.reticleScale) if target: if TeamUtils.damageAllowed(target, localAvatar): self.reticle.setColorScale(1, 1, 1, self.reticleAlpha) if base.localAvatar.currentWeapon: repId = WeaponGlobals.getRepId(base.localAvatar.currentWeaponId) baseRange = self.WeaponBaseRange.get(repId) calcRange = 0 specialRange = 0 specialMeleeRange = 0 ammoSkillId = localAvatar.guiMgr.combatTray.ammoSkillId deadzoneRange = base.cr.battleMgr.getModifiedAttackDeadzone(localAvatar, 0, ammoSkillId) if repId == InventoryType.PistolRep: if localAvatar.guiMgr.combatTray.isCharging: calcRange = base.cr.battleMgr.getModifiedAttackRange(localAvatar, InventoryType.PistolTakeAim, ammoSkillId) else: calcRange = base.cr.battleMgr.getModifiedAttackRange(localAvatar, InventoryType.PistolShoot, ammoSkillId) if ItemGlobals.getSubtype(localAvatar.currentWeaponId) == ItemGlobals.BLUNDERBUSS: baseRange = base.cr.battleMgr.getModifiedAttackRange(localAvatar, EnemySkills.PISTOL_SCATTERSHOT, ammoSkillId) calcRange = base.cr.battleMgr.getModifiedAttackRange(localAvatar, EnemySkills.PISTOL_SCATTERSHOT, ammoSkillId) elif ItemGlobals.getSubtype(localAvatar.currentWeaponId) == ItemGlobals.MUSKET: specialRange = base.cr.battleMgr.getModifiedAttackRange(localAvatar, EnemySkills.PISTOL_DEADEYE, ammoSkillId) elif ItemGlobals.getSubtype(localAvatar.currentWeaponId) == ItemGlobals.BAYONET: specialMeleeRange = base.cr.battleMgr.getModifiedAttackRange(localAvatar, EnemySkills.BAYONET_RUSH, 0) elif repId == InventoryType.DaggerRep: calcRange = base.cr.battleMgr.getModifiedAttackRange(localAvatar, InventoryType.DaggerAsp, 0) elif repId == InventoryType.WandRep: if ammoSkillId: calcRange = base.cr.battleMgr.getModifiedAttackRange(localAvatar, ammoSkillId, 0) specialRange = base.cr.battleMgr.getModifiedAttackRange(localAvatar, InventoryType.StaffBlast, 0) distance = dist if hasattr(target, 'battleTubeNodePaths') and not monstrous: for tube in target.battleTubeNodePaths: tubeLength = max(target.battleTubeRadius, target.battleTubeHeight) if distance - tubeLength < distance: distance -= tubeLength continue range = max(baseRange, calcRange) secondaryRange = max(baseRange, specialRange) if distance <= secondaryRange and distance >= deadzoneRange: self.reticle.setColorScale(1, 0.69999999999999996, 0, self.reticleAlpha) if distance <= range and distance >= deadzoneRange: self.reticle.setColorScale(1, 0, 0, self.reticleAlpha) if specialMeleeRange and distance <= specialMeleeRange: self.reticle.setColorScale(1, 0.69999999999999996, 0, self.reticleAlpha) else: self.reticle.setColorScale(0, 0, 1, self.reticleAlpha) else: self.reticle.setColorScale(1, 1, 1, self.reticleAlpha) oldTarget = base.localAvatar.currentAimOver if target == oldTarget: return Task.cont if oldTarget != None: messenger.send(oldTarget.uniqueName('aimOver'), [ 0]) base.localAvatar.currentAimOver = None oldTarget.hideEnemyTargetInfo() if oldTarget != None and not target: oldTarget.hideHpMeter(delay = 8.0) if target and not target.isInvisibleGhost(): target.showHpMeter() if TeamUtils.damageAllowed(target, localAvatar): target.showEnemyTargetInfo() messenger.send('pistolAimedTarget') else: target.showFriendlyTargetInfo() messenger.send(target.uniqueName('aimOver'), [ 1]) base.localAvatar.currentAimOver = target else: base.localAvatar.currentAimOver = None return Task.cont
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 createGui(self): itemId = self.data[0] self.picture = DirectFrame(parent = self, relief = None, state = DGG.DISABLED, pos = (0.01, 0, 0.01)) self.nameTag = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = self.name, text_scale = PiratesGuiGlobals.TextScaleSmall * PLocalizer.getHeadingScale(2), text_align = TextNode.ALeft, text_fg = PiratesGuiGlobals.TextFG1, text_shadow = PiratesGuiGlobals.TextShadow, pos = (0.050000000000000003, 0, 0.105), text_font = PiratesGlobals.getInterfaceFont()) itemTypeFormatted = '' self.itemTypeName = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = itemTypeFormatted, text_scale = PiratesGuiGlobals.TextScaleSmall, text_align = TextNode.ALeft, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_font = PiratesGlobals.getInterfaceFont(), pos = (0.050000000000000003, 0, 0.065000000000000002)) self.miscText = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = '', text_scale = PiratesGuiGlobals.TextScaleSmall, text_align = TextNode.ALeft, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_wordwrap = 11, pos = (0.050000000000000003, 0, 0.025000000000000001)) if self.minLvl > 0: repId = WeaponGlobals.getRepId(itemId) if repId: self.checkLevel(repId, self.minLvl) trainingReq = EconomyGlobals.getItemTrainingReq(itemId) if trainingReq: self.checkTrainingReq(trainingReq) if EconomyGlobals.getItemCategory(itemId) == ItemType.AMMO: skillId = WeaponGlobals.getSkillIdForAmmoSkillId(itemId) self.checkSkillReq(skillId) if self.buy: self.checkPlayerInventory(itemId) self.costText = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, image = SongListItem.coinImage, image_scale = 0.12, image_pos = Vec3(-0.01, 0, 0.01), text = str(self.price), text_scale = PiratesGuiGlobals.TextScaleSmall, text_align = TextNode.ARight, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_wordwrap = 11, text_pos = (-0.029999999999999999, 0, 0), pos = (self.width - 0.035000000000000003, 0, 0.105), text_font = PiratesGlobals.getInterfaceFont()) if self.quantity and self.quantity > 1: self.quantityLabel = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = str(self.quantity), frameColor = (0, 0, 0, 1), frameSize = (-0.01, 0.02, -0.01, 0.025000000000000001), text_scale = 0.0275, text_align = TextNode.ACenter, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_wordwrap = 11, pos = (0.02, 0, 0.025000000000000001), text_font = PiratesGlobals.getPirateBoldOutlineFont()) itemClass = EconomyGlobals.getItemCategory(itemId) if itemClass == ItemType.WEAPON or itemClass == ItemType.POUCH: asset = EconomyGlobals.getItemIcons(itemId) if asset: self.picture['geom'] = SongItemGui.weaponIcons.find('**/%s*' % asset) self.picture['geom_scale'] = 0.11 self.picture['geom_pos'] = (0.080000000000000002, 0, 0.068000000000000005) elif itemClass == ItemType.CONSUMABLE: asset = EconomyGlobals.getItemIcons(itemId) if asset: self.picture['geom'] = SongItemGui.skillIcons.find('**/%s*' % asset) self.picture['geom_scale'] = 0.11 self.picture['geom_pos'] = (0.080000000000000002, 0, 0.068000000000000005) if not InventoryType.begin_WeaponCannonAmmo <= itemId or itemId <= InventoryType.end_WeaponCannonAmmo: if (InventoryType.begin_WeaponPistolAmmo <= itemId or itemId <= InventoryType.end_WeaponGrenadeAmmo or InventoryType.begin_WeaponDaggerAmmo <= itemId) and itemId <= InventoryType.end_WeaponDaggerAmmo: skillId = WeaponGlobals.getSkillIdForAmmoSkillId(itemId) if skillId: asset = WeaponGlobals.getSkillIcon(skillId) if asset: self.picture['geom'] = SongListItem.skillIcons.find('**/%s' % asset) self.picture['geom_scale'] = 0.14999999999999999 self.picture['geom_pos'] = (0.069000000000000006, 0, 0.069000000000000006) elif InventoryType.SmallBottle <= itemId and itemId <= InventoryType.LargeBottle: self.picture['geom'] = SongListItem.topGui.find('**/main_gui_ship_bottle') self.picture['geom_scale'] = 0.10000000000000001 self.picture['geom_pos'] = (0.069000000000000006, 0, 0.069000000000000006) self.flattenStrong()
def showDetails(self, cell, detailsPos, detailsHeight, event=None): self.notify.debug('Item showDetails') if self.manager.heldItem or self.manager.locked or cell.isEmpty( ) or self.isEmpty() or not self.itemTuple: self.notify.debug(' early exit') return inv = localAvatar.getInventory() if not inv: return itemId = self.getId() self.helpFrame = DirectFrame(parent=self.manager, relief=None, state=DGG.DISABLED, sortOrder=1) self.helpFrame.setBin('gui-popup', -5) 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.3 halfHeight = 0.2 basePosX = cell.getX(aspect2d) basePosZ = cell.getZ(aspect2d) cellSizeX = 0.0 cellSizeZ = 0.0 if cell: cellSizeX = cell.cellSizeX cellSizeZ = cell.cellSizeZ textScale = PiratesGuiGlobals.TextScaleMed titleScale = PiratesGuiGlobals.TextScaleTitleSmall if len(self.getName()) >= 30: titleNameScale = PiratesGuiGlobals.TextScaleLarge else: titleNameScale = PiratesGuiGlobals.TextScaleExtraLarge subtitleScale = PiratesGuiGlobals.TextScaleMed iconScalar = 1.5 borderScaler = 0.25 splitHeight = 0.01 vMargin = 0.03 runningVertPosition = 0.3 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' else: if rarity == ItemGlobals.COMMON: titleColor = PiratesGuiGlobals.TextFG13 itemColor = 'itemYellow' else: if rarity == ItemGlobals.RARE: titleColor = PiratesGuiGlobals.TextFG4 itemColor = 'itemGreen' else: if rarity == ItemGlobals.FAMED: titleColor = PiratesGuiGlobals.TextFG5 itemColor = 'itemBlue' titleLabel = DirectLabel(parent=self, relief=None, text=self.getName(), 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.07 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.05 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) 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]) else: if itemType == ItemGlobals.SWORD: self.realItem.setPos(-1.5, 3.0, -0.3) self.realItem.setHpr(90, 170, -90) else: if itemSubtype in (ItemGlobals.MUSKET, ItemGlobals.BAYONET): self.realItem.setPos(-1.2, 3.0, -0.1) self.realItem.setHpr(0, 135, 10) else: if itemSubtype == ItemGlobals.BLUNDERBUSS: self.realItem.setPos(-0.3, 2.0, 0.0) self.realItem.setHpr(0, 90, 0) else: if itemType == ItemGlobals.GUN: self.realItem.setPos(-0.5, 2.0, -0.2) self.realItem.setHpr(0, 90, 0) else: if itemType == ItemGlobals.DOLL: self.realItem.setPos(0.0, 1.9, -0.1) self.realItem.setHpr(0, 90, 180) else: if itemType == ItemGlobals.DAGGER: self.realItem.setPos( -1.0, 2.0, -0.3) self.realItem.setHpr(90, 170, -90) else: if itemType == ItemGlobals.GRENADE: self.realItem.setPos( 0.0, 3.5, -0.2) self.realItem.setHpr(0, 0, 0) else: if itemType == ItemGlobals.STAFF: self.realItem.setPos( -0.4, 3.0, -0.3) self.realItem.setHpr( -90, 15, -90) self.realItem.reparentTo(self.portraitSceneGraph) iHeight = 0.175 self.createBuffer() self.itemCard.setZ(runningVertPosition - 0.06) runningVertPosition -= iHeight runningSize += iHeight labels.append(self.itemCard) itemCost = int(ItemGlobals.getGoldCost(itemId)) if self.cell: if self.cell.container: itemCost = int(itemCost * self.cell.container.getItemPriceMult()) goldLabel = DirectLabel(parent=self, relief=None, image=coinImage, image_scale=0.12, image_pos=Vec3(0.025, 0, -0.02), text=str(itemCost), text_scale=subtitleScale, text_align=TextNode.ARight, text_fg=PiratesGuiGlobals.TextFG1, text_shadow=PiratesGuiGlobals.TextShadow, pos=(halfWidth - 0.05, 0.0, runningVertPosition + 0.08), 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))))) 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.08 runningVertPosition -= iHeight runningSize += iHeight labels.append(infoLabel) 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.1, geom=attackIcon, geom_scale=0.1, image_pos=(-0.07, 0.0, -0.05), geom_pos=(-0.07, 0.0, -0.05), text=PLocalizer.getInventoryTypeName(specialAttack), text_scale=PiratesGuiGlobals.TextScaleLarge, text_wordwrap=halfWidth * 2.0 * (0.9 / 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.9 / 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 else: if specialAttackType == WeaponGlobals.DEFENSE_SKILL_INDEX: specialAttackTypeText = PLocalizer.DefenseSkill else: specialAttackTypeText = PLocalizer.WeaponSkill specialAttackTypeLabel = DirectLabel( parent=self, relief=None, text=specialAttackTypeText, text_scale=0.0335, text_wordwrap=halfWidth * 2.8 * (0.9 / 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.8 * (0.9 / titleScale), text_align=TextNode.ALeft, pos=(-halfWidth + 0.12 + textScale * 0.5, 0.0, runningVertPosition - (specialAttackNameLabel.getHeight() + specialAttackTypeLabel.getHeight() - 0.06)), text_pos=(0.0, -textScale)) saHeight = specialAttackNameLabel.getHeight( ) + specialAttackTypeLabel.getHeight( ) + specialAttackDescriptionLabel.getHeight() - 0.04 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.05, geom=attributeIcon, geom_scale=0.05, image_pos=(-0.07, 0.0, -0.03), geom_pos=(-0.07, 0.0, -0.03), text=PLocalizer.getItemAttributeName(attributes[i][0]), text_scale=PiratesGuiGlobals.TextScaleLarge, text_wordwrap=halfWidth * 2.0 * (0.9 / 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.9 / titleScale), text_align=TextNode.ARight, pos=(halfWidth - textScale * 0.5, 0.0, runningVertPosition), text_pos=(0.0, -textScale)) if attributeNameLabel.getHeight() > 0.075: attributeNameSpace = 0.08 else: attributeNameSpace = PiratesGuiGlobals.TextScaleLarge attributeDescriptionLabel = DirectLabel( parent=self, relief=None, text=PLocalizer.getItemAttributeDescription( attributes[i][0]), text_scale=textScale, text_wordwrap=halfWidth * 2.8 * (0.9 / 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)): skillId, skillBoost = skillBoosts[i] linkedSkills = ItemGlobals.getLinkedSkills(itemId) if linkedSkills: for id in linkedSkills: if skillId == WeaponGlobals.getLinkedSkillId(id): skillId = id boostIcon = self.SkillIcons.find( '**/%s' % WeaponGlobals.getSkillIcon(skillId)) boostNameLabel = DirectLabel( parent=self, relief=None, image=border, image_scale=0.05, geom=boostIcon, geom_scale=0.05, image_pos=(-0.07, 0.0, -0.03), geom_pos=(-0.07, 0.0, -0.03), text=PLocalizer.ItemBoost % PLocalizer.getInventoryTypeName(skillId), text_scale=textScale, text_wordwrap=halfWidth * 2.0 * (0.9 / 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(skillBoost), text_scale=textScale, text_wordwrap=halfWidth * 2.0 * (0.9 / 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.95 / 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) 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.4, 0.4, 0.4, 1.0) weaponText = PLocalizer.ItemLevelRequirement % ( weaponReq, PLocalizer.getItemTypeName(itemType)) else: if 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.08) topPanel.reparentTo(self.helpFrame) middlePanel = panels.attachNewNode('middlePanel') detailGui.find('**/middle_panel').copyTo(middlePanel) middlePanel.setScale(0.08) middlePanel.reparentTo(self.helpFrame) placement = 0 i = 0 heightMax = -0.08 currentHeight = runningVertPosition if detailsHeight: currentHeight = -detailsHeight while currentHeight < heightMax: middlePanel = panels.attachNewNode('middlePanel%s' % 1) detailGui.find('**/middle_panel').copyTo(middlePanel) middlePanel.setScale(0.08) middlePanel.reparentTo(self.helpFrame) if currentHeight + 0.2 >= heightMax: difference = heightMax - currentHeight placement += 0.168 / 0.2 * difference currentHeight += difference else: placement += 0.168 currentHeight += 0.2 middlePanel.setZ(-placement) i += 1 bottomPanel = panels.attachNewNode('bottomPanel') detailGui.find('**/bottom_panel').copyTo(bottomPanel) bottomPanel.setScale(0.08) bottomPanel.setZ(-placement) bottomPanel.reparentTo(self.helpFrame) colorPanel = panels.attachNewNode('colorPanel') detailGui.find('**/color').copyTo(colorPanel) colorPanel.setScale(0.08) colorPanel.setColor(titleColor) colorPanel.reparentTo(self.helpFrame) lineBreakTopPanel = panels.attachNewNode('lineBreakTopPanel') detailGui.find('**/line_break_top').copyTo(lineBreakTopPanel) lineBreakTopPanel.setScale(0.08, 0.08, 0.07) lineBreakTopPanel.setZ(0.008) lineBreakTopPanel.reparentTo(self.helpFrame) lineBreakBottomPanel = panels.attachNewNode('lineBreakBottomPanel') detailGui.find('**/line_break_bottom').copyTo(lineBreakBottomPanel) lineBreakBottomPanel.setScale(0.08, 0.08, 0.07) lineBreakBottomPanel.setZ(-0.015) lineBreakBottomPanel.reparentTo(self.helpFrame) panels.flattenStrong() self.helpFrame['frameSize'] = (-halfWidth, halfWidth, -(runningSize + vMargin), vMargin) totalHeight = self.helpFrame.getHeight() - 0.1 for label in labels: label.reparentTo(self.helpFrame) if basePosX > 0.0: newPosX = basePosX - (halfWidth + cellSizeX * 0.45) else: newPosX = basePosX + (halfWidth + cellSizeX * 0.45) newPosZ = basePosZ > 0.0 and basePosZ + cellSizeZ * 0.45 else: newPosZ = basePosZ + totalHeight - cellSizeZ * 0.75 if detailsPos: newPosX, newPosZ = detailsPos self.helpFrame.setPos(newPosX, 0, newPosZ) return
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 checkComboExpired(self, avId, weaponId, skillId, skillResult): attacker = base.cr.doId2do.get(avId) if not attacker: return 0 if skillId in self.EXCLUDED_SKILLS: return 0 skillInfo = WeaponGlobals.getSkillAnimInfo(skillId) if not skillInfo: return 0 barTime = self.TimingCache.get(skillId, None) if barTime is None: anim = skillInfo[WeaponGlobals.PLAYABLE_INDEX] skillAnim = getattr(base.cr.combatAnims, anim)(attacker, skillId, 0, 0, None, skillResult) if skillAnim == None: return 1 barTime = skillAnim.getDuration() self.TimingCache[skillId] = barTime curTime = globalClock.getFrameTime() for attackerId in self.timers: comboLength = len(self.timers[attackerId]) lastEntry = self.timers[attackerId][comboLength - 1] lastSkillId = lastEntry[self.SKILLID_INDEX] timestamp = lastEntry[self.TIMESTAMP_INDEX] if (barTime + timestamp - curTime) + self.TOLERANCE > 0: if attackerId != avId: return 0 subtypeId = ItemGlobals.getSubtype(weaponId) if not subtypeId: return 0 repId = WeaponGlobals.getSkillReputationCategoryId(skillId) if not repId: return 0 if repId != WeaponGlobals.getRepId(weaponId): return 0 comboChain = self.COMBO_ORDER.get(subtypeId) if comboChain: if skillId in self.SPECIAL_SKILLS.get(repId, []): if lastSkillId not in self.SPECIAL_SKILLS.get( repId, []): return 0 elif lastSkillId == skillId: numHits = WeaponGlobals.getNumHits(skillId) if comboLength < numHits: return 0 elif comboLength >= numHits: preMultihitEntry = self.timers[attackerId][ comboLength - numHits] preMultihitSkillId = preMultihitEntry[ self.SKILLID_INDEX] if preMultihitSkillId != skillId: return 0 elif skillId in comboChain: index = comboChain.index(skillId) if index > 0: requisiteAttack = comboChain[index - 1] if lastSkillId == requisiteAttack: return 0 currentAttack = comboChain[index] if lastSkillId == skillId: return 0 elif not comboLength: return 0 return 1
def rePanel(self, inventory): if not self.showing: self.needRefresh = 1 return None skillTokens = { InventoryType.CutlassToken: (ItemGlobals.RUSTY_CUTLASS,), InventoryType.PistolToken: (ItemGlobals.FLINTLOCK_PISTOL,), InventoryType.DollToken: (ItemGlobals.VOODOO_DOLL,), InventoryType.DaggerToken: (ItemGlobals.BASIC_DAGGER,), InventoryType.GrenadeToken: (ItemGlobals.GRENADE_POUCH,), InventoryType.WandToken: (ItemGlobals.CURSED_STAFF,) } zIndex = 1 for skillTokenKey in TOKEN_LIST: quantity = 0 if localAvatar.getInventory().stacks.get(skillTokenKey): quantity = 1 skillData = skillTokens[skillTokenKey] weaponId = skillData[0] key = None panel = WeaponPanel.WeaponPanel((weaponId, quantity), key) panel.reparentTo(self) panel.setZ(PiratesGuiGlobals.InventoryPanelHeight - 0.17999999999999999 - zIndex * panel.height) zIndex += 1 repCat = WeaponGlobals.getRepId(weaponId) self.weaponPanels[repCat] = panel self.ignore('inventoryQuantity-%s' % inventory.getDoId()) self.acceptOnce('inventoryQuantity-%s-%s' % (inventory.getDoId(), skillTokenKey), self.refreshList) repIcon_gui = loader.loadModel('models/textureCards/skillIcons') repIcon = repIcon_gui.find('**/box_base') if config.GetBool('want-fishing-game', 0): self.fishingIcon = GuiButton(pos = (0.16600000000000001, 0, 0.044999999999999998 + (PiratesGuiGlobals.InventoryPanelHeight - 0.17999999999999999) - zIndex * panel.height), helpText = PLocalizer.FishingRepDescription, helpOpaque = True, image = (repIcon, repIcon, repIcon, repIcon), image_scale = (0.14399999999999999, 0.14399999999999999, 0.14399999999999999)) fishIconCard = loader.loadModel('models/textureCards/fishing_icons') inv = localAvatar.getInventory() fishingChangeMsg = InventoryGlobals.getCategoryQuantChangeMsg(inv.doId, InventoryType.FishingRod) if self.fishingChangeMsg: self.ignore(fishingChangeMsg) self.fishingChangeMsg = fishingChangeMsg self.acceptOnce(fishingChangeMsg, self.refreshList) rodIcons = [ 'pir_t_gui_fsh_smRodIcon', 'pir_t_gui_fsh_mdRodIcon', 'pir_t_gui_fsh_lgRodIcon'] rodLvl = inv.getStackQuantity(InventoryType.FishingRod) rodIcon = rodIcons[rodLvl - 1] rodText = PLocalizer.FishingRodNames[rodLvl] if rodLvl >= 1: self.fishingIcon['geom'] = fishIconCard.find('**/' + rodIcon) self.fishingIcon['geom_scale'] = 0.10000000000000001 self.fishingIcon['geom_pos'] = (0, 0, 0) self.fishingIcon.reparentTo(self) fishingRepValue = localAvatar.getInventory().getReputation(InventoryType.FishingRep) self.fishingRepMeter = ReputationMeter(InventoryType.FishingRep, width = 0.66000000000000003) self.fishingRepMeter.setPos(0.62, 0, 0.041000000000000002 + (PiratesGuiGlobals.InventoryPanelHeight - 0.17999999999999999) - zIndex * panel.height) self.fishingRepMeter.update(fishingRepValue) self.fishingRepMeter.reparentTo(self) self.fishingRepMeter.flattenLight() self.fishingPoleName = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = rodText, text_scale = PiratesGuiGlobals.TextScaleSmall, text_align = TextNode.ALeft, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, pos = (0.28999999999999998, 0, -0.0050000000000000001 + (PiratesGuiGlobals.InventoryPanelHeight - 0.17999999999999999) - 7 * panel.height), text_font = PiratesGlobals.getInterfaceFont()) self.fishingPoleName.reparentTo(self) zIndex += 1 iconCard = loader.loadModel('models/textureCards/skillIcons') if config.GetBool('want-potion-game', 0): self.potionIcon = GuiButton(pos = (0.16600000000000001, 0, 0.044999999999999998 + (PiratesGuiGlobals.InventoryPanelHeight - 0.17999999999999999) - zIndex * panel.height), helpText = PLocalizer.PotionRepDescription, helpOpaque = True, image = (repIcon, repIcon, repIcon, repIcon), image_scale = (0.14399999999999999, 0.14399999999999999, 0.14399999999999999)) self.potionIcon['geom'] = iconCard.find('**/pir_t_gui_pot_base') self.potionIcon['geom_scale'] = 0.10000000000000001 self.potionIcon['geom_pos'] = (0, 0, 0) self.potionIcon.reparentTo(self) potionRepValue = localAvatar.getInventory().getReputation(InventoryType.PotionsRep) self.potionRepMeter = ReputationMeter(InventoryType.PotionsRep, width = 0.66000000000000003) self.potionRepMeter.setPos(0.62, 0, 0.041000000000000002 + (PiratesGuiGlobals.InventoryPanelHeight - 0.17999999999999999) - zIndex * panel.height) self.potionRepMeter.update(potionRepValue) self.potionRepMeter.reparentTo(self) self.potionRepMeter.flattenLight() zIndex += 1 items = dict(map(lambda x: (x.getType(), x.getCount()), inventory.getConsumables().values())) possibleItems = ItemGlobals.getAllHealthIds() havePorky = items.get(ItemGlobals.ROAST_PORK) if not havePorky and ItemGlobals.ROAST_PORK in possibleItems: possibleItems.remove(ItemGlobals.ROAST_PORK) offset = 0 if base.config.GetBool('want-potion-game', 0): items = inventory.getConsumables() listLength = len(InventoryType.PotionMinigamePotions) count = 0 for i in range(listLength): tonicId = InventoryType.PotionMinigamePotions[i] if items.get(tonicId): button = SkillButton(tonicId, self.tonicCallback, items.get(tonicId), showQuantity = True, showHelp = True, showRing = True) button.skillButton['geom_scale'] = 0.080000000000000002 x = 0.16 * (count % 6) + -1.2 z = 1.0 - int(count / 6) * 0.16 button.setPos(x, 0, z) button.reparentTo(self) self.tonicButtons[tonicId] = button count += 1 continue
def update(self, repId=None, fromUser=0): inv = localAvatar.getInventory() if not inv: self.notify.warning('SkillPage unable to find inventory') return if self.tabBar == None: return if self.demo: return if fromUser: self.lastUserSelectedTab = repId if repId == None: if localAvatar.getGameState() == 'Fishing': if self.lastUserSelectedTab: repId = self.lastUserSelectedTab else: repId = InventoryType.CannonRep elif localAvatar.cannon: repId = InventoryType.CannonRep elif localAvatar.gameFSM.state == 'ShipPilot': repId = InventoryType.SailingRep elif localAvatar.currentWeaponId and localAvatar.isWeaponDrawn: repId = WeaponGlobals.getRepId(localAvatar.currentWeaponId) elif localAvatar.currentWeaponId and not localAvatar.isWeaponDrawn and self.lastUserSelectedTab: repId = self.lastUserSelectedTab else: repId = InventoryType.CannonRep self.setRep(repId) self.tabBar.selectTab(str(repId)) self.repMeter.setCategory(repId) self.repMeter.update(inv.getReputation(repId)) unSpentId = self.getUnspent() amt = inv.getStackQuantity(unSpentId) if unSpentId in self.localMods: amt = self.localMods[unSpentId] self.unspent['text'] = PLocalizer.SkillPageUnspentPoints % amt if amt > 0: self.unspent['text_fg'] = (0.8, 1, 0.8, 1) else: self.unspent['text_fg'] = (1, 1, 1, 1) comboSkills = RadialMenu.ComboSkills(repId, 1) totalComboSkills = RadialMenu.ComboSkills(repId, 0) activeSkills = RadialMenu.ActiveSkills(repId, 1) totalActiveSkills = RadialMenu.ActiveSkills(repId, 0) passiveSkills = RadialMenu.PassiveSkills(repId, 1) totalPassiveSkills = RadialMenu.PassiveSkills(repId, 0) self.linkedSkillIds = {} linkedSkills = ItemGlobals.getLinkedSkills(localAvatar.currentWeaponId) if linkedSkills: for skillId in linkedSkills: realSkillId = WeaponGlobals.getLinkedSkillId(skillId) self.linkedSkillIds[realSkillId] = skillId for excludedSkillId in self.EXCLUDED_SKILLS: for skillId in activeSkills: if excludedSkillId == skillId: activeSkills.remove(skillId) totalActiveSkills.remove(skillId) for spot in self.skillFrames.keys(): if spot not in totalComboSkills: self.skillFrames[spot].hide() count = 0 for skill in totalComboSkills: skillPts = inv.getStackQuantity(skill) if skill in self.localMods: skillPts = self.localMods[skill] showIcon = skill in comboSkills or skillPts > 0 freeLock = False if not Freebooter.getPaidStatus(base.localAvatar.getDoId()): if not WeaponGlobals.canFreeUse(skill): freeLock = True if self.linkedSkillIds.has_key(skill): if self.skillFrames.has_key(skill): self.skillFrames[skill].hide() skill = self.linkedSkillIds[skill] self.createFrame(skill, skillPts, amt, freeLock, showIcon) x = 0.2 + 0.175 * count y = 1.11 self.skillFrames[skill].setPos(x, 0, y) if showIcon and skillPts > 1: self.makeBoostDisplay(skill, skillPts - 1) if not Freebooter.getPaidStatus(base.localAvatar.getDoId()): if not WeaponGlobals.canFreeUse(skill): self.skillFrames[skill].skillButton[ 'command'] = base.localAvatar.guiMgr.showNonPayer self.skillFrames[skill].skillButton['extraArgs'] = [ 'Restricted_Skill_' + WeaponGlobals.getSkillName(skill), 5 ] count += 1 count = 0 for skill in totalActiveSkills: skillPts = inv.getStackQuantity(skill) if skill in self.localMods: skillPts = self.localMods[skill] xMod, yMod = self.ringOffset(count) xMod *= 0.9 yMod *= 0.9 showIcon = skill in activeSkills or skillPts > 0 freeLock = False if not Freebooter.getPaidStatus(base.localAvatar.getDoId()): if not WeaponGlobals.canFreeUse(skill): freeLock = True if self.linkedSkillIds.has_key(skill): if self.skillFrames.has_key(skill): self.skillFrames[skill].hide() skill = self.linkedSkillIds[skill] self.createFrame(skill, skillPts, amt, freeLock, showIcon) x = xMod + 0.53 y = yMod + 0.615 self.skillFrames[skill].setPos(x, 0, y) if showIcon and skillPts > 1: self.makeBoostDisplay(skill, skillPts - 1) if not Freebooter.getPaidStatus(base.localAvatar.getDoId()): if not WeaponGlobals.canFreeUse(skill): self.skillFrames[skill].skillButton[ 'command'] = base.localAvatar.guiMgr.showNonPayer self.skillFrames[skill].skillButton['extraArgs'] = [ 'Restricted_Skill_' + WeaponGlobals.getSkillName(skill), 5 ] ammo = self.getAmmo(skill) if ammo != None and showIcon: self.skillFrames[skill].showQuantity = True self.skillFrames[skill].updateQuantity(ammo) count += 1 count = 0 for skill in totalPassiveSkills: skillPts = inv.getStackQuantity(skill) if skill in self.localMods: skillPts = self.localMods[skill] showIcon = skill in passiveSkills or skillPts > 0 freeLock = False if not Freebooter.getPaidStatus(base.localAvatar.getDoId()): if not WeaponGlobals.canFreeUse(skill): freeLock = True if self.linkedSkillIds.has_key(skill): if self.skillFrames.has_key(skill): self.skillFrames[skill].hide() skill = self.linkedSkillIds[skill] self.createFrame(skill, skillPts, amt, freeLock, showIcon) x = 0.2 + 0.175 * count y = 0.15 self.skillFrames[skill].setPos(x, 0, y) if showIcon and skillPts > 1: self.makeBoostDisplay(skill, skillPts - 1) if not Freebooter.getPaidStatus(base.localAvatar.getDoId()): if not WeaponGlobals.canFreeUse(skill): self.skillFrames[skill].skillButton[ 'command'] = base.localAvatar.guiMgr.showNonPayer self.skillFrames[skill].skillButton['extraArgs'] = [ 'Restricted_Skill_' + WeaponGlobals.getSkillName(skill), 5 ] count += 1 self.dataChanged = False return
def aimOverTargetTask(self, task): if base.localAvatar.hasStickyTargets(): if isinstance(base.localAvatar.currentWeapon, Doll.Doll): target = base.localAvatar.currentTarget if target: pt = self.getNearProjectionPoint(target) pt, distance = self.getTargetScreenXY(target) self.reticleHolder.setPos(pt) self.reticle.setScale(self.reticleScale / distance) else: self.reticleHolder.setPos(self.RETICLE_POS) self.reticle.setScale(self.reticleScale) return Task.cont target, dist = self.takeAim(base.localAvatar) if target: monstrous = target.hasNetPythonTag('MonstrousObject') else: monstrous = False dt = globalClock.getDt() dt = min(1.0, 8 * dt) if self.wantAimAssist: if target: pt = not monstrous and self.getNearProjectionPoint(target) pt, distance = self.getTargetScreenXY(target) rPos = self.reticleHolder.getPos() if not rPos.almostEqual(pt, 0.001): nPos = Vec3(rPos) nPos += (pt - rPos) * dt self.reticleHolder.setPos(nPos) rScale = self.reticle.getScale() nScale = rScale.almostEqual(Vec3(self.reticleScale), 0.001) or Vec3(rScale) f = self.reticleScale / distance nScale += (Vec3(f, f, f) - rScale) * dt nScale.setX(max(self.reticleScale / 1.25, nScale[0])) nScale.setY(max(self.reticleScale / 1.25, nScale[1])) nScale.setZ(max(self.reticleScale / 1.25, nScale[2])) self.reticle.setScale(nScale) else: rPos = self.reticleHolder.getPos() if not rPos.almostEqual(self.RETICLE_POS, 0.001): nPos = Vec3(rPos) nPos += (self.RETICLE_POS - rPos) * dt self.reticleHolder.setPos(nPos) self.reticle.setScale(self.reticleScale) target and TeamUtils.damageAllowed( target, localAvatar) and self.reticle.setColorScale( 1, 1, 1, self.reticleAlpha) if base.localAvatar.currentWeapon: repId = WeaponGlobals.getRepId(base.localAvatar.currentWeaponId) baseRange = self.WeaponBaseRange.get(repId) calcRange = 0 specialRange = 0 specialMeleeRange = 0 ammoSkillId = localAvatar.guiMgr.combatTray.ammoSkillId deadzoneRange = base.cr.battleMgr.getModifiedAttackDeadzone( localAvatar, 0, ammoSkillId) if repId == InventoryType.PistolRep: if localAvatar.guiMgr.combatTray.isCharging: calcRange = base.cr.battleMgr.getModifiedAttackRange( localAvatar, InventoryType.PistolTakeAim, ammoSkillId) else: calcRange = base.cr.battleMgr.getModifiedAttackRange( localAvatar, InventoryType.PistolShoot, ammoSkillId) if ItemGlobals.getSubtype(localAvatar.currentWeaponId ) == ItemGlobals.BLUNDERBUSS: baseRange = base.cr.battleMgr.getModifiedAttackRange( localAvatar, EnemySkills.PISTOL_SCATTERSHOT, ammoSkillId) calcRange = base.cr.battleMgr.getModifiedAttackRange( localAvatar, EnemySkills.PISTOL_SCATTERSHOT, ammoSkillId) elif ItemGlobals.getSubtype( localAvatar.currentWeaponId) == ItemGlobals.MUSKET: specialRange = base.cr.battleMgr.getModifiedAttackRange( localAvatar, EnemySkills.PISTOL_DEADEYE, ammoSkillId) elif ItemGlobals.getSubtype( localAvatar.currentWeaponId) == ItemGlobals.BAYONET: specialMeleeRange = base.cr.battleMgr.getModifiedAttackRange( localAvatar, EnemySkills.BAYONET_RUSH, 0) else: if repId == InventoryType.DaggerRep: calcRange = base.cr.battleMgr.getModifiedAttackRange( localAvatar, InventoryType.DaggerAsp, 0) else: if repId == InventoryType.WandRep: if ammoSkillId: calcRange = base.cr.battleMgr.getModifiedAttackRange( localAvatar, ammoSkillId, 0) specialRange = base.cr.battleMgr.getModifiedAttackRange( localAvatar, InventoryType.StaffBlast, 0) distance = dist if hasattr(target, 'battleTubeNodePaths'): if not monstrous: for tube in target.battleTubeNodePaths: tubeLength = max(target.battleTubeRadius, target.battleTubeHeight) if distance - tubeLength < distance: distance -= tubeLength range = max(baseRange, calcRange) secondaryRange = max(baseRange, specialRange) if distance <= secondaryRange: if distance >= deadzoneRange: self.reticle.setColorScale(1, 0.7, 0, self.reticleAlpha) if distance <= range: if distance >= deadzoneRange: self.reticle.setColorScale(1, 0, 0, self.reticleAlpha) if specialMeleeRange: if distance <= specialMeleeRange: self.reticle.setColorScale( 1, 0.7, 0, self.reticleAlpha) else: self.reticle.setColorScale(0, 0, 1, self.reticleAlpha) else: self.reticle.setColorScale(1, 1, 1, self.reticleAlpha) oldTarget = base.localAvatar.currentAimOver if target == oldTarget: return Task.cont if oldTarget != None: messenger.send(oldTarget.uniqueName('aimOver'), [0]) base.localAvatar.currentAimOver = None oldTarget.hideEnemyTargetInfo() if oldTarget != None and not target: oldTarget.hideHpMeter(delay=8.0) target and not target.isInvisibleGhost( ) and target.showHpMeter() TeamUtils.damageAllowed( target, localAvatar) and target.showEnemyTargetInfo() messenger.send('pistolAimedTarget') else: target.showFriendlyTargetInfo() messenger.send(target.uniqueName('aimOver'), [1]) base.localAvatar.currentAimOver = target else: base.localAvatar.currentAimOver = None return Task.cont
def createGui(self): itemId = self.data[0] self.picture = DirectFrame(parent=self, relief=None, state=DGG.DISABLED, pos=(0.01, 0, 0.01)) self.nameTag = DirectLabel( parent=self, relief=None, state=DGG.DISABLED, text=self.name, text_scale=PiratesGuiGlobals.TextScaleSmall * PLocalizer.getHeadingScale(2), text_align=TextNode.ALeft, text_fg=PiratesGuiGlobals.TextFG1, text_shadow=PiratesGuiGlobals.TextShadow, pos=(0.050000000000000003, 0, 0.105), text_font=PiratesGlobals.getInterfaceFont()) itemTypeFormatted = '' self.itemTypeName = DirectLabel( parent=self, relief=None, state=DGG.DISABLED, text=itemTypeFormatted, text_scale=PiratesGuiGlobals.TextScaleSmall, text_align=TextNode.ALeft, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, text_font=PiratesGlobals.getInterfaceFont(), pos=(0.050000000000000003, 0, 0.065000000000000002)) self.miscText = DirectLabel( parent=self, relief=None, state=DGG.DISABLED, text='', text_scale=PiratesGuiGlobals.TextScaleSmall, text_align=TextNode.ALeft, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, text_wordwrap=11, pos=(0.050000000000000003, 0, 0.025000000000000001)) if self.minLvl > 0: repId = WeaponGlobals.getRepId(itemId) if repId: self.checkLevel(repId, self.minLvl) trainingReq = EconomyGlobals.getItemTrainingReq(itemId) if trainingReq: self.checkTrainingReq(trainingReq) if EconomyGlobals.getItemCategory(itemId) == ItemType.AMMO: skillId = WeaponGlobals.getSkillIdForAmmoSkillId(itemId) self.checkSkillReq(skillId) if self.buy: self.checkPlayerInventory(itemId) self.costText = DirectLabel( parent=self, relief=None, state=DGG.DISABLED, image=SongListItem.coinImage, image_scale=0.12, image_pos=Vec3(-0.01, 0, 0.01), text=str(self.price), text_scale=PiratesGuiGlobals.TextScaleSmall, text_align=TextNode.ARight, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, text_wordwrap=11, text_pos=(-0.029999999999999999, 0, 0), pos=(self.width - 0.035000000000000003, 0, 0.105), text_font=PiratesGlobals.getInterfaceFont()) if self.quantity and self.quantity > 1: self.quantityLabel = DirectLabel( parent=self, relief=None, state=DGG.DISABLED, text=str(self.quantity), frameColor=(0, 0, 0, 1), frameSize=(-0.01, 0.02, -0.01, 0.025000000000000001), text_scale=0.0275, text_align=TextNode.ACenter, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, text_wordwrap=11, pos=(0.02, 0, 0.025000000000000001), text_font=PiratesGlobals.getPirateBoldOutlineFont()) itemClass = EconomyGlobals.getItemCategory(itemId) if itemClass == ItemType.WEAPON or itemClass == ItemType.POUCH: asset = EconomyGlobals.getItemIcons(itemId) if asset: self.picture['geom'] = SongItemGui.weaponIcons.find('**/%s*' % asset) self.picture['geom_scale'] = 0.11 self.picture['geom_pos'] = (0.080000000000000002, 0, 0.068000000000000005) elif itemClass == ItemType.CONSUMABLE: asset = EconomyGlobals.getItemIcons(itemId) if asset: self.picture['geom'] = SongItemGui.skillIcons.find('**/%s*' % asset) self.picture['geom_scale'] = 0.11 self.picture['geom_pos'] = (0.080000000000000002, 0, 0.068000000000000005) if not InventoryType.begin_WeaponCannonAmmo <= itemId or itemId <= InventoryType.end_WeaponCannonAmmo: if (InventoryType.begin_WeaponPistolAmmo <= itemId or itemId <= InventoryType.end_WeaponGrenadeAmmo or InventoryType.begin_WeaponDaggerAmmo <= itemId ) and itemId <= InventoryType.end_WeaponDaggerAmmo: skillId = WeaponGlobals.getSkillIdForAmmoSkillId(itemId) if skillId: asset = WeaponGlobals.getSkillIcon(skillId) if asset: self.picture['geom'] = SongListItem.skillIcons.find( '**/%s' % asset) self.picture['geom_scale'] = 0.14999999999999999 self.picture['geom_pos'] = (0.069000000000000006, 0, 0.069000000000000006) elif InventoryType.SmallBottle <= itemId and itemId <= InventoryType.LargeBottle: self.picture['geom'] = SongListItem.topGui.find( '**/main_gui_ship_bottle') self.picture['geom_scale'] = 0.10000000000000001 self.picture['geom_pos'] = (0.069000000000000006, 0, 0.069000000000000006) self.flattenStrong()
def loadWeaponButtons(self): for hotkey in self.hotkeys: hotkey.destroy() self.hotkeys = [] for icon in self.icons: icon.destroy() self.icons = [] for repMeter in self.repMeters: repMeter.destroy() self.repMeters = [] self['frameSize'] = (0, self.ICON_WIDTH * len(self.items) + 0.040000000000000001, 0, self.HEIGHT) self.setX(-( (self.ICON_WIDTH * len(self.items) + 0.040000000000000001) / 2.0)) topGui = loader.loadModel('models/gui/toplevel_gui') kbButton = topGui.find('**/keyboard_button') for i in range(len(self.items)): if self.items[i]: category = WeaponGlobals.getRepId(self.items[i][0]) icon = DirectFrame( parent=self, state=DGG.DISABLED, relief=None, frameSize=(0, 0.080000000000000002, 0, 0.080000000000000002), pos=(self.ICON_WIDTH * i + 0.080000000000000002, 0, 0.082000000000000003)) icon.setTransparency(1) hotkeyText = 'F%s' % self.items[i][1] hotkey = DirectFrame(parent=icon, state=DGG.DISABLED, relief=None, text=hotkeyText, text_align=TextNode.ACenter, text_scale=0.044999999999999998, text_pos=(0, 0), text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, image=kbButton, image_scale=0.059999999999999998, image_pos=(0, 0, 0.01), image_color=(0.5, 0.5, 0.34999999999999998, 1), pos=(0, 0, 0.080000000000000002)) self.hotkeys.append(hotkey) category = WeaponGlobals.getRepId(self.items[i][0]) if Freebooter.getPaidStatus(base.localAvatar.getDoId( )) or Freebooter.allowedFreebooterWeapon(category): asset = ItemGlobals.getIcon(self.items[i][0]) if asset: texCard = self.card.find('**/%s' % asset) icon['geom'] = texCard icon['geom_scale'] = 0.080000000000000002 icon.resetFrameSize() self.icons.append(icon) else: texCard = topGui.find('**/pir_t_gui_gen_key_subscriber*') icon['geom'] = texCard icon['geom_scale'] = 0.20000000000000001 icon.resetFrameSize() self.icons.append(icon) repMeter = DirectWaitBar( parent=icon, relief=DGG.SUNKEN, state=DGG.DISABLED, borderWidth=(0.002, 0.002), range=0, value=0, frameColor=(0.23999999999999999, 0.23999999999999999, 0.20999999999999999, 1), barColor=(0.80000000000000004, 0.80000000000000004, 0.69999999999999996, 1), pos=(-0.050000000000000003, 0, -0.052499999999999998), hpr=(0, 0, 0), frameSize=(0.0050000000000000001, 0.095000000000000001, 0, 0.012500000000000001)) self.repMeters.append(repMeter) inv = base.localAvatar.getInventory() if inv: repValue = inv.getReputation(category) (level, leftoverValue ) = ReputationGlobals.getLevelFromTotalReputation( category, repValue) max = ReputationGlobals.getReputationNeededToLevel( category, level) repMeter['range'] = max repMeter['value'] = leftoverValue
def handleBuyItem(self, data, useCode): itemId = data[0] if not itemId: return itemType = EconomyGlobals.getItemType(itemId) if itemType <= ItemType.WAND or itemType == ItemType.POTION: data[1] = 1 else: data[1] = EconomyGlobals.getItemQuantity(itemId) inventory = base.localAvatar.getInventory() if not inventory: return itemQuantity = self.purchaseInventory.getItemQuantity(itemId) currStock = inventory.getStackQuantity(itemId) currStockLimit = inventory.getStackLimit(itemId) if useCode == PiratesGuiGlobals.InventoryAdd: itemTypeName = PLocalizer.InventoryItemClassNames.get(itemType) trainingReq = EconomyGlobals.getItemTrainingReq(itemId) if trainingReq: amt = inventory.getStackQuantity(trainingReq) if not amt: base.localAvatar.guiMgr.createWarning( PLocalizer.NoTrainingWarning % itemTypeName, PiratesGuiGlobals.TextFG6) return itemType = EconomyGlobals.getItemType(itemId) if itemType != ItemType.POTION: minLvl = ItemGlobals.getWeaponRequirement(itemId) else: minLvl = 0 repId = WeaponGlobals.getRepId(itemId) repAmt = inventory.getAccumulator(repId) if minLvl > ReputationGlobals.getLevelFromTotalReputation( repId, repAmt)[0]: base.localAvatar.guiMgr.createWarning( PLocalizer.LevelReqWarning % (minLvl, itemTypeName), PiratesGuiGlobals.TextFG6) return if itemId in ItemGlobals.getAllWeaponIds(): locatables = [] for dataInfo in self.purchaseInventory.inventory: dataId = dataInfo[0] if dataId in ItemGlobals.getAllWeaponIds(): locatables.append( InvItem([InventoryType.ItemTypeWeapon, dataId, 0])) locatables.append( InvItem([InventoryType.ItemTypeWeapon, itemId, 0])) locationIds = inventory.canAddLocatables(locatables) for locationId in locationIds: if locationId in (Locations.INVALID_LOCATION, Locations.NON_LOCATION): base.localAvatar.guiMgr.createWarning( PLocalizer.InventoryFullWarning, PiratesGuiGlobals.TextFG6) return else: if itemId in ItemGlobals.getAllConsumableIds(): itemQuantity = self.purchaseInventory.getItemQuantity( itemId) currStock = inventory.getItemQuantity( InventoryType.ItemTypeConsumable, itemId) currStockLimit = inventory.getItemLimit( InventoryType.ItemTypeConsumable, itemId) if currStock + itemQuantity >= currStockLimit: base.localAvatar.guiMgr.createWarning( PLocalizer.TradeItemFullWarning, PiratesGuiGlobals.TextFG6) return if currStock == 0: locatables = [] dataIds = {} for dataInfo in self.purchaseInventory.inventory: dataId = dataInfo[0] if dataId in ItemGlobals.getAllConsumableIds(): if dataIds.has_key(dataId): dataIds[dataId] += 1 else: dataIds[dataId] = 1 if dataIds.has_key(itemId): dataIds[itemId] += 1 else: dataIds[itemId] = 1 for dataId in dataIds: locatables.append( InvItem([ InventoryType.ItemTypeConsumable, dataId, 0, dataIds[dataId] ])) locationIds = inventory.canAddLocatables(locatables) for locationId in locationIds: if locationId in (Locations.INVALID_LOCATION, Locations.NON_LOCATION): base.localAvatar.guiMgr.createWarning( PLocalizer.InventoryFullWarning, PiratesGuiGlobals.TextFG6) return itemQuantity = self.purchaseInventory.getItemQuantity(itemId) currStock = inventory.getStackQuantity(itemId) currStockLimit = inventory.getStackLimit(itemId) itemCategory = EconomyGlobals.getItemCategory(itemId) if currStock + itemQuantity >= currStockLimit: base.localAvatar.guiMgr.createWarning( PLocalizer.TradeItemFullWarning, PiratesGuiGlobals.TextFG6) return self.purchaseInventory.addPanel(data) self.purchaseInventory.inventory.append(data) elif useCode == PiratesGuiGlobals.InventoryRemove: self.purchaseInventory.removePanel(data) panel = self.storeInventory.getPanel(data) if panel: self.checkPanel(panel, inventory, itemId) self.updateBalance()
def checkComboExpired(self, avId, weaponId, skillId, skillResult): attacker = base.cr.doId2do.get(avId) if not attacker: return 0 if skillId in self.EXCLUDED_SKILLS: return 0 skillInfo = WeaponGlobals.getSkillAnimInfo(skillId) if not skillInfo: return 0 barTime = self.TimingCache.get(skillId, None) if barTime is None: anim = skillInfo[WeaponGlobals.PLAYABLE_INDEX] skillAnim = getattr(base.cr.combatAnims, anim)(attacker, skillId, 0, 0, None, skillResult) if skillAnim == None: return 1 barTime = skillAnim.getDuration() self.TimingCache[skillId] = barTime curTime = globalClock.getFrameTime() for attackerId in self.timers: comboLength = len(self.timers[attackerId]) lastEntry = self.timers[attackerId][comboLength - 1] lastSkillId = lastEntry[self.SKILLID_INDEX] timestamp = lastEntry[self.TIMESTAMP_INDEX] if (barTime + timestamp - curTime) + self.TOLERANCE > 0: if attackerId != avId: return 0 subtypeId = ItemGlobals.getSubtype(weaponId) if not subtypeId: return 0 repId = WeaponGlobals.getSkillReputationCategoryId(skillId) if not repId: return 0 if repId != WeaponGlobals.getRepId(weaponId): return 0 comboChain = self.COMBO_ORDER.get(subtypeId) if comboChain: if skillId in self.SPECIAL_SKILLS.get(repId, []): if lastSkillId not in self.SPECIAL_SKILLS.get(repId, []): return 0 elif lastSkillId == skillId: numHits = WeaponGlobals.getNumHits(skillId) if comboLength < numHits: return 0 elif comboLength >= numHits: preMultihitEntry = self.timers[attackerId][comboLength - numHits] preMultihitSkillId = preMultihitEntry[self.SKILLID_INDEX] if preMultihitSkillId != skillId: return 0 elif skillId in comboChain: index = comboChain.index(skillId) if index > 0: requisiteAttack = comboChain[index - 1] if lastSkillId == requisiteAttack: return 0 currentAttack = comboChain[index] if lastSkillId == skillId: return 0 elif not comboLength: return 0 return 1
def showDetails(self, cell, detailsPos, detailsHeight, event = None): self.notify.debug('Item showDetails') if self.manager.heldItem and self.manager.locked and cell.isEmpty() and self.isEmpty() or not (self.itemTuple): self.notify.debug(' early exit') return None inv = localAvatar.getInventory() if not inv: return None itemId = self.getId() self.helpFrame = DirectFrame(parent = self.manager, relief = None, state = DGG.DISABLED, sortOrder = 1) self.helpFrame.setBin('gui-popup', -5) 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 basePosX = cell.getX(aspect2d) basePosZ = cell.getZ(aspect2d) cellSizeX = 0.0 cellSizeZ = 0.0 if cell: cellSizeX = cell.cellSizeX cellSizeZ = cell.cellSizeZ textScale = PiratesGuiGlobals.TextScaleMed titleScale = PiratesGuiGlobals.TextScaleTitleSmall if len(self.getName()) >= 30: titleNameScale = PiratesGuiGlobals.TextScaleLarge else: 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 rarity = ItemGlobals.getRarity(itemId) rarityText = PLocalizer.getItemRarityName(rarity) subtypeText = PLocalizer.getItemSubtypeName(ItemGlobals.getSubtype(itemId)) if rarity == ItemGlobals.CRUDE: titleColor = PiratesGuiGlobals.TextFG24 elif rarity == ItemGlobals.COMMON: titleColor = PiratesGuiGlobals.TextFG13 elif rarity == ItemGlobals.RARE: titleColor = PiratesGuiGlobals.TextFG4 elif rarity == ItemGlobals.FAMED: titleColor = PiratesGuiGlobals.TextFG5 titleLabel = DirectLabel(parent = self, relief = None, text = self.getName(), 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 = '\x001slant\x001%s %s\x002' % (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: self.realItem = loader.loadModel('models/inventory/' + model) if self.realItem: 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 itemSubtype == ItemGlobals.RAM: self.realItem.setPos(-1.5, 1.5, -0.59999999999999998) self.realItem.setHpr(70, 160, -90) else: self.realItem.setPos(0.0, 1.5, -0.059999999999999998) self.realItem.setHpr(0, 90, 0) self.realItem.reparentTo(self.portraitSceneGraph) iHeight = 0.17999999999999999 self.createBuffer() self.itemCard.setZ(runningVertPosition - 0.059999999999999998) runningVertPosition -= iHeight runningSize += iHeight labels.append(self.itemCard) itemCost = int(ItemGlobals.getGoldCost(itemId)) if self.cell and self.cell.container: itemCost = int(itemCost * self.cell.container.getItemPriceMult()) goldLabel = DirectLabel(parent = self, relief = None, image = coinImage, image_scale = 0.12, image_pos = Vec3(0.025000000000000001, 0, -0.02), text = str(itemCost), 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) 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(), 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 = PiratesGuiGlobals.TextScaleLarge, 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 = textScale, text_wordwrap = halfWidth * 2.0 * (0.90000000000000002 / titleScale), text_align = TextNode.ALeft, text_fg = titleColor, text_font = PiratesGlobals.getInterfaceOutlineFont(), 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) weaponLevel = 0 weaponRepId = WeaponGlobals.getRepId(itemId) weaponRep = inv.getReputation(weaponRepId) weaponReq = ItemGlobals.getWeaponRequirement(itemId) weaponText = None 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)) else: trainingToken = EconomyGlobals.getItemTrainingReq(itemId) trainingAmt = inv.getItemQuantity(trainingToken) if trainingAmt == 0: weaponColor = PiratesGuiGlobals.TextFG6 weaponText = PLocalizer.ItemTrainingRequirement % PLocalizer.getItemTypeName(itemType) 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) panels.flattenStrong() self.helpFrame['frameSize'] = (-halfWidth, halfWidth, -(runningSize + vMargin), vMargin) totalHeight = self.helpFrame.getHeight() - 0.10000000000000001 for label in labels: label.reparentTo(self.helpFrame) if basePosX > 0.0: newPosX = basePosX - halfWidth + cellSizeX * 0.45000000000000001 else: newPosX = basePosX + halfWidth + cellSizeX * 0.45000000000000001 if basePosZ > 0.0: newPosZ = basePosZ + cellSizeZ * 0.45000000000000001 else: newPosZ = basePosZ + totalHeight - cellSizeZ * 0.75 if detailsPos: (newPosX, newPosZ) = detailsPos self.helpFrame.setPos(newPosX, 0, newPosZ)
def handleBuyItem(self, data, useCode): itemId = data[0] if not itemId: return None itemType = EconomyGlobals.getItemType(itemId) if itemType <= ItemType.WAND or itemType == ItemType.POTION: data[1] = 1 else: data[1] = EconomyGlobals.getItemQuantity(itemId) inventory = base.localAvatar.getInventory() if not inventory: return None itemQuantity = self.purchaseInventory.getItemQuantity(itemId) currStock = inventory.getStackQuantity(itemId) currStockLimit = inventory.getStackLimit(itemId) if useCode == PiratesGuiGlobals.InventoryAdd: itemTypeName = PLocalizer.InventoryItemClassNames.get(itemType) trainingReq = EconomyGlobals.getItemTrainingReq(itemId) if trainingReq: amt = inventory.getStackQuantity(trainingReq) if not amt: base.localAvatar.guiMgr.createWarning(PLocalizer.NoTrainingWarning % itemTypeName, PiratesGuiGlobals.TextFG6) return None itemType = EconomyGlobals.getItemType(itemId) if itemType != ItemType.POTION: minLvl = ItemGlobals.getWeaponRequirement(itemId) else: minLvl = 0 repId = WeaponGlobals.getRepId(itemId) repAmt = inventory.getAccumulator(repId) if minLvl > ReputationGlobals.getLevelFromTotalReputation(repId, repAmt)[0]: base.localAvatar.guiMgr.createWarning(PLocalizer.LevelReqWarning % (minLvl, itemTypeName), PiratesGuiGlobals.TextFG6) return None if itemId in ItemGlobals.getAllWeaponIds(): locatables = [] for dataInfo in self.purchaseInventory.inventory: dataId = dataInfo[0] if dataId in ItemGlobals.getAllWeaponIds(): locatables.append(InvItem([ InventoryType.ItemTypeWeapon, dataId, 0])) continue locatables.append(InvItem([ InventoryType.ItemTypeWeapon, itemId, 0])) locationIds = inventory.canAddLocatables(locatables) for locationId in locationIds: if locationId in (Locations.INVALID_LOCATION, Locations.NON_LOCATION): base.localAvatar.guiMgr.createWarning(PLocalizer.InventoryFullWarning, PiratesGuiGlobals.TextFG6) return None continue elif itemId in ItemGlobals.getAllConsumableIds(): itemQuantity = self.purchaseInventory.getItemQuantity(itemId) currStock = inventory.getItemQuantity(InventoryType.ItemTypeConsumable, itemId) currStockLimit = inventory.getItemLimit(InventoryType.ItemTypeConsumable, itemId) if currStock + itemQuantity >= currStockLimit: base.localAvatar.guiMgr.createWarning(PLocalizer.TradeItemFullWarning, PiratesGuiGlobals.TextFG6) return None if currStock == 0: locatables = [] dataIds = { } for dataInfo in self.purchaseInventory.inventory: dataId = dataInfo[0] if dataId in ItemGlobals.getAllConsumableIds(): if dataIds.has_key(dataId): dataIds[dataId] += 1 else: dataIds[dataId] = 1 dataIds.has_key(dataId) if dataIds.has_key(itemId): dataIds[itemId] += 1 else: dataIds[itemId] = 1 for dataId in dataIds: locatables.append(InvItem([ InventoryType.ItemTypeConsumable, dataId, 0, dataIds[dataId]])) locationIds = inventory.canAddLocatables(locatables) for locationId in locationIds: if locationId in (Locations.INVALID_LOCATION, Locations.NON_LOCATION): base.localAvatar.guiMgr.createWarning(PLocalizer.InventoryFullWarning, PiratesGuiGlobals.TextFG6) return None continue else: itemQuantity = self.purchaseInventory.getItemQuantity(itemId) currStock = inventory.getStackQuantity(itemId) currStockLimit = inventory.getStackLimit(itemId) itemCategory = EconomyGlobals.getItemCategory(itemId) if currStock + itemQuantity >= currStockLimit: base.localAvatar.guiMgr.createWarning(PLocalizer.TradeItemFullWarning, PiratesGuiGlobals.TextFG6) return None self.purchaseInventory.addPanel(data) self.purchaseInventory.inventory.append(data) elif useCode == PiratesGuiGlobals.InventoryRemove: self.purchaseInventory.removePanel(data) panel = self.storeInventory.getPanel(data) if panel: self.checkPanel(panel, inventory, itemId) self.updateBalance()
def update(self, repId = None, fromUser = 0): inv = localAvatar.getInventory() if not inv: self.notify.warning('SkillPage unable to find inventory') return None if self.tabBar == None: return None if self.demo: return None if fromUser: self.lastUserSelectedTab = repId if repId == None: if localAvatar.getGameState() == 'Fishing': if self.lastUserSelectedTab: repId = self.lastUserSelectedTab else: repId = InventoryType.CannonRep elif localAvatar.cannon: repId = InventoryType.CannonRep elif localAvatar.gameFSM.state == 'ShipPilot': repId = InventoryType.SailingRep elif localAvatar.currentWeaponId and localAvatar.isWeaponDrawn: repId = WeaponGlobals.getRepId(localAvatar.currentWeaponId) elif localAvatar.currentWeaponId and not (localAvatar.isWeaponDrawn) and self.lastUserSelectedTab: repId = self.lastUserSelectedTab else: repId = InventoryType.CannonRep self.setRep(repId) self.tabBar.selectTab(str(repId)) self.repMeter.setCategory(repId) self.repMeter.update(inv.getReputation(repId)) unSpentId = self.getUnspent() amt = inv.getStackQuantity(unSpentId) if unSpentId in self.localMods: amt = self.localMods[unSpentId] self.unspent['text'] = PLocalizer.SkillPageUnspentPoints % amt if amt > 0: self.unspent['text_fg'] = (0.80000000000000004, 1, 0.80000000000000004, 1) else: self.unspent['text_fg'] = (1, 1, 1, 1) comboSkills = RadialMenu.ComboSkills(repId, 1) totalComboSkills = RadialMenu.ComboSkills(repId, 0) activeSkills = RadialMenu.ActiveSkills(repId, 1) totalActiveSkills = RadialMenu.ActiveSkills(repId, 0) passiveSkills = RadialMenu.PassiveSkills(repId, 1) totalPassiveSkills = RadialMenu.PassiveSkills(repId, 0) self.linkedSkillIds = { } linkedSkills = ItemGlobals.getLinkedSkills(localAvatar.currentWeaponId) if linkedSkills: for skillId in linkedSkills: realSkillId = WeaponGlobals.getLinkedSkillId(skillId) self.linkedSkillIds[realSkillId] = skillId for excludedSkillId in self.EXCLUDED_SKILLS: for skillId in activeSkills: if excludedSkillId == skillId: activeSkills.remove(skillId) totalActiveSkills.remove(skillId) continue for spot in self.skillFrames.keys(): if spot not in totalComboSkills: self.skillFrames[spot].hide() continue count = 0 for skill in totalComboSkills: skillPts = inv.getStackQuantity(skill) if skill in self.localMods: skillPts = self.localMods[skill] if not skill in comboSkills: pass showIcon = skillPts > 0 freeLock = False if not Freebooter.getPaidStatus(base.localAvatar.getDoId()): if not WeaponGlobals.canFreeUse(skill): freeLock = True if self.linkedSkillIds.has_key(skill): if self.skillFrames.has_key(skill): self.skillFrames[skill].hide() skill = self.linkedSkillIds[skill] self.createFrame(skill, skillPts, amt, freeLock, showIcon) x = 0.20000000000000001 + 0.17499999999999999 * count y = 1.1100000000000001 self.skillFrames[skill].setPos(x, 0, y) if showIcon and skillPts > 1: self.makeBoostDisplay(skill, skillPts - 1) if not Freebooter.getPaidStatus(base.localAvatar.getDoId()): if not WeaponGlobals.canFreeUse(skill): self.skillFrames[skill].skillButton['command'] = base.localAvatar.guiMgr.showNonPayer self.skillFrames[skill].skillButton['extraArgs'] = [ 'Restricted_Skill_' + WeaponGlobals.getSkillName(skill), 5] count += 1 count = 0 for skill in totalActiveSkills: skillPts = inv.getStackQuantity(skill) if skill in self.localMods: skillPts = self.localMods[skill] (xMod, yMod) = self.ringOffset(count) xMod *= 0.90000000000000002 yMod *= 0.90000000000000002 if not skill in activeSkills: pass showIcon = skillPts > 0 freeLock = False if not Freebooter.getPaidStatus(base.localAvatar.getDoId()): if not WeaponGlobals.canFreeUse(skill): freeLock = True if self.linkedSkillIds.has_key(skill): if self.skillFrames.has_key(skill): self.skillFrames[skill].hide() skill = self.linkedSkillIds[skill] self.createFrame(skill, skillPts, amt, freeLock, showIcon) x = xMod + 0.53000000000000003 y = yMod + 0.61499999999999999 self.skillFrames[skill].setPos(x, 0, y) if showIcon and skillPts > 1: self.makeBoostDisplay(skill, skillPts - 1) if not Freebooter.getPaidStatus(base.localAvatar.getDoId()): if not WeaponGlobals.canFreeUse(skill): self.skillFrames[skill].skillButton['command'] = base.localAvatar.guiMgr.showNonPayer self.skillFrames[skill].skillButton['extraArgs'] = [ 'Restricted_Skill_' + WeaponGlobals.getSkillName(skill), 5] ammo = self.getAmmo(skill) if ammo != None and showIcon: self.skillFrames[skill].showQuantity = True self.skillFrames[skill].updateQuantity(ammo) count += 1 count = 0 for skill in totalPassiveSkills: skillPts = inv.getStackQuantity(skill) if skill in self.localMods: skillPts = self.localMods[skill] if not skill in passiveSkills: pass showIcon = skillPts > 0 freeLock = False if not Freebooter.getPaidStatus(base.localAvatar.getDoId()): if not WeaponGlobals.canFreeUse(skill): freeLock = True if self.linkedSkillIds.has_key(skill): if self.skillFrames.has_key(skill): self.skillFrames[skill].hide() skill = self.linkedSkillIds[skill] self.createFrame(skill, skillPts, amt, freeLock, showIcon) x = 0.20000000000000001 + 0.17499999999999999 * count y = 0.14999999999999999 self.skillFrames[skill].setPos(x, 0, y) if showIcon and skillPts > 1: self.makeBoostDisplay(skill, skillPts - 1) if not Freebooter.getPaidStatus(base.localAvatar.getDoId()): if not WeaponGlobals.canFreeUse(skill): self.skillFrames[skill].skillButton['command'] = base.localAvatar.guiMgr.showNonPayer self.skillFrames[skill].skillButton['extraArgs'] = [ 'Restricted_Skill_' + WeaponGlobals.getSkillName(skill), 5] count += 1 self.dataChanged = False
def showDetails(self, cell, detailsPos, detailsHeight, event = None): self.notify.debug('Item showDetails') if self.manager.heldItem and self.manager.locked and cell.isEmpty() and self.isEmpty() or not (self.itemTuple): self.notify.debug(' early exit') return None inv = localAvatar.getInventory() if not inv: return None itemId = self.getId() self.helpFrame = DirectFrame(parent = self.manager, relief = None, state = DGG.DISABLED, sortOrder = 1) self.helpFrame.setBin('gui-popup', -5) 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 basePosX = cell.getX(aspect2d) basePosZ = cell.getZ(aspect2d) cellSizeX = 0.0 cellSizeZ = 0.0 if cell: cellSizeX = cell.cellSizeX cellSizeZ = cell.cellSizeZ textScale = PiratesGuiGlobals.TextScaleMed titleScale = PiratesGuiGlobals.TextScaleTitleSmall if len(self.getName()) >= 30: titleNameScale = PiratesGuiGlobals.TextScaleLarge else: 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 rarity = ItemGlobals.getRarity(itemId) rarityText = PLocalizer.getItemRarityName(rarity) subtypeText = PLocalizer.getItemSubtypeName(ItemGlobals.getSubtype(itemId)) if rarity == ItemGlobals.CRUDE: titleColor = PiratesGuiGlobals.TextFG24 elif rarity == ItemGlobals.COMMON: titleColor = PiratesGuiGlobals.TextFG13 elif rarity == ItemGlobals.RARE: titleColor = PiratesGuiGlobals.TextFG4 elif rarity == ItemGlobals.FAMED: titleColor = PiratesGuiGlobals.TextFG5 titleLabel = DirectLabel(parent = self, relief = None, text = self.getName(), 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 = 'slant%s %s' % (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: self.realItem = loader.loadModel('models/inventory/' + model) if self.realItem: 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 itemSubtype == ItemGlobals.RAM: self.realItem.setPos(-1.5, 1.5, -0.59999999999999998) self.realItem.setHpr(70, 160, -90) else: self.realItem.setPos(0.0, 1.5, -0.059999999999999998) self.realItem.setHpr(0, 90, 0) self.realItem.reparentTo(self.portraitSceneGraph) iHeight = 0.17999999999999999 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) 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(), 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 = PiratesGuiGlobals.TextScaleLarge, 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 = textScale, text_wordwrap = halfWidth * 2.0 * (0.90000000000000002 / titleScale), text_align = TextNode.ALeft, text_fg = titleColor, text_font = PiratesGlobals.getInterfaceOutlineFont(), 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) weaponLevel = 0 weaponRepId = WeaponGlobals.getRepId(itemId) weaponRep = inv.getReputation(weaponRepId) weaponReq = ItemGlobals.getWeaponRequirement(itemId) weaponText = None 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)) else: trainingToken = EconomyGlobals.getItemTrainingReq(itemId) trainingAmt = inv.getItemQuantity(trainingToken) if trainingAmt == 0: weaponColor = PiratesGuiGlobals.TextFG6 weaponText = PLocalizer.ItemTrainingRequirement % PLocalizer.getItemTypeName(itemType) 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) panels.flattenStrong() self.helpFrame['frameSize'] = (-halfWidth, halfWidth, -(runningSize + vMargin), vMargin) totalHeight = self.helpFrame.getHeight() - 0.10000000000000001 for label in labels: label.reparentTo(self.helpFrame) if basePosX > 0.0: newPosX = basePosX - halfWidth + cellSizeX * 0.45000000000000001 else: newPosX = basePosX + halfWidth + cellSizeX * 0.45000000000000001 if basePosZ > 0.0: newPosZ = basePosZ + cellSizeZ * 0.45000000000000001 else: newPosZ = basePosZ + totalHeight - cellSizeZ * 0.75 if detailsPos: (newPosX, newPosZ) = detailsPos self.helpFrame.setPos(newPosX, 0, newPosZ)