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
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): """ 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): 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 (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 _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
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()