当前位置: 首页>>代码示例>>Python>>正文


Python WeaponGlobals.getSkillIcon方法代码示例

本文整理汇总了Python中pirates.battle.WeaponGlobals.getSkillIcon方法的典型用法代码示例。如果您正苦于以下问题:Python WeaponGlobals.getSkillIcon方法的具体用法?Python WeaponGlobals.getSkillIcon怎么用?Python WeaponGlobals.getSkillIcon使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在pirates.battle.WeaponGlobals的用法示例。


在下文中一共展示了WeaponGlobals.getSkillIcon方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。

示例1: updateIcons

# 需要导入模块: from pirates.battle import WeaponGlobals [as 别名]
# 或者: from pirates.battle.WeaponGlobals import getSkillIcon [as 别名]
    def updateIcons(self):
        shipOV = base.cr.getOwnerView(self.shipId)
        if shipOV:
            shipHullInfo = ShipUpgradeGlobals.HULL_TYPES.get(shipOV.customHull)
            shipRiggingInfo = ShipUpgradeGlobals.RIGGING_TYPES.get(shipOV.customRigging)
            UpgradeIcons = loader.loadModel("models/textureCards/shipUpgradeIcons", okMissing=True)
            skillIcons = loader.loadModel("models/textureCards/skillIcons")
            if shipHullInfo and shipHullInfo["Icon"]:
                if UpgradeIcons:
                    hullImage = UpgradeIcons.find("**/%s" % shipHullInfo["Icon"])
                    self.customHullLabel["geom"] = hullImage

                self.customHullLabel["text"] = shipHullInfo["Name"] + "\n" + PLocalizer.HullLabel
                self.customHullLabel.show()
                self.setShipHp(shipOV.Hp, shipOV.maxHp)
                self.setShipCargo(shipOV.cargo, shipOV.maxCargo)
                if shipHullInfo["BroadsideType"]:
                    broadsideId = shipHullInfo["BroadsideType"]
                    ammoIconName = WeaponGlobals.getSkillIcon(broadsideId)
                    broadsideIcon = skillIcons.find("**/%s" % ammoIconName)
                    self.broadsideLimit["geom"] = broadsideIcon
                    self.broadsideLimit["geom_scale"] = 0.14999999999999999
                else:
                    broadsideId = InventoryType.CannonRoundShot
                    ammoIconName = WeaponGlobals.getSkillIcon(broadsideId)
                    broadsideIcon = skillIcons.find("**/%s" % ammoIconName)
                    self.broadsideLimit["geom"] = broadsideIcon
                    self.broadsideLimit["geom_scale"] = 0.14999999999999999

            if shipRiggingInfo and shipRiggingInfo["Icon"]:
                riggingImage = skillIcons.find("**/%s" % shipRiggingInfo["Icon"])
                self.customRiggingLabel["geom"] = riggingImage
                self.customRiggingLabel["text"] = shipRiggingInfo["Name"] + "\n" + PLocalizer.RiggingLabel
                self.customRiggingLabel.show()
开发者ID:TTGhost,项目名称:POTCOR-src,代码行数:36,代码来源:ShipPanel.py

示例2: __init__

# 需要导入模块: from pirates.battle import WeaponGlobals [as 别名]
# 或者: from pirates.battle.WeaponGlobals import getSkillIcon [as 别名]
 def __init__(self, manager, skillId, itemTuple, imageScaleFactor = 1.0, showMax = 1, update = False):
     self.skillId = skillId
     InventoryUIStackItem.InventoryUIStackItem.__init__(self, manager, itemTuple, imageScaleFactor = imageScaleFactor, showMax = showMax, update = update)
     self.initialiseoptions(InventoryUIAmmoItem)
     SkillIcons = loader.loadModel('models/textureCards/skillIcons')
     self['image'] = SkillIcons.find('**/%s' % WeaponGlobals.getSkillIcon(skillId))
     self.helpFrame = None
     self.cm = CardMaker('itemCard')
     self.cm.setFrame(-0.29999999999999999, 0.29999999999999999, -0.089999999999999997, 0.089999999999999997)
     self.buffer = None
     self.lens = PerspectiveLens()
     self.lens.setNear(0.10000000000000001)
     self.lens.setAspectRatio(0.59999999999999998 / 0.17999999999999999)
     self.realItem = None
     self.iconLabel = None
     self.itemCard = None
     self.portraitSceneGraph = NodePath('PortraitSceneGraph')
     detailGui = loader.loadModel('models/gui/gui_card_detail')
     self.bg = detailGui.find('**/color')
     self.bg.setScale(4)
     self.bg.setPos(0, 17, -6.2999999999999998)
     self.glow = detailGui.find('**/glow')
     self.glow.setScale(3)
     self.glow.setPos(0, 17, -6.2999999999999998)
     self.glow.setColor(1, 1, 1, 0.80000000000000004)
     self.setBin('gui-fixed', 1)
     self.accept('open_main_window', self.createBuffer)
     self.accept('aspectRatioChanged', self.createBuffer)
     self.accept('close_main_window', self.destroyBuffer)
     self['image_scale'] = 0.10000000000000001 * imageScaleFactor
开发者ID:XamarinDeveloper,项目名称:Pirates-Online-Source,代码行数:32,代码来源:InventoryUIAmmoItem.py

示例3: getSkillIconName

# 需要导入模块: from pirates.battle import WeaponGlobals [as 别名]
# 或者: from pirates.battle.WeaponGlobals import getSkillIcon [as 别名]
def getSkillIconName(skillId, frame):
    if skillId == InventoryType.FishingRep:
        return 'pir_t_ico_swd_broadsword_b'
    
    if skillId == InventoryType.CutlassRep:
        return 'pir_t_ico_swd_broadsword_b'
    elif skillId == InventoryType.SailingRep:
        return 'sail_full_sail'
    elif skillId == InventoryType.CannonRep:
        return 'pir_t_ico_can_single'
    elif skillId == InventoryType.WandRep:
        return 'pir_t_ico_stf_dark_a'
    elif skillId == InventoryType.MeleeRep:
        return 'pir_t_ico_swd_broadsword_b'
    elif skillId == InventoryType.DaggerRep:
        return 'pir_t_ico_knf_small'
    elif skillId == InventoryType.GrenadeRep:
        return 'pir_t_ico_bom_grenade'
    elif skillId == InventoryType.PistolRep:
        return 'pir_t_ico_gun_pistol_a'
    elif skillId == InventoryType.DollRep:
        if frame == 0:
            return 'pir_t_ico_dol_spirit_a'
        else:
            return 'voodoo_attuned'
    else:
        return WeaponGlobals.getSkillIcon(skillId)
开发者ID:Puggyblue999,项目名称:PiratesOfTheCarribeanOnline,代码行数:29,代码来源:RadialMenu.py

示例4: __init__

# 需要导入模块: from pirates.battle import WeaponGlobals [as 别名]
# 或者: from pirates.battle.WeaponGlobals import getSkillIcon [as 别名]
 def __init__(self, uid):
     SimpleEconomyItem.__init__(self, uid)
     skillId = WeaponGlobals.getSkillIdForAmmoSkillId(uid)
     if skillId:
         asset = WeaponGlobals.getSkillIcon(skillId)
         if asset:
             self.icon = self.Icons.find('**/%s' % asset)
             self.iconScale = 1.1000000000000001
             self.iconHpr = (0, 0, 45)
开发者ID:TTGhost,项目名称:POTCOR-src,代码行数:11,代码来源:SimpleStoreItem.py

示例5: createGui

# 需要导入模块: from pirates.battle import WeaponGlobals [as 别名]
# 或者: from pirates.battle.WeaponGlobals import getSkillIcon [as 别名]
 def createGui(self):
     itemId = self.data[0]
     self.itemCount += 1
     self.itemQuantity = self.quantity
     self.itemCost = self.price
     self.picture = DirectFrame(parent = self, relief = None, state = DGG.DISABLED, pos = (0.035000000000000003, 0, 0.025000000000000001))
     self.quantityLabel = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = str(self.quantity), text_fg = PiratesGuiGlobals.TextFG2, text_scale = PiratesGuiGlobals.TextScaleSmall * PLocalizer.getHeadingScale(2), text_align = TextNode.ARight, text_wordwrap = 11, pos = (0.1225, 0, 0.014999999999999999))
     if len(self.name) >= 39:
         textScale = PiratesGuiGlobals.TextScaleMicro * PLocalizer.getHeadingScale(2)
     elif len(self.name) >= 35:
         textScale = PiratesGuiGlobals.TextScaleTiny * PLocalizer.getHeadingScale(2)
     else:
         textScale = PiratesGuiGlobals.TextScaleSmall * PLocalizer.getHeadingScale(2)
     self.nameTag = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, text = self.name, text_fg = PiratesGuiGlobals.TextFG2, text_scale = textScale, text_align = TextNode.ALeft, pos = (0.13, 0, 0.014999999999999999))
     self.costText = DirectLabel(parent = self, relief = None, state = DGG.DISABLED, image = InventoryListItem.coinImage, image_scale = 0.12, image_pos = Vec3(-0.0050000000000000001, 0, 0.012500000000000001), text = str(self.price), text_fg = PiratesGuiGlobals.TextFG2, text_scale = PiratesGuiGlobals.TextScaleSmall, text_align = TextNode.ARight, text_wordwrap = 11, text_pos = (-0.029999999999999999, 0, 0), pos = (self.width - 0.035000000000000003, 0, 0.014999999999999999), text_font = PiratesGlobals.getInterfaceFont())
     itemClass = EconomyGlobals.getItemCategory(itemId)
     itemType = EconomyGlobals.getItemType(itemId)
     if itemType == ItemType.FISHING_ROD or itemType == ItemType.FISHING_LURE:
         asset = EconomyGlobals.getItemIcons(itemId)
         if asset:
             self.picture['geom'] = PurchaseListItem.fishingIcons.find('**/%s*' % asset)
             self.picture['geom_scale'] = 0.040000000000000001
             self.picture['geom_pos'] = (0, 0, 0)
         
     elif itemClass == ItemType.WEAPON or itemClass == ItemType.POUCH:
         asset = EconomyGlobals.getItemIcons(itemId)
         if asset:
             self.picture['geom'] = InventoryListItem.weaponIcons.find('**/%s*' % asset)
             self.picture['geom_scale'] = 0.040000000000000001
             self.picture['geom_pos'] = (0, 0, 0)
         
     elif itemClass == ItemType.CONSUMABLE:
         asset = EconomyGlobals.getItemIcons(itemId)
         if asset:
             self.picture['geom'] = InventoryListItem.skillIcons.find('**/%s*' % asset)
             self.picture['geom_scale'] = 0.040000000000000001
             self.picture['geom_pos'] = (0, 0, 0)
         
     
     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'] = InventoryListItem.skillIcons.find('**/%s' % asset)
                     self.picture['geom_scale'] = 0.059999999999999998
                     self.picture['geom_pos'] = (0, 0, 0)
                 
             
         elif InventoryType.SmallBottle <= itemId and itemId <= InventoryType.LargeBottle:
             self.picture['geom'] = self.topGui.find('**/main_gui_ship_bottle')
             self.picture['geom_scale'] = 0.10000000000000001
             self.picture['geom_pos'] = (0, 0, 0)
         
     self.flattenStrong()
开发者ID:TTGhost,项目名称:POTCOR-src,代码行数:58,代码来源:PurchaseListItem.py

示例6: getGeomParams

# 需要导入模块: from pirates.battle import WeaponGlobals [as 别名]
# 或者: from pirates.battle.WeaponGlobals import getSkillIcon [as 别名]
 def getGeomParams(itemId):
     geomParams = { }
     itemType = EconomyGlobals.getItemType(itemId)
     if itemType <= ItemType.WAND or itemType == ItemType.POTION:
         if itemType == ItemType.POTION:
             geomParams['geom'] = InventoryItemGui.skillIcons.find('**/%s' % ItemGlobals.getIcon(itemId))
         else:
             itemType = ItemGlobals.getType(itemId)
             if ItemGlobals.getIcon(itemId):
                 geomParams['geom'] = InventoryItemGui.weaponIcons.find('**/%s' % ItemGlobals.getIcon(itemId))
             
         geomParams['geom_scale'] = 0.11
         geomParams['geom_pos'] = (0.080000000000000002, 0, 0.068000000000000005)
     else:
         itemClass = EconomyGlobals.getItemCategory(itemId)
         itemType = EconomyGlobals.getItemType(itemId)
         if itemType == ItemType.FISHING_ROD or itemType == ItemType.FISHING_LURE:
             asset = EconomyGlobals.getItemIcons(itemId)
             if asset:
                 geomParams['geom'] = InventoryItemGui.fishingIcons.find('**/%s*' % asset)
                 geomParams['geom_scale'] = 0.11
                 geomParams['geom_pos'] = (0.080000000000000002, 0, 0.068000000000000005)
             
         elif itemClass == ItemType.WEAPON and itemClass == ItemType.POUCH or itemClass == ItemType.AMMO:
             asset = EconomyGlobals.getItemIcons(itemId)
             if asset:
                 geomParams['geom'] = InventoryItemGui.weaponIcons.find('**/%s*' % asset)
                 geomParams['geom_scale'] = 0.11
                 geomParams['geom_pos'] = (0.080000000000000002, 0, 0.068000000000000005)
             
         elif itemClass == ItemType.CONSUMABLE:
             asset = EconomyGlobals.getItemIcons(itemId)
             if asset:
                 geomParams['geom'] = InventoryItemGui.skillIcons.find('**/%s*' % asset)
                 geomParams['geom_scale'] = 0.11
                 geomParams['geom_pos'] = (0.080000000000000002, 0, 0.068000000000000005)
             
         
     if not InventoryType.begin_WeaponCannonAmmo <= itemId or itemId <= InventoryType.end_WeaponCannonAmmo:
         if (InventoryType.begin_WeaponPistolAmmo <= itemId or itemId <= InventoryType.end_WeaponGrenadeAmmo or InventoryType.begin_WeaponDaggerAmmo <= itemId) and itemId <= InventoryType.end_WeaponDaggerAmmo:
             skillId = WeaponGlobals.getSkillIdForAmmoSkillId(itemId)
             if skillId:
                 asset = WeaponGlobals.getSkillIcon(skillId)
                 if asset:
                     geomParams['geom'] = InventoryListItem.skillIcons.find('**/%s' % asset)
                     geomParams['geom_scale'] = 0.14999999999999999
                     geomParams['geom_pos'] = (0.069000000000000006, 0, 0.069000000000000006)
                 
             
         elif InventoryType.SmallBottle <= itemId and itemId <= InventoryType.LargeBottle:
             geomParams['geom'] = InventoryListItem.topGui.find('**/main_gui_ship_bottle')
             geomParams['geom_scale'] = 0.10000000000000001
             geomParams['geom_pos'] = (0.069000000000000006, 0, 0.069000000000000006)
         
     return geomParams
开发者ID:TTGhost,项目名称:POTCOR-src,代码行数:57,代码来源:InventoryItemGui.py

示例7: updateSkillId

# 需要导入模块: from pirates.battle import WeaponGlobals [as 别名]
# 或者: from pirates.battle.WeaponGlobals import getSkillIcon [as 别名]
    def updateSkillId(self, skillId):
        self.skillId = skillId
        if self.skillButton:
            if self.quantityLabel:
                self.quantityLabel.detachNode()

            self.skillButton.destroy()

        if self.showQuantity and not (self.quantity):
            geomColor = Vec4(0.5, 0.5, 0.5, 1.0)
        else:
            geomColor = Vec4(1.0, 1.0, 1.0, 1.0)
        if self.showIcon:
            asset = WeaponGlobals.getSkillIcon(skillId)
            if hasattr(self, '_skillIconName'):
                asset = self._skillIconName

            geom = SkillButton.SkillIcons.find('**/%s' % asset)
            if geom.isEmpty():
                geom = SkillButton.SkillIcons.find('**/base')

            repId = WeaponGlobals.getSkillReputationCategoryId(self.skillId)
            geom_scale = getGeomScale(repId, skillId)
            image_color = (1, 1, 1, 1)
        else:
            geom = (None,)
            geom_scale = 0.12
            image_color = (0.5, 0.5, 0.5, 0.5)
        specialIconId = 0
        if self.isBreakAttackSkill:
            specialIconId = 1
        elif self.isDefenseSkill:
            specialIconId = 2
        elif skillId == ItemGlobals.getSpecialAttack(localAvatar.currentWeaponId):
            specialIconId = 3

        if specialIconId:
            something = SkillButton.SpecialIcons[specialIconId][0]
            if self.skillRing:
                self.skillRing.setupFace(something)

            self['image'] = None
        elif self.skillRing:
            self.skillRing.setupFace()

        if self.showRing:
            image = None
        else:
            image = SkillButton.Image
        self.skillButton = DirectButton(parent = self, relief = None, pos = (0, 0, 0), text = ('', '', self.name), text_align = TextNode.ACenter, text_shadow = Vec4(0, 0, 0, 1), text_scale = 0.040000000000000001, text_fg = Vec4(1, 1, 1, 1), text_pos = (0.0, 0.089999999999999997), image = image, image_scale = 0.14999999999999999, image_color = image_color, geom = geom, geom_scale = geom_scale, geom_color = geomColor, command = self.callback, sortOrder = 50, extraArgs = [
            skillId])
        self.skillButton.bind(DGG.ENTER, self.showDetails)
        self.skillButton.bind(DGG.EXIT, self.hideDetails)
        if self.quantityLabel and not self.quantityLabel.isEmpty():
            self.quantityLabel.reparentTo(self.skillButton)
开发者ID:Puggyblue999,项目名称:PiratesOfTheCarribeanOnline,代码行数:57,代码来源:SkillButton.py

示例8: isSkillValid

# 需要导入模块: from pirates.battle import WeaponGlobals [as 别名]
# 或者: from pirates.battle.WeaponGlobals import getSkillIcon [as 别名]
 def isSkillValid(self, skillId):
     ammoId = WeaponGlobals.getSkillAmmoInventoryId(skillId)
     ammoName = PLocalizer.InventoryTypeNames.get(ammoId)
     ammoDescription = PLocalizer.WeaponDescriptions.get(ammoId)
     ammoIconName = WeaponGlobals.getSkillIcon(skillId)
     ammoIcon = self.SkillIcons.find("**/%s" % ammoIconName)
     skillRepId = WeaponGlobals.getSkillReputationCategoryId(skillId)
     stackLimit = localAvatar.getInventory().getStackLimit(ammoId)
     if ammoName and ammoDescription and ammoIcon and stackLimit:
         return 1
     else:
         return 0
开发者ID:Puggyblue999,项目名称:PiratesOfTheCarribeanOnline,代码行数:14,代码来源:InventoryUIStackContainer.py

示例9: isSkillValid

# 需要导入模块: from pirates.battle import WeaponGlobals [as 别名]
# 或者: from pirates.battle.WeaponGlobals import getSkillIcon [as 别名]
 def isSkillValid(self, skillId):
     return WeaponGlobals.getSkillAmmoInventoryId(skillId) in InventoryGlobals.AmmoInGUI
     SkillIcons = loader.loadModel('models/textureCards/skillIcons')
     ammoId = WeaponGlobals.getSkillAmmoInventoryId(skillId)
     ammoName = PLocalizer.InventoryTypeNames.get(ammoId)
     ammoDescription = PLocalizer.WeaponDescriptions.get(ammoId)
     ammoIconName = WeaponGlobals.getSkillIcon(skillId)
     ammoIcon = SkillIcons.find('**/%s' % ammoIconName)
     skillRepId = WeaponGlobals.getSkillReputationCategoryId(skillId)
     if ammoName and ammoDescription and ammoIcon and skillRepId:
         return 1
     else:
         return 0
开发者ID:XamarinDeveloper,项目名称:Pirates-Online-Source,代码行数:15,代码来源:InventoryUIAmmoContainer.py

示例10: __init__

# 需要导入模块: from pirates.battle import WeaponGlobals [as 别名]
# 或者: from pirates.battle.WeaponGlobals import getSkillIcon [as 别名]
    def __init__(self, shipPage, shipId, **kwargs):
        self.shipPage = shipPage
        self.emptyBottle = True
        self.setShipId(shipId)
        self.timer = None
        self.lBroadsideLimit = 0
        self.rBroadsideLimit = 0
        kwargs.setdefault("relief", None)
        kwargs.setdefault("frameSize", (0, self.Width, 0, self.Height))
        DirectFrame.__init__(self, **None)
        self.initialiseoptions(ShipPanel)
        gui = loader.loadModel("models/gui/toplevel_gui")
        inventoryGui = loader.loadModel("models/gui/gui_icons_inventory")
        chestIcon = inventoryGui.find("**/pir_t_ico_trs_chest_01*")
        cannonIcon = gui.find("**/topgui_icon_ship_cannon_single")
        skillIcons = loader.loadModel("models/textureCards/skillIcons")
        broadsideId = InventoryType.CannonRoundShot
        ammoIconName = WeaponGlobals.getSkillIcon(broadsideId)
        broadsideIcon = skillIcons.find("**/%s" % ammoIconName)
        crewIcon = (gui.find("**/pir_t_gui_gen_friends_pirates"),)
        self.bottleFrame = ShipFrameBottle(
            parent=self,
            shipId=shipId,
            relief=None,
            state=DGG.DISABLED,
            pos=(0.074999999999999997, 0, 0.75),
            scale=0.83499999999999996,
        )
        gui = loader.loadModel("models/gui/gui_ship_window")
        bottleImage = gui.find("**/ship_bottle")
        self.shipBottle = DirectLabel(
            parent=self.bottleFrame,
            relief=None,
            state=DGG.DISABLED,
            geom=bottleImage,
            geom_scale=0.29999999999999999,
            geom_pos=(0, 0, 0),
            pos=(0.5, 0, -0.0),
        )
        self.nameLabel = DirectLabel(
            parent=self,
            relief=None,
            state=DGG.DISABLED,
            text=PLocalizer.makeHeadingString(PLocalizer.EmptyBottle, 2),
            text_fg=PiratesGuiGlobals.TextFG1,
            text_scale=PiratesGuiGlobals.TextScaleTitleSmall,
            text_align=TextNode.ACenter,
            text_shadow=(0, 0, 0, 1),
            text_wordwrap=30,
            textMayChange=1,
            text_font=PiratesGlobals.getPirateFont(),
            pos=(0.55000000000000004, 0, 1.22),
        )
        self.classLabel = DirectLabel(
            parent=self,
            relief=None,
            state=DGG.DISABLED,
            text=PLocalizer.makeHeadingString(PLocalizer.EmptyBottleDesc, 1),
            text_scale=PiratesGuiGlobals.TextScaleMed,
            text_align=TextNode.ACenter,
            text_fg=PiratesGuiGlobals.TextFG2,
            text_shadow=(0, 0, 0, 1),
            text_wordwrap=30,
            textMayChange=1,
            text_font=PiratesGlobals.getInterfaceFont(),
            pos=(0.55000000000000004, 0, 1.1799999999999999),
        )
        self.timer = PiratesTimer.PiratesTimer(
            showMinutes=True, mode=None, titleText="", titleFg="", infoText="", cancelText="", cancelCallback=None
        )
        self.timer.setFontColor(PiratesGuiGlobals.TextFG2)
        self.timer.reparentTo(self)
        self.timer.setPos(0.45000000000000001, 0, 0.93999999999999995)
        self.timer.setScale(0.59999999999999998)
        self.timer.stash()
        self.hpMeter = DirectWaitBar(
            parent=self,
            relief=DGG.RAISED,
            state=DGG.DISABLED,
            range=1,
            value=0,
            frameColor=(0.0, 0.0, 0.0, 0.0),
            barColor=(0.10000000000000001, 0.69999999999999996, 0.10000000000000001, 1),
            frameSize=(0, 0.31, 0, 0.018599999999999998),
            text="",
            text_align=TextNode.ARight,
            text_scale=0.029999999999999999,
            text_fg=(1, 1, 1, 1),
            text_shadow=(0, 0, 0, 1),
            text_pos=(0.29999999999999999, 0.029999999999999999),
            pos=(0.55000000000000004, 0.0, 0.45000000000000001),
            scale=1.2,
        )
        hpLabel = DirectLabel(
            parent=self.hpMeter,
            relief=None,
            state=DGG.DISABLED,
            text=PLocalizer.HP,
            text_scale=0.029999999999999999,
            text_align=TextNode.ALeft,
#.........这里部分代码省略.........
开发者ID:TTGhost,项目名称:POTCOR-src,代码行数:103,代码来源:ShipPanel.py

示例11: _createIface

# 需要导入模块: from pirates.battle import WeaponGlobals [as 别名]
# 或者: from pirates.battle.WeaponGlobals import getSkillIcon [as 别名]
 def _createIface(self):
     self.descText = DirectLabel(parent = self, relief = None, text = self.item.get('Text'), text_align = TextNode.ALeft, text_scale = 0.050000000000000003, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 1, pos = (0.02, 0, self.height / 2), text_font = PiratesGlobals.getInterfaceOutlineFont())
     self.valueText = DirectLabel(parent = self, relief = None, text = str(self.item.get('Value1')), text_align = TextNode.ALeft, text_scale = 0.050000000000000003, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 1, pos = (self.width * 0.65000000000000002, 0, self.height / 2), text_font = PiratesGlobals.getInterfaceOutlineFont())
     if self.item.get('Type') == 'Title':
         self.descText['text_scale'] = 0.055
         self.descText['text_fg'] = PiratesGuiGlobals.TextFG1
         self.descText['text_font'] = PiratesGlobals.getInterfaceOutlineFont()
         self.valueText['text_scale'] = 0.044999999999999998
         self.valueText['text_font'] = PiratesGlobals.getInterfaceOutlineFont()
         if self.item.has_key('Value2'):
             self.valueText2 = DirectLabel(parent = self, relief = None, text = str(self.item.get('Value2')), text_align = TextNode.ALeft, text_scale = 0.050000000000000003, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 1, pos = (self.width * 0.80000000000000004, 0, self.height / 2), text_font = PiratesGlobals.getInterfaceOutlineFont())
         
         if self.valueText2:
             self.valueText2['text_scale'] = 0.044999999999999998
             self.valueText2['text_font'] = PiratesGlobals.getInterfaceOutlineFont()
         
     elif self.item.get('Type') == 'Entry':
         self.descText['text_pos'] = (self.width * 0.059999999999999998, 0, 0)
         if self.item.has_key('Value2'):
             self.valueText2 = DirectLabel(parent = self, relief = None, text = str(self.item.get('Value2')), text_align = TextNode.ALeft, text_scale = 0.050000000000000003, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 1, pos = (self.width * 0.80000000000000004, 0, self.height / 2), text_font = PiratesGlobals.getInterfaceOutlineFont())
         
     elif self.item.get('Type') == 'Space':
         self.descText['text_scale'] = 0.02
         self.descText['text'] = ' '
         self.valueText['text_scale'] = 0.02
         self.valueText['text'] = ' '
     elif self.item.get('Type') == 'Button':
         self.descText['text_pos'] = (self.width * 0.059999999999999998, 0, 0)
         self.valueText['text'] = ' '
         self.button = DirectButton(parent = self, relief = DGG.RIDGE, text = self.item.get('Text'), text_align = TextNode.ALeft, text_scale = PiratesGuiGlobals.TextScaleLarge, text_fg = PiratesGuiGlobals.TextFG1, text_shadow = PiratesGuiGlobals.TextShadow, frameColor = PiratesGuiGlobals.ButtonColor1, command = self.item.get('Value2'), pos = (self.width * 0.65000000000000002, 0, self.height / 2), borderWidth = (0.01, 0.01), pad = (0.0050000000000000001, 0.0050000000000000001), textMayChange = 1)
         if self.item.get('State') == 'off':
             self.button['state'] = DGG.DISABLED
             self.button['text_fg'] = PiratesGuiGlobals.TextFG3
         elif self.item.get('State') == 'oneShot':
             self.button.bind(DGG.B1RELEASE, self.disableButton)
         
     elif self.item.get('Type') == 'Cargo':
         itemId = self.item.get('Value1')
         iconId = EconomyGlobals.getCargoCategory(itemId)
         if not iconId:
             self.notify.error('Invalid Item in Cargo! item: %s' % (self.item,))
         
         icon = self.icons.get(iconId)
         self.descText['geom'] = self.getCargoIcon(icon[0])
         self.descText['geom_scale'] = 0.089999999999999997 * self.height * 10
         self.descText['geom_pos'] = (0.050000000000000003, 0, 0.01)
         self.descText['text_pos'] = (0.23999999999999999, 0, 0)
         self.descText['text'] = icon[1]
         self.descText['text_fg'] = PiratesGuiGlobals.TextFG2
         self.descText['text_font'] = PiratesGlobals.getInterfaceOutlineFont()
         self.descText['text_scale'] = 0.050000000000000003 * self.height * 10
         self.descText.setTransparency(1)
         self.valueText['text'] = PLocalizer.UnknownGoldValue
         self.valueText['text_font'] = PiratesGlobals.getInterfaceOutlineFont()
         self.valueText['text_scale'] = 0.050000000000000003 * self.height * 10
         icon = self.icons.get(ItemId.CARGO_CRATE)
         self.descText2 = DirectLabel(parent = self, relief = None, text = '?', text_align = TextNode.ACenter, text_scale = 0.050000000000000003 * self.height * 10, text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 1, pos = (0.080000000000000002, 0, self.height / 2), geom = self.getCargoIcon(icon[0]), geom_scale = 0.089999999999999997 * self.height * 10, geom_pos = (0.10000000000000001, 0, 0.01), text_pos = (0.10000000000000001, 0, 0), geom_color = Vec4(0, 0, 0, 1), text_font = PiratesGlobals.getInterfaceOutlineFont())
     elif self.item.get('Type') == 'Gold':
         amount = self.item.get('Value2')
         itemName = PLocalizer.LootGold % amount
         self.descText['geom'] = self.getGoldIcon()
         self.descText['geom_scale'] = 0.14999999999999999 * self.height * 10
         self.descText['geom_pos'] = (0.050000000000000003, 0, 0.01)
         self.descText['text_pos'] = (0.23999999999999999, 0, 0)
         self.descText['text'] = itemName
         self.descText['text_fg'] = PiratesGuiGlobals.TextFG2
         self.descText['text_font'] = PiratesGlobals.getInterfaceOutlineFont()
         self.descText['text_scale'] = 0.050000000000000003 * self.height * 10
         self.descText.setTransparency(1)
         self.valueText['text'] = ' '
     elif self.item.get('Type') == 'Weapon':
         itemId = self.item.get('Value1')
         itemName = PLocalizer.InventoryTypeNames.get(itemId)
         iconName = EconomyGlobals.getItemIcons(itemId)
         self.descText['geom'] = self.getWeaponIcon(iconName)
         self.descText['geom_scale'] = 0.089999999999999997 * self.height * 10
         self.descText['geom_pos'] = (0.050000000000000003, 0, 0.01)
         self.descText['text_pos'] = (0.23999999999999999, 0, 0)
         self.descText['text'] = itemName
         self.descText['text_fg'] = PiratesGuiGlobals.TextFG2
         self.descText['text_font'] = PiratesGlobals.getInterfaceOutlineFont()
         self.descText['text_scale'] = 0.050000000000000003 * self.height * 10
         self.descText.setTransparency(1)
         self.valueText['text'] = ' '
     elif self.item.get('Type') == 'Ammo':
         itemId = self.item.get('Value1')
         amount = self.item.get('Value2')
         itemName = '%s %s' % (amount, PLocalizer.InventoryTypeNames.get(itemId))
         iconName = WeaponGlobals.getSkillIcon(itemId)
         self.descText['geom'] = self.getAmmoIcon(iconName)
         self.descText['geom_scale'] = 0.089999999999999997 * self.height * 10
         self.descText['geom_pos'] = (0.050000000000000003, 0, 0.01)
         self.descText['text_pos'] = (0.23999999999999999, 0, 0)
         self.descText['text'] = itemName
         self.descText['text_fg'] = PiratesGuiGlobals.TextFG2
         self.descText['text_font'] = PiratesGlobals.getInterfaceOutlineFont()
         self.descText['text_scale'] = 0.050000000000000003 * self.height * 10
         self.descText.setTransparency(1)
         self.valueText['text'] = ' '
开发者ID:Puggyblue999,项目名称:PiratesOfTheCarribeanOnline,代码行数:101,代码来源:ScoreboardItemGui.py

示例12: createGui

# 需要导入模块: from pirates.battle import WeaponGlobals [as 别名]
# 或者: from pirates.battle.WeaponGlobals import getSkillIcon [as 别名]
 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()
开发者ID:TTGhost,项目名称:POTCOR-src,代码行数:63,代码来源:SongItemGui.py

示例13: createHelpbox

# 需要导入模块: from pirates.battle import WeaponGlobals [as 别名]
# 或者: from pirates.battle.WeaponGlobals import getSkillIcon [as 别名]

#.........这里部分代码省略.........
                     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:
开发者ID:TTGhost,项目名称:POTCOR-src,代码行数:70,代码来源:InventoryItemGui.py

示例14: showDetails

# 需要导入模块: from pirates.battle import WeaponGlobals [as 别名]
# 或者: from pirates.battle.WeaponGlobals import getSkillIcon [as 别名]
 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
     
     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*')
     SkillIcons = loader.loadModel('models/textureCards/skillIcons')
     border = 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.TextFG24
     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 = PLocalizer.InventoryItemClassNames.get(EconomyGlobals.getItemType(self.getId()), ''), 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)
     self.iconLabel = DirectLabel(parent = self.portraitSceneGraph, relief = None, image = SkillIcons.find('**/%s' % WeaponGlobals.getSkillIcon(self.getSkillId())), pos = (0.0, 2.5, 0.0))
     iHeight = 0.17999999999999999
     self.createBuffer()
     self.itemCard.setZ(runningVertPosition - 0.059999999999999998)
     runningVertPosition -= iHeight
     runningSize += iHeight
     labels.append(self.itemCard)
     description = PLocalizer.WeaponDescriptions.get(self.getId())
     if not description:
         description = PLocalizer.WeaponDescriptions.get(self.getSkillId())
     
     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)
     
     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
     if detailsHeight:
         currentHeight = -detailsHeight
     
     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)
#.........这里部分代码省略.........
开发者ID:XamarinDeveloper,项目名称:Pirates-Online-Source,代码行数:103,代码来源:InventoryUIAmmoItem.py

示例15: showDetails

# 需要导入模块: from pirates.battle import WeaponGlobals [as 别名]
# 或者: from pirates.battle.WeaponGlobals import getSkillIcon [as 别名]
    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))
#.........这里部分代码省略.........
开发者ID:Puggyblue999,项目名称:PiratesOfTheCarribeanOnline,代码行数:103,代码来源:InventoryUICharmItem.py


注:本文中的pirates.battle.WeaponGlobals.getSkillIcon方法示例由纯净天空整理自Github/MSDocs等开源代码及文档管理平台,相关代码片段筛选自各路编程大神贡献的开源项目,源码版权归原作者所有,传播和使用请参考对应项目的License;未经允许,请勿转载。