def groupDamages(self):
isGroupRamming_WorldCollision = (data.data['attackReasonID'] in [2, 3]) and config.get(self.S_GROUP_DAMAGE_RAMMING_COLLISION)
isGroupFire = (data.data['attackReasonID'] == 1) and config.get(self.S_GROUP_DAMAGE_FIRE)
if isGroupRamming_WorldCollision or isGroupFire:
dataLog = data.data.copy()
attackerID = dataLog['attackerID']
attackReasonID = dataLog['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'] += dataLog['damage']
dataLog['damage'] = key['damage']
dataLog['dmgRatio'] = dataLog['damage'] * 100 // dataLog['maxHealth']
dataLog['fireDuration'] = BigWorld.time() - key['startAction'] if (attackReasonID == 1) and (key['startAction'] is not None) else None
dataLog['hitTime'] = key['hitTime']
else:
self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
'damage': dataLog['damage'],
'startAction': BigWorld.time() if attackReasonID == 1 else None,
'hitTime': dataLog['hitTime']}
dataLog['fireDuration'] = 0 if attackReasonID == 1 else None
else:
self.dictVehicle[attackerID] = {}
self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
'damage': dataLog['damage'],
'startAction': BigWorld.time() if attackReasonID == 1 else None,
'hitTime': dataLog['hitTime']}
dataLog['fireDuration'] = 0 if attackReasonID == 1 else None
self.setOutParameters(dataLog)
else:
self.setOutParameters(data.data)
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'))):
self.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 ('numberLine' in key) and ((BigWorld.serverTime() - key['time']) < 1.0):
key['time'] = BigWorld.serverTime()
key['damage'] += data.data['damage']
key['criticalHit'] = (key['criticalHit'] or data.data['criticalHit'])
if key['damage'] > 0:
self.dataLog['hitEffect'] = 'armor_pierced'
self.dataLog['criticalHit'] = key['criticalHit']
self.dataLog['damage'] = key['damage']
self.dataLog['dmgRatio'] = self.dataLog['damage'] * 100 // data.data['maxHealth']
self.dataLog['number'] = len(self.listLog)
if (attackReasonID == 1) and (key['beginFire'] is not None):
self.dataLog['fireDuration'] = BigWorld.time() - key['beginFire']
else:
self.dataLog['fireDuration'] = None
macroes = getValueMacroes(self.section, self.dataLog)
self.listLog[key['numberLine']] = parser(config.get(self.section + 'formatHistory'), 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)
self.shadow = shadow_value(self.section, macroes)
else:
self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
'damage': data.data['damage'],
'criticalHit': data.data['criticalHit'],
'numberLine': 0,
'beginFire': beginFire if attackReasonID == 1 else None}
self.addLine(attackerID, attackReasonID)
else:
self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
'damage': data.data['damage'],
'criticalHit': data.data['criticalHit'],
'numberLine': 0,
'beginFire': beginFire if attackReasonID == 1 else None}
self.addLine(attackerID, attackReasonID)
else:
self.dictVehicle[attackerID] = {}
self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
'damage': data.data['damage'],
'criticalHit': data.data['criticalHit'],
'numberLine': 0,
'beginFire': beginFire if attackReasonID == 1 else None}
self.addLine(attackerID, attackReasonID)
if self.callEvent:
as_event('ON_HIT')
else:
if config.get(self.section + 'showHitNoDamage') or data.data['isDamage']:
self.dataLog = data.data
self.addLine(None, None)
if self.callEvent:
as_event('ON_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')
def addClientMessage(Message):
global lastMessageTime
if len(Message) == 0:
return
if lastMessageTime is None:
lastMessageTime = BigWorld.serverTime()
MessengerEntry.g_instance.gui.addClientMessage(Message)
elif (BigWorld.serverTime() - lastMessageTime) > 3:
lastMessageTime = BigWorld.serverTime()
MessengerEntry.g_instance.gui.addClientMessage(Message)
else:
return
def __startAttack(self, alreadyStarted = False):
curTime = BigWorld.serverTime()
endTime = self.__startTime + self.__gasAttackSettings.preparationPeriod + self.__gasAttackSettings.compressionTime
self.delayCallback(endTime - curTime, self.__stopAttack)
if _ENABLE_DEBUG_LOG:
LOG_DEBUG('===Gas attack LAUNCHED! At %f, windup delay %f===' % (BigWorld.serverTime(), BigWorld.serverTime() - self.__windupTime))
self.__windupTime = BigWorld.serverTime()
self.__state = GasAttackState.ATTACK
if not alreadyStarted:
pass
self.__cloud = GasCloud(self.__mapSettings, self.__startTime + self.__gasAttackSettings.preparationPeriod, self.__gasAttackSettings, self.__cloudModelResource)
self.onAttackStarted()
def output(self):
if (data.data['attackReasonID'] == 1) and config.get(self.section + 'groupDamagesFromFire'):
if data.data['fireStage'] == 0:
self.dataLogFire = data.data.copy()
self.numberLine = 0
self.dataLogFire['number'] = '{:>2}'.format(len(self.listLog) + 1)
macroes = getValueMacroes(self.section, self.dataLogFire)
self.listLog.insert(0, parser(config.get(self.section + 'formatHistory'), macroes))
# self.addLine(None, None)
elif data.data['fireStage'] in [1, 2]:
self.dataLogFire['damage'] += data.data['damage']
self.dataLogFire['dmgRatio'] = self.dataLogFire['damage'] * 100 // data.data['maxHealth']
macroes = getValueMacroes(self.section, self.dataLogFire)
self.listLog[self.numberLine] = parser(config.get(self.section + 'formatHistory'), 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']
self.dataLog['number'] = '{:>2}'.format(len(self.listLog))
numberLine = self.dictVehicle[attackerID][attackReasonID]['numberLine']
macroes = getValueMacroes(self.section, self.dataLog)
self.listLog[numberLine] = parser(config.get(self.section + 'formatHistory'), macroes)
else:
self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
'damage': data.data['damage'],
'numberLine': 0}
self.addLine(attackerID, attackReasonID)
else:
self.dictVehicle[attackerID] = {}
self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
'damage': data.data['damage'],
'numberLine': 0}
self.addLine(attackerID, attackReasonID)
else:
if config.get(self.section + 'showHitNoDamage') or data.data['isDamage']:
self.dataLog = data.data
self.addLine(None, None)
as_event('ON_HIT')
return
def __startTimer(self):
self.__timerCallback = None
respawnTime = self.__respawnInfo.respawnTime
timeLeft = max(0, respawnTime - BigWorld.serverTime())
self.__ui.updateTimer(timeLeft, self.__vehicles, self.__cooldowns)
if timeLeft > 0:
self.__timerCallback = BigWorld.callback(1, self.__startTimer)
def action(self, repairPointIndex, action, nextActionTime):
if self.__ui is None:
return
else:
timeLeft = max(0, nextActionTime - BigWorld.serverTime())
if action in (REPAIR_POINT_ACTION.START_REPAIR, REPAIR_POINT_ACTION.RESTART_REPAIR):
self.__ui.call('repairTimer.show', [timeLeft,
self.__REPAIR_STATE.PROGRESS,
INGAME_GUI.REPAIRPOINT_TITLE,
None])
elif action == REPAIR_POINT_ACTION.COMPLETE_REPAIR:
self.__ui.call('repairTimer.show', [timeLeft,
self.__REPAIR_STATE.COOLDOWN,
INGAME_GUI.REPAIRPOINT_TITLE,
INGAME_GUI.REPAIRPOINT_UNAVAILABLE])
SoundGroups.g_instance.playSound2D(self.__REPAIR_SOUND_NAME)
elif action == REPAIR_POINT_ACTION.ENTER_WHILE_CD:
self.__ui.call('repairTimer.show', [timeLeft,
self.__REPAIR_STATE.COOLDOWN,
INGAME_GUI.REPAIRPOINT_TITLE,
INGAME_GUI.REPAIRPOINT_UNAVAILABLE])
elif action in (REPAIR_POINT_ACTION.LEAVE_WHILE_CD, REPAIR_POINT_ACTION.CANCEL_REPAIR):
self.__ui.call('repairTimer.hide')
self.onRepairPointStateChanged(repairPointIndex, action, timeLeft)
return
def _makeData(self):
result = []
arenaDP = g_sessionProvider.getArenaDP()
for pointID, point in g_ctfManager.getResourcePoints():
pointState = point['state']
timeLeft = ''
amount = point['amount']
progress = float(amount) / point['totalAmount'] * 100
if pointState == RESOURCE_POINT_STATE.FREE:
state = _POINTS_STATE.READY
elif pointState == RESOURCE_POINT_STATE.COOLDOWN:
self.__plugin.setUpdateRequired(True)
state = _POINTS_STATE.COOLDOWN
timeDelta = max(0, point['cooldownTime'] - BigWorld.serverTime())
timeLeft = time_utils.getTimeLeftFormat(timeDelta)
elif pointState == RESOURCE_POINT_STATE.CAPTURED:
state = _CAPTURE_STATE_BY_TEAMS[arenaDP.isAllyTeam(point['team'])]
elif pointState == RESOURCE_POINT_STATE.CAPTURED_LOCKED:
state = _CAPTURE_FROZEN_STATE_BY_TEAMS[arenaDP.isAllyTeam(point['team'])]
elif pointState == RESOURCE_POINT_STATE.BLOCKED:
state = _POINTS_STATE.CONFLICT
else:
state = _POINTS_STATE.FREEZE
result.append(self._makeItem(progress, state, amount, timeLeft))
return result
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
def __onDroppedToGround(self, flagID, flagTeam, loserVehicleID, flagPos, respawnTime):
flagType = self.__getFlagMarkerType(flagID, flagTeam)
self._parentObj.updateFlagbearerState(loserVehicleID, False)
self.__addFlagMarker(flagID, flagPos, flagType)
timer = respawnTime - BigWorld.serverTime()
self.__initTimer(int(math.ceil(timer)), flagID)
if loserVehicleID == BigWorld.player().playerVehicleID:
self.__delCaptureMarkers()
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 setInAoI(self, isInAoI):
"""
Set vehicle in area of interactive.
:param isInAoI: bool.
:return: True if property is changed, otherwise - False.
"""
if self._isInAoI != isInAoI:
self._isInAoI = isInAoI
if self._isInAoI:
if self._classTag == 'SPG':
self._spottedTime = BigWorld.serverTime()
self._spottedCount += 1
elif self._classTag != 'SPG':
self._spottedTime = BigWorld.serverTime()
return True
else:
return False
def __showMarkerCallback(self, eq, pos, dir, time, areaUID):
timer = round(time - BigWorld.serverTime())
area = self.__selectedAreas.pop(areaUID, None)
if area is not None:
area.destroy()
self.__selectedAreas[areaUID] = self.createEquipmentSelectedArea(pos, dir, eq)
self.__callbackDelayer.delayCallback(timer, functools.partial(self.__delayedAreaDestroy, areaUID))
g_sessionProvider.getEquipmentsCtrl().showMarker(eq, pos, dir, timer)
def __startPreparation(self, alreadyStarted = False):
g_ctfManager.hideAll()
self.__state = GasAttackState.PREPARE
attackTime = self.__startTime + self.__gasAttackSettings.preparationPeriod
curTime = BigWorld.serverTime()
timeDelta = attackTime - curTime
if timeDelta <= 0.001:
self.__startAttack(alreadyStarted)
else:
self.delayCallback(timeDelta, self.__startAttack)
if alreadyStarted and curTime - self.__startTime > GasAttackManager._ALLOWED_ACTIVITIES_LAG:
return
if _ENABLE_DEBUG_LOG:
LOG_DEBUG('===Gas attack preparation started at %f, windup delay %f===' % (BigWorld.serverTime(), BigWorld.serverTime() - self.__windupTime))
self.__windupTime = BigWorld.serverTime()
for mapActivity in self.__mapSettings.mapActivities:
MapActivities.startActivity(mapActivity)
self.onAttackPreparing()
def __onSetArenaTime(self, *args):
self.__timerCallBackId = None
arena = getattr(BigWorld.player(), 'arena', None)
if not g_sessionProvider.getCtx().isInBattle or arena is None:
return
arenaLength = int(arena.periodEndTime - BigWorld.serverTime())
arenaLength = arenaLength if arenaLength > 0 else 0
self.call('battle.timerBar.setTotalTime', [arenaLength])
if arenaLength > 1:
self.__timerCallBackId = BigWorld.callback(1, self.__onSetArenaTime)
def __arenaPeriodChanged(self, *args):
period = BigWorld.player().arena.period
if period != self.__prevArenaPeriod and period == ARENA_PERIOD.PREBATTLE:
if period == ARENA_PERIOD.PREBATTLE:
self.__mode = DetailedEngineState.__STOPPED
self.__prevArenaPeriod = period
time = uniform(0.0, (BigWorld.player().arena.periodEndTime - BigWorld.serverTime()) * 0.7)
self.__startEngineCbk = BigWorld.callback(time, self.__startEngineFunc)
elif period == ARENA_PERIOD.BATTLE:
self.__starting = False
def __updateFreeze(self):
lock = g_ctfManager.getResourcePointLock()
if lock is not None:
timeDelta = max(0, g_ctfManager.getResourcePointLock() - BigWorld.serverTime())
else:
timeDelta = 0
timeStr = time_utils.getTimeLeftFormat(timeDelta)
if self.__resourceIndicator is not None:
self.__resourceIndicator.setFreeze(True, timeStr)
self.__initFreezeCallback()
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 start(self, ui, battleProxy):
self.__ui = weakref.proxy(ui)
self.__battle = battleProxy
if self.__gasAttackMgr is not None:
self.__gasAttackMgr.onAttackPreparing += self.__onGasAttack
self.__gasAttackMgr.onAttackStarted += self.__onGasAttack
if self.__respawnInfo is not None:
if self.__respawnInfo.respawnTime > BigWorld.serverTime():
self.__show()
else:
self.__respawnInfo = None
return
def getActualSpottedCount(self):
"""
Update count of spotted if time is expired.
:return: integer containing updated count of spotted.
"""
expiryTime = BigWorld.serverTime() + settings.MINIMAP_WAS_SPOTTED_RESET_DELAY
if self._spottedTime is not None and self._spottedTime <= expiryTime:
if self._isInAoI and self._isActive:
self._spottedCount = 1
else:
self._spottedCount = 0
return self._spottedCount
def __showIfReady(self, needCooldown):
if self.__respawnInfo is None or self.__ui is None:
return
else:
if self.__respawnInfo.respawnTime > BigWorld.serverTime():
if needCooldown:
self.__showUICallback = BigWorld.callback(_SHOW_UI_COOLDOWN, self.__show)
else:
self.__show()
else:
self.__respawnInfo = None
return
def showHittingArea(self, equipmentID, pos, dir, time):
if _ENABLE_DEBUG_LOG:
LOG_DEBUG('===== showHittingArea =====')
LOG_DEBUG(equipmentID)
LOG_DEBUG(pos, dir, time)
areaUID = int(equipmentID)
if areaUID in self.__selectedAreas:
return
eq = vehicles.g_cache.equipments()[equipmentID]
timer = round(time - BigWorld.serverTime())
self.__selectedAreas[areaUID] = self.createEquipmentSelectedArea(pos, dir, eq)
self.__callbackDelayer.delayCallback(timer, functools.partial(self.__delayedAreaDestroy, areaUID))
g_sessionProvider.getEquipmentsCtrl().showMarker(eq, pos, dir, timer)
def launchScenario(self, startTime = None, gasAttackSettings = None):
if self.__gasAttackSettings is not None:
LOG_DEBUG('Already started gas attack at %f with settings %s' % (self.__startTime, self.__gasAttackSettings))
return
else:
if gasAttackSettings is None:
startTime, gasAttackSettings = _getDefaultScenario()
self.__startTime = startTime
if _ENABLE_DEBUG_LOG:
self.__windupTime = BigWorld.serverTime()
LOG_DEBUG('===Gas attack launch order received at %f===\n%s\n======' % (self.__windupTime, gasAttackSettings))
self.stopCallback(self.__startPreparation)
self.stopCallback(self.__startAttack)
self.__gasAttackSettings = gasAttackSettings
self.__state = GasAttackState.NO
curTime = BigWorld.serverTime()
if curTime < self.__startTime:
self.delayCallback(self.__startTime - curTime, self.__startPreparation)
else:
self.__startPreparation(True)
self.__soundMgr = GasSoundManager(self.__mapSettings.soundSettings)
self.__soundMgr.playAlarm()
return
def __arenaPeriodChanged(self, *args):
period = BigWorld.player().arena.period
if period != self.__prevArenaPeriod and period == ARENA_PERIOD.PREBATTLE:
self._mode = DetailedEngineState._STOPPED
self.__prevArenaPeriod = period
maxTime = BigWorld.player().arena.periodEndTime - BigWorld.serverTime()
maxTime = maxTime * 0.7 if maxTime > 0.0 else 1.0
time = uniform(0.0, maxTime)
self.__startEngineCbk = BigWorld.callback(time, self.__startEngineFunc)
elif period == ARENA_PERIOD.BATTLE:
if self.__startEngineCbk is None and self._mode == DetailedEngineState._STOPPED:
self.onEngineStart()
self.__starting = False
return
def __showMarkerCallback(self, eq, pos, dir, time, areaUID):
timer = round(time - BigWorld.serverTime())
area = self.__selectedAreas.pop(areaUID, None)
if area is not None:
area.destroy()
self.__selectedAreas[areaUID] = self.createEquipmentSelectedArea(pos, dir, eq)
area = self.__selectedAreas[areaUID]
if area is not None:
area.setGUIVisible(self.__isGUIVisible)
self.__callbackDelayer.delayCallback(timer, functools.partial(self.__delayedAreaDestroy, areaUID))
ctrl = g_sessionProvider.shared.equipments
if ctrl is not None:
ctrl.showMarker(eq, pos, dir, timer)
return
def __init__(self, entryID, active, matrix = None, location = VEHICLE_LOCATION.UNDEFINED):
super(VehicleEntry, self).__init__(entryID, active, matrix=matrix)
self._isInAoI = False
self._isEnemy = True
self._classTag = None
self._guiLabel = ''
self._isAlive = True
self._location = location
if active:
self._spottedCount = 1
self._spottedTime = BigWorld.serverTime()
else:
self._spottedCount = 0
self._spottedTime = None
return
def output(self):
if config.get(self.S_SHOW_HIT_NO_DAMAGE) or data.data['isDamage']:
self.reset_scrolling()
isGroupRamming_WorldCollision = (data.data['attackReasonID'] in [2, 3]) and config.get(self.S_GROUP_DAMAGE_RAMMING_COLLISION)
isGroupFire = (data.data['attackReasonID'] == 1) and config.get(self.S_GROUP_DAMAGE_FIRE)
if isGroupRamming_WorldCollision or isGroupFire:
self.dataLog = data.data.copy()
attackerID = self.dataLog['attackerID']
attackReasonID = self.dataLog['attackReasonID']
if attackerID in self.dictVehicle:
if (attackReasonID in self.dictVehicle[attackerID]) and ((BigWorld.serverTime() - self.dictVehicle[attackerID][attackReasonID]['time']) < 1.0):
key = self.dictVehicle[attackerID][attackReasonID]
key['time'] = BigWorld.serverTime()
key['damage'] += self.dataLog['damage']
key['criticalHit'] = (key['criticalHit'] or self.dataLog['criticalHit'])
if key['damage'] > 0:
self.dataLog['hitEffect'] = 'armor_pierced'
self.dataLog['criticalHit'] = key['criticalHit']
self.dataLog['damage'] = key['damage']
self.dataLog['dmgRatio'] = self.dataLog['damage'] * 100 // self.dataLog['maxHealth']
self.dataLog['number'] = len(self.listLog) - key['numberLine']
self.dataLog['fireDuration'] = BigWorld.time() - key['startAction'] if (attackReasonID == 1) and (key['startAction'] is not None) else None
self.dataLog['hitTime'] = key['hitTime']
self.setOutParameters(key['numberLine'])
else:
if attackReasonID in self.dictVehicle[attackerID]:
del self.dictVehicle[attackerID][attackReasonID]
self.addLine(attackerID, attackReasonID)
else:
self.dictVehicle[attackerID] = {}
self.addLine(attackerID, attackReasonID)
else:
self.dataLog = data.data
self.addLine()
if self.callEvent:
as_event('ON_HIT')
def showCarpetBombing(self, equipmentID, pos, dir, time):
if _ENABLE_DEBUG_LOG:
LOG_DEBUG('===== showCarpetBombing =====')
LOG_DEBUG(equipmentID)
LOG_DEBUG(pos, dir, time)
bombEquipment = vehicles.g_cache.equipments()[equipmentID]
shellDescr = items.vehicles.getDictDescr(bombEquipment.shellCompactDescr)
shotEffect = vehicles.g_cache.shotEffects[shellDescr['effectsIndex']]
airstrikeID = shotEffect.get('airstrikeID')
if airstrikeID is None:
LOG_ERROR('EquipmentID %s has no airstrike shot effect settings' % equipmentID)
return
else:
areaWidth, areaLength = bombEquipment.areaWidth, bombEquipment.areaLength
if _ENABLE_DEBUG_LOG:
LOG_DEBUG('Ideal', areaWidth, areaLength)
beginExplosionPos = BigWorld.wg_collideSegment(BigWorld.player().spaceID, pos, pos + dir * 1000.0, 18)
if beginExplosionPos is None:
return
beginExplosionPos = beginExplosionPos[0]
flatDir = Vector3(dir)
flatDir.y = 0.0
flatDir.normalise()
endDropPoint = pos + flatDir * (areaLength * bombEquipment.waveFraction)
endExplosionPos = BigWorld.wg_collideSegment(BigWorld.player().spaceID, endDropPoint, endDropPoint + dir * 1000.0, 18)
if endExplosionPos is None:
endExplosionPos = beginExplosionPos + flatDir * (areaLength * bombEquipment.waveFraction)
else:
endExplosionPos = endExplosionPos[0]
areaLength = beginExplosionPos.flatDistTo(endExplosionPos)
averageBombCount = bombEquipment.bombsNumber
bombsPerWidth, bombsPerLength = CombatEquipmentManager.__calcBombsDistribution(averageBombCount, areaWidth, areaLength)
delay = time - BigWorld.serverTime()
explosionVelocity = flatDir * bombEquipment.speed
partialAirstrikeFunc = functools.partial(BigWorld.PyGroundEffectManager().playAirstrike, airstrikeID, beginExplosionPos, explosionVelocity, areaWidth, areaLength, math.ceil(bombsPerWidth), math.ceil(bombsPerLength))
if _ENABLE_DEBUG_LOG:
LOG_DEBUG('delta', delay)
LOG_DEBUG('pos, dir', pos, dir)
LOG_DEBUG('Params for artyStrike effect', airstrikeID, beginExplosionPos, flatDir, areaWidth, areaLength, bombsPerWidth, bombsPerLength)
if delay < 0.0:
partialAirstrikeFunc()
else:
self.__callbackDelayer.delayCallback(delay, partialAirstrikeFunc)
if _ENABLE_DEBUG_DRAW:
self.debugStartLine = Flock.DebugLine(pos, beginExplosionPos)
self.debugEndLine = Flock.DebugLine(endDropPoint, endExplosionPos)
self.__callbackDelayer.delayCallback(delay, functools.partial(_DebugFrontLine.launch, beginExplosionPos, endExplosionPos, areaWidth, explosionVelocity))
return
def action(self, repairPointIndex, action, nextActionTime):
if self.__ui is None:
return
else:
timeLeft = max(0, nextActionTime - BigWorld.serverTime())
if action in (REPAIR_POINT_ACTION.START_REPAIR, REPAIR_POINT_ACTION.RESTART_REPAIR):
self.__ui.showTimer(timeLeft, _REPAIR_STATE.PROGRESS, INGAME_GUI.REPAIRPOINT_TITLE, None)
elif action == REPAIR_POINT_ACTION.COMPLETE_REPAIR:
self.__ui.showTimer(timeLeft, _REPAIR_STATE.COOLDOWN, INGAME_GUI.REPAIRPOINT_TITLE, INGAME_GUI.REPAIRPOINT_UNAVAILABLE)
BigWorld.player().soundNotifications.play(self.__repairSndName)
elif action == REPAIR_POINT_ACTION.ENTER_WHILE_CD:
self.__ui.showTimer(timeLeft, _REPAIR_STATE.COOLDOWN, INGAME_GUI.REPAIRPOINT_TITLE, INGAME_GUI.REPAIRPOINT_UNAVAILABLE)
elif action in (REPAIR_POINT_ACTION.LEAVE_WHILE_CD, REPAIR_POINT_ACTION.CANCEL_REPAIR, REPAIR_POINT_ACTION.BECOME_DISABLED):
self.__ui.hideTimer()
self.onRepairPointStateChanged(repairPointIndex, action, timeLeft)
return
def __generateMissionFromData(self):
mission = PlayerMission()
additionalDescription = None
hqActive = self.__activeMissionData['hqActive']
isInHQSector = self.__activeMissionData['isInHQSector']
sectorGroup = self.__activeMissionData['sectorGroup']
nonCapturedBases = self.__activeMissionData['bases']
endTime = self.__activeMissionData['endTime']
vehicle = BigWorld.entities.get(BigWorld.player().playerVehicleID)
vehicleIsAlive = vehicle is not None and vehicle.isStarted and vehicle.isAlive(
)
if vehicleIsAlive and not self.__isAttacker(
) and endTime - BigWorld.serverTime() > 0 and self.__isInRetreatArea(
) and self.__retreatMissionResults.get(sectorGroup, None) is None:
mission.missionType = EPIC_CONSTS.PRIMARY_WAYPOINT_MISSION
mission.missionText = EPIC_BATTLE.RETREAT_MISSION_TXT
mission.subText = EPIC_BATTLE.MISSION_ZONE_CLOSING_DEF
elif isInHQSector and hqActive or nonCapturedBases == 0:
componentSystem = self.__sessionProvider.arenaVisitor.getComponentSystem(
)
destructibleEntityComp = getattr(componentSystem,
'destructibleEntityComponent',
None)
if destructibleEntityComp is None:
LOG_ERROR('Expected DestructibleEntityComponent not present!')
return
mission.missionType = EPIC_CONSTS.PRIMARY_HQ_MISSION
destroyed = destructibleEntityComp.getNumDestroyedEntities()
toDestroy = self.__numDestructiblesToDestroy
if endTime > 0 and not hqActive:
mission.subText = EPIC_BATTLE.MISSION_ZONE_CLOSING_ATK if self.__isAttacker(
) else EPIC_BATTLE.MISSION_ZONE_CLOSING_DEF
else:
mission.subText = EPIC_BATTLE.MISSIONS_PRIMARY_ATK_HQ_SUB_TITLE if self.__isAttacker(
) else EPIC_BATTLE.MISSIONS_PRIMARY_DEF_HQ_SUB_TITLE
additionalDescription = makeHtmlString(
path=
'html_templates:battle/epicBattle/additionalHqMissionInfo',
key='attacker' if self.__isAttacker() else 'defender',
ctx={
'destroyed': destroyed,
'toDestroy': toDestroy
})
mission.missionText = EPIC_BATTLE.MISSIONS_PRIMARY_ATK_HQ if self.__isAttacker(
) else EPIC_BATTLE.MISSIONS_PRIMARY_DEF_HQ
else:
if endTime > 0:
mission.subText = EPIC_BATTLE.MISSION_ZONE_CLOSING_ATK if self.__isAttacker(
) else EPIC_BATTLE.MISSION_ZONE_CLOSING_DEF
mission.missionType = EPIC_CONSTS.PRIMARY_BASE_MISSION
mission.missionText = EPIC_BATTLE.MISSIONS_PRIMARY_ATK_BASE if self.__isAttacker(
) else EPIC_BATTLE.MISSIONS_PRIMARY_DEF_BASE
componentSystem = self.__sessionProvider.arenaVisitor.getComponentSystem(
)
sectorBaseComp = getattr(componentSystem, 'sectorBaseComponent',
None)
if sectorBaseComp is not None:
mission.id = next(
iter(
sectorBaseComp.getNonCapturedSectorBaseIdsByLane(
self.__currentLane)), None)
else:
LOG_ERROR('Expected SectorBaseComponent not present!')
return (mission, additionalDescription)
def __calculateElapsedTime(self):
self.__timeLeft = self.finishTime - BigWorld.serverTime(
) if self.finishTime else 0.0
def onPlayerShoot(self, aimInfo):
self._playLastShotTime = BigWorld.serverTime()
def _calcActualTime(self):
return self.__radarReadinessTime - BigWorld.serverTime()
def __onVehicleUpgradeStarted(self, vehicleId):
if vehicleId in self.__activeEffectsTime:
endTime = self.__activeEffectsTime[vehicleId]
if endTime > BigWorld.serverTime():
self.__destroyEffect(vehicleId)
self.__activeEffectsTime[vehicleId] = endTime
def _setViewSnapshot(self, leftTime):
if self.__showCountdown:
leftTime = self.finishTime - BigWorld.serverTime()
self._viewObject.updateMarkerTimer(self._typeID, leftTime, False,
self.__statusID)
def canStart(self):
return self.__canStart and BigWorld.serverTime(
) >= self.__startTime and self.__model is not None
def __init__(self, descriptor, quantity, stage, timeRemaining, tag = None):
super(_ReplayItem, self).__init__(descriptor, quantity, stage, timeRemaining, tag)
self.__cooldownTime = BigWorld.serverTime() + timeRemaining
def __onArenaPeriodChange(self, period, endTime, *_):
if period == ARENA_PERIOD.PREBATTLE:
self.__addPrebattleWaypoints(endTime - BigWorld.serverTime())
elif period == ARENA_PERIOD.BATTLE:
self.__removePrebattleWaypoints()
def init():
if BigWorld.serverTime() < 0.0:
Timer.__timeMethod = BigWorld.time
else:
Timer.__timeMethod = BigWorld.serverTime
def _startTick(self):
if self._totalTime:
timeLeft = max(0, self._finishTime - BigWorld.serverTime())
if timeLeft:
self._setViewSnapshot(timeLeft)
self._timeInterval.restart()
def __getTimeLeft(self):
attackEndTime = self.__gasAttackMgr.startTime + self.__gasAttackMgr.settings.attackLength
return max(0, attackEndTime - BigWorld.serverTime())
def printPeriodTime():
arena = BigWorld.player().arena
print '%f / %f' % (arena.periodEndTime - BigWorld.serverTime(),
arena.periodLength)
def _getTime(self, nextTime):
return max(0, round(nextTime - BigWorld.serverTime()))
def update(self, quantity, stage, timeRemaining, totalTime):
super(_ReplayItem, self).update(quantity, stage, timeRemaining,
totalTime)
self.__cooldownTime = BigWorld.serverTime() + timeRemaining
def _calculate(self):
return self._endTime - BigWorld.serverTime()
def _startTick(self):
if self._totalTime > 0 and self._typeID not in _SECONDARY_TIMERS:
self._viewObject.as_setTimeInSecondsS(
self._typeID, self._totalTime,
BigWorld.serverTime() - self._startTime)
def getTimeRemaining(self):
return max(0, self.__cooldownTime - BigWorld.serverTime())
def __startCountdownTimer(self, sectorGroupId):
diffTime = math.ceil(self.__transitionEndTimes[sectorGroupId] -
BigWorld.serverTime())
if diffTime >= 0:
self.onTransitionTimerUpdated(sectorGroupId, diffTime)
self.delayCallback(1, self.__tick)
def _adjustedDelay(self):
timeOffset = BigWorld.serverTime() - self.launchTime
return self._equipment.delay - timeOffset
def _showMarker(self):
delay = self.strikeTime - BigWorld.serverTime()
equipmentsCtrl = self.sessionProvider.shared.equipments
if equipmentsCtrl and delay > 0:
equipmentsCtrl.showMarker(self._equipment, self.position,
self._direction, delay)
def getCurrentTimeSnapshot(self):
return BigWorld.serverTime() - self._startTime
def updateStateCaptureUndefined(self):
if self._progressUndefinedTime <= BigWorld.serverTime():
self._progress = PROGRESS.CAPTURE_FINAL
def setTimeParams(self, totalTime, finishTime):
if finishTime:
self._startTime = finishTime - totalTime
else:
self._startTime = BigWorld.serverTime()
def _startTick(self):
if self._totalTime > 0 and self._typeID != _TIMER_STATES.STUN:
self._panel.as_setTimeInSecondsS(
self._typeID, self._totalTime,
BigWorld.serverTime() - self._startTime)
def _tick(self):
timeLeft = self._finishTime - BigWorld.serverTime()
if timeLeft >= 0 and self._engineState != 'destroyed':
self._updateSnapshot(timeLeft)
def __onAvatarReady(self):
arena = self.sessionProvider.arenaVisitor.getArenaSubscription()
if arena.period == ARENA_PERIOD.PREBATTLE:
self.__addPrebattleWaypoints(arena.periodEndTime - BigWorld.serverTime())
g_playerEvents.onAvatarReady -= self.__onAvatarReady
def __invalidateMissionStatus(self, force=False):
self.__onBeforeMissionInvalidation()
componentSystem = self.__sessionProvider.arenaVisitor.getComponentSystem(
)
sectorBaseComp = getattr(componentSystem, 'sectorBaseComponent', None)
if sectorBaseComp is None:
LOG_ERROR('Expected SectorBaseComponent not present!')
return
else:
destructibleEntityComp = getattr(componentSystem,
'destructibleEntityComponent',
None)
if destructibleEntityComp is None:
LOG_ERROR('Expected DestructibleEntityComponent not present!')
return
sectorComp = getattr(componentSystem, 'sectorComponent', None)
if sectorComp is None:
LOG_ERROR('Expected SectorComponent not present!')
return
playerDataComp = getattr(componentSystem, 'playerDataComponent',
None)
if destructibleEntityComp is None:
LOG_ERROR('Expected PlayerDataComponent not present!')
return
laneID = self.__currentLane
nonCapturedBases = sectorBaseComp.getNumNonCapturedBasesByLane(
laneID)
baseID = next(
iter(
sectorBaseComp.getCapturedSectorBaseIdsByLane(laneID)
[-1:]), None)
sectorGroupID = sectorBaseComp.getSectorForSectorBase(
baseID).groupID if baseID else None
hqActive = False
destroyedHQs = 0
hqs = destructibleEntityComp.destructibleEntities
if hqs:
hqActive = first(hqs.values()).isActive
destroyedHQs = destructibleEntityComp.getNumDestroyedEntities()
if destroyedHQs >= self.__numDestructiblesToDestroy:
return
if nonCapturedBases == 0 and self.__isAttacker():
if hqActive:
endTime = 0
else:
criticalEndTimes = []
sector = sectorComp.getSectorById(
playerDataComp.hqSectorID)
if sector is not None:
hqIdInPlayerGroup = sector.IDInPlayerGroup
for sector in sectorComp.sectors:
if sector.state == SECTOR_STATE.TRANSITION and sector.IDInPlayerGroup == hqIdInPlayerGroup - 1:
criticalEndTimes.append(
sector.endOfTransitionPeriod)
endTime = min(criticalEndTimes) if criticalEndTimes else 0
else:
_, _, endTime = sectorComp.getActiveWaypointSectorGroupForPlayerGroup(
self.__currentLane)
if endTime - BigWorld.serverTime(
) > 0.5 and self.__currentEndTime != endTime:
self.__currentEndTime = endTime
self.onPlayerMissionTimerSet(self.__currentEndTime)
isInHQSector = playerDataComp.getPlayerInHQSector()
if self.__activeMissionData['lane'] == laneID and self.__activeMissionData[
'bases'] == nonCapturedBases and self.__activeMissionData[
'hqActive'] == hqActive and self.__activeMissionData[
'destroyedHQs'] == destroyedHQs and self.__activeMissionData[
'endTime'] == endTime and self.__activeMissionData[
'sectorGroup'] == sectorGroupID and self.__activeMissionData[
'isInHQSector'] == isInHQSector and not force:
return
self.__activeMissionData['lane'] = laneID
self.__activeMissionData['bases'] = nonCapturedBases
self.__activeMissionData['hqActive'] = hqActive
destroyedHQUpdate = self.__activeMissionData[
'destroyedHQs'] != destroyedHQs
self.__activeMissionData['destroyedHQs'] = destroyedHQs
self.__activeMissionData['endTime'] = endTime
self.__activeMissionData['sectorGroup'] = sectorGroupID
self.__activeMissionData['isInHQSector'] = isInHQSector
mission, additionalDescription = self.__generateMissionFromData()
if mission.missionType == EPIC_CONSTS.PRIMARY_HQ_MISSION and self.__currentMission.missionType == EPIC_CONSTS.PRIMARY_HQ_MISSION and not destroyedHQUpdate and not force:
return
if mission.missionType != EPIC_CONSTS.PRIMARY_EMPTY_MISSION:
self.__currentMission = mission
self.onPlayerMissionUpdated(mission, additionalDescription)
return
def _tick(self):
timeLeft = self._finishTime - BigWorld.serverTime()
if timeLeft >= 0:
self._setViewSnapshot(timeLeft)
else:
self.hide()
def __onCameraChanged(self, cameraName, currentVehicleId=None):
if cameraName == 'video':
self.__elapsedTime = max(self.endTime - BigWorld.serverTime(), 0.0)
self.__updateMarker(self.__elapsedTime)
