def start(self):
self._interval = TimeInterval(_TARGET_UPDATE_INTERVAL, self, '_update')
ctrl = g_sessionProvider.shared.crosshair
raise ctrl is not None or AssertionError(
'Crosshair controller is not found')
ctrl.onCrosshairViewChanged += self._onCrosshairViewChanged
return
def __init__(self, parentObj, totalTime, timeLeft, siegeState,
engineState):
super(_PythonUpdater, self).__init__(parentObj, totalTime, timeLeft,
siegeState, engineState)
self._timeInterval = TimeInterval(0.05, self, '_tick')
self._startTime = BigWorld.serverTime()
self._finishTime = self._startTime + timeLeft
class DebugController(IViewComponentsController):
"""Controller for the debug panel.
This class starts internal update cycle and updates debug panel.
In order to collect lagging info from near vehicles, these vehicle's ids
should be provided from outside using special methods.
"""
statsCollector = dependency.descriptor(IStatisticsCollector)
def __init__(self):
super(DebugController, self).__init__()
self._debugPanelUI = None
self._timeInterval = None
return
def getControllerID(self):
return BATTLE_CTRL_ID.DEBUG
def startControl(self):
self._timeInterval = TimeInterval(_UPDATE_INTERVAL, self, '_update')
self._timeInterval.start()
def stopControl(self):
self._timeInterval.stop()
self._timeInterval = None
self.clearViewComponents()
return
def setViewComponents(self, debugPanelUI):
raise isinstance(debugPanelUI, IDebugPanel) or AssertionError
self._debugPanelUI = debugPanelUI
def clearViewComponents(self):
self._debugPanelUI = None
return
def _update(self):
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and not replayCtrl.isBattleSimulation and replayCtrl.fps > 0:
fps = BigWorld.getFPS()[1]
fpsReplay = int(replayCtrl.fps)
ping = replayCtrl.ping
isLaggingNow = replayCtrl.isLaggingNow
else:
fpsReplay = -1
isLaggingNow = BigWorld.statLagDetected()
ping = BigWorld.statPing()
fps = BigWorld.getFPS()[1]
self.statsCollector.update()
if replayCtrl.isRecording:
replayCtrl.setFpsPingLag(fps, ping, isLaggingNow)
try:
ping = int(ping)
fps = int(fps)
except (ValueError, OverflowError):
return
if self._debugPanelUI is not None:
self._debugPanelUI.updateDebugInfo(int(ping), int(fps), isLaggingNow, fpsReplay=fpsReplay)
return
class _DistancePlugin(CrosshairPlugin):
__slots__ = ('_interval', '_distance')
def __init__(self, parentObj):
super(_DistancePlugin, self).__init__(parentObj)
self._interval = None
self._distance = 0
return
def start(self):
self._interval = TimeInterval(_TARGET_UPDATE_INTERVAL, self, '_update')
ctrl = self.sessionProvider.shared.crosshair
ctrl.onCrosshairViewChanged += self._onCrosshairViewChanged
def stop(self):
if self._interval is not None:
self._interval.stop()
self._interval = None
ctrl = self.sessionProvider.shared.crosshair
if ctrl is not None:
ctrl.onCrosshairViewChanged -= self._onCrosshairViewChanged
return
def _update(self):
raise NotImplementedError
def _onCrosshairViewChanged(self, viewID):
raise NotImplementedError
class _DistancePlugin(IPlugin):
__slots__ = ('__weakref__', '_interval', '_distance')
def __init__(self, parentObj):
super(_DistancePlugin, self).__init__(parentObj)
self._interval = None
self._distance = 0
return
def start(self):
self._interval = TimeInterval(_TARGET_UPDATE_INTERVAL, self, '_update')
ctrl = g_sessionProvider.shared.crosshair
raise ctrl is not None or AssertionError('Crosshair controller is not found')
ctrl.onCrosshairViewChanged += self._onCrosshairViewChanged
return
def stop(self):
if self._interval is not None:
self._interval.stop()
self._interval = None
ctrl = g_sessionProvider.shared.crosshair
if ctrl is not None:
ctrl.onCrosshairViewChanged -= self._onCrosshairViewChanged
return
def _update(self):
raise NotImplementedError
def _onCrosshairViewChanged(self, viewID):
raise NotImplementedError
class DebugController(IViewComponentsController):
"""Controller for the debug panel.
This class starts internal update cycle and updates debug panel.
In order to collect lagging info from near vehicles, these vehicle's ids
should be provided from outside using special methods.
"""
def __init__(self):
super(DebugController, self).__init__()
self._debugPanelUI = None
self._timeInterval = None
return
def getControllerID(self):
return BATTLE_CTRL_ID.DEBUG
def startControl(self):
self._timeInterval = TimeInterval(_UPDATE_INTERVAL, self, '_update')
self._timeInterval.start()
def stopControl(self):
self._timeInterval.stop()
self._timeInterval = None
self._debugPanelUI = None
return
def setViewComponents(self, debugPanelUI):
raise isinstance(debugPanelUI, IDebugPanel) or AssertionError
self._debugPanelUI = debugPanelUI
def clearViewComponents(self):
self._debugPanelUI = None
return
def _update(self):
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.fps > 0:
fps = BigWorld.getFPS()[1]
fpsReplay = int(replayCtrl.fps)
ping = replayCtrl.ping
isLaggingNow = replayCtrl.isLaggingNow
else:
fpsReplay = -1
isLaggingNow = BigWorld.statLagDetected()
ping = BigWorld.statPing()
fps = BigWorld.getFPS()[1]
g_statistics.update()
if replayCtrl.isRecording:
replayCtrl.setFpsPingLag(fps, ping, isLaggingNow)
try:
ping = int(ping)
fps = int(fps)
except (ValueError, OverflowError):
return
if self._debugPanelUI is not None:
self._debugPanelUI.updateDebugInfo(int(ping), int(fps), isLaggingNow, fpsReplay=fpsReplay)
return
def start(self):
"""
Sets up and starts the timer to invalidate handlers.
"""
if self.__updateTI is None:
self.__updateTI = TimeInterval(VEHICLE_UPDATE_INTERVAL, self, '_update')
self.__updateTI.start()
return
def __init__(self, panel, typeID, viewID, totalTime):
super(_PythonTimer, self).__init__(panel, typeID, viewID, totalTime)
self._timeInterval = TimeInterval(1.0, self, '_tick')
self._startTime = BigWorld.serverTime()
if totalTime:
self._finishTime = self._startTime + totalTime
else:
self._finishTime = 0
def updateBlur(self):
if self.hotKeyDown or (player().getVehicleAttached() is None):
return
if self.timer is not None and self.timer.isStarted():
self.timer.stop()
self.timer = None
self.timer = TimeInterval(infoPanelConfig['delay'], self, 'hide')
self.timer.start()
class DebugPanel(UIInterface):
__UPDATE_INTERVAL = 0.01
def __init__(self, parentUI):
UIInterface.__init__(self)
self.__ui = parentUI
self.__timeInterval = None
self.__performanceStats = _PerformanceStats()
self.__performanceStats.populateUI(parentUI)
def start(self):
self.__timeInterval = TimeInterval(self.__UPDATE_INTERVAL, self, '_DebugPanel__update')
self.__timeInterval.start()
self.__update()
def destroy(self):
self.__performanceStats.disposeUI()
self.__performanceStats = None
self.__timeInterval.stop()
def __update(self):
player = BigWorld.player()
if player is None or not hasattr(player, 'playerVehicleID'):
return
fps = 0
recordedFps = -1
ping = 0
isLaggingNow = False
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.fps > 0:
fps = BigWorld.getFPS()[1]
recordedFps = replayCtrl.fps
ping = replayCtrl.ping
isLaggingNow = replayCtrl.isLaggingNow
else:
isLaggingNow = player.filter.isLaggingNow
if not isLaggingNow:
for v in BigWorld.entities.values():
if _isVehicleEntity(v):
if not v.isPlayer:
if v.isAlive() and isinstance(v.filter, BigWorld.WGVehicleFilter) and v.filter.isLaggingNow:
isLaggingNow = True
break
ping = min(BigWorld.LatencyInfo().value[3] * 1000, 999)
if ping < 999:
ping = max(1, ping - 500.0 * constants.SERVER_TICK_LENGTH)
fpsInfo = BigWorld.getFPS()
from helpers.statistics import g_statistics
g_statistics.update(fpsInfo, ping, isLaggingNow)
fps = fpsInfo[1]
if replayCtrl.isRecording:
replayCtrl.setFpsPingLag(fps, ping, isLaggingNow)
try:
self.__performanceStats.updateDebugInfo(int(fps), int(ping), isLaggingNow, int(recordedFps))
except:
pass
class DebugController(IViewComponentsController):
statsCollector = dependency.descriptor(IStatisticsCollector)
def __init__(self):
super(DebugController, self).__init__()
self._debugPanelUI = None
self._timeInterval = None
return
def getControllerID(self):
return BATTLE_CTRL_ID.DEBUG
def startControl(self):
self._timeInterval = TimeInterval(_UPDATE_INTERVAL, self, '_update')
self._timeInterval.start()
def stopControl(self):
self._timeInterval.stop()
self._timeInterval = None
self.clearViewComponents()
return
def setViewComponents(self, debugPanelUI):
self._debugPanelUI = debugPanelUI
def clearViewComponents(self):
self._debugPanelUI = None
return
def _update(self):
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and not replayCtrl.isBattleSimulation and replayCtrl.fps > 0 or replayCtrl.isServerSideReplay:
fps = BigWorld.getFPS()[1]
fpsReplay = int(replayCtrl.fps)
ping = replayCtrl.ping
isLaggingNow = replayCtrl.isLaggingNow
else:
fpsReplay = -1
isLaggingNow = BigWorld.statLagDetected()
ping = BigWorld.statPing()
fps = BigWorld.getFPS()[1]
self.statsCollector.update()
if replayCtrl.isRecording:
replayCtrl.setFpsPingLag(fps, ping, isLaggingNow)
try:
ping = int(ping)
fps = int(fps)
except (ValueError, OverflowError):
return
if self._debugPanelUI is not None:
self._debugPanelUI.updateDebugInfo(ping,
fps,
isLaggingNow,
fpsReplay=fpsReplay)
return
def output(self):
if config.get(self.S_SHOW_HIT_NO_DAMAGE) or data.data['isDamage']:
self.groupDamages()
if self.strLastHit:
if (self.timerLastHit is not None) and self.timerLastHit.isStarted:
self.timerLastHit.stop()
timeDisplayLastHit = float(parser(config.get(self.S_TIME_DISPLAY_LAST_HIT)))
self.timerLastHit = TimeInterval(timeDisplayLastHit, self, 'hideLastHit')
self.timerLastHit.start()
as_event('ON_LAST_HIT')
def _startTick(self):
if self._totalTime:
timeLeft = max(0, self._finishTime - BigWorld.serverTime())
if timeLeft:
self._setViewSnapshot(timeLeft)
self._timeInterval = TimeInterval(self.__interval, self, '_tick')
firstShortPeriod = float(self._totalTime) % self.__interval
if round(firstShortPeriod, 4) > 0.0:
self.__short1stPeriodCbId = BigWorld.callback(firstShortPeriod, self.__onShort1stPeriodFinished)
else:
self._timeInterval.restart()
def __init__(self,
panel,
typeID,
viewID,
totalTime,
finishTime,
startTime=None,
interval=1.0,
**kwargs):
super(PythonTimer, self).__init__(panel, typeID, viewID, totalTime,
finishTime, startTime, **kwargs)
self._timeInterval = TimeInterval(interval, self, '_tick')
def __init__(self):
super(VehicleStateController, self).__init__()
self.__eManager = Event.EventManager()
self.onVehicleStateUpdated = Event.Event(self.__eManager)
self.onVehicleControlling = Event.Event(self.__eManager)
self.onPostMortemSwitched = Event.Event(self.__eManager)
self.onRespawnBaseMoving = Event.Event(self.__eManager)
self.__waitingTI = TimeInterval(VEHICLE_WAINING_INTERVAL, self, '_waiting')
self.__updateTI = TimeInterval(VEHICLE_UPDATE_INTERVAL, self, '_update')
self.__vehicleID = 0
self.__updater = _PlayerVehicleUpdater()
self.__isRqToSwitch = False
def __init__(self, updater, vehicle):
"""
Constructor. Initializes internal variables based on vehicle state.
:param updater: An instance of _VehicleUpdater class, that creates this handler.
:param vehicle: Vehicle to be tracked.
:return:
"""
super(_EngineStateHandler, self).__init__(updater)
self.__gear = vehicle.appearance.gear if vehicle is not None else _STOPPED_ENGINE_GEAR
self.__vehMoveAnimTimer = TimeInterval(_VEHICLE_ANIM_DURATION, self, '_stopVehMoveAnim')
self.__engineStartAnimTimer = TimeInterval(_VEHICLE_ANIM_DURATION, self, '_stopEngineStartAnim')
return
def updateLastHit(self):
timeDisplayLastHit = float(
config.get('damageLog/lastHit/timeDisplayLastHit'))
self.lastHit = self.parser(
config.get('damageLog/lastHit/formatLastHit')) #, True)
if self.lastHit:
if (self.timerLastHit
is not None) and (self.timerLastHit.isStarted):
self.timerLastHit.stop()
self.timerLastHit = TimeInterval(timeDisplayLastHit, self,
'hideLastHit')
self.timerLastHit.start()
as_event('ON_LAST_HIT')
class InfoPanel(object):
def __init__(self):
self.textFormats = infoPanelConfig['formats']
self.textsFormatted = None
self.timer = None
def reset(self):
self.__init__()
info_panel_data.reset()
def setTextsFormatted(self):
def getFuncResponse(funcName):
func = getattr(info_panel_data, funcName, None)
if func and callable(func):
return func()
else:
return 'null'
self.textsFormatted = []
for textFormat in self.textFormats:
for macros in MACROSES:
if macros in textFormat:
funcName = macros.replace('{', '').replace('}', '')
funcResponse = getFuncResponse(funcName)
textFormat = textFormat.replace(macros, funcResponse)
self.textsFormatted.append(textFormat)
def hide(self):
if self.timer is not None and self.timer.isStarted():
self.timer.stop()
self.timer = None
self.textsFormatted = None
as_event('ON_INFO_PANEL')
def updateBlur(self):
if hotKeyPressed or (player().getVehicleAttached() is None):
return
if self.timer is not None and self.timer.isStarted():
self.timer.stop()
self.timer = None
self.timer = TimeInterval(infoPanelConfig['delay'], self, 'hide')
self.timer.start()
def update(self, vehicle):
if hotKeyPressed:
return
info_panel_data.init(vehicle)
self.setTextsFormatted()
as_event('ON_INFO_PANEL')
def output(self):
macroes = None
if (((data.data['attackReasonID'] in [2, 3]) and config.get(self.section + 'groupDamagesFromRamming_WorldCollision'))
or ((data.data['attackReasonID'] == 1) and config.get(self.section + 'groupDamagesFromFire'))):
dataLog = data.data.copy()
attackerID = data.data['attackerID']
attackReasonID = data.data['attackReasonID']
if attackerID in self.dictVehicle:
if (attackReasonID in self.dictVehicle[attackerID] and
('time' in self.dictVehicle[attackerID][attackReasonID]) and
('damage' in self.dictVehicle[attackerID][attackReasonID]) and
((BigWorld.serverTime() - self.dictVehicle[attackerID][attackReasonID]['time']) < 1)):
self.dictVehicle[attackerID][attackReasonID]['time'] = BigWorld.serverTime()
self.dictVehicle[attackerID][attackReasonID]['damage'] += data.data['damage']
key = self.dictVehicle[attackerID][attackReasonID]
dataLog['damage'] = key['damage']
dataLog['dmgRatio'] = dataLog['damage'] * 100 // data.data['maxHealth']
if (attackReasonID == 1) and (key['beginFire'] is not None):
dataLog['fireDuration'] = BigWorld.time() - key['beginFire']
else:
dataLog['fireDuration'] = None
else:
self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
'damage': data.data['damage'],
'beginFire': beginFire if attackReasonID == 1 else None}
dataLog['fireDuration'] = BigWorld.time() - beginFire if attackReasonID == 1 else None
else:
self.dictVehicle[attackerID] = {}
self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
'damage': data.data['damage'],
'beginFire': beginFire if attackReasonID == 1 else None}
dataLog['fireDuration'] = BigWorld.time() - beginFire if attackReasonID == 1 else None
macroes = getValueMacroes(self.section, dataLog)
self.strLastHit = parser(config.get(self.section + 'formatLastHit'), macroes)
else:
if config.get(self.section + 'showHitNoDamage') or data.data['isDamage']:
macroes = getValueMacroes(self.section, data.data)
self.strLastHit = parser(config.get(self.section + 'formatLastHit'), macroes)
else:
self.strLastHit = ''
if self.strLastHit:
if macroes is None:
macroes = getValueMacroes(self.section, data.data)
if (self.timerLastHit is not None) and self.timerLastHit.isStarted:
self.timerLastHit.stop()
timeDisplayLastHit = float(parser(config.get(self.section + 'timeDisplayLastHit'), macroes))
self.timerLastHit = TimeInterval(timeDisplayLastHit, self, 'hideLastHit')
self.timerLastHit.start()
self.shadow = shadow_value(self.section, macroes)
as_event('ON_LAST_HIT')
return
def __init__(self):
super(VehicleStateController, self).__init__()
self.__eManager = Event.EventManager()
self.onVehicleStateUpdated = Event.Event(self.__eManager)
self.onVehicleControlling = Event.Event(self.__eManager)
self.onPostMortemSwitched = Event.Event(self.__eManager)
self.onRespawnBaseMoving = Event.Event(self.__eManager)
self.__cachedStateValues = {}
self.__waitingTI = TimeInterval(VEHICLE_WAINING_INTERVAL, self, '_waiting')
self.__vehicleID = 0
self.__updater = None
self.__isRqToSwitch = False
self.__isInPostmortem = False
return
def __init__(self):
super(VehicleStateController, self).__init__()
self.__eManager = Event.EventManager()
self.onVehicleStateUpdated = Event.Event(self.__eManager)
self.onVehicleControlling = Event.Event(self.__eManager)
self.onPostMortemSwitched = Event.Event(self.__eManager)
self.onRespawnBaseMoving = Event.Event(self.__eManager)
self.__waitingTI = TimeInterval(VEHICLE_WAINING_INTERVAL, self,
'_waiting')
self.__updateTI = TimeInterval(VEHICLE_UPDATE_INTERVAL, self,
'_update')
self.__vehicleID = 0
self.__updater = _PlayerVehicleUpdater()
self.__isRqToSwitch = False
class PrecisePythonTimer(PythonTimer):
__slots__ = ('__short1stPeriodCbId', '__interval', '_timeInterval', '_startTime')
def __init__(self, viewObject, typeID, viewID, totalTime, finishTime, startTime=None, interval=1.0, secondInRow=False, **kwargs):
super(PrecisePythonTimer, self).__init__(viewObject, typeID, viewID, totalTime, finishTime, startTime, interval, secondInRow, **kwargs)
if startTime is not None:
self._startTime = startTime
self.__interval = interval
self.__short1stPeriodCbId = None
return
def _startTick(self):
if self._totalTime:
timeLeft = max(0, self._finishTime - BigWorld.serverTime())
if timeLeft:
self._setViewSnapshot(timeLeft)
self._timeInterval = TimeInterval(self.__interval, self, '_tick')
firstShortPeriod = float(self._totalTime) % self.__interval
if round(firstShortPeriod, 4) > 0.0:
self.__short1stPeriodCbId = BigWorld.callback(firstShortPeriod, self.__onShort1stPeriodFinished)
else:
self._timeInterval.restart()
def clear(self):
self.__clearShort1stPeriodCb()
super(PrecisePythonTimer, self).clear()
def _stopTick(self):
self.__clearShort1stPeriodCb()
super(PrecisePythonTimer, self)._stopTick()
def _setViewSnapshot(self, timeLeft):
raise NotImplementedError
def __clearShort1stPeriodCb(self):
if self.__short1stPeriodCbId is not None:
BigWorld.cancelCallback(self.__short1stPeriodCbId)
self.__short1stPeriodCbId = None
return
def __onShort1stPeriodFinished(self):
self.__short1stPeriodCbId = None
self._tick()
timeLeft = self._finishTime - BigWorld.serverTime()
if timeLeft > 0:
self._timeInterval.restart()
else:
self.hide()
return
def startTimer(self, device, duration):
self.TIMERS[device]['duration'] = duration
if self.TIMERS[device]['timer'] is not None:
return
self.TIMERS[device]['timer'] = TimeInterval(0.1, self, '{}OnTimer'.format(device))
self.TIMERS[device]['timer'].start()
as_event(EVENTS[device])
def __init__(self, updater, vehicle):
"""
Constructor. Initializes internal variables based on vehicle state.
:param updater: An instance of _VehicleUpdater class, that creates this handler.
:param vehicle: Vehicle to be tracked.
:return:
"""
super(_EngineStateHandler, self).__init__(updater)
if vehicle is not None and vehicle.appearance is not None:
self.__gear = vehicle.appearance.gear
else:
self.__gear = _STOPPED_ENGINE_GEAR
self.__vehMoveAnimTimer = TimeInterval(_VEHICLE_ANIM_DURATION, self, '_stopVehMoveAnim')
self.__engineStartAnimTimer = TimeInterval(_VEHICLE_ANIM_DURATION, self, '_stopEngineStartAnim')
return
def __init__(self, panel, typeID, viewID, totalTime):
super(_PythonTimer, self).__init__(panel, typeID, viewID, totalTime)
self._timeInterval = TimeInterval(1.0, self, '_tick')
self._startTime = BigWorld.serverTime()
if totalTime:
self._finishTime = self._startTime + totalTime
else:
self._finishTime = 0
def __init__(self):
"""
Constructor. Initializes internal variables.
"""
super(VehicleStateController, self).__init__()
self.__eManager = Event.EventManager()
self.onVehicleStateUpdated = Event.Event(self.__eManager)
self.onVehicleControlling = Event.Event(self.__eManager)
self.onPostMortemSwitched = Event.Event(self.__eManager)
self.onRespawnBaseMoving = Event.Event(self.__eManager)
self.__waitingTI = TimeInterval(VEHICLE_WAINING_INTERVAL, self,
'_waiting')
self.__vehicleID = 0
self.__updater = None
self.__isRqToSwitch = False
self.__isInPostmortem = False
return
def updateBlur(self):
if hotKeyPressed or (player().getVehicleAttached() is None):
return
if self.timer is not None and self.timer.isStarted():
self.timer.stop()
self.timer = None
self.timer = TimeInterval(infoPanelConfig['delay'], self, 'hide')
self.timer.start()
def start(self):
"""
Sets up and starts the timer to invalidate handlers.
"""
if self.__updateTI is None:
self.__updateTI = TimeInterval(VEHICLE_UPDATE_INTERVAL, self, '_update')
self.__updateTI.start()
return
def start(self):
if self._gui is None:
return
else:
if self._updateTI:
self._updateTI.stop()
for markerID in self._markers.iterkeys():
if markerID not in self._attachGUIToMarkersCallback:
self._attachGUIToMarkersCallback[
markerID] = BigWorld.callback(
0.0,
partial(self._attachGUIToMarkers,
markerID=markerID))
self._updateTI = TimeInterval(self._UPDATE_TICK_LENGTH, self,
'_tickUpdate')
self._updateTI.start()
return
def __init__(self,
viewObject,
typeID,
viewID,
totalTime,
finishTime,
startTime=None,
interval=1.0,
secondInRow=False,
**kwargs):
super(PythonTimer, self).__init__(viewObject,
typeID,
viewID,
totalTime,
finishTime,
startTime,
secondInRow=secondInRow,
**kwargs)
self._timeInterval = TimeInterval(interval, self, '_tick')
def output(self):
if config.get(self.S_SHOW_HIT_NO_DAMAGE) or data.data['isDamage']:
self.groupDamages()
if self.strLastHit:
if (self.timerLastHit is not None) and self.timerLastHit.isStarted:
self.timerLastHit.stop()
timeDisplayLastHit = float(parser(config.get(self.S_TIME_DISPLAY_LAST_HIT)))
self.timerLastHit = TimeInterval(timeDisplayLastHit, self, 'hideLastHit')
self.timerLastHit.start()
as_event('ON_LAST_HIT')
def output(self):
if (data.data['attackReasonID'] == 0) and (data.data['timer'] > 0):
self.data = data.data.copy()
macroes = getValueMacroes(self.section, self.data)
self.strTime = parser(config.get(self.section + 'formatTimer'), macroes)
as_event('ON_TIMER_RELOAD')
self.finishTime = self.data['timer'] + BigWorld.serverTime()
if (self.timerReloadAttacker is not None) and (self.timerReloadAttacker.isStarted):
self.timerReloadAttacker.stop()
self.timerReloadAttacker = TimeInterval(0.1, self, 'currentTimeReload')
self.timerReloadAttacker.start()
def currentTimeReload(self):
self.macros['timer'] = round(self.finishTime - BigWorld.serverTime(),
1)
self.config['timeTextAfterReload'] = float(
config.get('damageLog/timeReload/timeTextAfterReload'))
if self.macros['timer'] > 0:
self.currentTime = self.parser(
config.get('damageLog/timeReload/formatTimer'))
else:
self.timerReloadAttacker.stop()
if self.config['timeTextAfterReload'] > 0:
self.timerReloadAttacker = TimeInterval(
self.config['timeTextAfterReload'], self,
'afterTimerReload')
self.currentTime = self.parser(
config.get('damageLog/timeReload/formatTimerAfterReload'))
self.timerReloadAttacker.start()
else:
self.currentTime = ''
as_event('ON_TIMER_RELOAD')
def output(self):
macroes = None
if (((data.data['attackReasonID'] in [2, 3]) and config.get(self.section + 'groupDamagesFromRamming_WorldCollision'))
or ((data.data['attackReasonID'] == 1) and config.get(self.section + 'groupDamagesFromFire'))):
dataLog = data.data.copy()
attackerID = data.data['attackerID']
attackReasonID = data.data['attackReasonID']
if attackerID in self.dictVehicle:
if attackReasonID in self.dictVehicle[attackerID]:
key = self.dictVehicle[attackerID][attackReasonID]
if ('time' in key) and ('damage' in key) and ((BigWorld.serverTime() - key['time']) < 1):
key['time'] = BigWorld.serverTime()
key['damage'] += data.data['damage']
dataLog['damage'] = key['damage']
dataLog['dmgRatio'] = dataLog['damage'] * 100 // data.data['maxHealth']
if (attackReasonID == 1) and (key['beginFire'] is not None):
dataLog['fireDuration'] = BigWorld.time() - key['beginFire']
else:
dataLog['fireDuration'] = None
else:
self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
'damage': data.data['damage'],
'beginFire': beginFire if attackReasonID == 1 else None}
dataLog['fireDuration'] = BigWorld.time() - beginFire if attackReasonID == 1 else None
else:
self.dictVehicle[attackerID] = {}
self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
'damage': data.data['damage'],
'beginFire': beginFire if attackReasonID == 1 else None}
dataLog['fireDuration'] = BigWorld.time() - beginFire if attackReasonID == 1 else None
macroes = getValueMacroes(self.section, dataLog)
self.strLastHit = parser(config.get(self.section + 'formatLastHit'), macroes)
if not config.get(self.section + 'moveInBattle'):
self.x = parser(config.get(self.section + 'x'), macroes)
self.y = parser(config.get(self.section + 'y'), macroes)
else:
if config.get(self.section + 'showHitNoDamage') or data.data['isDamage']:
macroes = getValueMacroes(self.section, data.data)
self.strLastHit = parser(config.get(self.section + 'formatLastHit'), macroes)
if not config.get(self.section + 'moveInBattle'):
self.x = parser(config.get(self.section + 'x'), macroes)
self.y = parser(config.get(self.section + 'y'), macroes)
else:
self.strLastHit = ''
if self.strLastHit:
if macroes is None:
macroes = getValueMacroes(self.section, data.data)
if (self.timerLastHit is not None) and self.timerLastHit.isStarted:
self.timerLastHit.stop()
timeDisplayLastHit = float(parser(config.get(self.section + 'timeDisplayLastHit'), macroes))
self.timerLastHit = TimeInterval(timeDisplayLastHit, self, 'hideLastHit')
self.timerLastHit.start()
self.shadow = shadow_value(self.section, macroes)
as_event('ON_LAST_HIT')
class TimeTrackState(RepairState):
__slots__ = ('_timer', '_nextTime', '__weakref__')
def __init__(self, pointIndex, stateID, *actions):
super(TimeTrackState, self).__init__(pointIndex, stateID, *actions)
self._timer = None
self._nextTime = 0
return
def destroy(self):
self._destroyTimer()
super(TimeTrackState, self).destroy()
def setAction(self, action, nextActionTime):
if action in self._actions:
self._recreateTimer(nextActionTime)
self._updateTime()
else:
self._destroyTimer()
def _getTimeLeft(self):
return max(0, round(self._nextTime - BigWorld.serverTime()))
def _updateTime(self):
self._ctrl.onTimerUpdated(self._pointIndex, self._stateID,
self._getTimeLeft())
def _createTimer(self, nextActionTime):
self._nextTime = nextActionTime
self._timer = TimeInterval(1, self, '_updateTime')
self._timer.start()
def _destroyTimer(self):
if self._timer is not None:
self._timer.stop()
self._timer = None
return
def _recreateTimer(self, nextActionTime):
self._destroyTimer()
self._createTimer(nextActionTime)
def addTimer(self, device, duration):
if device in self.timers:
self.timers[device]['timer'].stop()
self.timers.update({
device: {
'duration': duration,
'timer': TimeInterval(0.1, self, '{}OnTimer'.format(device))
}
})
self.timers[device]['timer'].start()
self.eventHandler(device)
class TimeTrackState(RepairState):
__slots__ = ('_timer', '_nextTime', '__weakref__')
def __init__(self, pointIndex, stateID, *actions):
super(TimeTrackState, self).__init__(pointIndex, stateID, *actions)
self._timer = None
self._nextTime = 0
return
def destroy(self):
self._destroyTimer()
super(TimeTrackState, self).destroy()
def setAction(self, action, nextActionTime):
if action in self._actions:
self._recreateTimer(nextActionTime)
self._updateTime()
else:
self._destroyTimer()
def _getTimeLeft(self):
return max(0, round(self._nextTime - BigWorld.serverTime()))
def _updateTime(self):
self._ctrl.onTimerUpdated(self._pointIndex, self._stateID, self._getTimeLeft())
def _createTimer(self, nextActionTime):
self._nextTime = nextActionTime
self._timer = TimeInterval(1, self, '_updateTime')
self._timer.start()
def _destroyTimer(self):
if self._timer is not None:
self._timer.stop()
self._timer = None
return
def _recreateTimer(self, nextActionTime):
self._destroyTimer()
self._createTimer(nextActionTime)
class _PythonTimer(_TimerComponent):
__slots__ = ('_timeInterval', '_startTime', '_finishTime', '__weakref__')
def __init__(self, panel, typeID, viewID, totalTime):
super(_PythonTimer, self).__init__(panel, typeID, viewID, totalTime)
self._timeInterval = TimeInterval(1.0, self, '_tick')
self._startTime = BigWorld.serverTime()
if totalTime:
self._finishTime = self._startTime + totalTime
else:
self._finishTime = 0
def clear(self):
self._timeInterval.stop()
super(_PythonTimer, self).clear()
def _startTick(self):
if self._totalTime:
timeLeft = max(0, self._finishTime - BigWorld.serverTime())
if timeLeft:
self._panel.as_setTimeSnapshotS(self._typeID, self._totalTime, timeLeft)
self._timeInterval.start()
def _stopTick(self):
self._timeInterval.stop()
def _tick(self):
timeLeft = self._finishTime - BigWorld.serverTime()
if timeLeft >= 0:
self._panel.as_setTimeSnapshotS(self._typeID, self._totalTime, timeLeft)
else:
self.hide()
class PythonTimer(TimerComponent):
__slots__ = ('_timeInterval', '__weakref__')
def __init__(self, viewObject, typeID, viewID, totalTime, finishTime, startTime=None, interval=1.0, secondInRow=False, **kwargs):
super(PythonTimer, self).__init__(viewObject, typeID, viewID, totalTime, finishTime, startTime, secondInRow=secondInRow, **kwargs)
self._timeInterval = TimeInterval(interval, self, '_tick')
def clear(self):
self._timeInterval.stop()
super(PythonTimer, self).clear()
def _startTick(self):
if self._totalTime:
timeLeft = max(0, self._finishTime - BigWorld.serverTime())
if timeLeft:
self._setViewSnapshot(timeLeft)
self._timeInterval.restart()
def _stopTick(self):
self._timeInterval.stop()
def _tick(self):
timeLeft = self._finishTime - BigWorld.serverTime()
if timeLeft >= 0:
self._setViewSnapshot(timeLeft)
else:
self.hide()
def _setViewSnapshot(self, timeLeft):
raise NotImplementedError
class PythonTimer(TimerComponent):
__slots__ = ('_timeInterval', '__weakref__')
def __init__(self, panel, typeID, viewID, totalTime):
super(PythonTimer, self).__init__(panel, typeID, viewID, totalTime)
self._timeInterval = TimeInterval(1.0, self, '_tick')
def clear(self):
self._timeInterval.stop()
super(PythonTimer, self).clear()
def _startTick(self):
if self._totalTime:
timeLeft = max(0, self._finishTime - BigWorld.serverTime())
if timeLeft:
self._setViewSnapshot(timeLeft)
self._timeInterval.start()
def _stopTick(self):
self._timeInterval.stop()
def _tick(self):
timeLeft = self._finishTime - BigWorld.serverTime()
if timeLeft >= 0:
self._setViewSnapshot(timeLeft)
else:
self.hide()
def _setViewSnapshot(self, timeLeft):
raise NotImplementedError
class _PythonTimer(_TimerComponent):
__slots__ = ('_timeInterval', '_startTime', '_finishTime', '__weakref__')
def __init__(self, panel, typeID, viewID, totalTime):
super(_PythonTimer, self).__init__(panel, typeID, viewID, totalTime)
self._timeInterval = TimeInterval(1.0, self, '_tick')
self._startTime = BigWorld.serverTime()
if totalTime:
self._finishTime = self._startTime + totalTime
else:
self._finishTime = 0
def clear(self):
self._timeInterval.stop()
super(_PythonTimer, self).clear()
def _startTick(self):
if self._totalTime:
timeLeft = max(0, self._finishTime - BigWorld.serverTime())
if timeLeft:
self._panel.as_setTimeSnapshotS(self._typeID, self._totalTime,
timeLeft)
self._timeInterval.start()
def _stopTick(self):
self._timeInterval.stop()
def _tick(self):
timeLeft = self._finishTime - BigWorld.serverTime()
if timeLeft >= 0:
self._panel.as_setTimeSnapshotS(self._typeID, self._totalTime,
timeLeft)
else:
self.hide()
def __init__(self, config):
self.__config = config
self.__panels = []
self.__isSetHandler = False
self.__visible = False
self.__crosshairPosition = [0, 0]
self.__onShoot = None
self.__onShot = None
self.__onShotResult = None
self.__intervalHandlers = Event()
self.__eventHandlers = Event()
self.__keyHandlers = {}
interval = config['common']['updateInterval']
self.__timeInterval = TimeInterval(interval, self, 'onWatchStats')
g_eventBus.addListener(events.AppLifeCycleEvent.INITIALIZED,
self.onAppInitialized)
g_eventBus.addListener(events.AppLifeCycleEvent.DESTROYED,
self.onAppDestroyed)
appLoader = dependency.instance(IAppLoader)
appLoader.onGUISpaceEntered += self.onGUISpaceEntered
appLoader.onGUISpaceLeft += self.onGUISpaceLeft
g_statsCollector.eventHandlers.clear()
def timeReload(self):
reload_orig = self.data['typeDescriptor'].gun['reloadTime']
crew = 0.94 if self.data['typeDescriptor'].miscAttrs[
'crewLevelIncrease'] != 0 else 1
if (self.data['typeDescriptor'].gun['clip'][0] == 1) and (
self.data['typeDescriptor'].miscAttrs['gunReloadTimeFactor'] !=
0):
rammer = self.data['typeDescriptor'].miscAttrs[
'gunReloadTimeFactor']
else:
rammer = 1
self.macros['timer'] = round(reload_orig * crew * rammer, 1)
self.currentTime = self.parser(
config.get('damageLog/timeReload/formatTimer'))
as_event('ON_TIMER_RELOAD')
self.finishTime = self.macros['timer'] + BigWorld.serverTime()
if (self.timerReloadAttacker
is not None) and (self.timerReloadAttacker.isStarted):
self.timerReloadAttacker.stop()
self.timerReloadAttacker = TimeInterval(0.1, self, 'currentTimeReload')
self.timerReloadAttacker.start()
def __init__(self):
"""
Constructor. Initializes internal variables.
"""
super(VehicleStateController, self).__init__()
self.__eManager = Event.EventManager()
self.onVehicleStateUpdated = Event.Event(self.__eManager)
self.onVehicleControlling = Event.Event(self.__eManager)
self.onPostMortemSwitched = Event.Event(self.__eManager)
self.onRespawnBaseMoving = Event.Event(self.__eManager)
self.__waitingTI = TimeInterval(VEHICLE_WAINING_INTERVAL, self, '_waiting')
self.__vehicleID = 0
self.__updater = None
self.__isRqToSwitch = False
return
def currentTimeReload(self):
self.data['timer'] = self.finishTime - BigWorld.serverTime()
timeTextAfterReload = float(config.get(self.section + 'timeTextAfterReload'))
if self.data['timer'] > 0:
macroes = getValueMacroes(self.section, self.data)
self.strTime = parser(config.get(self.section + 'formatTimer'), macroes)
else:
self.timerReloadAttacker.stop()
if timeTextAfterReload > 0:
self.timerReloadAttacker = TimeInterval(timeTextAfterReload, self, 'afterTimerReload')
macroes = getValueMacroes(self.section, self.data)
self.strTime = parser(config.get(self.section + 'formatTimerAfterReload'), macroes)
self.timerReloadAttacker.start()
else:
self.strTime = ''
as_event('ON_TIMER_RELOAD')
def output(self):
if (data.data['attackReasonID'] == 1) and config.get(self.section + 'groupDamagesFromFire'):
if data.data['fireStage'] == 0:
self.dataFire = data.data.copy()
macroes = getValueMacroes(self.section, self.dataFire)
self.strLastHit = parser(config.get(self.section + 'formatLastHit'), macroes)
elif data.data['fireStage'] in [1, 2]:
self.dataFire['damage'] += data.data['damage']
self.dataLog['dmgRatio'] = self.dataFire['damage'] * 100 // data.data['maxHealth']
macroes = getValueMacroes(self.section, self.dataFire)
self.strLastHit = parser(config.get(self.section + 'formatLastHit'), macroes)
elif (data.data['attackReasonID'] in [2, 3]) and config.get(self.section + 'groupDamagesFromRamming_WorldCollision'):
self.dataLog = data.data.copy()
attackerID = data.data['attackerID']
attackReasonID = data.data['attackReasonID']
if attackerID in self.dictVehicle:
if (attackReasonID in self.dictVehicle[attackerID] and
('time' in self.dictVehicle[attackerID][attackReasonID]) and
('damage' in self.dictVehicle[attackerID][attackReasonID]) and
((BigWorld.serverTime() - self.dictVehicle[attackerID][attackReasonID]['time']) < 1)):
self.dictVehicle[attackerID][attackReasonID]['time'] = BigWorld.serverTime()
self.dictVehicle[attackerID][attackReasonID]['damage'] += data.data['damage']
self.dataLog['damage'] = self.dictVehicle[attackerID][attackReasonID]['damage']
self.dataLog['dmgRatio'] = self.dataLog['damage'] * 100 // data.data['maxHealth']
else:
self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
'damage': data.data['damage']}
else:
self.dictVehicle[attackerID] = {}
self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
'damage': data.data['damage']}
macroes = getValueMacroes(self.section, self.dataLog)
self.strLastHit = parser(config.get(self.section + 'formatLastHit'), macroes)
else:
if config.get(self.section + 'showHitNoDamage') or data.data['isDamage']:
macroes = getValueMacroes(self.section, data.data)
self.strLastHit = parser(config.get(self.section + 'formatLastHit'), macroes)
else:
self.strLastHit = ''
if self.strLastHit:
if (self.timerLastHit is not None) and self.timerLastHit.isStarted:
self.timerLastHit.stop()
timeDisplayLastHit = float(config.get(self.section + 'timeDisplayLastHit'))
self.timerLastHit = TimeInterval(timeDisplayLastHit, self, 'hideLastHit')
self.timerLastHit.start()
as_event('ON_LAST_HIT')
return
class TimerReload(object):
def __init__(self):
self.strTime = ''
self.section = 'damageLog/timeReload/'
self.currentTime = 0
self.finishTime = 0
self.data = None
self.timerReloadAttacker = None
def reset(self):
self.strTime = ''
self.section = 'damageLog/timeReload/'
self.currentTime = 0
self.finishTime = 0
self.data = None
if (self.timerReloadAttacker is not None) and self.timerReloadAttacker.isStarted:
self.timerReloadAttacker.stop()
def afterTimerReload(self):
self.strTime = ''
if (self.timerReloadAttacker is not None) and self.timerReloadAttacker.isStarted:
self.timerReloadAttacker.stop()
as_event('ON_TIMER_RELOAD')
def currentTimeReload(self):
self.data['timer'] = self.finishTime - BigWorld.serverTime()
timeTextAfterReload = float(config.get(self.section + 'timeTextAfterReload'))
if self.data['timer'] > 0:
macroes = getValueMacroes(self.section, self.data)
self.strTime = parser(config.get(self.section + 'formatTimer'), macroes)
else:
self.timerReloadAttacker.stop()
if timeTextAfterReload > 0:
self.timerReloadAttacker = TimeInterval(timeTextAfterReload, self, 'afterTimerReload')
macroes = getValueMacroes(self.section, self.data)
self.strTime = parser(config.get(self.section + 'formatTimerAfterReload'), macroes)
self.timerReloadAttacker.start()
else:
self.strTime = ''
as_event('ON_TIMER_RELOAD')
def output(self):
if (data.data['attackReasonID'] == 0) and (data.data['timer'] > 0):
self.data = data.data.copy()
macroes = getValueMacroes(self.section, self.data)
self.strTime = parser(config.get(self.section + 'formatTimer'), macroes)
as_event('ON_TIMER_RELOAD')
self.finishTime = self.data['timer'] + BigWorld.serverTime()
if (self.timerReloadAttacker is not None) and (self.timerReloadAttacker.isStarted):
self.timerReloadAttacker.stop()
self.timerReloadAttacker = TimeInterval(0.1, self, 'currentTimeReload')
self.timerReloadAttacker.start()
def __setTipsInfo(self):
showFalloutEventInfo = False
arena = getClientArena()
if arena is not None:
showFalloutEventInfo = arena.guiType == constants.ARENA_GUI_TYPE.EVENT_BATTLES
if showFalloutEventInfo:
self.as_setEventInfoPanelDataS({'bgUrl': RES_ICONS.MAPS_ICONS_EVENTINFOPANEL_FALLOUTEVENT,
'items': FalloutInfoPanelHelper.getHelpTextAsDicts(arena.arenaType)})
elif self.__updateTipTI is None:
battlesCount = DEFAULT_BATTLES_COUNT
if g_lobbyContext.getBattlesCount() is not None:
battlesCount = g_lobbyContext.getBattlesCount()
arenaDP = self.__battleCtx.getArenaDP()
vType, vLvl, nation = arenaDP.getVehicleInfo().getTypeInfo()
self.__tipsGetter = tips.getTipsIterator(battlesCount, vType, nation, vLvl)
if self.__tipsGetter is not None:
self._updateTipsInfo()
self.__updateTipTI = TimeInterval(NEW_TIP_DURATION, self, '_updateTipsInfo')
self.__updateTipTI.start()
return
class LastHit(object):
def __init__(self, section):
self.dataFire = None
self.section = section
self.strLastHit = ''
self.timerLastHit = None
self.dictVehicle = {}
self.shadow = {}
self._data = None
_data = userprefs.get('DamageLog/lastHit', {'x': config.get(section + 'x'), 'y': config.get(section + 'y')})
self.x = _data['x']
self.y = _data['y']
as_callback("lastHit_mouseDown", self.mouse_down)
as_callback("lastHit_mouseUp", self.mouse_up)
as_callback("lastHit_mouseMove", self.mouse_move)
if (self.timerLastHit is not None) and self.timerLastHit.isStarted:
self.timerLastHit.stop()
def reset(self, section):
self.dataFire = None
self.section = section
self.strLastHit = ''
self.timerLastHit = None
self.dictVehicle = {}
self.shadow = {}
if (self.timerLastHit is not None) and self.timerLastHit.isStarted:
self.timerLastHit.stop()
userprefs.set('DamageLog/lastHit', {'x': self.x, 'y': self.y})
def mouse_down(self, _data):
if _data['buttonIdx'] == 0:
self._data = _data
def mouse_up(self, _data):
if _data['buttonIdx'] == 0:
self._data = None
def mouse_move(self, _data):
if self._data:
self.x += (_data['x'] - self._data['x'])
self.y += (_data['y'] - self._data['y'])
as_event('ON_LAST_HIT')
def hideLastHit (self):
self.strLastHit = ''
if (self.timerLastHit is not None) and self.timerLastHit.isStarted:
self.timerLastHit.stop()
as_event('ON_LAST_HIT')
def output(self):
if (((data.data['attackReasonID'] in [2, 3]) and config.get(self.section + 'groupDamagesFromRamming_WorldCollision'))
or ((data.data['attackReasonID'] == 1) and config.get(self.section + 'groupDamagesFromFire'))):
dataLog = data.data.copy()
attackerID = data.data['attackerID']
attackReasonID = data.data['attackReasonID']
if attackerID in self.dictVehicle:
if (attackReasonID in self.dictVehicle[attackerID] and
('time' in self.dictVehicle[attackerID][attackReasonID]) and
('damage' in self.dictVehicle[attackerID][attackReasonID]) and
((BigWorld.serverTime() - self.dictVehicle[attackerID][attackReasonID]['time']) < 1)):
self.dictVehicle[attackerID][attackReasonID]['time'] = BigWorld.serverTime()
self.dictVehicle[attackerID][attackReasonID]['damage'] += data.data['damage']
dataLog['damage'] = self.dictVehicle[attackerID][attackReasonID]['damage']
dataLog['dmgRatio'] = dataLog['damage'] * 100 // data.data['maxHealth']
else:
self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
'damage': data.data['damage']}
else:
self.dictVehicle[attackerID] = {}
self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
'damage': data.data['damage']}
macroes = getValueMacroes(self.section, dataLog)
self.strLastHit = parser(config.get(self.section + 'formatLastHit'), macroes)
else:
if config.get(self.section + 'showHitNoDamage') or data.data['isDamage']:
macroes = getValueMacroes(self.section, data.data)
self.strLastHit = parser(config.get(self.section + 'formatLastHit'), macroes)
else:
self.strLastHit = ''
if self.strLastHit:
if (self.timerLastHit is not None) and self.timerLastHit.isStarted:
self.timerLastHit.stop()
timeDisplayLastHit = float(parser(config.get(self.section + 'timeDisplayLastHit'), macroes))
self.timerLastHit = TimeInterval(timeDisplayLastHit, self, 'hideLastHit')
self.timerLastHit.start()
self.shadow = shadow_value(self.section, macroes)
as_event('ON_LAST_HIT')
return
def start(self):
self.__timeInterval = TimeInterval(self.__UPDATE_INTERVAL, self, '_DebugPanel__update')
self.__timeInterval.start()
self.__update()
class DebugPanel(UIInterface):
__UPDATE_INTERVAL = 0.01
def __init__(self, parentUI):
UIInterface.__init__(self)
self.__ui = parentUI
self.__timeInterval = None
self.__performanceStats = _PerformanceStats()
self.__performanceStats.populateUI(parentUI)
return
def start(self):
self.__timeInterval = TimeInterval(self.__UPDATE_INTERVAL, self, '_DebugPanel__update')
self.__timeInterval.start()
self.__update()
def destroy(self):
self.__performanceStats.disposeUI()
self.__performanceStats = None
self.__timeInterval.stop()
return
def __update(self):
player = BigWorld.player()
if player is None or not hasattr(player, 'playerVehicleID'):
return
else:
fps = 0
recordedFps = -1
ping = 0
isLaggingNow = False
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.fps > 0:
fps = BigWorld.getFPS()[1]
recordedFps = replayCtrl.fps
ping = replayCtrl.ping
isLaggingNow = replayCtrl.isLaggingNow
else:
isLaggingNow = player.filter.isLaggingNow
if not isLaggingNow:
for v in BigWorld.entities.values():
if _isVehicleEntity(v):
if not v.isPlayer:
if v.isAlive() and isinstance(v.filter, BigWorld.WGVehicleFilter) and v.filter.isLaggingNow:
isLaggingNow = True
break
ping = min(BigWorld.LatencyInfo().value[3] * 1000, 999)
if ping < 999:
ping = max(1, ping - 500.0 * constants.SERVER_TICK_LENGTH)
fpsInfo = BigWorld.getFPS()
from helpers.statistics import g_statistics
g_statistics.update(fpsInfo, ping, isLaggingNow)
fps = fpsInfo[1]
if replayCtrl.isRecording:
replayCtrl.setFpsPingLag(fps, ping, isLaggingNow)
try:
self.__performanceStats.updateDebugInfo(int(fps), int(ping), isLaggingNow, int(recordedFps))
except:
pass
return
class BattleLoading(LobbySubView, BattleLoadingMeta, IArenaController):
MAP_BG_SOURCE = 'gui/maps/icons/map/screen/%s.dds'
SMALL_MAP_SOURCE = '../maps/icons/map/battleLoading/%s.png'
def __init__(self, ctx = None):
super(BattleLoading, self).__init__(backAlpha=0.0)
self.__logArenaUniID = False
self.__battleCtx = None
self.__isArenaTypeDataInited = False
self.__updateTipTI = None
self.__tipsGetter = None
return
@storage_getter('users')
def usersStorage(self):
return None
def _populate(self):
super(BattleLoading, self)._populate()
g_sessionProvider.addArenaCtrl(self)
BigWorld.wg_updateColorGrading()
BigWorld.wg_enableGUIBackground(True, False)
self.__addArenaTypeData()
Waiting.close()
def _dispose(self):
Waiting.close()
g_sessionProvider.removeArenaCtrl(self)
BigWorld.wg_enableGUIBackground(False, True)
super(BattleLoading, self)._dispose()
self.__tipsGetter = None
if self.__updateTipTI:
self.__updateTipTI.stop()
self.__updateTipTI = None
return
def setBattleCtx(self, battleCtx):
self.__battleCtx = battleCtx
def invalidateArenaInfo(self):
arenaDP = self.__battleCtx.getArenaDP()
self.__setTipsInfo()
self.__addArenaExtraData(arenaDP)
self.__addPlayerData(arenaDP)
self.invalidateVehiclesInfo(arenaDP)
def invalidateVehiclesInfo(self, arenaDP):
regionGetter = self.__battleCtx.getRegionCode
isSpeaking = self.app.voiceChatManager.isPlayerSpeaking
userGetter = self.usersStorage.getUser
actionGetter = VehicleActions.getBitMask
playerTeam = arenaDP.getNumberOfTeam()
for isEnemy in (False, True):
result = []
for vInfoVO, _, _ in arenaDP.getTeamIterator(isEnemy):
result.append(self.__makeItem(vInfoVO, userGetter, isSpeaking, actionGetter, regionGetter, playerTeam, isEnemy))
self.as_setVehiclesDataS(isEnemy, result)
def addVehicleInfo(self, vo, arenaDP):
playerTeam = arenaDP.getNumberOfTeam()
isEnemy = vo.team != playerTeam
item = self.__makeItem(vo, self.usersStorage.getUser, self.app.voiceChatManager.isPlayerSpeaking, VehicleActions.getBitMask, self.__battleCtx.getRegionCode, playerTeam, isEnemy)
self.as_addVehicleInfoS(isEnemy, item, arenaDP.getVehiclesIDs(isEnemy))
def invalidateVehicleInfo(self, flags, vo, arenaDP):
playerTeam = arenaDP.getNumberOfTeam()
isEnemy = vo.team != playerTeam
if flags & INVALIDATE_OP.SORTING > 0:
vehiclesIDs = arenaDP.getVehiclesIDs(isEnemy)
else:
vehiclesIDs = None
item = self.__makeItem(vo, self.usersStorage.getUser, self.app.voiceChatManager.isPlayerSpeaking, VehicleActions.getBitMask, self.__battleCtx.getRegionCode, playerTeam, isEnemy)
self.as_updateVehicleInfoS(isEnemy, item, vehiclesIDs)
return
def invalidateVehicleStatus(self, flags, vo, arenaDP):
isEnemy = vo.team != arenaDP.getNumberOfTeam()
if flags & INVALIDATE_OP.SORTING > 0:
vehiclesIDs = arenaDP.getVehiclesIDs(isEnemy)
else:
vehiclesIDs = None
self.as_setVehicleStatusS(isEnemy, vo.vehicleID, vo.vehicleStatus, vehiclesIDs)
return
def invalidatePlayerStatus(self, flags, vo, arenaDP):
self.as_setPlayerStatusS(vo.team != arenaDP.getNumberOfTeam(), vo.vehicleID, vo.playerStatus)
def invalidateUsersTags(self):
self.invalidateVehiclesInfo(self.__battleCtx.getArenaDP())
def updateSpaceLoadProgress(self, progress):
self.as_setProgressS(progress)
def arenaLoadCompleted(self):
if not BattleReplay.isPlaying():
self.destroy()
else:
BigWorld.wg_enableGUIBackground(False, False)
def __makeItem(self, vInfoVO, userGetter, isSpeaking, actionGetter, regionGetter, playerTeam, isEnemy):
player = vInfoVO.player
vTypeVO = vInfoVO.vehicleType
dbID = player.accountDBID
user = userGetter(dbID)
if user:
isMuted = user.isMuted()
else:
isMuted = False
return {'accountDBID': dbID,
'isMuted': isMuted,
'isSpeaking': isSpeaking(dbID),
'vehicleID': vInfoVO.vehicleID,
'prebattleID': vInfoVO.prebattleID,
'vehicleStatus': vInfoVO.vehicleStatus,
'playerStatus': vInfoVO.getPlayerStatusInTeam(playerTeam=playerTeam),
'squadIndex': vInfoVO.squadIndex,
'vehicleAction': actionGetter(vInfoVO.events),
'vehicleIcon': vTypeVO.iconPath,
'vehicleName': vTypeVO.shortName,
'vehicleGuiName': vTypeVO.guiName,
'playerName': player.getPlayerLabel(),
'igrType': player.igrType,
'clanAbbrev': player.clanAbbrev,
'region': regionGetter(dbID)}
def __addArenaTypeData(self):
arena = getClientArena()
if arena:
arenaType = arena.arenaType
mapBG = arenaType.geometryName
if arena.guiType != constants.ARENA_GUI_TYPE.EVENT_BATTLES:
self.as_setMapNameS(arenaType.name)
elif arenaType.gameplayName in ('fallout', 'fallout2'):
mapBG += '_fallout'
BigWorld.wg_setGUIBackground(BattleLoading.MAP_BG_SOURCE % mapBG)
def _updateTipsInfo(self):
if self.__tipsGetter is not None:
statusStr, tipStr = next(self.__tipsGetter)
self.as_setTipTitleS(text_styles.highTitle(statusStr))
self.as_setTipS(text_styles.main(tipStr))
return
def __setTipsInfo(self):
showFalloutEventInfo = False
arena = getClientArena()
if arena is not None:
showFalloutEventInfo = arena.guiType == constants.ARENA_GUI_TYPE.EVENT_BATTLES
if showFalloutEventInfo:
self.as_setEventInfoPanelDataS({'bgUrl': RES_ICONS.MAPS_ICONS_EVENTINFOPANEL_FALLOUTEVENT,
'items': FalloutInfoPanelHelper.getHelpTextAsDicts(arena.arenaType)})
elif self.__updateTipTI is None:
battlesCount = DEFAULT_BATTLES_COUNT
if g_lobbyContext.getBattlesCount() is not None:
battlesCount = g_lobbyContext.getBattlesCount()
arenaDP = self.__battleCtx.getArenaDP()
vType, vLvl, nation = arenaDP.getVehicleInfo().getTypeInfo()
self.__tipsGetter = tips.getTipsIterator(battlesCount, vType, nation, vLvl)
if self.__tipsGetter is not None:
self._updateTipsInfo()
self.__updateTipTI = TimeInterval(NEW_TIP_DURATION, self, '_updateTipsInfo')
self.__updateTipTI.start()
return
def __addArenaExtraData(self, arenaDP):
arena = getClientArena()
if arena:
extraData = arena.extraData or {}
descExtra = getPrebattleFullDescription(extraData)
arenaTypeID = getArenaTypeID()
arenaSubType = getArenaSubTypeName(arenaTypeID)
team = arenaDP.getNumberOfTeam()
enemy = arenaDP.getNumberOfTeam(True)
hasBase = isBaseExists(arenaTypeID, team)
opponents = extraData.get('opponents', {})
team1 = opponents.get(str(team), {}).get('name', '#menu:loading/team1')
team2 = opponents.get(str(enemy), {}).get('name', '#menu:loading/team2')
self.as_setTeamsS(team1, team2)
if arena.guiType == constants.ARENA_GUI_TYPE.EVENT_BATTLES:
self.as_setWinTextS(i18n.makeString('#arenas:type/fallout/description'))
else:
self.as_setWinTextS(getBattleSubTypeWinText(arenaTypeID, 1 if hasBase else 2))
if descExtra:
self.as_setBattleTypeNameS(descExtra)
self.as_setBattleTypeFrameNumS(arena.guiType + 1)
elif arena.guiType in [constants.ARENA_GUI_TYPE.RANDOM, constants.ARENA_GUI_TYPE.TRAINING]:
self.as_setBattleTypeNameS('#arenas:type/%s/name' % arenaSubType)
self.as_setBattleTypeFrameNameS(getNecessaryArenaFrameName(arenaSubType, hasBase))
if arena.guiType == constants.ARENA_GUI_TYPE.TRAINING and self.__logArenaUniID == False:
self.__logArenaUniID = True
from time import strftime, localtime
from debug_utils import LOG_NOTE
LOG_NOTE('arenaUniqueID: %d | timestamp: %s' % (arena.arenaUniqueID, strftime('%d.%m.%Y %H:%M:%S', localtime())))
else:
self.as_setBattleTypeNameS('#menu:loading/battleTypes/%d' % arena.guiType)
if arena.guiType in constants.ARENA_GUI_TYPE_LABEL.LABELS:
self.as_setBattleTypeFrameNameS(constants.ARENA_GUI_TYPE_LABEL.LABELS[arena.guiType])
else:
self.as_setBattleTypeFrameNumS(arena.guiType + 1)
def __addPlayerData(self, arenaDP):
vInfoVO = arenaDP.getVehicleInfo()
self.as_setPlayerDataS(vInfoVO.vehicleID, vInfoVO.getSquadID())
class VehicleStateController(object):
def __init__(self):
super(VehicleStateController, self).__init__()
self.__eManager = Event.EventManager()
self.onVehicleStateUpdated = Event.Event(self.__eManager)
self.onVehicleControlling = Event.Event(self.__eManager)
self.onPostMortemSwitched = Event.Event(self.__eManager)
self.onRespawnBaseMoving = Event.Event(self.__eManager)
self.__waitingTI = TimeInterval(VEHICLE_WAINING_INTERVAL, self, '_waiting')
self.__updateTI = TimeInterval(VEHICLE_UPDATE_INTERVAL, self, '_update')
self.__vehicleID = 0
self.__updater = _PlayerVehicleUpdater()
self.__isRqToSwitch = False
def clear(self):
if self.__waitingTI:
self.__waitingTI.stop()
self.__waitingTI = None
if self.__updateTI:
self.__updateTI.stop()
self.__updateTI = None
self.__vehicleID = 0
self.__isRqToSwitch = False
self.__updater = None
self.__eManager.clear()
return
def setPlayerVehicle(self, vehicleID):
self.onVehicleStateUpdated(VEHICLE_VIEW_STATE.PLAYER_INFO, vehicleID)
self.__vehicleID = vehicleID
self.__waitingTI.start()
def getControllingVehicle(self):
vehicle = None
if self.__vehicleID:
vehicle = BigWorld.entity(self.__vehicleID)
return vehicle
def invalidate(self, state, value):
if state == VEHICLE_VIEW_STATE.DESTROYED:
self.__updateTI.stop()
self.onVehicleStateUpdated(state, value)
def switchToPostmortem(self):
self.__isRqToSwitch = False
if avatar_getter.getPlayerVehicleID() == self.__vehicleID:
self.__waitingTI.stop()
self.__updateTI.stop()
self.onPostMortemSwitched()
def switchToAnother(self, vehicleID):
if self.__vehicleID == vehicleID or vehicleID is None:
return
else:
if self.__updater:
self.__updater.clear()
self.__waitingTI.stop()
self.__updateTI.stop()
self.__vehicleID = vehicleID
self.__isRqToSwitch = True
self.onVehicleStateUpdated(VEHICLE_VIEW_STATE.PLAYER_INFO, self.__vehicleID)
self.__waitingTI.start()
return
def _waiting(self):
vehicle = BigWorld.entity(self.__vehicleID)
if vehicle is not None:
self.__waitingTI.stop()
self._setup(vehicle)
return
def _update(self):
states = self.__updater.update(self.__vehicleID, self.__updateTI)
if states is not None:
for item in states:
self.onVehicleStateUpdated(*item)
return
def _setup(self, vehicle):
self.__updater = self.__updater.switch(vehicle.isPlayer)
if self.__isRqToSwitch:
nationID = vehicle.typeDescriptor.type.id[0]
notifications = avatar_getter.getSoundNotifications()
if notifications:
notifications.clear()
SoundGroups.g_instance.soundModes.setCurrentNation(nations.NAMES[nationID])
self.onVehicleControlling(vehicle)
if not vehicle.isAlive():
self.onVehicleStateUpdated(VEHICLE_VIEW_STATE.DESTROYED, None)
else:
self.__updateTI.start()
return
class VehicleStateController(IBattleController):
"""
Class of controller that tracks specified vehicle on arena. At any time there is only one
instance of this class. When player's own vehicle is destroyed, controller can track other
vehicles on player's team.
The main goal of the controller to combine all knowledge about vehicle state changes and to
notify subscribers about that through appropriate events. The controller declares public
interface to know about changes. Triggers call these method to notify the controller about
specific changes that occur outside client. Also there is a list of changes that are triggered
directly by the controller via the updater. The updater tracks those parameters on which there
are no outside triggers or when required to control triggering frequency.
"""
def __init__(self):
"""
Constructor. Initializes internal variables.
"""
super(VehicleStateController, self).__init__()
self.__eManager = Event.EventManager()
self.onVehicleStateUpdated = Event.Event(self.__eManager)
self.onVehicleControlling = Event.Event(self.__eManager)
self.onPostMortemSwitched = Event.Event(self.__eManager)
self.onRespawnBaseMoving = Event.Event(self.__eManager)
self.__cachedStateValues = {}
self.__waitingTI = TimeInterval(VEHICLE_WAINING_INTERVAL, self, '_waiting')
self.__vehicleID = 0
self.__updater = None
self.__isRqToSwitch = False
self.__isInPostmortem = False
return
def getControllerID(self):
return BATTLE_CTRL_ID.OBSERVED_VEHICLE_STATE
def startControl(self):
pass
def stopControl(self):
"""
Clears internal variables and stops timers.
:return:
"""
if self.__waitingTI is not None:
self.__waitingTI.stop()
self.__waitingTI = None
if self.__updater is not None:
self.__updater.clear()
self.__updater = None
self.__vehicleID = 0
self.__isRqToSwitch = False
self.__isInPostmortem = False
self.__eManager.clear()
self.__cachedStateValues.clear()
return
@property
def isInPostmortem(self):
return self.__isInPostmortem
def setPlayerVehicle(self, vehicleID):
"""
Sets ID of player's own vehicle.
:param vehicleID: ID of vehicle entity
"""
self.notifyStateChanged(VEHICLE_VIEW_STATE.PLAYER_INFO, vehicleID)
self.__vehicleID = vehicleID
self.__updater = _VehicleUpdater(self, self.__vehicleID)
self.__waitingTI.start()
def getControllingVehicle(self):
"""
Gets entity of vehicle that is controlling.
:return: entity of vehicle or None
"""
vehicle = None
if self.__vehicleID:
vehicle = BigWorld.entity(self.__vehicleID)
return vehicle
def notifyStateChanged(self, stateID, value):
"""
Store the specified state value, and raise the event
:param stateID: id for state, listed within VEHICLE_VIEW_STATE
:param value: state value
"""
self.__cachedStateValues[stateID] = value
self.onVehicleStateUpdated(stateID, value)
def getStateValue(self, stateID):
"""
Returns the last value for the the desired state
:param stateID: id of state, listed within VEHICLE_VIEW_STATE
:return: None or state value
"""
if stateID in self.__cachedStateValues:
return self.__cachedStateValues[stateID]
else:
return None
return None
def invalidate(self, state, value, vehicleID = 0):
"""
Invalidates vehicle sates. The method should be invoked by vehicle state change trigger.
:param state: A state listed within VEHICLE_VIEW_STATE
:param value: New state value
:param vehicleID: ID of vehicle for which the given state is changed.
"""
if vehicleID != 0 and vehicleID != self.__vehicleID:
return
else:
isStateChangeHandled = False
if self.__updater is not None:
isStateChangeHandled = self.__updater.handleStateChange(state, value)
if not isStateChangeHandled:
self.notifyStateChanged(state, value)
return
def switchToPostmortem(self):
"""
Switches to postmortem mode.
"""
self.__isRqToSwitch = False
if avatar_getter.getPlayerVehicleID() == self.__vehicleID:
self.__waitingTI.stop()
if self.__updater is not None:
self.__updater.stop()
self.__isInPostmortem = True
self.onPostMortemSwitched()
return
def switchToOther(self, vehicleID):
"""
Switches to another vehicle.
:param vehicleID: ID of a new vehicle to be tracked.
"""
if self.__vehicleID == vehicleID or vehicleID is None:
return
else:
self.notifyStateChanged(VEHICLE_VIEW_STATE.SWITCHING, vehicleID)
self.__waitingTI.stop()
if self.__updater:
self.__updater.stop()
self.__vehicleID = vehicleID
self.__isRqToSwitch = True
self.notifyStateChanged(VEHICLE_VIEW_STATE.PLAYER_INFO, self.__vehicleID)
self.__waitingTI.start()
return
def movingToRespawn(self):
"""
Emits the appropriate event and state change event. The method should be called
when the vehicle is moved to respawn.
:return:
"""
self.notifyStateChanged(VEHICLE_VIEW_STATE.SWITCHING, 0)
self.onRespawnBaseMoving()
def _waiting(self):
"""
Callback to be invoked when the waiting timer is elapsed. Starts the updater when the
avatar has been switched to the required vehicle.
"""
vehicle = BigWorld.entity(self.__vehicleID)
if vehicle is not None:
self.__waitingTI.stop()
self._setup(vehicle)
return
def _setup(self, vehicle):
"""
Set up the updater and other properties
:param vehicle: Vehicle entity.
"""
if self.__updater is not None:
self.__updater = self.__updater.switch(self.__vehicleID)
if self.__isRqToSwitch:
nationID = vehicle.typeDescriptor.type.id[0]
notifications = avatar_getter.getSoundNotifications()
if notifications is not None:
notifications.clear()
SoundGroups.g_instance.soundModes.setCurrentNation(nations.NAMES[nationID])
self.onVehicleControlling(vehicle)
if not vehicle.isAlive():
self.notifyStateChanged(VEHICLE_VIEW_STATE.DESTROYED, None)
elif self.__updater is not None:
self.__updater.start()
return
def startControl(self):
self._timeInterval = TimeInterval(_UPDATE_INTERVAL, self, '_update')
self._timeInterval.start()
def start(self):
self._interval = TimeInterval(_TARGET_UPDATE_INTERVAL, self, '_update')
ctrl = g_sessionProvider.shared.crosshair
raise ctrl is not None or AssertionError('Crosshair controller is not found')
ctrl.onCrosshairViewChanged += self._onCrosshairViewChanged
return
class _EngineStateHandler(_StateHandler):
"""
The class provides logic to track engine state changes and vehicle movement changes.
All logic is based on changes of the current gear.
"""
__slots__ = ('__weakref__', '__gear', '__vehMoveAnimTimer', '__engineStartAnimTimer')
def __init__(self, updater, vehicle):
"""
Constructor. Initializes internal variables based on vehicle state.
:param updater: An instance of _VehicleUpdater class, that creates this handler.
:param vehicle: Vehicle to be tracked.
:return:
"""
super(_EngineStateHandler, self).__init__(updater)
self.__gear = vehicle.appearance.gear if vehicle is not None else _STOPPED_ENGINE_GEAR
self.__vehMoveAnimTimer = TimeInterval(_VEHICLE_ANIM_DURATION, self, '_stopVehMoveAnim')
self.__engineStartAnimTimer = TimeInterval(_VEHICLE_ANIM_DURATION, self, '_stopEngineStartAnim')
return
def clear(self):
"""
Resets internal variables.
"""
self.__gear = _STOPPED_ENGINE_GEAR
self._stopVehMoveAnim()
self._stopEngineStartAnim()
def _invalidate(self, vehicle):
"""
The method determines whether one of the following events has occurred and exposes the
appropriate state change to the updater:
1. Vehicle starts moving.
2. Engine is started.
By these events, appropriate animations are run on UI. To stop animations appropriate state
change event is sent in _VEHICLE_ANIM_DURATION time. Note that animation duration depends
on sound effect (track length). But right now there is no way to determine effect duration.
Therefore for all vehicles the same constant is used.
:param vehicle: A reference to the tracked vehicle(BW entity).
:return: The state change if any. Otherwise an empty list.
"""
states = []
gear = vehicle.appearance.gear
if self.__gear != gear:
if not self.__gear and gear > 0:
if not self.__vehMoveAnimTimer.isStarted():
states.append((VEHICLE_VIEW_STATE.VEHICLE_MOVEMENT_STATE, True))
self.__vehMoveAnimTimer.start()
elif self.__gear == _STOPPED_ENGINE_GEAR and gear >= 0:
if not self.__engineStartAnimTimer.isStarted():
states.append((VEHICLE_VIEW_STATE.VEHICLE_ENGINE_STATE, True))
self.__engineStartAnimTimer.start()
elif self.__gear > 0 and not self.__gear:
pass
elif self.__gear >= 0 and gear == _STOPPED_ENGINE_GEAR:
pass
self.__gear = gear
return states
def _stopVehMoveAnim(self):
"""
Stops 'vehicle start' animation by sending the appropriate event.
"""
if self.__vehMoveAnimTimer.isStarted():
self.__vehMoveAnimTimer.stop()
self.notifyStateChanged(VEHICLE_VIEW_STATE.VEHICLE_MOVEMENT_STATE, False)
def _stopEngineStartAnim(self):
"""
Stops 'engine start' animation by sending the appropriate event.
"""
if self.__engineStartAnimTimer.isStarted():
self.__engineStartAnimTimer.stop()
self.notifyStateChanged(VEHICLE_VIEW_STATE.VEHICLE_ENGINE_STATE, False)
class LastHit(_Base):
def __init__(self, section):
_Base.__init__(self, section)
self.strLastHit = ''
if config.get(self.section + 'moveInBattle'):
_data = userprefs.get('DamageLog/lastHit', {'x': config.get(section + 'x'), 'y': config.get(section + 'y')})
as_callback("lastHit_mouseDown", self.mouse_down)
as_callback("lastHit_mouseUp", self.mouse_up)
as_callback("lastHit_mouseMove", self.mouse_move)
else:
_data = {'x': config.get(section + 'x'), 'y': config.get(section + 'y')}
self.x = _data['x']
self.y = _data['y']
self.timerLastHit = None
def reset(self):
_Base.reset(self)
self.strLastHit = ''
if (self.timerLastHit is not None) and self.timerLastHit.isStarted:
self.timerLastHit.stop()
if (None not in [self.x, self.y]) and config.get(self.section + 'moveInBattle'):
userprefs.set('DamageLog/lastHit', {'x': self.x, 'y': self.y})
def mouse_move(self, _data):
self._mouse_move(_data, 'ON_LAST_HIT')
def hideLastHit(self):
self.strLastHit = ''
if (self.timerLastHit is not None) and self.timerLastHit.isStarted:
self.timerLastHit.stop()
as_event('ON_LAST_HIT')
def output(self):
macroes = None
if (((data.data['attackReasonID'] in [2, 3]) and config.get(self.section + 'groupDamagesFromRamming_WorldCollision'))
or ((data.data['attackReasonID'] == 1) and config.get(self.section + 'groupDamagesFromFire'))):
dataLog = data.data.copy()
attackerID = data.data['attackerID']
attackReasonID = data.data['attackReasonID']
if attackerID in self.dictVehicle:
if attackReasonID in self.dictVehicle[attackerID]:
key = self.dictVehicle[attackerID][attackReasonID]
if ('time' in key) and ('damage' in key) and ((BigWorld.serverTime() - key['time']) < 1):
key['time'] = BigWorld.serverTime()
key['damage'] += data.data['damage']
dataLog['damage'] = key['damage']
dataLog['dmgRatio'] = dataLog['damage'] * 100 // data.data['maxHealth']
if (attackReasonID == 1) and (key['beginFire'] is not None):
dataLog['fireDuration'] = BigWorld.time() - key['beginFire']
else:
dataLog['fireDuration'] = None
else:
self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
'damage': data.data['damage'],
'beginFire': beginFire if attackReasonID == 1 else None}
dataLog['fireDuration'] = BigWorld.time() - beginFire if attackReasonID == 1 else None
else:
self.dictVehicle[attackerID] = {}
self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
'damage': data.data['damage'],
'beginFire': beginFire if attackReasonID == 1 else None}
dataLog['fireDuration'] = BigWorld.time() - beginFire if attackReasonID == 1 else None
macroes = getValueMacroes(self.section, dataLog)
self.strLastHit = parser(config.get(self.section + 'formatLastHit'), macroes)
if not config.get(self.section + 'moveInBattle'):
self.x = parser(config.get(self.section + 'x'), macroes)
self.y = parser(config.get(self.section + 'y'), macroes)
else:
if config.get(self.section + 'showHitNoDamage') or data.data['isDamage']:
macroes = getValueMacroes(self.section, data.data)
self.strLastHit = parser(config.get(self.section + 'formatLastHit'), macroes)
if not config.get(self.section + 'moveInBattle'):
self.x = parser(config.get(self.section + 'x'), macroes)
self.y = parser(config.get(self.section + 'y'), macroes)
else:
self.strLastHit = ''
if self.strLastHit:
if macroes is None:
macroes = getValueMacroes(self.section, data.data)
if (self.timerLastHit is not None) and self.timerLastHit.isStarted:
self.timerLastHit.stop()
timeDisplayLastHit = float(parser(config.get(self.section + 'timeDisplayLastHit'), macroes))
self.timerLastHit = TimeInterval(timeDisplayLastHit, self, 'hideLastHit')
self.timerLastHit.start()
self.shadow = shadow_value(self.section, macroes)
as_event('ON_LAST_HIT')
class _VehicleUpdater(object):
"""
The class implements logic for tracking changes of vehicle parameters in equal time intervals.
It encapsulates different algorithms of tracking based on vehicle type. The inner logic is
based on the custom state handlers (classes derived from _StateHandler).
"""
def __init__(self, vehCtrl, vehicleID):
"""
Constructor. Initializes internal variables.
:param vehCtrl: Reference to vehicle state controller owning this updater.
:param vehicleID: Unique identifier of vehicle to be tracked
"""
super(_VehicleUpdater, self).__init__()
self.__isAlive = True
self.__handlers = None
self.__ctrl = weakref.proxy(vehCtrl)
self.__vehicleID = vehicleID
self.__updateTI = None
self._setUpHandlers()
return
def handleStateChange(self, state, value):
"""
Represents a hook to catch states changes before the vehicle state controller propagates
them to subscribers. Redirects the call to each handler to perform required logic.
:param state: A state listed within VEHICLE_VIEW_STATE
:param value: State value
:return: True if any handler returns True. Otherwise - False.
"""
isStateHandled = False
for handler in self.__handlers:
isStateHandled |= handler.handleStateChange(state, value)
return isStateHandled
def switch(self, vehicleID):
"""
Switches the updater to another vehicle: reset internal states and handlers.
:param vehicleID: Unique identifier of a new vehicle that will be tracked
"""
self.clear()
self.__vehicleID = vehicleID
self._setUpHandlers()
return self
def start(self):
"""
Sets up and starts the timer to invalidate handlers.
"""
if self.__updateTI is None:
self.__updateTI = TimeInterval(VEHICLE_UPDATE_INTERVAL, self, '_update')
self.__updateTI.start()
return
def stop(self):
"""
Stops and clears running timer (if any).
"""
if self.__updateTI is not None:
self.__updateTI.stop()
self.__updateTI = None
return
def clear(self):
"""
Clears internal variables and stops timer.
"""
self.stop()
if self.__handlers is not None:
for handler in self.__handlers:
handler.clear()
self.__handlers = None
self.__vehicleID = None
return
def notifyStateChanged(self, state, value):
"""
The helper method to provide handler ability to notify subscribers about changes of
vehicle's states through the vehicle state controller.
:param state: A state listed within VEHICLE_VIEW_STATE
:param value: State value.
"""
self.__ctrl.notifyStateChanged(state, value)
def _update(self):
"""
Callback on timer tick event. Initiates invalidation of all handlers, get all states
changes and redirects them to the vehicle state controller by emitting appropriate events.
"""
states = []
vehicle = BigWorld.entity(self.__vehicleID)
if vehicle is not None and vehicle.isStarted:
if not vehicle.isAlive() and self.__isAlive:
self.__isAlive = False
states.append((VEHICLE_VIEW_STATE.DESTROYED, None))
for handler in self.__handlers:
newStates = handler(vehicle)
states.extend(newStates)
for item in states:
self.notifyStateChanged(*item)
return
def _setUpHandlers(self):
"""
Determines a list of handlers based on vehicle type and sets up them.
"""
vehicle = BigWorld.entity(self.__vehicleID)
if vehicle is not None:
isPlayerVehicle = vehicle.isPlayerVehicle
if isPlayerVehicle:
self.__handlers = (_SpeedStateHandler(self, True), _RpmStateHandler(self, vehicle), _EngineStateHandler(self, vehicle))
else:
self.__handlers = (_HealthStateHandler(self),
_SpeedStateHandler(self, False),
_RpmStateHandler(self, vehicle),
_EngineStateHandler(self, vehicle))
return
def _createTimer(self, nextActionTime):
self._nextTime = nextActionTime
self._timer = TimeInterval(1, self, '_updateTime')
self._timer.start()
