Jump to content
Korean Random
Sign in to follow this  
DKRUBEN

Grand colors in python how?

Recommended Posts

Good to all ... I'm here, a little lost, if possible, was a little help in creating a color reader, and the value attributed to it. below is a small step of the intended ...  :thx:

 

class ConfigInterface(DKmodsCore.DKmodsConfigInterface):

    def init(self):
        self.version = '1.0.0 (10/03/2019)'
        self.version_id = 100
        self.data = {
            'colors': {
                'WN8': [
                    {'value': 450,    'color': '#FE0E00'},
                    {'value': 984,    'color': '#FE7903'},
                    {'value': 1577,   'color': '#F8F400'},
                    {'value': 2368,   'color': '#60FF00'},
                    {'value': 3182,   'color': '#02C9B3'},
                    {'value': 999999, 'color': '#D042F3'}
                ],
                'EFF': [
                    {'value': 604,    'color': '#FE0E00'},
                    {'value': 884,    'color': '#FE7903'},
                    {'value': 1187,   'color': '#F8F400'},
                    {'value': 1547,   'color': '#60FF00'},
                    {'value': 1872,   'color': '#02C9B3'},
                    {'value': 999999, 'color': '#D042F3'}
                ],
                'x': [
                    {'value': 16.5, 'color': '#FE0E00'},
                    {'value': 33.5, 'color': '#FE7903'},
                    {'value': 52.5, 'color': '#F8F400'},
                    {'value': 75.5, 'color': '#60FF00'},
                    {'value': 92.5, 'color': '#02C9B3'},
                    {'value': 999,  'color': '#D042F3'}
                ],
            }
        }

        self.i18n = {
            'version': self.version_id,
            'UI_description': self.ID,
            #'UI_setting_**_text': '',
            #'UI_setting_**_tooltip': '',
            }

        super(ConfigInterface, self).init()


g__cfg = ConfigInterface()
###

//---------------------------------------------------------//
#####XVM SOERCE
def get(path, default=None):
    if config_data is None or not path or path == '':
        return default
    try:
        path = path.replace('.', '/')
        if path[0] == '/':
            path = path[1:]
        c = config_data
        for x in path.split('/'):
            if not isinstance(c, collections.Mapping) or x not in c:
                return default
            c = c[x]
        return c
    except Exception:
        err(traceback.format_exc())
    return default

                 
def getDynamicColorValue(type, value, prefix='#'):
    if value is None or math.isnan(value):
        return ''

    cfg = config.get('colors/%s' % type)
    if not cfg:
        return ''

    color = next((int(x['color'], 0) for x in cfg if value <= float(x['value'])), 0xFFFFFF)

    return "{0}{1:06x}".format(prefix, color)

 

Share this post


Link to post

Short link
Share on other sites
# -*- coding: utf-8 -*-
import traceback
import BigWorld
import GUI
import math
from constants import ARENA_BONUS_TYPE
from Avatar import PlayerAvatar
from items import vehicles
from math import log as mathLog
from json import dumps
from re import sub
from gui.Scaleform.daapi.view.battle_results_window import BattleResultsWindow
from gui.Scaleform.daapi.view.battle.shared.ribbons_panel import BattleRibbonsPanel
from gui.Scaleform.daapi.view.battle.shared.ribbons_aggregator import RibbonsAggregator
from gui.Scaleform.genConsts.BATTLE_EFFICIENCY_TYPES import BATTLE_EFFICIENCY_TYPES
from gui.battle_control.battle_constants import PERSONAL_EFFICIENCY_TYPE
from gui.Scaleform.daapi.view.battle.shared.damage_log_panel import DamageLogPanel
from debug_utils import LOG_CURRENT_EXCEPTION
from helpers import dependency
from gui import InputHandler, g_guiResetters
from skeletons.account_helpers.settings_core import ISettingsCore
#
import DKmodsCore
from DKmodsCore.flash import COMPONENT_TYPE, COMPONENT_EVENT, COMPONENT_ALIGN
#


class ConfigInterface(DKmodsCore.DKmodsConfigInterface):

    def init(self):
        self.ID = 'BattleEfficiency'
        self.version = '1.0.0 (10/03/2019)'
        self.version_id = 100
        self.data = {
            'version': self.version_id,
            'enabled': True,
            'sizePercent': 100,
            'shadow': True,
            'font': '$IMELanguageBar',
            'background': False,
            'backgroundImage': '../maps/bg.png',
            'backgroundData': {'alpha': 1.0},
            'panelSize': {
                'widthNormal': 100,
                'heightNormal': 20
            },
            'panel': {
                'x': 124,
                'y': 38,
                'width': 100,
                'height': 20,
                'drag': True,
                'border': True,
                'alignX': COMPONENT_ALIGN.LEFT,
                'alignY': COMPONENT_ALIGN.TOP
            },
            'shadowText': {
                "distance": 0,
                "angle": 0,
                "color": "0x000000",
                "alpha": 0,
                "blurX": 0,
                "blurY": 0,
                "strength": 0,
                "quality": 0
            },
            'format': "<font size='15'>WN8: <font color='{{WN8Color}}'>{{WN8}}</font> EFF: <font color='{{EFFColor}}'>{{EFF}}</font></font>",
            'battleResultsWindow': {
                'enabled': False,
                'textFormat': "<textFormat tabstops='[195]'>{{mapName}} - {{battleType}}<tab>WN8: <font color='{{c:WN8}}'>{{WN8}}</font>, EFF: <font color='{{c:EFF}}'>{{EFF}}</font></textFormat>"
            },
            'colors': {
                'WN8': [
                    {'value': 450,    'color': '0xFE0E00'},
                    {'value': 984,    'color': '0xFE7903'},
                    {'value': 1577,   'color': '0xF8F400'},
                    {'value': 2368,   'color': '0x60FF00'},
                    {'value': 3182,   'color': '0x02C9B3'},
                    {'value': 999999, 'color': '0xD042F3'}
                ],
                'EFF': [
                    {'value': 604,    'color': '0xFE0E00'},
                    {'value': 884,    'color': '0xFE7903'},
                    {'value': 1187,   'color': '0xF8F400'},
                    {'value': 1547,   'color': '0x60FF00'},
                    {'value': 1872,   'color': '0x02C9B3'},
                    {'value': 999999, 'color': '0xD042F3'}
                ],
                'X': [
                    {'value': 16.5, 'color': '0xFE0E00'},
                    {'value': 33.5, 'color': '0xFE7903'},
                    {'value': 52.5, 'color': '0xF8F400'},
                    {'value': 75.5, 'color': '0x60FF00'},
                    {'value': 92.5, 'color': '0x02C9B3'},
                    {'value': 999,  'color': '0xD042F3'}
                ],
                'DIFFExpDmg': {
                    'bad': '#FE0E00',
                    'good': '#x60FF00'
                }
            }
        }

        self.i18n = {
            'version': self.version_id,
            'UI_description': self.ID,
            'UI_message_enabled': 'Enable|Disable Options.',
            'UI_setting_sizePercent_text': 'Size Percent',
            'UI_setting_sizePercent_tooltip': '',
            'UI_setting_shadow_text': 'Enabled|Disabled Shadow Texr',
            'UI_setting_shadow_tooltip': '',
            'UI_setting_background_text': 'Enabled|Disabled Backgraund',
            'UI_setting_background_tooltip': ''
            }

        super(ConfigInterface, self).init()

    def updateMod(self):
        pass

    def createTemplate(self):
        return {
            'modDisplayName': self.i18n['UI_description'],
            'settingsVersion': self.version_id,
            'enabled': self.data['enabled'],
            'column1': [
                self.tb.createStepper('sizePercent', 10, 100, 10, False),
                self.tb.createControl('shadow')
            ],
            'column2': [
                self.tb.createControl('background')
            ]}

    def registerSettings(self):
        pass


g_cfg = ConfigInterface()
analytics = DKmodsCore.Analytics(g_cfg.ID, g_cfg.version, 'UA-121940539-1')
###


def getDynamicColorValue(type, value, prefix='#'):
    if value is None or math.isnan(value):
        return ''
    else:
        cfg = g_cfg.data['colors'][type]
        if not cfg:
            return ''
        color = next((int(x['color'], 0) for x in cfg if value <= float(x['value'])), 16777215)
        return '{0}{1:06x}'.format(prefix, color)


ALIAS = 'BattleEfficiency'
MACROS = ['{{WN8}}', '{{EFF}}', '{{XTE}}', '{{DIFFExpDmg}}', '{{WN8Color}}', '{{EFFColor}}', '{{XTEColor}}',
          '{{DIFFExpDmgColor}}']
DATA_IDS = {'damageDealt': 3, 'spotted': 11, 'kills': 12, 'defAndCap': {'vehWStun': 17, 'vehWOStun': 14}}
config_data = None


class efficiencyCalculator(object):

    avgTier = 5

    def __init__(self):
        self.tankExpd = {}
        self.vehCD = None
        self.vInfoOK = False

    def reset(self):
        self.__init__()

    def setAvgTier(self):
        plName = BigWorld.player().name
        if DKmodsCore._stat.resp and (plName in DKmodsCore._stat.resp.get('players', {})):
            plStats = DKmodsCore._stat.resp['players'].get(plName)
            self.avgTier = plStats.get('avglvl', 5)

    def registerVInfoData(self, vehCD):
        self.vehCD = vehCD
        vInfoData = DKmodsCore.getVehicleInfoData(vehCD)

        for item in ['wn8expDamage', 'wn8expSpot', 'wn8expFrag', 'wn8expDef', 'wn8expWinRate']:
            self.tankExpd[item] = vInfoData.get(item, None)

        self.vInfoOK = None not in self.tankExpd.values()
        if self.vInfoOK:
            self.setAvgTier()

    def calc(self, damage, spotted, frags, defence, capture, win):
        if self.vInfoOK:
            rDAMAGE = float(damage) / float(self.tankExpd['wn8expDamage'])
            rSPOT = float(spotted) / float(self.tankExpd['wn8expSpot'])
            rFRAG = float(frags) / float(self.tankExpd['wn8expFrag'])
            rDEF = float(defence) / float(self.tankExpd['wn8expDef'])
            rWIN = (100.0 if win == 'win' else 0) / float(self.tankExpd['wn8expWinRate'])

            rDAMAGEc = max(0.0, (rDAMAGE - 0.22) / (1 - 0.22))
            rSPOTc = max(0.0, min(rDAMAGEc + 0.1, max(0.0, (rSPOT - 0.38) / (1 - 0.38))))
            rFRAGc = max(0.0, min(rDAMAGEc + 0.2, max(0.0, (rFRAG - 0.12) / (1 - 0.12))))
            rDEFc = max(0.0, min(rDAMAGEc + 0.1, max(0.0, (rDEF - 0.10) / (1 - 0.10))))
            rWINc = max(0.0, (rWIN - 0.71) / (1 - 0.71))
            
            self.WN8 = int(980 * rDAMAGEc + 210 * rDAMAGEc * rFRAGc + 155 * rFRAGc * rSPOTc + 75 *
                           rDEFc * rFRAGc + 145 * min(1.8, rWINc))
            self.DIFFExpDmg = int(damage - self.tankExpd['wn8expDamage'])
        else:
            self.WN8 = 0
            self.DIFFExpDmg = 0

        self.EFF = int(max(0, int(damage * (10.0 / (self.avgTier + 2)) * (0.23 + 2 * self.avgTier / 100.0) + frags *
                                  250 + spotted * 150 + mathLog(capture + 1, 1.732) * 150 + defence * 150)))

        if self.vehCD is not None:
            self.XTE = DKmodsCore.calculateXTE(self.vehCD, damage, frags)
        else:
            self.XTE = 0

        return {'WN8': self.WN8, 'EFF': self.EFF, 'XTE': self.XTE, 'DIFFExpDmg': self.DIFFExpDmg}


efficiencyCalculator = efficiencyCalculator()


class battleEfficiency(object):

    def __init__(self):
        self.vehCD = None
        self.tankExpd = {}
        self.tankExists = False
        self.frags = 0
        self.damage = 0
        self.spotted = 0
        self.defence = 0
        self.capture = 0
        self.WN8 = 0
        self.EFF = 0
        self.XTE = 0
        self.DIFFExpDmg = 0
        self.WN8Color = '#FFFFFF'
        self.EFFColor = '#FFFFFF'
        self.XTEColor = '#FFFFFF'
        self.DIFFExpDmgColor = '#FFFFFF'
        self.pickColors()

    def reset(self):
        self.__init__()

    def getTextFormat(self):
        tf = g_cfg.data['format']
        for macro in MACROS:
            if macro in tf:
                attr = macro.replace('{', '').replace('}', '')
                tf = tf.replace(macro, str(getattr(self, attr)))

        return tf

    def pickColors(self):
        self.WN8Color = getDynamicColorValue('WN8', self.WN8)
        self.EFFColor = getDynamicColorValue('EFF', self.EFF)
        self.XTEColor = getDynamicColorValue('X', self.XTE)
        self.DIFFExpDmgColor = g_cfg.data['colors']['DIFFExpDmg']['bad'] if self.DIFFExpDmg <= 0 else\
            g_cfg.data['colors']['DIFFExpDmg']['good']

    def update(self):
        calcResult = efficiencyCalculator.calc(self.damage, self.spotted, self.frags, self.defence, self.capture, '')
        self.WN8, self.EFF, self.XTE, self.DIFFExpDmg = calcResult['WN8'], calcResult['EFF'],calcResult['XTE'], calcResult['DIFFExpDmg']
        self.pickColors()
        flash.setVisible(True)
        flash.set_text(self.getTextFormat())


battleEfficiency = battleEfficiency()


class Flash(object):
    settingsCore = dependency.descriptor(ISettingsCore)

    def __init__(self):
        self.name = {}
        self.data = {}

    def startBattle(self):
        if not g_cfg.data['enabled']:
            return
        self.setup()
        COMPONENT_EVENT.UPDATED += self.update
        self.createObject(COMPONENT_TYPE.PANEL)
        if g_cfg.data['background']:
            self.createObject(COMPONENT_TYPE.IMAGE)
            self.updateObject(COMPONENT_TYPE.IMAGE, self.data['backgroundData'])
        self.createObject(COMPONENT_TYPE.LABEL)
        if g_cfg.data['shadow']:
            self.updateObject(COMPONENT_TYPE.LABEL, self.data['shadow'])
        else:
            self.updateObject(COMPONENT_TYPE.LABEL, {'shadow': {'distance': 0, 'angle': 0, 'color': '0x000000', 'alpha': 0, "blurX": 0, 'blur': 0, 'strength': 0, 'quality': 0}})
        g_guiResetters.add(self.screenResize)
        self.screenResize()

    def stopBattle(self):
        if not g_cfg.data['enabled']:
            return
        g_guiResetters.remove(self.screenResize)
        COMPONENT_EVENT.UPDATED -= self.update
        self.deleteObject(COMPONENT_TYPE.PANEL)
        if g_cfg.data['background']:
            self.deleteObject(COMPONENT_TYPE.IMAGE)
        self.deleteObject(COMPONENT_TYPE.LABEL)

    def deleteObject(self, name):
        DKmodsCore.g_flash.deleteComponent(self.name[name])

    def createObject(self, name):
        DKmodsCore.g_flash.createComponent(self.name[name], name, self.data[name])

    def updateObject(self, name, data):
        DKmodsCore.g_flash.updateComponent(self.name[name], data)

    def update(self, alias, props):
        if str(alias) == str(g_cfg.ID):
            x = int(props.get('x', g_cfg.data['panel']['x']))
            if x and x != int(g_cfg.data['panel']['x']):
                g_cfg.data['panel']['x'] = x
                self.data[COMPONENT_TYPE.PANEL]['x'] = x
            y = int(props.get('y', g_cfg.data['panel']['y']))
            if y and y != int(g_cfg.data['panel']['y']):
                g_cfg.data['panel']['y'] = y
                self.data[COMPONENT_TYPE.PANEL]['y'] = y
            self.screenResize()
            print '%s Flash coordinates updated : y = %i, x = %i, props: %s' % (alias, g_cfg.data['panel']['y'], g_cfg.data['panel']['x'], props)

    def setup(self):
        self.name = {
            COMPONENT_TYPE.PANEL: g_cfg.ID,
            COMPONENT_TYPE.IMAGE: '%s.%s' % (g_cfg.ID, 'image'),
            COMPONENT_TYPE.LABEL: '%s.%s' % (g_cfg.ID, 'text')
        }
        self.data = {
            COMPONENT_TYPE.PANEL: g_cfg.data.get('panel'),
            COMPONENT_TYPE.IMAGE: {'image': g_cfg.data.get('backgroundImage')},
            'backgroundData': g_cfg.data.get('backgroundData'),
            COMPONENT_TYPE.LABEL: {'text': '', 'index': 1, 'multiline': True},
            'shadow': {'shadow': g_cfg.data.get('shadowText')}
        }

    def setupSize(self, h=None, w=None):
        height = int(g_cfg.data['panelSize'].get('heightNormal', 20))
        width = int(g_cfg.data['panelSize'].get('widthNormal', 100))

        if h is not None and w is not None:
            height = h
            width = w

        height = height * g_cfg.data['sizePercent'] / 100
        width = width * g_cfg.data['sizePercent'] / 100

        for name in self.data:
            self.data[name]['height'] = height
            self.data[name]['width'] = width
        data = {'height': height, 'width': width}
        self.updateObject(COMPONENT_TYPE.PANEL, data)
        self.updateObject(COMPONENT_TYPE.LABEL, data)
        if g_cfg.data['background']:
            self.updateObject(COMPONENT_TYPE.IMAGE, data)

    def textRepSize(self, message):
        mod = False
        text = ''
        count = 0
        for id in message.split('\"'):
            if count:
                text += '"'
            if mod:
                text += '%s' % (int(id) * g_cfg.data['sizePercent'] / 100)
                mod = False
            else:
                text += '%s' % id
            if 'size=' in id:
                mod = True
            count += 1
        return text

    def set_text(self, text):
        txt = '<font face="%s" color="#FFFFFF" vspace="-3" align="baseline" >%s</font>' % (g_cfg.data['font'], text)
        self.updateObject(COMPONENT_TYPE.LABEL, {'text': self.textRepSize(txt)})

    def setVisible(self, status):
        data = {'visible': status}
        self.updateObject(COMPONENT_TYPE.PANEL, data)
        self.updateObject(COMPONENT_TYPE.LABEL, data)
        if g_cfg.data['background']:
            data = {'visible': False}
            self.updateObject(COMPONENT_TYPE.IMAGE, data)

    @staticmethod
    def screenFix(screen, value, mod, align=1):
        if align == 1:
            if value + mod > screen:
                return max(0, int(screen - mod))
            if value < 0:
                return 0
        if align == -1:
            if value - mod < -screen:
                return min(0, int(-screen + mod))
            if value > 0:
                return 0
        if align == 0:
            scr = screen / 2
            if value < scr:
                return int(scr - mod)
            if value > -scr:
                return int(-scr)
        return None

    def screenResize(self):
        curScr = GUI.screenResolution()
        scale = self.settingsCore.interfaceScale.get()
        xMo, yMo = curScr[0] / scale, curScr[1] / scale
        x = None
        if g_cfg.data['panel']['alignX'] == COMPONENT_ALIGN.LEFT:
            x = self.screenFix(xMo, g_cfg.data['panel']['x'], g_cfg.data['panel']['width'], 1)
        if g_cfg.data['panel']['alignX'] == COMPONENT_ALIGN.RIGHT:
            x = self.screenFix(xMo, g_cfg.data['panel']['x'], g_cfg.data['panel']['width'], -1)
        if g_cfg.data['panel']['alignX'] == COMPONENT_ALIGN.CENTER:
            x = self.screenFix(xMo, g_cfg.data['panel']['x'], g_cfg.data['panel']['width'], 0)
        if x is not None:
            if x != int(g_cfg.data['panel']['x']):
                g_cfg.data['panel']['x'] = x
                self.data[COMPONENT_TYPE.PANEL]['x'] = x
        y = None
        if g_cfg.data['panel']['alignY'] == COMPONENT_ALIGN.TOP:
            y = self.screenFix(yMo, g_cfg.data['panel']['y'], g_cfg.data['panel']['height'], 1)
        if g_cfg.data['panel']['alignY'] == COMPONENT_ALIGN.BOTTOM:
            y = self.screenFix(yMo, g_cfg.data['panel']['y'], g_cfg.data['panel']['height'], -1)
        if g_cfg.data['panel']['alignY'] == COMPONENT_ALIGN.CENTER:
            y = self.screenFix(yMo, g_cfg.data['panel']['y'], g_cfg.data['panel']['height'], 0)
        if y is not None:
            if y != int(g_cfg.data['panel']['y']):
                g_cfg.data['panel']['y'] = y
                self.data[COMPONENT_TYPE.PANEL]['y'] = y
        self.updateObject(COMPONENT_TYPE.PANEL, self.data[COMPONENT_TYPE.PANEL])


flash = Flash()


@DKmodsCore.registerEvent(PlayerAvatar, 'vehicle_onEnterWorld')
def vehicle_onEnterWorld(self, vehicle):
    if not g_cfg.data['enabled']:
        return

    if vehicle.id == self.playerVehicleID:
        efficiencyCalculator.registerVInfoData(vehicle.typeDescriptor.type.compactDescr)


@DKmodsCore.injectoverrideMethod(RibbonsAggregator, 'suspend')
def suspend(base, self):
    if not g_cfg.data['enabled']:
        base(self)
        return

    self.resume()


@DKmodsCore.registerEvent(BattleRibbonsPanel, '_addRibbon')
def _addRibbon(self, ribbonID, ribbonType='', leftFieldStr='', vehName='', vehType='', rightFieldStr=''):
    if not g_cfg.data['enabled']:
        return

    if ribbonType not in [BATTLE_EFFICIENCY_TYPES.DETECTION, BATTLE_EFFICIENCY_TYPES.DESTRUCTION,
                          BATTLE_EFFICIENCY_TYPES.DEFENCE, BATTLE_EFFICIENCY_TYPES.CAPTURE]:
        return

    if ribbonType == BATTLE_EFFICIENCY_TYPES.DETECTION:
        battleEfficiency.spotted += 1 if (len(leftFieldStr.strip()) == 0) else int(leftFieldStr[1:])
    elif ribbonType == BATTLE_EFFICIENCY_TYPES.DESTRUCTION:
        battleEfficiency.frags += 1
    elif ribbonType == BATTLE_EFFICIENCY_TYPES.DEFENCE:
        battleEfficiency.defence = min(100, battleEfficiency.defence + int(leftFieldStr))
    elif ribbonType == BATTLE_EFFICIENCY_TYPES.CAPTURE:
        battleEfficiency.capture = int(leftFieldStr)
    
    battleEfficiency.update()


@DKmodsCore.registerEvent(DamageLogPanel, '_onTotalEfficiencyUpdated')
def _onTotalEfficiencyUpdated(self, diff):
    if not g_cfg.data['enabled']:
        return
    
    if PERSONAL_EFFICIENCY_TYPE.DAMAGE in diff:
        battleEfficiency.damage = diff[PERSONAL_EFFICIENCY_TYPE.DAMAGE]
        battleEfficiency.update()


@DKmodsCore.registerEvent(PlayerAvatar, '_PlayerAvatar__startGUI')
def __startGUI(self):
    if not g_cfg.data['enabled']:
        return

    if BigWorld.player().arena.bonusType == ARENA_BONUS_TYPE.REGULAR:
        flash.startBattle()


@DKmodsCore.registerEvent(PlayerAvatar, '_PlayerAvatar__destroyGUI')
def __destroyGUI(self):
    if not g_cfg.data['enabled']:
        return
    battleEfficiency.reset()
    efficiencyCalculator.reset()
    flash.stopBattle()


@DKmodsCore.injectoverrideMethod(BattleResultsWindow, 'as_setDataS')
def as_setDataS(base, self, data):
    if not (g_cfg.data['enabled'] and g_cfg.data['battleResultsWindow']['enabled']):
        return base(self, data)

    def _logLargeData(d):
        pretty_d = dumps(d, indent = 2)
        print pretty_d

    def _normalizeString(s):
        return sub('<.*?>', '', s.replace('\xc2\xa0', '').replace('.', ''))

    def _splitArenaStr(s):
        _s = s.replace(u'\xa0\u2014', '-').replace(u'\u2013', '-')
        _s = _s.split('-')
        return _s if (len(_s) == 2) else (s, '')

    try:
        teamDict = data['team1']
        statValues = data['personal']['statValues'][0]
        arenaStr = data['common']['arenaStr'].strip().split('-')
        stunStatus = 'vehWStun' if (len(statValues) > 16) else 'vehWOStun'

        for playerDict in teamDict:
            if playerDict['isSelf']:
                efficiencyCalculator.registerVInfoData(playerDict['vehicleCD'])
                break

        damageDealt = _normalizeString(statValues[DATA_IDS['damageDealt']]['value'])
        spotted = _normalizeString(statValues[DATA_IDS['spotted']]['value'])
        kills = _normalizeString(statValues[DATA_IDS['kills']]['value']).split('/')
        kills = kills[1]
        defAndCap = _normalizeString(statValues[DATA_IDS['defAndCap'][stunStatus]]['value']).split('/')
        defence = defAndCap[0]
        capture = defAndCap[1]

        calcResult = efficiencyCalculator.calc(int(damageDealt), int(spotted), int(kills), int(defence),
                                               int(capture), str(data['common']['resultShortStr']))
        self.WN8, self.EFF, self.XTE = calcResult['WN8'], calcResult['EFF'], calcResult['XTE']

        arenaStr = data['common']['arenaStr'].split(u'\u2013')
        mapName = arenaStr[0].strip()
        battleType = arenaStr[1].strip()

        textFormat = g_cfg.data['battleResultsWindow']['textFormat']
        textFormat = textFormat.replace('{{mapName}}', mapName)
        textFormat = textFormat.replace('{{battleType}}', battleType)
        textFormat = textFormat.replace('{{WN8}}', str(self.WN8))
        textFormat = textFormat.replace('{{EFF}}', str(self.EFF))
        textFormat = textFormat.replace('{{XTE}}', str(self.XTE))
        textFormat = textFormat.replace('{{c:WN8}}', getDynamicColorValue('wn8', self.WN8))
        textFormat = textFormat.replace('{{c:EFF}}', getDynamicColorValue('eff', self.EFF))
        textFormat = textFormat.replace('{{c:XTE}}', getDynamicColorValue('x', self.XTE))
        data['common']['arenaStr'] = textFormat
    except:
        traceback.print_exc()
        _logLargeData(data)
        data['common']['arenaStr'] += '  <font color="#FE0E00">efficiency error!</font>'

    efficiencyCalculator.reset()
    return base(self, data)


BigWorld.BEFF = flash.set_text

this..

 

Share this post


Link to post

Short link
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.
Note: Your post will require moderator approval before it will be visible.

Guest
Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

Sign in to follow this  

  • Recently Browsing   0 members

    No registered users viewing this page.

×
×
  • Create New...