NovaBryan/EVE_Dump
Log | Files | 📦 下载最新源码 (.zip) | Refs | README

format.py (9024B)


      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\packages\dogma\attributes\format.py
      2 import math
      3 import dogma.data as dogma_data
      4 import eveformat
      5 from carbon.common.script.util.mathCommon import FloatCloseEnough
      6 from dogma.attributes import datetime
      7 from eve.common.script.util.eveFormat import FmtDist2
      8 import evetypes
      9 from carbon.common.lib.const import SEC, HOUR
     10 from localization import GetByLabel, formatters
     11 import localization
     12 from carbon.common.script.util import format
     13 from dogma import const as dogmaConst, units
     14 from itertoolsext import Bundle
     15 from localization.formatters.timeIntervalFormatters import FormatSeconds
     16 SIZE_DICT = {1: 'UI/InfoWindow/SmallSize',
     17  2: 'UI/InfoWindow/MediumSize',
     18  3: 'UI/InfoWindow/LargeSize',
     19  4: 'UI/InfoWindow/XLargeSize'}
     20 GENDER_DICT = {1: 'UI/Common/Gender/Male',
     21  2: 'UI/Common/Gender/Unisex',
     22  3: 'UI/Common/Gender/Female'}
     23 
     24 def GetAttribute(attributeID):
     25     return dogma_data.get_attribute(attributeID)
     26 
     27 
     28 def GetDisplayName(attributeID):
     29     attribute = GetAttribute(attributeID)
     30     return localization.GetByMessageID(attribute.displayNameID) or attribute.name
     31 
     32 
     33 def GetIconID(attributeID):
     34     return GetAttribute(attributeID).iconID
     35 
     36 
     37 def GetName(attributeID):
     38     return GetAttribute(attributeID).name
     39 
     40 
     41 def FormatUnit(unitID, fmt = 'd'):
     42     if unitID in (dogmaConst.unitTime, dogmaConst.unitLength, dogmaConst.unitAttributeID):
     43         return ''
     44     if units.has_unit(unitID) and fmt == 'd':
     45         return units.get_display_name(unitID)
     46     return ''
     47 
     48 
     49 def FormatValue(value, unitID = None):
     50     if value is None:
     51         return
     52     if unitID == dogmaConst.unitTime:
     53         return format.FmtDate(long(value * SEC), 'll')
     54     if unitID == dogmaConst.unitMilliseconds:
     55         abs_seconds = math.fabs(value) / 1000.0
     56         if abs_seconds > 60:
     57             ret = formatters.FormatTimeIntervalShortWritten(abs_seconds, showTo='millisecond')
     58         else:
     59             ret = FormatSeconds(abs_seconds)
     60         sign = '-' if value < 0 else ''
     61         return u'{}{}'.format(sign, ret)
     62     if unitID == dogmaConst.unitLength:
     63         return FmtDist2(value)
     64     if unitID == dogmaConst.unitHour:
     65         return format.FmtDate(long(value * HOUR), 'ss')
     66     if unitID == dogmaConst.unitMoney:
     67         return format.FmtAmt(value)
     68     if unitID == dogmaConst.unitDatetime:
     69         return format.FmtDate(datetime.float_as_time(value))
     70     if unitID in (dogmaConst.unitTeraflops, dogmaConst.unitCapacitorUnits, dogmaConst.unitMegaWatts):
     71         return round(value, 2)
     72     if unitID == dogmaConst.unitWarpSpeed:
     73         return format.RoundDistance(value)
     74     if unitID in (dogmaConst.unitInverseAbsolutePercent, dogmaConst.unitInversedModifierPercent):
     75         value = float(round(1.0 - value, 6)) * 100
     76     elif unitID == dogmaConst.unitModifierPercent:
     77         value = round(abs(value * 100 - 100) * (-1 if value < 1.0 else 1), 3)
     78     elif unitID == dogmaConst.unitAbsolutePercent:
     79         value *= 100
     80     elif unitID == dogmaConst.unitModifierRealPercent:
     81         return localization.formatters.FormatNumeric(value, decimalPlaces=1, useGrouping=True)
     82     if type(value) is str:
     83         value = eval(value)
     84     if unitID == dogmaConst.unitMass:
     85         return localization.formatters.FormatNumeric(value, decimalPlaces=0, useGrouping=True)
     86     if unitID in (dogmaConst.unitModifierRelativePercent, dogmaConst.unitPercentage, dogmaConst.unitAbsolutePercent):
     87         if abs(value) < 10:
     88             decimalPlaces = 2
     89         else:
     90             decimalPlaces = 1
     91         value = round(value, decimalPlaces)
     92         if abs(value - int(value)) < 1e-10:
     93             decimalPlaces = 0
     94         return localization.formatters.FormatNumeric(value, decimalPlaces=decimalPlaces, useGrouping=True)
     95     if not isinstance(value, basestring) and FloatCloseEnough(round(value), value, 1e-10):
     96         return format.FmtAmt(round(value))
     97     if unitID == dogmaConst.unitAttributePoints:
     98         return round(value, 1)
     99     if unitID == dogmaConst.unitMaxVelocity:
    100         return localization.formatters.FormatNumeric(value, decimalPlaces=2, useGrouping=True)
    101     if unitID in (dogmaConst.unitHitpoints,
    102      dogmaConst.unitVolume,
    103      dogmaConst.unitInverseAbsolutePercent,
    104      dogmaConst.unitInversedModifierPercent):
    105         if value < 1:
    106             significantDigits = 2 if unitID == dogmaConst.unitHitpoints else 3
    107             decimalPlaces = int(-math.ceil(math.log10(abs(value))) + significantDigits)
    108         else:
    109             decimalPlaces = 2
    110         return localization.formatters.FormatNumeric(value, decimalPlaces=decimalPlaces, useGrouping=True)
    111     if unitID == dogmaConst.unitModifierMultiplier:
    112         return round(value, 3)
    113     return value
    114 
    115 
    116 def GetFormatAndValue(attributeType, value, overrideUnitID = None):
    117     unitID = overrideUnitID or getattr(attributeType, 'unitID', None)
    118     unit_text = FormatUnit(unitID)
    119     if unitID == dogmaConst.unitGroupID:
    120         value = evetypes.GetGroupNameByGroup(value)
    121     elif unitID == dogmaConst.unitTypeID:
    122         value = evetypes.GetName(value)
    123     elif unitID == dogmaConst.unitSizeclass:
    124         value = GetByLabel(SIZE_DICT.get(int(value)))
    125     elif unitID == dogmaConst.unitAttributeID:
    126         value = GetDisplayName(value)
    127     elif attributeType.attributeID == dogmaConst.attributeVolume:
    128         value = eveformat.volume(value)
    129     elif unitID == dogmaConst.unitModifierRealPercent:
    130         formattedValue = FormatValue(value)
    131         sign = '+'
    132         if value < 0:
    133             sign = '-'
    134         value = '%s%s%s' % (sign, formattedValue, unit_text)
    135     elif unitID == dogmaConst.unitLevel:
    136         value = GetByLabel('UI/InfoWindow/TechLevelX', numLevel=format.FmtAmt(value))
    137     elif unitID == dogmaConst.unitBoolean:
    138         if int(value) == 1:
    139             value = GetByLabel('UI/Common/True')
    140         else:
    141             value = GetByLabel('UI/Common/False')
    142     elif unitID == dogmaConst.unitSlot:
    143         value = GetByLabel('UI/InfoWindow/SlotX', slotNum=format.FmtAmt(value))
    144     elif unitID == dogmaConst.unitBonus:
    145         if value >= 0:
    146             value = '%s%s' % (unit_text, value)
    147     elif unitID == dogmaConst.unitGender:
    148         value = GetByLabel(GENDER_DICT.get(int(value)))
    149     elif unitID in (dogmaConst.unitDatetime, dogmaConst.unitMilliseconds):
    150         value = FormatValue(value, unitID)
    151     elif attributeType.attributeID == dogmaConst.attributeMaxLockedTargets:
    152         value = int(math.ceil(value))
    153     elif attributeType.dataType == dogmaConst.attributeDataTypeTypeTypeListId:
    154         typeListID = int(value)
    155         try:
    156             typeListDisplayName = evetypes.GetTypeListDisplayName(typeListID)
    157             if not typeListDisplayName:
    158                 typeListDisplayName = "[Unnamed Typelist '%s']" % typeListID
    159         except evetypes.TypeListNotFoundException:
    160             typeListDisplayName = "[Missing Typelist '%s']" % typeListID
    161 
    162         value = typeListDisplayName
    163     elif not unit_text:
    164         value = FormatValue(value, unitID)
    165     else:
    166         value = GetByLabel('UI/InfoWindow/ValueAndUnit', value=FormatValue(value, unitID), unit=unit_text)
    167     return value
    168 
    169 
    170 def GetFormattedAttributeAndValue(attributeID, value, overrideUnitID = None):
    171     attribute = GetAttribute(attributeID)
    172     if not attribute.displayWhenZero and not value:
    173         return None
    174     return GetFormattedAttributeAndValueAllowZero(attributeID, value, overrideUnitID)
    175 
    176 
    177 def GetFormattedAttributeAndValueAllowZero(attributeID, value, overrideUnitID = None):
    178     if value is None:
    179         return
    180     attribute = GetAttribute(attributeID)
    181     if not attribute.published:
    182         return
    183     iconID = getattr(attribute, 'iconID', None)
    184     infoTypeID = None
    185     if not iconID:
    186         unitID = getattr(attribute, 'unitID', None)
    187         if unitID == dogmaConst.unitTypeID:
    188             iconID = evetypes.GetIconID(value)
    189             infoTypeID = int(value)
    190         if unitID == dogmaConst.unitGroupID:
    191             iconID = evetypes.GetGroupIconIDByGroup(value)
    192         if unitID == dogmaConst.unitAttributeID:
    193             iconID = GetIconID(value)
    194     value = GetFormatAndValue(attribute, value, overrideUnitID)
    195     return Bundle(displayName=dogma_data.get_attribute_display_name(attributeID), value=value, iconID=iconID, infoTypeID=infoTypeID)
    196 
    197 
    198 PERCENT_UNITS = (dogmaConst.unitInverseAbsolutePercent, dogmaConst.unitInversedModifierPercent, dogmaConst.unitModifierPercent)
    199 
    200 def GetFormattedDiff(attributeID, diff):
    201     attribute = GetAttribute(attributeID)
    202     if not attribute.published:
    203         return
    204     if attribute.unitID in PERCENT_UNITS:
    205         diff += 1
    206     info = GetFormattedAttributeAndValueAllowZero(attributeID, diff)
    207     if info is None:
    208         return
    209     diffStr = unicode(info.value)
    210     if diffStr.startswith('+') or diffStr.startswith('-'):
    211         pass
    212     elif diff >= 0.0 and not diffStr.startswith('+'):
    213         diffStr = u'+{}'.format(diffStr)
    214     elif diff < 0.0 and not diffStr.startswith('-'):
    215         diffStr = u'-{}'.format(diffStr)
    216     return diffStr